@aibyzero/byz 0.1.5 → 0.1.7

package/CHANGELOG.md

@@ -2,6 +2,24 @@
 
 ## Unreleased
 
+## 0.1.7 - 2026-08-29
+
+### Added
+
+- Added same-session routing and collaboration preferences that classify common requests, inject minimal per-turn guidance, and show route details only on demand.
+- Added the default BYZ conversation shell with a goal-first welcome, low-noise progress, on-demand details, and natural-language confirmation input.
+
+### Changed
+
+- Changed the default interactive shell to hide internal resources, tool rows, model metadata, and advanced controls until requested.
+
+## 0.1.6 - 2026-08-28
+
+### Added
+
+- Added same-session `/fast` hot switching with reversible model and thinking state, explicit user choices taking priority, and no changes to the active workflow or conversation ([#22](https://github.com/kingxiaozhe/byz/pull/22)).
+- Added opt-in `/prewalk` one-time handoff after the first successful built-in workspace edit or write, reusing the authenticated Fast target without changing the conversation or workflow ([#23](https://github.com/kingxiaozhe/byz/pull/23)).
+
 ## 0.1.5 - 2026-08-28
 
 ### Fixed

package/README.md

@@ -56,6 +56,39 @@ An explicit `--model` or `--thinking` option always wins. Continuing or resuming
 an existing session keeps that session's model and applies the Fast thinking
 default. Normal `byz` runs ignore `BYZ_FAST_MODEL` and remain unchanged.
 
+Inside an interactive session, Fast can be changed without restarting BYZ or
+starting a new conversation:
+
+```text
+/fast
+/fast on
+/fast off
+/fast status
+```
+
+`/fast on` snapshots the current model and thinking, then applies the same Fast
+defaults. `/fast off` restores that snapshot. The active workflow, conversation,
+session, skills, prompts, and tools do not change. Explicitly selecting a model
+or thinking level exits Fast and keeps that explicit choice. BYZ rejects Fast
+state changes while the agent is running, and an unavailable or unauthenticated
+configured model leaves the current state unchanged.
+
+## Prewalk
+
+Arm a one-time handoff when the current model should understand the task and perform the first successful workspace edit before Fast continues:
+
+```text
+/prewalk
+/prewalk status
+/prewalk cancel
+```
+
+`/prewalk` is available only in an interactive, trusted, idle session. It resolves and authenticates the same target used by Fast before arming. If `BYZ_FAST_MODEL` is unset, the current authenticated model remains selected and only thinking changes to `low` after the handoff.
+
+Only the first successful Pi built-in `edit` or `write` whose real target remains inside the current workspace consumes the armed state. Read-only tools, failed writes, extension tools with the same name, and file or directory symlink escapes do not trigger it. Parallel tool results are checked serially and can consume the state only once.
+
+Prewalk preserves the current conversation, session, workflow, skills, prompts, and tools. It does not add another model call for planning. An explicit model or thinking selection cancels an armed Prewalk and keeps the user's choice. Enabling Fast also cancels it; Prewalk refuses to arm when Fast is already active.
+
 ## Workflows
 
 ```bash

package/dist/cli.js

@@ -1,6 +1,8 @@
 #!/usr/bin/env node
 
-import { prepareFastRuntimeArgs } from "./fast.js";
+import { createConversationExtension } from "./conversation/conversation-extension.js";
+import { createFastSessionController, prepareFastRuntimeArgs, selectFastRuntimeArgs } from "./fast.js";
+import { createPrewalkExtension } from "./prewalk.js";
 import { main } from "./runtime/bundle/index.js";
 import { handleByzUpdate } from "./update.js";
 import { createWorkflowSwitchExtension, shouldEnableWorkflowSwitch, shouldLoadWorkflow } from "./workflow-switch.js";
@@ -24,15 +26,6 @@ try {
 	const fastRuntime = prepareFastRuntimeArgs(args);
 	const parsedWorkflow = parseWorkflowOption(fastRuntime.commandArgs);
 	const commandArgs = parsedWorkflow.forwardedArgs;
-	const isRootHelp = commandArgs.length === 1 && (commandArgs[0] === "--help" || commandArgs[0] === "-h");
-	if (isRootHelp) {
-		console.error("BYZ updates: byz update (npm-managed global installations only)");
-		console.error("BYZ Fast: --fast (thinking=low; optional model: BYZ_FAST_MODEL)");
-		console.error("BYZ workflows: --workflow <cm|cm-plugin|none> (default: BYZ_WORKFLOW or cm)");
-		console.error(
-			"Commands: byz workflow list | byz workflow status [cm|cm-plugin|none] | byz workflow check <cm|cm-plugin>",
-		);
-	}
 
 	if (await handleWorkflowCommand(commandArgs, { workflowId: parsedWorkflow.workflowId })) {
 		// BYZ-owned command handled without starting the Pi runtime.
@@ -40,17 +33,11 @@ try {
 		// BYZ release metadata and package target stay independent from Pi.
 	} else {
 		const loadWorkflow = shouldLoadWorkflow(commandArgs);
-		const runtimeArgs = loadWorkflow ? fastRuntime.args : fastRuntime.commandArgs;
 		const isInteractive = shouldEnableWorkflowSwitch(commandArgs, {
 			stdinIsTTY: process.stdin.isTTY,
 			stdoutIsTTY: process.stdout.isTTY,
 		});
-		if (fastRuntime.enabled && loadWorkflow && isInteractive) {
-			console.error(
-				`BYZ Fast: model=${fastRuntime.model}, thinking=${fastRuntime.thinking}, workflow=${parsedWorkflow.workflowId}`,
-			);
-		}
-
+		const runtimeArgs = selectFastRuntimeArgs(fastRuntime, { isInteractive, loadWorkflow });
 		if (loadWorkflow && isInteractive) {
 			const parsedRuntimeWorkflow = parseWorkflowOption(runtimeArgs);
 			const resolveResources = (workflowId) =>
@@ -60,7 +47,20 @@ try {
 				initialWorkflowId: parsedRuntimeWorkflow.workflowId,
 				resolveResources,
 			});
-			await main(parsedRuntimeWorkflow.forwardedArgs, { byzWorkflowExtensionFactory: workflowExtension });
+			const fastController = createFastSessionController({
+				initiallyEnabled: fastRuntime.enabled,
+				initialUseConfiguredModel: fastRuntime.useConfiguredModel,
+				initialUseLowThinking: fastRuntime.useLowThinking,
+			});
+			const prewalkExtension = createPrewalkExtension({ fastController });
+			const conversationExtension = createConversationExtension();
+			const byzExtension = (pi) => {
+				conversationExtension(pi);
+				workflowExtension(pi);
+				fastController.extension(pi);
+				prewalkExtension(pi);
+			};
+			await main(parsedRuntimeWorkflow.forwardedArgs, { byzWorkflowExtensionFactory: byzExtension });
 		} else {
 			const prepared = await prepareWorkflowRuntimeArgs(runtimeArgs, { load: loadWorkflow });
 			await main(prepared.args);

package/dist/conversation/conversation-extension.js

@@ -0,0 +1,85 @@
+import { createInteractionPolicy, formatDecision, parseConversationControl } from "./interaction-policy.js";
+import { createRoutingPolicy } from "./routing-policy.js";
+
+const WELCOME = "BYZ\n\n你想让我帮你做什么？";
+
+export function createConversationExtension() {
+	const policy = createInteractionPolicy();
+	const routingPolicy = createRoutingPolicy();
+
+	return function conversationExtension(pi) {
+		let progressTimer;
+
+		function clearProgressTimer() {
+			if (progressTimer) clearTimeout(progressTimer);
+			progressTimer = undefined;
+		}
+
+		pi.on("session_start", (_event, ctx) => {
+			routingPolicy.reset();
+			ctx.ui.setTitle?.("BYZ");
+			ctx.ui.setMessagePresenter?.((message) => policy.presentAssistantMessage(message));
+			ctx.ui.setToolExecutionVisible?.(false);
+			ctx.ui.setFooter?.(() => ({
+				invalidate() {},
+				render() {
+					return [];
+				},
+			}));
+			ctx.ui.setConfirmationPresenter?.(async ({ title, message, confirm }) => {
+				const prompt = formatDecision({
+					impact: message,
+					recommendation: "确认",
+					alternative: "取消",
+					onReject: "不会执行此操作",
+				});
+				const answer = await ctx.ui.input(prompt, `${title}：输入“确认”或“取消”`);
+				const choice = answer ? parseConversationControl(answer) : undefined;
+				if (choice === "accept" || choice === "proceed") return true;
+				if (choice === "reject") return false;
+				return confirm();
+			});
+			ctx.ui.notify(WELCOME, "info");
+		});
+		pi.on("agent_start", (_event, ctx) => {
+			policy.resetProgress();
+			clearProgressTimer();
+			progressTimer = setTimeout(() => {
+				const message = policy.present("progress", "");
+				if (message) ctx.ui.setWorkingMessage?.(message);
+			}, 30_000);
+		});
+		pi.on("agent_end", () => {
+			clearProgressTimer();
+		});
+		pi.on("session_shutdown", () => {
+			routingPolicy.reset();
+			clearProgressTimer();
+		});
+		function showDetails(ctx) {
+			policy.setDetailEnabled(true);
+			ctx.ui.setToolExecutionVisible?.(true);
+			ctx.ui.notify("已展开细节。高级控制：/fast、/prewalk、/workflow。", "info");
+		}
+
+		pi.registerCommand("details", {
+			description: "Show BYZ advanced controls",
+			handler: async (_args, ctx) => showDetails(ctx),
+		});
+		pi.on("before_agent_start", async (event, ctx) => {
+			const route = routingPolicy.route(event.prompt);
+			if (route.details || parseConversationControl(event.prompt) === "detail") showDetails(ctx);
+			if (policy.isDetailEnabled()) {
+				ctx.ui.notify(
+					`当前类别：${route.kind}。当前偏好：主动程度 ${route.preferences.autonomy}，交付 ${route.preferences.delivery}。`,
+					"info",
+				);
+			}
+			return {
+				systemPrompt: `${event.systemPrompt ?? ""}\n\nBYZ collaboration guidance for this turn:\n${route.instructions}`,
+			};
+		});
+	};
+}
+
+export { WELCOME };

package/dist/conversation/interaction-policy.js

@@ -0,0 +1,53 @@
+const INTERNAL_TERMS = /\b(?:model|skill|workflow|fast|prewalk|token|tool|step\s*\d+)\b/gi;
+
+export function createInteractionPolicy() {
+	let progressShown = false;
+	let detailEnabled = false;
+
+	function present(kind, message, { detail = false } = {}) {
+		if (kind === "progress") {
+			if (progressShown) return undefined;
+			progressShown = true;
+			return "正在处理，稍后给你结果。";
+		}
+		if (kind === "advanced-control" && !detailEnabled && !detail) return undefined;
+		if (detail || detailEnabled) return message;
+		return message.replace(INTERNAL_TERMS, "内部设置");
+	}
+
+	function presentAssistantMessage(message) {
+		if (detailEnabled) return message;
+		const content = message.content
+			.filter((part) => part.type === "text")
+			.map((part) => ({ ...part, text: part.text.replace(INTERNAL_TERMS, "内部设置") }));
+		return { ...message, content };
+	}
+
+	return {
+		present,
+		presentAssistantMessage,
+		setDetailEnabled(enabled) {
+			detailEnabled = enabled;
+		},
+		isDetailEnabled() {
+			return detailEnabled;
+		},
+		resetProgress() {
+			progressShown = false;
+		},
+	};
+}
+
+export function parseConversationControl(input) {
+	const value = input.trim();
+	if (/^(展开细节|查看细节|显示细节)$/.test(value)) return "detail";
+	if (/^(少问一点|直接做)$/.test(value)) return "proceed";
+	if (/^(关键动作先问我|先问我)$/.test(value)) return "confirm";
+	if (/^(取消|不要|拒绝)$/.test(value)) return "reject";
+	if (/^(确认|继续|同意|可以)$/.test(value)) return "accept";
+	return undefined;
+}
+
+export function formatDecision({ impact, recommendation, alternative, onReject }) {
+	return `需要你决定\n影响：${impact}\n建议：${recommendation}\n其他选择：${alternative}\n如果拒绝：${onReject}`;
+}

package/dist/conversation/routing-policy.js

@@ -0,0 +1,102 @@
+const DEFAULT_PREFERENCES = Object.freeze({
+	autonomy: "balanced",
+	delivery: "normal",
+});
+
+const CONTROL_PATTERNS = [
+	[/关键动作先问我|先问我/, { autonomy: "confirm-key-actions" }],
+	[/少问一点/, { autonomy: "fewer-questions" }],
+	[/直接做/, { autonomy: "direct" }],
+	[/先给三个方向/, { delivery: "three-directions" }],
+	[/展开细节|查看细节|显示细节/, {}],
+];
+
+const FALLBACKS = Object.freeze({
+	research: {
+		missingInput: "需要可访问链接、正文、关键词或目标来源。",
+		fallback: "可先基于你提供的摘要做初步判断，或请你补充正文、截图、链接。",
+	},
+	"bug-fix": {
+		missingInput: "需要复现步骤、报错信息、相关输入或运行环境。",
+		fallback: "可先根据现象列排查清单，等你补充日志后再定位。",
+	},
+	"project-recovery": {
+		missingInput: "需要当前项目路径、上次进度、任务状态或错误现场。",
+		fallback: "可先读取本地项目状态并汇总可恢复线索。",
+	},
+	general: {
+		missingInput: "需要更明确的目标、输入材料或期望输出。",
+		fallback: "可先给出可选方向或最小可执行下一步。",
+	},
+});
+
+function classify(goal) {
+	if (/https?:\/\/|链接|帖子|查一下|调研|研究/.test(goal)) return "research";
+	if (/三个方向|创意|设计|文案|写作|起个名字/.test(goal)) return "creative";
+	if (/报错|bug|缺陷|无法复现|修复/.test(goal)) return "bug-fix";
+	if (/新功能|实现|开发|增加.*功能|添加.*功能/.test(goal)) return "feature";
+	if (/继续.*项目|恢复.*项目|上次.*停/.test(goal)) return "project-recovery";
+	return "general";
+}
+
+function instructionsFor(kind, preferences) {
+	const collaboration = [
+		preferences.autonomy === "direct" ? "在安全且可逆的范围内直接推进，不要先要求用户选择内部模式。" : undefined,
+		preferences.autonomy === "fewer-questions" ? "仅在缺少会明显改变结果的关键信息时提一个问题。" : undefined,
+		preferences.autonomy === "confirm-key-actions" ? "关键动作前说明影响并请求确认。" : undefined,
+		preferences.delivery === "three-directions" ? "先给出三个可区分的方向，再建议一个推荐方向。" : undefined,
+	].filter(Boolean);
+	const task = {
+		research: "优先说明来源是否可访问；无法取得内容时说明缺失并建议用户提供正文或替代来源。",
+		creative: "先给出可见的创作骨架或方向，避免暴露内部能力名称。",
+		"bug-fix": "先以可复现证据定位；无法复现时说明缺少的环境、输入或日志。",
+		feature: "先确认目标与范围；涉及高影响动作时保持既有确认边界。",
+		"project-recovery": "只在当前会话可见信息足够时恢复上下文；否则说明需要的项目状态。",
+		general: "直接用自然语言处理目标；资料不足时说明未完成部分和可行替代路径。",
+	}[kind];
+	return [...collaboration, task].join("\n");
+}
+
+export function classifyRequest(prompt, preferences = DEFAULT_PREFERENCES) {
+	const kind = classify(prompt.trim());
+	return {
+		fallback: FALLBACKS[kind]?.fallback,
+		instructions: instructionsFor(kind, preferences),
+		kind,
+		missingInput: FALLBACKS[kind]?.missingInput,
+	};
+}
+
+export function parseSessionPreference(input) {
+	const preferences = {};
+	const details = /展开细节|查看细节|显示细节/.test(input);
+	let goal = input;
+	for (const [pattern, changes] of CONTROL_PATTERNS) {
+		if (pattern.test(goal)) Object.assign(preferences, changes);
+		goal = goal.replace(pattern, "");
+	}
+	return { details, goal: goal.replace(/[，,。；;]+/g, " ").trim(), preferences };
+}
+
+export const parseSessionPreferences = parseSessionPreference;
+
+export function createRoutingPolicy() {
+	let preferences = { ...DEFAULT_PREFERENCES };
+
+	return {
+		route(input) {
+			const parsed = parseSessionPreference(input);
+			preferences = { ...preferences, ...parsed.preferences };
+			const route = classifyRequest(parsed.goal, preferences);
+			return {
+				...route,
+				details: parsed.details,
+				goal: parsed.goal,
+				preferences: { ...preferences },
+			};
+		},
+		reset() {
+			preferences = { ...DEFAULT_PREFERENCES };
+		},
+	};
+}

package/dist/fast-session.js

@@ -0,0 +1,276 @@
+const FAST_COMMAND_USAGE = "Usage: /fast [on|off|status]";
+
+function parseFastModelReference(value) {
+	const separatorIndex = value.indexOf("/");
+	if (separatorIndex <= 0 || separatorIndex === value.length - 1) return undefined;
+	return {
+		provider: value.slice(0, separatorIndex),
+		modelId: value.slice(separatorIndex + 1),
+	};
+}
+
+function formatModel(model) {
+	return model ? `${model.provider}/${model.id}` : "none";
+}
+
+function modelsMatch(left, right) {
+	return left?.provider === right?.provider && left?.id === right?.id;
+}
+
+export function createFastSessionController({
+	env = process.env,
+	initiallyEnabled = false,
+	initialUseConfiguredModel = true,
+	initialUseLowThinking = true,
+} = {}) {
+	let active = false;
+	let snapshot;
+	let internalTransition = false;
+	let currentThinkingTransition;
+	let pi;
+	const ignoredThinkingTransitions = [];
+	const activeListeners = new Set();
+	const explicitSelectionListeners = new Set();
+
+	function notifyStatus(ctx) {
+		ctx.ui.notify(
+			`Fast: ${active ? "on" : "off"}; model=${formatModel(ctx.model)}; thinking=${pi.getThinkingLevel()}`,
+			"info",
+		);
+	}
+
+	async function emitListeners(listeners, event, ctx) {
+		for (const listener of listeners) await listener(event, ctx);
+	}
+
+	async function exitForExplicitSelection(event, ctx) {
+		if (internalTransition) return;
+		if (active) {
+			active = false;
+			snapshot = undefined;
+			await emitListeners(activeListeners, false, ctx);
+		}
+		await emitListeners(explicitSelectionListeners, event, ctx);
+	}
+
+	async function handleThinkingSelection(event, ctx) {
+		if (
+			currentThinkingTransition &&
+			event.previousLevel === currentThinkingTransition.previousLevel &&
+			event.level === pi.getThinkingLevel()
+		) {
+			currentThinkingTransition.consumed = true;
+			return;
+		}
+		const ignoredIndex = ignoredThinkingTransitions.findIndex(
+			(transition) => transition.previousLevel === event.previousLevel && transition.level === event.level,
+		);
+		if (ignoredIndex !== -1) {
+			ignoredThinkingTransitions.splice(ignoredIndex, 1);
+			return;
+		}
+		await exitForExplicitSelection(event, ctx);
+	}
+
+	function beginThinkingTransition() {
+		const transition = {
+			previousLevel: pi.getThinkingLevel(),
+			level: pi.getThinkingLevel(),
+			consumed: false,
+		};
+		currentThinkingTransition = transition;
+		return transition;
+	}
+
+	function finishThinkingTransition(transition) {
+		transition.level = pi.getThinkingLevel();
+		currentThinkingTransition = undefined;
+		if (!transition.consumed && transition.level !== transition.previousLevel) {
+			ignoredThinkingTransitions.push(transition);
+		}
+	}
+
+	function setThinkingInternally(level) {
+		if (pi.getThinkingLevel() === level) return;
+		const transition = beginThinkingTransition();
+		try {
+			pi.setThinkingLevel(level);
+		} finally {
+			finishThinkingTransition(transition);
+		}
+	}
+
+	async function setModelInternally(model) {
+		const transition = beginThinkingTransition();
+		try {
+			return await pi.setModel(model);
+		} finally {
+			finishThinkingTransition(transition);
+		}
+	}
+
+	function resolveTarget(
+		ctx,
+		{ requireAuth = false, requireModel = false, useConfiguredModel = true, useLowThinking = true } = {},
+	) {
+		const configuredModel = useConfiguredModel ? env.BYZ_FAST_MODEL?.trim() : undefined;
+		let model = ctx.model;
+		if (configuredModel) {
+			const reference = parseFastModelReference(configuredModel);
+			if (!reference) {
+				ctx.ui.notify(`Invalid BYZ_FAST_MODEL "${configuredModel}". Expected provider/model.`, "error");
+				return undefined;
+			}
+			model = ctx.modelRegistry.find(reference.provider, reference.modelId);
+			if (!model) {
+				ctx.ui.notify(`Fast model "${configuredModel}" was not found.`, "error");
+				return undefined;
+			}
+			if (!ctx.modelRegistry.hasConfiguredAuth(model)) {
+				ctx.ui.notify(`Fast model "${configuredModel}" has no configured authentication.`, "error");
+				return undefined;
+			}
+			if (!ctx.model) {
+				ctx.ui.notify("Fast cannot preserve the current model because no model is selected.", "error");
+				return undefined;
+			}
+		}
+		if (!model && requireModel) {
+			ctx.ui.notify("Fast cannot preserve the current model because no model is selected.", "error");
+			return undefined;
+		}
+		if (model && requireAuth && !ctx.modelRegistry.hasConfiguredAuth(model)) {
+			ctx.ui.notify(`Fast model "${formatModel(model)}" has no configured authentication.`, "error");
+			return undefined;
+		}
+		return {
+			configuredModel,
+			model,
+			thinking: useLowThinking ? "low" : pi.getThinkingLevel(),
+		};
+	}
+
+	async function applyTarget(ctx, target) {
+		internalTransition = true;
+		try {
+			if (target.model && !modelsMatch(ctx.model, target.model)) {
+				const changed = await setModelInternally(target.model);
+				if (!changed) {
+					ctx.ui.notify(`Fast model "${formatModel(target.model)}" has no configured authentication.`, "error");
+					return false;
+				}
+			}
+			setThinkingInternally(target.thinking);
+			return true;
+		} catch (error) {
+			const message = error instanceof Error ? error.message : String(error);
+			ctx.ui.notify(`Fast target could not be applied: ${message}`, "error");
+			return false;
+		} finally {
+			internalTransition = false;
+		}
+	}
+
+	async function enable(ctx, { useConfiguredModel = true, useLowThinking = true } = {}) {
+		if (!ctx.isIdle()) {
+			ctx.ui.notify("Fast cannot change while the agent is busy.", "warning");
+			return;
+		}
+		if (active) {
+			notifyStatus(ctx);
+			return;
+		}
+
+		const target = resolveTarget(ctx, { useConfiguredModel, useLowThinking });
+		if (!target) return;
+		const nextSnapshot = {
+			model: ctx.model,
+			thinking: pi.getThinkingLevel(),
+		};
+		if (!(await applyTarget(ctx, target))) return;
+		snapshot = nextSnapshot;
+		active = true;
+		await emitListeners(activeListeners, true, ctx);
+		notifyStatus(ctx);
+	}
+
+	async function disable(ctx) {
+		if (!ctx.isIdle()) {
+			ctx.ui.notify("Fast cannot change while the agent is busy.", "warning");
+			return;
+		}
+		if (!active || !snapshot) {
+			notifyStatus(ctx);
+			return;
+		}
+
+		const originalTarget = { model: snapshot.model, thinking: snapshot.thinking };
+		if (!(await applyTarget(ctx, originalTarget))) return;
+		active = false;
+		snapshot = undefined;
+		await emitListeners(activeListeners, false, ctx);
+		notifyStatus(ctx);
+	}
+
+	function extension(extensionApi) {
+		pi = extensionApi;
+
+		pi.registerCommand("fast", {
+			description: "Switch Fast mode for the current session",
+			handler: async (args, ctx) => {
+				const action = args.trim().toLowerCase() || "status";
+				if (action === "status") {
+					notifyStatus(ctx);
+					return;
+				}
+				if (action === "on") {
+					await enable(ctx);
+					return;
+				}
+				if (action === "off") {
+					await disable(ctx);
+					return;
+				}
+				ctx.ui.notify(FAST_COMMAND_USAGE, "warning");
+			},
+		});
+
+		pi.on("model_select", exitForExplicitSelection);
+		pi.on("thinking_level_select", handleThinkingSelection);
+		if (initiallyEnabled) {
+			pi.on("session_start", async (_event, ctx) => {
+				await enable(ctx, {
+					useConfiguredModel: initialUseConfiguredModel,
+					useLowThinking: initialUseLowThinking,
+				});
+			});
+		}
+	}
+
+	return {
+		applyTarget,
+		extension,
+		formatTarget(target) {
+			return formatModel(target.model);
+		},
+		getThinkingLevel() {
+			return pi.getThinkingLevel();
+		},
+		isActive() {
+			return active;
+		},
+		onActiveChange(listener) {
+			activeListeners.add(listener);
+			return () => activeListeners.delete(listener);
+		},
+		onExplicitSelection(listener) {
+			explicitSelectionListeners.add(listener);
+			return () => explicitSelectionListeners.delete(listener);
+		},
+		resolveTarget,
+	};
+}
+
+export function createFastSwitchExtension(options) {
+	return createFastSessionController(options).extension;
+}

package/dist/fast.js

@@ -1,5 +1,7 @@
 import { getActiveByzOptionIndexes } from "./workflow-switch.js";
 
+export { createFastSessionController, createFastSwitchExtension } from "./fast-session.js";
+
 const SESSION_OPTIONS = new Set(["--continue", "-c", "--resume", "-r", "--session", "--session-id", "--fork"]);
 const THINKING_SUFFIX_PATTERN = /:(off|minimal|low|medium|high|xhigh|max)$/;
 
@@ -63,5 +65,12 @@ export function prepareFastRuntimeArgs(args, env = process.env) {
 		enabled: true,
 		model: explicitModel ?? (resumesSession ? "session" : configuredModel || "default"),
 		thinking: explicitThinking ?? modelThinking ?? "low",
+		useConfiguredModel: !hasModelOption && !resumesSession,
+		useLowThinking: !hasThinkingOption && !modelThinking,
 	};
 }
+
+export function selectFastRuntimeArgs(fastRuntime, { isInteractive, loadWorkflow }) {
+	if (isInteractive) return fastRuntime.commandArgs;
+	return loadWorkflow ? fastRuntime.args : fastRuntime.commandArgs;
+}