@selesai/code 0.2.1 → 0.3.1

package/dist/extensions/pi-subagents/test/unit/stale-run-reconciler.test.ts

@@ -0,0 +1,255 @@
+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 { checkPidLiveness, reconcileAsyncRun } from "../../src/runs/background/stale-run-reconciler.ts";
+
+function tempRoot(prefix: string): string {
+	return fs.mkdtempSync(path.join(os.tmpdir(), prefix));
+}
+
+function writeStatus(asyncDir: string, status: Record<string, unknown>): void {
+	fs.mkdirSync(asyncDir, { recursive: true });
+	fs.writeFileSync(path.join(asyncDir, "status.json"), JSON.stringify(status, null, 2), "utf-8");
+}
+
+function errno(code: string): NodeJS.ErrnoException {
+	const error = new Error(code) as NodeJS.ErrnoException;
+	error.code = code;
+	return error;
+}
+
+describe("async stale-run reconciliation", () => {
+	it("classifies pid liveness without treating EPERM as dead", () => {
+		assert.equal(checkPidLiveness(123, () => true), "alive");
+		assert.equal(checkPidLiveness(123, () => { throw errno("ESRCH"); }), "dead");
+		assert.equal(checkPidLiveness(123, () => { throw errno("EPERM"); }), "unknown");
+		assert.equal(checkPidLiveness(123, () => { throw new Error("boom"); }), "unknown");
+	});
+
+	it("marks a running async run failed when the runner pid is dead and no result exists", () => {
+		const root = tempRoot("pi-stale-run-");
+		try {
+			const asyncDir = path.join(root, "run-dead");
+			const resultsDir = path.join(root, "results");
+			writeStatus(asyncDir, {
+				runId: "run-dead",
+				sessionId: "session-current",
+				mode: "single",
+				state: "running",
+				pid: 12345,
+				startedAt: 1000,
+				lastUpdate: 1000,
+				currentStep: 0,
+				steps: [{ agent: "scout", status: "running", startedAt: 1000 }],
+			});
+
+			const result = reconcileAsyncRun(asyncDir, {
+				resultsDir,
+				kill: () => { throw errno("ESRCH"); },
+				now: () => 2000,
+			});
+
+			assert.equal(result.repaired, true);
+			assert.equal(result.status?.state, "failed");
+			assert.match(result.message ?? "", /process 12345 exited or disappeared/);
+			const status = JSON.parse(fs.readFileSync(path.join(asyncDir, "status.json"), "utf-8"));
+			assert.equal(status.state, "failed");
+			assert.equal(status.sessionId, "session-current");
+			assert.equal(status.steps[0].status, "failed");
+			assert.match(status.steps[0].error, /process 12345 exited or disappeared/);
+			const resultJson = JSON.parse(fs.readFileSync(path.join(resultsDir, "run-dead.json"), "utf-8"));
+			assert.equal(resultJson.success, false);
+			assert.equal(resultJson.sessionId, "session-current");
+			assert.equal(resultJson.state, "failed");
+			assert.equal(resultJson.exitCode, 1);
+			assert.match(resultJson.summary, /process 12345 exited or disappeared/);
+			assert.match(fs.readFileSync(path.join(asyncDir, "events.jsonl"), "utf-8"), /subagent\.run\.repaired_stale/);
+		} finally {
+			fs.rmSync(root, { recursive: true, force: true });
+		}
+	});
+
+	it("includes runner stderr diagnostics when repairing a stale startup crash", () => {
+		const root = tempRoot("pi-stale-run-stderr-");
+		try {
+			const asyncDir = path.join(root, "run-dead-stderr");
+			const resultsDir = path.join(root, "results");
+			writeStatus(asyncDir, {
+				runId: "run-dead-stderr",
+				mode: "single",
+				state: "running",
+				pid: 12345,
+				startedAt: 1000,
+				lastUpdate: 1000,
+				currentStep: 0,
+				steps: [{ agent: "scout", status: "running", startedAt: 1000 }],
+			});
+			fs.writeFileSync(path.join(asyncDir, "runner.stderr.log"), "startup failed\nmissing peer package\n", "utf-8");
+
+			const result = reconcileAsyncRun(asyncDir, {
+				resultsDir,
+				kill: () => { throw errno("ESRCH"); },
+				now: () => 2000,
+			});
+
+			assert.equal(result.repaired, true);
+			assert.match(result.message ?? "", /Runner stderr tail:/);
+			assert.match(result.message ?? "", /missing peer package/);
+			const status = JSON.parse(fs.readFileSync(path.join(asyncDir, "status.json"), "utf-8"));
+			assert.match(status.steps[0].error, /missing peer package/);
+			const resultJson = JSON.parse(fs.readFileSync(path.join(resultsDir, "run-dead-stderr.json"), "utf-8"));
+			assert.match(resultJson.summary, /missing peer package/);
+		} finally {
+			fs.rmSync(root, { recursive: true, force: true });
+		}
+	});
+
+	it("keeps stale repair successful when the event log cannot be appended", () => {
+		const root = tempRoot("pi-stale-event-log-collision-");
+		try {
+			const asyncDir = path.join(root, "run-dead-events-dir");
+			const resultsDir = path.join(root, "results");
+			writeStatus(asyncDir, {
+				runId: "run-dead-events-dir",
+				mode: "single",
+				state: "running",
+				pid: 12345,
+				startedAt: 1000,
+				lastUpdate: 1000,
+				currentStep: 0,
+				steps: [{ agent: "worker", status: "running", startedAt: 1000 }],
+			});
+			fs.mkdirSync(path.join(asyncDir, "events.jsonl"));
+
+			const result = reconcileAsyncRun(asyncDir, {
+				resultsDir,
+				kill: () => { throw errno("ESRCH"); },
+				now: () => 2000,
+			});
+
+			assert.equal(result.repaired, true);
+			assert.equal(result.status?.state, "failed");
+			assert.equal(JSON.parse(fs.readFileSync(path.join(asyncDir, "status.json"), "utf-8")).state, "failed");
+			assert.equal(JSON.parse(fs.readFileSync(path.join(resultsDir, "run-dead-events-dir.json"), "utf-8")).success, false);
+			assert.equal(fs.statSync(path.join(asyncDir, "events.jsonl")).isDirectory(), true);
+		} finally {
+			fs.rmSync(root, { recursive: true, force: true });
+		}
+	});
+
+	it("repairs stale status with per-child result outcomes", () => {
+		const root = tempRoot("pi-stale-mixed-result-");
+		try {
+			const asyncDir = path.join(root, "run-mixed");
+			const resultsDir = path.join(root, "results");
+			fs.mkdirSync(resultsDir, { recursive: true });
+			writeStatus(asyncDir, {
+				runId: "run-mixed",
+				mode: "chain",
+				state: "running",
+				pid: 12345,
+				startedAt: 1000,
+				lastUpdate: 1000,
+				steps: [
+					{ agent: "scout", status: "running", startedAt: 1000 },
+					{ agent: "worker", status: "running", startedAt: 1100 },
+				],
+			});
+			const scoutSession = path.join(root, "scout.jsonl");
+			const workerSession = path.join(root, "worker.jsonl");
+			fs.writeFileSync(path.join(resultsDir, "run-mixed.json"), JSON.stringify({
+				id: "run-mixed",
+				success: false,
+				state: "failed",
+				results: [
+					{ agent: "scout", success: true, sessionFile: scoutSession, model: "fast" },
+					{ agent: "worker", success: false, error: "boom", sessionFile: workerSession, model: "careful" },
+				],
+			}, null, 2), "utf-8");
+
+			const result = reconcileAsyncRun(asyncDir, {
+				resultsDir,
+				kill: () => { throw errno("ESRCH"); },
+				now: () => 2000,
+			});
+
+			assert.equal(result.repaired, true);
+			assert.equal(result.status?.state, "failed");
+			assert.equal(result.status?.steps?.[0]?.status, "complete");
+			assert.equal(result.status?.steps?.[0]?.exitCode, 0);
+			assert.equal(result.status?.steps?.[0]?.model, "fast");
+			assert.equal(result.status?.steps?.[0]?.sessionFile, scoutSession);
+			assert.equal(result.status?.steps?.[1]?.status, "failed");
+			assert.equal(result.status?.steps?.[1]?.exitCode, 1);
+			assert.equal(result.status?.steps?.[1]?.error, "boom");
+			assert.equal(result.status?.steps?.[1]?.model, "careful");
+			assert.equal(result.status?.steps?.[1]?.sessionFile, workerSession);
+		} finally {
+			fs.rmSync(root, { recursive: true, force: true });
+		}
+	});
+
+	it("fails a stale run when a live pid has not updated beyond the stale threshold", () => {
+		const root = tempRoot("pi-stale-live-pid-");
+		try {
+			const asyncDir = path.join(root, "run-reused-pid");
+			const resultsDir = path.join(root, "results");
+			writeStatus(asyncDir, {
+				runId: "run-reused-pid",
+				mode: "single",
+				state: "running",
+				pid: 12345,
+				startedAt: 1000,
+				lastUpdate: 1000,
+				steps: [{ agent: "worker", status: "running", startedAt: 1000 }],
+			});
+
+			const result = reconcileAsyncRun(asyncDir, {
+				resultsDir,
+				kill: () => true,
+				now: () => 5000,
+				staleAlivePidMs: 1000,
+			});
+
+			assert.equal(result.repaired, true);
+			assert.equal(result.status?.state, "failed");
+			assert.match(result.message ?? "", /live PID, but status has not updated/);
+		} finally {
+			fs.rmSync(root, { recursive: true, force: true });
+		}
+	});
+
+	it("preserves an existing result instead of overwriting it with stale-run failure", () => {
+		const root = tempRoot("pi-stale-existing-result-");
+		try {
+			const asyncDir = path.join(root, "run-result");
+			const resultsDir = path.join(root, "results");
+			fs.mkdirSync(resultsDir, { recursive: true });
+			writeStatus(asyncDir, {
+				runId: "run-result",
+				mode: "single",
+				state: "running",
+				pid: 12345,
+				startedAt: 1000,
+				lastUpdate: 1000,
+				steps: [{ agent: "worker", status: "running", startedAt: 1000 }],
+			});
+			const resultPath = path.join(resultsDir, "run-result.json");
+			fs.writeFileSync(resultPath, JSON.stringify({ id: "run-result", success: true, state: "complete", summary: "already done" }, null, 2), "utf-8");
+
+			const result = reconcileAsyncRun(asyncDir, {
+				resultsDir,
+				kill: () => { throw errno("ESRCH"); },
+				now: () => 2000,
+			});
+
+			assert.equal(result.repaired, true);
+			assert.equal(result.status?.state, "complete");
+			assert.equal(JSON.parse(fs.readFileSync(resultPath, "utf-8")).summary, "already done");
+		} finally {
+			fs.rmSync(root, { recursive: true, force: true });
+		}
+	});
+});

