@vincemakes/kiso-code 0.1.21 → 0.1.23

package/dist/chat.d.ts

@@ -21,10 +21,10 @@ export interface AutoCompact {
 /** Parse KISO_AUTO_COMPACT — an invalid value is OFF, never a crash. */
 export declare function autoCompactFromEnv(): AutoCompact | undefined;
 /**
- * C 区: the model window in tokens — KISO_CONTEXT_WINDOW overrides the
- * 200k default. The microcompact threshold is derived from it (50%), and
- * the status line's ~ctx estimate is measured against it — one source of
- * truth for the window.
+ * C 区: the model window in tokens — env (KISO_CONTEXT_WINDOW) beats the
+ * config window (合并轮 B), both beat the 200k default. The microcompact
+ * threshold is derived from it (50%), and the status line's ~ctx estimate
+ * is measured against it — one source of truth for the window.
  */
 export declare function contextWindowTokens(): number;
 /**

package/dist/chat.js

@@ -9,7 +9,7 @@ import { escapeTerminal, kUnit, palette, renderEvent, renderRecap } from "@vince
 import { editFileDiff, writeFileDiff } from "@vincemakes/kiso-tui";
 import { canonicalTargetPath } from "@vincemakes/kiso-tools-node";
 import { dispatch } from "./dispatch.js";
-import { CANCELLED, agentModel, body, bodyLog, dock } from "./state.js";
+import { CANCELLED, agentModel, body, bodyLog, configuredWindow, dock } from "./state.js";
 import { ask, pendingAsk, resolveUncertains } from "./trust-ui.js";
 import { FauxExhaustionError, failOnFauxExhaustion } from "./faux-glue.js";
 import { MODES, getMode, setMode } from "./mode.js";
@@ -26,12 +26,15 @@ export function autoCompactFromEnv() {
     return { thresholdRatio: ratio };
 }
 /**
- * C 区: the model window in tokens — KISO_CONTEXT_WINDOW overrides the
- * 200k default. The microcompact threshold is derived from it (50%), and
- * the status line's ~ctx estimate is measured against it — one source of
- * truth for the window.
+ * C 区: the model window in tokens — env (KISO_CONTEXT_WINDOW) beats the
+ * config window (合并轮 B), both beat the 200k default. The microcompact
+ * threshold is derived from it (50%), and the status line's ~ctx estimate
+ * is measured against it — one source of truth for the window.
  */
 export function contextWindowTokens() {
+    const windowOverride = configuredWindow;
+    if (windowOverride !== undefined)
+        return windowOverride;
     const window = Number.parseInt(process.env.KISO_CONTEXT_WINDOW ?? "", 10);
     return Number.isFinite(window) && window > 0 ? window : DEFAULT_CONTEXT_WINDOW;
 }
@@ -303,7 +306,7 @@ export async function chat(session, faux, input, autoCompact) {
                 // 手感批 C8: the opt-in auto-compact — checked AFTER the
                 // turn ended (the run's terminal is in the log, the ratio
                 // is post-run).
-                maybeAutoCompact();
+                await maybeAutoCompact();
                 resolve();
             }
             catch (err) {
@@ -419,15 +422,19 @@ export async function chat(session, faux, input, autoCompact) {
     // 手感批 C8: the auto-compact check — the /compact FULL path via the
     // shared dispatch (same notices, same chain ordering, same mid-run
     // refusal — the isRunning guard here only avoids the refusal's noise).
+    // The appended segment is NOT awaited here on purpose: from inside a
+    // chain segment, awaiting the append would be circular (the segment
+    // chains after THIS segment's promise). The exit path re-awaits the
+    // chain once more after the turn — see the final awaits in chat().
     const maybeAutoCompact = () => {
         if (autoCompact === undefined)
             return;
         if (currentRun !== null)
             return; // dispatch would refuse — skip the noise
         const ratio = estimateCtxRatio(session);
-        if (Number.isFinite(ratio) && ratio >= autoCompact.thresholdRatio) {
-            dispatch("/compact", dispatchCtx);
-        }
+        if (!Number.isFinite(ratio) || ratio < autoCompact.thresholdRatio)
+            return;
+        dispatch("/compact", dispatchCtx);
     };
     input.onLine((line) => {
         if (!replReady) {
@@ -449,7 +456,7 @@ export async function chat(session, faux, input, autoCompact) {
         const last = await consumeRun(session, recoveryRun, input, turnNo, faux, liveInput, statusCb);
         currentRun = null;
         failOnFauxExhaustion(last, faux, input);
-        maybeAutoCompact(); // 手感批 C8: the recovery run ended too — same check
+        maybeAutoCompact(); // 手感批 C8: the recovery run ended too — same check (awaited by the exit re-await)
     }
     if (cancelled) {
         input.close();
@@ -470,4 +477,10 @@ export async function chat(session, faux, input, autoCompact) {
     input.prompt();
     await input.closed;
     await chainRef.current; // never exit while a turn is in flight
+    // 手感批 C8: the auto-compact may have appended ITS segment inside the
+    // turn (the check runs at the turn's end, after the exit-await above
+    // already captured the chain) — re-await once so the summarize either
+    // runs before the exit or the chain is already settled. One level is
+    // enough: the /compact segment appends nothing of its own.
+    await chainRef.current;
 }

package/dist/config.d.ts

@@ -0,0 +1,96 @@
+/**
+ * 合并轮 B — the config surface (schema v1).
+ *
+ * Two files: the user config `~/.kiso/config.json` and the project config
+ * `<cwd>/.kiso/config.json` (an artifact of the E3 trust package — a
+ * trusted project's config applies, an untrusted one is never even read).
+ * Precedence: flags > env > project config > user config > defaults.
+ *
+ * Schema v1:
+ *   model?: string   — a profile NAME (models.<name>) or "provider/model"
+ *                      direct write (provider: "openai-compat" | "anthropic")
+ *   models?: { [name]: { kind: "openai-compat"|"anthropic",
+ *                        baseUrl?: string, model: string, apiKeyEnv: string } }
+ *   mode?: "manual"|"default"|"accept-edits"|"plan"|"bypass"
+ *   contextWindow?: number      — tokens
+ *   autoCompact?: { thresholdRatio: number }   — 0<r<1; default off
+ *   projectTrust?: "ask" | "never"             — no "always" (the ruling)
+ *
+ * Credential discipline (HARD): a config NEVER stores a key — only the
+ * apiKeyEnv NAME it reads from the environment at use time. A profile
+ * whose apiKeyEnv is unset is UNAVAILABLE (listed as such; switching to
+ * it is refused loudly) — never a crash.
+ *
+ * Failure discipline: a broken JSON file fails LOUDLY (file + reason,
+ * non-zero exit) — a silently ignored config would mislead. A known key
+ * with an invalid value is likewise loud; unknown top-level keys are
+ * ignored (forward compatibility).
+ */
+import type { Mode } from "./mode.js";
+export type ProfileKind = "openai-compat" | "anthropic";
+export interface ModelProfile {
+    readonly kind: ProfileKind;
+    readonly baseUrl?: string;
+    readonly model: string;
+    /** The env var NAME holding the key — never the key itself. */
+    readonly apiKeyEnv: string;
+}
+export interface AutoCompactConfig {
+    readonly thresholdRatio: number;
+}
+export interface KisoConfig {
+    readonly model?: string;
+    readonly models?: Readonly<Record<string, ModelProfile>>;
+    readonly mode?: Mode;
+    readonly contextWindow?: number;
+    readonly autoCompact?: AutoCompactConfig;
+    readonly projectTrust?: "ask" | "never";
+}
+/** The resolved, merged config — project wins over user, both validated. */
+export interface ResolvedConfig {
+    readonly user: KisoConfig;
+    readonly project: KisoConfig;
+}
+export declare class ConfigError extends Error {
+}
+/** Parse + validate one config file. Broken JSON / invalid known values →
+ *  ConfigError with the file path (LOUD). Unknown keys pass (forward compat). */
+export declare function parseConfig(text: string, source: string): KisoConfig;
+/** The user config — never gated (the user's own file). */
+export declare function loadUserConfig(): KisoConfig | null;
+/** The project config — read ONLY when the project's .kiso passed the E3
+ *  trust gate (an untrusted project's config is never even read). */
+export declare function loadProjectConfig(cwd: string, trusted: boolean): KisoConfig | null;
+/** Merge: project wins over user (each layer's own keys only). */
+export declare function mergeConfigs(user: KisoConfig | null, project: KisoConfig | null): KisoConfig;
+/** A profile is available when its apiKeyEnv var is set (the key exists). */
+export declare function profileAvailable(p: ModelProfile): boolean;
+/** The resolved runtime model — what the adapter is built from. */
+export interface ResolvedModel {
+    readonly name: string;
+    readonly profile: ModelProfile;
+    readonly apiKey: string;
+}
+/** "provider/model" direct write → a profile. */
+export declare function directWriteProfile(value: string): ModelProfile | null;
+/**
+ * Resolve the model — precedence: --model flag > env (the OPENAI_* /
+ * ANTHROPIC_* key vars) > project config > user config > default (faux).
+ * The flag names a profile or writes provider/model directly. A named
+ * profile that does not exist is a LOUD ConfigError; an unavailable one
+ * (env key missing) is refused with the reason — never a silent fallback.
+ * Returns null when nothing resolves (faux mode).
+ */
+export declare function resolveModel(modelFlag: string | undefined, merged: KisoConfig): ResolvedModel | null;
+/** Mode: env (KISO_MODE) beats config.mode; the --mode flag is applied by
+ *  main before this runs (flags are the top of the chain). */
+export declare function resolveModeFromConfig(merged: KisoConfig): Mode | undefined;
+/** Context window: env (KISO_CONTEXT_WINDOW) > config.contextWindow >
+ *  default (200k — the caller's default). */
+export declare function resolveContextWindow(merged: KisoConfig): number | undefined;
+/** Auto-compact: env (KISO_AUTO_COMPACT) > config.autoCompact > off. An
+ *  invalid env value is OFF (it set the env → it wins, and it is invalid). */
+export declare function resolveAutoCompact(merged: KisoConfig): AutoCompactConfig | undefined;
+/** Project-trust policy: config.projectTrust (project wins over user) —
+ *  "ask" (the E3 gate, default) or "never" (the gate auto-refuses). */
+export declare function resolveProjectTrustPolicy(merged: KisoConfig): "ask" | "never";

package/dist/config.js

@@ -0,0 +1,263 @@
+/**
+ * 合并轮 B — the config surface (schema v1).
+ *
+ * Two files: the user config `~/.kiso/config.json` and the project config
+ * `<cwd>/.kiso/config.json` (an artifact of the E3 trust package — a
+ * trusted project's config applies, an untrusted one is never even read).
+ * Precedence: flags > env > project config > user config > defaults.
+ *
+ * Schema v1:
+ *   model?: string   — a profile NAME (models.<name>) or "provider/model"
+ *                      direct write (provider: "openai-compat" | "anthropic")
+ *   models?: { [name]: { kind: "openai-compat"|"anthropic",
+ *                        baseUrl?: string, model: string, apiKeyEnv: string } }
+ *   mode?: "manual"|"default"|"accept-edits"|"plan"|"bypass"
+ *   contextWindow?: number      — tokens
+ *   autoCompact?: { thresholdRatio: number }   — 0<r<1; default off
+ *   projectTrust?: "ask" | "never"             — no "always" (the ruling)
+ *
+ * Credential discipline (HARD): a config NEVER stores a key — only the
+ * apiKeyEnv NAME it reads from the environment at use time. A profile
+ * whose apiKeyEnv is unset is UNAVAILABLE (listed as such; switching to
+ * it is refused loudly) — never a crash.
+ *
+ * Failure discipline: a broken JSON file fails LOUDLY (file + reason,
+ * non-zero exit) — a silently ignored config would mislead. A known key
+ * with an invalid value is likewise loud; unknown top-level keys are
+ * ignored (forward compatibility).
+ */
+import { readFileSync } from "node:fs";
+import { join } from "node:path";
+import { kisoHome } from "./state.js";
+const KINDS = ["openai-compat", "anthropic"];
+const MODES_LIST = ["manual", "default", "accept-edits", "plan", "bypass"];
+export class ConfigError extends Error {
+}
+/** Parse + validate one config file. Broken JSON / invalid known values →
+ *  ConfigError with the file path (LOUD). Unknown keys pass (forward compat). */
+export function parseConfig(text, source) {
+    let raw;
+    try {
+        raw = JSON.parse(text);
+    }
+    catch (err) {
+        throw new ConfigError(`config ${source}: broken JSON — ${err instanceof Error ? err.message : String(err)}`);
+    }
+    if (raw === null || typeof raw !== "object" || Array.isArray(raw)) {
+        throw new ConfigError(`config ${source}: the root must be a JSON object`);
+    }
+    const out = {};
+    const obj = raw;
+    const fail = (key, why) => {
+        throw new ConfigError(`config ${source}: ${key} — ${why}`);
+    };
+    if (obj.model !== undefined) {
+        if (typeof obj.model !== "string" || obj.model === "")
+            fail("model", "expected a profile name or provider/model string");
+        out.model = obj.model;
+    }
+    if (obj.models !== undefined) {
+        if (obj.models === null || typeof obj.models !== "object" || Array.isArray(obj.models))
+            fail("models", "expected an object of profiles");
+        const models = {};
+        for (const [name, v] of Object.entries(obj.models)) {
+            if (v === null || typeof v !== "object" || Array.isArray(v))
+                fail(`models.${name}`, "expected a profile object");
+            const p = v;
+            if (typeof p.kind !== "string" || !KINDS.includes(p.kind))
+                fail(`models.${name}.kind`, `expected one of ${KINDS.join(", ")}`);
+            if (typeof p.model !== "string" || p.model === "")
+                fail(`models.${name}.model`, "expected a model string");
+            if (typeof p.apiKeyEnv !== "string" || p.apiKeyEnv === "")
+                fail(`models.${name}.apiKeyEnv`, "expected an env var name (the config never stores keys)");
+            if (p.baseUrl !== undefined && typeof p.baseUrl !== "string")
+                fail(`models.${name}.baseUrl`, "expected a string");
+            models[name] = {
+                kind: p.kind,
+                model: p.model,
+                apiKeyEnv: p.apiKeyEnv,
+                ...(typeof p.baseUrl === "string" ? { baseUrl: p.baseUrl } : {}),
+            };
+        }
+        out.models = models;
+    }
+    if (obj.mode !== undefined) {
+        if (typeof obj.mode !== "string" || !MODES_LIST.includes(obj.mode))
+            fail("mode", `expected one of ${MODES_LIST.join(", ")}`);
+        out.mode = obj.mode;
+    }
+    if (obj.contextWindow !== undefined) {
+        if (typeof obj.contextWindow !== "number" || !Number.isFinite(obj.contextWindow) || obj.contextWindow <= 0) {
+            fail("contextWindow", "expected a positive token count");
+        }
+        out.contextWindow = obj.contextWindow;
+    }
+    if (obj.autoCompact !== undefined) {
+        if (obj.autoCompact === null || typeof obj.autoCompact !== "object" || Array.isArray(obj.autoCompact))
+            fail("autoCompact", "expected { thresholdRatio }");
+        const r = obj.autoCompact.thresholdRatio;
+        if (typeof r !== "number" || !Number.isFinite(r) || r <= 0 || r >= 1)
+            fail("autoCompact.thresholdRatio", "expected a number strictly between 0 and 1");
+        out.autoCompact = { thresholdRatio: r };
+    }
+    if (obj.projectTrust !== undefined) {
+        if (obj.projectTrust !== "ask" && obj.projectTrust !== "never")
+            fail("projectTrust", 'expected "ask" or "never" (there is deliberately no "always")');
+        out.projectTrust = obj.projectTrust;
+    }
+    return out;
+}
+function readConfigFile(path, source) {
+    let text;
+    try {
+        text = readFileSync(path, "utf8");
+    }
+    catch (err) {
+        if (err.code === "ENOENT")
+            return null;
+        throw err;
+    }
+    return parseConfig(text, source);
+}
+/** The user config — never gated (the user's own file). */
+export function loadUserConfig() {
+    return readConfigFile(join(kisoHome(), "config.json"), "~/.kiso/config.json");
+}
+/** The project config — read ONLY when the project's .kiso passed the E3
+ *  trust gate (an untrusted project's config is never even read). */
+export function loadProjectConfig(cwd, trusted) {
+    if (!trusted)
+        return null;
+    return readConfigFile(join(cwd, ".kiso", "config.json"), "<cwd>/.kiso/config.json");
+}
+/** Merge: project wins over user (each layer's own keys only). */
+export function mergeConfigs(user, project) {
+    const u = user ?? {};
+    const p = project ?? {};
+    return {
+        ...(u.model !== undefined ? { model: u.model } : {}),
+        ...(p.model !== undefined ? { model: p.model } : {}),
+        ...(u.models !== undefined ? { models: u.models } : {}),
+        ...(p.models !== undefined ? { models: { ...u.models, ...p.models } } : u.models !== undefined ? { models: u.models } : {}),
+        ...(u.mode !== undefined ? { mode: u.mode } : {}),
+        ...(p.mode !== undefined ? { mode: p.mode } : {}),
+        ...(u.contextWindow !== undefined ? { contextWindow: u.contextWindow } : {}),
+        ...(p.contextWindow !== undefined ? { contextWindow: p.contextWindow } : {}),
+        ...(u.autoCompact !== undefined ? { autoCompact: u.autoCompact } : {}),
+        ...(p.autoCompact !== undefined ? { autoCompact: p.autoCompact } : {}),
+        ...(u.projectTrust !== undefined ? { projectTrust: u.projectTrust } : {}),
+        ...(p.projectTrust !== undefined ? { projectTrust: p.projectTrust } : {}),
+    };
+}
+/** A profile is available when its apiKeyEnv var is set (the key exists). */
+export function profileAvailable(p) {
+    return process.env[p.apiKeyEnv] !== undefined;
+}
+/** "provider/model" direct write → a profile. */
+export function directWriteProfile(value) {
+    const slash = value.indexOf("/");
+    if (slash <= 0 || slash === value.length - 1)
+        return null;
+    const kind = value.slice(0, slash);
+    if (kind !== "openai-compat" && kind !== "anthropic")
+        return null;
+    return {
+        kind,
+        model: value.slice(slash + 1),
+        apiKeyEnv: kind === "anthropic" ? "ANTHROPIC_API_KEY" : "OPENAI_API_KEY",
+    };
+}
+/**
+ * Resolve the model — precedence: --model flag > env (the OPENAI_* /
+ * ANTHROPIC_* key vars) > project config > user config > default (faux).
+ * The flag names a profile or writes provider/model directly. A named
+ * profile that does not exist is a LOUD ConfigError; an unavailable one
+ * (env key missing) is refused with the reason — never a silent fallback.
+ * Returns null when nothing resolves (faux mode).
+ */
+export function resolveModel(modelFlag, merged) {
+    if (modelFlag !== undefined) {
+        const direct = directWriteProfile(modelFlag);
+        if (direct !== null)
+            return resolveProfile(modelFlag, direct);
+        const p = merged.models?.[modelFlag];
+        if (p === undefined)
+            throw new ConfigError(`unknown model profile: ${modelFlag} (see models in ~/.kiso/config.json)`);
+        return resolveProfile(modelFlag, p);
+    }
+    // env beats config: a key in the environment names the provider.
+    if (process.env.OPENAI_API_KEY !== undefined) {
+        return {
+            name: process.env.OPENAI_MODEL ?? "gpt-4o",
+            profile: {
+                kind: "openai-compat",
+                model: process.env.OPENAI_MODEL ?? "gpt-4o",
+                ...(process.env.OPENAI_BASE_URL !== undefined ? { baseUrl: process.env.OPENAI_BASE_URL } : {}),
+                apiKeyEnv: "OPENAI_API_KEY",
+            },
+            apiKey: process.env.OPENAI_API_KEY,
+        };
+    }
+    if (process.env.ANTHROPIC_API_KEY !== undefined) {
+        return {
+            name: process.env.ANTHROPIC_MODEL ?? "claude-sonnet-5",
+            profile: {
+                kind: "anthropic",
+                model: process.env.ANTHROPIC_MODEL ?? "claude-sonnet-5",
+                apiKeyEnv: "ANTHROPIC_API_KEY",
+            },
+            apiKey: process.env.ANTHROPIC_API_KEY,
+        };
+    }
+    // config (project wins over user) names a model; default is faux.
+    const configured = merged.model;
+    if (configured !== undefined) {
+        const direct = directWriteProfile(configured);
+        if (direct !== null)
+            return resolveProfile(configured, direct);
+        const p = merged.models?.[configured];
+        if (p === undefined)
+            throw new ConfigError(`config model "${configured}" is not a defined profile (see models in ~/.kiso/config.json)`);
+        return resolveProfile(configured, p);
+    }
+    return null;
+}
+function resolveProfile(name, p) {
+    if (!profileAvailable(p)) {
+        throw new ConfigError(`model ${name}: unavailable — the env var ${p.apiKeyEnv} is not set (configs never store keys, only the env-var name)`);
+    }
+    return { name, profile: p, apiKey: process.env[p.apiKeyEnv] };
+}
+/** Mode: env (KISO_MODE) beats config.mode; the --mode flag is applied by
+ *  main before this runs (flags are the top of the chain). */
+export function resolveModeFromConfig(merged) {
+    const fromEnv = process.env.KISO_MODE;
+    if (fromEnv !== undefined)
+        return fromEnv;
+    return merged.mode;
+}
+/** Context window: env (KISO_CONTEXT_WINDOW) > config.contextWindow >
+ *  default (200k — the caller's default). */
+export function resolveContextWindow(merged) {
+    const fromEnv = Number.parseInt(process.env.KISO_CONTEXT_WINDOW ?? "", 10);
+    if (Number.isFinite(fromEnv) && fromEnv > 0)
+        return fromEnv;
+    return merged.contextWindow;
+}
+/** Auto-compact: env (KISO_AUTO_COMPACT) > config.autoCompact > off. An
+ *  invalid env value is OFF (it set the env → it wins, and it is invalid). */
+export function resolveAutoCompact(merged) {
+    const raw = process.env.KISO_AUTO_COMPACT;
+    if (raw !== undefined) {
+        const ratio = Number.parseFloat(raw);
+        if (!Number.isFinite(ratio) || ratio <= 0 || ratio >= 1)
+            return undefined;
+        return { thresholdRatio: ratio };
+    }
+    return merged.autoCompact;
+}
+/** Project-trust policy: config.projectTrust (project wins over user) —
+ *  "ask" (the E3 gate, default) or "never" (the gate auto-refuses). */
+export function resolveProjectTrustPolicy(merged) {
+    return merged.projectTrust ?? "ask";
+}

package/dist/dispatch.d.ts

@@ -3,7 +3,7 @@
  * turns. The bodies moved verbatim from chat()'s closure; chat provides
  * the context (the chain, the run state, the prompt arming).
  */
-import type { AgentSession } from "@vincemakes/kiso-runtime";
+import { type AgentSession } from "@vincemakes/kiso-runtime";
 import { type LineInput } from "./state.js";
 /** Everything dispatch touches that chat() owns. */
 export interface DispatchCtx {

package/dist/dispatch.js

@@ -4,8 +4,10 @@
  * the context (the chain, the run state, the prompt arming).
  */
 import { escapeTerminal, palette } from "@vincemakes/kiso-tui";
+import { buildAdapter } from "@vincemakes/kiso-runtime";
 import { MODES, getMode, setMode } from "./mode.js";
-import { body, bodyLog } from "./state.js";
+import { agentModel, body, bodyLog, configModels, setAgentModel, setCurrentModelName } from "./state.js";
+import { directWriteProfile, profileAvailable } from "./config.js";
 /** The ONE dispatcher — slash commands, exit, and turns. The recovery
  *  replay routes through it too — a queued "/last" must never become a
  *  user turn (v2c: the rl lives in main, so lines arrive earlier and the
@@ -23,6 +25,7 @@ export function dispatch(line, ctx) {
             bodyLog(cmd("/last", "show the most recent tool call's input and output"));
             bodyLog(cmd("/status", "show session id, event count, and context estimate"));
             bodyLog(cmd("/mode", "show the approval tier; /mode <name> switches (manual/default/accept-edits/plan/bypass)"));
+            bodyLog(cmd("/model", "list model profiles; /model <name|provider/model> switches"));
             bodyLog(cmd("/compact", "summarize the older conversation to free context"));
             bodyLog(cmd("exit", "leave the session"));
             ctx.input.prompt();
@@ -100,6 +103,57 @@ export function dispatch(line, ctx) {
         });
         return;
     }
+    if (trimmed === "/model" || trimmed.startsWith("/model ")) {
+        // 合并轮 B: /model lists the profiles (with availability — the
+        // config never stores keys, only apiKeyEnv NAMES; an unset env
+        // marks the profile unavailable, never a crash) and switches the
+        // session's adapter — the NEXT turn uses it (session.setAdapter),
+        // the notice cell leaves the audit line in the body.
+        ctx.chainRef.current = ctx.chainRef.current.then(async () => {
+            const arg = trimmed.slice(6).trim();
+            if (arg === "") {
+                bodyLog(`model: ${agentModel}`);
+                const names = Object.keys(configModels);
+                if (names.length === 0) {
+                    bodyLog("profiles: (none — define models in ~/.kiso/config.json)");
+                }
+                else {
+                    for (const name of names) {
+                        const p = configModels[name];
+                        bodyLog(`  ${name} → ${p.kind}/${p.model} · ${p.apiKeyEnv} ${profileAvailable(p) ? "(available)" : "(unavailable)"}`);
+                    }
+                }
+                bodyLog("switch with /model <profile-name|provider/model>");
+            }
+            else {
+                try {
+                    const direct = directWriteProfile(arg);
+                    const profile = direct ?? configModels[arg];
+                    if (profile === undefined) {
+                        bodyLog(`no such model profile: ${arg}`);
+                    }
+                    else if (!profileAvailable(profile)) {
+                        bodyLog(`model ${arg}: unavailable — the env var ${profile.apiKeyEnv} is not set (configs never store keys, only the env-var name)`);
+                    }
+                    else {
+                        const adapter = await buildAdapter(profile.kind, {
+                            apiKey: process.env[profile.apiKeyEnv],
+                            ...(profile.baseUrl !== undefined ? { baseUrl: profile.baseUrl } : {}),
+                        });
+                        ctx.session.setAdapter(adapter);
+                        setAgentModel(profile.model);
+                        setCurrentModelName(arg);
+                        body.notice(`model → ${arg} (${profile.model}) — takes effect on the next turn`);
+                    }
+                }
+                catch (err) {
+                    body.notice(`[/model] failed: ${err instanceof Error ? err.message : String(err)}`);
+                }
+            }
+            ctx.input.prompt();
+        });
+        return;
+    }
     if (trimmed === "/compact") {
         // /compact (ADR-0044): the older conversation becomes one
         // model summary — an OFF-LOOP call through the session's own

package/dist/index.js

@@ -31,10 +31,11 @@ import { createAgent, disposeExtensions, loadExtensions, loadProjectExtensions,
 import { createFauxProvider } from "@vincemakes/kiso-evals";
 import { createCodingTools } from "@vincemakes/kiso-tools-node";
 import { MODES, modeExtensions, modeFromEnv, modeSystemPrompt, setMode } from "./mode.js";
-import { body, bodyLog, dock, extensionsDir, loadedExtensions, mergedTempPaths, projectExtensions, sessionsDir, setAgentModel, setBody, setExtensionLists, userExtensions, VERSION } from "./state.js";
+import { body, bodyLog, currentFaux, dock, extensionsDir, loadedExtensions, mergedConfig, mergedTempPaths, projectExtensions, sessionsDir, setAgentModel, setBody, setConfigModels, setConfiguredWindow, setCurrentFaux, setCurrentModelName, setExtensionLists, setMergedConfig, userExtensions, VERSION } from "./state.js";
 import { interactivePrompt, resolveProjectTrust } from "./trust-ui.js";
 import { fauxSkip, readFauxScript } from "./faux-glue.js";
 import { autoCompactFromEnv, chat, contextWindowTokens } from "./chat.js";
+import { loadProjectConfig, loadUserConfig, mergeConfigs, resolveAutoCompact, resolveContextWindow, resolveModel } from "./config.js";
 import { resume } from "./resume.js";
 // The moved exports stay reachable from this entry — the test imports
 // (project-trust, coding-agent) never change (B4: 断言零改动).
@@ -250,7 +251,7 @@ export function composeSystemPrompt(cwd) {
     const injected = readProjectInstructions(cwd);
     return injected === "" ? SYSTEM_PROMPT : `${SYSTEM_PROMPT}\n${injected}`;
 }
-async function makeAgent(fauxSkipTurns = 0, input) {
+async function makeAgent(fauxSkipTurns = 0, input, modelFlag) {
     const store = new SessionStore(sessionsDir());
     // E3: the project-level trust gate runs BEFORE any extension load (the
     // mcp/skills merges must be in the env when the user-level extensions
@@ -266,24 +267,27 @@ async function makeAgent(fauxSkipTurns = 0, input) {
     else {
         setExtensionLists(user, [], user);
     }
-    // Provider wiring (F 组): the CLI never imports provider SDKs directly —
-    // the runtime's lazy provider resolution owns them. Real key → real
-    // provider; none → faux.
-    const anthropicKey = process.env.ANTHROPIC_API_KEY;
-    const openaiKey = process.env.OPENAI_API_KEY;
-    let provider;
-    let model;
-    if (anthropicKey) {
-        provider = "anthropic";
-        model = process.env.ANTHROPIC_MODEL ?? "claude-sonnet-5";
-    }
-    else if (openaiKey) {
-        provider = "openai-compat";
-        model = process.env.OPENAI_MODEL ?? "gpt-4o";
+    // 合并轮 B — the config surface: user config + (trusted) project config,
+    // resolved with flags > env > project > user > default. The CLI never
+    // imports provider SDKs directly — the runtime's lazy provider
+    // resolution owns them (a config profile only ever NAMES an env var for
+    // its key; the key itself never sits in a config file).
+    const userCfg = loadUserConfig();
+    const projectCfg = loadProjectConfig(process.cwd(), project !== null);
+    const merged = mergeConfigs(userCfg, projectCfg);
+    setMergedConfig(merged);
+    setConfigModels(merged.models ?? {});
+    setConfiguredWindow(resolveContextWindow(merged));
+    const resolved = resolveModel(modelFlag, merged);
+    const model = resolved === null ? "faux" : resolved.profile.model;
+    if (resolved === null) {
+        console.log("[faux mode — set ANTHROPIC_API_KEY or OPENAI_API_KEY, or configure models in ~/.kiso/config.json]\n");
+        setCurrentFaux(true);
+        setCurrentModelName("faux");
     }
     else {
-        console.log("[faux mode — set ANTHROPIC_API_KEY or OPENAI_API_KEY for a real model]\n");
-        model = "faux";
+        setCurrentFaux(false);
+        setCurrentModelName(resolved.name);
     }
     setAgentModel(model); // v2b: the status bar shows it
     const definition = {
@@ -312,11 +316,11 @@ async function makeAgent(fauxSkipTurns = 0, input) {
         // project extensions (the deny>ask>allow composition keeps a user
         // deny winning over any mode tier — bypass included).
         extensions: [...modeExtensions(), ...loadedExtensions],
-        ...(provider !== undefined
+        ...(resolved !== null
             ? {
-                provider,
-                apiKey: (anthropicKey ?? openaiKey),
-                ...(process.env.OPENAI_BASE_URL !== undefined ? { baseUrl: process.env.OPENAI_BASE_URL } : {}),
+                provider: resolved.profile.kind,
+                apiKey: resolved.apiKey,
+                ...(resolved.profile.baseUrl !== undefined ? { baseUrl: resolved.profile.baseUrl } : {}),
             }
             : { adapter: createFauxProvider(readFauxScript().slice(fauxSkipTurns)) }),
     };
@@ -327,6 +331,21 @@ async function main() {
     // first makeAgent (the tier extensions read `current` live). The flag
     // is stripped from the positional args, so it works in any position.
     const args = process.argv.slice(2);
+    // 合并轮 B: --model <profile|provider/model> — the top of the model
+    // precedence chain; the value flows into makeAgent's config resolution.
+    let modelFlag;
+    const modelArgIdx = args.indexOf("--model");
+    if (modelArgIdx !== -1) {
+        modelFlag = args[modelArgIdx + 1];
+        if (modelFlag === undefined) {
+            console.error("usage: --model <profile-name|provider/model>");
+            process.exit(2);
+        }
+        args.splice(modelArgIdx, 2);
+    }
+    // Modes: --mode wins over KISO_MODE, which wins over the USER config's
+    // mode (the project config's mode applies later — after the trust gate,
+    // inside makeAgent — unless a higher layer already decided).
     const modeFlag = args.indexOf("--mode");
     if (modeFlag !== -1) {
         const m = MODES.find((x) => x === args[modeFlag + 1]);
@@ -338,12 +357,14 @@ async function main() {
         args.splice(modeFlag, 2);
     }
     else {
-        setMode(modeFromEnv());
+        setMode(modeFromEnv() ?? loadUserConfig()?.mode ?? "default");
     }
     const [command, arg] = args;
     // 八: faux mode is the keyless demo script — an exhausted script must
-    // exit non-zero, never masquerade as a successful provider run.
-    const faux = process.env.ANTHROPIC_API_KEY === undefined && process.env.OPENAI_API_KEY === undefined;
+    // exit non-zero, never masquerade as a successful provider run. The
+    // verdict comes from makeAgent's config resolution now (a config
+    // profile can provide a real model with no OPENAI_* env).
+    let faux = true;
     let agent;
     // v2c: ONE input source per process — the raw-mode editor on a TTY
     // (entered here, dock-bound, trusted before any extension loads),
@@ -360,6 +381,16 @@ async function main() {
         onDock: () => dock.redraw(), // v2d-B: the freeze scrolls the dock up — re-pin it
     }));
     try {
+        // 合并轮 B: the project config's mode applies AFTER the trust gate
+        // (its verdict decides whether the project config exists at all) —
+        // unless a higher layer (--mode flag / KISO_MODE) already decided.
+        const applyConfigMode = () => {
+            if (modeFlag !== -1 || process.env.KISO_MODE !== undefined)
+                return;
+            const m = mergedConfig.mode;
+            if (m !== undefined)
+                setMode(m);
+        };
         switch (command) {
             case "chat": {
                 const id = arg ?? new Date().toISOString().replace(/[:.]/g, "-").slice(0, 16);
@@ -368,11 +399,13 @@ async function main() {
                 dock.enter();
                 // E 区: a resumed session continues the script at its durable
                 // position — never restarts it (fauxSkip).
-                const agent = await makeAgent(fauxSkip(id), input);
+                const agent = await makeAgent(fauxSkip(id), input, modelFlag);
+                applyConfigMode();
                 const session = await agent.session({ id });
                 bodyLog(`session ${id}\n`);
                 extensionsBanner();
-                await chat(session, faux, input, autoCompactFromEnv());
+                faux = currentFaux;
+                await chat(session, faux, input, resolveAutoCompact(mergedConfig));
                 break;
             }
             case "resume": {
@@ -384,13 +417,15 @@ async function main() {
                 // (argv = [node, script, resume, id, prompt?]).
                 const prompt = process.argv[4];
                 dock.enter();
-                const agent = await makeAgent(fauxSkip(arg), input);
+                const agent = await makeAgent(fauxSkip(arg), input, modelFlag);
+                applyConfigMode();
                 const session = await agent.session({ id: arg });
+                faux = currentFaux;
                 await resume(session, prompt, faux, input);
                 break;
             }
             case "sessions": {
-                const agent = await makeAgent();
+                const agent = await makeAgent(0, undefined, modelFlag);
                 for (const meta of agent.sessions()) {
                     console.log(renderSessionLine(meta));
                 }

package/dist/mode.d.ts

@@ -14,9 +14,10 @@ export type Mode = "manual" | "default" | "accept-edits" | "plan" | "bypass";
 export declare const MODES: readonly Mode[];
 export declare function getMode(): Mode;
 export declare function setMode(m: Mode): void;
-/** The startup mode: KISO_MODE env (or the --mode flag — the CLI applies
- *  it before the first makeAgent). */
-export declare function modeFromEnv(): Mode;
+/** The startup mode from env: KISO_MODE, or undefined when unset (the
+ *  config layer's mode then applies — 合并轮 B; the --mode flag is
+ *  applied by main before the first makeAgent and wins over everything). */
+export declare function modeFromEnv(): Mode | undefined;
 /** The five built-in mode tiers as chain extensions — named "mode:<tier>"
  *  so the runtime's decidedBy records exactly that (the runtime derives
  *  approvalPolicies from extensions[].approvals, tagging each with the

package/dist/mode.js

@@ -20,12 +20,12 @@ export function getMode() {
 export function setMode(m) {
     current = m;
 }
-/** The startup mode: KISO_MODE env (or the --mode flag — the CLI applies
- *  it before the first makeAgent). */
+/** The startup mode from env: KISO_MODE, or undefined when unset (the
+ *  config layer's mode then applies — 合并轮 B; the --mode flag is
+ *  applied by main before the first makeAgent and wins over everything). */
 export function modeFromEnv() {
     const raw = process.env.KISO_MODE;
-    const m = MODES.find((x) => x === raw);
-    return m ?? "default";
+    return MODES.find((x) => x === raw);
 }
 /** The per-tier verdict for a tool call — only when this tier is current. */
 function tierVerdict(tier, call) {

package/dist/state.d.ts

@@ -52,6 +52,26 @@ export declare function bodyLog(text: string): void;
 /** The model name for the status bar — set by makeAgent. */
 export declare let agentModel: string;
 export declare function setAgentModel(value: string): void;
+/** 合并轮 B: whether the agent runs on the faux provider (no real key) —
+ *  set inside makeAgent, read by main for chat/resume's exhaustion check. */
+export declare let currentFaux: boolean;
+export declare function setCurrentFaux(value: boolean): void;
+/** 合并轮 B: the merged config (user + trusted project) as resolved by the
+ *  LAST makeAgent — /model and autoCompact resolve against it. */
+export declare let mergedConfig: import("./config.js").KisoConfig;
+export declare function setMergedConfig(value: import("./config.js").KisoConfig): void;
+/** 合并轮 B: the resolved context window (env > config.contextWindow) —
+ *  chat.ts's contextWindowTokens() consults it before the env. */
+export declare let configuredWindow: number | undefined;
+export declare function setConfiguredWindow(value: number | undefined): void;
+/** 合并轮 B: the merged config (user + trusted project) + the current
+ *  model's NAME — /model lists and switches against them. */
+export declare let configModels: Readonly<Record<string, import("./config.js").ModelProfile>>;
+export declare function setConfigModels(models: Readonly<Record<string, import("./config.js").ModelProfile>>): void;
+/** The name of the model currently driving the session ("faux" or the
+ *  profile name / provider/model write / env model). */
+export declare let currentModelName: string;
+export declare function setCurrentModelName(value: string): void;
 /** E1: the extensions loaded by makeAgent — their names feed the banner. */
 export declare let loadedExtensions: readonly KisoExtension[];
 /** E1: the USER-level extensions alone — the banner's unmarked part (E3:

package/dist/state.js

@@ -46,6 +46,36 @@ export let agentModel = "faux";
 export function setAgentModel(value) {
     agentModel = value;
 }
+/** 合并轮 B: whether the agent runs on the faux provider (no real key) —
+ *  set inside makeAgent, read by main for chat/resume's exhaustion check. */
+export let currentFaux = true;
+export function setCurrentFaux(value) {
+    currentFaux = value;
+}
+/** 合并轮 B: the merged config (user + trusted project) as resolved by the
+ *  LAST makeAgent — /model and autoCompact resolve against it. */
+export let mergedConfig = {};
+export function setMergedConfig(value) {
+    mergedConfig = value;
+}
+/** 合并轮 B: the resolved context window (env > config.contextWindow) —
+ *  chat.ts's contextWindowTokens() consults it before the env. */
+export let configuredWindow;
+export function setConfiguredWindow(value) {
+    configuredWindow = value;
+}
+/** 合并轮 B: the merged config (user + trusted project) + the current
+ *  model's NAME — /model lists and switches against them. */
+export let configModels = {};
+export function setConfigModels(models) {
+    configModels = models;
+}
+/** The name of the model currently driving the session ("faux" or the
+ *  profile name / provider/model write / env model). */
+export let currentModelName = "faux";
+export function setCurrentModelName(value) {
+    currentModelName = value;
+}
 /** E1: the extensions loaded by makeAgent — their names feed the banner. */
 export let loadedExtensions = [];
 /** E1: the USER-level extensions alone — the banner's unmarked part (E3:

package/dist/trust-ui.js

@@ -10,6 +10,7 @@ import { join } from "node:path";
 import { escapeTerminal, palette } from "@vincemakes/kiso-tui";
 import { projectArtifacts, recordTrust, trustFor } from "@vincemakes/kiso-runtime";
 import { CANCELLED, bodyLog, dock, kisoHome, mergedTempPaths } from "./state.js";
+import { loadUserConfig, resolveProjectTrustPolicy } from "./config.js";
 /** v2a: the interactive prompt — blue, the identity accent. readline owns
  *  the echo of what the user types; we own the prompt's color. (v2c: the
  *  readline prompt keeps "you> " — the brick ▌ is the dock's row only;
@@ -90,6 +91,12 @@ export async function resolveProjectTrust(input) {
     const artifacts = await projectArtifacts(process.cwd());
     if (artifacts === null)
         return null; // no .kiso artifacts — nothing to gate
+    // 合并轮 B: projectTrust "never" (user config) — the gate auto-refuses:
+    // no ask, no record, nothing loads. There is deliberately no "always".
+    if (resolveProjectTrustPolicy(loadUserConfig() ?? {}) === "never") {
+        bodyLog(`[project .kiso] projectTrust: never — ${artifacts.root} not loaded`);
+        return null;
+    }
     const record = trustFor(artifacts.root, artifacts.digest);
     if (record?.decision === "granted") {
         applyProjectMerges(artifacts);

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "@vincemakes/kiso-code",
-  "version": "0.1.21",
-  "description": "kiso CLI — the coding-agent reference product: kiso chat / kiso resume / kiso sessions.",
+  "version": "0.1.23",
+  "description": "kiso CLI \u2014 the coding-agent reference product: kiso chat / kiso resume / kiso sessions.",
   "type": "module",
   "license": "MIT",
   "bin": {
@@ -18,13 +18,13 @@
     "test": "vitest run"
   },
   "dependencies": {
-    "@vincemakes/kiso-core": "0.1.21",
-    "@vincemakes/kiso-evals": "0.1.21",
-    "@vincemakes/kiso-provider-anthropic": "0.1.21",
-    "@vincemakes/kiso-provider-openai": "0.1.21",
-    "@vincemakes/kiso-runtime": "0.1.21",
-    "@vincemakes/kiso-tools-node": "0.1.21",
-    "@vincemakes/kiso-tui": "0.1.21"
+    "@vincemakes/kiso-core": "0.1.23",
+    "@vincemakes/kiso-evals": "0.1.23",
+    "@vincemakes/kiso-provider-anthropic": "0.1.23",
+    "@vincemakes/kiso-provider-openai": "0.1.23",
+    "@vincemakes/kiso-runtime": "0.1.23",
+    "@vincemakes/kiso-tools-node": "0.1.23",
+    "@vincemakes/kiso-tui": "0.1.23"
   },
   "devDependencies": {
     "@types/node": "^26.1.2",