@aibyzero/byz 0.1.2 → 0.1.3

package/CHANGELOG.md

@@ -2,6 +2,16 @@
 
 ## Unreleased
 
+## 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

package/dist/cli.js

@@ -1,5 +1,6 @@
 #!/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";
@@ -23,11 +24,13 @@ function shouldLoadWorkflow(runtimeArgs) {
 }
 
 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,7 +40,21 @@ 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) });
+		const loadWorkflow = shouldLoadWorkflow(commandArgs);
+		const runtimeArgs = loadWorkflow ? fastRuntime.args : fastRuntime.commandArgs;
+		const prepared = await prepareWorkflowRuntimeArgs(runtimeArgs, { load: loadWorkflow });
+		const optionArgs = commandArgs.slice(
+			0,
+			commandArgs.indexOf("--") === -1 ? commandArgs.length : commandArgs.indexOf("--"),
+		);
+		const isInteractive = !optionArgs.some((arg) =>
+			["--help", "-h", "--version", "-v", "--export", "--list-models", "--print", "-p", "--mode"].includes(arg),
+		);
+		if (fastRuntime.enabled && loadWorkflow && isInteractive) {
+			console.error(
+				`BYZ Fast: model=${fastRuntime.model}, thinking=${fastRuntime.thinking}, workflow=${prepared.workflowId}`,
+			);
+		}
 		await main(prepared.args);
 	}
 } catch (error) {

package/dist/fast.js

@@ -0,0 +1,64 @@
+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 = [];
+	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") {
+			if (enabled) throw new Error("--fast may only be specified once.");
+			enabled = true;
+			continue;
+		}
+		if (arg.startsWith("--fast=")) {
+			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",
+	};
+}