@selesai/code 0.8.5 → 0.8.6

package/dist/extensions/pi-subagents/src/shared/session-lineage.ts

@@ -0,0 +1,71 @@
+import * as fs from "node:fs";
+
+/**
+ * Resolve the chain of session identities whose workflow estate the current
+ * session should adopt. Session files record their parent in the header's
+ * `parentSession` field, so a fresh session created by handoff/new/fork can
+ * walk back to every predecessor and re-attach its persisted async runs,
+ * results, retained children, and wait subscriptions.
+ */
+
+export interface SessionLineageInput {
+	sessionManager: {
+		getSessionFile(): string | null | undefined;
+		getHeader?(): { parentSession?: string | null } | null;
+	};
+}
+
+export interface SessionLineageOptions {
+	/** Maximum number of session identities retained in the lineage. Defaults to 8. */
+	depth?: number;
+	/** Explicit parent session file (e.g. SessionStartEvent.previousSessionFile). */
+	parentHint?: string | null;
+}
+
+const MAX_HEADER_BYTES = 2048;
+
+function readParentSessionHeader(sessionFile: string): string | undefined {
+	let text: string;
+	try {
+		const fd = fs.openSync(sessionFile, "r");
+		try {
+			const buffer = Buffer.alloc(MAX_HEADER_BYTES);
+			const read = fs.readSync(fd, buffer, 0, buffer.length, 0);
+			text = buffer.subarray(0, read).toString("utf-8");
+		} finally {
+			fs.closeSync(fd);
+		}
+	} catch {
+		return undefined;
+	}
+	const newline = text.indexOf("\n");
+	const line = newline >= 0 ? text.slice(0, newline) : text;
+	if (!line.trim()) return undefined;
+	try {
+		const header = JSON.parse(line) as { type?: unknown; parentSession?: unknown };
+		if (header.type !== "session") return undefined;
+		return typeof header.parentSession === "string" && header.parentSession ? header.parentSession : undefined;
+	} catch {
+		return undefined;
+	}
+}
+
+export function resolveSessionLineage(input: SessionLineageInput, options: SessionLineageOptions = {}): string[] {
+	const depth = Math.max(1, Math.floor(options.depth ?? 8));
+	const lineage: string[] = [];
+	const seen = new Set<string>();
+	const current = input.sessionManager.getSessionFile();
+	if (current) {
+		lineage.push(current);
+		seen.add(current);
+	}
+	let parent = options.parentHint ?? input.sessionManager.getHeader?.()?.parentSession;
+	if (!parent && current) parent = readParentSessionHeader(current);
+	while (parent && lineage.length < depth && !seen.has(parent)) {
+		if (!fs.existsSync(parent)) break;
+		lineage.push(parent);
+		seen.add(parent);
+		parent = readParentSessionHeader(parent);
+	}
+	return lineage;
+}

package/dist/extensions/pi-subagents/src/shared/types.ts

