@selesai/code 0.12.0 → 0.13.1

package/dist/extensions/model-prompt-injector/index.test.ts

@@ -1,102 +0,0 @@
-import { describe, expect, it, vi } from "vitest";
-import type { ExtensionAPI } from "@selesai/code";
-import modelPromptInjector, {
-	findRule,
-	patternMatches,
-	type InjectConfig,
-	type InjectRule,
-	type ModelRef,
-} from "./index.ts";
-
-const model = (provider: string, id: string, name = id): ModelRef => ({ provider, id, name });
-
-function harness(config: InjectConfig, activeModel: ModelRef | undefined) {
-	const handlers: Record<string, Function> = {};
-	const pi = {
-		on: vi.fn((event: string, handler: Function) => {
-			handlers[event] = handler;
-		}),
-	} as unknown as ExtensionAPI;
-	const ctx = {
-		model: activeModel,
-		ui: { setStatus: vi.fn() },
-	};
-	modelPromptInjector(pi, config);
-	return { handlers, ctx };
-}
-
-describe("patternMatches", () => {
-	it("matches provider/model exactly, case-insensitively", () => {
-		expect(patternMatches("deepseek/deepseek-v4-pro", model("DeepSeek", "deepseek-v4-pro"))).toBe(true);
-		expect(patternMatches("deepseek/deepseek-v4-pro", model("openrouter", "deepseek-v4-pro"))).toBe(false);
-	});
-
-	it("supports wildcards in provider and id", () => {
-		expect(patternMatches("*/deepseek-v4-pro", model("openrouter", "deepseek-v4-pro"))).toBe(true);
-		expect(patternMatches("deepseek/*", model("deepseek", "deepseek-v4-pro"))).toBe(true);
-		expect(patternMatches("deepseek/*", model("deepseek", "deepseek-chat"))).toBe(true);
-		expect(patternMatches("deepseek/*", model("openai", "gpt-5"))).toBe(false);
-	});
-
-	it("bare patterns match id or display name", () => {
-		expect(patternMatches("deepseek-v4-pro", model("deepseek", "deepseek-v4-pro"))).toBe(true);
-		expect(patternMatches("gpt-*", model("openai", "gpt-5", "GPT-5"))).toBe(true);
-		expect(patternMatches("deepseek*", model("deepseek", "deepseek-v4-pro"))).toBe(true);
-	});
-
-	it("matches * against any model", () => {
-		expect(patternMatches("*", model("openai", "gpt-5"))).toBe(true);
-	});
-});
-
-describe("findRule", () => {
-	const rules: InjectRule[] = [
-		{ match: ["deepseek/*"], prompt: "A" },
-		{ match: ["*/deepseek-v4-pro"], prompt: "B" },
-		{ match: ["*"], prompt: "C", enabled: false },
-	];
-
-	it("first matching rule wins", () => {
-		expect(findRule(rules, model("deepseek", "deepseek-v4-pro"))?.prompt).toBe("A");
-		expect(findRule(rules, model("openrouter", "deepseek-v4-pro"))?.prompt).toBe("B");
-	});
-
-	it("skips disabled rules", () => {
-		expect(findRule([{ match: ["*"], prompt: "C", enabled: false }], model("openai", "gpt-5"))).toBeUndefined();
-	});
-});
-
-describe("before_agent_start", () => {
-	it("appends the rule prompt to the system prompt", async () => {
-		const { handlers, ctx } = harness({ rules: [{ match: ["deepseek/*"], prompt: "EXTRA" }] }, model("deepseek", "deepseek-chat"));
-		const result = await handlers["before_agent_start"]({ systemPrompt: "BASE" }, ctx);
-		expect(result).toEqual({ systemPrompt: "BASE\n\nEXTRA" });
-	});
-
-	it("prepends the rule prompt to the top of the system prompt", async () => {
-		const { handlers, ctx } = harness(
-			{ rules: [{ match: ["deepseek/*"], prompt: "TOP", mode: "prepend" }] },
-			model("deepseek", "deepseek-chat"),
-		);
-		const result = await handlers["before_agent_start"]({ systemPrompt: "BASE" }, ctx);
-		expect(result).toEqual({ systemPrompt: "TOP\n\nBASE" });
-	});
-
-	it("replaces the system prompt in replace mode", async () => {
-		const { handlers, ctx } = harness(
-			{ rules: [{ match: ["deepseek/*"], prompt: "ONLY ME", mode: "replace" }] },
-			model("deepseek", "deepseek-chat"),
-		);
-		const result = await handlers["before_agent_start"]({ systemPrompt: "BASE" }, ctx);
-		expect(result).toEqual({ systemPrompt: "ONLY ME" });
-	});
-
-	it("returns undefined when no rule matches", async () => {
-		const { handlers, ctx } = harness(
-			{ rules: [{ match: ["deepseek/*"], prompt: "EXTRA" }] },
-			model("openai", "gpt-5"),
-		);
-		const result = await handlers["before_agent_start"]({ systemPrompt: "BASE" }, ctx);
-		expect(result).toBeUndefined();
-	});
-});

