opencode-clm 0.2.0 → 0.4.0

package/src/settings-table.ts

@@ -10,13 +10,14 @@
  */
 import { basename, resolve } from "node:path";
 
-import { resolveBudgetPolicy } from "./budget.ts";
+import { FALLBACK_BUDGET, formatPercent, resolveBudget, resolveBudgetPolicy, type BudgetPolicyConfig } from "./budget.ts";
 import { MIN_OBSERVATION_CAP, resolveObservationCap } from "./observation.ts";
 import { toEditGate, type EditGate } from "./policy.ts";
-import { HOUSE_STEERING, parseFlag, parseFractions, parseTokens, type ClmSettings } from "./settings.ts";
+import { HOUSE_STEERING, parseBudget, parseCompaction, parseCooldown, parseFlag, parseFractions, parseMode, parseTokens, type ClmMode, type ClmSettings, type CompactionMode } from "./settings.ts";
 
 export type SettingKey =
-	| "editing" | "budget" | "reserve" | "reminders" | "gate" | "guard" | "cap" | "steering" | "compactPrompt" | "reasoning";
+	| "editing" | "budget" | "reserve" | "reminders" | "cooldown" | "gate" | "guard" | "compaction" | "cap" | "steering" | "mode" | "oneTool" | "trailer"
+	| "compactPrompt" | "reasoning";
 
 /**
  * Per-session changes, as stored in overrides.json. Only keys that differ from the base are
@@ -25,12 +26,16 @@ export type SettingKey =
  */
 export interface ClmOverrides {
 	editing?: boolean;
-	budget?: number | null;
+	/** Tokens, a share of the model window as text (`"50%"`), or null for the whole window. */
+	budget?: number | BudgetPercent | null;
 	reserve?: number;
 	/** Reminder fractions; empty disables every reminder, the budget − reserve one included. */
 	reminders?: number[];
+	/** Reminder cooldown as a share of the budget; 0 is off. */
+	cooldown?: number;
 	gate?: EditGate;
 	guard?: "withhold" | "off";
+	compaction?: CompactionMode;
 	cap?: number | null;
 	capHead?: number;
 	/** Absolute path. */
@@ -38,8 +43,14 @@ export interface ClmOverrides {
 	/** Absolute path. */
 	compactPrompt?: string | null;
 	reasoning?: boolean;
+	oneTool?: boolean;
+	trailer?: boolean;
+	mode?: ClmMode;
 }
 
+/** A budget percentage as stored in overrides.json: `"50%"`, `"12.5%"`. */
+export type BudgetPercent = `${number}%`;
+
 /** Settings in force for one session: the resolved settings plus whether edits apply. */
 export interface SettingsValues {
 	editing: boolean;
@@ -49,6 +60,8 @@ export interface SettingsValues {
 export interface FormatContext {
 	/** Model context window, shown next to a `window` budget. */
 	modelWindow?: number;
+	/** Model output limit; a percentage budget is a share of the window minus this. */
+	modelOutput?: number;
 }
 
 export interface ParseContext {
@@ -78,6 +91,24 @@ export function compactTokens(value: number): string {
 	return value.toLocaleString("en-US");
 }
 
+const percentText = (fraction: number) => formatPercent(fraction) as BudgetPercent;
+
+/** `"50%"` → 0.5; undefined for anything but a percentage from 1% to 100%. */
+export function budgetPercentFraction(value: unknown): number | undefined {
+	if (typeof value !== "string" || !/^\d+(?:\.\d+)?%$/.test(value)) return undefined;
+	const percent = Number(value.slice(0, -1));
+	return percent >= 1 && percent <= 100 ? percent / 100 : undefined;
+}
+
+/** The budget fields of a policy for a `budget` override. */
+function budgetFields(budget: number | BudgetPercent | null): Pick<BudgetPolicyConfig, "contextBudget" | "contextFraction"> {
+	if (budget === null) return { contextBudget: undefined, contextFraction: undefined };
+	if (typeof budget === "number") return { contextBudget: budget, contextFraction: undefined };
+	const fraction = budgetPercentFraction(budget);
+	if (fraction === undefined) throw new Error(`budget must be a percentage from 1% to 100%, got ${JSON.stringify(budget)}`);
+	return { contextBudget: undefined, contextFraction: fraction };
+}
+
 const onOff = (value: boolean) => (value ? "on" : "off");
 
 function formatReminders(fractions: readonly number[]): string {
@@ -134,19 +165,25 @@ export const SETTINGS_TABLE: readonly SettingDescriptor[] = [
 		key: "budget",
 		name: "budget",
 		label: "Budget",
-		description: "Token budget the reminders, the edit gate and the overflow guard measure against, OpenCode's system prompt and tool schemas included. A number (32k) or \"window\" for the model's context window. Env: CLM_BUDGET.",
-		placeholder: "32k, 1.5m, or window",
+		description: `Token budget the reminders, the edit gate and the overflow guard measure against, OpenCode's system prompt and tool schemas included. A percentage of the model window minus its output limit (50%; ${compactTokens(FALLBACK_BUDGET)} while the window is unknown), a number (32k), or "window" for all of it. Env: CLM_BUDGET.`,
+		placeholder: "50%, 32k, 1.5m, or window",
 		format: (values, context) => {
-			const budget = values.settings.budget.contextBudget;
-			if (budget !== undefined) return compactTokens(budget);
+			const policy = values.settings.budget;
+			if (policy.contextBudget !== undefined) return compactTokens(policy.contextBudget);
+			if (policy.contextFraction !== undefined) {
+				const resolved = context?.modelWindow ? resolveBudget(policy, context.modelWindow, context.modelOutput) : undefined;
+				return `${formatPercent(policy.contextFraction)}${resolved ? ` (${compactTokens(resolved.budget)})` : ""}`;
+			}
 			return `window${context?.modelWindow ? ` (${compactTokens(context.modelWindow)})` : ""}`;
 		},
+		// The settings page pre-fills its prompt with the formatted value: `50% (131,072)`.
 		parse: (text) => {
-			const value = text.trim().toLowerCase();
-			if (value === "window" || value === "model") return { budget: null };
-			const budget = parseTokens(value, "budget");
-			if (budget <= 0) throw new Error(`budget must be a positive number of tokens or "window", got "${text}"`);
-			return { budget };
+			const parsed = parseBudget(text.replace(/\s*\([^)]*\)\s*$/, ""), "budget");
+			switch (parsed.kind) {
+				case "window": return { budget: null };
+				case "fraction": return { budget: percentText(parsed.fraction) };
+				case "tokens": return { budget: parsed.tokens };
+			}
 		},
 	},
 	{
@@ -167,6 +204,17 @@ export const SETTINGS_TABLE: readonly SettingDescriptor[] = [
 		format: (values) => formatReminders(values.settings.budget.remindAtFractions),
 		parse: (text) => ({ reminders: parseReminders(text) }),
 	},
+	{
+		key: "cooldown",
+		// Named after the reminders it governs; `cooldown` is an alias.
+		name: "reminder-cooldown",
+		label: "Reminder cooldown",
+		description: "After an accepted edit, percentage reminders stay silent until the context grows by this share of the budget; tiers crossed meanwhile are skipped. The budget − reserve reminder always fires. A share (10%, 0.1) or off. Env: CLM_REMINDER_COOLDOWN.",
+		choices: ["10%", "25%", "5%", "off"],
+		placeholder: "10%, 0.1, or off",
+		format: (values) => (values.settings.budget.reminderCooldown > 0 ? formatPercent(values.settings.budget.reminderCooldown) : "off"),
+		parse: (text) => ({ cooldown: parseCooldown(text, "reminder-cooldown") }),
+	},
 	{
 		key: "gate",
 		name: "gate",
@@ -185,6 +233,15 @@ export const SETTINGS_TABLE: readonly SettingDescriptor[] = [
 		format: (values) => onOff(values.settings.guard === "withhold"),
 		parse: (text) => ({ guard: parseFlag(text.trim().toLowerCase() === "withhold" ? "on" : text, "guard") ? "withhold" : "off" }),
 	},
+	{
+		key: "compaction",
+		name: "compaction",
+		label: "OC compaction",
+		description: "OpenCode's automatic compaction: off turns it off (a provider overflow is then reported, not compacted); auto and on leave your config's compaction.auto (under auto the overflow guard keeps requests below OpenCode's threshold). Manual /compact always works. The flag is shared by every session of the server. Env: CLM_NATIVE_COMPACTION.",
+		choices: ["auto", "off", "on"],
+		format: (values) => values.settings.compaction,
+		parse: (text) => ({ compaction: parseCompaction(text) }),
+	},
 	{
 		key: "cap",
 		name: "cap",
@@ -210,6 +267,33 @@ export const SETTINGS_TABLE: readonly SettingDescriptor[] = [
 			return { steering: parsePathSetting(text, context.directory, ["none", "off", ""]) };
 		},
 	},
+	{
+		key: "mode",
+		name: "mode",
+		label: "Mode",
+		description: "edit: the model edits its context through the mirror. notices-only: no mirror, no protocol prompt and no edits; budget notices and reminders, the overflow guard, the observation cap and the size trailer still apply, to compare telling the model its budget with letting it edit. An accepted revision is kept but not applied while notices-only is in force. Env: CLM_MODE.",
+		choices: ["edit", "notices-only"],
+		format: (values) => values.settings.mode,
+		parse: (text) => ({ mode: parseMode(text) }),
+	},
+	{
+		key: "oneTool",
+		name: "one-tool",
+		label: "One tool per turn",
+		description: "Paper-harness parity: run only the first tool call of each model response; later calls in it fail with a note to repeat them. Env: CLM_ONE_TOOL_PER_TURN.",
+		choices: ["off", "on"],
+		format: (values) => onOff(values.settings.oneTool),
+		parse: (text) => ({ oneTool: parseFlag(text, "one-tool") }),
+	},
+	{
+		key: "trailer",
+		name: "trailer",
+		label: "Size trailer",
+		description: "Paper-harness parity: end every successful tool result with \"[context: ~N of B tokens after this result]\". Env: CLM_SIZE_TRAILER.",
+		choices: ["off", "on"],
+		format: (values) => onOff(values.settings.trailer),
+		parse: (text) => ({ trailer: parseFlag(text, "trailer") }),
+	},
 	{
 		key: "compactPrompt",
 		name: "compact-prompt",
@@ -239,18 +323,30 @@ const ALIASES: Record<string, SettingKey> = {
 	remind: "reminders",
 	"remind-at": "reminders",
 	remindat: "reminders",
+	cooldown: "cooldown",
+	"reminder-cooldown": "cooldown",
+	remindercooldown: "cooldown",
 	gate: "gate",
 	"edit-gate": "gate",
 	guard: "guard",
 	overflow: "guard",
+	compaction: "compaction",
+	"native-compaction": "compaction",
 	cap: "cap",
 	observation: "cap",
 	"observation-cap": "cap",
 	observationcap: "cap",
 	steering: "steering",
+	"one-tool": "oneTool",
+	onetool: "oneTool",
+	"one-tool-per-turn": "oneTool",
+	trailer: "trailer",
+	"size-trailer": "trailer",
+	sizetrailer: "trailer",
 	"compact-prompt": "compactPrompt",
 	compactprompt: "compactPrompt",
 	reasoning: "reasoning",
+	mode: "mode",
 };
 
 /** Names `/clm config` lists. */
@@ -274,10 +370,13 @@ export function unknownSettingText(name: string): string {
 export function applyOverrides(base: ClmSettings, overrides: ClmOverrides): ClmSettings {
 	const budget = resolveBudgetPolicy({
 		...base.budget,
-		contextBudget: overrides.budget === null ? undefined : overrides.budget ?? base.budget.contextBudget,
+		...(overrides.budget !== undefined
+			? budgetFields(overrides.budget)
+			: { contextBudget: base.budget.contextBudget, contextFraction: base.budget.contextFraction }),
 		reserve: overrides.reserve ?? base.budget.reserve,
 		remindAtFractions: overrides.reminders ?? base.budget.remindAtFractions,
 		remindAtReserve: overrides.reminders !== undefined ? overrides.reminders.length > 0 : base.budget.remindAtReserve,
+		reminderCooldown: overrides.cooldown ?? base.budget.reminderCooldown,
 	});
 	const observationCap = resolveObservationCap({
 		maxCharacters: overrides.cap === null ? undefined : overrides.cap ?? base.observationCap.maxCharacters,
@@ -288,6 +387,10 @@ export function applyOverrides(base: ClmSettings, overrides: ClmOverrides): ClmS
 		budget,
 		gate: overrides.gate ?? base.gate,
 		guard: overrides.guard ?? base.guard,
+		compaction: overrides.compaction ?? base.compaction,
+		oneTool: overrides.oneTool ?? base.oneTool,
+		trailer: overrides.trailer ?? base.trailer,
+		mode: overrides.mode ?? base.mode,
 		observationCap,
 		steeringPath: overrides.steering === null ? undefined : overrides.steering ?? base.steeringPath,
 		compactPromptPath: overrides.compactPrompt === null ? undefined : overrides.compactPrompt ?? base.compactPromptPath,
@@ -300,16 +403,22 @@ function baseValue(key: keyof ClmOverrides, values: SettingsValues): unknown {
 	const settings = values.settings;
 	switch (key) {
 		case "editing": return values.editing;
-		case "budget": return settings.budget.contextBudget ?? null;
+		case "budget": return settings.budget.contextBudget ??
+			(settings.budget.contextFraction !== undefined ? percentText(settings.budget.contextFraction) : null);
 		case "reserve": return settings.budget.reserve;
 		case "reminders": return settings.budget.remindAtReserve || settings.budget.remindAtFractions.length > 0 ? [...settings.budget.remindAtFractions] : [];
+		case "cooldown": return settings.budget.reminderCooldown;
 		case "gate": return settings.gate;
 		case "guard": return settings.guard;
+		case "compaction": return settings.compaction;
+		case "oneTool": return settings.oneTool;
+		case "trailer": return settings.trailer;
 		case "cap": return settings.observationCap.maxCharacters ?? null;
 		case "capHead": return settings.observationCap.headFraction;
 		case "steering": return settings.steeringPath ?? null;
 		case "compactPrompt": return settings.compactPromptPath ?? null;
 		case "reasoning": return settings.reasoning;
+		case "mode": return settings.mode;
 	}
 }
 
@@ -321,7 +430,7 @@ function baseValue(key: keyof ClmOverrides, values: SettingsValues): unknown {
  */
 export function settingsAsOverrides(settings: ClmSettings): ClmOverrides {
 	const values: SettingsValues = { editing: true, settings };
-	const keys: Array<keyof ClmOverrides> = ["budget", "reserve", "reminders", "gate", "guard", "cap", "capHead", "steering", "compactPrompt", "reasoning"];
+	const keys: Array<keyof ClmOverrides> = ["budget", "reserve", "reminders", "cooldown", "gate", "guard", "compaction", "cap", "capHead", "steering", "mode", "oneTool", "trailer", "compactPrompt", "reasoning"];
 	return Object.fromEntries(keys.map((key) => [key, baseValue(key, values)])) as ClmOverrides;
 }
 
@@ -340,16 +449,21 @@ const isPath = (value: unknown) => value === null || (typeof value === "string"
 const VALID: Record<keyof ClmOverrides, (value: unknown) => boolean> = {
 	editing: (value) => typeof value === "boolean",
 	// Integers: state.json's budget check stores them as counts.
-	budget: (value) => value === null || (Number.isInteger(value) && (value as number) > 0),
+	budget: (value) => value === null || (Number.isInteger(value) && (value as number) > 0) || budgetPercentFraction(value) !== undefined,
 	reserve: (value) => Number.isInteger(value) && (value as number) >= 0,
 	reminders: (value) => Array.isArray(value) && value.every((fraction) => isNumber(fraction) && fraction > 0 && fraction < 1),
+	cooldown: (value) => isNumber(value) && value >= 0 && value < 1,
 	gate: (value) => value === "fit" || value === "shrink" || value === "none",
 	guard: (value) => value === "withhold" || value === "off",
+	compaction: (value) => value === "auto" || value === "off" || value === "on",
+	oneTool: (value) => typeof value === "boolean",
+	trailer: (value) => typeof value === "boolean",
 	cap: (value) => value === null || (isNumber(value) && value >= MIN_OBSERVATION_CAP),
 	capHead: (value) => isNumber(value) && value > 0 && value <= 1,
 	steering: isPath,
 	compactPrompt: isPath,
 	reasoning: (value) => typeof value === "boolean",
+	mode: (value) => value === "edit" || value === "notices-only",
 };
 
 /**

package/src/settings.ts

@@ -5,8 +5,7 @@
  * instead of running with a guess.
  *
  * Setting set adapted from pi-clm src/settings.ts (MIT, Copyright 2026 Emanuel Casco).
- * pi-clm's per-session overrides (`/clm config` panel) are not ported: OpenCode commands
- * cannot open a panel.
+ * Per-session overrides (`/clm config`) live in src/settings-table.ts and src/overrides.ts.
  */
 import { join, resolve } from "node:path";
 import { fileURLToPath } from "node:url";
@@ -38,6 +37,40 @@ export interface ClmSettings {
 	commands: boolean;
 	/** Write every transformed request to `<session dir>/requests/nN.json` (debugging). */
 	dumpRequests: boolean;
+	/**
+	 * OpenCode's automatic compaction (`compaction.auto`): `off` turns it off; `auto` pauses it
+	 * while the guard enforces a budget (src/compaction.ts); `on` leaves the user's config value
+	 * (pi's names). Manual /compact always works.
+	 */
+	compaction: CompactionMode;
+	/** Run only the first tool call of each model response (paper-harness parity). */
+	oneTool: boolean;
+	/** Append `[context: ~N of B tokens after this result]` to tool results (paper-harness parity). */
+	trailer: boolean;
+	/**
+	 * `edit`: the model edits its context through the mirror. `notices-only`: no mirror, no
+	 * protocol prompt and no edits; budget notices, reminders, the guard, the cap and the
+	 * trailer still apply (to compare telling the model its budget with letting it edit).
+	 */
+	mode: ClmMode;
+}
+
+export type ClmMode = "edit" | "notices-only";
+
+/** `edit`, `notices-only`, or `notices` (an alias of `notices-only`). */
+export function parseMode(value: unknown, name = "mode"): ClmMode {
+	const text = String(value).trim().toLowerCase();
+	if (text === "edit") return "edit";
+	if (text === "notices-only" || text === "notices") return "notices-only";
+	throw new Error(`${name} must be edit or notices-only, got ${JSON.stringify(value)}`);
+}
+
+export type CompactionMode = "auto" | "off" | "on";
+
+export function parseCompaction(value: unknown, name = "compaction"): CompactionMode {
+	const text = String(value).trim().toLowerCase();
+	if (text === "auto" || text === "off" || text === "on") return text;
+	throw new Error(`${name} must be auto, off or on, got ${JSON.stringify(value)}`);
 }
 
 export const PACKAGE_DIR = resolve(fileURLToPath(new URL("..", import.meta.url)));
@@ -47,6 +80,7 @@ export const SKILLS_DIR = join(PACKAGE_DIR, "skills");
 type Env = Record<string, string | undefined>;
 
 const OFF_WORDS = ["none", "off"];
+const BUDGET_FORMS = `a number of tokens (32000, 32k), a percentage of the model window (1% to 100%), or "window"`;
 
 function pick(options: Record<string, unknown>, key: string, env: Env, envKey: string): unknown {
 	if (options[key] !== undefined) return options[key];
@@ -55,6 +89,11 @@ function pick(options: Record<string, unknown>, key: string, env: Env, envKey: s
 }
 
 /** `32000`, `32k`, `1.5m`, `32_000`, `32,000`. */
+/** The default `mirrorDir`: `<project>/.opencode/clm`, inside the project, so the model's tools reach it without an external-directory permission. */
+export function defaultMirrorDir(directory: string): string {
+	return join(directory, ".opencode", "clm");
+}
+
 export function parseTokens(value: unknown, name: string): number {
 	const text = String(value).trim().toLowerCase().replace(/[_,]/g, "");
 	const match = /^(\d+(?:\.\d+)?)(k|m)?$/.exec(text);
@@ -63,6 +102,34 @@ export function parseTokens(value: unknown, name: string): number {
 	return Math.round(Number(match[1]) * scale);
 }
 
+export type BudgetValue =
+	| { kind: "tokens"; tokens: number }
+	| { kind: "fraction"; fraction: number }
+	| { kind: "window" };
+
+/**
+ * A budget setting: `32000` / `32k` (tokens), `50%` (of the model window minus its output
+ * limit; 1% to 100%), or `window` / `model` (the whole of it).
+ */
+export function parseBudget(value: unknown, name = "budget"): BudgetValue {
+	const text = String(value).trim().toLowerCase();
+	if (text === "window" || text === "model") return { kind: "window" };
+	if (text.endsWith("%")) {
+		const number = text.slice(0, -1).trim();
+		const percent = /^\d+(?:\.\d+)?$/.test(number) ? Number(number) : Number.NaN;
+		if (!(percent >= 1 && percent <= 100)) throw new Error(`${name} must be ${BUDGET_FORMS}, got ${JSON.stringify(value)}`);
+		return { kind: "fraction", fraction: percent / 100 };
+	}
+	let tokens: number;
+	try {
+		tokens = parseTokens(value, name);
+	} catch {
+		throw new Error(`${name} must be ${BUDGET_FORMS}, got ${JSON.stringify(value)}`);
+	}
+	if (tokens <= 0) throw new Error(`${name} must be a positive number of tokens or "window", got ${JSON.stringify(value)}`);
+	return { kind: "tokens", tokens };
+}
+
 export function parseFlag(value: unknown, name: string): boolean {
 	if (typeof value === "boolean") return value;
 	const key = String(value).trim().toLowerCase();
@@ -89,6 +156,23 @@ export function parseFractions(value: unknown, name: string): number[] | "off" {
 	return [...new Set(fractions)];
 }
 
+const COOLDOWN_FORMS = `a share of the budget between 0 and 1, as a percentage (10%) or a fraction (0.1), or off`;
+
+/**
+ * The reminder cooldown: `10%` or `0.1` (a share of the budget, strictly between 0 and 1), or
+ * `off` / `none` / `0` for no cooldown (0).
+ */
+export function parseCooldown(value: unknown, name = "reminderCooldown"): number {
+	if (value === false) return 0;
+	const text = String(value).trim().toLowerCase();
+	if (text === "off" || text === "none" || text === "0" || text === "0%") return 0;
+	const percent = text.endsWith("%");
+	const number = percent ? text.slice(0, -1).trim() : text;
+	const parsed = /^\d*\.?\d+$/.test(number) ? Number(number) / (percent ? 100 : 1) : Number.NaN;
+	if (!(parsed > 0 && parsed < 1)) throw new Error(`${name} must be ${COOLDOWN_FORMS}, got ${JSON.stringify(value)}`);
+	return parsed;
+}
+
 function withName<T>(name: string, parse: () => T): T {
 	try {
 		return parse();
@@ -110,6 +194,7 @@ export function resolveSettings(options: Record<string, unknown> = {}, env: Env
 	const budgetRaw = pick(options, "budget", env, "CLM_BUDGET");
 	const reserveRaw = pick(options, "reserve", env, "CLM_RESERVE");
 	const remindRaw = pick(options, "remindAt", env, "CLM_REMIND_AT");
+	const cooldownRaw = pick(options, "reminderCooldown", env, "CLM_REMINDER_COOLDOWN");
 	const gateRaw = pick(options, "gate", env, "CLM_EDIT_GATE");
 	const guardRaw = pick(options, "guard", env, "CLM_OVERFLOW");
 	const capRaw = pick(options, "observationCap", env, "CLM_OBSERVATION_CAP");
@@ -119,11 +204,16 @@ export function resolveSettings(options: Record<string, unknown> = {}, env: Env
 	const factorRaw = pick(options, "estimateFactor", env, "CLM_ESTIMATE_FACTOR");
 	const reasoningRaw = pick(options, "reasoning", env, "CLM_REASONING");
 	const dumpRaw = pick(options, "dumpRequests", env, "CLM_DUMP_REQUESTS");
+	const compactionRaw = pick(options, "compaction", env, "CLM_NATIVE_COMPACTION");
+	const oneToolRaw = pick(options, "oneTool", env, "CLM_ONE_TOOL_PER_TURN");
+	const trailerRaw = pick(options, "trailer", env, "CLM_SIZE_TRAILER");
+	const modeRaw = pick(options, "mode", env, "CLM_MODE");
 
 	const overrides: Partial<BudgetPolicyConfig> = {};
 	if (budgetRaw !== undefined) {
-		overrides.contextBudget = String(budgetRaw).trim().toLowerCase() === "window" ? undefined : parseTokens(budgetRaw, "budget");
-		if (overrides.contextBudget === 0) throw new Error(`budget must be a positive number of tokens or "window", got ${JSON.stringify(budgetRaw)}`);
+		const parsed = parseBudget(budgetRaw, "budget");
+		overrides.contextBudget = parsed.kind === "tokens" ? parsed.tokens : undefined;
+		overrides.contextFraction = parsed.kind === "fraction" ? parsed.fraction : undefined;
 	}
 	if (reserveRaw !== undefined) overrides.reserve = parseTokens(reserveRaw, "reserve");
 	if (remindRaw !== undefined) {
@@ -139,6 +229,7 @@ export function resolveSettings(options: Record<string, unknown> = {}, env: Env
 			overrides.remindAtFractions = fractions;
 		}
 	}
+	if (cooldownRaw !== undefined) overrides.reminderCooldown = parseCooldown(cooldownRaw, "reminderCooldown");
 	const budget = withName("budget", () => resolveBudgetPolicy({ ...DEFAULT_BUDGET_POLICY, ...overrides }));
 
 	let guard: ClmSettings["guard"] = "withhold";
@@ -177,7 +268,7 @@ export function resolveSettings(options: Record<string, unknown> = {}, env: Env
 		gate: gateRaw === undefined ? "fit" : withName("gate (CLM_EDIT_GATE)", () => toEditGate(gateRaw)),
 		guard,
 		observationCap,
-		mirrorDir: dirRaw === undefined ? join(directory, ".opencode", "clm") : resolve(directory, String(dirRaw)),
+		mirrorDir: dirRaw === undefined ? defaultMirrorDir(directory) : resolve(directory, String(dirRaw)),
 		steeringPath,
 		compactPromptPath,
 		estimateFactor,
@@ -185,5 +276,9 @@ export function resolveSettings(options: Record<string, unknown> = {}, env: Env
 		skill: options.skill === undefined ? true : parseFlag(options.skill, "skill"),
 		commands: options.commands === undefined ? true : parseFlag(options.commands, "commands"),
 		dumpRequests: dumpRaw === undefined ? false : parseFlag(dumpRaw, "dumpRequests"),
+		compaction: compactionRaw === undefined ? "auto" : parseCompaction(compactionRaw),
+		oneTool: oneToolRaw === undefined ? false : parseFlag(oneToolRaw, "oneTool"),
+		trailer: trailerRaw === undefined ? false : parseFlag(trailerRaw, "trailer"),
+		mode: modeRaw === undefined ? "edit" : parseMode(modeRaw),
 	};
 }

package/src/tui/complete.ts

@@ -0,0 +1,102 @@
+// Tab completion for typed `/clm …` lines in the TUI prompt. OpenCode has no argument
+// completion for commands (its slash menu closes at the first space), so the TUI plugin
+// completes inline: Tab extends the line to the longest common prefix of the matching items
+// and lists them when several remain. Items follow pi-clm's `getArgumentCompletions`
+// (pi src/index.ts:961-980) plus `budget` and setting values. Written for this package.
+
+import { PAGES } from "../panel/command.ts";
+import { SETTING_NAMES, settingDescriptor } from "../settings-table.ts";
+import type { FocusedPrompt, InterceptContext } from "./intercept.ts";
+
+const PREFIX = "/clm ";
+
+/** pi's word list: pages, status, config, `config <setting>`, config reset, on, off, reset, path; plus budget. */
+export const CLM_COMPLETIONS: readonly string[] = [
+	...PAGES,
+	"status",
+	"config",
+	...SETTING_NAMES.map((name) => `config ${name}`),
+	"config reset",
+	"on",
+	"off",
+	"reset",
+	"path",
+	"budget",
+];
+
+/** Items for the text after `/clm `: subcommands, or a setting's choices after `config <setting> `. */
+export function clmCompletions(args: string): string[] {
+	const lower = args.toLowerCase();
+	const value = /^config\s+(\S+)\s+(.*)$/i.exec(args);
+	if (value) {
+		const choices = settingDescriptor(value[1]!)?.choices ?? [];
+		return choices
+			.filter((choice) => choice.toLowerCase().startsWith(value[2]!.toLowerCase()))
+			.map((choice) => `config ${value[1]} ${choice}`);
+	}
+	return CLM_COMPLETIONS.filter((item) => item.startsWith(lower));
+}
+
+function commonPrefix(items: readonly string[]): string {
+	let prefix = items[0] ?? "";
+	for (const item of items) {
+		while (!item.startsWith(prefix)) prefix = prefix.slice(0, -1);
+	}
+	return prefix;
+}
+
+export interface Completion {
+	/** The new prompt text; the same text when no item extends it. */
+	text: string;
+	/** Items still matching; more than one when the line stays ambiguous. */
+	items: string[];
+}
+
+/** `undefined` unless `text` is `/clm ` followed by something an item completes. */
+export function completeClmLine(text: string): Completion | undefined {
+	if (!text.startsWith(PREFIX)) return undefined;
+	const args = text.slice(PREFIX.length).replace(/^\s+/, "");
+	const items = clmCompletions(args);
+	if (items.length === 0) return undefined;
+	if (items.length === 1) return { text: `${PREFIX}${items[0]} `, items };
+	const common = commonPrefix(items);
+	return { text: common.length > args.length ? `${PREFIX}${common}` : text, items };
+}
+
+export interface TabDeps {
+	focused(): (FocusedPrompt & { cursorOffset?: unknown }) | null | undefined;
+	/** False when `/clm` is not this package's (as for Enter). */
+	owned(): boolean;
+	/** Shows the remaining items when Tab cannot extend the line. */
+	show(items: readonly string[]): void;
+}
+
+/**
+ * Called for every key. Consumes Tab (no modifiers) on a `/clm …` line with the cursor at the
+ * end when an item matches; everything else, `/clm` without a space (OpenCode's own slash
+ * menu completes that) and lines with no match included, passes through to the host's Tab.
+ * Returns the completion applied, for tests.
+ */
+export function interceptTab(context: InterceptContext, deps: TabDeps): Completion | undefined {
+	const event = context.event;
+	if (event.name !== "tab" || event.shift || event.ctrl || event.meta) return undefined;
+	const focused = deps.focused();
+	if (!focused || typeof focused.plainText !== "string" || typeof focused.setText !== "function") return undefined;
+	const text = focused.plainText;
+	if (typeof focused.cursorOffset === "number" && focused.cursorOffset !== text.length) return undefined;
+	const completion = completeClmLine(text);
+	if (!completion) return undefined;
+	try {
+		if (!deps.owned()) return undefined;
+	} catch {
+		return undefined;
+	}
+	context.consume();
+	if (completion.text !== text) {
+		focused.setText(completion.text);
+		if (typeof focused.cursorOffset === "number") focused.cursorOffset = completion.text.length;
+	} else {
+		deps.show(completion.items);
+	}
+	return completion;
+}