1 +import assert
from "node:assert";
3 +import { describe, it }
from "node:test";
8 + type ExtensionCommandContext,
10 +}
from "@earendil-works/pi-coding-agent";
12 +import registerTaskCommands, {
14 + createStartTaskCommand,
15 + createFinishTaskCommand,
16 + createAbortTaskCommand,
17 + createDiscardTaskCommand,
19 +}
from "../index.ts";
21 +const path: PathFn = (name, fn,
...children)
=> ({ name, fn, children });
24 +pathSuite(
"manual workflow", (path)
=> {
26 + path(
"push AAA",
async (h)
=> {
27 + h.
appendUserMessage(
"main work");
28 + h.
appendAssistantMessage(
"working...");
29 + await h.
runPushTask(
"Task AAA");
30 + assert.
strictEqual(h.
getStatus(),
"pending task: task-aaa");
31 + assert.
ok(
!h.
isLlmTriggered());
32 + h.
assertBranchHistory(
34 + assistant(
"working..."),
36 + notification(
"Task stored. Use `/start-task` or `/auto` to start it."),
39 + path(
"discard AAA",
async (h)
=> {
40 + await h.
runDiscardTask();
41 + assert.
strictEqual(h.
getStatus(),
undefined);
42 + assert.
ok(
!h.
isLlmTriggered());
43 + h.
assertBranchHistory(
45 + assistant(
"working..."),
47 + notification(
"Task discarded."),
50 + path(
"start AAA",
async (h)
=> {
51 + await h.
runStartTask();
52 + assert.
strictEqual(h.
getStatus(),
"current task: task-aaa");
53 + assert.
ok(h.
isLlmTriggered());
54 + h.
assertBranchHistory(
58 + path(
"finish AAA",
async (h)
=> {
59 + h.
appendAssistantMessage(
"Done.");
60 + await h.
runFinishTask();
61 + assert.
strictEqual(h.
getStatus(),
undefined);
62 + assert.
ok(h.
isLlmTriggered());
63 + h.
assertBranchHistory(
65 + assistant(
"working..."),
67 + taskResult(
"task-aaa",
"Done."),
68 + notification(
"Task finished. Last response attached."),
71 + path(
"start AAA [no task]",
async (h)
=> {
72 + await h.
runStartTask();
73 + assert.
strictEqual(h.
getStatus(),
undefined);
74 + assert.
ok(h.
isLlmTriggered());
75 + h.
assertBranchHistory(
77 + assistant(
"working..."),
79 + taskResult(
"task-aaa",
"Done."),
80 + notification(
"No pending task. Use push-task first."),
83 + path(
"discard AAA [no task]",
async (h)
=> {
84 + await h.
runDiscardTask();
85 + assert.
strictEqual(h.
getStatus(),
undefined);
86 + assert.
ok(h.
isLlmTriggered());
87 + h.
assertBranchHistory(
89 + assistant(
"working..."),
91 + taskResult(
"task-aaa",
"Done."),
92 + notification(
"No pending task to discard."),
95 + path(
"finish AAA [no task]",
async (h)
=> {
96 + await h.
runFinishTask();
97 + assert.
strictEqual(h.
getStatus(),
undefined);
98 + assert.
ok(h.
isLlmTriggered());
99 + h.
assertBranchHistory(
101 + assistant(
"working..."),
103 + taskResult(
"task-aaa",
"Done."),
104 + notification(
"Not inside task, nothing to finish."),
107 + path(
"abort AAA [no task]",
async (h)
=> {
108 + await h.
runAbortTask();
109 + assert.
strictEqual(h.
getStatus(),
undefined);
110 + assert.
ok(h.
isLlmTriggered());
111 + h.
assertBranchHistory(
113 + assistant(
"working..."),
115 + taskResult(
"task-aaa",
"Done."),
116 + notification(
"Not inside task, nothing to abort."),
120 + path(
"abort AAA",
async (h)
=> {
121 + h.
appendAssistantMessage(
"Partial...");
122 + await h.
runAbortTask();
123 + assert.
strictEqual(h.
getStatus(),
"pending task: task-aaa");
124 + assert.
ok(
!h.
isLlmTriggered());
125 + h.
assertBranchHistory(
127 + assistant(
"working..."),
129 + notification(
"Task aborted. Branch abandoned without summary."),
132 + path(
"start AAA",
async (h)
=> {
133 + await h.
runStartTask();
134 + assert.
strictEqual(h.
getStatus(),
"current task: task-aaa");
135 + assert.
ok(h.
isLlmTriggered());
136 + h.
assertBranchHistory(
140 + path(
"finish AAA",
async (h)
=> {
141 + h.
appendAssistantMessage(
"Done.");
142 + await h.
runFinishTask();
143 + assert.
strictEqual(h.
getStatus(),
undefined);
144 + assert.
ok(h.
isLlmTriggered());
145 + h.
assertBranchHistory(
147 + assistant(
"working..."),
149 + taskResult(
"task-aaa",
"Done."),
150 + notification(
"Task finished. Last response attached."),
155 + path(
"push BBB",
async (h)
=> {
156 + h.
appendAssistantMessage(
"some more work");
157 + await h.
runPushTask(
"Task BBB");
158 + assert.
strictEqual(h.
getStatus(),
"pending task: task-bbb");
159 + assert.
ok(
!h.
isLlmTriggered());
160 + h.
assertBranchHistory(
162 + assistant(
"some more work"),
164 + notification(
"Task stored. Use `/start-task` or `/auto` to start it."),
167 + path(
"discard BBB",
async (h)
=> {
168 + await h.
runDiscardTask();
169 + assert.
strictEqual(h.
getStatus(),
"current task: task-aaa");
170 + assert.
ok(
!h.
isLlmTriggered());
171 + h.
assertBranchHistory(
173 + assistant(
"some more work"),
175 + notification(
"Task discarded."),
178 + path(
"finish AAA",
async (h)
=> {
179 + h.
appendAssistantMessage(
"Done.");
180 + await h.
runFinishTask();
181 + assert.
strictEqual(h.
getStatus(),
undefined);
182 + assert.
ok(h.
isLlmTriggered());
183 + h.
assertBranchHistory(
185 + assistant(
"working..."),
187 + taskResult(
"task-aaa",
"Done."),
188 + notification(
"Task finished. Last response attached."),
192 + path(
"start BBB",
async (h)
=> {
193 + await h.
runStartTask();
194 + assert.
strictEqual(h.
getStatus(),
"current task: task-bbb");
195 + assert.
ok(h.
isLlmTriggered());
196 + h.
assertBranchHistory(
200 + path(
"finish BBB",
async (h)
=> {
201 + h.
appendAssistantMessage(
"inner done");
202 + await h.
runFinishTask();
203 + assert.
strictEqual(h.
getStatus(),
"current task: task-aaa");
204 + assert.
ok(h.
isLlmTriggered());
205 + h.
assertBranchHistory(
207 + assistant(
"some more work"),
209 + taskResult(
"task-bbb",
"inner done"),
210 + notification(
"Task finished. Last response attached."),
213 + path(
"finish AAA",
async (h)
=> {
214 + h.
appendAssistantMessage(
"Done.");
215 + await h.
runFinishTask();
216 + assert.
strictEqual(h.
getStatus(),
undefined);
217 + assert.
ok(h.
isLlmTriggered());
218 + h.
assertBranchHistory(
220 + assistant(
"working..."),
222 + taskResult(
"task-aaa",
"Done."),
223 + notification(
"Task finished. Last response attached."),
227 + path(
"abort BBB",
async (h)
=> {
228 + h.
appendAssistantMessage(
"partial inner");
229 + await h.
runAbortTask();
230 + assert.
strictEqual(h.
getStatus(),
"pending task: task-bbb");
231 + assert.
ok(
!h.
isLlmTriggered());
232 + h.
assertBranchHistory(
234 + assistant(
"some more work"),
236 + notification(
"Task aborted. Branch abandoned without summary."),
239 + path(
"finish AAA",
async (h)
=> {
240 + h.
appendAssistantMessage(
"Done.");
241 + await h.
runFinishTask();
242 + assert.
strictEqual(h.
getStatus(),
undefined);
243 + assert.
ok(h.
isLlmTriggered());
244 + h.
assertBranchHistory(
246 + assistant(
"working..."),
248 + taskResult(
"task-aaa",
"Done."),
249 + notification(
"Task finished. Last response attached."),
255 + path(
"push BBB [inherit]",
async (h)
=> {
256 + h.
appendAssistantMessage(
"some more work");
257 + await h.
runPushTask(
"Task BBB",
true);
258 + assert.
strictEqual(h.
getStatus(),
"pending task: task-bbb");
259 + assert.
ok(
!h.
isLlmTriggered());
260 + h.
assertBranchHistory(
262 + assistant(
"some more work"),
263 + task(
"Task BBB",
true),
264 + notification(
"Task stored. Use `/start-task` or `/auto` to start it."),
267 + path(
"discard BBB [inherit]",
async (h)
=> {
268 + await h.
runDiscardTask();
269 + assert.
strictEqual(h.
getStatus(),
"current task: task-aaa");
270 + assert.
ok(
!h.
isLlmTriggered());
271 + h.
assertBranchHistory(
273 + assistant(
"some more work"),
274 + task(
"Task BBB",
true),
275 + notification(
"Task discarded."),
278 + path(
"finish AAA",
async (h)
=> {
279 + h.
appendAssistantMessage(
"Done.");
280 + await h.
runFinishTask();
281 + assert.
strictEqual(h.
getStatus(),
undefined);
282 + assert.
ok(h.
isLlmTriggered());
283 + h.
assertBranchHistory(
285 + assistant(
"working..."),
287 + taskResult(
"task-aaa",
"Done."),
288 + notification(
"Task finished. Last response attached."),
292 + path(
"start BBB [inherit]",
async (h)
=> {
293 + await h.
runStartTask();
294 + assert.
strictEqual(h.
getStatus(),
"current task: task-bbb");
295 + assert.
ok(h.
isLlmTriggered());
296 + h.
assertBranchHistory(
298 + assistant(
"some more work"),
299 + task(
"Task BBB",
true),
303 + path(
"finish BBB [inherit]",
async (h)
=> {
304 + h.
appendAssistantMessage(
"inner done");
305 + await h.
runFinishTask();
306 + assert.
strictEqual(h.
getStatus(),
"current task: task-aaa");
307 + assert.
ok(h.
isLlmTriggered());
308 + h.
assertBranchHistory(
310 + assistant(
"some more work"),
311 + task(
"Task BBB",
true),
312 + taskResult(
"task-bbb",
"inner done"),
313 + notification(
"Task finished. Last response attached."),
316 + path(
"finish AAA",
async (h)
=> {
317 + h.
appendAssistantMessage(
"Done.");
318 + await h.
runFinishTask();
319 + assert.
strictEqual(h.
getStatus(),
undefined);
320 + assert.
ok(h.
isLlmTriggered());
321 + h.
assertBranchHistory(
323 + assistant(
"working..."),
325 + taskResult(
"task-aaa",
"Done."),
326 + notification(
"Task finished. Last response attached."),
330 + path(
"abort BBB [inherit]",
async (h)
=> {
331 + h.
appendAssistantMessage(
"partial inner");
332 + await h.
runAbortTask();
333 + assert.
strictEqual(h.
getStatus(),
"pending task: task-bbb");
334 + assert.
ok(
!h.
isLlmTriggered());
335 + h.
assertBranchHistory(
337 + assistant(
"some more work"),
338 + task(
"Task BBB",
true),
339 + notification(
"Task aborted. Branch abandoned without summary."),
342 + path(
"finish AAA",
async (h)
=> {
343 + h.
appendAssistantMessage(
"Done.");
344 + await h.
runFinishTask();
345 + assert.
strictEqual(h.
getStatus(),
undefined);
346 + assert.
ok(h.
isLlmTriggered());
347 + h.
assertBranchHistory(
349 + assistant(
"working..."),
351 + taskResult(
"task-aaa",
"Done."),
352 + notification(
"Task finished. Last response attached."),
360 + path(
"push AAA [inherit]",
async (h)
=> {
361 + h.
appendUserMessage(
"main work");
362 + h.
appendAssistantMessage(
"working...");
363 + await h.
runPushTask(
"Task AAA",
true);
364 + assert.
strictEqual(h.
getStatus(),
"pending task: task-aaa");
365 + assert.
ok(
!h.
isLlmTriggered());
366 + h.
assertBranchHistory(
368 + assistant(
"working..."),
369 + task(
"Task AAA",
true),
370 + notification(
"Task stored. Use `/start-task` or `/auto` to start it."),
373 + path(
"discard AAA",
async (h)
=> {
374 + await h.
runDiscardTask();
375 + assert.
strictEqual(h.
getStatus(),
undefined);
376 + assert.
ok(
!h.
isLlmTriggered());
377 + h.
assertBranchHistory(
379 + assistant(
"working..."),
380 + task(
"Task AAA",
true),
381 + notification(
"Task discarded."),
384 + path(
"start AAA",
async (h)
=> {
385 + await h.
runStartTask();
386 + assert.
strictEqual(h.
getStatus(),
"current task: task-aaa");
387 + assert.
ok(h.
isLlmTriggered());
388 + h.
assertBranchHistory(
390 + assistant(
"working..."),
391 + task(
"Task AAA",
true),
395 + path(
"finish AAA",
async (h)
=> {
396 + h.
appendAssistantMessage(
"Done.");
397 + await h.
runFinishTask();
398 + assert.
strictEqual(h.
getStatus(),
undefined);
399 + assert.
ok(h.
isLlmTriggered());
400 + h.
assertBranchHistory(
402 + assistant(
"working..."),
403 + task(
"Task AAA",
true),
404 + taskResult(
"task-aaa",
"Done."),
405 + notification(
"Task finished. Last response attached."),
408 + path(
"start AAA [no task]",
async (h)
=> {
409 + await h.
runStartTask();
410 + assert.
strictEqual(h.
getStatus(),
undefined);
411 + assert.
ok(h.
isLlmTriggered());
412 + h.
assertBranchHistory(
414 + assistant(
"working..."),
415 + task(
"Task AAA",
true),
416 + taskResult(
"task-aaa",
"Done."),
417 + notification(
"No pending task. Use push-task first."),
420 + path(
"discard AAA [no task]",
async (h)
=> {
421 + await h.
runDiscardTask();
422 + assert.
strictEqual(h.
getStatus(),
undefined);
423 + assert.
ok(h.
isLlmTriggered());
424 + h.
assertBranchHistory(
426 + assistant(
"working..."),
427 + task(
"Task AAA",
true),
428 + taskResult(
"task-aaa",
"Done."),
429 + notification(
"No pending task to discard."),
432 + path(
"finish AAA [no task]",
async (h)
=> {
433 + await h.
runFinishTask();
434 + assert.
strictEqual(h.
getStatus(),
undefined);
435 + assert.
ok(h.
isLlmTriggered());
436 + h.
assertBranchHistory(
438 + assistant(
"working..."),
439 + task(
"Task AAA",
true),
440 + taskResult(
"task-aaa",
"Done."),
441 + notification(
"Not inside task, nothing to finish."),
444 + path(
"abort AAA [no task]",
async (h)
=> {
445 + await h.
runAbortTask();
446 + assert.
strictEqual(h.
getStatus(),
undefined);
447 + assert.
ok(h.
isLlmTriggered());
448 + h.
assertBranchHistory(
450 + assistant(
"working..."),
451 + task(
"Task AAA",
true),
452 + taskResult(
"task-aaa",
"Done."),
453 + notification(
"Not inside task, nothing to abort."),
457 + path(
"abort AAA",
async (h)
=> {
458 + h.
appendAssistantMessage(
"Partial...");
459 + await h.
runAbortTask();
460 + assert.
strictEqual(h.
getStatus(),
"pending task: task-aaa");
461 + assert.
ok(
!h.
isLlmTriggered());
462 + h.
assertBranchHistory(
464 + assistant(
"working..."),
465 + task(
"Task AAA",
true),
466 + notification(
"Task aborted. Branch abandoned without summary."),
469 + path(
"start AAA",
async (h)
=> {
470 + await h.
runStartTask();
471 + assert.
strictEqual(h.
getStatus(),
"current task: task-aaa");
472 + assert.
ok(h.
isLlmTriggered());
473 + h.
assertBranchHistory(
475 + assistant(
"working..."),
476 + task(
"Task AAA",
true),
480 + path(
"finish AAA",
async (h)
=> {
481 + h.
appendAssistantMessage(
"Done.");
482 + await h.
runFinishTask();
483 + assert.
strictEqual(h.
getStatus(),
undefined);
484 + assert.
ok(h.
isLlmTriggered());
485 + h.
assertBranchHistory(
487 + assistant(
"working..."),
488 + task(
"Task AAA",
true),
489 + taskResult(
"task-aaa",
"Done."),
490 + notification(
"Task finished. Last response attached."),
495 + path(
"push BBB",
async (h)
=> {
496 + h.
appendAssistantMessage(
"some more work");
497 + await h.
runPushTask(
"Task BBB");
498 + assert.
strictEqual(h.
getStatus(),
"pending task: task-bbb");
499 + assert.
ok(
!h.
isLlmTriggered());
500 + h.
assertBranchHistory(
502 + assistant(
"working..."),
503 + task(
"Task AAA",
true),
505 + assistant(
"some more work"),
507 + notification(
"Task stored. Use `/start-task` or `/auto` to start it."),
510 + path(
"discard BBB",
async (h)
=> {
511 + await h.
runDiscardTask();
512 + assert.
strictEqual(h.
getStatus(),
"current task: task-aaa");
513 + assert.
ok(
!h.
isLlmTriggered());
514 + h.
assertBranchHistory(
516 + assistant(
"working..."),
517 + task(
"Task AAA",
true),
519 + assistant(
"some more work"),
521 + notification(
"Task discarded."),
524 + path(
"finish AAA",
async (h)
=> {
525 + h.
appendAssistantMessage(
"Done.");
526 + await h.
runFinishTask();
527 + assert.
strictEqual(h.
getStatus(),
undefined);
528 + assert.
ok(h.
isLlmTriggered());
529 + h.
assertBranchHistory(
531 + assistant(
"working..."),
532 + task(
"Task AAA",
true),
533 + taskResult(
"task-aaa",
"Done."),
534 + notification(
"Task finished. Last response attached."),
538 + path(
"start BBB",
async (h)
=> {
539 + await h.
runStartTask();
540 + assert.
strictEqual(h.
getStatus(),
"current task: task-bbb");
541 + assert.
ok(h.
isLlmTriggered());
542 + h.
assertBranchHistory(
546 + path(
"finish BBB",
async (h)
=> {
547 + h.
appendAssistantMessage(
"inner done");
548 + await h.
runFinishTask();
549 + assert.
strictEqual(h.
getStatus(),
"current task: task-aaa");
550 + assert.
ok(h.
isLlmTriggered());
551 + h.
assertBranchHistory(
553 + assistant(
"working..."),
554 + task(
"Task AAA",
true),
556 + assistant(
"some more work"),
558 + taskResult(
"task-bbb",
"inner done"),
559 + notification(
"Task finished. Last response attached."),
562 + path(
"finish AAA",
async (h)
=> {
563 + h.
appendAssistantMessage(
"Done.");
564 + await h.
runFinishTask();
565 + assert.
strictEqual(h.
getStatus(),
undefined);
566 + assert.
ok(h.
isLlmTriggered());
567 + h.
assertBranchHistory(
569 + assistant(
"working..."),
570 + task(
"Task AAA",
true),
571 + taskResult(
"task-aaa",
"Done."),
572 + notification(
"Task finished. Last response attached."),
576 + path(
"abort BBB",
async (h)
=> {
577 + h.
appendAssistantMessage(
"partial inner");
578 + await h.
runAbortTask();
579 + assert.
strictEqual(h.
getStatus(),
"pending task: task-bbb");
580 + assert.
ok(
!h.
isLlmTriggered());
581 + h.
assertBranchHistory(
583 + assistant(
"working..."),
584 + task(
"Task AAA",
true),
586 + assistant(
"some more work"),
588 + notification(
"Task aborted. Branch abandoned without summary."),
591 + path(
"finish AAA",
async (h)
=> {
592 + h.
appendAssistantMessage(
"Done.");
593 + await h.
runFinishTask();
594 + assert.
strictEqual(h.
getStatus(),
undefined);
595 + assert.
ok(h.
isLlmTriggered());
596 + h.
assertBranchHistory(
598 + assistant(
"working..."),
599 + task(
"Task AAA",
true),
600 + taskResult(
"task-aaa",
"Done."),
601 + notification(
"Task finished. Last response attached."),
607 + path(
"push BBB [inherit]",
async (h)
=> {
608 + h.
appendAssistantMessage(
"some more work");
609 + await h.
runPushTask(
"Task BBB",
true);
610 + assert.
strictEqual(h.
getStatus(),
"pending task: task-bbb");
611 + assert.
ok(
!h.
isLlmTriggered());
612 + h.
assertBranchHistory(
614 + assistant(
"working..."),
615 + task(
"Task AAA",
true),
617 + assistant(
"some more work"),
618 + task(
"Task BBB",
true),
619 + notification(
"Task stored. Use `/start-task` or `/auto` to start it."),
622 + path(
"discard BBB [inherit]",
async (h)
=> {
623 + await h.
runDiscardTask();
624 + assert.
strictEqual(h.
getStatus(),
"current task: task-aaa");
625 + assert.
ok(
!h.
isLlmTriggered());
626 + h.
assertBranchHistory(
628 + assistant(
"working..."),
629 + task(
"Task AAA",
true),
631 + assistant(
"some more work"),
632 + task(
"Task BBB",
true),
633 + notification(
"Task discarded."),
636 + path(
"finish AAA",
async (h)
=> {
637 + h.
appendAssistantMessage(
"Done.");
638 + await h.
runFinishTask();
639 + assert.
strictEqual(h.
getStatus(),
undefined);
640 + assert.
ok(h.
isLlmTriggered());
641 + h.
assertBranchHistory(
643 + assistant(
"working..."),
644 + task(
"Task AAA",
true),
645 + taskResult(
"task-aaa",
"Done."),
646 + notification(
"Task finished. Last response attached."),
650 + path(
"start BBB [inherit]",
async (h)
=> {
651 + await h.
runStartTask();
652 + assert.
strictEqual(h.
getStatus(),
"current task: task-bbb");
653 + assert.
ok(h.
isLlmTriggered());
654 + h.
assertBranchHistory(
656 + assistant(
"working..."),
657 + task(
"Task AAA",
true),
659 + assistant(
"some more work"),
660 + task(
"Task BBB",
true),
664 + path(
"finish BBB [inherit]",
async (h)
=> {
665 + h.
appendAssistantMessage(
"inner done");
666 + await h.
runFinishTask();
667 + assert.
strictEqual(h.
getStatus(),
"current task: task-aaa");
668 + assert.
ok(h.
isLlmTriggered());
669 + h.
assertBranchHistory(
671 + assistant(
"working..."),
672 + task(
"Task AAA",
true),
674 + assistant(
"some more work"),
675 + task(
"Task BBB",
true),
676 + taskResult(
"task-bbb",
"inner done"),
677 + notification(
"Task finished. Last response attached."),
680 + path(
"finish AAA",
async (h)
=> {
681 + h.
appendAssistantMessage(
"Done.");
682 + await h.
runFinishTask();
683 + assert.
strictEqual(h.
getStatus(),
undefined);
684 + assert.
ok(h.
isLlmTriggered());
685 + h.
assertBranchHistory(
687 + assistant(
"working..."),
688 + task(
"Task AAA",
true),
689 + taskResult(
"task-aaa",
"Done."),
690 + notification(
"Task finished. Last response attached."),
694 + path(
"abort BBB [inherit]",
async (h)
=> {
695 + h.
appendAssistantMessage(
"partial inner");
696 + await h.
runAbortTask();
697 + assert.
strictEqual(h.
getStatus(),
"pending task: task-bbb");
698 + assert.
ok(
!h.
isLlmTriggered());
699 + h.
assertBranchHistory(
701 + assistant(
"working..."),
702 + task(
"Task AAA",
true),
704 + assistant(
"some more work"),
705 + task(
"Task BBB",
true),
706 + notification(
"Task aborted. Branch abandoned without summary."),
709 + path(
"finish AAA",
async (h)
=> {
710 + h.
appendAssistantMessage(
"Done.");
711 + await h.
runFinishTask();
712 + assert.
strictEqual(h.
getStatus(),
undefined);
713 + assert.
ok(h.
isLlmTriggered());
714 + h.
assertBranchHistory(
716 + assistant(
"working..."),
717 + task(
"Task AAA",
true),
718 + taskResult(
"task-aaa",
"Done."),
719 + notification(
"Task finished. Last response attached."),
727 + path(
"start AAA [no task]",
async (h)
=> {
728 + h.
appendUserMessage(
"main work");
729 + h.
appendAssistantMessage(
"working...");
730 + await h.
runStartTask();
731 + assert.
strictEqual(h.
getStatus(),
undefined);
732 + assert.
ok(
!h.
isLlmTriggered());
733 + h.
assertBranchHistory(
735 + assistant(
"working..."),
736 + notification(
"No pending task. Use push-task first."),
739 + path(
"discard AAA [no task]",
async (h)
=> {
740 + h.
appendUserMessage(
"main work");
741 + h.
appendAssistantMessage(
"working...");
742 + await h.
runDiscardTask();
743 + assert.
strictEqual(h.
getStatus(),
undefined);
744 + assert.
ok(
!h.
isLlmTriggered());
745 + h.
assertBranchHistory(
747 + assistant(
"working..."),
748 + notification(
"No pending task to discard."),
751 + path(
"finish AAA [no task]",
async (h)
=> {
752 + h.
appendUserMessage(
"main work");
753 + h.
appendAssistantMessage(
"working...");
754 + await h.
runFinishTask();
755 + assert.
strictEqual(h.
getStatus(),
undefined);
756 + assert.
ok(
!h.
isLlmTriggered());
757 + h.
assertBranchHistory(
759 + assistant(
"working..."),
760 + notification(
"Not inside task, nothing to finish."),
763 + path(
"abort AAA [no task]",
async (h)
=> {
764 + h.
appendUserMessage(
"main work");
765 + h.
appendAssistantMessage(
"working...");
766 + await h.
runAbortTask();
767 + assert.
strictEqual(h.
getStatus(),
undefined);
768 + assert.
ok(
!h.
isLlmTriggered());
769 + h.
assertBranchHistory(
771 + assistant(
"working..."),
772 + notification(
"Not inside task, nothing to abort."),
778 +describe(
"automated workflow", ()
=> {
779 + it(
"completes push-task -> /auto -> finish-task and injects the branch result",
async ()
=> {
780 + const { appendUserMessage, appendAssistantMessage, assertBranchHistory, isLlmTriggered, getStatus, releaseNextIdle, flushMicrotasks, runPushTask, runAuto }
= 783 + appendUserMessage(
"main work");
784 + appendAssistantMessage(
"working on main...");
785 + await runPushTask(
"Analyze performance.");
786 + assert.
strictEqual(
getStatus(),
"pending task: analyze-performance");
787 + assertBranchHistory(
789 + assistant(
"working on main..."),
790 + task(
"Analyze performance."),
791 + notification(
"Task stored. Use `/start-task` or `/auto` to start it."),
794 + const running
= runAuto();
796 + await flushMicrotasks();
797 + await releaseNextIdle();
799 + assertBranchHistory(
800 + user(
"Analyze performance."),
803 + appendAssistantMessage(
"Found 3 bottlenecks: ...");
805 + await releaseNextIdle();
806 + await releaseNextIdle();
808 + assertBranchHistory(
810 + assistant(
"working on main..."),
811 + task(
"Analyze performance."),
812 + taskResult(
"analyze-performance",
"Found 3 bottlenecks: ..."),
813 + notification(
"Task finished. Last response attached."),
815 + assert.
ok(
isLlmTriggered());
818 + it(
"returns the branch result to the original leaf for branch-context tasks",
async ()
=> {
819 + const { appendUserMessage, appendAssistantMessage, assertBranchHistory, isLlmTriggered, getStatus, releaseNextIdle, flushMicrotasks, runPushTask, runAuto }
= 822 + appendUserMessage(
"main work");
823 + appendAssistantMessage(
"working...");
824 + await runPushTask(
"Quick fix.",
true);
825 + assert.
strictEqual(
getStatus(),
"pending task: quick-fix");
826 + assertBranchHistory(
828 + assistant(
"working..."),
829 + task(
"Quick fix.",
true),
830 + notification(
"Task stored. Use `/start-task` or `/auto` to start it."),
833 + const running
= runAuto();
835 + await flushMicrotasks();
836 + await releaseNextIdle();
838 + assertBranchHistory(
840 + assistant(
"working..."),
841 + task(
"Quick fix.",
true),
842 + user(
"Quick fix."),
845 + appendAssistantMessage(
"Fixed the bug.");
847 + await releaseNextIdle();
848 + await releaseNextIdle();
850 + assertBranchHistory(
852 + assistant(
"working..."),
853 + task(
"Quick fix.",
true),
854 + taskResult(
"quick-fix",
"Fixed the bug."),
855 + notification(
"Task finished. Last response attached."),
857 + assert.
ok(
isLlmTriggered());
860 + it(
"stops when navigation is cancelled and does not mark the task done",
async ()
=> {
861 + const { appendUserMessage, assertBranchHistory, isLlmTriggered, setCancelNextNav, releaseNextIdle, flushMicrotasks, runPushTask, runAuto }
= 864 + appendUserMessage(
"main work");
865 + await runPushTask(
"Analyze performance.");
867 + setCancelNextNav(
true);
869 + const running
= runAuto();
871 + await flushMicrotasks();
872 + await releaseNextIdle();
874 + assert.
ok(
!isLlmTriggered());
876 + assertBranchHistory(
878 + task(
"Analyze performance."),
879 + notification(
"Task stored. Use `/start-task` or `/auto` to start it."),
883 + it(
"notifies and exits when started with no pending tasks",
async ()
=> {
884 + const { assertBranchHistory, releaseNextIdle, flushMicrotasks, runAuto }
= 887 + const running
= runAuto();
889 + await flushMicrotasks();
890 + await releaseNextIdle();
893 + assertBranchHistory(
894 + notification(
"No pending tasks to run."),
898 + it(
"warns and returns when /auto is already running",
async ()
=> {
899 + const { assertBranchHistory, releaseNextIdle, flushMicrotasks, emitSessionShutdown, runAuto }
= 902 + const firstRun
= runAuto();
903 + await flushMicrotasks();
906 + assertBranchHistory(
notification(
"Auto is already running."));
908 + await emitSessionShutdown();
909 + await releaseNextIdle();
913 + it(
"stops when the last assistant message was aborted",
async ()
=> {
914 + const { appendUserMessage, appendAssistantMessage, isLlmTriggered, releaseNextIdle, flushMicrotasks, runPushTask, runStartTask, runAuto }
= 917 + appendUserMessage(
"start");
918 + await runPushTask(
"Implement phase 1.",
true);
920 + await runStartTask();
922 + appendAssistantMessage(
"Stopped by user.",
"aborted");
924 + const running
= runAuto();
926 + await flushMicrotasks();
927 + await releaseNextIdle();
929 + assert.
ok(
!isLlmTriggered());
932 + it(
"keeps waiting while follow-up work is pending after finishTask",
async ()
=> {
933 + const { appendUserMessage, appendAssistantMessage, isLlmTriggered, setPendingMessages, releaseNextIdle, flushMicrotasks, runPushTask, runStartTask, runAuto }
= 936 + appendUserMessage(
"start");
937 + await runPushTask(
"Quick fix.",
true);
939 + await runStartTask();
941 + appendAssistantMessage(
"Fixed the bug.");
943 + let resolved
= false;
944 + const running
= runAuto().
then(()
=> {
948 + await flushMicrotasks();
949 + setPendingMessages(
true);
950 + await releaseNextIdle();
951 + await releaseNextIdle();
952 + assert.
ok(
isLlmTriggered());
953 + assert.
strictEqual(resolved,
false);
955 + setPendingMessages(
false);
956 + await releaseNextIdle();
958 + assert.
strictEqual(resolved,
true);
964 +describe(
"registration", ()
=> {
965 + it(
"registers the push-task tool and all five task commands", ()
=> {
966 + const registered
: Array<{ type
: string; name
: string; description
?: string }>
= [];
968 + registerTool: (tool
: { name
: string; label
: string; description
: string })
=> 969 + registered.
push({ type:
"tool", name: tool.
name, description: tool.
description }),
970 + registerCommand: (name
: string, opts
: { description
: string })
=> 971 + registered.
push({ type:
"command", name, description: opts.
description }),
972 + registerMessageRenderer: ()
=> {},
974 + }
as unknown as ExtensionAPI;
976 + registerTaskCommands(pi);
978 + assert.
deepStrictEqual(registered, [
979 + { type:
"tool", name:
"push-task", description:
"Store a task prompt for a user-started navigation branch." },
980 + { type:
"command", name:
"start-task", description:
"Navigate to a fresh context and inject the active task prompt" },
981 + { type:
"command", name:
"discard-task", description:
"Discard the active task without executing it" },
982 + { type:
"command", name:
"finish-task", description:
"Finish the current task and return to the task start point" },
983 + { type:
"command", name:
"abort-task", description:
"Abort the current task without finishing" },
984 + { type:
"command", name:
"auto", description:
"Automatically run pushed task branches" },
989 +const assistant = (content
: string)
=> ({
990 + type:
"message" as const,
991 + message: { role:
"assistant" as const, content: [{ type:
"text" as const, text: content }] }
992 +})
as unknown as Partial<
BranchEntry>;
994 +const user = (content
: string)
=> ({
995 + type:
"message" as const,
996 + message: { role:
"user" as const, content: [{ type:
"text", text: content }] }
997 +})
as unknown as Partial<
BranchEntry>;
999 +const task = (prompt
: string, inherit_context
= false)
=> ({
1000 + type:
"custom" as const,
1001 + customType:
"task",
1002 + data: { prompt, inherit_context }
1003 +})
as unknown as Partial<
BranchEntry>;
1005 +const taskResult = (slug
: string, content
?: string)
=> ({
1006 + type:
"custom_message" as const,
1007 + customType:
"task-result",
1008 + details: { slug },
1009 + ...(content
!== undefined ? { content: [{ type:
"text" as const, text: content }] }
: {}),
1010 +})
as unknown as Partial<
BranchEntry>;
1014 +function makeHarness() {
1015 + const sm
= SessionManager.
inMemory();
1018 + sm.
appendThinkingLevelChange(
"off");
1019 + const idleWaiters
: Array<()
=> void>
= [];
1020 + const sessionShutdownHandlers
: Array<()
=> unknown>
= [];
1021 + const triggeredCustomMessages
= new Set<
string>();
1022 + const triggeredUserMessages
= new Set<
string>();
1024 + const trackedHints
: Array<{ text
: string; afterEntryId
: string | null }>
= [];
1025 + let cancelNextNav
= false;
1026 + let pendingMessages
= false;
1027 + let taskStatus
: string | undefined;
1031 + appendEntry(customType
: string, data
?: unknown) {
1032 + sm.
appendCustomEntry(customType, data);
1034 + sendUserMessage(content
: string | Array<{ type
: string; text
: string }>) {
1035 + const text
= typeof content
=== "string" ? content
: content.
map((b)
=> b.
text).
join(
"");
1036 + sm.
appendMessage({ role:
"user", content: [{ type:
"text", text }], timestamp:
Date.
now() });
1037 + const branch
= sm.
getBranch();
1038 + const last
= branch[branch.
length - 1];
1039 + if (last) triggeredUserMessages.
add(last.
id);
1042 + message
: { customType
: string; content
: unknown; display
?: boolean; details
?: unknown },
1043 + options
?: { triggerTurn
?: boolean },
1045 + sm.
appendCustomMessageEntry(
1046 + message.customType,
1047 + message.
content as string,
1048 + message.
display ?? true,
1052 + if (options?.triggerTurn) {
1053 + const branch
= sm.
getBranch();
1054 + const last
= branch[branch.
length - 1];
1055 + if (last) triggeredCustomMessages.
add(last.
id);
1058 + on(eventName
: string,
handler: ()
=> unknown) {
1059 + if (eventName
=== "session_shutdown") sessionShutdownHandlers.
push(handler);
1061 + registerMessageRenderer() {},
1062 + registerTool() {},
1063 + registerCommand() {},
1064 + }
as unknown as ExtensionAPI;
1068 + waitForIdle:
async ()
=> {
1069 + await new Promise<
void>((resolve)
=> {
1070 + idleWaiters.
push(resolve);
1073 + hasPendingMessages: ()
=> pendingMessages,
1074 + sessionManager: sm,
1076 + notify(message
: string) {
1077 + trackedHints.
push({ text: message, afterEntryId: sm.
getLeafId() });
1079 + setStatus(key
: string, value
: string | undefined) {
1080 + if (key
=== "task") taskStatus
= value;
1083 + fg: (_key
: string, text
: string)
=> text,
1084 + bg: (_key
: string, text
: string)
=> text,
1085 + bold: (text
: string)
=> text,
1086 + }
as unknown as Theme,
1088 + navigateTree:
async (targetId
: string)
=> {
1089 + if (cancelNextNav) {
1090 + cancelNextNav
= false;
1091 + return { cancelled:
true };
1093 + sm.
branch(targetId);
1094 + return { cancelled:
false };
1096 + }
as unknown as ExtensionCommandContext & { sessionManager
: SessionManager };
1100 + function isLlmTriggered()
: boolean {
1101 + const branch
= sm.
getBranch();
1102 + if (branch.
length === 0)
return false;
1104 + for (
let i
= branch.
length - 1; i
>= 0; i
--) {
1105 + const entry
= branch[i];
1106 + if (entry.
type === "custom")
continue;
1107 + if (entry.
type === "message" && entry.message.role
=== "user")
return triggeredUserMessages.
has(entry.
id);
1108 + if (entry.
type === "message" && entry.message.role
=== "assistant")
return false;
1109 + if (entry.
type === "custom_message")
return triggeredCustomMessages.
has(entry.
id);
1115 + function appendUserMessage(text
: string)
: void {
1116 + sm.
appendMessage({ role:
"user", content: [{ type:
"text", text }], timestamp:
0 });
1119 + function appendAssistantMessage(text
: string, stopReason
?: string)
: void {
1120 + sm.
appendMessage({
1121 + role:
"assistant",
1122 + content: [{ type:
"text", text }],
1126 + ...(stopReason
? { stopReason }
: {}),
1127 + }
as Parameters<
typeof sm.appendMessage>[
0]);
1130 + function assertBranchHistory(
...expected
: Partial<
BranchEntry>[]) {
1131 + const entries
= sm.
getBranch();
1132 + const actual
: Partial<
BranchEntry>[]
= [];
1133 + const consumedHints
= new Set<
number>();
1135 + for (
const entry
of entries) {
1137 + const HIDDEN_TYPES
= new Set([
"thinking_level_change",
"model_change",
"session_info",
"label"]);
1139 + HIDDEN_TYPES.
has(entry.
type)
|| 1140 + (entry.
type === "custom" && (entry.customType
=== "task-done" || entry.customType
=== "task-start"));
1144 + const { id: _id, parentId: _pid, timestamp: _ts, display: _dp, data: rawData, details: rawDetails,
...restEntry }
= entry
as unknown as Record<
string,
unknown>;
1147 + const stripped
: Record<
string,
unknown>
= {
...restEntry };
1150 + if (stripped.message
&& typeof stripped.message
=== "object") {
1151 + const { timestamp: _mt, model: _mp, provider: _pp, stopReason: _sr,
...msgRest }
= stripped.message
as Record<
string,
unknown>;
1152 + stripped.message
= msgRest;
1156 + if (rawData
&& typeof rawData
=== "object") {
1157 + const cleaned
: Record<
string,
unknown>
= {};
1158 + for (
const [k, v]
of Object.
entries(rawData
as Record<
string,
unknown>)) {
1159 + if (
typeof v
!== "string" || !/^[a-f0-9]{8}$/.
test(v)) {
1163 + if (
Object.
keys(cleaned).
length > 0) stripped.
data = cleaned;
1167 + if (rawDetails
&& typeof rawDetails
=== "object") {
1168 + const cleaned
: Record<
string,
unknown>
= {};
1169 + for (
const [k, v]
of Object.
entries(rawDetails
as Record<
string,
unknown>)) {
1170 + if (
typeof v
!== "string" || !/^[a-f0-9]{8}$/.
test(v)) {
1174 + if (
Object.
keys(cleaned).
length > 0) stripped.details
= cleaned;
1177 + actual.
push(stripped
as Partial<
BranchEntry>);
1181 + for (
let i
= 0; i
< trackedHints.
length; i
++) {
1182 + if (trackedHints[i].afterEntryId
=== entry.
id) {
1183 + actual.
push(
notification(trackedHints[i].
text));
1184 + consumedHints.
add(i);
1190 + for (
let i
= 0; i
< trackedHints.
length; i
++) {
1191 + if (
!consumedHints.
has(i)
&& trackedHints[i].afterEntryId
=== null) {
1192 + actual.
unshift(
notification(trackedHints[i].
text));
1193 + consumedHints.
add(i);
1199 + const remaining
: Array<{ text
: string; afterEntryId
: string | null }>
= [];
1200 + for (
let i
= 0; i
< trackedHints.
length; i
++) {
1201 + if (
!consumedHints.
has(i)
&& trackedHints[i].afterEntryId
=== null) {
1202 + remaining.
push(trackedHints[i]);
1205 + trackedHints.
length = 0;
1206 + trackedHints.
push(
...remaining);
1208 + assert.
deepStrictEqual(actual, expected);
1213 + async function releaseNextIdle() {
1214 + const next
= idleWaiters.
shift();
1215 + assert.
ok(next,
"Expected a pending waitForIdle call.");
1218 + for (
let i
= 0; i
< 10; i
++) {
1219 + await Promise.
resolve();
1223 + async function flushMicrotasks() {
1224 + await Promise.
resolve();
1225 + await Promise.
resolve();
1228 + async function emitSessionShutdown() {
1229 + for (
const handler
of sessionShutdownHandlers) {
1234 + function setPendingMessages(value
: boolean) {
1235 + pendingMessages
= value;
1238 + function setCancelNextNav(v
: boolean) {
1239 + cancelNextNav
= v;
1244 + async function runPushTask(prompt
: string, inherit_context
?: boolean) {
1245 + const tool
= createPushTaskTool(pi);
1246 + await tool.
execute(
"call-1", { prompt, inherit_context },
undefined,
undefined, ctx);
1249 + async function runTaskCommand(command
: {
handler: (args
: string, ctx
: ExtensionCommandContext)
=> Promise<
unknown> }) {
1250 + const handlerP
= command.
handler(
"", ctx);
1251 + await releaseNextIdle();
1255 + const runStartTask = ()
=> runTaskCommand(
createStartTaskCommand(pi));
1256 + const runFinishTask = ()
=> runTaskCommand(
createFinishTaskCommand(pi));
1257 + const runDiscardTask = ()
=> runTaskCommand(
createDiscardTaskCommand(pi));
1258 + const runAbortTask = ()
=> runTaskCommand(
createAbortTaskCommand());
1261 + registerTaskCommands(pi);
1263 + function runAuto()
: Promise<
void> {
1264 + return createAutoCommand(pi).
handler(
"", ctx)
as Promise<
void>;
1267 + function getStatus()
: string | undefined {
1268 + return taskStatus;
1272 + assertBranchHistory,
1275 + appendUserMessage,
1276 + appendAssistantMessage,
1279 + emitSessionShutdown,
1280 + setPendingMessages,
1292 +const notification = (text
: string)
=> ({
1293 + type:
"notification" as const,
1295 + afterEntryId:
null as string | null 1296 +})
as unknown as Partial<
BranchEntry>;
1298 +type BranchEntry = import(
"@earendil-works/pi-coding-agent").
SessionEntry | NotificationEntry;
1302 +type NotificationEntry = {
1303 + type
: "notification";
1305 + afterEntryId
: string | null;
1310 +interface PathNode {
1312 + fn?: (h
: ReturnType<
typeof makeHarness>)
=> Promise<
void>
| void;
1313 + children
: PathNode[];
1318 + fn?: (h
: ReturnType<
typeof makeHarness>)
=> Promise<
void>
| void,
1319 + ...children
: PathNode[]
1322 +function pathSuite(
1323 + description
: string,
1324 + fn: (path
: PathFn)
=> PathNode | PathNode[],
1326 + describe(description, ()
=> {
1327 + const roots
= fn(path);
1328 + const rootsArray
= Array.
isArray(roots)
? roots
: [roots];
1330 + function registerTests(node
: PathNode, ancestors
: PathNode[])
: void {
1331 + const chain
= [
...ancestors, node];
1332 + const name
= chain.
map(n
=> n.
name).
join(
" → ");
1334 + it(name,
async ()
=> {
1335 + const h
= makeHarness();
1336 + for (
const ancestor
of chain) {
1337 + if (ancestor.fn) {
1338 + await ancestor.
fn(h);
1343 + for (
const child
of node.children) {
1344 + registerTests(child, chain);
1348 + for (
const root
of rootsArray) {
1349 + registerTests(
root, []);