package/dist/extensions/model-prompt-injector/index.ts

@@ -1,148 +0,0 @@
-/**
- * model-prompt-injector
- *
- * Injects a model-specific prompt into the system prompt whenever the active
- * model matches a rule in config.json (sibling of this file).
- *
- * Config lives only here in host code — nothing is exposed to user settings.
- * `/reload` re-reads it.
- *
- * config.json format:
- * {
- *   "rules": [
- *     {
- *       "match": ["provider/model", "provider/*", "<any>/model", "bare-name", "*"],
- *       "mode": "prepend" | "append" | "replace",   // default: "append"
- *       "prompt": "...",
- *       "enabled": true                 // default: true
- *     }
- *   ]
- * }
- *
- * Matching (case-insensitive, "*" is a wildcard):
- * - "provider/model" — glob against `<provider>/<id>`.
- * - bare pattern (no "/") — glob against model id OR display name.
- * - First matching rule wins; later rules are ignored.
- * - mode "prepend" puts the prompt at the very top of the system prompt;
- *   mode "append" adds it to the end; mode "replace" replaces the whole system prompt.
- */
-import { readFileSync } from "node:fs";
-import { dirname, join } from "node:path";
-import { fileURLToPath } from "node:url";
-import type { ExtensionAPI } from "@selesai/code";
-
-export type InjectMode = "prepend" | "append" | "replace";
-
-export interface InjectRule {
-	match: string[];
-	prompt: string;
-	mode?: InjectMode;
-	enabled?: boolean;
-}
-
-export interface InjectConfig {
-	rules: InjectRule[];
-}
-
-/** Model shape needed for matching (structurally compatible with pi's Model). */
-export interface ModelRef {
-	provider: string;
-	id: string;
-	name: string;
-}
-
-const CONFIG_PATH = join(dirname(fileURLToPath(import.meta.url)), "config.json");
-
-function globToRegex(glob: string): RegExp {
-	const escaped = glob.replace(/[.+?^${}()|[\]\\]/g, "\\$&").replace(/\*/g, ".*");
-	return new RegExp(`^${escaped}$`, "i");
-}
-
-export function patternMatches(pattern: string, model: ModelRef): boolean {
-	const slash = pattern.indexOf("/");
-	if (slash >= 0) {
-		return (
-			globToRegex(pattern.slice(0, slash)).test(model.provider) &&
-			globToRegex(pattern.slice(slash + 1)).test(model.id)
-		);
-	}
-	return globToRegex(pattern).test(model.id) || globToRegex(pattern).test(model.name);
-}
-
-export function findRule(rules: readonly InjectRule[], model: ModelRef): InjectRule | undefined {
-	for (const rule of rules) {
-		if (rule.enabled === false) continue;
-		if (rule.match.some((pattern) => patternMatches(pattern, model))) return rule;
-	}
-	return undefined;
-}
-
-export function loadConfig(path: string = CONFIG_PATH): InjectConfig {
-	const fail = (message: string): InjectConfig => {
-		console.error(`[model-prompt-injector] ${message}`);
-		return { rules: [] };
-	};
-
-	let raw: unknown;
-	try {
-		raw = JSON.parse(readFileSync(path, "utf8"));
-	} catch (error) {
-		return fail(`cannot load ${path}: ${(error as Error).message}`);
-	}
-
-	if (typeof raw !== "object" || raw === null || !Array.isArray((raw as { rules?: unknown }).rules)) {
-		return fail(`invalid config: expected { "rules": [...] }`);
-	}
-
-	const rules: InjectRule[] = [];
-	for (const [index, entry] of (raw as { rules: unknown[] }).rules.entries()) {
-		const label = `rule #${index + 1}`;
-		if (typeof entry !== "object" || entry === null) {
-			console.error(`[model-prompt-injector] ${label} is not an object — skipped`);
-			continue;
-		}
-		const rule = entry as Partial<InjectRule>;
-		if (!Array.isArray(rule.match) || rule.match.length === 0 || !rule.match.every((m) => typeof m === "string")) {
-			console.error(`[model-prompt-injector] ${label} needs a non-empty "match" string array — skipped`);
-			continue;
-		}
-		if (typeof rule.prompt !== "string" || rule.prompt.trim() === "") {
-			console.error(`[model-prompt-injector] ${label} needs a non-empty "prompt" string — skipped`);
-			continue;
-		}
-		if (rule.mode !== undefined && rule.mode !== "prepend" && rule.mode !== "append" && rule.mode !== "replace") {
-			console.error(`[model-prompt-injector] ${label}: "mode" must be "prepend", "append" or "replace" — skipped`);
-			continue;
-		}
-		rules.push({
-			match: rule.match,
-			prompt: rule.prompt,
-			mode: rule.mode ?? "append",
-			enabled: rule.enabled ?? true,
-		});
-	}
-	return { rules };
-}
-
-export default function modelPromptInjector(pi: ExtensionAPI, config: InjectConfig = loadConfig()) {
-	const ruleFor = (model: ModelRef | undefined): InjectRule | undefined =>
-		model ? findRule(config.rules, model) : undefined;
-
-	const active = config.rules.filter((rule) => rule.enabled !== false);
-	if (active.length > 0) {
-		console.log(
-			`[model-prompt-injector] ${active.length} rule(s) active: ${active
-				.map((rule) => rule.match.join(","))
-				.join(" | ")}`,
-		);
-	}
-
-	pi.on("before_agent_start", async (event, ctx) => {
-		const rule = ruleFor(ctx.model);
-		if (!rule) return;
-		if (rule.mode === "replace") return { systemPrompt: rule.prompt };
-		if (rule.mode === "prepend") return { systemPrompt: `${rule.prompt}\n\n${event.systemPrompt}` };
-		return { systemPrompt: `${event.systemPrompt}\n\n${rule.prompt}` };
-	});
-
-}

