2026-10-11 16:39:25 -07:00
// Web console tests, subagents and helper reports, end to end.
// Run with: node --test scripts/test-web-console-subagents.mjs
//
// Shared setup (a per-process console home, the CLI runner, fixtures) lives in
// web-console-test-helpers.mjs; see the comment at its top.
import test from "node:test" ;
import assert from "node:assert/strict" ;
import fs from "node:fs" ;
import path from "node:path" ;
2026-10-25 15:33:35 -07:00
import { defaultInstruction , offered , onLines , STRENGTH_LINES , STRENGTHS } from "../src/web-console/public/subagents.js" ;
2026-11-04 19:23:52 -08:00
import { spawnSync } from "node:child_process" ;
import { readSubagentCursor , readSubagentSetting } from "../src/web-console/settings.mjs" ;
import { foldKey } from "../src/web-console/workspace.mjs" ;
2026-10-11 16:39:25 -07:00
import {
ROOT ,
HOME ,
2026-11-04 19:23:52 -08:00
ENV ,
CONSOLE_CLI ,
safeJson ,
2026-10-11 16:39:25 -07:00
cli ,
sessionUrl ,
readState ,
openSession ,
postPatch ,
ask ,
EXPORT_A ,
consoleSession ,
addFolder ,
tempFolder ,
reportedHelper ,
} from "./web-console-test-helpers.mjs" ;
/* ------------------------------------------- subagents: end to end */
// The switch is remembered per project folder in the console home, so every
// test that starts from "off" clears it first.
const SUBAGENTS_STORE = path . join ( HOME , "subagents.json" );
const subagentsSession = ( extra = {}, { keepStore = false } = {}) => {
if ( ! keepStore ) fs . rmSync ( SUBAGENTS_STORE , { force : true });
return openSession ({ workflow : "implement" , ... extra });
};
const setSubagents = async ( s , body ) => {
const res = await s . send ( "/subagents" , body );
return { status : res . status , body : await res . json () };
};
const frameSubagents = async ( s ) =>
( await ( await fetch ( ` ${ s . base } /state` , { headers : { cookie : s . cookie , connection : "close" } })). json ()). subagents ;
const ON3 = { on : true , instruction : null , max : 3 };
const submitAndWait = async ( s ) => {
assert . equal (( await s . send ( "/submit" , EXPORT_A )). status , 200 );
return cli ([ "wait" , "--session" , s . sid , "--seconds" , "10" ]);
};
const subagentLines = ( reply ) =>
String ( reply || "" )
. split ( "\n" )
. filter (( l ) => l . startsWith ( "Subagents:" ));
test ( "subagents: a change reaches the next pickup once, last in reply, edits name what they replace and off follows only an on" , async () => {
const s = subagentsSession ();
const extra = tempFolder ();
try {
// Nothing saved means on, and open already told the agent. Turn it off and
// let that be said, so the rest of the test starts from an off agent.
assert . equal (( await setSubagents ( s , { ... ON3 , on : false })). status , 200 );
assert . equal ( subagentLines (( await submitAndWait ( s )). json . reply ). length , 1 , "off is said to an agent told on" );
const on = await setSubagents ( s , ON3 );
assert . equal ( on . status , 200 );
assert . equal ( on . body . ok , true );
const rev = on . body . setting . revision ;
2026-10-25 15:33:35 -07:00
assert . deepEqual ( on . body . setting , { workflow : "implement" , on : true , instruction : null , max : 3 , strength : "balanced" , revision : rev });
2026-10-11 16:39:25 -07:00
assert . equal (( await ask ( s , "Which files does the first task touch?" )). status , 200 );
assert . equal (( await addFolder ( s , { path : extra })). status , 200 );
const first = await submitAndWait ( s );
assert . equal ( first . status , 0 );
2026-11-02 12:00:12 -08:00
assert . equal ( "subagents" in first . json , false , "no structured subagents object on the wire" );
assert . equal ( "workspace" in first . json , false , "no structured workspace object on the wire" );
2026-10-11 16:39:25 -07:00
const reply = first . json . reply ;
const at = ( re ) => reply . search ( re );
assert . ok ( at ( /^Export format: a$/m ) === 0 , reply );
2026-11-02 12:00:12 -08:00
assert . ok ( at ( /^Quick question \(/m ) > 0 , reply );
assert . ok ( at ( /^Workspace:/m ) > at ( /^Quick question \(/m ), reply );
2026-10-11 16:39:25 -07:00
assert . ok ( at ( /^Subagents:/m ) > at ( /^Workspace:/m ), reply );
2026-11-02 12:00:12 -08:00
assert . equal ( subagentLines ( reply )[ 0 ], "Subagents: on, balanced strength, at most 3 helpers at once (a console setting, not typed by the person)." );
assert . ok ( reply . endsWith ( "\n " + defaultInstruction ( "implement" ). split ( "\n" ). pop (). trim ()), "the block goes last, ending on the instruction" );
for ( const old of [ "revision" , "Helper strength:" , "At most 3 helpers" , "Report each helper" , "Match each helper" ]) {
assert . ok ( ! reply . includes ( old ), "the old frame sentence is gone: " + old );
}
2026-10-11 16:39:25 -07:00
assert . deepEqual ( subagentLines ( reply ). length , 1 , "one block" );
assert . deepEqual ( readSubagentCursor ( s . session ), { revision : rev , state : "on" });
const second = await submitAndWait ( s );
assert . equal ( "subagents" in second . json , false , "handed over once" );
assert . deepEqual ( subagentLines ( second . json . reply ), []);
const edited = await setSubagents ( s , { ... ON3 , max : 5 });
assert . equal ( edited . body . setting . revision , rev + 1 );
const third = await submitAndWait ( s );
2026-11-02 12:00:12 -08:00
assert . equal ( "subagents" in third . json , false );
2026-10-11 16:39:25 -07:00
assert . deepEqual ( subagentLines ( third . json . reply ), [
2026-11-02 12:00:12 -08:00
"Subagents: on, balanced strength, at most 5 helpers at once (a console setting, not typed by the person)." ,
2026-10-11 16:39:25 -07:00
]);
const same = await setSubagents ( s , { ... ON3 , max : 5 });
assert . equal ( same . status , 200 );
assert . equal ( same . body . setting . revision , rev + 1 , "saving the same values bumps nothing" );
assert . equal ( "subagents" in ( await submitAndWait ( s )). json , false , "and injects nothing" );
const off = await setSubagents ( s , { ... ON3 , on : false , max : 5 });
assert . equal ( off . body . setting . revision , rev + 2 , "off is a revision of its own" );
const fourth = await submitAndWait ( s );
2026-11-02 12:00:12 -08:00
assert . deepEqual ( subagentLines ( fourth . json . reply ), [ "Subagents: off. Start no new helpers for the rest of this session." ]);
2026-10-11 16:39:25 -07:00
assert . equal ( "subagents" in ( await submitAndWait ( s )). json , false , "off is said once" );
} finally {
2026-11-02 12:00:12 -08:00
cli ([ "stop" , "--session" , s . sid , "--force" ]);
2026-10-11 16:39:25 -07:00
fs . rmSync ( extra , { recursive : true , force : true });
}
});
test ( "subagents: never on means never a line, and chat hands a pending block over on its own" , async () => {
// A project that saved "off" starts its next session off and untold.
const first = subagentsSession ();
assert . equal (( await setSubagents ( first , { on : false , instruction : null , max : 4 })). status , 200 );
2026-11-02 12:00:12 -08:00
cli ([ "stop" , "--session" , first . sid , "--force" ]);
2026-10-11 16:39:25 -07:00
const s = subagentsSession ({}, { keepStore : true });
try {
const off = await setSubagents ( s , { on : false , instruction : null , max : 4 });
assert . equal ( off . status , 200 );
const got = await submitAndWait ( s );
assert . equal ( "subagents" in got . json , false );
2026-11-02 12:00:12 -08:00
assert . deepEqual ( subagentLines ( got . json . reply ?? "" ), [], "off is never said to an agent not told on" );
2026-10-11 16:39:25 -07:00
assert . equal ( cli ([ "chat" , "--session" , s . sid ]). status , 10 );
assert . equal (( await setSubagents ( s , { on : true , instruction : "Split by file." , max : 4 })). status , 200 );
const chat = cli ([ "chat" , "--session" , s . sid ]);
assert . equal ( chat . status , 0 );
2026-11-02 12:00:12 -08:00
assert . equal ( chat . json . chat , undefined , "no question, no chat key" );
assert . equal ( "subagents" in chat . json , false );
assert . match ( chat . json . reply , /^Subagents: on, balanced strength, at most 4 helpers at once/ );
2026-10-11 16:39:25 -07:00
assert . match ( chat . json . reply , /^ {2}Split by file\.$/m );
assert . equal ( cli ([ "chat" , "--session" , s . sid ]). status , 10 , "then nothing" );
} finally {
2026-11-02 12:00:12 -08:00
cli ([ "stop" , "--session" , s . sid , "--force" ]);
2026-10-11 16:39:25 -07:00
}
});
test ( "subagents: a resume re-states an on setting once, says nothing when off, and a lost cursor repeats the block" , async () => {
const s = subagentsSession ();
try {
const rev = ( await setSubagents ( s , ON3 )). body . setting . revision ;
const resumed = cli ([ "open" , "--resume" , s . sid , "--no-open" ]);
assert . equal ( resumed . json . ok , true );
2026-11-02 12:00:12 -08:00
assert . equal ( "subagents" in resumed . json , false , "no structured object on the wire" );
assert . equal ( subagentLines ( resumed . json . reply )[ 0 ], "Subagents: on, balanced strength, at most 3 helpers at once (a console setting, not typed by the person)." );
assert . equal ( readSubagentCursor ( s . session ). revision , rev , "open stamped the cursor" );
2026-10-11 16:39:25 -07:00
assert . ok ( resumed . json . reply . split ( "\n" ). every (( l , i ) => i === 0 || l . startsWith ( " " )), "only the block's lines" );
assert . equal ( "subagents" in ( await submitAndWait ( s )). json , false , "the next pickup carries nothing" );
// The print happened but the cursor write did not: the block comes again.
fs . writeFileSync ( path . join ( s . session , "subagents-cursor.json" ), JSON . stringify ({ revision : 0 , state : "none" }));
const again = await submitAndWait ( s );
2026-11-02 12:00:12 -08:00
assert . deepEqual ( subagentLines ( again . json . reply ), [ "Subagents: on, balanced strength, at most 3 helpers at once (a console setting, not typed by the person)." ]);
2026-10-11 16:39:25 -07:00
assert . deepEqual ( readSubagentCursor ( s . session ), { revision : rev , state : "on" });
assert . equal (( await setSubagents ( s , { ... ON3 , on : false })). status , 200 );
const quiet = cli ([ "open" , "--resume" , s . sid , "--no-open" ]);
assert . equal ( "subagents" in quiet . json , false , "a resume with the switch off says nothing" );
assert . equal ( "reply" in quiet . json , false );
assert . equal ( "subagents" in ( await submitAndWait ( s )). json , false , "nor does the next pickup" );
} finally {
2026-11-02 12:00:12 -08:00
cli ([ "stop" , "--session" , s . sid , "--force" ]);
2026-10-11 16:39:25 -07:00
}
});
test ( "subagents: a dashboard launch into implement hears implement's saved setting once" , async () => {
const seed = subagentsSession ();
try {
assert . equal (( await setSubagents ( seed , ON3 )). status , 200 );
} finally {
2026-11-02 12:00:12 -08:00
cli ([ "stop" , "--session" , seed . sid , "--force" ]);
2026-10-11 16:39:25 -07:00
}
const s = consoleSession ([ "--workflow" , "dashboard" ]);
try {
assert . equal (( await s . get ( "/state" )). subagents . offered , false , "the dashboard offers no switch" );
const launched = cli ([ "open" , "--resume" , s . sid , "--no-open" , "--workflow" , "implement" ]);
// On the launch itself, not at a later pickup: a skill may do its main
// work before it ever collects anything.
2026-11-02 12:00:12 -08:00
assert . match ( launched . json . reply , /^Subagents: on, balanced strength/m , "the launch's own open output carries the block" );
assert . equal ( "subagents" in launched . json , false );
2026-10-11 16:39:25 -07:00
// open consumed the subagents block and advanced the cursor before it
// printed, so chat has nothing left to hand over.
assert . equal ( cli ([ "chat" , "--session" , s . sid ]). status , 10 , "never both" );
const view = await s . get ( "/state" );
assert . deepEqual ([ view . subagents . offered , view . subagents . supported , view . subagents . on ], [ true , true , true ]);
} finally {
2026-11-02 12:00:12 -08:00
cli ([ "stop" , "--session" , s . sid , "--force" ]);
2026-10-11 16:39:25 -07:00
}
});
test ( "subagents: the setting survives a restart at the same revision and starts the next session in the project" , async () => {
const s = subagentsSession ();
let next = null ;
try {
const saved = await setSubagents ( s , { on : true , instruction : "Split by file." , max : 7 });
assert . equal ( saved . status , 200 );
const rev = saved . body . setting . revision ;
2026-11-02 12:00:12 -08:00
cli ([ "stop" , "--session" , s . sid , "--force" ]);
2026-10-11 16:39:25 -07:00
const resumed = cli ([ "open" , "--resume" , s . sid , "--no-open" ]);
const frame = await (
await fetch ( ` ${ sessionUrl ( resumed . json . url ). base } /state` , { headers : { cookie : sessionUrl ( resumed . json . url ). cookie , connection : "close" } })
). json ();
assert . deepEqual (
[ frame . subagents . on , frame . subagents . instruction , frame . subagents . max , frame . subagents . revision ],
[ true , "Split by file." , 7 , rev ],
"a restart alone bumps nothing"
);
next = subagentsSession ({}, { keepStore : true });
const fresh = await frameSubagents ( next );
assert . deepEqual ([ fresh . on , fresh . instruction , fresh . max ], [ true , "Split by file." , 7 ], "a new session in the same project starts there" );
} finally {
2026-11-02 12:00:12 -08:00
cli ([ "stop" , "--session" , s . sid , "--force" ]);
if ( next ) cli ([ "stop" , "--session" , next . sid , "--force" ]);
2026-10-11 16:39:25 -07:00
}
});
test ( "subagents: a save that matches this session still becomes the project's setting, without a bump" , async () => {
const b = subagentsSession ();
const a = subagentsSession ({}, { keepStore : true });
let c = null ;
try {
const before = ( await frameSubagents ( b )). revision ;
assert . equal (( await setSubagents ( a , { ... ON3 , on : false })). status , 200 , "another session turns it off for the project" );
const same = await setSubagents ( b , ON3 );
assert . equal ( same . status , 200 );
assert . equal ( same . body . setting . revision , before , "nothing changed for this session's agent" );
assert . equal ( "subagents" in ( await submitAndWait ( b )). json , false );
c = subagentsSession ({}, { keepStore : true });
assert . equal (( await frameSubagents ( c )). on , true , "the next session starts from the person's latest pick" );
} finally {
2026-11-02 12:00:12 -08:00
for ( const s of [ a , b , c ]) if ( s ) cli ([ "stop" , "--session" , s . sid , "--force" ]);
2026-10-11 16:39:25 -07:00
}
});
test ( "subagents: a workflow without the switch refuses it, bad bodies name the field, and an older copy's open hides it" , async () => {
2026-11-02 13:13:31 -08:00
const plain = subagentsSession ({ workflow : "changelog" });
2026-10-11 16:39:25 -07:00
const s = subagentsSession ();
try {
2026-11-02 13:13:31 -08:00
assert . deepEqual ( await setSubagents ( plain , ON3 ), { status : 400 , body : { error : "not-offered" } });
assert . equal (( await frameSubagents ( plain )). offered , false );
assert . equal ( "subagents" in ( await submitAndWait ( plain )). json , false );
2026-10-11 16:39:25 -07:00
assert . deepEqual ( await setSubagents ( s , { ... ON3 , max : 0 }), { status : 400 , body : { error : "max" } });
assert . deepEqual ( await setSubagents ( s , { ... ON3 , max : 21 }), { status : 400 , body : { error : "max" } });
assert . deepEqual ( await setSubagents ( s , { ... ON3 , instruction : "x" . repeat ( 2001 ) }), { status : 400 , body : { error : "too-long" } });
assert . deepEqual ( await setSubagents ( s , { ... ON3 , on : "yes" }), { status : 400 , body : { error : "bad" } });
2026-10-25 15:33:35 -07:00
assert . deepEqual ( await setSubagents ( s , { ... ON3 , strength : "fast" }), { status : 400 , body : { error : "strength" } });
2026-10-11 16:39:25 -07:00
assert . equal (( await frameSubagents ( s )). supported , true , "this copy's open carries caps" );
fs . appendFileSync ( path . join ( s . session , "events.ndjson" ), JSON . stringify ({ at : new Date (). toISOString (), type : "open" , resumed : true }) + "\n" );
assert . equal (( await frameSubagents ( s )). supported , false , "an older copy's open has no caps" );
cli ([ "open" , "--resume" , s . sid , "--no-open" ]);
assert . equal (( await frameSubagents ( s )). supported , true );
// A session an older server ran has no setting file: nothing is injected,
// whatever the store says.
assert . equal (( await setSubagents ( s , ON3 )). status , 200 );
fs . rmSync ( path . join ( s . session , "subagents-setting.json" ), { force : true });
assert . equal ( "subagents" in ( await submitAndWait ( s )). json , false );
} finally {
2026-11-02 13:13:31 -08:00
cli ([ "stop" , "--session" , plain . sid , "--force" ]);
cli ([ "stop" , "--session" , s . sid , "--force" ]);
}
});
test ( "subagents: a newly opted-in workflow offers the switch end to end" , async () => {
const s = subagentsSession ({ workflow : "xray" });
try {
assert . equal ( offered ( "xray" ), true , "skills.js opts xray in" );
assert . ok ( defaultInstruction ( "xray" ). length > 0 , "and ships its instruction" );
const frame = await frameSubagents ( s );
assert . equal ( frame . offered , true , "the session's frame offers the switch" );
const on = await setSubagents ( s , ON3 );
assert . equal ( on . status , 200 , "the route accepts the save" );
assert . equal ( on . body . setting . workflow , "xray" );
} finally {
2026-11-02 12:00:12 -08:00
cli ([ "stop" , "--session" , s . sid , "--force" ]);
2026-10-11 16:39:25 -07:00
}
});
2026-10-25 15:33:35 -07:00
test ( "subagents: a strength-only change reaches the agent once, with its profile line" , async () => {
const s = subagentsSession ();
try {
const before = ( await frameSubagents ( s )). revision ;
const thrifty = await setSubagents ( s , { ... ON3 , strength : "thrifty" });
assert . equal ( thrifty . status , 200 );
assert . equal ( thrifty . body . setting . revision , before + 1 , "a strength alone is a change" );
assert . equal ( thrifty . body . setting . strength , "thrifty" );
const picked = await submitAndWait ( s );
2026-11-02 12:00:12 -08:00
assert . equal ( "subagents" in picked . json , false );
assert . deepEqual ( subagentLines ( picked . json . reply ), [ "Subagents: on, thrifty strength, at most 3 helpers at once (a console setting, not typed by the person)." ]);
2026-10-25 15:33:35 -07:00
assert . equal (( await frameSubagents ( s )). strength , "thrifty" );
const again = await setSubagents ( s , { ... ON3 , strength : "thrifty" });
assert . equal ( again . body . setting . revision , before + 1 , "the same strength again bumps nothing" );
assert . equal ( "subagents" in ( await submitAndWait ( s )). json , false );
} finally {
2026-11-02 12:00:12 -08:00
cli ([ "stop" , "--session" , s . sid , "--force" ]);
2026-10-25 15:33:35 -07:00
}
});
test ( "subagents: a setting saved before strength existed reads as balanced and bumps nothing" , async () => {
const s = subagentsSession ();
try {
assert . equal (( await setSubagents ( s , { ... ON3 , max : 4 })). status , 200 );
const strip = ( file , entries ) => {
const saved = JSON . parse ( fs . readFileSync ( file , "utf8" ));
for ( const entry of entries ( saved )) delete entry . strength ;
fs . writeFileSync ( file , JSON . stringify ( saved ));
};
strip ( SUBAGENTS_STORE , ( store ) => Object . values ( store ). flatMap (( project ) => Object . values ( project )));
strip ( path . join ( s . session , "subagents-setting.json" ), ( setting ) => [ setting ]);
const rev = JSON . parse ( fs . readFileSync ( path . join ( s . session , "subagents-setting.json" ), "utf8" )). revision ;
2026-11-02 12:00:12 -08:00
cli ([ "stop" , "--session" , s . sid , "--force" ]);
2026-10-25 15:33:35 -07:00
const resumed = sessionUrl ( cli ([ "open" , "--resume" , s . sid , "--no-open" ]). json . url );
const frame = ( await ( await fetch ( ` ${ resumed . base } /state` , { headers : { cookie : resumed . cookie , connection : "close" } })). json ()). subagents ;
assert . deepEqual ([ frame . max , frame . strength , frame . revision ], [ 4 , "balanced" , rev ], "an upgrade alone bumps nothing" );
} finally {
2026-11-02 12:00:12 -08:00
cli ([ "stop" , "--session" , s . sid , "--force" ]);
2026-10-25 15:33:35 -07:00
}
});
test ( "subagents: every strength renders its own profile line, and a missing one is balanced" , () => {
const base = { revision : 1 , max : 3 , instruction : "Split by file." };
for ( const strength of STRENGTHS ) {
const lines = onLines ({ ... base , strength });
2026-11-02 12:00:12 -08:00
const word = strength ;
assert . equal ( lines [ 0 ], `Subagents: on, ${ word } strength, at most 3 helpers at once (a console setting, not typed by the person).` , strength );
assert . equal ( lines . filter (( l ) => l . includes ( "Helper strength:" )). length , 0 , "the old profile sentence is gone: " + strength );
2026-10-25 15:33:35 -07:00
}
2026-11-02 12:00:12 -08:00
assert . equal ( new Set ( STRENGTHS . map (( k ) => onLines ({ ... base , strength : k })[ 0 ])). size , STRENGTHS . length , "four different lines" );
assert . equal ( onLines ( base )[ 0 ], onLines ({ ... base , strength : "balanced" })[ 0 ], "a missing strength is balanced" );
2026-10-25 15:33:35 -07:00
});
2026-10-11 16:39:25 -07:00
/* ------------------------------------------ subagents: helper reports */
test ( "helpers: post merges them by id, a real helper supersedes working alone, and null clears the list" , () => {
const s = consoleSession ([ "--workflow" , "implement" ]);
try {
assert . equal ( postPatch ( s , { helpers : [ reportedHelper ( "h1" )] }). status , 0 );
const done = reportedHelper ( "h1" , { state : "done" , result : "Found 2 call sites" });
assert . equal ( postPatch ( s , { helpers : [ done , reportedHelper ( "h2" )] }). status , 0 );
assert . deepEqual ( readState ( s . session ). helpers , [ done , reportedHelper ( "h2" )], "h1 updated in place, h2 added" );
// Working alone is a claim about having no helper tool at all, so real
// helpers supersede it whichever order the two arrive in.
assert . equal ( postPatch ( s , { helpers : [{ id : "alone" , alone : true }] }). status , 0 );
assert . deepEqual ( readState ( s . session ). helpers . map (( h ) => h . id ), [ "h1" , "h2" ], "alone beside real helpers is dropped" );
assert . equal ( postPatch ( s , { helpers : null }). status , 0 );
assert . equal ( "helpers" in readState ( s . session ), false );
assert . equal ( postPatch ( s , { helpers : [{ id : "alone" , alone : true }] }). status , 0 );
assert . deepEqual ( readState ( s . session ). helpers , [{ id : "alone" , alone : true }]);
const second = postPatch ( s , { helpers : [{ id : "solo" , alone : true }] }, { expectFail : true });
assert . equal ( second . status , 3 );
assert . match ( second . stderr , /helper "solo"/ );
assert . deepEqual ( readState ( s . session ). helpers , [{ id : "alone" , alone : true }], "the refused entry was not written" );
assert . equal ( postPatch ( s , { helpers : [ reportedHelper ( "h1" )] }). status , 0 );
assert . deepEqual ( readState ( s . session ). helpers . map (( h ) => h . id ), [ "h1" ], "a real helper removes the working-alone marker" );
} finally {
2026-11-02 12:00:12 -08:00
cli ([ "stop" , "--session" , s . sid , "--force" ]);
2026-10-11 16:39:25 -07:00
}
});
test ( "helpers: every malformed report exits 3 naming the helper, and nothing is written" , () => {
const s = consoleSession ([ "--workflow" , "implement" ]);
try {
assert . equal ( postPatch ( s , { helpers : [ reportedHelper ( "h1" )] }). status , 0 );
const statePath = path . join ( s . session , "state.json" );
const before = fs . readFileSync ( statePath , "utf8" );
const cases = [
[ "missing title" , [{ id : "h3" , ask : "Read the docs" , state : "running" }], /helper "h3": title must be a non-empty string/ ],
[ "unknown state" , [ reportedHelper ( "h3" , { state : "paused" })], /helper "h3": state must be running, done or failed/ ],
[ "81-char title" , [ reportedHelper ( "h3" , { title : "t" . repeat ( 81 ) })], /helper "h3": title must be at most 80 characters/ ],
[ "401-char ask" , [ reportedHelper ( "h3" , { ask : "a" . repeat ( 401 ) })], /helper "h3": ask must be at most 400 characters/ ],
[ "201-char result" , [ reportedHelper ( "h3" , { state : "done" , result : "r" . repeat ( 201 ) })], /helper "h3": result must be at most 200 characters/ ],
2026-11-02 12:00:12 -08:00
[ "completion marker" , [ reportedHelper ( "h3" , { state : "done" , result : "PHASE_COMPLETE" })], /helper "h3" result: contains a loop completion marker/ ],
[ "metrics bait" , [ reportedHelper ( "h3" , { title : "Risk 3" })], /helper "h3" title: contains "Risk 3"/ ],
[ "not an array" , { id : "h3" }, /helpers: must be an array/ ],
[ "null entry" , [ null ], /helpers: entries must be objects/ ],
[ "string entry" , [ "h3" ], /helpers: entries must be objects/ ],
2026-10-11 16:39:25 -07:00
];
for ( const [ name , helpers , re ] of cases ) {
const res = postPatch ( s , { helpers }, { expectFail : true });
assert . equal ( res . status , 3 , name );
assert . match ( res . stderr , re , name );
assert . equal ( fs . readFileSync ( statePath , "utf8" ), before , ` ${ name } : nothing written` );
}
} finally {
2026-11-02 12:00:12 -08:00
cli ([ "stop" , "--session" , s . sid , "--force" ]);
2026-10-11 16:39:25 -07:00
}
});
2026-10-25 15:33:35 -07:00
test ( "helpers: a reported strength and effort are kept, other values exit 3 naming the helper, and both stay optional" , () => {
const s = consoleSession ([ "--workflow" , "implement" ]);
try {
const ran = reportedHelper ( "h1" , { strength : "standard" , effort : "medium" });
assert . equal ( postPatch ( s , { helpers : [ ran ] }). status , 0 );
assert . deepEqual ( readState ( s . session ). helpers , [ ran ], "strength and effort are kept as reported" );
const statePath = path . join ( s . session , "state.json" );
const before = fs . readFileSync ( statePath , "utf8" );
for ( const [ name , extra , re ] of [
[ "unknown strength" , { strength : "huge" }, /helper "h2": strength must be light, standard, strongest or inherit/ ],
[ "unknown effort" , { effort : "max" }, /helper "h2": effort must be low, medium or high/ ],
]) {
const res = postPatch ( s , { helpers : [ reportedHelper ( "h2" , extra )] }, { expectFail : true });
assert . equal ( res . status , 3 , name );
assert . match ( res . stderr , re , name );
assert . equal ( fs . readFileSync ( statePath , "utf8" ), before , ` ${ name } : nothing written` );
}
assert . equal ( postPatch ( s , { helpers : [ reportedHelper ( "h3" )] }). status , 0 , "a helper without the fields still posts" );
assert . deepEqual ( readState ( s . session ). helpers . map (( h ) => h . id ), [ "h1" , "h3" ]);
} finally {
2026-11-02 12:00:12 -08:00
cli ([ "stop" , "--session" , s . sid , "--force" ]);
2026-10-25 15:33:35 -07:00
}
});
2026-10-11 16:39:25 -07:00
test ( "docs: a doc's version never goes back; the same version again is fine, and a hop starts every doc fresh" , () => {
const s = consoleSession ([ "--workflow" , "implement" ]);
try {
const doc = ( version , md ) => ({ docs : [{ id : "phase" , title : "Phase 5 tasks" , version , blocks : [{ id : "tasks" , state : "settled" , md }] }] });
assert . equal ( postPatch ( s , doc ( 7 , "- [x] Task 4.1" )). status , 0 );
assert . equal ( postPatch ( s , doc ( 7 , "- [x] Task 4.1 (again)" )). status , 0 , "the same version again is fine" );
const statePath = path . join ( s . session , "state.json" );
const before = fs . readFileSync ( statePath , "utf8" );
const stale = postPatch ( s , doc ( 1 , "- [ ] Task 4.1" ), { expectFail : true });
assert . equal ( stale . status , 3 );
2026-11-02 12:00:12 -08:00
assert . match ( stale . stderr , /doc "phase" version: the page is at version 7; this patch sends 1/ );
2026-10-11 16:39:25 -07:00
assert . equal ( fs . readFileSync ( statePath , "utf8" ), before , "nothing written" );
assert . equal ( postPatch ( s , doc ( 8 , "- [ ] Task 5.1" )). status , 0 , "a higher version goes through" );
assert . equal ( postPatch ( s , { docs : [{ id : "phase" , blocks : [{ id : "tasks" , state : "settled" , md : "- [x] Task 5.1" }] }] }). status , 0 , "a patch with no version is not checked" );
cli ([ "open" , "--resume" , s . sid , "--no-open" , "--workflow" , "dashboard" ]);
cli ([ "open" , "--resume" , s . sid , "--no-open" , "--workflow" , "implement" ]);
assert . equal ( postPatch ( s , doc ( 1 , "- [ ] Task 1.1" )). status , 0 , "after a hop the doc starts fresh" );
} finally {
2026-11-02 12:00:12 -08:00
cli ([ "stop" , "--session" , s . sid , "--force" ]);
2026-10-11 16:39:25 -07:00
}
});
test ( "docs: a second phase in one build session goes through as notes/implement.md teaches it" , () => {
const md = fs . readFileSync ( path . join ( ROOT , "src" , "web-console" , "notes" , "implement.md" ), "utf8" );
2026-11-03 04:08:09 -08:00
assert . match ( md , /A later phase posts the same doc with the new title and file/ );
2026-11-02 12:00:12 -08:00
assert . match ( fs . readFileSync ( path . join ( ROOT , "src" , "web-console" , "console-docs.md" ), "utf8" ), /`version`: moves by itself when content changes and never goes back; leave it out/ );
2026-10-11 16:39:25 -07:00
const taught = consoleSession ([ "--workflow" , "implement" ]);
try {
// As taught: no version anywhere, and the second phase simply goes through.
const phase = ( n , md ) => ({
headline : { stage : `Phase ${ n } ` , cleared : 0 },
2026-11-03 04:08:09 -08:00
docs : [{ id : "phasefile" , title : `phase- ${ n } .md` , blocks : [{ id : "body" , state : "settled" , md }] }],
2026-10-11 16:39:25 -07:00
});
assert . equal ( postPatch ( taught , phase ( 1 , "- [ ] Task 1.1" )). status , 0 );
assert . equal ( postPatch ( taught , phase ( 1 , "- [x] Task 1.1" )). status , 0 );
assert . equal ( postPatch ( taught , phase ( 2 , "- [ ] Task 2.1" )). status , 0 );
assert . deepEqual (
readState ( taught . session ). docs . map (( d ) => [ d . id , d . title , d . version ]),
2026-11-03 04:08:09 -08:00
[[ "phasefile" , "phase-2.md" , 3 ]]
2026-10-11 16:39:25 -07:00
);
} finally {
2026-11-02 12:00:12 -08:00
cli ([ "stop" , "--session" , taught . sid , "--force" ]);
2026-10-11 16:39:25 -07:00
}
// An explicit version still never goes back.
const s = consoleSession ([ "--workflow" , "implement" ]);
try {
const phase = ( n , version , md ) => ({
headline : { stage : `Phase ${ n } ` , cleared : 0 },
2026-11-03 04:08:09 -08:00
docs : [{ id : "phasefile" , title : `phase- ${ n } .md` , version , blocks : [{ id : "body" , state : "settled" , md }] }],
2026-10-11 16:39:25 -07:00
});
assert . equal ( postPatch ( s , phase ( 1 , 1 , "- [ ] Task 1.1" )). status , 0 );
assert . equal ( postPatch ( s , phase ( 1 , 2 , "- [x] Task 1.1" )). status , 0 );
const restarted = postPatch ( s , phase ( 2 , 1 , "- [ ] Task 2.1" ), { expectFail : true });
assert . equal ( restarted . status , 3 , "restarting at version 1 is refused" );
assert . equal ( postPatch ( s , phase ( 2 , 3 , "- [ ] Task 2.1" )). status , 0 , "continuing from the page's version goes through" );
const docs = readState ( s . session ). docs ;
assert . deepEqual (
docs . map (( d ) => [ d . id , d . title , d . version ]),
2026-11-03 04:08:09 -08:00
[[ "phasefile" , "phase-2.md" , 3 ]]
2026-10-11 16:39:25 -07:00
);
} finally {
2026-11-02 12:00:12 -08:00
cli ([ "stop" , "--session" , s . sid , "--force" ]);
}
});
test ( "subagents: a change arrives as reply lines only, carrying state, strength and limit and none of the old frame sentences" , async () => {
const s = subagentsSession ();
try {
assert . equal (( await setSubagents ( s , { on : true , instruction : "Split by file." , max : 6 , strength : "thrifty" })). status , 200 );
const got = await submitAndWait ( s );
assert . equal ( got . status , 0 );
assert . equal ( "subagents" in got . json , false , "no subagents object" );
assert . equal ( "workspace" in got . json , false , "no workspace object" );
assert . deepEqual ( subagentLines ( got . json . reply ), [ "Subagents: on, thrifty strength, at most 6 helpers at once (a console setting, not typed by the person)." ]);
assert . ok ( got . json . reply . endsWith ( "\n Split by file." ), "the person's instruction follows, indented" );
for ( const old of [ "revision" , "Helper strength:" , "Hand independent" , "Report each helper" , "If your tools cannot" ]) {
assert . ok ( ! got . json . reply . includes ( old ), "no old frame sentence: " + old );
}
} finally {
cli ([ "stop" , "--session" , s . sid , "--force" ]);
2026-10-11 16:39:25 -07:00
}
});
2026-11-04 19:23:52 -08:00
/* ------------------------------------- a loop phase's helpers follow its strength */
const loopOpen = ( cwd , env , workflow = "implement" , extraArgs = [ "--loop" ]) => {
const clean = { ... process . env , ... ENV };
for ( const key of [ "PLAN2CODE_IN_APP" , "PLAN2CODE_EMBED_ORIGIN" , "PLAN2CODE_APP_ANNOUNCE" , "PLAN2CODE_APP_TOKEN" , "PLAN2CODE_CONSOLE_SID" , "PLAN2CODE_LOOP_STRENGTH" ]) delete clean [ key ];
const res = spawnSync ( process . execPath , [ CONSOLE_CLI , "open" , "--workflow" , workflow , ... extraArgs , "--no-open" ], { env : { ... clean , ... env }, encoding : "utf8" , cwd });
assert . equal ( res . status , 0 , res . stderr );
return safeJson ( res . stdout );
};
test ( "subagents: open --loop on a phase strength tells the agent that strength, leaves the stored setting alone and off stays off" , () => {
const cwd = fs . mkdtempSync ( path . join ( HOME , "sub-loop-" ));
const stored = ( entry ) => fs . writeFileSync ( SUBAGENTS_STORE , JSON . stringify ({ [ foldKey ( cwd )] : { implement : entry } }));
const sessions = [];
try {
stored ({ on : true , instruction : null , max : 3 , strength : "balanced" });
const before = fs . readFileSync ( SUBAGENTS_STORE , "utf8" );
const thrifty = loopOpen ( cwd , { PLAN2CODE_IN_APP : "1" , PLAN2CODE_LOOP_STRENGTH : "thrifty" });
sessions . push ( thrifty . sid );
assert . deepEqual ( subagentLines ( thrifty . reply ), [ "Subagents: on, thrifty strength, at most 3 helpers at once (a console setting, not typed by the person)." ]);
assert . deepEqual ( readState ( thrifty . session ). loop , { driving : true , strength : "thrifty" });
assert . equal ( fs . readFileSync ( SUBAGENTS_STORE , "utf8" ), before , "the stored setting is not rewritten" );
// The next phase in the same session runs on another strength, then none.
const best = loopOpen ( cwd , { PLAN2CODE_IN_APP : "1" , PLAN2CODE_LOOP_STRENGTH : "best" }, "implement" , [ "--resume" , thrifty . sid , "--loop" ]);
assert . deepEqual ( subagentLines ( best . reply ). map (( l ) => l . replace ( / \(a console.*/ , "" )), [ "Subagents: on, best strength, at most 3 helpers at once" ]);
assert . equal ( fs . readFileSync ( SUBAGENTS_STORE , "utf8" ), before );
// A phase with no strength after a strength phase hears the stored one.
const none = loopOpen ( cwd , { PLAN2CODE_IN_APP : "1" }, "implement" , [ "--resume" , thrifty . sid , "--loop" ]);
assert . deepEqual ( subagentLines ( none . reply ). map (( l ) => l . replace ( / \(a console.*/ , "" )), [ "Subagents: on, balanced strength, at most 3 helpers at once" ]);
assert . deepEqual ( readState ( thrifty . session ). loop , { driving : true });
// Off stays off, whatever the phase's strength.
stored ({ on : false , instruction : null , max : 3 , strength : "balanced" });
const off = loopOpen ( cwd , { PLAN2CODE_IN_APP : "1" , PLAN2CODE_LOOP_STRENGTH : "thrifty" }, "implement" , [ "--resume" , thrifty . sid , "--loop" ]);
assert . ok ( ! subagentLines ( off . reply ). some (( l ) => / on , /.test(l)), JSON.stringify(off.reply));
assert . equal ( readSubagentSetting ( thrifty . session ). on , false );
} finally {
for ( const sid of sessions ) cli ([ "stop" , "--session" , sid , "--force" ], { expectFail : true });
}
});
test ( "subagents: open without --loop ignores PLAN2CODE_LOOP_STRENGTH, and a word that is not a strength is dropped" , () => {
const cwd = fs . mkdtempSync ( path . join ( HOME , "sub-noloop-" ));
fs . writeFileSync ( SUBAGENTS_STORE , JSON . stringify ({ [ foldKey ( cwd )] : { implement : { on : true , instruction : null , max : 3 , strength : "balanced" } } }));
const sessions = [];
try {
const plain = loopOpen ( cwd , { PLAN2CODE_LOOP_STRENGTH : "thrifty" }, "implement" , []);
sessions . push ( plain . sid );
assert . deepEqual ( subagentLines ( plain . reply ). map (( l ) => l . replace ( / \(a console.*/ , "" )), [ "Subagents: on, balanced strength, at most 3 helpers at once" ]);
assert . equal ( "loop" in readState ( plain . session ), false );
const odd = loopOpen ( cwd , { PLAN2CODE_IN_APP : "1" , PLAN2CODE_LOOP_STRENGTH : "session" });
sessions . push ( odd . sid );
assert . deepEqual ( readState ( odd . session ). loop , { driving : true });
} finally {
for ( const sid of sessions ) cli ([ "stop" , "--session" , sid , "--force" ], { expectFail : true });
}
});