@selesai/code 0.5.20 → 0.5.21

package/dist/extensions/pi-subagents/test/unit/task-intent.test.ts

@@ -0,0 +1,86 @@
+import assert from "node:assert/strict";
+import { describe, it } from "node:test";
+import { classifyTaskMutationIntent, expectsImplementationMutation, taskMayMutate } from "../../src/runs/shared/task-intent.ts";
+
+describe("classifyTaskMutationIntent", () => {
+	it("keeps write imperatives despite investigative wording", () => {
+		assert.equal(classifyTaskMutationIntent("builder", "Inspect the failure and implement the fix").kind, "implementation");
+		assert.equal(classifyTaskMutationIntent("builder", "Research the current code path and patch the bug").kind, "implementation");
+	});
+
+	it("does not broaden the shared completion-guard classifier for role-only path patches", () => {
+		assert.equal(classifyTaskMutationIntent("builder", "Patch src/auth.ts").kind, "unknown");
+	});
+
+	it("treats scoped no-edit constraints as constraints, not task intent", () => {
+		assert.equal(classifyTaskMutationIntent("builder", "Do not modify tests; implement the fix").kind, "implementation");
+		assert.equal(classifyTaskMutationIntent("builder", "Fix the bug. Do not edit files outside src/.").kind, "implementation");
+		assert.equal(classifyTaskMutationIntent("builder", "Must not touch the production database; implement the fix locally").kind, "implementation");
+	});
+
+	it("stops the prohibition object before a following implementation clause", () => {
+		for (const task of [
+			"Do not modify tests but implement the fix",
+			"Do not modify tests and implement the fix",
+			"Do not modify tests: implement the fix",
+			"Do not modify tests? Implement the fix",
+			"Do not modify tests - implement the fix",
+			"Do not modify tests – implement the fix",
+			"Do not modify tests — implement the fix",
+		]) {
+			assert.equal(classifyTaskMutationIntent("builder", task).kind, "implementation", task);
+		}
+		assert.equal(classifyTaskMutationIntent("builder", "Do not modify tests and fixtures").kind, "read-only");
+	});
+
+	it("lets blanket no-edit prohibitions win over write verbs", () => {
+		assert.equal(classifyTaskMutationIntent("builder", "Implement this. Do not edit files.").kind, "read-only");
+		assert.equal(classifyTaskMutationIntent("builder", "Do not edit files. Tell me how to fix the bug.").kind, "read-only");
+		assert.equal(classifyTaskMutationIntent("builder", "Report on the extraction pipeline. Do not modify project/source files.").kind, "read-only");
+		assert.equal(classifyTaskMutationIntent("commentator", "Final correctness review after prior fixes. Inspect all changed files and tests. Do not modify project/source files. Report findings.").kind, "read-only");
+	});
+
+	it("strips repeated prohibition phrases before testing write intent", () => {
+		assert.equal(classifyTaskMutationIntent("builder", "Do not modify vendor/. Do not modify generated/. Summarize the build.").kind, "read-only");
+		assert.equal(classifyTaskMutationIntent("builder", "Do not modify vendor/. Do not modify generated/. Implement the fix in src/.").kind, "implementation");
+	});
+
+	it("classifies research agents and commentator-style tasks as read-only", () => {
+		assert.equal(classifyTaskMutationIntent("researcher", "Research this and patch the bug").kind, "read-only");
+		assert.equal(classifyTaskMutationIntent("commentator", "Review this and fix any real issues").kind, "read-only");
+		assert.equal(classifyTaskMutationIntent("commentator", "Review findings and determine what to implement with playbooks instead of before").kind, "read-only");
+		assert.equal(classifyTaskMutationIntent("commentator", "Review findings and determine what to implement with playbooks instead of before").kind, "read-only");
+		assert.equal(classifyTaskMutationIntent("commentator", "Review this; regardless of findings, apply changes directly").kind, "implementation");
+		assert.equal(classifyTaskMutationIntent("commentator", "Implement the approved file changes").kind, "implementation");
+		assert.equal(classifyTaskMutationIntent("commentator", "Implement the approved file changes").kind, "implementation");
+	});
+
+	it("keeps report-writing deliverables read-only", () => {
+		assert.equal(classifyTaskMutationIntent("builder", "Write a report on the API").kind, "read-only");
+		assert.equal(classifyTaskMutationIntent("builder", "Create a summary").kind, "unknown");
+	});
+
+	it("expectsImplementationMutation mirrors the classifier", () => {
+		assert.equal(expectsImplementationMutation("builder", "Do not modify tests; implement the fix"), true);
+		assert.equal(expectsImplementationMutation("builder", "Review the diff and suggest fixes only. Do not edit files."), false);
+	});
+});
+
+describe("taskMayMutate", () => {
+	it("treats any bare write verb as write-capable", () => {
+		for (const task of ["Write the code", "Commit the changes", "Delete temporary data", "Remove obsolete assets", "Update dependencies"]) {
+			assert.equal(taskMayMutate(task), true, task);
+		}
+	});
+
+	it("does not count verbs inside prohibitions or read-only deliverables", () => {
+		assert.equal(taskMayMutate("Do not modify project/source files. Report findings."), false);
+		assert.equal(taskMayMutate("Write a report on the API"), false);
+		assert.equal(taskMayMutate("Summarize the build output"), false);
+	});
+
+	it("keeps verbs that survive outside a scoped prohibition", () => {
+		assert.equal(taskMayMutate("Do not modify tests but implement the fix"), true);
+		assert.equal(taskMayMutate("Do not modify tests; update the parser"), true);
+	});
+});

