@aibyzero/byz 0.1.2 → 0.1.4

package/CHANGELOG.md

@@ -2,6 +2,22 @@
 
 ## Unreleased
 
+## 0.1.4 - 2026-08-27
+
+### Added
+
+- Added same-session `/workflow` hot switching between the bundled CM Workflow, CM Plugin Workflow, and no managed workflow while preserving conversation, model, thinking, Fast Mode, and unrelated host resources ([#18](https://github.com/kingxiaozhe/byz/pull/18)).
+
+## 0.1.3 - 2026-08-27
+
+### Added
+
+- Added opt-in Fast Mode with the complete selected workflow, `thinking=low` by default, optional `BYZ_FAST_MODEL`, and explicit model or thinking options taking precedence ([#15](https://github.com/kingxiaozhe/byz/pull/15)).
+
+### Fixed
+
+- Made BYZ's bundled workflow skills and prompts win same-name host collisions while continuing to load unrelated host resources ([#16](https://github.com/kingxiaozhe/byz/pull/16)).
+
 ## 0.1.2 - 2026-08-27
 
 ### Added

package/README.md

@@ -34,6 +34,28 @@ Workflows do not have an end-user update or rollback command. Every BYZ release
 selects one CM version and one compatible CM Plugin version; users run the
 versions selected by their installed BYZ release.
 
+## Fast mode
+
+Use Fast mode for lower-latency, lower-token everyday work without removing the
+selected workflow's skills, prompts, context, or quality gates:
+
+```bash
+byz --fast
+byz --fast --workflow cm-plugin
+```
+
+Fast mode uses Pi's existing runtime controls and defaults thinking to `low`.
+Set an optional model once when a separate fast model is available:
+
+```bash
+export BYZ_FAST_MODEL="provider/model"
+byz --fast
+```
+
+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.
+
 ## Workflows
 
 ```bash
@@ -45,9 +67,15 @@ byz --workflow cm-plugin
 byz --workflow none
 ```
 
-BYZ loads at most one workflow per session. Users do not install, update, or
-roll back either workflow separately. Local development can override package
-roots with `BYZ_CM_WORKFLOW_ROOT` or
+Inside an interactive session, `/workflow` shows the active workflow.
+`/workflow cm`, `/workflow cm-plugin`, and `/workflow none` switch it in place
+without starting a new conversation or calling the model. BYZ validates the
+target before replacing its managed skills and prompts, does not reload
+unrelated extensions, and rejects switching while the agent is running.
+
+BYZ loads at most one workflow at a time. Users do not install, update, or roll
+back either workflow separately. Local development can override package roots
+with `BYZ_CM_WORKFLOW_ROOT` or
 `BYZ_CM_PLUGIN_WORKFLOW_ROOT`; the two roots must remain distinct.
 
 ## Development

package/dist/cli.js

@@ -1,8 +1,15 @@
 #!/usr/bin/env node
 
+import { prepareFastRuntimeArgs } from "./fast.js";
 import { main } from "./runtime/bundle/index.js";
 import { handleByzUpdate } from "./update.js";
-import { handleWorkflowCommand, parseWorkflowOption, prepareWorkflowRuntimeArgs } from "./workflows.js";
+import { createWorkflowSwitchExtension, shouldEnableWorkflowSwitch, shouldLoadWorkflow } from "./workflow-switch.js";
+import {
+	handleWorkflowCommand,
+	parseWorkflowOption,
+	prepareWorkflowRuntimeArgs,
+	resolveWorkflowRuntimeResources,
+} from "./workflows.js";
 
 process.title = "byz";
 process.env.BYZ_CODING_AGENT = "true";
@@ -13,21 +20,14 @@ process.env.PI_TELEMETRY = "0";
 
 const args = process.argv.slice(2);
 
-function shouldLoadWorkflow(runtimeArgs) {
-	const terminatorIndex = runtimeArgs.indexOf("--");
-	const optionArgs = runtimeArgs.slice(0, terminatorIndex === -1 ? runtimeArgs.length : terminatorIndex);
-	if (optionArgs.some((arg) => ["--help", "-h", "--version", "-v", "--export", "--list-models"].includes(arg))) {
-		return false;
-	}
-	return !["auth", "config", "install", "list", "remove", "uninstall", "update"].includes(optionArgs[0]);
-}
-
 try {
-	const parsedWorkflow = parseWorkflowOption(args);
+	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|status|check> [cm|cm-plugin]");
 	}
@@ -37,8 +37,32 @@ try {
 	} else if (await handleByzUpdate(commandArgs)) {
 		// BYZ release metadata and package target stay independent from Pi.
 	} else {
-		const prepared = await prepareWorkflowRuntimeArgs(args, { load: shouldLoadWorkflow(commandArgs) });
-		await main(prepared.args);
+		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}`,
+			);
+		}
+
+		if (loadWorkflow && isInteractive) {
+			const parsedRuntimeWorkflow = parseWorkflowOption(runtimeArgs);
+			const resolveResources = (workflowId) =>
+				resolveWorkflowRuntimeResources(workflowId, parsedRuntimeWorkflow.forwardedArgs);
+			const workflowExtension = createWorkflowSwitchExtension({
+				initialResources: await resolveResources(parsedRuntimeWorkflow.workflowId),
+				initialWorkflowId: parsedRuntimeWorkflow.workflowId,
+				resolveResources,
+			});
+			await main(parsedRuntimeWorkflow.forwardedArgs, { byzWorkflowExtensionFactory: workflowExtension });
+		} else {
+			const prepared = await prepareWorkflowRuntimeArgs(runtimeArgs, { load: loadWorkflow });
+			await main(prepared.args);
+		}
 	}
 } catch (error) {
 	console.error(error instanceof Error ? error.message : String(error));

package/dist/fast.js

@@ -0,0 +1,67 @@
+import { getActiveByzOptionIndexes } from "./workflow-switch.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)$/;
+
+function getOptionArgs(args) {
+	const terminatorIndex = args.indexOf("--");
+	return args.slice(0, terminatorIndex === -1 ? args.length : terminatorIndex);
+}
+
+function findOptionValue(args, option) {
+	let value;
+	for (let index = 0; index < args.length; index++) {
+		if (args[index] === option) value = args[index + 1];
+	}
+	return value;
+}
+
+export function prepareFastRuntimeArgs(args, env = process.env) {
+	const forwardedArgs = [];
+	const activeFastOptions = getActiveByzOptionIndexes(args, "fast");
+	let enabled = false;
+	for (let index = 0; index < args.length; index++) {
+		const arg = args[index];
+		if (arg === "--") {
+			forwardedArgs.push(...args.slice(index));
+			break;
+		}
+		if (arg === "--fast" && activeFastOptions.has(index)) {
+			if (enabled) throw new Error("--fast may only be specified once.");
+			enabled = true;
+			continue;
+		}
+		if (arg.startsWith("--fast=") && activeFastOptions.has(index)) {
+			throw new Error("--fast does not accept a value.");
+		}
+		forwardedArgs.push(arg);
+	}
+
+	if (!enabled) {
+		return { args: forwardedArgs, commandArgs: forwardedArgs, enabled: false };
+	}
+
+	const optionArgs = getOptionArgs(forwardedArgs);
+	const hasModelOption = optionArgs.includes("--model");
+	const hasThinkingOption = optionArgs.includes("--thinking");
+	const resumesSession = optionArgs.some((arg) => SESSION_OPTIONS.has(arg));
+	const configuredModel = env.BYZ_FAST_MODEL?.trim();
+	const explicitModel = findOptionValue(optionArgs, "--model");
+	const modelThinking = explicitModel?.match(THINKING_SUFFIX_PATTERN)?.[1];
+	const presetArgs = [];
+	if (!hasModelOption && !resumesSession && configuredModel) {
+		presetArgs.push("--model", configuredModel);
+	}
+	if (!hasThinkingOption && !modelThinking) {
+		presetArgs.push("--thinking", "low");
+	}
+
+	const explicitThinking = findOptionValue(optionArgs, "--thinking");
+	return {
+		args: [...presetArgs, ...forwardedArgs],
+		commandArgs: forwardedArgs,
+		enabled: true,
+		model: explicitModel ?? (resumesSession ? "session" : configuredModel || "default"),
+		thinking: explicitThinking ?? modelThinking ?? "low",
+	};
+}