package/dist/extensions/pi-subagents/test/unit/status-format.test.ts

@@ -0,0 +1,19 @@
+import assert from "node:assert/strict";
+import { describe, it } from "node:test";
+import { aggregateStepStatus, formatActivityLabel, formatParallelOutcome } from "../../src/shared/status-format.ts";
+import type { AsyncJobStep } from "../../src/shared/types.ts";
+
+describe("status format helpers", () => {
+	it("formats activity labels consistently", () => {
+		assert.equal(formatActivityLabel(1_000, undefined, 1_500), "active now");
+		assert.equal(formatActivityLabel(1_000, "needs_attention", 4_000), "no activity for 3s");
+		assert.equal(formatActivityLabel(undefined, "active_long_running", 4_000), "active but long-running");
+	});
+
+	it("aggregates step status and parallel outcomes", () => {
+		const steps = [{ status: "complete" }, { status: "running" }, { status: "failed" }] satisfies Array<Pick<AsyncJobStep, "status">>;
+		assert.equal(aggregateStepStatus(steps), "running");
+		assert.equal(formatParallelOutcome(steps, 3), "1 agent running · 1/3 done · 1 failed");
+		assert.equal(formatParallelOutcome(steps, 3, { showRunning: false }), "1/3 done · 1 failed");
+	});
+});

