@selesai/code 0.8.4 → 0.8.6

package/dist/extensions/pi-subagents/test/unit/single-output.test.ts

@@ -309,4 +309,32 @@ describe("finalizeSingleOutput", () => {
 
 		assert.equal(result.displayOutput, "truncated output");
 	});
+
+	it("preserves the saved-output reference for acceptance-only failures", () => {
+		const result = finalizeSingleOutput({
+			fullOutput: "useful output",
+			outputPath: "/tmp/review.md",
+			outputMode: "file-only",
+			exitCode: 1,
+			preserveSavedOutput: true,
+			savedPath: "/tmp/review.md",
+		});
+
+		assert.match(result.displayOutput, /^Output saved to:/);
+		assert.doesNotMatch(result.displayOutput, /useful output/);
+	});
+
+	it("does not duplicate an existing saved-output reference", () => {
+		const outputReference = formatSavedOutputReference("/tmp/review.md", "useful output");
+		const result = finalizeSingleOutput({
+			fullOutput: `useful output\n\n${outputReference.message}`,
+			outputPath: "/tmp/review.md",
+			exitCode: 1,
+			preserveSavedOutput: true,
+			savedPath: "/tmp/review.md",
+			outputReference,
+		});
+
+		assert.equal(result.displayOutput.match(/Output saved to:/g)?.length, 1);
+	});
 });

package/dist/extensions/pi-subagents/test/unit/steering-action.test.ts

@@ -2,11 +2,12 @@ import assert from "node:assert/strict";
 import * as fs from "node:fs";
 import * as os from "node:os";
 import * as path from "node:path";
-import { describe, it } from "node:test";
+import { afterEach, describe, it } from "node:test";
 import { writeAtomicJson, writePrivateAtomicJson } from "../../src/shared/atomic-json.ts";
 import { closeSteerInbox, interruptRequestPath, steerRequestsDir, writeSteerAck, type SteerRequest } from "../../src/runs/background/control-channel.ts";
 import { steerAsyncRun } from "../../src/runs/foreground/async-steering-action.ts";
 import { createSteeringStatus, recordSteeringRequest, updateSteeringTarget } from "../../src/runs/background/steering.ts";
