gentle-pi 0.2.7 → 0.3.0

package/lib/sdd-preflight.ts

@@ -0,0 +1,253 @@
+import { existsSync, mkdirSync, readdirSync, readFileSync, writeFileSync } from "node:fs";
+import { dirname, join } from "node:path";
+import { fileURLToPath } from "node:url";
+import type { ExtensionAPI, ExtensionContext } from "@earendil-works/pi-coding-agent";
+
+const PACKAGE_ROOT = dirname(dirname(fileURLToPath(import.meta.url)));
+const ASSETS_DIR = join(PACKAGE_ROOT, "assets");
+
+export type SddExecutionMode = "interactive" | "auto";
+export type SddArtifactStore = "openspec" | "engram" | "both";
+export type SddChainedPrStrategy =
+	| "auto-forecast"
+	| "ask-always"
+	| "single-pr-default"
+	| "force-chained";
+
+export interface SddPreflightPreferences {
+	executionMode: SddExecutionMode;
+	artifactStore: SddArtifactStore;
+	chainedPrStrategy: SddChainedPrStrategy;
+	reviewBudgetLines: number;
+	engramAvailable: boolean;
+}
+
+interface SddPreflightCallbacks {
+	pi: ExtensionAPI;
+	installAssets?: (cwd: string) => {
+		agents: number;
+		chains: number;
+		support: number;
+		skipped: number;
+	};
+	applyModelConfig?: (cwd: string) => { updated: number; skipped: number };
+}
+
+const DEFAULT_SDD_PREFLIGHT: SddPreflightPreferences = {
+	executionMode: "interactive",
+	artifactStore: "openspec",
+	chainedPrStrategy: "auto-forecast",
+	reviewBudgetLines: 400,
+	engramAvailable: false,
+};
+
+const sddPreflightBySession = new Map<string, SddPreflightPreferences>();
+const sddPreflightInFlight = new Map<string, Promise<SddPreflightPreferences>>();
+
+function isRecord(value: unknown): value is Record<string, unknown> {
+	return typeof value === "object" && value !== null && !Array.isArray(value);
+}
+
+function copyDirectoryFiles(
+	sourceDir: string,
+	targetDir: string,
+	force: boolean,
+): { copied: number; skipped: number } {
+	if (!existsSync(sourceDir)) return { copied: 0, skipped: 0 };
+	mkdirSync(targetDir, { recursive: true });
+	let copied = 0;
+	let skipped = 0;
+	for (const entry of readdirSync(sourceDir, { withFileTypes: true })) {
+		const sourcePath = join(sourceDir, entry.name);
+		const targetPath = join(targetDir, entry.name);
+		if (entry.isDirectory()) {
+			const child = copyDirectoryFiles(sourcePath, targetPath, force);
+			copied += child.copied;
+			skipped += child.skipped;
+			continue;
+		}
+		if (!entry.isFile()) continue;
+		if (!force && existsSync(targetPath)) {
+			skipped += 1;
+			continue;
+		}
+		writeFileSync(targetPath, readFileSync(sourcePath));
+		copied += 1;
+	}
+	return { copied, skipped };
+}
+
+export function installSddAssets(
+	cwd: string,
+	force: boolean,
+): { agents: number; chains: number; support: number; skipped: number } {
+	const agents = copyDirectoryFiles(
+		join(ASSETS_DIR, "agents"),
+		join(cwd, ".pi", "agents"),
+		force,
+	);
+	const chains = copyDirectoryFiles(
+		join(ASSETS_DIR, "chains"),
+		join(cwd, ".pi", "chains"),
+		force,
+	);
+	const support = copyDirectoryFiles(
+		join(ASSETS_DIR, "support"),
+		join(cwd, ".pi", "gentle-ai", "support"),
+		force,
+	);
+	return {
+		agents: agents.copied,
+		chains: chains.copied,
+		support: support.copied,
+		skipped: agents.skipped + chains.skipped + support.skipped,
+	};
+}
+
+export function isSddPreflightTrigger(text: string): boolean {
+	return /^\/sdd-[^\s]*(?:\s|$)/i.test(text.trim());
+}
+
+export function sddPreflightSessionKey(ctx: ExtensionContext): string {
+	const manager = (ctx as unknown as { sessionManager?: unknown }).sessionManager;
+	if (isRecord(manager)) {
+		const getSessionFile = manager.getSessionFile;
+		if (typeof getSessionFile === "function") {
+			const value = getSessionFile.call(manager);
+			if (typeof value === "string" && value.length > 0) return value;
+		}
+		const getSessionId = manager.getSessionId;
+		if (typeof getSessionId === "function") {
+			const value = getSessionId.call(manager);
+			if (typeof value === "string" && value.length > 0) return value;
+		}
+	}
+	return ctx.cwd;
+}
+
+function hasWritableEngramTool(pi: ExtensionAPI): boolean {
+	try {
+		const getActiveTools = (pi as unknown as { getActiveTools?: () => unknown[] })
+			.getActiveTools;
+		if (typeof getActiveTools !== "function") return false;
+		const tools = getActiveTools.call(pi);
+		return tools.some((tool) => {
+			const name =
+				typeof tool === "string"
+					? tool
+					: isRecord(tool) && typeof tool.name === "string"
+						? tool.name
+						: "";
+			return (
+				name === "mem_save" ||
+				name === "engram_mem_save" ||
+				name.endsWith(".mem_save") ||
+				name.endsWith(".engram_mem_save")
+			);
+		});
+	} catch {
+		return false;
+	}
+}
+
+function normalizeSddReviewBudget(value: string): number {
+	const parsed = Number.parseInt(value.trim(), 10);
+	return Number.isFinite(parsed) && parsed > 0 ? parsed : 400;
+}
+
+async function collectSddPreflightPreferences(
+	ctx: ExtensionContext,
+	engramAvailable: boolean,
+): Promise<SddPreflightPreferences> {
+	if (!ctx.hasUI) return { ...DEFAULT_SDD_PREFLIGHT, engramAvailable };
+	const executionMode = await ctx.ui.select("SDD execution mode", [
+		"interactive",
+		"auto",
+	]);
+	const artifactOptions = engramAvailable
+		? ["openspec", "engram", "both"]
+		: ["openspec"];
+	const artifactStore = await ctx.ui.select("SDD artifact store", artifactOptions);
+	const chainedPrStrategy = await ctx.ui.select("SDD PR chaining", [
+		"auto-forecast",
+		"ask-always",
+		"single-pr-default",
+		"force-chained",
+	]);
+	const reviewBudgetLines = normalizeSddReviewBudget(
+		(await ctx.ui.input("SDD review budget lines", "400")) ?? "400",
+	);
+	return {
+		executionMode:
+			executionMode === "auto" ? "auto" : DEFAULT_SDD_PREFLIGHT.executionMode,
+		artifactStore:
+			artifactStore === "engram" || artifactStore === "both"
+				? artifactStore
+				: DEFAULT_SDD_PREFLIGHT.artifactStore,
+		chainedPrStrategy:
+			chainedPrStrategy === "ask-always" ||
+			chainedPrStrategy === "single-pr-default" ||
+			chainedPrStrategy === "force-chained"
+				? chainedPrStrategy
+				: DEFAULT_SDD_PREFLIGHT.chainedPrStrategy,
+		reviewBudgetLines,
+		engramAvailable,
+	};
+}
+
+export function renderSddPreflightPrompt(prefs: SddPreflightPreferences): string {
+	return [
+		"## SDD Session Preflight",
+		"The user already chose these SDD preferences for this Pi session. Reuse them unless the user explicitly changes them.",
+		`- Execution mode: ${prefs.executionMode}`,
+		`- Artifact store: ${prefs.artifactStore}${prefs.engramAvailable ? "" : " (Engram unavailable in this session)"}`,
+		`- Chained PR strategy: ${prefs.chainedPrStrategy}`,
+		`- Review budget: ${prefs.reviewBudgetLines} changed lines`,
+		"- If task/workload forecasts conflict with these preferences, pause before sdd-apply and ask the user for a delivery decision.",
+	].join("\n");
+}
+
+export async function ensureSddPreflight(
+	ctx: ExtensionContext,
+	callbacks: SddPreflightCallbacks,
+): Promise<SddPreflightPreferences> {
+	const sessionKey = sddPreflightSessionKey(ctx);
+	const existing = sddPreflightBySession.get(sessionKey);
+	if (existing) return existing;
+	const inFlight = sddPreflightInFlight.get(sessionKey);
+	if (inFlight) return inFlight;
+	const promise = (async () => {
+		const engramAvailable = hasWritableEngramTool(callbacks.pi);
+		const prefs = await collectSddPreflightPreferences(ctx, engramAvailable);
+		const result = callbacks.installAssets?.(ctx.cwd) ?? installSddAssets(ctx.cwd, false);
+		const modelResult = callbacks.applyModelConfig?.(ctx.cwd) ?? { updated: 0, skipped: 0 };
+		if (ctx.hasUI) {
+			ctx.ui.notify(
+				[
+					"Gentle AI SDD preflight complete.",
+					`Mode: ${prefs.executionMode}`,
+					`Artifacts: ${prefs.artifactStore}`,
+					`PR chaining: ${prefs.chainedPrStrategy}`,
+					`Review budget: ${prefs.reviewBudgetLines} changed lines`,
+					`Assets installed: ${result.agents} agent(s), ${result.chains} chain(s), ${result.support} support file(s), ${result.skipped} skipped.`,
+					`Model-routed agents updated: ${modelResult.updated}`,
+				].join("\n"),
+				"info",
+			);
+		}
+		sddPreflightBySession.set(sessionKey, prefs);
+		return prefs;
+	})();
+	sddPreflightInFlight.set(sessionKey, promise);
+	try {
+		return await promise;
+	} finally {
+		sddPreflightInFlight.delete(sessionKey);
+	}
+}
+
+export function getSddPreflightPreferences(
+	ctx: ExtensionContext,
+): SddPreflightPreferences | undefined {
+	return sddPreflightBySession.get(sddPreflightSessionKey(ctx));
+}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "gentle-pi",
-  "version": "0.2.7",
+  "version": "0.3.0",
   "description": "Turn Pi into el Gentleman: a senior-architect development harness with SDD/OpenSpec, subagents, strict TDD evidence, review guardrails, and skill discovery.",
   "license": "MIT",
   "type": "module",