package/dist/extensions/pi-subagents/test/unit/tool-budget.test.ts

@@ -23,6 +23,17 @@ describe("tool-budget module", () => {
 		assert.deepEqual(resolved.budget, { soft: 2, hard: 4, block: "*" });
 	});
 
+	it("accepts a zero hard limit only when the internal minimum opts in", () => {
+		assert.deepEqual(
+			validateToolBudgetConfig({ hard: 0, block: "*" }, "toolBudget", { minimumHard: 0 }).budget,
+			{ hard: 0, block: "*" },
+		);
+		assert.equal(
+			validateToolBudgetConfig({ soft: 0, hard: 0, block: "*" }, "toolBudget", { minimumHard: 0 }).error,
+			"toolBudget.soft must be an integer >= 1 when provided.",
+		);
+	});
+
 	it("rejects unsafe configs", () => {
 		assert.equal(validateToolBudgetConfig({ hard: 0 }).error, "toolBudget.hard must be an integer >= 1.");
 		assert.equal(validateToolBudgetConfig({ soft: 5, hard: 4 }).error, "toolBudget.soft must be <= toolBudget.hard.");
@@ -33,6 +44,9 @@ describe("tool-budget module", () => {
 	it("serializes and decodes env config", () => {
 		const budget = { soft: 2, hard: 4, block: ["read"] };
 		assert.deepEqual(decodeToolBudgetEnv(encodeToolBudgetEnv(budget)), budget);
+		const zeroBudget = { hard: 0, block: "*" as const };
+		assert.throws(() => decodeToolBudgetEnv(encodeToolBudgetEnv(zeroBudget)), /SELESAI_SUBAGENT_TOOL_BUDGET\.hard must be an integer >= 1/);
+		assert.deepEqual(decodeToolBudgetEnv(encodeToolBudgetEnv(zeroBudget), { allowZero: true }), zeroBudget);
 	});
 
 	it("tracks state and block decisions", () => {
@@ -42,6 +56,7 @@ describe("tool-budget module", () => {
 		assert.equal(toolBudgetState(budget, 4, "read").outcome, "hard-blocked");
 		assert.equal(shouldBlockToolForBudget(budget, "read", 4), true);
 		assert.equal(shouldBlockToolForBudget(budget, "write", 4), false);
+		assert.equal(shouldBlockToolForBudget({ hard: 0, block: "*" }, "read", 1), true);
 	});
 
 	it("formats user-facing budget messages", () => {

package/dist/extensions/pi-subagents/test/unit/tool-description.test.ts

@@ -34,6 +34,8 @@ describe("registered subagent tool description", () => {
 		for (const builtinName of ["scout", "worker", "planner"]) {
 			assert.doesNotMatch(description, new RegExp(`\\b${builtinName}\\b`));
 		}
+		assert.match(description, /^To delegate work, call with \{ agent, task \}, \{ tasks \}, or \{ chain \}; omit action\./i);
+		assert.match(description, /Use action only for management\/control actions listed below/i);
 		assert.match(description, /use \{ action: "list" \} to inspect configured agents\/chains/i);
 		assert.match(description, /executable\/non-disabled/i);
 		assert.match(description, /proactive skill subagent suggestions/i);
@@ -42,10 +44,17 @@ describe("registered subagent tool description", () => {
 		assert.match(description, /timeoutMs/i);
 		assert.match(description, /maxRuntimeMs/i);
 		assert.match(description, /foreground and async\/background runs/i);
+		assert.match(description, /omit acceptance for reviewer\/read-only calls/i);
+		assert.match(description, /acceptance\.review\.required/i);
+		assert.match(description, /reviewed is achieved only after an independent reviewer result/i);
 		assert.doesNotMatch(description, /only for foreground runs/i);
 		assert.doesNotMatch(description, /omit for async\/background runs/i);
 		assert.match(description, /SAFETY-CRITICAL SUBAGENT GUIDANCE/);
 		assert.match(description, /Do not sleep or poll status just to wait/i);
+		assert.match(description, /use subagent_wait/i);
+		assert.match(description, /interactive session.*normally return control/i);
+		assert.match(description, /Headless sessions auto-drain current-session work at agent_end/i);
+		assert.doesNotMatch(description, /MUST call subagent_wait/i);
 		assert.match(description, /ordinary child subagents are not orchestrators/i);
 		assert.match(description, /keep one writer/i);
 		assert.match(description, /view: "fleet"/);
@@ -54,31 +63,68 @@ describe("registered subagent tool description", () => {
 		assert.match(description, /schedule-list/);
 		assert.match(description, /action: "eject"/);
 		assert.match(description, /action: "disable"/);
+		assert.match(description, /action: "grant-spawn-budget"/);
+		assert.match(description, /root interactive parent/i);
+		assert.match(description, /cumulative grants cannot exceed the original configured cap/i);
+		assert.match(description, /acceptanceRole affects inferred acceptance only/i);
+		assert.match(description, /Explicit task mutation\/no-edit intent wins/i);
+		assert.match(description, /omission preserves name heuristics/i);
+		assert.match(description, /false or an empty string to clear it/i);
 		assert.match(description, /status\.json/);
 		assert.match(description, /events\.jsonl/);
+		// Chain quick-reference: both sequential and parallel fan-out examples (#417)
+		assert.match(description, /CHAIN EXAMPLES/i);
+		assert.match(
+			description,
+			/chain:\s*\[\s*\{\s*agent:\s*"[\w-]+",\s*task:\s*"[^"]*"\s*\}\s*,\s*\{\s*agent:\s*"[\w-]+",\s*task:\s*"[^"]*\{previous\}[^"]*"\s*\}\s*\]/,
+			"full mode should show a sequential chain example using {previous}",
+		);
+		assert.match(
+			description,
+			/\{\s*parallel:\s*\[\s*\{\s*agent:\s*"[\w-]+",\s*task:\s*"[^"]*",\s*count:\s*\d+\s*\}\s*\]\s*\}/,
+			"full mode should show a parallel fan-out chain example with count",
+		);
 	});
 
 	it("offers a compact mode that keeps safety-critical guidance", () => {
 		const description = buildSubagentToolDescription({ toolDescriptionMode: "compact" });
 
 		assert.equal(description, COMPACT_SUBAGENT_TOOL_DESCRIPTION);
+		assert.match(description, /^To delegate work, call with \{ agent, task \}, \{ tasks \}, or \{ chain \}; omit action\./i);
+		assert.match(description, /Use action only for management\/control actions listed below/i);
 		assert.ok(description.length < FULL_SUBAGENT_TOOL_DESCRIPTION.length * 0.8, "compact mode should be materially shorter than full mode");
 		assert.match(description, /SINGLE/);
 		assert.match(description, /PARALLEL/);
 		assert.match(description, /CHAIN/);
 		assert.match(description, /action without execution fields/i);
-		assert.match(description, /wait tool/i);
+		assert.match(description, /subagent_wait/i);
+		assert.match(description, /interactive session.*normally return control/i);
+		assert.match(description, /Non-interactive runs.*auto-drain current-session work at agent_end/i);
+		assert.doesNotMatch(description, /MUST call subagent_wait/i);
 		assert.match(description, /Do not sleep or poll/i);
 		assert.match(description, /ordinary child subagents are not orchestrators/i);
 		assert.match(description, /one writer/i);
+		assert.match(description, /omit acceptance for reviewer\/read-only calls/i);
+		assert.match(description, /acceptance\.review\.required/i);
+		assert.match(description, /reviewed is an achieved status/i);
 		assert.match(description, /view:"fleet"/);
 		assert.match(description, /view:"transcript"/);
 		assert.match(description, /steer/);
 		assert.match(description, /schedule-list/);
 		assert.match(description, /eject/);
 		assert.match(description, /disable/);
+		assert.match(description, /grant-spawn-budget/);
+		assert.match(description, /acceptanceRole.*affects inferred acceptance only/i);
+		assert.match(description, /Explicit task intent wins/i);
+		assert.match(description, /omission keeps name heuristics/i);
+		assert.match(description, /false or an empty string to clear it/i);
 		assert.match(description, /status\.json/);
 		assert.match(description, /events\.jsonl/);
+		// Compact mode keeps a chain quick-reference too (#417)
+		assert.match(description, /chain example/i);
+		assert.match(description, /\{previous\}/);
+		assert.match(description, /parallel:/);
+		assert.match(description, /count:/);
 	});
 
 	it("renders a custom project description with placeholders and mandatory safety guidance", () => {

package/dist/extensions/pi-subagents/test/unit/turn-budget.test.ts

@@ -6,7 +6,9 @@ import {
 	appendTurnBudgetSystemPrompt,
 	formatTurnBudgetOutput,
 	initialTurnBudgetState,
-	shouldAbortForTurnBudget,
+	resolveTurnBudgetConfig,
+	turnBudgetDecision,
+	turnBudgetDeferredState,
 	turnBudgetExceededMessage,
 	turnBudgetSoftNote,
 	turnBudgetState,
@@ -23,6 +25,29 @@ describe("turn-budget module", () => {
 		});
 	});
 
+	describe("resolveTurnBudgetConfig", () => {
+		it("resolves valid budgets and supplies the default grace turn", () => {
+			assert.deepEqual(resolveTurnBudgetConfig({ maxTurns: 5 }), {
+				turnBudget: { maxTurns: 5, graceTurns: 1 },
+			});
+			assert.deepEqual(resolveTurnBudgetConfig({ maxTurns: 5, graceTurns: 0 }), {
+				turnBudget: { maxTurns: 5, graceTurns: 0 },
+			});
+		});
+
+		it("rejects invalid values with the caller's boundary label", () => {
+			assert.deepEqual(resolveTurnBudgetConfig({ maxTurns: 0 }, "agent.turnBudget"), {
+				error: "agent.turnBudget.maxTurns must be an integer >= 1.",
+			});
+			assert.deepEqual(resolveTurnBudgetConfig({ maxTurns: 2, graceTurns: -1 }), {
+				error: "turnBudget.graceTurns must be an integer >= 0.",
+			});
+			assert.deepEqual(resolveTurnBudgetConfig({ maxTurns: 2, extra: true }), {
+				error: "turnBudget.extra is not supported.",
+			});
+		});
+	});
+
 	describe("appendTurnBudgetSystemPrompt", () => {
 		it("returns the system prompt unchanged when no budget is configured", () => {
 			assert.equal(appendTurnBudgetSystemPrompt("You are a reviewer.", undefined), "You are a reviewer.");
@@ -152,22 +177,43 @@ describe("turn-budget module", () => {
 		});
 	});
 
-	describe("shouldAbortForTurnBudget", () => {
-		it("allows a terminal assistant response on the final grace turn", () => {
-			assert.equal(shouldAbortForTurnBudget(budget({ maxTurns: 3, graceTurns: 1 }), 4, true), false);
+	describe("turnBudgetDecision", () => {
+		it("continues below the hard limit and for a terminal response on the final grace turn", () => {
+			assert.equal(turnBudgetDecision(budget({ maxTurns: 3, graceTurns: 1 }), 3, false, false), "continue");
+			assert.equal(turnBudgetDecision(budget({ maxTurns: 3, graceTurns: 1 }), 4, true, false), "continue");
+		});
+
+		it("defers termination when the hard-limit assistant response starts tool work", () => {
+			assert.equal(turnBudgetDecision(budget({ maxTurns: 3, graceTurns: 1 }), 4, false, true), "defer");
+			assert.equal(turnBudgetDecision(budget({ maxTurns: 3, graceTurns: 1 }), 5, false, true), "defer");
 		});
 
-		it("aborts a non-terminal assistant response on the final grace turn", () => {
-			assert.equal(shouldAbortForTurnBudget(budget({ maxTurns: 3, graceTurns: 1 }), 4, false), true);
+		it("enforces the hard limit for strict foreground delegation but allows the exact terminal boundary", () => {
+			assert.equal(turnBudgetDecision(budget({ maxTurns: 3, graceTurns: 1 }), 4, false, true, true), "abort");
+			assert.equal(turnBudgetDecision(budget({ maxTurns: 3, graceTurns: 1 }), 4, true, true, true), "continue");
 		});
 
-		it("aborts turns beyond the grace window even if the message is terminal", () => {
-			assert.equal(shouldAbortForTurnBudget(budget({ maxTurns: 3, graceTurns: 1 }), 5, true), true);
+		it("aborts at the next safe assistant boundary", () => {
+			assert.equal(turnBudgetDecision(budget({ maxTurns: 3, graceTurns: 1 }), 4, false, false), "abort");
+			assert.equal(turnBudgetDecision(budget({ maxTurns: 3, graceTurns: 1 }), 5, true, false), "abort");
 		});
 
 		it("allows a terminal response at the soft limit when grace turns are zero", () => {
-			assert.equal(shouldAbortForTurnBudget(budget({ maxTurns: 2, graceTurns: 0 }), 2, true), false);
-			assert.equal(shouldAbortForTurnBudget(budget({ maxTurns: 2, graceTurns: 0 }), 2, false), true);
+			assert.equal(turnBudgetDecision(budget({ maxTurns: 2, graceTurns: 0 }), 2, true, false), "continue");
+			assert.equal(turnBudgetDecision(budget({ maxTurns: 2, graceTurns: 0 }), 2, false, false), "abort");
+		});
+	});
+
+	describe("turnBudgetDeferredState", () => {
+		it("records the exact turn where hard termination became pending", () => {
+			assert.deepEqual(turnBudgetDeferredState(budget({ maxTurns: 2, graceTurns: 0 }), 2), {
+				maxTurns: 2,
+				graceTurns: 0,
+				turnCount: 2,
+				outcome: "termination-deferred",
+				wrapUpRequestedAtTurn: 2,
+				terminationDeferredAtTurn: 2,
+			});
 		});
 	});