@@ -1361,6 +1361,8 @@ export interface AsyncStatus {
 	pendingAppends?: number;
 	parallelGroups?: AsyncParallelGroupStatus[];
 	workflowGraph?: WorkflowGraphSnapshot;
+	/** Auto-relaunch count when a workflow budget result triggered a fresh top-level run. */
+	workflowRelaunchCount?: number;
 	checkpoint?: ChainCheckpointState;
 	processTerminal?: ProcessTerminalV1;
 	runFanoutBudget?: RunFanoutBudgetSnapshot;
@@ -1460,6 +1462,8 @@ export type AsyncJobStep = NonNullable<AsyncStatus["steps"]>[number] & {
 export interface AsyncJobState {
 	asyncId: string;
 	asyncDir: string;
+	/** True when the job was adopted from a previous session via lineage carry-over. */
+	adopted?: boolean;
 	/** Parent-resolved launch directory retained for trusted live artifact lookup. */
 	cwd?: string;
 	status: "queued" | "running" | "complete" | "failed" | "paused" | "stopped" | "rejected";
@@ -1654,6 +1658,12 @@ export interface ActiveAsyncCapacitySnapshot {
 export interface SubagentState {
 	baseCwd: string;
 	currentSessionId: string | null;
+	/** Ordered session identities (session file paths) whose workflow estate this session adopts, self first. */
+	sessionLineage?: string[];
+	/** Earliest result-file mtime eligible for adoption from lineage sessions (replay guard). */
+	adoptedResultWindowStart?: number;
+	/** Set when a session switch adopted live workflows; consumed on the first settled turn to inject a carry-over summary. */
+	handoffResumePending?: boolean;
 	/** Runtime-owned artifact resolution inputs used by Fleet transcript targeting. */
 	artifactDirPreference?: ArtifactDirPreference;
 	/** Runtime authority snapshot used by optional inspector controls. */
@@ -1907,6 +1917,12 @@ export interface ExtensionConfig {
 	maxSubagentSpawnsPerSession?: number;
 	/** Cumulative logical-child cap for one top-level run tree. Defaults to 64. */
 	maxSubagentSpawnsPerRun?: number;
+	/**
+	 * Max auto-relaunches when a scripted workflow ends with a fan-out budget
+	 * result before the goal is clean. Each relaunch is a fresh top-level run
+	 * with a new fan-out budget. Defaults to 12; 0 means unlimited.
+	 */
+	maxWorkflowAutoRelaunches?: number;
 	/** Optional active top-level async run cap per parent session. Unset or 0 means unlimited. */
 	maxActiveAsyncRunsPerSession?: number;
 	/** Global cap on simultaneously-running subagent tasks within a single run. Defaults to 20. */

package/dist/extensions/pi-subagents/src/tui/fleet.ts

@@ -239,7 +239,7 @@ export function collectFleetSnapshot(
 		if (options.asyncDirRoot !== undefined) {
 			const trackedIds = new Set(trackedRuns.map((run) => run.id));
 			const history = listAsyncRuns(options.asyncDirRoot, {
-				...(state.currentSessionId ? { sessionId: state.currentSessionId } : {}),
+				...(state.sessionLineage?.length ? { sessionIds: state.sessionLineage } : state.currentSessionId ? { sessionId: state.currentSessionId } : {}),
 				entryLimit: MAX_FLEET_HISTORY_CANDIDATES,
 				resultsDir: options.resultsDir ?? DIRS.results,
 				reconcile: false,

package/dist/extensions/pi-subagents/src/workflows/workflow-auto-relaunch.ts

@@ -0,0 +1,28 @@
+/**
+ * Auto-relaunch policy for scripted workflows that end before the goal is clean
+ * because the per-run fan-out budget was exhausted.
+ *
+ * A `budget` result means the goal was demonstrably not reached, so the only
+ * decision is whether to relaunch. `clean` and failures always surface to the
+ * parent — the parent remains the authority on whether the goal is met.
+ */
+
+export const DEFAULT_MAX_WORKFLOW_AUTO_RELAUNCHES = 12;
+
+export interface AutoRelaunchDecision {
+	relaunch: boolean;
+	capped: boolean;
+}
+
+export function resolveMaxWorkflowAutoRelaunches(raw: unknown): number | undefined {
+	if (raw === undefined) return DEFAULT_MAX_WORKFLOW_AUTO_RELAUNCHES;
+	if (typeof raw !== "number" || !Number.isInteger(raw) || raw < 0) return DEFAULT_MAX_WORKFLOW_AUTO_RELAUNCHES;
+	return raw === 0 ? undefined : raw;
+}
+
+export function resolveAutoRelaunchDecision(value: unknown, relaunched: number, cap: number | undefined): AutoRelaunchDecision {
+	const budgetExhausted = !!value && typeof value === "object" && !Array.isArray(value) && (value as Record<string, unknown>).result === "budget";
+	if (!budgetExhausted) return { relaunch: false, capped: false };
+	if (cap === undefined) return { relaunch: true, capped: false };
+	return relaunched >= cap ? { relaunch: false, capped: true } : { relaunch: true, capped: false };
+}

package/dist/extensions/pi-subagents/test/unit/handoff-adoption.test.ts

@@ -0,0 +1,103 @@
+import assert from "node:assert/strict";
+import { execFileSync } from "node:child_process";
+import { fileURLToPath } from "node:url";
+import path from "node:path";
+import { describe, it } from "node:test";
+
+const projectRoot = path.resolve(path.dirname(fileURLToPath(import.meta.url)), "..", "..");
+
+describe("handoff workflow carry-over", () => {
+	it("adopts the previous session's active async workflows and tells the agent", () => {
+		const script = String.raw`
+			import os from "node:os";
+			import path from "node:path";
+			import fs from "node:fs";
+			import { DIRS } from "./src/shared/types.ts";
+			import registerSubagentExtension from "./index.ts";
+			const handlers = new Map();
+			const events = { listeners: new Map(), on(name, handler) { this.listeners.set(name, handler); return () => this.listeners.delete(name); }, emit(name, payload) { this.listeners.get(name)?.(payload); } };
+			const sent = [];
+			const widgets = [];
+			const pi = new Proxy({
+				events,
+				on(name, handler) { handlers.set(name, handler); },
+				registerTool() {}, registerCommand() {}, registerShortcut() {}, registerMessageRenderer() {},
+				sendMessage(message, options) { sent.push({ message, options }); }, getSessionName() { return undefined; },
+			}, { get(target, prop) { return prop in target ? target[prop] : () => undefined; } });
+
+			const tmp = fs.mkdtempSync(path.join(os.tmpdir(), "selesai-handoff-"));
+			const oldSession = path.join(tmp, "old-session.jsonl");
+			const newSession = path.join(tmp, "new-session.jsonl");
+			fs.writeFileSync(oldSession, JSON.stringify({ type: "session", version: 1, id: "old-session", timestamp: new Date().toISOString(), cwd: process.cwd() }) + "\n");
+			fs.writeFileSync(newSession, JSON.stringify({ type: "session", version: 1, id: "new-session", timestamp: new Date().toISOString(), cwd: process.cwd(), parentSession: oldSession }) + "\n");
+
+			// One active async workflow owned by the previous session.
+			const runId = "adopted-workflow-run";
+			const asyncDir = path.join(DIRS.async, runId);
+			fs.mkdirSync(asyncDir, { recursive: true });
+			fs.writeFileSync(path.join(asyncDir, "status.json"), JSON.stringify({
+				runId,
+				state: "running",
+				sessionId: oldSession,
+				mode: "workflow",
+				workflowKey: "task",
+				agent: "builder",
+				startedAt: Date.now(),
+				steps: [{ agent: "builder", status: "running", phase: "build-1", description: "Implement the carry-over plan" }],
+			}));
+			fs.mkdirSync(path.join(DIRS.async, ".active-runs"), { recursive: true });
+			fs.writeFileSync(path.join(DIRS.async, ".active-runs", runId), "");
+
+			// A result file for an old-session run written during the switch window.
+			const resultRunId = "adopted-completed-run";
+			const resultPath = path.join(DIRS.results, resultRunId + ".json");
+			fs.mkdirSync(DIRS.results, { recursive: true });
+			fs.writeFileSync(resultPath, JSON.stringify({ runId: resultRunId, sessionId: oldSession, agent: "explorer", summary: "done", success: true }));
+
+			const ctx = { cwd: process.cwd(), hasUI: true, ui: { setWidget(key, value) { widgets.push([key, value]); }, requestRender() {}, onTerminalInput() { return () => {}; }, getEditorText() { return ""; }, notify() {}, theme: { fg(_name, text) { return text; }, bg(_name, text) { return text; }, bold(text) { return text; } } }, sessionManager: { getSessionId() { return "new-session"; }, getSessionFile() { return newSession; }, getHeader() { return { parentSession: oldSession }; }, getEntries() { return []; } }, modelRegistry: { getAvailable() { return []; } } };
+
+			registerSubagentExtension(pi);
+			handlers.get("session_start")({ reason: "new", previousSessionFile: oldSession }, ctx);
+			sent.length = 0;
+
+			// No handoff notice until a turn settles.
+			if (sent.length !== 0) throw new Error("handoff notice sent before the first settled turn");
+
+			handlers.get("agent_settled")();
+			const handoff = sent.filter((entry) => entry.message?.customType === "subagent-handoff-resume");
+			if (handoff.length !== 1) throw new Error(JSON.stringify(sent.map((entry) => entry.message)));
+			if (handoff[0].options?.triggerTurn !== true) throw new Error("handoff notice did not trigger a turn");
+			if (typeof handoff[0].message?.content !== "string" || !handoff[0].message.content.includes(runId) || !handoff[0].message.content.includes("carried over")) {
+				throw new Error("handoff notice lacks the adopted workflow: " + JSON.stringify(handoff[0].message));
+			}
+
+			// Only once per adoption.
+			handlers.get("agent_settled")();
+			if (sent.filter((entry) => entry.message?.customType === "subagent-handoff-resume").length !== 1) throw new Error("handoff notice repeated");
+
+			// Compaction resume message now lists the live workflows.
+			handlers.get("session_before_compact")({ reason: "threshold", signal: new AbortController().signal });
+			handlers.get("session_compact")({ reason: "threshold" });
+			const compaction = sent.filter((entry) => entry.message?.customType === "subagent-compaction-resume");
+			if (compaction.length !== 1) throw new Error("compaction resume missing: " + JSON.stringify(sent.map((entry) => entry.message?.customType)));
+			if (typeof compaction[0].message?.content !== "string" || !compaction[0].message.content.includes(runId)) {
+				throw new Error("compaction resume lacks the workflow manifest: " + JSON.stringify(compaction[0].message));
+			}
+
+			// Adopted old-session result gets delivered and cleaned up (batched
+			// notification debounces, so poll with a generous bound).
+			let delivered = false;
+			for (let attempt = 0; attempt < 40 && !delivered; attempt++) {
+				await new Promise((resolve) => setTimeout(resolve, 250));
+				delivered = !fs.existsSync(resultPath);
+			}
+			if (!delivered) throw new Error("adopted result file was not delivered");
+
+			await handlers.get("session_shutdown")();
+		`;
+		const env = { ...process.env };
+		delete env.SELESAI_SUBAGENT_CHILD;
+		execFileSync(process.execPath, ["--experimental-strip-types", "--import", "./test/support/register-loader.mjs", "--input-type=module", "--eval", script], { cwd: projectRoot, env, stdio: "pipe" });
+		assert.ok(true);
+	});
+});

package/dist/extensions/pi-subagents/test/unit/index-child-registration.test.ts

@@ -103,6 +103,28 @@ describe("subagent extension child mode", () => {
 		execFileSync(process.execPath, ["--experimental-strip-types", "--import", "./test/support/register-loader.mjs", "--input-type=module", "--eval", script], { cwd: projectRoot, env: parentToolEnv(), stdio: "pipe" });
 	});
 
+	it("declares packaged prompts through resources_discover", () => {
+		const script = String.raw`
+			import registerSubagentExtension from "./index.ts";
+			import * as fs from "node:fs";
+			const handlers = new Map();
+			const fakePi = new Proxy({
+				events: { on() { return () => {}; }, emit() {} },
+				registerTool() {}, registerCommand() {}, registerShortcut() {}, registerMessageRenderer() {}, sendMessage() {}, getSessionName() {},
+				on(event, handler) { handlers.set(event, handler); },
+			}, { get(target, prop) { return prop in target ? target[prop] : () => undefined; } });
+			registerSubagentExtension(fakePi);
+			const handler = handlers.get("resources_discover");
+			if (!handler) throw new Error("resources_discover handler not registered");
+			const result = handler({ type: "resources_discover", cwd: process.cwd(), reason: "startup" });
+			if (!result || !Array.isArray(result.promptPaths) || result.promptPaths.length !== 1) throw new Error("expected one promptPath, got " + JSON.stringify(result));
+			const promptDir = result.promptPaths[0];
+			if (!fs.existsSync(promptDir + "/review-loop.md")) throw new Error("review-loop.md not found under " + promptDir);
+			if (!fs.existsSync(promptDir + "/parallel-review.md")) throw new Error("parallel-review.md not found under " + promptDir);
+		`;
+		execFileSync(process.execPath, ["--experimental-strip-types", "--import", "./test/support/register-loader.mjs", "--input-type=module", "--eval", script], { cwd: projectRoot, env: parentToolEnv(), stdio: "pipe" });
+	});
+
 	it("shows omitted workflow async as background even when asyncByDefault is false", () => {
 		const agentDir = fs.mkdtempSync(path.join(os.tmpdir(), "pi-subagents-workflow-manifest-config-"));
 		try {

package/dist/extensions/pi-subagents/test/unit/session-lineage.test.ts

@@ -0,0 +1,73 @@
+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 { resolveSessionLineage } from "../../src/shared/session-lineage.ts";
+
+function sessionFile(dir: string, name: string, parentSession?: string): string {
+	const file = path.join(dir, name);
+	const header = {
+		type: "session",
+		version: 1,
+		id: name,
+		timestamp: new Date().toISOString(),
+		cwd: dir,
+		...(parentSession ? { parentSession } : {}),
+	};
+	fs.writeFileSync(file, `${JSON.stringify(header)}\n`);
+	return file;
+}
+
+describe("session lineage", () => {
+	it("resolves self plus the parent chain from session headers", () => {
+		const dir = fs.mkdtempSync(path.join(os.tmpdir(), "selesai-lineage-"));
+		const grandparent = sessionFile(dir, "a.jsonl");
+		const parent = sessionFile(dir, "b.jsonl", grandparent);
+		const current = sessionFile(dir, "c.jsonl", parent);
+		const lineage = resolveSessionLineage({ sessionManager: { getSessionFile: () => current, getHeader: () => ({ parentSession: parent }) } });
+		assert.deepEqual(lineage, [current, parent, grandparent]);
+	});
+
+	it("prefers an explicit parent hint over the header", () => {
+		const dir = fs.mkdtempSync(path.join(os.tmpdir(), "selesai-lineage-"));
+		const hinted = sessionFile(dir, "hinted.jsonl");
+		const headed = sessionFile(dir, "headed.jsonl");
+		const current = sessionFile(dir, "current.jsonl", headed);
+		const lineage = resolveSessionLineage({ sessionManager: { getSessionFile: () => current, getHeader: () => ({ parentSession: headed }) } }, { parentHint: hinted });
+		assert.deepEqual(lineage, [current, hinted]);
+	});
+
+	it("bounds the walk depth", () => {
+		const dir = fs.mkdtempSync(path.join(os.tmpdir(), "selesai-lineage-"));
+		const files: string[] = [];
+		for (let i = 0; i < 12; i++) files.push(sessionFile(dir, `s${i}.jsonl`, i > 0 ? files[i - 1]! : undefined));
+		const current = sessionFile(dir, "current.jsonl", files[11]);
+		const lineage = resolveSessionLineage({ sessionManager: { getSessionFile: () => current } }, { depth: 3 });
+		assert.equal(lineage.length, 3);
+		assert.equal(lineage[0], current);
+		assert.equal(lineage[1], files[11]);
+		assert.equal(lineage[2], files[10]);
+	});
+
+	it("stops at missing parent files", () => {
+		const dir = fs.mkdtempSync(path.join(os.tmpdir(), "selesai-lineage-"));
+		const missing = path.join(dir, "missing.jsonl");
+		const current = sessionFile(dir, "current.jsonl", missing);
+		const lineage = resolveSessionLineage({ sessionManager: { getSessionFile: () => current, getHeader: () => ({ parentSession: missing }) } });
+		assert.deepEqual(lineage, [current]);
+	});
+
+	it("does not loop on cyclic parent chains", () => {
+		const dir = fs.mkdtempSync(path.join(os.tmpdir(), "selesai-lineage-"));
+		const a = sessionFile(dir, "a.jsonl");
+		const b = sessionFile(dir, "b.jsonl", a);
+		fs.writeFileSync(a, `${JSON.stringify({ type: "session", version: 1, id: "a", timestamp: new Date().toISOString(), cwd: dir, parentSession: b })}\n`);
+		const lineage = resolveSessionLineage({ sessionManager: { getSessionFile: () => b, getHeader: () => ({ parentSession: a }) } });
+		assert.deepEqual(lineage, [b, a]);
+	});
+
+	it("handles session managers without getHeader or session file", () => {
+		assert.deepEqual(resolveSessionLineage({ sessionManager: { getSessionFile: () => null } }, { parentHint: "/nonexistent/parent.jsonl" }), []);
+	});
+});

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/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);