@oh-my-pi/pi-coding-agent 16.4.8 → 16.5.0

package/src/cli/gallery-fixtures/shell.ts

@@ -1,4 +1,4 @@
-/** Gallery fixtures for the shell tools (bash, eval). */
+/** Gallery fixtures for the shell tools (bash, eval, launch). */
 import type { GalleryFixture } from "./types";
 
 export const shellFixtures: Record<string, GalleryFixture> = {
@@ -56,6 +56,87 @@ export const shellFixtures: Record<string, GalleryFixture> = {
 		},
 	},
 
+	launch: {
+		label: "Launch",
+		streamingArgs: { op: "start", name: "web" },
+		args: {
+			op: "start",
+			name: "web",
+			application: "bun",
+			args: ["run", "dev"],
+			ready: { log: "Local:.*http", port: 5173, timeout: 30 },
+		},
+		result: {
+			content: [
+				{
+					type: "text",
+					text: "Started web: ready pid=51234 uptime=1.2s restarts=0\nReady: Local: http://localhost:5173",
+				},
+			],
+			details: {
+				op: "start",
+				daemon: {
+					name: "web",
+					id: "d-1",
+					state: "ready",
+					pid: 51234,
+					createdAt: 0,
+					startedAt: Date.now() - 1_200,
+					readyAt: Date.now(),
+					restartCount: 0,
+					outputBytes: 2048,
+					readyMatch: "Local:   http://localhost:5173/",
+					persist: false,
+					detached: false,
+				},
+				timedOut: false,
+			},
+		},
+		errorResult: {
+			content: [{ type: "text", text: "start requires application" }],
+			isError: true,
+			details: { op: "start" },
+		},
+	},
+
+	launch_logs: {
+		label: "Launch",
+		renderer: "launch",
+		args: { op: "logs", name: "comp-debug", lines: 100, follow: true, cursor: 233_512, timeout: 30 },
+		result: {
+			content: [
+				{
+					type: "text",
+					text: [
+						"Breakpoint 1: 3 locations.",
+						"(lldb) run",
+						"Process 726 launched: '/tmp/compiler'",
+						"frame #0: 0x0000000100012f80 compiler`parse_expression",
+						"[comp-debug: ready; cursor=233797]",
+					].join("\n"),
+				},
+			],
+			details: {
+				op: "logs",
+				cursor: 233_797,
+				timedOut: false,
+				state: "ready",
+				terminalRows: [
+					"\x1b[0mBreakpoint 1: 3 locations.",
+					"\x1b[0m(lldb) run",
+					"\x1b[0mProcess 726 launched: '/tmp/compiler'",
+					"\x1b[0mframe #0: 0x0000000100012f80 compiler`parse_expression",
+					"\x1b[0m\x1b[1;38;5;2m(lldb)\x1b[0m ",
+				],
+			},
+		},
+		errorResult: {
+			content: [{ type: "text", text: "No daemon named web" }],
+			isError: true,
+			details: { op: "logs" },
+		},
+	},
+
 	eval: {
 		label: "Eval",
 		streamingArgs: {

package/src/cli.ts

@@ -27,6 +27,7 @@ import {
 import { declareWorkerHostEntry, installWorkerInbox } from "@oh-my-pi/pi-utils/worker-host";
 import { installProfileAlias, resolveProfileAliasCommandFromProcess } from "./cli/profile-alias";
 import { extractProfileFlags } from "./cli/profile-bootstrap";
+import { DAEMON_BROKER_WORKER_ARG } from "./launch/protocol";
 
 if (Bun.semver.order(Bun.version, MIN_BUN_VERSION) < 0) {
 	process.stderr.write(
@@ -78,6 +79,8 @@ async function runSmokeTest(): Promise<void> {
 	const { smokeTestTtsWorker } = await import("./tts/tts-client");
 	const { smokeTestMnemopiEmbedWorker } = await import("./mnemopi/embed-client");
 	const { smokeTestJsEvalWorker } = await import("./eval/js/context-manager");
+	// Smoke dependencies stay lazy so normal CLI startup does not load worker clients.
+	const { smokeTestDaemonBroker } = await import("./launch/client");
 	await smokeTestSyncWorker();
 
 	const statsServer = await startServer(0);
@@ -97,6 +100,7 @@ async function runSmokeTest(): Promise<void> {
 	await smokeTestJsEvalWorker();
 	await smokeTestTtsWorker();
 	await smokeTestMnemopiEmbedWorker();
+	await smokeTestDaemonBroker();
 	process.stdout.write("smoke-test: ok\n");
 }
 
@@ -167,6 +171,12 @@ async function runWorkerEntrypoint(arg: string | undefined): Promise<boolean> {
 		await runIpcSubprocessWorker(startMnemopiEmbedWorker);
 		return true;
 	}
+	if (arg === DAEMON_BROKER_WORKER_ARG) {
+		// Worker selectors must dispatch before the normal command graph loads.
+		const { startDaemonBrokerFromEnvironment } = await import("./launch/broker");
+		await startDaemonBrokerFromEnvironment();
+		return true;
+	}
 	return false;
 }
 

package/src/commands/launch.ts

@@ -34,6 +34,23 @@ export default class Index extends Command {
 		plan: Flags.string({
 			description: "Plan model for architectural planning (or PI_PLAN_MODEL env)",
 		}),
+		prewalk: Flags.boolean({
+			description:
+				"Switch from the active model to a fast/cheap model at the first edit/write after the plan's todo list exists (default off; see prewalk.enabled)",
+		}),
+		"no-prewalk": Flags.boolean({
+			description: "Disable prewalk even if prewalk.enabled is set",
+		}),
+		"prewalk-into": Flags.string({
+			description: 'Target model for prewalk (default the "smol" role)',
+		}),
+		"plan-yolo": Flags.boolean({
+			description:
+				"Force read-only plan mode at start, auto-approve the plan on the model's first resolve call, then switch to --plan-yolo-into to implement it",
+		}),
+		"plan-yolo-into": Flags.string({
+			description: 'Target model for plan-yolo execution (default the "smol" role)',
+		}),
 		provider: Flags.string({
 			description: "Provider to use (legacy; prefer --model)",
 		}),

package/src/config/model-resolver.ts

@@ -37,7 +37,14 @@ import {
 	resolveThinkingLevelForModel,
 } from "../thinking";
 import { isAuthenticated, kNoAuth, type ModelRegistry } from "./model-registry";
-import { MODEL_ROLE_IDS, type ModelRole } from "./model-roles";
+import {
+	DEFAULT_MODEL_ROLE_ALIAS,
+	formatModelRoleAlias,
+	LEGACY_MODEL_ROLE_ALIAS_PREFIX,
+	MODEL_ROLE_ALIAS_PREFIX,
+	MODEL_ROLE_IDS,
+	type ModelRole,
+} from "./model-roles";
 import type { Settings } from "./settings";
 
 function isKnownProvider(provider: string): provider is KnownProvider {
@@ -109,8 +116,7 @@ function parseThinkingSuffix(value: string, options?: ThinkingSuffixOptions): Co
  * level / `:auto` sentinel); `base` then has the suffix stripped. Otherwise
  * `base` is the input.
  * `minColonIndex` requires the colon to appear strictly after that index —
- * role-alias callers pass `PREFIX_MODEL_ROLE.length` so the base is at least
- * as long as the `pi/` prefix.
+ * role-alias callers pass the matched alias prefix length.
  */
 function splitThinkingSuffix(
 	pattern: string,
@@ -850,17 +856,32 @@ export function parseModelPattern(
 	);
 }
 
-const PREFIX_MODEL_ROLE = "pi/";
 const DEFAULT_MODEL_ROLE = "default";
+const MODEL_ROLE_ALIAS_PREFIXES = [MODEL_ROLE_ALIAS_PREFIX, LEGACY_MODEL_ROLE_ALIAS_PREFIX];
+
+function isModelRole(role: string): role is ModelRole {
+	return (MODEL_ROLE_IDS as string[]).includes(role);
+}
+
+/**
+ * Minimum colon index for splitting a `:<level>` suffix off a role alias, or
+ * `undefined` when `value` is not role-alias shaped. Doubles as the slice
+ * offset of the role name for prefixed aliases (`@role`, `pi/role`); the bare
+ * `*` default alias returns 0 because its colon sits immediately after the
+ * one-character token (`*:xhigh`).
+ */
+function modelRoleAliasPrefixLength(value: string): number | undefined {
+	if (value === DEFAULT_MODEL_ROLE_ALIAS || value.startsWith(`${DEFAULT_MODEL_ROLE_ALIAS}:`)) return 0;
+	return MODEL_ROLE_ALIAS_PREFIXES.find(prefix => value.startsWith(prefix))?.length;
+}
 
-function getModelRoleAlias(value: string): ModelRole | undefined {
+function getModelRoleAlias(value: string, settings?: Settings): string | undefined {
 	const normalized = value.trim();
-	if (!normalized.startsWith(PREFIX_MODEL_ROLE)) return undefined;
+	const prefixLength = modelRoleAliasPrefixLength(normalized);
+	if (prefixLength === undefined) return undefined;
 
-	const candidate = normalized.slice(PREFIX_MODEL_ROLE.length);
-	for (const role of MODEL_ROLE_IDS) {
-		if (candidate === role) return role;
-	}
+	const candidate = normalized === DEFAULT_MODEL_ROLE_ALIAS ? DEFAULT_MODEL_ROLE : normalized.slice(prefixLength);
+	if (isModelRole(candidate) || settings?.getModelRole(candidate) !== undefined) return candidate;
 	return undefined;
 }
 
@@ -871,7 +892,14 @@ function normalizeModelPatternList(value: string | string[] | undefined): string
 }
 
 function isSessionInheritedAgentPattern(value: string): boolean {
-	return value === DEFAULT_MODEL_ROLE || value === `${PREFIX_MODEL_ROLE}${DEFAULT_MODEL_ROLE}` || value === "pi/task";
+	return (
+		value === DEFAULT_MODEL_ROLE ||
+		value === formatModelRoleAlias(DEFAULT_MODEL_ROLE) ||
+		value === DEFAULT_MODEL_ROLE_ALIAS ||
+		value === `${LEGACY_MODEL_ROLE_ALIAS_PREFIX}${DEFAULT_MODEL_ROLE}` ||
+		value === formatModelRoleAlias("task") ||
+		value === `${LEGACY_MODEL_ROLE_ALIAS_PREFIX}task`
+	);
 }
 
 function shouldInheritDefaultBeforePriority(role: ModelRole): boolean {
@@ -904,7 +932,7 @@ function resolveDefaultInheritedPatterns(
 	configuredDefault: string | undefined,
 	roleDefaults: string[],
 	settings: Settings | undefined,
-	visited: Set<ModelRole>,
+	visited: Set<string>,
 ): string[] {
 	if (!shouldInheritDefaultBeforePriority(role) || !configuredDefault) return [];
 
@@ -912,13 +940,12 @@ function resolveDefaultInheritedPatterns(
 	for (const pattern of normalizeModelPatternList(configuredDefault)) {
 		const { base: aliasCandidate, level: thinkingLevel } = splitThinkingSuffix(
 			pattern,
-			PREFIX_MODEL_ROLE.length,
+			modelRoleAliasPrefixLength(pattern) ?? LEGACY_MODEL_ROLE_ALIAS_PREFIX.length,
 			MAX_THINKING_SUFFIX_OPTIONS,
 		);
-		const aliasRole = getModelRoleAlias(aliasCandidate);
+		const aliasRole = getModelRoleAlias(aliasCandidate, settings);
 		if (aliasRole === role) {
-			// Self-alias (e.g. modelRoles.default = "pi/smol") would loop back to the
-			// same unset role; collapse straight to the built-in priority chain.
+			// Self-alias (e.g. modelRoles.default = "@smol") would loop back to the
 			resolved.push(
 				...(thinkingLevel
 					? roleDefaults.map(defaultPattern => `${defaultPattern}:${thinkingLevel}`)
@@ -927,8 +954,7 @@ function resolveDefaultInheritedPatterns(
 			continue;
 		}
 		if (aliasRole && !visited.has(aliasRole)) {
-			// Cross-role alias (e.g. modelRoles.default = "pi/slow"): resolve the
-			// target role's patterns now so downstream one-layer expanders see
+			// Cross-role alias (e.g. modelRoles.default = "@slow"): resolve the
 			// concrete model patterns instead of another role alias.
 			const recursed = resolveConfiguredRolePattern(pattern, settings, new Set(visited));
 			if (recursed && recursed.length > 0) {
@@ -944,27 +970,29 @@ function resolveDefaultInheritedPatterns(
 function resolveConfiguredRolePattern(
 	value: string,
 	settings?: Settings,
-	visited: Set<ModelRole> = new Set(),
+	visited: Set<string> = new Set(),
 ): string[] | undefined {
 	const normalized = value.trim();
 	if (!normalized) return undefined;
 
 	const { base: aliasCandidate, level: thinkingLevel } = splitThinkingSuffix(
 		normalized,
-		PREFIX_MODEL_ROLE.length,
+		modelRoleAliasPrefixLength(normalized) ?? LEGACY_MODEL_ROLE_ALIAS_PREFIX.length,
 		MAX_THINKING_SUFFIX_OPTIONS,
 	);
-	const role = getModelRoleAlias(aliasCandidate);
+	const role = getModelRoleAlias(aliasCandidate, settings);
 	if (!role) return [normalized];
 	if (visited.has(role)) return undefined;
 	visited.add(role);
 
 	const configured = settings?.getModelRole(role)?.trim();
 	const configuredDefault = settings?.getModelRole(DEFAULT_MODEL_ROLE)?.trim();
-	const roleDefaults = rolePriorityDefaults(role);
+	const roleDefaults = isModelRole(role) ? rolePriorityDefaults(role) : [];
 	const resolved = configured
 		? normalizeModelPatternList(configured)
-		: resolveDefaultInheritedPatterns(role, configuredDefault, roleDefaults, settings, visited);
+		: isModelRole(role)
+			? resolveDefaultInheritedPatterns(role, configuredDefault, roleDefaults, settings, visited)
+			: roleDefaults;
 	if (resolved.length === 0) {
 		resolved.push(...roleDefaults);
 	}
@@ -976,7 +1004,7 @@ function resolveConfiguredRolePattern(
 }
 
 /**
- * Expand a role alias like "pi/smol" to the configured model string.
+ * Expand a role alias like "@smol" to the configured model string.
  */
 export function expandRoleAlias(value: string, settings?: Settings): string {
 	const normalized = value.trim();
@@ -1014,8 +1042,13 @@ export function resolveAgentModelPatterns(options: AgentModelPatternResolutionOp
 	const singleAgentPattern = normalizedAgentPatterns.length === 1 ? normalizedAgentPatterns[0] : undefined;
 	const agentInheritsSessionModel = singleAgentPattern ? isSessionInheritedAgentPattern(singleAgentPattern) : false;
 	if (configuredAgentPatterns.length > 0) {
+		if (
+			singleAgentPattern === formatModelRoleAlias("task") ||
+			singleAgentPattern === `${LEGACY_MODEL_ROLE_ALIAS_PREFIX}task`
+		) {
+			return configuredAgentPatterns;
+		}
 		if (!agentInheritsSessionModel) return configuredAgentPatterns;
-		if (singleAgentPattern === "pi/task") return configuredAgentPatterns;
 	}
 
 	const fallback =
@@ -1102,12 +1135,16 @@ export function extractExplicitThinkingSelector(
 	let current = normalized;
 	while (!visited.has(current)) {
 		visited.add(current);
-		const strictSelector = splitThinkingSuffix(current, PREFIX_MODEL_ROLE.length).level;
+		const rolePrefixLength = modelRoleAliasPrefixLength(current) ?? LEGACY_MODEL_ROLE_ALIAS_PREFIX.length;
+		const strictSelector = splitThinkingSuffix(current, rolePrefixLength).level;
 		if (strictSelector) {
 			return strictSelector;
 		}
-		const maxSelector = splitThinkingSuffix(current, PREFIX_MODEL_ROLE.length, MAX_THINKING_SUFFIX_OPTIONS).level;
-		if (maxSelector && (current.startsWith(PREFIX_MODEL_ROLE) || !isLiteralModelSelector(current, options))) {
+		const maxSelector = splitThinkingSuffix(current, rolePrefixLength, MAX_THINKING_SUFFIX_OPTIONS).level;
+		if (
+			maxSelector &&
+			(modelRoleAliasPrefixLength(current) !== undefined || !isLiteralModelSelector(current, options))
+		) {
 			return maxSelector;
 		}
 		const expanded = expandRoleAlias(current, settings).trim();
@@ -1278,7 +1315,7 @@ export function resolveAdvisorRoleSelection(
 	settings: Settings,
 	availableModels: Model<Api>[],
 ): { model: Model<Api>; thinkingLevel?: ConfiguredThinkingLevel } | undefined {
-	const resolved = resolveModelRoleValue(`${PREFIX_MODEL_ROLE}advisor`, availableModels, {
+	const resolved = resolveModelRoleValue(formatModelRoleAlias("advisor"), availableModels, {
 		settings,
 		matchPreferences: getModelMatchPreferences(settings),
 	});
@@ -1300,6 +1337,7 @@ export async function resolveModelScope(
 	patterns: string[],
 	modelRegistry: Pick<ModelRegistry, "getAvailable">,
 	preferences?: ModelMatchPreferences,
+	settings?: Settings,
 ): Promise<ScopedModel[]> {
 	const availableModels = modelRegistry.getAvailable();
 	const context = buildPreferenceContext(availableModels, preferences);
@@ -1337,6 +1375,25 @@ export async function resolveModelScope(
 			continue;
 		}
 
+		// Role aliases (`@smol`, `pi/slow`) resolve to the role's single concrete
+		// model — not its whole fallback chain — so a role contributes one scope
+		// entry exactly like `--model` would pick. (Bare `*` stays a match-all
+		// glob above; scope semantics, not the default-role alias.)
+		if (settings && modelRoleAliasPrefixLength(pattern) !== undefined) {
+			const resolved = resolveModelRoleValue(pattern, availableModels, { settings, matchPreferences: preferences });
+			if (resolved.warning) logger.warn(resolved.warning);
+			if (!resolved.model) {
+				logger.warn(`No models match pattern "${pattern}"`);
+				continue;
+			}
+			if (resolved.thinkingLevel === AUTO_THINKING) {
+				addScopedModel(resolved.model, undefined, false);
+			} else {
+				addScopedModel(resolved.model, resolved.thinkingLevel, resolved.explicitThinkingLevel);
+			}
+			continue;
+		}
+
 		const { model, thinkingLevel, warning, explicitThinkingLevel } = parseModelPatternWithContext(
 			pattern,
 			availableModels,
@@ -1386,7 +1443,7 @@ export async function resolveAllowedModels(
 	if (!patterns || patterns.length === 0) {
 		return available;
 	}
-	const scoped = await resolveModelScope(patterns, modelRegistry, preferences);
+	const scoped = await resolveModelScope(patterns, modelRegistry, preferences, settings);
 	if (scoped.length === 0) {
 		return [];
 	}
@@ -1415,6 +1472,7 @@ export async function resolveAllowedModels(
 export function filterAvailableModelsByEnabledPatterns(
 	available: Model<Api>[],
 	patterns: readonly string[],
+	settings?: Settings,
 ): Model<Api>[] {
 	if (patterns.length === 0) return available;
 
@@ -1432,6 +1490,13 @@ export function filterAvailableModelsByEnabledPatterns(
 			continue;
 		}
 
+		// Mirror resolveModelScope: role aliases resolve to the role's model.
+		if (settings && modelRoleAliasPrefixLength(pattern) !== undefined) {
+			const { model } = resolveModelRoleValue(pattern, available, { settings });
+			if (model) addAllowed(model);
+			continue;
+		}
+
 		const { model } = parseModelPatternWithContext(pattern, available, context);
 		if (model) {
 			addAllowed(model);
@@ -1456,9 +1521,10 @@ export function resolveCliModel(options: {
 	cliProvider?: string;
 	cliModel?: string;
 	modelRegistry: CliModelRegistry;
+	settings?: Settings;
 	preferences?: ModelMatchPreferences;
 }): ResolveCliModelResult {
-	const { cliProvider, cliModel, modelRegistry, preferences } = options;
+	const { cliProvider, cliModel, modelRegistry, settings, preferences } = options;
 
 	if (!cliModel) {
 		return { model: undefined, selector: undefined, warning: undefined, error: undefined };
@@ -1474,6 +1540,19 @@ export function resolveCliModel(options: {
 		};
 	}
 
+	if (!cliProvider && modelRoleAliasPrefixLength(cliModel) !== undefined) {
+		const resolved = resolveModelRoleValue(cliModel, availableModels, { settings, matchPreferences: preferences });
+		if (resolved.model) {
+			return {
+				model: resolved.model,
+				selector: formatModelString(resolved.model),
+				thinkingLevel: resolved.thinkingLevel,
+				warning: resolved.warning,
+				error: undefined,
+			};
+		}
+	}
+
 	const providerMap = new Map<string, string>();
 	for (const model of availableModels) {
 		providerMap.set(model.provider.toLowerCase(), model.provider);

package/src/config/model-roles.ts

@@ -5,6 +5,20 @@
 import { isValidThemeColor, type ThemeColor } from "../modes/theme/theme";
 import type { Settings } from "./settings";
 
+/** Canonical prefix for a configured model role selector. */
+export const MODEL_ROLE_ALIAS_PREFIX = "@";
+
+/** Legacy prefix accepted for backwards-compatible role selectors. */
+export const LEGACY_MODEL_ROLE_ALIAS_PREFIX = "pi/";
+
+/** Shorthand selector for the default model role. */
+export const DEFAULT_MODEL_ROLE_ALIAS = "*";
+
+/** Format a model role as its canonical selector. */
+export function formatModelRoleAlias(role: string): string {
+	return `${MODEL_ROLE_ALIAS_PREFIX}${role}`;
+}
+
 export type ModelRole =
 	| "default"
 	| "smol"

package/src/config/settings-schema.ts

@@ -117,7 +117,7 @@ export const TAB_METADATA: Record<SettingTab, { label: string; icon: `tab.${stri
  */
 export const TAB_GROUPS: Record<SettingTab, readonly string[]> = {
 	appearance: ["Theme", "Status Line", "Display", "Images"],
-	model: ["Thinking", "Sampling", "Prompt", "Retry & Fallback", "Advisor", "Vision"],
+	model: ["Thinking", "Sampling", "Prompt", "Retry & Fallback", "Advisor", "Prewalk", "Vision"],
 	interaction: [
 		"Input",
 		"Approvals",
@@ -331,6 +331,25 @@ export const DEFAULT_BASH_INTERCEPTOR_RULES: BashInterceptorRule[] = [
 		tool: "write",
 		message: "Use the `write` tool instead of echo/cat redirection. It handles encoding and provides confirmation.",
 	},
+	{
+		pattern: "^\\s*nohup\\s+|(?<!&)\\&\\s*$",
+		tool: "launch",
+		message:
+			"Use the `launch` tool instead of nohup or background shell syntax so the process stays observable and managed.",
+	},
+	{
+		pattern:
+			"^\\s*(?:(?:bun|npm|pnpm|yarn)\\s+(?:run\\s+)?(?:dev|start)(?:\\s|$)|(?:vite|next\\s+dev|nuxt\\s+dev|nodemon|lldb|gdb|tail\\s+-f)(?:\\s|$)|docker\\s+compose\\s+up(?!.*(?:\\s-d(?:\\s|$)|--detach))(?:\\s|$))",
+		tool: "launch",
+		message:
+			"Use the `launch` tool for services, watchers, and debuggers so other omp instances can observe and control them.",
+	},
+	{
+		pattern:
+			"^\\s*(?:(?:bun|npm|pnpm|yarn)\\s+(?:run\\s+)?\\S+|cargo\\s+watch|watchexec|pytest|vitest|jest|tsc)(?:.|\\n)*(?:--watch|-w)(?:\\s|$)",
+		tool: "launch",
+		message: "Use the `launch` tool for watch mode so its output, input, and lifecycle stay managed.",
+	},
 ];
 
 export const SETTINGS_SCHEMA = {
@@ -403,6 +422,17 @@ export const SETTINGS_SCHEMA = {
 				"Pair a second model (assigned to the 'advisor' role) that passively reviews each turn and injects notes.",
 		},
 	},
+	"prewalk.enabled": {
+		type: "boolean",
+		default: false,
+		ui: {
+			tab: "model",
+			group: "Prewalk",
+			label: "Enable Prewalk",
+			description:
+				"Start on the active model, then switch to a fast/cheap model (default the 'smol' role) at the first edit/write after the plan nudge's todo list exists — the strong model plans, commits the todos, and starts the implementation before handing off. Overridable per session with --prewalk / --no-prewalk.",
+		},
+	},
 	"advisor.subagents": {
 		type: "boolean",
 		default: false,
@@ -867,6 +897,17 @@ export const SETTINGS_SCHEMA = {
 			description: "Remove the 1-character horizontal padding from the left and right of the terminal output",
 		},
 	},
+	"tui.scrollbackRebuild": {
+		type: "boolean",
+		default: false,
+		ui: {
+			tab: "appearance",
+			group: "Display",
+			label: "Rewrite Scrollback",
+			description:
+				"Erase and replay terminal scrollback when a block's final form replaces its live preview. When off (default), stale preview copies remain in history and the final content is appended below.",
+		},
+	},
 
 	"display.shimmer": {
 		type: "enum",
@@ -918,6 +959,18 @@ export const SETTINGS_SCHEMA = {
 		},
 	},
 
+	"display.collapseCompacted": {
+		type: "boolean",
+		default: true,
+		ui: {
+			tab: "appearance",
+			group: "Display",
+			label: "Collapse Compacted History",
+			description:
+				"Collapse pre-compaction history behind the summary divider on the live transcript; disable to keep the full transcript inline with dividers at each compaction point",
+		},
+	},
+
 	showHardwareCursor: {
 		type: "boolean",
 		default: true, // will be computed based on platform if undefined
@@ -1239,7 +1292,7 @@ export const SETTINGS_SCHEMA = {
 	textVerbosity: {
 		type: "enum",
 		values: ["low", "medium", "high"] as const,
-		default: "high",
+		default: "medium",
 		ui: {
 			tab: "model",
 			group: "Sampling",
@@ -1247,8 +1300,8 @@ export const SETTINGS_SCHEMA = {
 			description: "OpenAI Responses and Codex response verbosity (low, medium, or high)",
 			options: [
 				{ value: "low", label: "Low", description: "Prefer concise responses" },
-				{ value: "medium", label: "Medium", description: "Balance brevity and detail" },
-				{ value: "high", label: "High", description: "Prefer detailed responses (default)" },
+				{ value: "medium", label: "Medium", description: "Balance brevity and detail (default)" },
+				{ value: "high", label: "High", description: "Prefer detailed responses" },
 			],
 		},
 	},
@@ -2597,14 +2650,14 @@ export const SETTINGS_SCHEMA = {
 			group: "Mnemopi",
 			label: "Mnemopi LLM Mode",
 			description:
-				"Use no LLM, the online tiny model (the TINY role from /models, else pi/smol), or a remote OpenAI-compatible endpoint",
+				"Use no LLM, the online tiny model (the TINY role from /models, else @smol), or a remote OpenAI-compatible endpoint",
 			condition: "mnemopiActive",
 			options: [
 				{ value: "none", label: "None", description: "Disable Mnemopi LLM-backed extraction" },
 				{
 					value: "smol",
 					label: "Online (tiny)",
-					description: "Use the online tiny model (the TINY role from /models, else pi/smol)",
+					description: "Use the online tiny model (the TINY role from /models, else @smol)",
 				},
 				{ value: "remote", label: "Remote", description: "Use the Mnemopi remote LLM settings below" },
 			],
@@ -3518,6 +3571,17 @@ export const SETTINGS_SCHEMA = {
 		},
 	},
 
+	"launch.enabled": {
+		type: "boolean",
+		default: true,
+		ui: {
+			tab: "tools",
+			group: "Available Tools",
+			label: "Launch",
+			description: "Enable the launch tool for supervising shared long-running project processes",
+		},
+	},
+
 	"speechgen.enabled": {
 		type: "boolean",
 		default: false,
@@ -4547,7 +4611,7 @@ export const SETTINGS_SCHEMA = {
 			group: "Tiny Model",
 			label: "Tiny Model",
 			description:
-				"Session-title model: online (the TINY role from /models, else pi/smol) by default, or a local on-device model",
+				"Session-title model: online (the TINY role from /models, else @smol) by default, or a local on-device model",
 			options: TINY_TITLE_MODEL_OPTIONS,
 		},
 	},

package/src/edit/renderer.ts

@@ -423,22 +423,25 @@ function formatStreamingDiff(
 	cache?: RenderedStringCache,
 ): string {
 	if (!diff) return "";
-	// Clamp the collapsed tail to the viewport so a tall or fast-growing diff
-	// cannot outgrow the live window. Otherwise its mutating tail scrolls above
-	// the native-scrollback commit boundary and the engine re-commits a fresh
-	// snapshot every streamed frame, stacking duplicate "… more lines above"
-	// previews in history. The budget is VISUAL rows (a long wrapped line counts
+	// Clamp the tail to the viewport so a tall or fast-growing diff cannot
+	// outgrow the live window. Otherwise its mutating rows scroll above the
+	// native-scrollback commit boundary mid-stream and freeze into immutable
+	// history as a stale preview snapshot; the finalize repair then recommits
+	// the final render below it — a duplicated block on the tape. Collapsed
+	// gets a short fixed tail; expanded widens it to the viewport-sized window,
+	// never unbounded. The budget is VISUAL rows (a long wrapped line counts
 	// for more than one) at the framed block's inner width (border only —
-	// contentPaddingLeft is 0); only the visible suffix is syntax-colored, so the
-	// cheap raw-line wrap walk keeps the per-chunk cost bounded. innerWidth/budget
-	// are in the cache salt so a resize re-slices.
+	// contentPaddingLeft is 0); only the visible suffix is syntax-colored, so
+	// the cheap raw-line wrap walk keeps the per-chunk cost bounded.
+	// innerWidth/budget are in the cache salt so a resize re-slices.
 	const innerWidth = Math.max(1, width - 2);
-	const budget = expanded ? Number.POSITIVE_INFINITY : Math.min(EDIT_STREAMING_PREVIEW_LINES, previewWindowRows());
+	const budget = expanded ? previewWindowRows() : Math.min(EDIT_STREAMING_PREVIEW_LINES, previewWindowRows());
 	let text = cachedRenderedString(cache, uiTheme, expanded, `${rawPath}:${innerWidth}:${budget}`, diff, () => {
 		// "Cursor" tail window: pin the last rows to the bottom so freshly streamed
 		// changes stay on screen. The whole-file diff is recomputed every chunk and
 		// its Myers alignment is not monotonic in payload length, so a hunk-aware
-		// window stutters as rows move between hunks. Expanded lifts the cap.
+		// window stutters as rows move between hunks. Expanded widens the window
+		// to the viewport; the full diff appears once the result finalizes.
 		const allLines = diff.replace(/\n+$/u, "").split("\n");
 		let visualUsed = 0;
 		let cut = allLines.length;