+import { createRunFanoutBudget } from "../../src/runs/shared/run-fanout-budget.ts";
 import { ASYNC_DIR, type AsyncStatus, type Details, type SteeringRecoveryDescriptor, type SteeringTargetState, type SubagentState } from "../../src/shared/types.ts";
 
 function createState(): SubagentState {
@@ -29,6 +30,11 @@ function createState(): SubagentState {
 }
 
 let statusWriteMtimeMs = Date.now();
+const budgetDirectories: string[] = [];
+
+afterEach(() => {
+	for (const directory of budgetDirectories.splice(0)) fs.rmSync(directory, { recursive: true, force: true });
+});
 
 function writeStatus(asyncDir: string, status: AsyncStatus): void {
 	fs.mkdirSync(asyncDir, { recursive: true });
@@ -91,8 +97,11 @@ async function readRequest(asyncDir: string): Promise<SteerRequest> {
 }
 
 function recoveryDescriptor(runId: string): SteeringRecoveryDescriptor {
+	const runFanoutBudget = createRunFanoutBudget(runId, 64);
+	budgetDirectories.push(runFanoutBudget.directory);
 	return {
 		version: 1,
+		runFanoutBudget,
 		sourceRunId: runId,
 		agent: "worker-0",
 		cwd: os.tmpdir(),

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

@@ -61,6 +61,45 @@ describe("classifyTaskMutationIntent", () => {
 		assert.equal(classifyTaskMutationIntent("worker", "Create a summary").kind, "unknown");
 	});
 
+	it("does not read hyphenated fix adjectives as the fix verb", () => {
+		// Core regression: "must-fix items" in review output specs (fails on old code).
+		assert.equal(classifyTaskMutationIntent("worker", "Return a review with the top 2-3 must-fix items").kind, "unknown");
+		assert.equal(classifyTaskMutationIntent("worker", "Return a review with the top 2-3 must-fix items.").kind, "unknown");
+		assert.equal(classifyTaskMutationIntent("worker", "Review and report MUST-FIX items").kind, "unknown");
+		// should-fix with a noun from the pattern's alternation (also fails on old code).
+		assert.equal(classifyTaskMutationIntent("worker", "List should-fix tests with severity labels").kind, "unknown");
+		// Same class for other verbs: hyphenated adjective + verb.
+		assert.equal(classifyTaskMutationIntent("worker", "Return must-edit findings").kind, "unknown");
+		assert.equal(classifyTaskMutationIntent("worker", "Return must-update items").kind, "unknown");
+		assert.equal(classifyTaskMutationIntent("worker", "List should-add files").kind, "unknown");
+		assert.equal(classifyTaskMutationIntent("worker", "Return must-apply changes").kind, "unknown");
+		assert.equal(classifyTaskMutationIntent("worker", "List should-make changes").kind, "unknown");
+		assert.equal(classifyTaskMutationIntent("worker", "must-do those fixes").kind, "unknown");
+		// Dash coverage: U+2010 hyphen, U+2011 non-breaking hyphen, en/em dashes.
+		assert.equal(classifyTaskMutationIntent("worker", "Return the must\u2010fix items").kind, "unknown");
+		assert.equal(classifyTaskMutationIntent("worker", "Return the must\u2011fix items").kind, "unknown");
+		assert.equal(classifyTaskMutationIntent("worker", "Return the must\u2013fix items").kind, "unknown");
+		assert.equal(classifyTaskMutationIntent("worker", "Return the must\u2014fix items").kind, "unknown");
+		// Clause-level em/en dashes are punctuation, not compounds: "branch—fix it".
+		assert.equal(classifyTaskMutationIntent("worker", "Inspect the failing branch\u2014fix it.").kind, "implementation");
+		assert.equal(classifyTaskMutationIntent("worker", "Inspect the failing branch\u2013fix it.").kind, "implementation");
+		assert.equal(taskMayMutate("Inspect the failing branch\u2014fix it."), true);
+		// Hyphenated genuine imperatives stay write-capable.
+		assert.equal(taskMayMutate("hot-fix the bug"), true);
+		assert.equal(taskMayMutate("quick-fix that bug"), true);
+		// Genuine imperative usage keeps classifying as implementation.
+		assert.equal(classifyTaskMutationIntent("worker", "Go through the list and fix items one by one").kind, "implementation");
+		assert.equal(classifyTaskMutationIntent("worker", "fix items on the sprint board").kind, "implementation");
+		// CLI flags keep write intent: "--fix" / "-w" are not hyphenated adjectives.
+		assert.equal(classifyTaskMutationIntent("worker", "Run eslint --fix code").kind, "implementation");
+		assert.equal(taskMayMutate("Run eslint --fix code"), true);
+		// "--write" was never a classifier verb (pre-existing unknown); the
+		// regression guard is that write-capability survives for acceptance.
+		assert.equal(taskMayMutate("Run prettier --write files"), true);
+		// Guard-facing mirror: the completion guard must not expect mutation.
+		assert.equal(expectsImplementationMutation("worker", "Return a review with the top 2-3 must-fix items"), false);
+	});
+
 	it("expectsImplementationMutation mirrors the classifier", () => {
 		assert.equal(expectsImplementationMutation("worker", "Do not modify tests; implement the fix"), true);
 		assert.equal(expectsImplementationMutation("worker", "Review the diff and suggest fixes only. Do not edit files."), false);

package/dist/extensions/pi-subagents/test/unit/timeout-defaults.test.ts

@@ -3,6 +3,7 @@ import { describe, it } from "node:test";
 import {
 	DEFAULT_ASYNC_TIMEOUT_MS,
 	DEFAULT_FOREGROUND_TIMEOUT_MS,
+	resolveConfigDefaultTimeoutMs,
 	resolveSingleAgentLaunchTimeout,
 } from "../../src/runs/foreground/subagent-executor.ts";
 
@@ -70,4 +71,68 @@ describe("single-agent launch timeout wiring", () => {
 			{ timeoutMs: 5_000 },
 		);
 	});
+
+	const NINETY_MIN = 90 * 60 * 1000;
+
+	it("applies the global config default in place of the foreground backstop", () => {
+		assert.deepEqual(resolveSingleAgentLaunchTimeout({}, false, NINETY_MIN), {
+			timeoutMs: NINETY_MIN,
+		});
+	});
+
+	it("applies the global config default to composite foreground runs (parallel/chain)", () => {
+		assert.deepEqual(
+			resolveSingleAgentLaunchTimeout({ agent: "worker", task: "x", tasks: [{ agent: "worker", task: "y" }] }, false, NINETY_MIN),
+			{ timeoutMs: NINETY_MIN },
+		);
+		assert.deepEqual(
+			resolveSingleAgentLaunchTimeout({ agent: "worker", task: "x", chain: [{ agent: "worker", task: "y" }] }, false, NINETY_MIN),
+			{ timeoutMs: NINETY_MIN },
+		);
+	});
+
+	it("applies the global config default in place of the single-agent async backstop", () => {
+		assert.deepEqual(resolveSingleAgentLaunchTimeout({}, true, NINETY_MIN), {
+			timeoutMs: NINETY_MIN,
+		});
+	});
+
+	it("lets an explicit call timeout win over the global config default", () => {
+		assert.deepEqual(resolveSingleAgentLaunchTimeout({ timeoutMs: 5_000 }, false, NINETY_MIN), {
+			timeoutMs: 5_000,
+		});
+	});
+
+	it("keeps composite async runs unbounded even with a global config default", () => {
+		assert.deepEqual(
+			resolveSingleAgentLaunchTimeout({ agent: "worker", task: "x", tasks: [{ agent: "worker", task: "y" }] }, true, NINETY_MIN),
+			{},
+		);
+	});
+});
+
+describe("resolveConfigDefaultTimeoutMs", () => {
+	it("returns a positive integer unchanged", () => {
+		assert.equal(resolveConfigDefaultTimeoutMs(90 * 60 * 1000), 90 * 60 * 1000);
+	});
+
+	it("treats unset config as no default", () => {
+		assert.equal(resolveConfigDefaultTimeoutMs(undefined), undefined);
+	});
+
+	it("ignores non-positive, non-integer, and non-numeric values", () => {
+		assert.equal(resolveConfigDefaultTimeoutMs(0), undefined);
+		assert.equal(resolveConfigDefaultTimeoutMs(-1), undefined);
+		assert.equal(resolveConfigDefaultTimeoutMs(1.5), undefined);
+		assert.equal(resolveConfigDefaultTimeoutMs("600000" as unknown), undefined);
+		assert.equal(resolveConfigDefaultTimeoutMs(Number.NaN), undefined);
+	});
+
+	it("accepts the maximum schedulable timer delay but ignores anything larger", () => {
+		// 2_147_483_647 is the largest delay a Node.js timer can honor; above it
+		// setTimeout overflows to ~1ms and the run would expire almost immediately.
+		assert.equal(resolveConfigDefaultTimeoutMs(2_147_483_647), 2_147_483_647);
+		assert.equal(resolveConfigDefaultTimeoutMs(2_147_483_648), undefined);
+		assert.equal(resolveConfigDefaultTimeoutMs(Number.MAX_SAFE_INTEGER), undefined);
+	});
 });

package/dist/extensions/pi-subagents/test/unit/workflow-auto-relaunch.test.ts

@@ -0,0 +1,45 @@
+import assert from "node:assert/strict";
+import { describe, it } from "node:test";
+import {
+	DEFAULT_MAX_WORKFLOW_AUTO_RELAUNCHES,
+	resolveAutoRelaunchDecision,
+	resolveMaxWorkflowAutoRelaunches,
+} from "../../src/workflows/workflow-auto-relaunch.ts";
+
+describe("workflow auto-relaunch policy", () => {
+	it("relaunches on a budget result while under the cap", () => {
+		const decision = resolveAutoRelaunchDecision({ result: "budget", rounds: 3 }, 2, 12);
+		assert.deepEqual(decision, { relaunch: true, capped: false });
+	});
+
+	it("does not relaunch a clean result", () => {
+		const decision = resolveAutoRelaunchDecision({ result: "clean", rounds: 3 }, 0, 12);
+		assert.deepEqual(decision, { relaunch: false, capped: false });
+	});
+
+	it("does not relaunch non-workflow values", () => {
+		for (const value of [undefined, null, 5, "budget", ["budget"], { result: "failed" }]) {
+			const decision = resolveAutoRelaunchDecision(value, 0, 12);
+			assert.deepEqual(decision, { relaunch: false, capped: false });
+		}
+	});
+
+	it("marks the cap as reached when the relaunch count equals the cap", () => {
+		const decision = resolveAutoRelaunchDecision({ result: "budget" }, 12, 12);
+		assert.deepEqual(decision, { relaunch: false, capped: true });
+	});
+
+	it("relaunches indefinitely when the cap is unlimited", () => {
+		const decision = resolveAutoRelaunchDecision({ result: "budget" }, 50, undefined);
+		assert.deepEqual(decision, { relaunch: true, capped: false });
+	});
+
+	it("resolves the configured cap with a safe default and 0 as unlimited", () => {
+		assert.equal(resolveMaxWorkflowAutoRelaunches(undefined), DEFAULT_MAX_WORKFLOW_AUTO_RELAUNCHES);
+		assert.equal(resolveMaxWorkflowAutoRelaunches(5), 5);
+		assert.equal(resolveMaxWorkflowAutoRelaunches(0), undefined);
+		assert.equal(resolveMaxWorkflowAutoRelaunches(-3), DEFAULT_MAX_WORKFLOW_AUTO_RELAUNCHES);
+		assert.equal(resolveMaxWorkflowAutoRelaunches("12"), DEFAULT_MAX_WORKFLOW_AUTO_RELAUNCHES);
+		assert.equal(resolveMaxWorkflowAutoRelaunches(2.5), DEFAULT_MAX_WORKFLOW_AUTO_RELAUNCHES);
+	});
+});

package/dist/extensions/pi-subagents/test/unit/worktree.test.ts

@@ -125,6 +125,67 @@ describe("worktree", () => {
 		}
 	});
 
+	it("rejects worktree base directories inside Selesai extensions", () => {
+		const repoDir = createRepo("selesai-worktree-extension-dir-");
+		const tempHome = fs.mkdtempSync(path.join(os.tmpdir(), "selesai-worktree-home-"));
+		const previousAgentDir = process.env.SELESAI_CODING_AGENT_DIR;
+		const previousHome = process.env.HOME;
+		const previousUserProfile = process.env.USERPROFILE;
+		const extensionsDir = path.join(tempHome, ".selesai", "agent", "extensions");
+		try {
+			process.env.HOME = tempHome;
+			process.env.USERPROFILE = tempHome;
+			delete process.env.SELESAI_CODING_AGENT_DIR;
+			assert.throws(
+				() => createWorktrees(repoDir, "extension-dir", 1, { baseDir: extensionsDir }),
+				/worktree base directory cannot be inside Pi extensions directory/i,
+			);
+			assert.throws(
+				() => createWorktrees(repoDir, "extension-subdir", 1, { baseDir: path.join(extensionsDir, "checkout") }),
+				/worktree base directory cannot be inside Pi extensions directory/i,
+			);
+		} finally {
+			if (previousAgentDir === undefined) delete process.env.SELESAI_CODING_AGENT_DIR;
+			else process.env.SELESAI_CODING_AGENT_DIR = previousAgentDir;
+			if (previousHome === undefined) delete process.env.HOME;
+			else process.env.HOME = previousHome;
+			if (previousUserProfile === undefined) delete process.env.USERPROFILE;
+			else process.env.USERPROFILE = previousUserProfile;
+			cleanupRepo(repoDir);
+			fs.rmSync(tempHome, { recursive: true, force: true });
+		}
+	});
+
+	it("rejects symlinked worktree base directories inside Selesai extensions", () => {
+		const repoDir = createRepo("selesai-worktree-extension-symlink-");
+		const tempHome = fs.mkdtempSync(path.join(os.tmpdir(), "selesai-worktree-home-"));
+		const previousAgentDir = process.env.SELESAI_CODING_AGENT_DIR;
+		const previousHome = process.env.HOME;
+		const previousUserProfile = process.env.USERPROFILE;
+		const extensionsDir = path.join(tempHome, ".selesai", "agent", "extensions");
+		const aliasDir = path.join(tempHome, "extension-alias");
+		try {
+			process.env.HOME = tempHome;
+			process.env.USERPROFILE = tempHome;
+			delete process.env.SELESAI_CODING_AGENT_DIR;
+			fs.mkdirSync(extensionsDir, { recursive: true });
+			fs.symlinkSync(extensionsDir, aliasDir, process.platform === "win32" ? "junction" : "dir");
+			assert.throws(
+				() => createWorktrees(repoDir, "extension-symlink", 1, { baseDir: path.join(aliasDir, "checkout") }),
+				/worktree base directory cannot be inside Pi extensions directory/i,
+			);
+		} finally {
+			if (previousAgentDir === undefined) delete process.env.SELESAI_CODING_AGENT_DIR;
+			else process.env.SELESAI_CODING_AGENT_DIR = previousAgentDir;
+			if (previousHome === undefined) delete process.env.HOME;
+			else process.env.HOME = previousHome;
+			if (previousUserProfile === undefined) delete process.env.USERPROFILE;
+			else process.env.USERPROFILE = previousUserProfile;
+			cleanupRepo(repoDir);
+			fs.rmSync(tempHome, { recursive: true, force: true });
+		}
+	});
+
 	it("uses SELESAI_SUBAGENTS_WORKTREE_DIR when no base directory is configured", () => {
 		const repoDir = createRepo("pi-worktree-env-base-dir-");
 		const previous = process.env.SELESAI_SUBAGENTS_WORKTREE_DIR;

package/dist/extensions/ponytail/index.js

@@ -16,6 +16,9 @@ export { filterSkillBodyForMode };
 export const readDefaultMode = getDefaultMode;
 
 export function resolveSessionMode(entries, fallbackMode = DEFAULT_MODE) {
+  // Unreachable: normalizePersistedMode always returns a valid mode or null,
+  // and the caller passes a valid default.
+  /* v8 ignore next 1 */
   const fallback = normalizePersistedMode(fallbackMode) || DEFAULT_MODE;
   if (!Array.isArray(entries)) return fallback;
 
@@ -59,6 +62,9 @@ export default function ponytailExtension(pi) {
 
   const setMode = (mode, ctx) => {
     const normalized = normalizePersistedMode(mode);
+    // Unreachable: setMode is only called with validated modes from the
+    // command handler and the deactivation input handler.
+    /* v8 ignore next 1 */
     if (!normalized) return;
 
     currentMode = normalized;
@@ -68,6 +74,8 @@ export default function ponytailExtension(pi) {
 
   const sendAlias = (skillName, args, ctx) => {
     const normalized = String(args || "").trim();
+    // Unreachable: the alias command handlers always pass empty args.
+    /* v8 ignore next 1 */
     const message = normalized ? `${skillName} ${normalized}` : skillName;
 
     if (ctx?.isIdle?.() === false) {
@@ -91,6 +99,9 @@ export default function ponytailExtension(pi) {
 
       if (parsed.type === "set-default") {
         const written = writeDefaultMode(parsed.mode);
+        // Unreachable: parsePonytailCommand only returns set-default for
+        // valid config modes, so writeDefaultMode always succeeds.
+        /* v8 ignore next 1 */
         if (written) {
           configuredDefaultMode = getDefaultMode();
           const message = configuredDefaultMode === written

package/dist/extensions/ponytail/ponytail-config.cjs

@@ -57,6 +57,8 @@ function getConfigDir() {
   }
   if (process.platform === 'win32') {
     return path.join(
+      // Unreachable: APPDATA is always set on Windows.
+      /* v8 ignore next 1 */
       process.env.APPDATA || path.join(os.homedir(), 'AppData', 'Roaming'),
       'ponytail'
     );

package/dist/extensions/ponytail/ponytail-instructions.cjs

@@ -14,6 +14,9 @@ const COMPACT_MODE_RULES = {
 };
 
 function filterSkillBodyForMode(body, mode) {
+  // Unreachable: normalizeMode returns a valid mode or null, and the caller
+  // passes a valid mode.
+  /* v8 ignore next 1 */
   const effectiveMode = normalizeMode(mode) || DEFAULT_MODE;
   const withoutFrontmatter = String(body || '').replace(/^---[\s\S]*?---\s*/, '');
 
@@ -90,6 +93,9 @@ function getPonytailInstructions(mode, options) {
     return 'PONYTAIL MODE ACTIVE — level: ' + configuredMode + '. Behavior defined by /ponytail-' + configuredMode + ' skill.';
   }
 
+  // Unreachable: normalizePersistedMode above already falls back to
+  // DEFAULT_MODE, so normalizeMode always returns a valid mode here.
+  /* v8 ignore next 1 */
   const effectiveMode = normalizeMode(configuredMode) || DEFAULT_MODE;
   if (options?.compact === true) return getCompactInstructions(effectiveMode);