@vincemakes/kiso-code 0.29.0 → 0.31.0

package/dist/config.d.ts

@@ -8,8 +8,9 @@
  *
  * Schema v1:
  *   model?: string   — a profile NAME (models.<name>) or "provider/model"
- *                      direct write (provider: "openai-compat" | "anthropic")
- *   models?: { [name]: { kind: "openai-compat"|"anthropic",
+ *                      direct write (provider: "openai-compat" |
+ *                      "anthropic" | "openai-responses")
+ *   models?: { [name]: { kind: "openai-compat"|"anthropic"|"openai-responses",
  *                        baseUrl?: string, model: string, apiKeyEnv: string } }
  *   mode?: "manual"|"default"|"accept-edits"|"plan"|"bypass"
  *   contextWindow?: number      — tokens
@@ -27,7 +28,11 @@
  * ignored (forward compatibility).
  */
 import type { Mode } from "./mode.js";
-export type ProfileKind = "openai-compat" | "anthropic";
+/** OR-1: `openai-responses` is a DIALECT, not a vendor — the same kind
+ *  drives the first-party Responses API and the ChatGPT subscription
+ *  backend, and which one it is follows the profile's baseUrl (and so
+ *  the credential it resolves to). */
+export type ProfileKind = "openai-compat" | "anthropic" | "openai-responses";
 export interface ModelProfile {
     readonly kind: ProfileKind;
     readonly baseUrl?: string;
@@ -59,6 +64,11 @@ export interface KisoConfig {
      *  project file is a LOUD error rather than a silent win. `KISO_THEME`
      *  still outranks it — the environment is the more local answer. */
     readonly theme?: "dark" | "light";
+    /** DT-1a: named acceptance checks a delegated task may reference —
+     *  user-authored (or trust-gated project) commands, run by the PARENT
+     *  in the child's worktree. A model never supplies a command; it names
+     *  one of these. `{ "test": "npm test", "lint": "npm run lint" }`. */
+    readonly checks?: Readonly<Record<string, string>>;
 }
 /** The resolved, merged config — project wins over user, both validated. */
 export interface ResolvedConfig {
@@ -77,13 +87,44 @@ export declare function loadUserConfig(): KisoConfig | null;
 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). */
+/** What a profile's sign-in actually IS. The two shapes are not
+ *  interchangeable: an API key is a string an adapter holds, an OAuth
+ *  sign-in is a token that expires and must be re-resolved per request. */
+export type ProfileAuth = {
+    readonly type: "api-key";
+    readonly apiKey: string;
+    readonly source: "store" | "env" | "none";
+} | {
+    readonly type: "oauth";
+    readonly providerId: string;
+};
+/** Where a profile's sign-in comes from, or why it has none. The sign-in
+ *  plan's resolve rule: a stored credential OWNS the provider (an
+ *  unusable stored one is an error, never a silent fall back to env);
+ *  with nothing stored, the profile's env var applies; a keyless profile
+ *  (no apiKeyEnv — PH-1c, finding PH-F19) is an unauthenticated endpoint.
+ *
+ *  OR-1: a stored OAuth credential is USABLE only by an adapter that can
+ *  drive one, which today is the Responses adapter's ChatGPT target. For
+ *  every other kind it stays the same loud refusal it has always been —
+ *  the caller is told which sign-in it has and which one it needs. */
+export declare function authForProfile(name: string, p: ModelProfile): ProfileAuth;
+/** The reason a profile is unavailable, for the surfaces that print it. */
+export declare function unavailableReason(name: string, p: ModelProfile): string;
+/** A profile is available when a sign-in resolves for it — of EITHER
+ *  shape: an OAuth-only profile is available, and calling the key-only
+ *  resolver here would have declared it broken. */
 export declare function profileAvailable(p: ModelProfile): boolean;
-/** The resolved runtime model — what the adapter is built from. */
+/** The resolved runtime model — what the adapter is built from. Exactly
+ *  one of the two sign-in fields is set: an OAuth profile has no key to
+ *  hand over, and the caller must build the adapter from the token thunk
+ *  instead (the compiler enforces the branch — `apiKey` is optional). */
 export interface ResolvedModel {
     readonly name: string;
     readonly profile: ModelProfile;
-    readonly apiKey: string;
+    readonly apiKey?: string;
+    /** OR-1: the provider whose stored OAuth sign-in this profile uses. */
+    readonly oauthProviderId?: string;
 }
 /** "provider/model" direct write → a profile. */
 export declare function directWriteProfile(value: string): ModelProfile | null;

package/dist/config.js

@@ -8,8 +8,9 @@
  *
  * Schema v1:
  *   model?: string   — a profile NAME (models.<name>) or "provider/model"
- *                      direct write (provider: "openai-compat" | "anthropic")
- *   models?: { [name]: { kind: "openai-compat"|"anthropic",
+ *                      direct write (provider: "openai-compat" |
+ *                      "anthropic" | "openai-responses")
+ *   models?: { [name]: { kind: "openai-compat"|"anthropic"|"openai-responses",
  *                        baseUrl?: string, model: string, apiKeyEnv: string } }
  *   mode?: "manual"|"default"|"accept-edits"|"plan"|"bypass"
  *   contextWindow?: number      — tokens
@@ -29,7 +30,8 @@
 import { readFileSync } from "node:fs";
 import { join } from "node:path";
 import { kisoHome } from "./state.js";
-const KINDS = ["openai-compat", "anthropic"];
+import { AuthError, getCredential, providerIdOf } from "./auth/credentials.js";
+const KINDS = ["openai-compat", "anthropic", "openai-responses"];
 const MODES_LIST = ["manual", "default", "accept-edits", "plan", "bypass"];
 export class ConfigError extends Error {
 }
@@ -63,6 +65,17 @@ export function parseConfig(text, source) {
             fail("theme", "belongs in the USER config — a terminal is a property of the person at it, not of the project");
         out.theme = obj.theme;
     }
+    if (obj.checks !== undefined) {
+        if (obj.checks === null || typeof obj.checks !== "object" || Array.isArray(obj.checks))
+            fail("checks", "expected an object of name → command");
+        for (const [name, cmd] of Object.entries(obj.checks)) {
+            if (!/^[A-Za-z0-9_-]+$/.test(name))
+                fail(`checks.${name}`, "a check name is letters, digits, _ or -");
+            if (typeof cmd !== "string" || cmd.trim() === "")
+                fail(`checks.${name}`, "expected a non-empty command string");
+        }
+        out.checks = obj.checks;
+    }
     if (obj.model !== undefined) {
         if (typeof obj.model !== "string" || obj.model === "")
             fail("model", "expected a profile name or provider/model string");
@@ -162,13 +175,69 @@ export function mergeConfigs(user, project) {
         ...(p.autoCompact !== undefined ? { autoCompact: p.autoCompact } : {}),
         ...(u.projectTrust !== undefined ? { projectTrust: u.projectTrust } : {}),
         ...(p.projectTrust !== undefined ? { projectTrust: p.projectTrust } : {}),
+        // DT-1a: checks merge per name — a (trusted) project's check wins over the user's
+        ...(u.checks !== undefined || p.checks !== undefined ? { checks: { ...(u.checks ?? {}), ...(p.checks ?? {}) } } : {}),
     };
 }
-/** A profile is available when its apiKeyEnv var is set (the key exists). */
+/** Where a profile's sign-in comes from, or why it has none. The sign-in
+ *  plan's resolve rule: a stored credential OWNS the provider (an
+ *  unusable stored one is an error, never a silent fall back to env);
+ *  with nothing stored, the profile's env var applies; a keyless profile
+ *  (no apiKeyEnv — PH-1c, finding PH-F19) is an unauthenticated endpoint.
+ *
+ *  OR-1: a stored OAuth credential is USABLE only by an adapter that can
+ *  drive one, which today is the Responses adapter's ChatGPT target. For
+ *  every other kind it stays the same loud refusal it has always been —
+ *  the caller is told which sign-in it has and which one it needs. */
+export function authForProfile(name, p) {
+    const providerId = providerIdOf(p.kind, p.baseUrl);
+    if (providerId !== null) {
+        let stored;
+        try {
+            stored = getCredential(providerId);
+        }
+        catch (err) {
+            if (err instanceof AuthError)
+                throw new ConfigError(`model ${name}: ${err.message}`);
+            throw err;
+        }
+        if (stored !== undefined) {
+            if (stored.type === "api-key")
+                return { type: "api-key", apiKey: stored.key, source: "store" };
+            if (p.kind === "openai-responses")
+                return { type: "oauth", providerId };
+            throw new ConfigError(`model ${name}: signed in to ${providerId} with OAuth, but this profile's adapter needs an API key — run \`kiso login ${providerId}\` with a key, or \`kiso logout ${providerId}\` to use the env var ${p.apiKeyEnv ?? "(none configured)"}`);
+        }
+    }
+    if (p.apiKeyEnv === undefined)
+        return { type: "api-key", apiKey: "none", source: "none" };
+    const fromEnv = process.env[p.apiKeyEnv];
+    if (fromEnv !== undefined)
+        return { type: "api-key", apiKey: fromEnv, source: "env" };
+    const hint = providerId !== null ? `run \`kiso login ${providerId}\` or set the env var ${p.apiKeyEnv}` : `set the env var ${p.apiKeyEnv}`;
+    throw new ConfigError(`model ${name}: unavailable — no credential: ${hint} (configs never store keys, only the env-var name)`);
+}
+/** The reason a profile is unavailable, for the surfaces that print it. */
+export function unavailableReason(name, p) {
+    try {
+        authForProfile(name, p);
+        return "";
+    }
+    catch (err) {
+        return err instanceof Error ? err.message : String(err);
+    }
+}
+/** A profile is available when a sign-in resolves for it — of EITHER
+ *  shape: an OAuth-only profile is available, and calling the key-only
+ *  resolver here would have declared it broken. */
 export function profileAvailable(p) {
-    // PH-1c (finding PH-F19): a keyless profile (no apiKeyEnv) is an
-    // unauthenticated endpoint — always available.
-    return p.apiKeyEnv === undefined || process.env[p.apiKeyEnv] !== undefined;
+    try {
+        authForProfile("?", p);
+        return true;
+    }
+    catch {
+        return false;
+    }
 }
 /** "provider/model" direct write → a profile. */
 export function directWriteProfile(value) {
@@ -176,11 +245,15 @@ export function directWriteProfile(value) {
     if (slash <= 0 || slash === value.length - 1)
         return null;
     const kind = value.slice(0, slash);
-    if (kind !== "openai-compat" && kind !== "anthropic")
+    if (kind !== "openai-compat" && kind !== "anthropic" && kind !== "openai-responses")
         return null;
     return {
         kind,
         model: value.slice(slash + 1),
+        // OR-1: a direct-write `openai-responses/…` names no baseUrl, so it
+        // is the FIRST-PARTY target and its env var is OpenAI's. The
+        // ChatGPT backend needs a baseUrl and a stored sign-in, which is a
+        // configured profile's job, not a one-line direct write.
         apiKeyEnv: kind === "anthropic" ? "ANTHROPIC_API_KEY" : "OPENAI_API_KEY",
     };
 }
@@ -243,12 +316,10 @@ export function resolveModel(modelFlag, merged) {
     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)`);
-    }
     // PH-1c (finding PH-F19): a keyless profile hands the adapter a
     // placeholder — the SDKs require SOME string; the endpoint ignores it.
-    return { name, profile: p, apiKey: p.apiKeyEnv === undefined ? "none" : process.env[p.apiKeyEnv] };
+    const auth = authForProfile(name, p);
+    return auth.type === "oauth" ? { name, profile: p, oauthProviderId: auth.providerId } : { name, profile: p, apiKey: auth.apiKey };
 }
 /** Mode: env (KISO_MODE) beats config.mode; the --mode flag is applied by
  *  main before this runs (flags are the top of the chain). */

package/dist/dispatch.js

@@ -5,11 +5,37 @@
  */
 import { contextRows, contextUnavailableRows, displayVerb, escapeTerminal, helpRows, kUnit, modePickView, modelPickView, palette } from "@vincemakes/kiso-tui";
 import { newSessionId } from "./session-id.js";
-import { buildAdapter, resolveContinuationScope, resolveReasoning } from "@vincemakes/kiso-runtime/internal";
+import { buildAdapter, lookupModelMetadata, resolveContinuationScope, resolveReasoning } from "@vincemakes/kiso-runtime/internal";
 import { MODES, MODE_NOTE, getMode, setMode } from "./mode.js";
 import { clipboardWrite, lastAnswer } from "./clipboard.js";
 import { agentModel, body, bodyLog, configModels, dock, readContextLedger, sessionsDir, setAgentModel, setCurrentModelName, setLastBinding } from "./state.js";
-import { directWriteProfile, profileAvailable } from "./config.js";
+import { authForProfile, directWriteProfile, profileAvailable, unavailableReason } from "./config.js";
+/** The picker's CLI half (owner 2026-09-08): a profile's LEGAL effort levels
+ *  and its default, from the registry, shown wherever the profile is listed
+ *  — kiso never silently drops a level, and now it shows the ones it takes.
+ *  A model the registry does not know shows `unknown` (nothing is guessed);
+ *  it must not read `none`, which is a REAL level since the Responses rows. */
+function effortNote(p) {
+    const reasoning = lookupModelMetadata(p.model, p.baseUrl)?.capabilities.reasoning ?? null;
+    const effort = reasoning?.effort ?? null;
+    if (effort === null)
+        return "effort: unknown";
+    return `effort: ${effort.levels.map((l) => (l === effort.default ? `[${l}]` : l)).join(" · ")}`;
+}
+/** What signs a profile in, for the listing: the env var's name, `oauth`
+ *  for a subscription sign-in, or `no key` for an unauthenticated endpoint. */
+function signInNote(p) {
+    try {
+        const auth = authForProfile("?", p);
+        if (auth.type === "oauth")
+            return "oauth";
+    }
+    catch {
+        // unavailable — the availability mark says so; the env name still names what would sign it in
+    }
+    return p.apiKeyEnv ?? "no key";
+}
+import { oauthTokenThunk } from "./auth/token.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
@@ -295,7 +321,7 @@ export function dispatch(line, ctx) {
                         header: `model — current: ${agentModel}`,
                         options: names.map((name) => {
                             const profile = configModels[name];
-                            const marks = [`profile: ${name}`, ...(profileAvailable(profile) ? [] : ["unavailable"]), ...(profile.model === agentModel ? ["current"] : [])];
+                            const marks = [`profile: ${name}`, ...(profileAvailable(profile) ? [] : ["unavailable"]), ...(profile.model === agentModel ? ["current"] : []), effortNote(profile)];
                             return { label: `${profile.kind}/${profile.model}`, note: marks.join(" · ") };
                         }),
                         // PH-1a (finding PH-F4): the example must be a syntax
@@ -329,7 +355,7 @@ export function dispatch(line, ctx) {
                 else {
                     for (const name of names) {
                         const p = configModels[name];
-                        bodyLog(`  ${name} → ${p.kind}/${p.model} · ${p.apiKeyEnv} ${profileAvailable(p) ? "(available)" : "(unavailable)"}`);
+                        bodyLog(`  ${name} → ${p.kind}/${p.model} · ${signInNote(p)} ${profileAvailable(p) ? "(available)" : "(unavailable)"} · ${effortNote(p)}`);
                     }
                 }
                 bodyLog("switch with /model <profile-name|provider/model>");
@@ -347,13 +373,19 @@ export function dispatch(line, ctx) {
                         bodyLog(`no such model profile: ${profName}`);
                     }
                     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)`);
+                        bodyLog(unavailableReason(arg, profile));
                     }
                     else {
+                        const auth = authForProfile(profName, profile);
                         const adapter = await buildAdapter(profile.kind, {
                             // PH-1c (PH-F19): a keyless profile = an unauthenticated
                             // endpoint — the placeholder satisfies the SDK's ctor.
-                            apiKey: profile.apiKeyEnv === undefined ? "none" : process.env[profile.apiKeyEnv],
+                            // OR-1: an OAuth profile passes a token thunk instead
+                            // — there is no key, and the adapter re-resolves the
+                            // token per request.
+                            ...(auth.type === "oauth"
+                                ? { oauth: oauthTokenThunk(auth.providerId), ...(ctx.session.id !== undefined ? { promptCacheKey: ctx.session.id } : {}) }
+                                : { apiKey: auth.apiKey }),
                             ...(profile.baseUrl !== undefined ? { baseUrl: profile.baseUrl } : {}),
                             ...(profile.promptCaching !== undefined ? { promptCaching: profile.promptCaching } : {}),
                         });
@@ -370,7 +402,9 @@ export function dispatch(line, ctx) {
                         let refused = null;
                         if (effortTok !== undefined) {
                             const candidate = { thinking: "default", effort: effortTok };
-                            const resolved = resolveReasoning(profile.model, candidate);
+                            // OR-1: the endpoint narrows the row — the same model id answers
+                            // differently at the first-party API and at the subscription backend
+                            const resolved = resolveReasoning(profile.model, candidate, profile.baseUrl);
                             if (resolved.ok)
                                 reasoning = candidate;
                             else
@@ -386,12 +420,15 @@ export function dispatch(line, ctx) {
                                 adapter,
                                 model: profile.model,
                                 provider: profile.kind,
+                                // OR-1: the endpoint is the fourth passenger — the cost
+                                // path and the window lookup key on (model, endpoint).
+                                ...(profile.baseUrl !== undefined ? { baseUrl: profile.baseUrl } : {}),
                                 ...(scope !== undefined ? { scope } : {}),
                                 ...(reasoning !== undefined ? { reasoning } : {}),
                             };
                             ctx.session.setModelBinding(binding);
                             setLastBinding(binding);
-                            setAgentModel(profile.model);
+                            setAgentModel(profile.model, profile.baseUrl);
                             setCurrentModelName(arg);
                             body.notice(`model → ${profName} (${profile.model}${effortTok !== undefined ? ` · ${effortTok}` : ""}) — takes effect on the next turn`);
                         }

package/dist/index.js

@@ -41,6 +41,7 @@ import { isFirstRun, scaffoldFirstRun } from "./first-run.js";
 import { fauxSkip, readFauxScript } from "./faux-glue.js";
 import { chat, contextWindowTokens, displayCtxRatio } from "./chat.js";
 import { loadProjectConfig, loadUserConfig, mergeConfigs, resolveAutoCompact, resolveContextWindow, resolveModel } from "./config.js";
+import { oauthTokenThunk } from "./auth/token.js";
 import { checkForUpdate } from "./update-check.js";
 import { resume } from "./resume.js";
 import { resumeTail } from "./resume-tail.js";
@@ -590,6 +591,10 @@ async function makeAgent(sessionId, input, modelFlag) {
     const projectCfg = loadProjectConfig(process.cwd(), project !== null);
     const merged = mergeConfigs(userCfg, projectCfg);
     setMergedConfig(merged);
+    // DT-1a: what a delegated task may NAME — the configured checks and the
+    // model profiles — handed to the (in-process) subagent extension through
+    // the environment. A model never supplies a command; it names a check.
+    process.env.KISO_DELEGATION_CONFIG_JSON = JSON.stringify({ checks: merged.checks ?? {}, profiles: Object.keys(merged.models ?? {}) });
     setConfigModels(merged.models ?? {});
     setConfiguredWindow(resolveContextWindow(merged));
     const resolved = resolveModel(modelFlag, merged);
@@ -603,7 +608,7 @@ async function makeAgent(sessionId, input, modelFlag) {
         setCurrentFaux(false);
         setCurrentModelName(resolved.name);
     }
-    setAgentModel(model); // v2b: the status bar shows it
+    setAgentModel(model, resolved?.profile.baseUrl); // v2b: the status bar shows it; OR-1: the endpoint rides along
     // W21: the extensions array is built ONCE per agent and shared with
     // the runtime by reference — the don't-ask-again writer pushes the
     // generated extension into it so a first-time rule joins the chain
@@ -643,13 +648,24 @@ async function makeAgent(sessionId, input, modelFlag) {
         // field survives for the callers that want a bound (subagents, the
         // SDK, `kiso run`); the interactive front door does not set one.
         // Modes: the five tiers join at the CHAIN HEAD, before the user/
-        // project extensions (the deny>ask>allow composition keeps a user
+        // project extensions (the deny>allow>ask composition keeps a user
         // deny winning over any mode tier — bypass included).
         extensions,
         ...(resolved !== null
             ? {
                 provider: resolved.profile.kind,
-                apiKey: resolved.apiKey,
+                // OR-1: exactly one sign-in shape reaches the adapter. An
+                // OAuth profile has no key to pass — it passes the thunk
+                // the adapter re-resolves per request instead.
+                ...(resolved.oauthProviderId !== undefined
+                    ? { oauth: oauthTokenThunk(resolved.oauthProviderId) }
+                    : { apiKey: resolved.apiKey ?? "none" }),
+                // OR-1: the ChatGPT backend's cache lane is the SESSION —
+                // one conversation's requests share a key, different
+                // conversations never do. The one entry point that hands
+                // no session id is `kiso sessions`, a read-only listing
+                // that streams nothing, so its absence costs no cache.
+                ...(sessionId !== undefined ? { promptCacheKey: sessionId } : {}),
                 ...(resolved.profile.baseUrl !== undefined ? { baseUrl: resolved.profile.baseUrl } : {}),
                 ...(resolved.profile.promptCaching !== undefined ? { promptCaching: resolved.profile.promptCaching } : {}),
             }
@@ -785,7 +801,7 @@ async function chatLoop(agent, firstId, input, autoCompact) {
         // XP-1 §2.1: the switched-to session's OWN truth repaints the row —
         // the global display state never outlives the session it described
         // (pre-XP the row kept the previous session's /model selection).
-        setAgentModel(session.model);
+        setAgentModel(session.model, session.baseUrl);
         setCurrentModelName(session.model);
         paintBootStatus(session);
         const nav = {
@@ -799,6 +815,51 @@ async function chatLoop(agent, firstId, input, autoCompact) {
         id = end.id;
     }
 }
+/** A secret from the terminal: hidden input on a TTY, the whole of stdin
+ *  otherwise (a pipe, a heredoc) — never an argument, which shell history
+ *  would keep. */
+async function readSecret(prompt) {
+    if (process.stdin.isTTY !== true) {
+        return await new Promise((resolve) => {
+            let buf = "";
+            process.stdin.setEncoding("utf8");
+            process.stdin.on("data", (d) => {
+                buf += d;
+            });
+            process.stdin.on("end", () => resolve(buf.split("\n")[0] ?? ""));
+            process.stdin.resume();
+        });
+    }
+    process.stdout.write(prompt);
+    return await new Promise((resolve) => {
+        let buf = "";
+        process.stdin.setRawMode(true);
+        process.stdin.resume();
+        process.stdin.setEncoding("utf8");
+        const onData = (chunk) => {
+            for (const ch of chunk) {
+                if (ch === "\r" || ch === "\n") {
+                    process.stdin.setRawMode(false);
+                    process.stdin.pause();
+                    process.stdin.off("data", onData);
+                    process.stdout.write("\n");
+                    resolve(buf);
+                    return;
+                }
+                if (ch === "\u0003") {
+                    process.stdin.setRawMode(false);
+                    process.stdout.write("\n");
+                    process.exit(130);
+                }
+                if (ch === "\u007f" || ch === "\b")
+                    buf = buf.slice(0, -1);
+                else
+                    buf += ch;
+            }
+        };
+        process.stdin.on("data", onData);
+    });
+}
 async function main() {
     // E group (the graceful-exit gate ③, R-G 0.1.48): a terminal closing
     // turns the in-flight stdout/stderr writes into EIO, and node's
@@ -1091,6 +1152,67 @@ async function main() {
                 }
                 break;
             }
+            case "login":
+            case "logout":
+            case "auth": {
+                // the sign-in plan (2026-09-08), step 1: the credential store.
+                // `login <provider>` reads the key from a hidden prompt on a TTY
+                // or from stdin otherwise (never from an argument — shell history);
+                // `logout <provider>` deletes; `auth` lists, keys masked.
+                const { KNOWN_PROVIDERS, OAUTH_PROVIDERS, authPath, deleteCredential, maskSecret, readAuthFile, setCredential } = await import("./auth/credentials.js");
+                const provider = arg;
+                if (command === "auth") {
+                    const file = readAuthFile();
+                    const rows = Object.entries(file.credentials);
+                    const lines = [`credentials: ${authPath()}${rows.length === 0 ? " (none stored)" : ""}`];
+                    for (const [id, cred] of rows) {
+                        if (cred.type === "api-key")
+                            lines.push(`  ${id.padEnd(10)} api-key ${maskSecret(cred.key)}  saved ${new Date(cred.savedAt).toISOString().slice(0, 10)}`);
+                        else
+                            lines.push(`  ${id.padEnd(10)} oauth   ${cred.accountId ?? ""}  expires ${new Date(cred.expires).toISOString()}${cred.expires < Date.now() ? " (expired)" : ""}`);
+                    }
+                    const envs = ["ANTHROPIC_API_KEY", "OPENAI_API_KEY"].filter((k) => process.env[k] !== undefined);
+                    lines.push(`env vars set: ${envs.length ? envs.join(", ") : "none"} (a stored credential owns its provider; env applies only when nothing is stored)`);
+                    process.stdout.write(`${lines.join("\n")}\n`);
+                    break;
+                }
+                if (provider === undefined || !KNOWN_PROVIDERS.includes(provider)) {
+                    throw new CliUsageError(`kiso ${command} <provider> — one of: ${KNOWN_PROVIDERS.join(", ")}`);
+                }
+                if (command === "logout") {
+                    const had = deleteCredential(provider);
+                    process.stdout.write(had ? `signed out of ${provider}\n` : `nothing stored for ${provider}\n`);
+                    break;
+                }
+                if (OAUTH_PROVIDERS.includes(provider)) {
+                    // the subscription sign-in (plan step 2): the browser flow with a
+                    // paste path; the callback host/port can be moved by env for tests
+                    const { chatgptFlow } = await import("./auth/oauth/chatgpt.js");
+                    const { createInterface } = await import("node:readline");
+                    const rl = createInterface({ input: process.stdin, output: process.stdout });
+                    const cbPort = process.env.KISO_OAUTH_CALLBACK_PORT !== undefined ? Number(process.env.KISO_OAUTH_CALLBACK_PORT) : undefined;
+                    try {
+                        const cred = await chatgptFlow.login({
+                            notify: (line) => process.stdout.write(`${line}\n`),
+                            prompt: (q) => new Promise((resolve) => rl.question(q, resolve)),
+                            ...(cbPort !== undefined ? { callback: { host: process.env.KISO_OAUTH_CALLBACK_HOST ?? "127.0.0.1", port: cbPort } } : {}),
+                            ...(process.env.KISO_OAUTH_TOKEN_URL !== undefined ? { tokenUrl: process.env.KISO_OAUTH_TOKEN_URL } : {}),
+                        });
+                        setCredential(provider, cred);
+                        process.stdout.write(`signed in to ${provider} (${chatgptFlow.label}) — account ${cred.accountId ?? "?"}, expires ${new Date(cred.expires).toISOString()} — stored in ${authPath()}\n`);
+                    }
+                    finally {
+                        rl.close();
+                    }
+                    break;
+                }
+                const key = (await readSecret(`API key for ${provider}: `)).trim();
+                if (key === "")
+                    throw new CliUsageError(`kiso login ${provider}: no key given`);
+                setCredential(provider, { type: "api-key", key, savedAt: Date.now() });
+                process.stdout.write(`signed in to ${provider} with an API key (${maskSecret(key)}) — stored in ${authPath()}\n`);
+                break;
+            }
             case "help": {
                 // PH-1b (finding PH-F21): the CLI must be able to describe its
                 // own configuration — the old help listed five commands and
@@ -1104,6 +1226,10 @@ async function main() {
                     "  kiso resume              pick a session to continue (TTY picker)\n" +
                     "  kiso resume <id> [prompt]   continue a session (one-shot)\n" +
                     "  kiso sessions           list durable sessions\n" +
+                    "  kiso login <provider>    anthropic|openai|deepseek|zai: store an API key (hidden prompt, or stdin when piped);\n" +
+                    "                           chatgpt: sign in with a ChatGPT subscription (browser; unofficial third-party flow)\n" +
+                    "  kiso logout <provider>   remove the stored credential\n" +
+                    "  kiso auth               list stored credentials (keys masked)\n" +
                     "  kiso help               this help\n\n" +
                     "flags (any position):\n" +
                     "  --model <profile|provider/model>   pick the model (also /model in-session)\n" +

package/dist/mode.d.ts

@@ -6,7 +6,7 @@
  * switches take effect immediately. The extension NAME rides the runtime's decidedBy
  * field: an automated denial records decidedBy: "mode:<name>" — the
  * audit sell. User-level extensions stay on the chain AFTER the mode
- * tiers; a user deny always wins (the chain's deny>ask>allow
+ * tiers; a user deny always wins (the chain's deny>allow>ask
  * monotonicity — bypass cannot override an extension deny).
  */
 import type { KisoExtension } from "@vincemakes/kiso-runtime";
@@ -29,7 +29,7 @@ export declare function modeFromEnv(): Mode | undefined;
  *  extension name). The CURRENT tier is first: an all-allow chain records
  *  decidedBy = the FIRST SPEAKER, so an auto-allow under the startup mode
  *  names that mode honestly. Order never affects verdicts — the chain is
- *  deny>ask>allow over the SPEAKING verdicts (abstain = no opinion), so a
+ *  deny>allow>ask over the SPEAKING verdicts (abstain = no opinion), so a
  *  user extension's deny wins over any mode tier, bypass included (the
  *  monotonicity e2e pins it). */
 export declare function modeExtensions(): readonly KisoExtension[];

package/dist/mode.js

@@ -6,7 +6,7 @@
  * switches take effect immediately. The extension NAME rides the runtime's decidedBy
  * field: an automated denial records decidedBy: "mode:<name>" — the
  * audit sell. User-level extensions stay on the chain AFTER the mode
- * tiers; a user deny always wins (the chain's deny>ask>allow
+ * tiers; a user deny always wins (the chain's deny>allow>ask
  * monotonicity — bypass cannot override an extension deny).
  */
 export const MODES = ["manual", "default", "accept-edits", "plan", "bypass"];
@@ -78,7 +78,7 @@ function tierVerdict(tier, call) {
  *  extension name). The CURRENT tier is first: an all-allow chain records
  *  decidedBy = the FIRST SPEAKER, so an auto-allow under the startup mode
  *  names that mode honestly. Order never affects verdicts — the chain is
- *  deny>ask>allow over the SPEAKING verdicts (abstain = no opinion), so a
+ *  deny>allow>ask over the SPEAKING verdicts (abstain = no opinion), so a
  *  user extension's deny wins over any mode tier, bypass included (the
  *  monotonicity e2e pins it). */
 export function modeExtensions() {

package/dist/state.d.ts

@@ -156,7 +156,10 @@ export declare function setSessionStore(value: {
 }): void;
 /** The model name for the status bar — set by makeAgent. */
 export declare let agentModel: string;
-export declare function setAgentModel(value: string): void;
+/** OR-1: the live model's ENDPOINT, set in the same call as the model so
+ *  the two can never drift: the window lookup keys on (model, endpoint). */
+export declare let agentBaseUrl: string | undefined;
+export declare function setAgentModel(value: string, baseUrl?: string): void;
 /** merge round 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;
@@ -213,7 +216,9 @@ export declare const CANCELLED: unique symbol;
 export interface LastBinding {
     readonly adapter: import("@vincemakes/kiso-core").Adapter;
     readonly model: string;
-    readonly provider?: "anthropic" | "openai-compat";
+    readonly provider?: "anthropic" | "openai-compat" | "openai-responses";
+    /** OR-1: the endpoint inherits with the adapter (the cost path keys on it). */
+    readonly baseUrl?: string;
     readonly scope?: import("@vincemakes/kiso-core").ContinuationScope;
     readonly reasoning?: import("@vincemakes/kiso-runtime/internal").ReasoningSetting;
 }

package/dist/state.js

@@ -213,8 +213,12 @@ export function setSessionStore(value) {
 }
 /** The model name for the status bar — set by makeAgent. */
 export let agentModel = "faux";
-export function setAgentModel(value) {
+/** OR-1: the live model's ENDPOINT, set in the same call as the model so
+ *  the two can never drift: the window lookup keys on (model, endpoint). */
+export let agentBaseUrl;
+export function setAgentModel(value, baseUrl) {
     agentModel = value;
+    agentBaseUrl = baseUrl;
 }
 /** merge round B: whether the agent runs on the faux provider (no real key) —
  *  set inside makeAgent, read by main for chat/resume's exhaustion check. */

package/dist/trust-ui.d.ts

@@ -37,6 +37,19 @@ export declare let pendingAsk: (() => void) | null;
 export declare function askPanel(input: LineInput, view: PanelView, opts?: {
     safer?: () => Promise<SaferAnswer>;
 }): Promise<PanelVerdict>;
+/**
+ * The dock-less fallback line → a verdict. `y…` allows. `n <reason>` / `no
+ * <reason>` DENIES WITH THE REASON — the words become the tool result and
+ * the run continues with the model seeing them, the same verdict the panel's
+ * "No + words" produces (chat.ts, the deny case). A bare `n`/`no`, or any
+ * other line, is the bare denial that aborts the run — unchanged. (LH-1 ruling
+ * 2026-09-08: the default refusal across arms is refuse-with-a-reason-and-
+ * continue, and the surface a piped or 0-row leg drives is this one.)
+ */
+export declare function parseFallbackAnswer(answer: string): {
+    action: "allow" | "deny";
+    reason: string;
+};
 /**
  * KC3.5 — the AskUI bridge: the panel the ask extension asks through.
  *