package/dist/extensions/pi-subagents/src/runs/shared/turn-budget.ts

@@ -1,98 +0,0 @@
-import type { ResolvedTurnBudget, TurnBudgetState } from "../../shared/types.ts";
-
-export const DEFAULT_TURN_BUDGET_GRACE_TURNS = 1;
-
-export function resolveTurnBudgetConfig(
-	raw: unknown,
-	label = "turnBudget",
-): { turnBudget?: ResolvedTurnBudget; error?: string } {
-	if (raw === undefined) return {};
-	if (!raw || typeof raw !== "object" || Array.isArray(raw)) {
-		return { error: `${label} must be an object with maxTurns and optional graceTurns.` };
-	}
-	const unknownField = Object.keys(raw).find((key) => key !== "maxTurns" && key !== "graceTurns");
-	if (unknownField) return { error: `${label}.${unknownField} is not supported.` };
-	const budget = raw as { maxTurns?: unknown; graceTurns?: unknown };
-	if (typeof budget.maxTurns !== "number" || !Number.isInteger(budget.maxTurns) || budget.maxTurns < 1) {
-		return { error: `${label}.maxTurns must be an integer >= 1.` };
-	}
-	const graceTurns = budget.graceTurns ?? DEFAULT_TURN_BUDGET_GRACE_TURNS;
-	if (typeof graceTurns !== "number" || !Number.isInteger(graceTurns) || graceTurns < 0) {
-		return { error: `${label}.graceTurns must be an integer >= 0.` };
-	}
-	return { turnBudget: { maxTurns: budget.maxTurns, graceTurns } };
-}
-
-export function appendTurnBudgetSystemPrompt(systemPrompt: string, budget: { maxTurns: number; graceTurns?: number } | undefined): string {
-	if (!budget) return systemPrompt;
-	const graceTurns = budget.graceTurns ?? DEFAULT_TURN_BUDGET_GRACE_TURNS;
-	const grace = graceTurns === 1 ? "1 additional assistant turn" : `${graceTurns} additional assistant turns`;
-	const block = [
-		"## Turn budget",
-		`This child run has a soft budget of ${budget.maxTurns} assistant turn${budget.maxTurns === 1 ? "" : "s"}.`,
-		`After that, ${grace} may be allowed only for a final wrap-up.`,
-		"When you approach or reach the soft budget, stop starting new tool work and return the final answer immediately.",
-		"This runner uses process-mode execution, so live steering after launch may be unavailable; treat this instruction as the wrap-up request.",
-		"If you continue past the soft budget plus grace turns, the supervisor may abort the process and return only partial output.",
-	].join("\n");
-	return systemPrompt.trim() ? `${systemPrompt.trim()}\n\n${block}` : block;
-}
-
-export function turnBudgetSoftNote(budget: ResolvedTurnBudget, turnCount: number): string {
-	return `Turn budget wrap-up was requested after ${turnCount} assistant turn${turnCount === 1 ? "" : "s"} (soft limit ${budget.maxTurns}, grace ${budget.graceTurns}). Process-mode live steering is unavailable, so the child was warned at launch to wrap up by this budget. Output may be partial.`;
-}
-
-export function turnBudgetExceededMessage(budget: ResolvedTurnBudget, turnCount: number): string {
-	return `Subagent exceeded turn budget after ${turnCount} assistant turn${turnCount === 1 ? "" : "s"} (soft limit ${budget.maxTurns} + grace ${budget.graceTurns}).`;
-}
-
-export function turnBudgetDeferredNote(budget: ResolvedTurnBudget, turnCount: number): string {
-	return `Turn-budget termination was deferred at ${turnCount} assistant turn${turnCount === 1 ? "" : "s"} (soft limit ${budget.maxTurns} + grace ${budget.graceTurns}) because the assistant started tool work. The run ended before another safe assistant boundary; output may be partial.`;
-}
-
-export function formatTurnBudgetOutput(message: string, output: string): string {
-	return output.trim()
-		? `${message}\n\nPartial output before turn-budget abort:\n${output}`
-		: message;
-}
-
-export function initialTurnBudgetState(budget: { maxTurns: number; graceTurns?: number }): TurnBudgetState {
-	return { maxTurns: budget.maxTurns, graceTurns: budget.graceTurns ?? DEFAULT_TURN_BUDGET_GRACE_TURNS, outcome: "within-budget", turnCount: 0 };
-}
-
-export function turnBudgetState(budget: ResolvedTurnBudget, turnCount: number, exceeded: boolean): TurnBudgetState {
-	return {
-		...budget,
-		turnCount,
-		outcome: exceeded ? "exceeded" : "wrap-up-requested",
-		wrapUpRequestedAtTurn: budget.maxTurns,
-		...(exceeded ? { exceededAtTurn: turnCount } : {}),
-	};
-}
-
-export function turnBudgetDeferredState(
-	budget: ResolvedTurnBudget,
-	turnCount: number,
-	terminationDeferredAtTurn = turnCount,
-): TurnBudgetState {
-	return {
-		...budget,
-		turnCount,
-		outcome: "termination-deferred",
-		wrapUpRequestedAtTurn: budget.maxTurns,
-		terminationDeferredAtTurn,
-	};
-}
-
-export function turnBudgetDecision(
-	budget: ResolvedTurnBudget,
-	turnCount: number,
-	terminalAssistantStop: boolean,
-	toolWorkActiveOrStarting: boolean,
-	enforceHardLimit = false,
-): "continue" | "defer" | "abort" {
-	const hardLimit = budget.maxTurns + budget.graceTurns;
-	if (terminalAssistantStop || turnCount < hardLimit) return "continue";
-	if (toolWorkActiveOrStarting && !enforceHardLimit) return "defer";
-	return "abort";
-}

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