package/dist/extensions/pi-subagents/test/unit/subagent-control.test.ts

@@ -0,0 +1,245 @@
+import assert from "node:assert/strict";
+import { describe, it } from "node:test";
+import {
+	buildControlEvent,
+	claimControlNotification,
+	controlNotificationKey,
+	deriveActivityState,
+	formatControlIntercomMessage,
+	formatControlNoticeMessage,
+	resolveControlConfig,
+	shouldNotifyControlEvent,
+} from "../../src/runs/shared/subagent-control.ts";
+import { nextLongRunningTrigger } from "../../src/runs/shared/long-running-guard.ts";
+
+const config = resolveControlConfig(undefined, {
+	needsAttentionAfterMs: 300,
+});
+
+describe("subagent control attention state", () => {
+	it("marks a run as needing attention only after the idle threshold", () => {
+		assert.equal(deriveActivityState({ config, startedAt: 0, lastActivityAt: 0, now: 50 }), undefined);
+		assert.equal(deriveActivityState({ config, startedAt: 0, lastActivityAt: 0, now: 400 }), "needs_attention");
+		assert.equal(deriveActivityState({ config, startedAt: 0, now: 400 }), "needs_attention");
+	});
+
+
+	it("builds compact needs-attention control events", () => {
+		const event = buildControlEvent({
+			to: "needs_attention",
+			runId: "run-1",
+			agent: "worker",
+			index: 2,
+			ts: 1_000,
+			lastActivityAt: 100,
+		});
+		assert.deepEqual(event, {
+			type: "needs_attention",
+			to: "needs_attention",
+			ts: 1_000,
+			runId: "run-1",
+			agent: "worker",
+			index: 2,
+			message: "worker needs attention (no observed activity for 0s)",
+			reason: "idle",
+			elapsedMs: 900,
+		});
+	});
+
+	it("supports a specific attention message", () => {
+		const event = buildControlEvent({
+			to: "needs_attention",
+			runId: "run-1",
+			agent: "worker",
+			message: "worker completed without making edits for an implementation task",
+		});
+
+		assert.equal(event.message, "worker completed without making edits for an implementation task");
+	});
+
+	it("builds terminal completion guard control events", () => {
+		const event = buildControlEvent({
+			to: "needs_attention",
+			runId: "run-1",
+			agent: "worker",
+			message: "worker completed without making edits for an implementation task",
+			reason: "completion_guard",
+		});
+
+		assert.equal(event.reason, "completion_guard");
+	});
+
+	it("defaults notifications to active-long-running and needs attention", () => {
+		const event = buildControlEvent({ to: "needs_attention", runId: "run-1", agent: "worker" });
+		const activeEvent = buildControlEvent({ type: "active_long_running", to: "active_long_running", runId: "run-1", agent: "worker" });
+		assert.equal(shouldNotifyControlEvent(config, event), true);
+		assert.equal(shouldNotifyControlEvent(config, activeEvent), true);
+		assert.deepEqual(config.notifyOn, ["active_long_running", "needs_attention"]);
+		assert.deepEqual(config.notifyChannels, ["event", "async", "intercom"]);
+	});
+
+	it("defaults active-long-running notices to elapsed time only", () => {
+		const defaults = resolveControlConfig();
+
+		assert.equal(defaults.activeNoticeAfterMs, 240_000);
+		assert.equal(defaults.activeNoticeAfterTurns, undefined);
+		assert.equal(defaults.activeNoticeAfterTokens, undefined);
+		assert.equal(nextLongRunningTrigger(defaults, {
+			startedAt: 0,
+			now: 77_000,
+			turns: 50,
+			tokens: 800_000,
+		}), undefined);
+		assert.equal(nextLongRunningTrigger(defaults, {
+			startedAt: 0,
+			now: 240_000,
+			turns: 1,
+			tokens: 1,
+		}), "time_threshold");
+	});
+
+	it("supports opt-in turn and token long-running thresholds", () => {
+		const tokenBudget = resolveControlConfig(undefined, { activeNoticeAfterMs: 999_999, activeNoticeAfterTokens: 500_000 });
+		const turnBudget = resolveControlConfig(undefined, { activeNoticeAfterMs: 999_999, activeNoticeAfterTurns: 5 });
+
+		assert.equal(nextLongRunningTrigger(tokenBudget, {
+			startedAt: 0,
+			now: 77_000,
+			turns: 1,
+			tokens: 500_000,
+		}), "token_threshold");
+		assert.equal(nextLongRunningTrigger(turnBudget, {
+			startedAt: 0,
+			now: 77_000,
+			turns: 5,
+			tokens: 1,
+		}), "turn_threshold");
+	});
+
+	it("resolves custom notification config", () => {
+		const custom = resolveControlConfig(undefined, {
+			needsAttentionAfterMs: 1234,
+			activeNoticeAfterMs: 2345,
+			activeNoticeAfterTurns: 7,
+			activeNoticeAfterTokens: 8000,
+			failedToolAttemptsBeforeAttention: 4,
+			notifyOn: ["active_long_running", "needs_attention", "nope" as never],
+			notifyChannels: ["event", "intercom", "bad" as never],
+		});
+		assert.equal(custom.needsAttentionAfterMs, 1234);
+		assert.equal(custom.activeNoticeAfterMs, 2345);
+		assert.equal(custom.activeNoticeAfterTurns, 7);
+		assert.equal(custom.activeNoticeAfterTokens, 8000);
+		assert.equal(custom.failedToolAttemptsBeforeAttention, 4);
+		assert.deepEqual(custom.notifyOn, ["active_long_running", "needs_attention"]);
+		assert.deepEqual(custom.notifyChannels, ["event", "intercom"]);
+	});
+
+	it("falls back to defaults for invalid non-empty notification arrays", () => {
+		const custom = resolveControlConfig(undefined, {
+			notifyOn: ["bogus" as never],
+			notifyChannels: ["bogus" as never],
+		});
+		assert.deepEqual(custom.notifyOn, ["active_long_running", "needs_attention"]);
+		assert.deepEqual(custom.notifyChannels, ["event", "async", "intercom"]);
+	});
+
+	it("allows empty notification arrays to disable notifications", () => {
+		const custom = resolveControlConfig(undefined, {
+			notifyOn: [],
+			notifyChannels: [],
+		});
+		const event = buildControlEvent({ to: "needs_attention", runId: "run-1", agent: "worker" });
+		assert.deepEqual(custom.notifyOn, []);
+		assert.deepEqual(custom.notifyChannels, []);
+		assert.equal(shouldNotifyControlEvent(custom, event), false);
+	});
+
+	it("formats control notices with a proactive hint and concrete commands", () => {
+		const event = buildControlEvent({ to: "needs_attention", runId: "78f659a3", agent: "worker" });
+
+		const message = formatControlNoticeMessage(event, "subagent-worker-78f659a3");
+
+		assert.match(message, /Subagent needs attention: worker/);
+		assert.match(message, /Hint: Inspect status first unless the run is clearly blocked/);
+		assert.match(message, /Live async nudges interrupt the child before sending the follow-up/);
+		assert.match(message, /Nudge: subagent\(\{ action: "resume", id: "78f659a3", message: "What are you blocked on\?/);
+		assert.match(message, /Direct intercom target: subagent-worker-78f659a3/);
+		assert.match(message, /Status: subagent\(\{ action: "status", id: "78f659a3" \}\)/);
+		assert.match(message, /Interrupt: subagent\(\{ action: "interrupt", id: "78f659a3" \}\)/);
+		assert.doesNotMatch(message, /Wait:/);
+	});
+
+	it("formats active-long-running notices as informational", () => {
+		const event = buildControlEvent({
+			type: "active_long_running",
+			to: "active_long_running",
+			runId: "78f659a3",
+			agent: "worker",
+			turns: 15,
+			tokens: 160000,
+			toolCount: 42,
+			currentTool: "edit",
+			currentPath: "src/runs/background/async-status.ts",
+			reason: "turn_threshold",
+		});
+
+		const message = formatControlNoticeMessage(event, "subagent-worker-78f659a3-1");
+
+		assert.match(message, /Subagent active but long-running: worker/);
+		assert.match(message, /Inspect status/);
+		assert.match(message, /Nudge: subagent\(\{ action: "resume", id: "78f659a3", message: "What are you blocked on\?/);
+		assert.match(message, /15 turns/);
+		assert.match(message, /160000 tokens/);
+		assert.match(message, /path src\/runs\/background\/async-status\.ts/);
+		assert.doesNotMatch(message, /Subagent needs attention/);
+	});
+
+	it("formats terminal completion guard notices without live-run commands", () => {
+		const event = buildControlEvent({
+			to: "needs_attention",
+			runId: "78f659a3",
+			agent: "worker",
+			index: 0,
+			message: "worker completed without making edits for an implementation task",
+			reason: "completion_guard",
+		});
+
+		const message = formatControlNoticeMessage(event, "subagent-worker-78f659a3-1");
+
+		assert.match(message, /Subagent failed: worker/);
+		assert.match(message, /read the output artifact or session/);
+		assert.match(message, /Run intercom target \(may be inactive\): subagent-worker-78f659a3-1/);
+		assert.doesNotMatch(message, /Status:/);
+		assert.doesNotMatch(message, /Interrupt:/);
+		assert.doesNotMatch(message, /What are you blocked on/);
+	});
+
+	it("formats intercom notifications with the same control commands", () => {
+		const event = buildControlEvent({ to: "needs_attention", runId: "78f659a3", agent: "worker" });
+
+		const message = formatControlIntercomMessage(event, "subagent-worker-78f659a3");
+
+		assert.match(message, /worker needs attention in run 78f659a3/);
+		assert.match(message, /Nudge: subagent\(\{ action: "resume", id: "78f659a3", message: "What are you blocked on\?/);
+	});
+
+	it("dedupes notifications once per child target and attention state", () => {
+		const event = buildControlEvent({ to: "needs_attention", runId: "run-1", agent: "worker", index: 0 });
+		const seen = new Set<string>();
+
+		assert.equal(controlNotificationKey(event, "subagent-worker-run-1-1"), "subagent-worker-run-1-1:needs_attention:idle");
+		assert.equal(claimControlNotification(resolveControlConfig(), event, seen, "subagent-worker-run-1-1"), true);
+		assert.equal(claimControlNotification(resolveControlConfig(), event, seen, "subagent-worker-run-1-1"), false);
+
+		const terminalEvent = buildControlEvent({
+			to: "needs_attention",
+			runId: "run-1",
+			agent: "worker",
+			index: 0,
+			message: "worker completed without making edits for an implementation task",
+			reason: "completion_guard",
+		});
+		assert.equal(claimControlNotification(resolveControlConfig(), terminalEvent, seen, "subagent-worker-run-1-1"), true);
+	});
+});