@@ -25,6 +25,7 @@
   "files": [
     "assets/",
     "extensions/",
+    "lib/",
     "prompts/",
     "skills/",
     "scripts/",

package/scripts/verify-package-files.mjs

@@ -12,6 +12,7 @@ const requiredPaths = [
   "extensions/gentle-ai.ts",
   "extensions/sdd-init.ts",
   "extensions/skill-registry.ts",
+  "lib/sdd-preflight.ts",
   "prompts/gcl.md",
   "prompts/gis.md",
   "prompts/gpr.md",

package/tests/runtime-harness.mjs

@@ -1,8 +1,10 @@
 #!/usr/bin/env node
 import assert from "node:assert/strict";
-import { mkdtemp, rm } from "node:fs/promises";
+import { existsSync } from "node:fs";
+import { mkdtemp, mkdir, readFile, rm, writeFile } from "node:fs/promises";
 import { tmpdir } from "node:os";
 import { dirname, join } from "node:path";
+import { discoverAndLoadExtensions } from "@earendil-works/pi-coding-agent";
 import { fileURLToPath, pathToFileURL } from "node:url";
 
 const ROOT = dirname(dirname(fileURLToPath(import.meta.url)));
@@ -15,6 +17,8 @@ const EXTENSIONS = [
 
 const EXPECTED_COMMANDS = [
 	"gentle-ai:install-sdd",
+	"gentle-ai:sdd-preflight",
+	"gentle:sdd-preflight",
 	"gentle:models",
 	"gentle-ai:models",
 	"gentleman:models",
@@ -31,6 +35,7 @@ function createPi() {
 	const commands = new Map();
 	const flags = new Map();
 	const flagValues = new Map([["no-skill-registry", true]]);
+	let activeTools = ["read", "bash", "edit", "write"];
 
 	const pi = {
 		on(name, handler) {
@@ -53,12 +58,19 @@ function createPi() {
 		getCommands() {
 			return Array.from(commands, ([name, definition]) => ({ name, ...definition }));
 		},
+		getActiveTools() {
+			return activeTools;
+		},
+		setActiveTools(value) {
+			activeTools = value;
+		},
 		getAllTools() {
 			return [
 				{ name: "read" },
 				{ name: "bash" },
 				{ name: "edit" },
 				{ name: "write" },
+				{ name: "mem_save" },
 			];
 		},
 	};
@@ -68,15 +80,18 @@ function createPi() {
 
 function createUi() {
 	const notifications = [];
+	const selections = [];
 	return {
 		notifications,
+		selections,
 		notify(message, level = "info") {
 			notifications.push({ message, level });
 		},
 		async confirm() {
 			return false;
 		},
-		async select(_label, options) {
+		async select(label, options) {
+			selections.push({ label, options });
 			return options[0];
 		},
 		async input(_label, placeholder) {
@@ -88,11 +103,19 @@ function createUi() {
 	};
 }
 
-function createCtx(cwd, hasUI = false) {
+function createCtx(cwd, hasUI = false, sessionId = "session-1") {
 	return {
 		cwd,
 		hasUI,
 		ui: createUi(),
+		sessionManager: {
+			getSessionFile() {
+				return join(cwd, `${sessionId}.jsonl`);
+			},
+			getSessionId() {
+				return sessionId;
+			},
+		},
 		modelRegistry: {
 			async getAvailable() {
 				return [];
@@ -122,9 +145,17 @@ async function run() {
 	}
 	assert.ok(flags.has("no-skill-registry"), "missing no-skill-registry flag");
 	assert.ok(hooks.has("session_start"), "missing session_start hook");
+	assert.ok(hooks.has("input"), "missing input hook");
 	assert.ok(hooks.has("before_agent_start"), "missing before_agent_start hook");
 	assert.ok(hooks.has("tool_call"), "missing tool_call hook");
 
+	const discovered = await discoverAndLoadExtensions(["./extensions"], ROOT);
+	assert.deepEqual(
+		discovered.errors,
+		[],
+		"declared extension directory must load without invalid helper modules",
+	);
+
 	const promptCwd = await tempWorkspace();
 	try {
 		const promptHook = hooks.get("before_agent_start")[0];
@@ -154,10 +185,146 @@ async function run() {
 		for (const handler of hooks.get("session_start")) {
 			await handler({ reason: "startup" }, createCtx(noUiCwd, false));
 		}
+		assert.equal(
+			existsSync(join(noUiCwd, ".pi", "agents", "sdd-apply.md")),
+			false,
+			"session_start must not install SDD agents before first SDD intent",
+		);
+		assert.equal(
+			existsSync(join(noUiCwd, ".pi", "chains", "sdd-full.chain.md")),
+			false,
+			"session_start must not install SDD chains before first SDD intent",
+		);
 	} finally {
 		await rm(noUiCwd, { recursive: true, force: true });
 	}
 
+	const lazySddCwd = await tempWorkspace();
+	try {
+		await mkdir(join(lazySddCwd, ".pi", "gentle-ai"), { recursive: true });
+		await writeFile(
+			join(lazySddCwd, ".pi", "gentle-ai", "models.json"),
+			JSON.stringify({ "sdd-apply": { model: "openai/gpt-5", thinking: "high" } }, null, 2),
+		);
+		const ctx = createCtx(lazySddCwd, true);
+		const inputHook = hooks.get("input")[0];
+		assert.deepEqual(
+			await inputHook({ text: "hola, solo mirando", source: "interactive" }, ctx),
+			{ action: "continue" },
+		);
+		assert.deepEqual(
+			await inputHook({ text: "what is SDD?", source: "interactive" }, ctx),
+			{ action: "continue" },
+		);
+		assert.deepEqual(
+			await inputHook({ text: "what can I do with SDD?", source: "interactive" }, ctx),
+			{ action: "continue" },
+		);
+		assert.deepEqual(
+			await inputHook({ text: "how do I use SDD?", source: "interactive" }, ctx),
+			{ action: "continue" },
+		);
+		assert.deepEqual(
+			await inputHook({ text: "Can I use SDD?", source: "interactive" }, ctx),
+			{ action: "continue" },
+		);
+		assert.deepEqual(
+			await inputHook({ text: "don't use sdd for this", source: "interactive" }, ctx),
+			{ action: "continue" },
+		);
+		assert.deepEqual(
+			await inputHook({ text: "sin usar SDD por ahora", source: "interactive" }, ctx),
+			{ action: "continue" },
+		);
+		assert.deepEqual(
+			await inputHook({ text: "let's not use SDD for this", source: "interactive" }, ctx),
+			{ action: "continue" },
+		);
+		assert.deepEqual(
+			await inputHook({ text: "never use SDD here", source: "interactive" }, ctx),
+			{ action: "continue" },
+		);
+		assert.deepEqual(
+			await inputHook({ text: "no quiero usar SDD por ahora", source: "interactive" }, ctx),
+			{ action: "continue" },
+		);
+		assert.deepEqual(
+			await inputHook({ text: "I use SDD sometimes", source: "interactive" }, ctx),
+			{ action: "continue" },
+		);
+		assert.deepEqual(
+			await inputHook({ text: "I'm using SDD in another repo", source: "interactive" }, ctx),
+			{ action: "continue" },
+		);
+		assert.equal(existsSync(join(lazySddCwd, ".pi", "agents", "sdd-apply.md")), false);
+
+		assert.deepEqual(
+			await inputHook({ text: "please use sdd for this change", source: "interactive" }, ctx),
+			{ action: "continue" },
+		);
+		assert.deepEqual(
+			await inputHook({ text: "/sdd", source: "interactive" }, ctx),
+			{ action: "continue" },
+		);
+		assert.deepEqual(
+			await inputHook({ text: "/sdd plan", source: "interactive" }, ctx),
+			{ action: "continue" },
+		);
+		assert.deepEqual(
+			await inputHook({ text: "/sdd:plan", source: "interactive" }, ctx),
+			{ action: "continue" },
+		);
+		assert.equal(existsSync(join(lazySddCwd, ".pi", "agents", "sdd-apply.md")), false);
+
+		assert.deepEqual(
+			await inputHook({ text: "/sdd-plan this change", source: "interactive" }, ctx),
+			{ action: "continue" },
+		);
+		assert.equal(existsSync(join(lazySddCwd, ".pi", "agents", "sdd-apply.md")), true);
+		assert.equal(existsSync(join(lazySddCwd, ".pi", "chains", "sdd-full.chain.md")), true);
+		const lazyAppliedAgent = await readFile(
+			join(lazySddCwd, ".pi", "agents", "sdd-apply.md"),
+			"utf8",
+		);
+		assert.match(lazyAppliedAgent, /model: openai\/gpt-5/);
+		assert.match(lazyAppliedAgent, /thinking: high/);
+		assert.equal(ctx.ui.selections.length, 3);
+		assert.deepEqual(ctx.ui.selections[1].options, ["openspec"]);
+		assert.match(ctx.ui.notifications.at(-1).message, /SDD preflight complete/);
+
+		await inputHook({ text: "/sdd-plan another change", source: "interactive" }, ctx);
+		assert.equal(ctx.ui.selections.length, 3, "preflight should run only once per session");
+		const promptHook = hooks.get("before_agent_start")[0];
+		const promptResult = promptHook({ systemPrompt: "base" }, ctx);
+		assert.match(promptResult.systemPrompt, /SDD Session Preflight/);
+		assert.match(promptResult.systemPrompt, /Execution mode: interactive/);
+	} finally {
+		await rm(lazySddCwd, { recursive: true, force: true });
+	}
+
+	const commandSddCwd = await tempWorkspace();
+	try {
+		const ctx = createCtx(commandSddCwd, true, "command-session");
+		await commands.get("gentle-ai:sdd-preflight").handler("", ctx);
+		assert.equal(existsSync(join(commandSddCwd, ".pi", "agents", "sdd-apply.md")), true);
+		assert.equal(ctx.ui.selections.length, 3);
+		await commands.get("gentle:sdd-preflight").handler("", ctx);
+		assert.equal(ctx.ui.selections.length, 3, "manual preflight command should reuse session choices");
+	} finally {
+		await rm(commandSddCwd, { recursive: true, force: true });
+	}
+
+	const engramSddCwd = await tempWorkspace();
+	try {
+		pi.setActiveTools(["read", "bash", "edit", "write", "mem_save"]);
+		const ctx = createCtx(engramSddCwd, true, "engram-session");
+		await commands.get("gentle-ai:sdd-preflight").handler("", ctx);
+		assert.deepEqual(ctx.ui.selections[1].options, ["openspec", "engram", "both"]);
+	} finally {
+		pi.setActiveTools(["read", "bash", "edit", "write"]);
+		await rm(engramSddCwd, { recursive: true, force: true });
+	}
+
 	const installCwd = await tempWorkspace();
 	try {
 		const ctx = createCtx(installCwd, true);
@@ -171,11 +338,118 @@ async function run() {
 	try {
 		const ctx = createCtx(sddCwd, true);
 		await commands.get("sdd-init").handler("", ctx);
+		assert.equal(existsSync(join(sddCwd, ".pi", "agents", "sdd-apply.md")), true);
+		assert.equal(existsSync(join(sddCwd, ".pi", "chains", "sdd-full.chain.md")), true);
+		assert.equal(ctx.ui.selections.length, 3);
+		assert.match(ctx.ui.notifications[0].message, /SDD preflight complete/);
 		assert.match(ctx.ui.notifications.at(-1).message, /Wrote openspec\/config\.yaml/);
+
+		await commands.get("gentle-ai:sdd-preflight").handler("", ctx);
+		assert.equal(ctx.ui.selections.length, 3, "/sdd-init preflight should be reused by later manual preflight");
 	} finally {
 		await rm(sddCwd, { recursive: true, force: true });
 	}
 
+	const modelsCwd = await tempWorkspace();
+	try {
+		await mkdir(join(modelsCwd, ".pi", "agents"), { recursive: true });
+		await mkdir(
+			join(modelsCwd, ".pi", "npm", "node_modules", "pi-subagents", "agents"),
+			{ recursive: true },
+		);
+		await writeFile(
+			join(
+				modelsCwd,
+				".pi",
+				"npm",
+				"node_modules",
+				"pi-subagents",
+				"agents",
+				"worker.md",
+			),
+			`---\nname: worker\ndescription: Builtin worker\n---\n`,
+		);
+		await writeFile(
+			join(modelsCwd, ".pi", "agents", "sdd-apply.md"),
+			`---\nname: sdd-apply\ndescription: Apply phase\n---\n\nbody\n`,
+		);
+		await mkdir(join(modelsCwd, ".pi", "gentle-ai"), { recursive: true });
+		await writeFile(
+			join(modelsCwd, ".pi", "gentle-ai", "models.json"),
+			JSON.stringify({ "sdd-apply": "openai/gpt-5" }, null, 2),
+		);
+
+		const ctx = createCtx(modelsCwd, true);
+		await hooks.get("session_start")[0]({ reason: "startup" }, ctx);
+		const legacyAppliedAgent = await readFile(
+			join(modelsCwd, ".pi", "agents", "sdd-apply.md"),
+			"utf8",
+		);
+		assert.match(legacyAppliedAgent, /model: openai\/gpt-5/);
+		assert.doesNotMatch(legacyAppliedAgent, /thinking:/);
+
+		ctx.ui.custom = () =>
+			Promise.resolve({
+				type: "save",
+				config: {
+					"sdd-apply": { model: "openai/gpt-5", thinking: "high" },
+					worker: { model: "openai/gpt-5-mini", thinking: "low" },
+				},
+			});
+		await commands.get("gentle:models").handler("", ctx);
+
+		const savedConfig = JSON.parse(
+			await readFile(join(modelsCwd, ".pi", "gentle-ai", "models.json"), "utf8"),
+		);
+		assert.deepEqual(savedConfig["sdd-apply"], {
+			model: "openai/gpt-5",
+			thinking: "high",
+		});
+
+		const applyAgent = await readFile(
+			join(modelsCwd, ".pi", "agents", "sdd-apply.md"),
+			"utf8",
+		);
+		assert.match(applyAgent, /model: openai\/gpt-5/);
+		assert.match(applyAgent, /thinking: high/);
+
+		const settings = JSON.parse(
+			await readFile(join(modelsCwd, ".pi", "settings.json"), "utf8"),
+		);
+		assert.equal(
+			settings.subagents.agentOverrides.worker.model,
+			"openai/gpt-5-mini",
+		);
+		assert.equal(settings.subagents.agentOverrides.worker.thinking, "low");
+
+		let customPanelCalls = 0;
+		ctx.ui.input = async () => "custom/provider-model";
+		ctx.ui.custom = (factory) =>
+			new Promise((resolve) => {
+				customPanelCalls += 1;
+				const panel = factory(null, null, null, resolve);
+				if (customPanelCalls === 1) {
+					panel.handleInput("e"); // effort picker for all agents
+					for (let i = 0; i < 4; i++) panel.handleInput("j"); // medium
+					panel.handleInput("\r");
+					panel.handleInput("c"); // custom model from the same unsaved draft
+					return;
+				}
+				panel.handleInput("\u0013"); // ctrl+s saves the draft reopened after custom model input
+			});
+		await commands.get("gentle:models").handler("", ctx);
+
+		const customSavedConfig = JSON.parse(
+			await readFile(join(modelsCwd, ".pi", "gentle-ai", "models.json"), "utf8"),
+		);
+		assert.deepEqual(customSavedConfig["sdd-apply"], {
+			model: "custom/provider-model",
+			thinking: "medium",
+		});
+	} finally {
+		await rm(modelsCwd, { recursive: true, force: true });
+	}
+
 	const registryCwd = await tempWorkspace();
 	try {
 		const ctx = createCtx(registryCwd, true);