@@ -1,250 +0,0 @@
-import assert from "node:assert/strict";
-import { describe, it } from "node:test";
-import type { ResolvedTurnBudget, TurnBudgetState } from "../../src/shared/types.ts";
-import {
-	DEFAULT_TURN_BUDGET_GRACE_TURNS,
-	appendTurnBudgetSystemPrompt,
-	formatTurnBudgetOutput,
-	initialTurnBudgetState,
-	resolveTurnBudgetConfig,
-	turnBudgetDecision,
-	turnBudgetDeferredState,
-	turnBudgetExceededMessage,
-	turnBudgetSoftNote,
-	turnBudgetState,
-} from "../../src/runs/shared/turn-budget.ts";
-
-function budget(overrides: Partial<ResolvedTurnBudget> = {}): ResolvedTurnBudget {
-	return { maxTurns: 3, graceTurns: 1, ...overrides };
-}
-
-describe("turn-budget module", () => {
-	describe("DEFAULT_TURN_BUDGET_GRACE_TURNS", () => {
-		it("defaults to one grace turn", () => {
-			assert.equal(DEFAULT_TURN_BUDGET_GRACE_TURNS, 1);
-		});
-	});
-
-	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.");
-			assert.equal(appendTurnBudgetSystemPrompt("", undefined), "");
-		});
-
-		it("appends a turn-budget block after an existing system prompt", () => {
-			const result = appendTurnBudgetSystemPrompt("You are a reviewer.", budget({ maxTurns: 5, graceTurns: 2 }));
-			assert.ok(result.startsWith("You are a reviewer.\n\n## Turn budget\n"), result);
-			assert.match(result, /soft budget of 5 assistant turns/);
-			assert.match(result, /2 additional assistant turns/);
-		});
-
-		it("emits only the turn-budget block when the system prompt is empty", () => {
-			const result = appendTurnBudgetSystemPrompt("   ", budget({ maxTurns: 5, graceTurns: 1 }));
-			assert.ok(result.startsWith("## Turn budget\n"), result);
-			assert.equal(result.includes("You are"), false);
-		});
-
-		it("trims surrounding whitespace from the existing system prompt before joining", () => {
-			const result = appendTurnBudgetSystemPrompt("\nYou are a reviewer.\n\n", budget());
-			assert.ok(result.startsWith("You are a reviewer.\n\n## Turn budget\n"), result);
-			assert.equal(result.startsWith("\n"), false);
-		});
-
-		it("pluralizes maxTurns for single and multiple turns", () => {
-			assert.match(appendTurnBudgetSystemPrompt("", budget({ maxTurns: 1 })), /soft budget of 1 assistant turn\./);
-			assert.match(appendTurnBudgetSystemPrompt("", budget({ maxTurns: 4 })), /soft budget of 4 assistant turns\./);
-		});
-
-		it("pluralizes graceTurns for one versus many or zero", () => {
-			assert.match(appendTurnBudgetSystemPrompt("", budget({ graceTurns: 1 })), /1 additional assistant turn may be allowed/);
-			assert.match(appendTurnBudgetSystemPrompt("", budget({ graceTurns: 0 })), /0 additional assistant turns may be allowed/);
-			assert.match(appendTurnBudgetSystemPrompt("", budget({ graceTurns: 3 })), /3 additional assistant turns may be allowed/);
-		});
-	});
-
-	describe("turnBudgetSoftNote", () => {
-		it("describes the wrap-up request with soft limit and grace values", () => {
-			assert.equal(
-				turnBudgetSoftNote(budget({ maxTurns: 3, graceTurns: 1 }), 3),
-				"Turn budget wrap-up was requested after 3 assistant turns (soft limit 3, grace 1). Process-mode live steering is unavailable, so the child was warned at launch to wrap up by this budget. Output may be partial.",
-			);
-		});
-
-		it("pluralizes the turn count", () => {
-			assert.match(turnBudgetSoftNote(budget(), 1), /requested after 1 assistant turn\b/);
-			assert.match(turnBudgetSoftNote(budget(), 5), /requested after 5 assistant turns\b/);
-		});
-	});
-
-	describe("turnBudgetExceededMessage", () => {
-		it("describes the hard abort with soft limit plus grace", () => {
-			assert.equal(
-				turnBudgetExceededMessage(budget({ maxTurns: 3, graceTurns: 1 }), 4),
-				"Subagent exceeded turn budget after 4 assistant turns (soft limit 3 + grace 1).",
-			);
-		});
-
-		it("pluralizes the turn count", () => {
-			assert.match(turnBudgetExceededMessage(budget(), 1), /after 1 assistant turn\b/);
-			assert.match(turnBudgetExceededMessage(budget(), 3), /after 3 assistant turns\b/);
-		});
-	});
-
-	describe("formatTurnBudgetOutput", () => {
-		it("prefixes the abort message onto captured partial output", () => {
-			assert.equal(
-				formatTurnBudgetOutput("ABORT", "partial work"),
-				"ABORT\n\nPartial output before turn-budget abort:\npartial work",
-			);
-		});
-
-		it("preserves multi-line partial output verbatim", () => {
-			assert.equal(
-				formatTurnBudgetOutput("ABORT", "line1\nline2\nline3"),
-				"ABORT\n\nPartial output before turn-budget abort:\nline1\nline2\nline3",
-			);
-		});
-
-		it("returns only the message when there is no partial output", () => {
-			assert.equal(formatTurnBudgetOutput("ABORT", ""), "ABORT");
-			assert.equal(formatTurnBudgetOutput("ABORT", "  \n  "), "ABORT");
-		});
-	});
-
-	describe("initialTurnBudgetState", () => {
-		it("starts within budget at turn zero and copies the resolved budget", () => {
-			const state = initialTurnBudgetState(budget({ maxTurns: 5, graceTurns: 2 }));
-			const expected: TurnBudgetState = { maxTurns: 5, graceTurns: 2, outcome: "within-budget", turnCount: 0 };
-			assert.deepEqual(state, expected);
-			assert.equal("wrapUpRequestedAtTurn" in state, false);
-			assert.equal("exceededAtTurn" in state, false);
-		});
-	});
-
-	describe("turnBudgetState", () => {
-		it("marks a wrap-up request without recording an exceeded turn", () => {
-			const state = turnBudgetState(budget({ maxTurns: 3, graceTurns: 1 }), 3, false);
-			assert.deepEqual(state, {
-				maxTurns: 3,
-				graceTurns: 1,
-				turnCount: 3,
-				outcome: "wrap-up-requested",
-				wrapUpRequestedAtTurn: 3,
-			});
-			assert.equal("exceededAtTurn" in state, false);
-		});
-
-		it("marks an exceeded budget and records the turn where it happened", () => {
-			const state = turnBudgetState(budget({ maxTurns: 3, graceTurns: 1 }), 4, true);
-			assert.deepEqual(state, {
-				maxTurns: 3,
-				graceTurns: 1,
-				turnCount: 4,
-				outcome: "exceeded",
-				wrapUpRequestedAtTurn: 3,
-				exceededAtTurn: 4,
-			});
-		});
-
-		it("records the wrap-up request at the soft-limit turn even when exceeded", () => {
-			const state = turnBudgetState(budget({ maxTurns: 2, graceTurns: 0 }), 2, true);
-			assert.equal(state.wrapUpRequestedAtTurn, 2);
-			assert.equal(state.exceededAtTurn, 2);
-			assert.equal(state.outcome, "exceeded");
-		});
-	});
-
-	describe("turnBudgetDecision", () => {
-		it("continues for a clean terminal response even after the hard limit", () => {
-			assert.equal(turnBudgetDecision(budget({ maxTurns: 3, graceTurns: 1 }), 3, false, false), "continue");
-			assert.equal(turnBudgetDecision(budget({ maxTurns: 3, graceTurns: 1 }), 4, true, false), "continue");
-			assert.equal(turnBudgetDecision(budget({ maxTurns: 3, graceTurns: 1 }), 5, 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("enforces the hard limit for strict foreground delegation but allows terminal completion", () => {
-			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");
-			assert.equal(turnBudgetDecision(budget({ maxTurns: 3, graceTurns: 1 }), 5, true, true, true), "continue");
-		});
-
-		it("aborts non-terminal work 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, false, false), "abort");
-		});
-
-		it("allows a terminal response at the soft limit when grace turns are zero", () => {
-			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,
-			});
-		});
-	});
-
-	describe("turn budget state transitions", () => {
-		it("walks within-budget -> wrap-up-requested -> exceeded as turns accrue", () => {
-			const resolved = budget({ maxTurns: 3, graceTurns: 1 });
-
-			const start = initialTurnBudgetState(resolved);
-			assert.equal(start.outcome, "within-budget");
-			assert.equal(start.turnCount, 0);
-
-			const warning = turnBudgetState(resolved, resolved.maxTurns, false);
-			assert.equal(warning.outcome, "wrap-up-requested");
-			assert.equal(warning.turnCount, resolved.maxTurns);
-			assert.equal(warning.wrapUpRequestedAtTurn, resolved.maxTurns);
-			assert.equal("exceededAtTurn" in warning, false);
-
-			const exceeded = turnBudgetState(resolved, resolved.maxTurns + resolved.graceTurns, true);
-			assert.equal(exceeded.outcome, "exceeded");
-			assert.equal(exceeded.turnCount, resolved.maxTurns + resolved.graceTurns);
-			assert.equal(exceeded.exceededAtTurn, resolved.maxTurns + resolved.graceTurns);
-			assert.equal(exceeded.wrapUpRequestedAtTurn, resolved.maxTurns);
-		});
-
-		it("can represent immediate exceedance when grace turns are zero", () => {
-			const resolved = budget({ maxTurns: 2, graceTurns: 0 });
-			const exceeded = turnBudgetState(resolved, resolved.maxTurns, true);
-			assert.equal(exceeded.outcome, "exceeded");
-			assert.equal(exceeded.exceededAtTurn, resolved.maxTurns);
-		});
-	});
-});