@selesai/code 0.8.12 → 0.9.1

package/dist/extensions/pi-subagents/test/integration/result-watcher.test.ts

@@ -7,7 +7,6 @@ import type { ExtensionContext } from "@selesai/code";
 import { buildCompletionKey } from "../../src/runs/background/completion-dedupe.ts";
 import { createResultWatcher as createRawResultWatcher } from "../../src/runs/background/result-watcher.ts";
 import { writeAsyncResultFile, writePendingAsyncResultFile } from "../../src/runs/background/result-files.ts";
-import { createScheduledRunManager, scheduledRunStorePath } from "../../src/runs/background/scheduled-runs.ts";
 import { prepareMissionLaunch, writeMissionAsyncBinding } from "../../src/missions/lifecycle.ts";
 import { readMission, updateMission } from "../../src/missions/store.ts";
 import { createNestedRoute, writeNestedEvent } from "../../src/runs/shared/nested-events.ts";
@@ -400,64 +399,6 @@ describe("result watcher", () => {
 		}
 	});
 
-	it("observes retained-project completions without changing active-session delivery", async () => {
-		const root = fs.mkdtempSync(path.join(os.tmpdir(), "pi-result-watcher-scheduled-"));
-		const resultsDir = path.join(root, "results");
-		const project = path.join(root, "project-a");
-		fs.mkdirSync(resultsDir);
-		fs.mkdirSync(project);
-		const ctx = {
-			cwd: project,
-			sessionManager: {
-				getSessionId: () => "session-a",
-				getSessionFile: () => path.join(project, "session-a.jsonl"),
-			},
-		} as unknown as ExtensionContext;
-		const manager = createScheduledRunManager({
-			config: { scheduledRuns: { enabled: true } },
-			storeRoot: path.join(root, "stores"),
-			launch: async () => ({ content: [{ type: "text", text: "Async" }], details: { mode: "single", results: [], asyncId: "scheduled-a" } }),
-		});
-		try {
-			manager.bindSession(ctx);
-			await manager.handleToolCall({ action: "schedule.create", id: "retained", every: "1h", workflowScript: "return runs.run('main', { agent: 'worker' })" }, ctx);
-			await manager.handleToolCall({ action: "schedule.run", id: "retained" }, ctx);
-			const scheduleDir = path.join(scheduledRunStorePath(project, undefined, path.join(root, "stores")), "retained");
-			assert.equal(fs.existsSync(path.join(scheduleDir, "active.lock")), true);
-
-			const emitted: Array<{ event: string; data: unknown }> = [];
-			const state = createState();
-			state.currentSessionId = "session-b";
-			const resultPath = path.join(resultsDir, "scheduled-a.json");
-			writeIndexedResult(resultPath, { id: "scheduled-a", sessionId: "session-a", success: true, summary: "done" });
-			const watcher = createResultWatcher({
-				events: {
-					on: () => () => {},
-					emit(event: string, data: unknown) { emitted.push({ event, data }); },
-				},
-			}, state, resultsDir, 60_000, {
-				observeCompletion: (result) => manager.handleAsyncCompletion(result),
-				observedCompletionRunIds: () => manager.observedCompletionRunIds(),
-				notifier: { deliver: async () => assert.fail("inactive-session completion must not reach the live notifier") },
-			});
-			try {
-				watcher.startResultWatcher();
-				watcher.primeExistingResults();
-				await new Promise((resolve) => setTimeout(resolve, 10));
-			} finally {
-				watcher.stopResultWatcher();
-			}
-
-			assert.equal(state.currentSessionId, "session-b");
-			assert.equal(emitted.length, 0);
-			assert.equal(fs.existsSync(path.join(scheduleDir, "active.lock")), false);
-			assert.match(fs.readFileSync(path.join(scheduleDir, "history.json"), "utf-8"), /"state": "completed"/);
-			assert.equal(fs.existsSync(resultPath), true, "the owning session keeps delivery ownership of its result file");
-		} finally {
-			manager.stop();
-			fs.rmSync(root, { recursive: true, force: true });
-		}
-	});
 
 	it("delivers indexed pending results during reload when public promotion is blocked", async () => {
 		const resultsDir = fs.mkdtempSync(path.join(os.tmpdir(), "pi-result-watcher-pending-index-"));

package/dist/extensions/pi-subagents/test/integration/single-execution.test.ts

@@ -413,26 +413,6 @@ describe("single sync execution", { skip: !available ? "pi packages not availabl
 		assert.equal(mockPi.callCount(), 0);
 	});
 
-	it("allows schedule.create to carry the required workflowScript target", { skip: !createSubagentExecutor ? "executor not importable" : undefined }, async () => {
-		let forwarded;
-		const executor = makeExecutor([makeAgent("echo")], {}, false, undefined, true, new Map(), undefined, async (params) => {
-			forwarded = params;
-			return { content: [{ type: "text", text: "created" }], details: { mode: "management", results: [] } };
-		});
-
-		const result = await executor.execute(
-			"schedule-create",
-			{ action: "schedule.create", id: "nightly", every: "1h", workflowScript: "return runs.run('main', { agent: 'echo' })" },
-			new AbortController().signal,
-			undefined,
-			makeMinimalCtx(tempDir),
-		);
-
-		assert.equal(result.isError, undefined);
-		assert.equal(result.content[0]?.text, "created");
-		assert.equal(forwarded?.workflowScript, "return runs.run('main', { agent: 'echo' })");
-	});
-
 	it("starts workflow scripts asynchronously with a portable internal run id", { skip: !createSubagentExecutor ? "executor not importable" : undefined }, async () => {
 		mockPi.onCall({ echoEnv: [SUBAGENT_STEER_INBOX_ENV, SUBAGENT_STEER_CAPABILITY_ENV, SUBAGENT_STEER_ACK_DIR_ENV] });
 		const asyncJobs: SubagentState["asyncJobs"] = new Map();
@@ -1683,45 +1663,6 @@ describe("single sync execution", { skip: !available ? "pi packages not availabl
 		assert.match(result.content[0]?.text ?? "", /Valid:/);
 	});
 
-	it("routes watchdog.configure through the management action path", { skip: !createSubagentExecutor ? "executor not importable" : undefined }, async () => {
-		const gpt = { provider: "openai-codex", id: "gpt-5.5", reasoning: true };
-		const opus = { provider: "anthropic", id: "claude-opus-4-8", reasoning: true };
-		const models = [gpt, opus];
-		const watchdog = new MainWatchdogRuntime({ cwd: tempDir });
-		const executor = createSubagentExecutor!({
-			pi: { events: createEventBus(), getSessionName: () => undefined },
-			state: { baseCwd: tempDir, currentSessionId: null, asyncJobs: new Map(), foregroundControls: new Map(), lastForegroundControlId: null },
-			config: {},
-			asyncByDefault: false,
-			watchdog,
-			tempArtifactsDir: tempDir,
-			getSubagentSessionRoot: () => tempDir,
-			expandTilde: (value: string) => value,
-			discoverAgents: () => ({ agents: [makeAgent("echo")] }),
-		});
-		const ctx = {
-			...makeMinimalCtx(tempDir),
-			model: gpt,
-			modelRegistry: {
-				getAvailable: () => models,
-				find: (provider: string, id: string) => models.find((model) => model.provider === provider && model.id === id),
-				hasConfiguredAuth: (model: unknown) => Boolean(model),
-			},
-		};
-
-		const result = await executor.execute(
-			"watchdog-configure",
-			{ action: "watchdog.configure", model: "recommended" },
-			new AbortController().signal,
-			undefined,
-			ctx,
-		);
-
-		assert.equal(result.isError, undefined);
-		assert.match(result.content[0]?.text ?? "", /session model configured: anthropic\/claude-opus-4-8:high/);
-		assert.equal(watchdog.getSnapshot(tempDir).config.main.model, "anthropic/claude-opus-4-8");
-	});
-
 	it("rejects duplicate concurrent subagent execution calls", async () => {
 		mockPi.onCall({ output: "first call completed", delay: 100 });
 		const executor = makeExecutor([makeAgent("echo")]);

package/dist/extensions/pi-subagents/test/integration/slash-commands.test.ts

@@ -5,7 +5,6 @@ import * as path from "node:path";
 import { beforeEach, describe, it } from "node:test";
 import { visibleWidth } from "@earendil-works/pi-tui";
 
-import { scheduledRunStorePath } from "../../src/runs/background/scheduled-runs.ts";
 import { SUBAGENT_FANOUT_CHILD_ENV } from "../../src/runs/shared/pi-args.ts";
 import { ASYNC_DIR } from "../../src/shared/types.ts";
 import type { WatchdogReviewFunction } from "../../src/watchdog/runtime.ts";
@@ -280,35 +279,6 @@ describe("subagents watchdog slash command", { skip: !available ? "watchdog comm
 		});
 	});
 
-	it("recommends and saves a strong complementary watchdog model", async () => {
-		await withIsolatedHome(async () => {
-			await withTempProject("pi-watchdog-model-", async (root) => {
-				const gpt = { provider: "openai-codex", id: "gpt-5.5", reasoning: true };
-				const opus = { provider: "anthropic", id: "claude-opus-4-8", reasoning: true };
-				const models = [gpt, opus];
-				const modelRegistry = {
-					getAvailable: () => models,
-					find: (provider: string, id: string) => models.find((entry) => entry.provider === provider && entry.id === id),
-					hasConfiguredAuth: (model: unknown) => Boolean(model),
-				};
-				const ctx = createCommandContext({ cwd: root, model: gpt, modelRegistry });
-				const { commands, sent } = createWatchdogHarness();
-
-				await commands.get("subagents-watchdog")!.handler("recommend-model", ctx);
-				await commands.get("subagents-watchdog")!.handler("model recommended", ctx);
-
-				const recommendation = String((sent[0] as { content?: unknown }).content ?? "");
-				assert.match(recommendation, /Recommended: anthropic\/claude-opus-4-8:high/);
-				const settingsPath = path.join(process.env.HOME!, ".selesai", "agent", "settings.json");
-				const settings = JSON.parse(fs.readFileSync(settingsPath, "utf-8"));
-				assert.equal(settings.subagents.watchdog.main.model, "anthropic/claude-opus-4-8");
-				assert.equal(settings.subagents.watchdog.main.thinking, "high");
-				assert.equal(settings.subagents.watchdog.enabled, undefined);
-				assert.match(String((sent[1] as { content?: unknown }).content ?? ""), /Run \/subagents-watchdog on if the watchdog is still off/);
-			});
-		});
-	});
-
 	it("supports session-scoped recommended watchdog models without writing settings", async () => {
 		await withIsolatedHome(async () => {
 			await withTempProject("pi-watchdog-session-model-", async (root) => {
@@ -529,23 +499,6 @@ describe("slash command custom message delivery", { skip: !available ? "slash-co
 
 	it("/subagents-stop keeps the selector within its allocated width", async () => {
 		await withTempProject("pi-stop-selector-width-", async (root) => {
-			const id = "scheduled-width-check";
-			const nextRunAt = "2099-01-01T00:00:00.000Z";
-			const scheduleDir = path.join(scheduledRunStorePath(root), id);
-			fs.mkdirSync(scheduleDir, { recursive: true });
-			fs.writeFileSync(path.join(scheduleDir, "schedule.json"), JSON.stringify({
-				schemaVersion: 1,
-				id,
-				name: "A very long scheduled run name with wide characters 中文🙂",
-				cwd: root,
-				trigger: { kind: "once", at: nextRunAt, nextRunAt },
-				target: { agent: "scout", task: "Inspect" },
-				overlap: "skip",
-				catchUp: "latest",
-				paused: false,
-				createdAt: "2026-08-06T00:00:00.000Z",
-				updatedAt: "2026-08-06T00:00:00.000Z",
-			}), "utf-8");
 
 			const commands = new Map<string, RegisteredSlashCommand>();
 			const pi = {

package/dist/extensions/pi-subagents/test/unit/authority-policy.test.ts

@@ -7,7 +7,6 @@ describe("authority policy", () => {
 		assert.equal(resolveAuthorityDecision({ action: "discardWorktree" }), "confirm");
 		assert.equal(resolveAuthorityDecision({ action: "destructiveCleanup" }), "confirm");
 		assert.equal(resolveAuthorityDecision({ action: "spawnBudgetGrant" }), "confirm");
-		assert.equal(resolveAuthorityDecision({ action: "scheduleCreate" }), "auto");
 		assert.equal(resolveAuthorityDecision({ action: "stopRun" }), "auto");
 		assert.equal(resolveAuthorityDecision({ action: "steerRun" }), "auto");
 	});

package/dist/extensions/pi-subagents/test/unit/compaction-resume.test.ts

@@ -32,7 +32,7 @@ describe("async compaction resume", () => {
 			renders = 0;
 			handlers.get("session_before_compact")({ reason: "threshold", signal: new AbortController().signal });
 			const cleared = widgets.filter(([key, value]) => value === undefined).map(([key]) => key).sort();
-			if (JSON.stringify(cleared) !== JSON.stringify(["subagent-async", "subagent-fleet-status"])) throw new Error(JSON.stringify(widgets));
+			if (JSON.stringify(cleared) !== JSON.stringify(["subagent-async"])) throw new Error(JSON.stringify(widgets));
 			widgets.length = 0;
 			events.emit("subagent:async-complete", { id: "running", sessionId: "compact-session", agent: "worker", success: true, summary: "done" });
 			events.emit("subagent:async-started", { id: "running-2", pid: 2, sessionId: "compact-session", mode: "single", agent: "worker", asyncDir: path.join(os.tmpdir(), "pi-compaction-test-running-2") });
@@ -41,7 +41,7 @@ describe("async compaction resume", () => {
 			if (widgets.length !== 0) throw new Error("widgets restored inside compaction hook");
 			handlers.get("agent_start")();
 			const restored = widgets.filter(([_, value]) => value !== undefined).map(([key]) => key).sort();
-			if (JSON.stringify(restored) !== JSON.stringify(["subagent-async", "subagent-fleet-status"])) throw new Error(JSON.stringify(widgets));
+			if (JSON.stringify(restored) !== JSON.stringify(["subagent-async"])) throw new Error(JSON.stringify(widgets));
 			if (sent.length !== 1 || sent[0].options?.triggerTurn !== true || sent[0].message?.customType !== "subagent-compaction-resume") throw new Error(JSON.stringify(sent));
 
 			sent.length = 0;

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

@@ -612,8 +612,8 @@ describe("subagent extension child mode", () => {
 			}), "utf-8");
 			updateActiveRunIndex(asyncDir, "running");
 			handlers.get("tool_result")({ toolName: "subagent" }, ctx);
-			const fleetWidgets = widgets.filter((entry) => entry.key === "subagent-fleet-status");
-			if (!fleetWidgets.some((entry) => typeof entry.value === "function")) throw new Error("management result did not restore active fleet status: " + JSON.stringify(fleetWidgets));
+			const asyncWidgets = widgets.filter((entry) => entry.key === "subagent-async");
+			if (!asyncWidgets.some((entry) => typeof entry.value === "function" || typeof entry.value === "string")) throw new Error("management result did not restore active async status: " + JSON.stringify(asyncWidgets));
 			handlers.get("session_shutdown")();
 			fs.rmSync(asyncDir, { recursive: true, force: true });
 		`;
@@ -787,7 +787,7 @@ describe("subagent extension child mode", () => {
 		}
 	});
 
-	it("registers the main watchdog command and renderer in parent mode", () => {
+	it("does not register the main watchdog command or renderer in parent mode", () => {
 		const script = String.raw`
 			import registerSubagentExtension from "./index.ts";
 			const events = { on() { return () => {}; }, emit() {} };
@@ -808,8 +808,8 @@ describe("subagent extension child mode", () => {
 				},
 			});
 			registerSubagentExtension(fakePi);
-			if (!commands.includes("subagents-watchdog")) throw new Error("watchdog command not registered: " + commands.join(", "));
-			if (!renderers.includes("subagent_watchdog_warning")) throw new Error("watchdog renderer not registered: " + renderers.join(", "));
+			if (commands.includes("subagents-watchdog")) throw new Error("watchdog command still registered: " + commands.join(", "));
+			if (renderers.includes("subagent_watchdog_warning")) throw new Error("watchdog renderer still registered: " + renderers.join(", "));
 		`;
 
 		execFileSync(

package/dist/extensions/pi-subagents/test/unit/public-execution.test.ts

@@ -14,14 +14,6 @@ describe("public subagent execution normalization", () => {
 		assert.deepEqual(normalizePublicSubagentExecution({ tasks: [{ agent: "worker" }] }), { ok: true, params: { tasks: [{ agent: "worker" }] } });
 		assert.deepEqual(normalizePublicSubagentExecution({ chain: [{ agent: "worker" }] }), { ok: true, params: { chain: [{ agent: "worker" }] } });
 		assert.deepEqual(normalizePublicSubagentExecution({ action: " list " }), { ok: true, params: { action: "list" } });
-		assert.deepEqual(
-			normalizePublicSubagentExecution({ action: " schedule.create ", every: "1h", workflowScript: "return 1" }),
-			{ ok: true, params: { action: "schedule.create", every: "1h", workflowScript: "return 1" } },
-		);
-		assert.deepEqual(
-			normalizePublicSubagentExecution({ action: "schedule.create", agent: "worker", task: "work" }),
-			{ ok: true, params: { action: "schedule.create", agent: "worker", task: "work" } },
-		);
 	});
 
 	it("rejects private run fan-out fields at the public boundary", () => {

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

@@ -95,9 +95,9 @@ describe("subagent extension RPC bridge", () => {
 			(reply as { data: { capabilities?: { resume?: boolean } } }).data.capabilities?.resume,
 			true,
 		);
-		assert.deepEqual(
+		assert.equal(
 			(reply as { data: { capabilities?: { fleetStatus?: unknown } } }).data.capabilities?.fleetStatus,
-			{ version: 1 },
+			undefined,
 		);
 
 		bridge.dispose();

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

@@ -70,10 +70,10 @@ describe("subagent action recovery", () => {
 	});
 
 	it("routes invalid schedule actions through common recovery", async () => {
-		const result = await createExecutor().execute("invalid-schedule-action", { action: "schedule.lsit" }, new AbortController().signal, undefined, ctx());
+		const result = await createExecutor().execute("invalid-removed-action", { action: "removed.lsit" }, new AbortController().signal, undefined, ctx());
 		assert.equal(result.isError, true);
 		assert.equal(result.content[0]?.type, "text");
-		assert.equal(result.content[0]?.text, unknownSubagentActionMessage("schedule.lsit"));
+		assert.equal(result.content[0]?.text, unknownSubagentActionMessage("removed.lsit"));
 	});
 
 	it("lists and suggests mission decision resolution", () => {

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

@@ -593,7 +593,7 @@ describe("subagent prompt runtime", () => {
 		}
 	});
 
-	it("registers child watchdog lifecycle handlers only when enabled by env", () => {
+	it("does not register child watchdog lifecycle handlers when env is set", () => {
 		delete process.env[CHILD_WATCHDOG_CONFIG_ENV];
 		// Clear the ack capture and steer env vars explicitly: when this test suite itself
 		// runs inside a pi-subagents child, the runner sets them and extra agent_end
@@ -634,9 +634,9 @@ describe("subagent prompt runtime", () => {
 			sendMessage() {},
 		} as { on(event: string, handler: unknown): void; getThinkingLevel(): string; sendMessage(): void });
 
-		assert.ok((handlersWith.get("before_agent_start")?.length ?? 0) >= 2);
-		assert.ok((handlersWith.get("turn_end")?.length ?? 0) >= 1);
-		assert.ok((handlersWith.get("agent_end")?.length ?? 0) >= 2, "watchdog and auto-drain both observe agent_end");
+		assert.equal(handlersWith.get("agent_end")?.length ?? 0, 1, "child watchdog lifecycle handlers are not registered");
+		assert.equal(handlersWith.get("before_agent_start")?.length ?? 0, handlersWithout.get("before_agent_start")?.length ?? 0);
+		assert.equal(handlersWith.get("turn_end")?.length ?? 0, handlersWithout.get("turn_end")?.length ?? 0);
 	});
 
 	it("registered structured_output tool accepts valid schema output and writes the capture file", async () => {

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

@@ -29,11 +29,31 @@ describe("workflow auto-relaunch policy", () => {
 		assert.deepEqual(decision, { relaunch: false, capped: true });
 	});
 
-	it("relaunches indefinitely when the cap is unlimited", () => {
+	it("relaunches indefinitely when the cap is unlimited and progress is omitted", () => {
 		const decision = resolveAutoRelaunchDecision({ result: "budget" }, 50, undefined);
 		assert.deepEqual(decision, { relaunch: true, capped: false });
 	});
 
+	it("stops when usage budget blocks the whole round", () => {
+		const decision = resolveAutoRelaunchDecision({ result: "budget" }, 0, undefined, { launched: 0, fanoutRejected: 0, usageBudgetBlocked: 1, stateWrites: 0 });
+		assert.deepEqual(decision, { relaunch: false, capped: false, stallReason: "usage-budget" });
+	});
+
+	it("stops when fanout rejects every launch", () => {
+		const decision = resolveAutoRelaunchDecision({ result: "budget" }, 1, undefined, { launched: 0, fanoutRejected: 3, usageBudgetBlocked: 0, stateWrites: 0 });
+		assert.deepEqual(decision, { relaunch: false, capped: false, stallReason: "fanout-limited" });
+	});
+
+	it("stops when a budget round makes no progress", () => {
+		const decision = resolveAutoRelaunchDecision({ result: "budget" }, 0, 12, { launched: 0, fanoutRejected: 0, usageBudgetBlocked: 0, stateWrites: 0 });
+		assert.deepEqual(decision, { relaunch: false, capped: false, stallReason: "no-progress" });
+	});
+
+	it("allows a retry when children actually launch", () => {
+		const decision = resolveAutoRelaunchDecision({ result: "budget" }, 1, 12, { launched: 3, fanoutRejected: 0, usageBudgetBlocked: 0, stateWrites: 0 });
+		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);

package/dist/modes/interactive/components/model-selector.d.ts

@@ -2,6 +2,14 @@ import { type Model } from "@earendil-works/pi-ai";
 import { Container, type Focusable, Input, type TUI } from "@earendil-works/pi-tui";
 import type { ModelRuntime } from "../../../core/model-runtime.ts";
 import type { SettingsManager } from "../../../core/settings-manager.ts";
+export interface ModelSelectorOptions {
+    /** Restrict the list (for example, to vision-capable models). */
+    modelFilter?: (model: Model<any>) => boolean;
+    /** Add an "off" choice without changing the active/default model. */
+    allowOff?: boolean;
+    /** Do not persist this selection as the main/default model. */
+    persistSelection?: boolean;
+}
 interface ScopedModelItem {
     model: Model<any>;
     thinkingLevel?: string;
@@ -25,6 +33,7 @@ export declare class ModelSelectorComponent extends Container implements Focusab
     private modelRuntime;
     private onSelectCallback;
     private onCancelCallback;
+    private readonly options;
     private errorMessage?;
     private refreshStatusMessage;
     private refreshStatusSuccess;
@@ -36,7 +45,7 @@ export declare class ModelSelectorComponent extends Container implements Focusab
     private readonly refreshAbortController;
     private refreshTimeout?;
     private closed;
-    constructor(tui: TUI, currentModel: Model<any> | undefined, settingsManager: SettingsManager, modelRuntime: ModelRuntime, scopedModels: ReadonlyArray<ScopedModelItem>, onSelect: (model: Model<any>) => void, onCancel: () => void, initialSearchInput?: string);
+    constructor(tui: TUI, currentModel: Model<any> | undefined, settingsManager: SettingsManager, modelRuntime: ModelRuntime, scopedModels: ReadonlyArray<ScopedModelItem>, onSelect: (model: Model<any> | undefined) => void, onCancel: () => void, initialSearchInput?: string, options?: ModelSelectorOptions);
     private loadModelsFromSnapshot;
     private refreshModels;
     private close;

package/dist/modes/interactive/components/model-selector.js

@@ -30,6 +30,7 @@ export class ModelSelectorComponent extends Container {
     modelRuntime;
     onSelectCallback;
     onCancelCallback;
+    options;
     errorMessage;
     refreshStatusMessage = "Refreshing model catalogs…";
     refreshStatusSuccess = false;
@@ -41,7 +42,7 @@ export class ModelSelectorComponent extends Container {
     refreshAbortController = new AbortController();
     refreshTimeout;
     closed = false;
-    constructor(tui, currentModel, settingsManager, modelRuntime, scopedModels, onSelect, onCancel, initialSearchInput) {
+    constructor(tui, currentModel, settingsManager, modelRuntime, scopedModels, onSelect, onCancel, initialSearchInput, options = {}) {
         super();
         this.tui = tui;
         this.currentModel = currentModel;
@@ -51,6 +52,7 @@ export class ModelSelectorComponent extends Container {
         this.scope = scopedModels.length > 0 ? "scoped" : "all";
         this.onSelectCallback = onSelect;
         this.onCancelCallback = onCancel;
+        this.options = options;
         // Add top border
         this.addChild(new DynamicBorder());
         this.addChild(new Spacer(1));
@@ -100,17 +102,19 @@ export class ModelSelectorComponent extends Container {
             id: model.id,
             model,
         }));
-        this.allModels = this.sortModels(models);
+        this.allModels = this.sortModels(models).filter((item) => !this.options.modelFilter || this.options.modelFilter(item.model));
         this.scopedModels = this.scopedModels.map((scoped) => {
             const refreshed = this.modelRuntime.getModel(scoped.model.provider, scoped.model.id);
             return refreshed ? { ...scoped, model: refreshed } : scoped;
         });
-        this.scopedModelItems = this.scopedModels.map((scoped) => ({
+        this.scopedModelItems = this.scopedModels.filter((scoped) => !this.options.modelFilter || this.options.modelFilter(scoped.model)).map((scoped) => ({
             provider: scoped.model.provider,
             id: scoped.model.id,
             model: scoped.model,
         }));
         this.activeModels = this.scope === "scoped" ? this.scopedModelItems : this.allModels;
+        if (this.options.allowOff)
+            this.activeModels = [{ provider: "", id: "off", model: { provider: "", id: "off", name: "Disabled", input: ["text"] } }, ...this.activeModels];
         this.filteredModels = this.activeModels;
         const currentIndex = this.filteredModels.findIndex((item) => modelsAreEqual(this.currentModel, item.model));
         this.selectedIndex =
@@ -303,9 +307,9 @@ export class ModelSelectorComponent extends Container {
     }
     handleSelect(model) {
         this.close();
-        // Save as new default
-        this.settingsManager.setDefaultModelAndProvider(model.provider, model.id);
-        this.onSelectCallback(model);
+        if (model.id !== "off" && this.options.persistSelection !== false)
+            this.settingsManager.setDefaultModelAndProvider(model.provider, model.id);
+        this.onSelectCallback(model.id === "off" ? undefined : model);
     }
     getSearchInput() {
         return this.searchInput;

package/dist/modes/interactive/components/settings-selector.d.ts

@@ -3,6 +3,7 @@ import type { Transport } from "@earendil-works/pi-ai";
 import { Container, type ScrollViewScrollbar, SettingsList } from "@earendil-works/pi-tui";
 import type { DefaultProjectTrust, FullscreenExitOutput, TuiMode, WarningSettings } from "../../../core/settings-manager.ts";
 import { type TerminalTheme } from "../theme/theme.ts";
+import type { ModelSelectorComponent } from "./model-selector.ts";
 export interface SkillToggleItem {
     name: string;
     enabled: boolean;
@@ -21,6 +22,7 @@ export interface SettingsConfig {
     imageCaptionModel: string | undefined;
     imageCaptionContextTokens: number;
     visionModels: string[];
+    visionModelSelector?: (currentValue: string, done: () => void) => ModelSelectorComponent;
     steeringMode: "all" | "one-at-a-time";
     followUpMode: "all" | "one-at-a-time";
     transport: Transport;

package/dist/modes/interactive/components/settings-selector.js

@@ -528,6 +528,9 @@ export class SettingsSelectorComponent extends Container {
             description: "Model used to describe images when the main model can't see them (off disables)",
             currentValue: currentCaptionModel,
             values: visionModelValues,
+            submenu: config.visionModelSelector
+                ? (currentValue, done) => config.visionModelSelector(currentValue, done)
+                : undefined,
         });
         // Vision caption context-token budget
         const captionModelIndex = items.findIndex((item) => item.id === "image-caption-model");

package/dist/modes/interactive/interactive-mode.js

@@ -3682,6 +3682,11 @@ export class InteractiveMode {
                 imageCaptionModel: this.settingsManager.getImageCaptionModel(),
                 imageCaptionContextTokens: this.settingsManager.getImageCaptionContextTokens(),
                 visionModels: this.getVisionModels(),
+                visionModelSelector: (currentValue, selectorDone) => new ModelSelectorComponent(this.ui, undefined, this.settingsManager, this.session.modelRuntime, this.session.scopedModels, (model) => {
+                    this.settingsManager.setImageCaptionModel(model ? `${model.provider}/${model.id}` : undefined);
+                    selectorDone();
+                    this.showStatus(model ? `Vision caption model: ${model.provider}/${model.id}` : "Vision captioning disabled");
+                }, selectorDone, currentValue === "off" ? undefined : currentValue, { modelFilter: (model) => model.input.includes("image"), allowOff: true, persistSelection: false }),
                 steeringMode: this.session.steeringMode,
                 followUpMode: this.session.followUpMode,
                 transport: this.settingsManager.getTransport(),
@@ -4081,6 +4086,8 @@ export class InteractiveMode {
     showModelSelector(initialSearchInput) {
         this.showSelector((done) => {
             const selector = new ModelSelectorComponent(this.ui, this.session.model, this.settingsManager, this.session.modelRuntime, this.session.scopedModels, async (model) => {
+                if (!model)
+                    return;
                 try {
                     await this.session.setModel(model);
                     this.footer.invalidate();

package/dist/skills/pi-subagents/references/constraints-and-recipes.md

@@ -19,7 +19,7 @@ This file is a detailed reference loaded from `skills/pi-subagents/SKILL.md`.
   become second decision-makers.
 - **Respect the fixed authority policy.** `authorityPolicy` is a small `auto` / `confirm` / `forbid` map for supported operational actions. Worktree discard, destructive cleanup, and spawn-budget grants default to confirmation; stop, steer, and schedule creation remain automatic. Use `worktree.discard` with the durable `handoffPath`; confirm-required actions refuse safely without an interactive UI and retained paths include manual Git recovery commands.
 
-Runtime config can change orchestration behavior. `intercomBridge.resultDelivery: false` disables only external acknowledged grouped-result delivery when native parent notifications own completion; supervisor asks/progress stay active, and enabled transport failures are still reported. `asyncByDefault` and `forceTopLevelAsync` affect whether launches detach; `waitTool` can make direct `subagent_wait()` calls return immediately while headless auto-drain remains active, and its effective value is propagated to child runtimes; `globalConcurrencyLimit` bounds concurrent fanout, while a positive `maxSubagentSpawnsPerSession` optionally caps cumulative launches (`0` or unset is unlimited). Status and doctor report the budget; static work preflights declared capacity; only the settled root interactive parent can use `grant-spawn-budget` after native confirmation, with total grants bounded by the original cap. Compaction does not reset usage or grants; `singleRunOutputBaseDir` and `worktreeBaseDir` route outputs and worktrees; `completionBatch` groups async notifications. `artifactDir` is `project` (default), `session`, or `temp` and chooses where subagent artifacts are stored. Set `asyncWidget: false` to hide the above-editor background-run widget when a companion footer or dashboard owns that space (fleet inspector remains available). Per-run `artifacts: false` disables artifact capture for that launch. Async status and result artifacts include `lifecycleArtifactVersion` and fields such as `workflowGraph`, `steps`, `results`, `totalTokens`, `totalCost`, `turnCount`, `toolCount`, and nested `children`. Child protocol failures expose a structured `protocolError`; `protocol_output_limit` means a child emitted a JSONL line above the 16 MiB live-parser cap. Prefer these artifacts and `status` views over scraping terminal output.
+Runtime config can change orchestration behavior. `intercomBridge.resultDelivery: false` disables only external acknowledged grouped-result delivery when native parent notifications own completion; supervisor asks/progress stay active, and enabled transport failures are still reported. `asyncByDefault` and `forceTopLevelAsync` affect whether launches detach; `waitTool` can make direct `subagent_wait()` calls return immediately while headless auto-drain remains active, and its effective value is propagated to child runtimes; `globalConcurrencyLimit` bounds concurrent fanout, while a positive `maxSubagentSpawnsPerSession` optionally caps cumulative launches (`0` or unset is unlimited). Status and doctor report the budget; static work preflights declared capacity; only the settled root interactive parent can use `grant-spawn-budget` after native confirmation, with total grants bounded by the original cap. Compaction does not reset usage or grants; `singleRunOutputBaseDir` and `worktreeBaseDir` route outputs and worktrees; `completionBatch` groups async notifications. `artifactDir` is `project` (default), `session`, or `temp` and chooses where subagent artifacts are stored. Set `asyncWidget: false` to hide the above-editor background-run widget when a companion footer or dashboard owns that space (run status view remains available). Per-run `artifacts: false` disables artifact capture for that launch. Async status and result artifacts include `lifecycleArtifactVersion` and fields such as `workflowGraph`, `steps`, `results`, `totalTokens`, `totalCost`, `turnCount`, `toolCount`, and nested `children`. Child protocol failures expose a structured `protocolError`; `protocol_output_limit` means a child emitted a JSONL line above the 16 MiB live-parser cap. Prefer these artifacts and `status` views over scraping terminal output.
 
 ## Best Practices
 

package/dist/skills/pi-subagents/references/execution-controls.md

@@ -186,7 +186,7 @@ const run = subagent({
 // Continue local inspection, then later call status with the returned id.
 ```
 
-While children run, the persistent FleetView and the collapsed foreground tool-result card show live per-child detail: resolved model and thinking level, `[fresh]`/`[fork]` context, tool/token/elapsed counters, and current activity. The collapsed running card also prints the configured expand-key hint ("Press … for live detail"); expanding it shows nested children, recent tools, and recent output. Model badges appear once the child's model resolves at first attempt start. `/subagents-fleet` opens the live fleet inspector, which also has per-child controls (`s` steer, `D` stop with confirmation). When optional Herdr 0.7.5+ is available, `H` opens a raw inspector dashboard for the selected active async child; this mirrors artifacts rather than attaching to the headless child. Use it for confusing or long-running active async work when the human wants a dedicated visual pane or FleetView is insufficient, not for routine headless runs.
+While children run, the persistent run status and the collapsed foreground tool-result card show live per-child detail: resolved model and thinking level, `[fresh]`/`[fork]` context, tool/token/elapsed counters, and current activity. The collapsed running card also prints the configured expand-key hint ("Press … for live detail"); expanding it shows nested children, recent tools, and recent output. Model badges appear once the child's model resolves at first attempt start. `subagent({ action: "status" })` opens the live run status view, which also has per-child controls (`s` steer, `D` stop with confirmation). When optional Herdr 0.7.5+ is available, `H` opens a raw inspector dashboard for the selected active async child; this mirrors artifacts rather than attaching to the headless child. Use it for confusing or long-running active async work when the human wants a dedicated visual pane or run status is insufficient, not for routine headless runs.
 
 Inspect async runs with `subagent({ action: "status", id: "..." })` or `subagent({ action: "status" })` for active runs. Use `subagent({ action: "status", view: "fleet" })` when supervising several active foreground/background runs and `subagent({ action: "status", id: "...", view: "transcript", index: 0 })` when you need the latest child output without digging through artifacts. If a delegated fanout child launches nested runs, the parent status view shows them as a tree and you can target a nested run directly with its nested id.
 
@@ -236,31 +236,6 @@ Use native `subagent` runs for unattended implementation, review, and gate work
 
 A cooperating terminal runtime can register read-only external records through `pi-subagents/external-runs`. Records include the source, session, state, optional report path, and completion reason. They are observations only: pi-subagents does not start, stop, steer, or otherwise own the foreign process. Run unattended raw terminal agents in an explicit isolated cwd or worktree; do not use a live project checkout as disposable review space.
 
-### Scheduled subagent runs
-
-Schedules are durable project records under `.pi-subagents/schedules/`. They are enabled by default; set `{ "scheduledRuns": { "enabled": false } }` in `~/.selesai/agent/extensions/subagent/config.json` to disable them. Only schedule explicit work the user asked for.
-
-```typescript
-// One-shot reviewer
-subagent({ action: "schedule.create", id: "evening-review", name: "Evening review", at: "+30m", workflowScript: "return runs.run('main', { agent: 'reviewer', task: 'Review the diff.' })" })
-
-// Fixed recurring workflow
-subagent({ action: "schedule.create", id: "backlog", every: "6h", catchUp: "latest", workflowScript: "..." })
-
-subagent({ action: "schedule.list" })
-subagent({ action: "schedule.show", id: "backlog" })
-subagent({ action: "schedule.history", id: "backlog" })
-subagent({ action: "schedule.pause", id: "backlog" })
-subagent({ action: "schedule.resume", id: "backlog" })
-subagent({ action: "schedule.run", id: "backlog" })
-subagent({ action: "schedule.run-due" })
-subagent({ action: "schedule.delete", id: "backlog" })
-```
-
-`schedule.create` accepts exactly one target, `workflowScript`, and exactly one trigger (`at`, or a fixed `every` interval using `m`, `h`, `d`, or `w`). Runs always launch async with fresh context and no automatic mission; mission attachment is deferred from this first slice. `overlap` is currently `skip`; `catchUp` supports `latest` and `none`. `schedule.run-due` is the headless external-launcher seam. Calendar recurrence, cron, and the schedule inspector are deferred from this first safe slice. Definitions, bounded history, append-only events, and per-run receipts remain project-scoped across Selesai sessions.
-
-Humans can use `/subagents-doctor` for the same read-only report. It checks runtime paths, discovery counts, async support, current session context, and intercom bridge state.
-
 ### Subagent control
 
 Subagent control is the runtime visibility and intervention layer for delegated runs. It is separate from lifecycle status. Lifecycle status says whether a child is `queued`, `running`, `paused`, `complete`, `stopped`, `failed`, or `rejected`. Activity reporting is factual: it tracks the last observed activity time and the current tool when known. It does not pretend to know that a child is truly stuck. Manual top-level async cancellation uses `stop` / `/subagents-stop`; a live async chain can gain one more tail step via `append-step`, and a paused async chain checkpoint can be decided with `approve-checkpoint` or `reject-checkpoint`.
@@ -326,10 +301,7 @@ are always transcript-visible; choose the watchdog model that matches the desire
 cheap-monitor vs strong-reviewer policy.
 
 Prefer a strong complementary model (for example Opus 4.8 high paired against a
-GPT 5.5 main session, or the reverse). Recommendation and configuration:
-
-```text
-/subagents-watchdog recommend-model
+GPT 5.5 main session, or the reverse). ```text
 /subagents-watchdog session model recommended
 /subagents-watchdog on
 /subagents-watchdog status
@@ -338,8 +310,6 @@ GPT 5.5 main session, or the reverse). Recommendation and configuration:
 
 ```typescript
 subagent({ action: "watchdog.status" })
-subagent({ action: "watchdog.recommend-model" })
-subagent({ action: "watchdog.configure", model: "recommended", scope: "session" })
 subagent({ action: "watchdog.check" })
 ```
 

package/dist/skills/pi-subagents/references/management-authoring-rpc.md

@@ -161,4 +161,4 @@ Native chain and parallel steps are also launchable directly from the command li
 
 Other Selesai extensions can call `pi-subagents` through the in-process event bus. The RPC channels are `subagents:rpc:v1:ready`, `subagents:rpc:v1:request`, and per-request replies at `subagents:rpc:v1:reply:<requestId>`. Envelopes use `{ version: 1, requestId, method, params }`, and replies use `{ version: 1, requestId, success, data | error }`. `ping` advertises the exact process-local async completion event as `events.asyncComplete` for RPC-spawn consumers.
 
-Methods: `ping`, `status`, `spawn`, `steer`, `interrupt`, `resume`, and `stop`. `ping` capability metadata advertises optional projections: `capabilities.fleetStatus: { version: 1 }` adds bounded current-session `data.fleet` records (opaque reconciliation `key`, resolved `agent`, optional `role`, `model`, `effort`, caller-facing `goal`, `startedAt`, split `{ input, output, total }` tokens, plus `totalActive`/`omitted` overflow counts) to successful `status` replies; `capabilities.launchResolvedExtensions` advertises parent-resolved opaque launch-extension identifiers in status details; `capabilities.runtimeAcknowledgedExtensions` advertises the best-effort child-runtime acknowledgement projection fed by cooperating extensions emitting `subagent:acknowledge-extension`. Foreground `details.results[]` rows carry a stable numeric `index`; correlate children by `(runId, index)` rather than row position. Consumers should read status/result artifacts and RPC projections instead of scraping terminal output and must ignore unknown fields. `spawn` requires `workflowScript`, is async-only, and rejects management actions, `async: false`, or `clarify: true`; it reuses the normal executor, so discovery, validation, session attribution, configured spawn caps, child-safety depth, artifacts, and async status are shared with the `subagent` tool. `status`, acknowledged async `steer`, and `interrupt` map to the normal control actions. RPC steer disables pause-and-revive recovery and advertises `capabilities.nonRecoveringSteer`, preserving the caller's authority over the exact spawned child. `resume` requires a target plus non-empty message and delegates to the package-owned revival path; it may set a caller-owned `file-only` output path but cannot override the persisted child model, tools, budgets, session ownership, or exclusive session lease. For retained-child workflows, list children first and resume only rows reported `resumable`; otherwise start a same-role fallback challenge and label it as fallback. `stop` targets running async runs through the existing timeout control channel. `pi.events` is process-local, so separate Selesai processes and child subagents need lifecycle artifact files or `pi-intercom` instead.
+Methods: `ping`, `status`, `spawn`, `steer`, `interrupt`, `resume`, and `stop`. `ping` capability metadata advertises optional projections: `capabilities.launchResolvedExtensions` advertises parent-resolved opaque launch-extension identifiers in status details; `capabilities.runtimeAcknowledgedExtensions` advertises the best-effort child-runtime acknowledgement projection fed by cooperating extensions emitting `subagent:acknowledge-extension`. Foreground `details.results[]` rows carry a stable numeric `index`; correlate children by `(runId, index)` rather than row position. Consumers should read status/result artifacts and RPC projections instead of scraping terminal output and must ignore unknown fields. `spawn` requires `workflowScript`, is async-only, and rejects management actions, `async: false`, or `clarify: true`; it reuses the normal executor, so discovery, validation, session attribution, configured spawn caps, child-safety depth, artifacts, and async status are shared with the `subagent` tool. `status`, acknowledged async `steer`, and `interrupt` map to the normal control actions. RPC steer disables pause-and-revive recovery and advertises `capabilities.nonRecoveringSteer`, preserving the caller's authority over the exact spawned child. `resume` requires a target plus non-empty message and delegates to the package-owned revival path; it may set a caller-owned `file-only` output path but cannot override the persisted child model, tools, budgets, session ownership, or exclusive session lease. For retained-child workflows, list children first and resume only rows reported `resumable`; otherwise start a same-role fallback challenge and label it as fallback. `stop` targets running async runs through the existing timeout control channel. `pi.events` is process-local, so separate Selesai processes and child subagents need lifecycle artifact files or `pi-intercom` instead.