@vincemakes/kiso-code 0.30.0 → 0.31.1

package/dist/auth/credentials.d.ts

@@ -0,0 +1,39 @@
+export type Credential = {
+    readonly type: "api-key";
+    readonly key: string;
+    readonly savedAt: number;
+} | {
+    readonly type: "oauth";
+    readonly access: string;
+    readonly refresh: string;
+    /** epoch milliseconds */
+    readonly expires: number;
+    readonly accountId?: string;
+    readonly savedAt: number;
+};
+export interface AuthFile {
+    readonly version: 1;
+    readonly credentials: Readonly<Record<string, Credential>>;
+}
+export declare class AuthError extends Error {
+}
+/** The providers a credential can be stored for (the runtime's built-in
+ *  manifests; `custom` endpoints stay on env vars — a key for an unknown
+ *  origin has no identity to own). */
+export declare const KNOWN_PROVIDERS: readonly string[];
+/** The providers whose sign-in is an OAuth flow rather than a key. */
+export declare const OAUTH_PROVIDERS: readonly string[];
+/** The provider identity a profile's credential is stored under, or null
+ *  for an origin nobody recognizes (custom: env var only). */
+export declare function providerIdOf(kind: string, baseUrl?: string): string | null;
+export declare function authPath(): string;
+export declare function readAuthFile(path?: string): AuthFile;
+export declare function getCredential(providerId: string, path?: string): Credential | undefined;
+/** The one write path: lock, read, transform, write atomically (mode 0600
+ *  on creation; the home directory 0700 on creation). Returns what was written. */
+export declare function modifyAuthFile(fn: (file: AuthFile) => AuthFile, path?: string): AuthFile;
+export declare function setCredential(providerId: string, credential: Credential, path?: string): void;
+/** Removes the credential; false when there was none. */
+export declare function deleteCredential(providerId: string, path?: string): boolean;
+/** The only rendering of a secret: its length class and last four characters. */
+export declare function maskSecret(secret: string): string;

package/dist/auth/credentials.js

@@ -0,0 +1,170 @@
+/**
+ * The credential store — sign-in's foundation (the sign-in plan, 2026-09-08).
+ *
+ * `~/.kiso/auth.json` holds one credential per provider: an API key, or an
+ * OAuth token set (the flows arrive in the next step; the shape is fixed now
+ * so a stored OAuth credential is recognized, never misread as a key). The
+ * file is written atomically (tmp + rename) with mode 0600 on creation; the
+ * ONE write path is `modifyAuthFile`, serialized across processes by a
+ * directory lock beside the file — no dependency, and a stale lock (an
+ * earlier process that died) is reclaimed by age.
+ *
+ * The resolve rule (the reference implementation's, kept as design): a
+ * stored credential OWNS its provider. When one exists it is used; when it is
+ * unusable (an OAuth token where the adapter needs a key; a malformed file)
+ * the failure is named and there is NO silent fall back to an env var — "which
+ * key paid for this" stays answerable. Only when nothing is stored does the
+ * profile's env var apply, as before.
+ *
+ * Keys never appear in stdout, in the session log, or in an error message —
+ * `maskSecret` is the only rendering.
+ */
+import { existsSync, mkdirSync, readFileSync, renameSync, rmSync, statSync, writeFileSync } from "node:fs";
+import { dirname, join } from "node:path";
+import { kisoHome } from "../state.js";
+export class AuthError extends Error {
+}
+/** The providers a credential can be stored for (the runtime's built-in
+ *  manifests; `custom` endpoints stay on env vars — a key for an unknown
+ *  origin has no identity to own). */
+export const KNOWN_PROVIDERS = ["anthropic", "openai", "deepseek", "zai", "chatgpt"];
+/** The providers whose sign-in is an OAuth flow rather than a key. */
+export const OAUTH_PROVIDERS = ["chatgpt"];
+// Mirrors the runtime's known-origin table (packages/runtime/src/provider/
+// manifest.ts, not on the SDK surface): a compat profile whose baseUrl origin
+// is a built-in endpoint resolves to that provider's identity.
+const ORIGIN_TO_PROVIDER = {
+    "https://api.openai.com": "openai",
+    "https://api.deepseek.com": "deepseek",
+    "https://api.z.ai": "zai",
+    "https://open.bigmodel.cn": "zai",
+};
+/** The ChatGPT backend's origin — the one that means the SUBSCRIPTION
+ *  identity rather than OpenAI's. Mirrors the runtime's CHATGPT_ORIGIN.
+ *  Absent from ORIGIN_TO_PROVIDER on purpose: that table resolves
+ *  openai-CHAT profiles, and the subscription backend serves only the
+ *  Responses dialect. */
+const CHATGPT_ORIGIN = "https://chatgpt.com";
+/** The provider identity a profile's credential is stored under, or null
+ *  for an origin nobody recognizes (custom: env var only). */
+export function providerIdOf(kind, baseUrl) {
+    if (kind === "anthropic")
+        return "anthropic";
+    // OR-1: exactly two identities serve the Responses dialect — the
+    // ChatGPT subscription backend, and OpenAI. There is no `custom`
+    // bucket: a Responses endpoint that is neither is still OpenAI's API
+    // shape behind a proxy, and its credential is OpenAI's.
+    if (kind === "openai-responses")
+        return originOf(baseUrl) === CHATGPT_ORIGIN ? "chatgpt" : "openai";
+    if (kind !== "openai-compat")
+        return null;
+    if (baseUrl === undefined)
+        return "openai";
+    const origin = originOf(baseUrl);
+    return origin === null ? null : (ORIGIN_TO_PROVIDER[origin] ?? null);
+}
+function originOf(baseUrl) {
+    if (baseUrl === undefined)
+        return null;
+    try {
+        return new URL(baseUrl).origin;
+    }
+    catch {
+        return null;
+    }
+}
+export function authPath() {
+    return join(kisoHome(), "auth.json");
+}
+const EMPTY = { version: 1, credentials: {} };
+export function readAuthFile(path = authPath()) {
+    if (!existsSync(path))
+        return EMPTY;
+    let parsed;
+    try {
+        parsed = JSON.parse(readFileSync(path, "utf8"));
+    }
+    catch (err) {
+        throw new AuthError(`${path} is not valid JSON (${err.message}) — fix or remove it; kiso never guesses at credentials`);
+    }
+    if (typeof parsed !== "object" || parsed === null || parsed.version !== 1 || typeof parsed.credentials !== "object") {
+        throw new AuthError(`${path} has an unknown shape (expected version 1) — fix or remove it`);
+    }
+    return parsed;
+}
+export function getCredential(providerId, path = authPath()) {
+    return readAuthFile(path).credentials[providerId];
+}
+/** The lock: a directory beside the file. mkdir is atomic on every platform
+ *  Node runs on; a lock older than STALE_MS belongs to a process that died
+ *  and is reclaimed. Waits up to WAIT_MS, then refuses by name. */
+const STALE_MS = 30_000;
+const WAIT_MS = 10_000;
+function sleepSync(ms) {
+    Atomics.wait(new Int32Array(new SharedArrayBuffer(4)), 0, 0, ms);
+}
+function withLock(path, fn) {
+    const lock = `${path}.lock`;
+    const deadline = Date.now() + WAIT_MS;
+    for (;;) {
+        try {
+            mkdirSync(lock);
+            break;
+        }
+        catch (err) {
+            if (err.code !== "EEXIST")
+                throw err;
+            let age = 0;
+            try {
+                age = Date.now() - statSync(lock).mtimeMs;
+            }
+            catch {
+                continue; // it vanished between the mkdir and the stat — try again
+            }
+            if (age > STALE_MS) {
+                rmSync(lock, { recursive: true, force: true });
+                continue;
+            }
+            if (Date.now() > deadline)
+                throw new AuthError(`${path} is locked by another kiso process (${lock}); try again, or remove the lock if no kiso is running`);
+            sleepSync(25);
+        }
+    }
+    try {
+        return fn();
+    }
+    finally {
+        rmSync(lock, { recursive: true, force: true });
+    }
+}
+/** The one write path: lock, read, transform, write atomically (mode 0600
+ *  on creation; the home directory 0700 on creation). Returns what was written. */
+export function modifyAuthFile(fn, path = authPath()) {
+    mkdirSync(dirname(path), { recursive: true, mode: 0o700 });
+    return withLock(path, () => {
+        const next = fn(readAuthFile(path));
+        const tmp = `${path}.tmp-${process.pid}`;
+        writeFileSync(tmp, `${JSON.stringify(next, null, 2)}\n`, { mode: 0o600 });
+        renameSync(tmp, path);
+        return next;
+    });
+}
+export function setCredential(providerId, credential, path = authPath()) {
+    modifyAuthFile((file) => ({ version: 1, credentials: { ...file.credentials, [providerId]: credential } }), path);
+}
+/** Removes the credential; false when there was none. */
+export function deleteCredential(providerId, path = authPath()) {
+    let had = false;
+    modifyAuthFile((file) => {
+        had = providerId in file.credentials;
+        const { [providerId]: _gone, ...rest } = file.credentials;
+        return { version: 1, credentials: rest };
+    }, path);
+    return had;
+}
+/** The only rendering of a secret: its length class and last four characters. */
+export function maskSecret(secret) {
+    if (secret.length <= 4)
+        return "••••";
+    return `••••${secret.slice(-4)}`;
+}

package/dist/auth/oauth/chatgpt.d.ts

@@ -0,0 +1,40 @@
+import type { OAuthCredential, OAuthFlow } from "./index.js";
+export declare const CHATGPT: {
+    readonly providerId: "chatgpt";
+    readonly clientId: "app_EMoamEEZ73f0CkXaXp7hrann";
+    readonly authorizeUrl: "https://auth.openai.com/oauth/authorize";
+    readonly tokenUrl: "https://auth.openai.com/oauth/token";
+    readonly redirectUri: "http://localhost:1455/auth/callback";
+    readonly scope: "openid profile email offline_access";
+    readonly jwtClaimPath: "https://api.openai.com/auth";
+    readonly originator: "kiso";
+};
+export interface AuthorizationFlow {
+    readonly verifier: string;
+    readonly state: string;
+    readonly url: string;
+}
+export declare function createAuthorizationFlow(redirectUri?: string): AuthorizationFlow;
+/** A pasted redirect URL, a `code#state` pair, a query string, or a bare code. */
+export declare function parseAuthorizationInput(input: string): {
+    readonly code?: string | undefined;
+    readonly state?: string | undefined;
+};
+export declare function decodeJwtPayload(token: string): Record<string, unknown> | null;
+export declare function accountIdOf(accessToken: string): string | null;
+interface TokenSet {
+    readonly access: string;
+    readonly refresh: string;
+    readonly expires: number;
+}
+export declare function exchangeCode(code: string, verifier: string, redirectUri: string, tokenUrl?: string, signal?: AbortSignal): Promise<TokenSet>;
+export declare function refreshTokens(refresh: string, tokenUrl?: string): Promise<TokenSet>;
+export declare function credentialFromTokens(tokens: TokenSet): OAuthCredential;
+/** The local callback: one code for one state, or null when the port cannot
+ *  be bound (the paste path takes over). */
+export declare function startCallbackServer(state: string, host: string, port: number): Promise<{
+    readonly waitForCode: () => Promise<string | null>;
+    readonly close: () => void;
+} | null>;
+export declare const chatgptFlow: OAuthFlow;
+export {};

package/dist/auth/oauth/chatgpt.js

@@ -0,0 +1,203 @@
+/**
+ * The ChatGPT subscription sign-in — the flow the reference implementation
+ * uses (pi, `packages/ai/src/auth/oauth/openai-codex.ts` @ a79b37334, MIT,
+ * Mario Zechner; the constants and the sequence are reused as design, the
+ * code is ours). What is known and not known about it is recorded in
+ * kiso-doc/kiso-provider-mainline-2026-09-08.md §3; the owner accepted the
+ * terms risk on 2026-09-08. The product labels it as unofficial.
+ *
+ * Sequence: PKCE + state → the authorize URL (opened or printed) → the
+ * callback on 127.0.0.1:1455 (state checked; or a pasted redirect URL /
+ * code when the port cannot be bound) → the code exchanged at the token
+ * endpoint → {access, refresh, expires, accountId} where accountId is the
+ * `chatgpt_account_id` claim of the access token's JWT payload (a token
+ * without it is refused: the backend needs the header).
+ *
+ * The token is only usable against the ChatGPT backend's Responses
+ * endpoint — the Responses adapter is the second half of this step.
+ */
+import { createServer } from "node:http";
+import { generatePkce, randomState } from "./pkce.js";
+export const CHATGPT = {
+    providerId: "chatgpt",
+    clientId: "app_EMoamEEZ73f0CkXaXp7hrann",
+    authorizeUrl: "https://auth.openai.com/oauth/authorize",
+    tokenUrl: "https://auth.openai.com/oauth/token",
+    redirectUri: "http://localhost:1455/auth/callback",
+    scope: "openid profile email offline_access",
+    jwtClaimPath: "https://api.openai.com/auth",
+    originator: "kiso",
+};
+export function createAuthorizationFlow(redirectUri = CHATGPT.redirectUri) {
+    const { verifier, challenge } = generatePkce();
+    const state = randomState();
+    const url = new URL(CHATGPT.authorizeUrl);
+    url.searchParams.set("response_type", "code");
+    url.searchParams.set("client_id", CHATGPT.clientId);
+    url.searchParams.set("redirect_uri", redirectUri);
+    url.searchParams.set("scope", CHATGPT.scope);
+    url.searchParams.set("code_challenge", challenge);
+    url.searchParams.set("code_challenge_method", "S256");
+    url.searchParams.set("state", state);
+    url.searchParams.set("id_token_add_organizations", "true");
+    url.searchParams.set("codex_cli_simplified_flow", "true");
+    url.searchParams.set("originator", CHATGPT.originator);
+    return { verifier, state, url: url.toString() };
+}
+/** A pasted redirect URL, a `code#state` pair, a query string, or a bare code. */
+export function parseAuthorizationInput(input) {
+    const value = input.trim();
+    if (value === "")
+        return {};
+    try {
+        const url = new URL(value);
+        return { code: url.searchParams.get("code") ?? undefined, state: url.searchParams.get("state") ?? undefined };
+    }
+    catch {
+        // not a URL
+    }
+    if (value.includes("#")) {
+        const [code, state] = value.split("#", 2);
+        return { code, state };
+    }
+    if (value.includes("code=")) {
+        const params = new URLSearchParams(value);
+        return { code: params.get("code") ?? undefined, state: params.get("state") ?? undefined };
+    }
+    return { code: value };
+}
+export function decodeJwtPayload(token) {
+    const parts = token.split(".");
+    if (parts.length !== 3)
+        return null;
+    try {
+        return JSON.parse(Buffer.from(parts[1] ?? "", "base64url").toString("utf8"));
+    }
+    catch {
+        return null;
+    }
+}
+export function accountIdOf(accessToken) {
+    const payload = decodeJwtPayload(accessToken);
+    const auth = payload?.[CHATGPT.jwtClaimPath];
+    const id = auth?.chatgpt_account_id;
+    return typeof id === "string" && id.length > 0 ? id : null;
+}
+async function readTokenResponse(response, operation) {
+    if (!response.ok) {
+        const text = await response.text().catch(() => "");
+        throw new Error(`ChatGPT sign-in: token ${operation} failed (${response.status})${text ? `: ${text.slice(0, 200)}` : ""}`);
+    }
+    const json = (await response.json());
+    if (typeof json.access_token !== "string" || typeof json.refresh_token !== "string" || typeof json.expires_in !== "number") {
+        throw new Error(`ChatGPT sign-in: token ${operation} response is missing fields`);
+    }
+    return { access: json.access_token, refresh: json.refresh_token, expires: Date.now() + json.expires_in * 1000 };
+}
+export async function exchangeCode(code, verifier, redirectUri, tokenUrl = CHATGPT.tokenUrl, signal) {
+    const response = await fetch(tokenUrl, {
+        method: "POST",
+        headers: { "Content-Type": "application/x-www-form-urlencoded" },
+        body: new URLSearchParams({ grant_type: "authorization_code", client_id: CHATGPT.clientId, code, code_verifier: verifier, redirect_uri: redirectUri }),
+        ...(signal ? { signal } : {}),
+    });
+    return readTokenResponse(response, "exchange");
+}
+export async function refreshTokens(refresh, tokenUrl = CHATGPT.tokenUrl) {
+    const response = await fetch(tokenUrl, {
+        method: "POST",
+        headers: { "Content-Type": "application/x-www-form-urlencoded" },
+        body: new URLSearchParams({ grant_type: "refresh_token", client_id: CHATGPT.clientId, refresh_token: refresh }),
+    });
+    return readTokenResponse(response, "refresh");
+}
+export function credentialFromTokens(tokens) {
+    const accountId = accountIdOf(tokens.access);
+    if (accountId === null)
+        throw new Error("ChatGPT sign-in: the access token carries no chatgpt_account_id claim — signed in to something the backend will not serve");
+    return { type: "oauth", access: tokens.access, refresh: tokens.refresh, expires: tokens.expires, accountId, savedAt: Date.now() };
+}
+const PAGE = (title, body) => `<!doctype html><meta charset="utf-8"><title>${title}</title><body style="font:16px system-ui;padding:2rem"><h1>${title}</h1><p>${body}</p></body>`;
+/** The local callback: one code for one state, or null when the port cannot
+ *  be bound (the paste path takes over). */
+export function startCallbackServer(state, host, port) {
+    return new Promise((resolve) => {
+        let settle;
+        const waited = new Promise((r) => {
+            settle = r;
+        });
+        const server = createServer((req, res) => {
+            const url = new URL(req.url ?? "", `http://${host}`);
+            const reply = (status, title, body) => {
+                res.statusCode = status;
+                res.setHeader("Content-Type", "text/html; charset=utf-8");
+                res.end(PAGE(title, body));
+            };
+            if (url.pathname !== "/auth/callback")
+                return reply(404, "Not found", "This is kiso's sign-in callback.");
+            if (url.searchParams.get("state") !== state)
+                return reply(400, "State mismatch", "The sign-in did not start from this kiso. Start again.");
+            const code = url.searchParams.get("code");
+            if (!code)
+                return reply(400, "Missing code", "The authorization server sent no code.");
+            reply(200, "Signed in", "You can close this window and return to kiso.");
+            settle?.(code);
+        });
+        server.on("error", () => resolve(null));
+        server.listen(port, host, () => {
+            resolve({
+                waitForCode: () => waited,
+                close: () => {
+                    settle?.(null);
+                    server.close();
+                },
+            });
+        });
+    });
+}
+export const chatgptFlow = {
+    providerId: CHATGPT.providerId,
+    label: "ChatGPT subscription (Plus/Pro) — the Codex sign-in flow; unofficial for third-party tools",
+    async login(interaction) {
+        const cb = interaction.callback ?? { host: "127.0.0.1", port: 1455 };
+        const redirectUri = interaction.callback ? `http://localhost:${cb.port}/auth/callback` : CHATGPT.redirectUri;
+        const flow = createAuthorizationFlow(redirectUri);
+        const server = await startCallbackServer(flow.state, cb.host, cb.port);
+        interaction.notify(`open this URL to sign in:\n  ${flow.url}`);
+        // OR-4 (owner, 2026-09-09): the URL is opened for the person when the
+        // caller can — the printed line stays the fallback and the paste path.
+        if (interaction.open !== undefined) {
+            interaction.open(flow.url);
+            interaction.notify("(opened in your browser — if nothing opened, copy the URL above)");
+        }
+        let code = null;
+        if (server !== null) {
+            interaction.notify(`waiting for the browser to come back to ${redirectUri} … (or paste the redirected URL here)`);
+            const pasted = interaction.prompt("").then((line) => {
+                const parsed = parseAuthorizationInput(line);
+                if (parsed.state !== undefined && parsed.state !== flow.state)
+                    throw new Error("ChatGPT sign-in: the pasted state does not match this sign-in");
+                return parsed.code ?? null;
+            });
+            code = await Promise.race([server.waitForCode(), pasted]);
+            server.close();
+        }
+        else {
+            interaction.notify(`port ${cb.port} is busy: after signing in, paste the redirected URL (or the code) here`);
+            const parsed = parseAuthorizationInput(await interaction.prompt("redirected URL or code: "));
+            if (parsed.state !== undefined && parsed.state !== flow.state)
+                throw new Error("ChatGPT sign-in: the pasted state does not match this sign-in");
+            code = parsed.code ?? null;
+        }
+        if (code === null || code === "")
+            throw new Error("ChatGPT sign-in: no authorization code arrived");
+        const tokens = await exchangeCode(code, flow.verifier, redirectUri, interaction.tokenUrl, interaction.signal);
+        return credentialFromTokens(tokens);
+    },
+    async refresh(credential, tokenUrl) {
+        const tokens = await refreshTokens(credential.refresh, tokenUrl);
+        const fresh = credentialFromTokens(tokens);
+        const accountId = accountIdOf(tokens.access) ?? credential.accountId;
+        return { ...fresh, ...(accountId !== undefined ? { accountId } : {}) };
+    },
+};

package/dist/auth/oauth/index.d.ts

@@ -0,0 +1,37 @@
+/**
+ * The OAuth interface — one shape for every subscription sign-in (the
+ * sign-in plan, 2026-09-08, step 2). A flow knows how to obtain a credential
+ * interactively and how to refresh one; the credential store owns
+ * persistence; `ensureFresh` (../refresh.ts) owns WHEN a refresh happens.
+ */
+import type { Credential } from "../credentials.js";
+export type OAuthCredential = Extract<Credential, {
+    type: "oauth";
+}>;
+export interface LoginInteraction {
+    /** Print a line for the person signing in (the URL to open, the paste prompt). */
+    readonly notify: (line: string) => void;
+    /** Ask the person for a line (the pasted redirect URL or code when the
+     *  local callback cannot be reached); resolves "" when unavailable. */
+    readonly prompt: (question: string) => Promise<string>;
+    /** OR-4: open the authorize URL in the person's browser, when there is
+     *  one. OPTIONAL — the CLI passes it on a TTY; tests and pipes never do,
+     *  so nothing opens a browser under a test rig. The URL is always
+     *  printed too: this is a convenience, never the only path. */
+    readonly open?: (url: string) => void;
+    readonly signal?: AbortSignal;
+    /** Test seam: the callback listener's host/port (defaults 127.0.0.1:1455). */
+    readonly callback?: {
+        readonly host: string;
+        readonly port: number;
+    };
+    /** Test seam: the token endpoint (defaults to the vendor's). */
+    readonly tokenUrl?: string;
+}
+export interface OAuthFlow {
+    readonly providerId: string;
+    /** What the product says beside this method (an honest label). */
+    readonly label: string;
+    login(interaction: LoginInteraction): Promise<OAuthCredential>;
+    refresh(credential: OAuthCredential, tokenUrl?: string): Promise<OAuthCredential>;
+}

package/dist/auth/oauth/index.js

@@ -0,0 +1 @@
+export {};

package/dist/auth/oauth/pkce.d.ts

@@ -0,0 +1,5 @@
+export declare function generatePkce(): {
+    readonly verifier: string;
+    readonly challenge: string;
+};
+export declare function randomState(): string;

package/dist/auth/oauth/pkce.js

@@ -0,0 +1,12 @@
+/** PKCE (RFC 7636) with S256 — the two values every browser sign-in needs.
+ *  node:crypto only; base64url without padding, as the spec requires. */
+import { createHash, randomBytes } from "node:crypto";
+const base64url = (bytes) => Buffer.from(bytes).toString("base64").replace(/\+/g, "-").replace(/\//g, "_").replace(/=+$/, "");
+export function generatePkce() {
+    const verifier = base64url(randomBytes(32));
+    const challenge = base64url(createHash("sha256").update(verifier).digest());
+    return { verifier, challenge };
+}
+export function randomState() {
+    return randomBytes(16).toString("hex");
+}

package/dist/auth/refresh.d.ts

@@ -0,0 +1,12 @@
+/**
+ * When a refresh happens (the sign-in plan §2): an OAuth credential that
+ * expires within FRESH_WINDOW_MS is refreshed INSIDE the store's write path —
+ * re-read under the lock first, so two kiso processes never refresh the same
+ * token twice (the second sees the first's result). A failed refresh is a
+ * named error ("signed out of <provider>: run `kiso login <provider>`"),
+ * never a silent fall back to an API key or an env var.
+ */
+import { type Credential } from "./credentials.js";
+import type { OAuthFlow } from "./oauth/index.js";
+export declare const FRESH_WINDOW_MS: number;
+export declare function ensureFresh(providerId: string, flow: OAuthFlow, path?: string, now?: number, tokenUrl?: string): Promise<Credential>;

package/dist/auth/refresh.js

@@ -0,0 +1,40 @@
+/**
+ * When a refresh happens (the sign-in plan §2): an OAuth credential that
+ * expires within FRESH_WINDOW_MS is refreshed INSIDE the store's write path —
+ * re-read under the lock first, so two kiso processes never refresh the same
+ * token twice (the second sees the first's result). A failed refresh is a
+ * named error ("signed out of <provider>: run `kiso login <provider>`"),
+ * never a silent fall back to an API key or an env var.
+ */
+import { AuthError, modifyAuthFile, readAuthFile } from "./credentials.js";
+export const FRESH_WINDOW_MS = 5 * 60_000;
+export async function ensureFresh(providerId, flow, path, now = Date.now(), tokenUrl) {
+    const current = readAuthFile(path).credentials[providerId];
+    if (current === undefined)
+        throw new AuthError(`not signed in to ${providerId}: run \`kiso login ${providerId}\``);
+    if (current.type !== "oauth" || current.expires - now > FRESH_WINDOW_MS)
+        return current;
+    let refreshed;
+    let error;
+    // the double check: another process may have refreshed while we waited for the lock
+    const again = readAuthFile(path).credentials[providerId];
+    if (again !== undefined && again.type === "oauth" && again.expires - now > FRESH_WINDOW_MS)
+        return again;
+    try {
+        refreshed = await flow.refresh(current, tokenUrl);
+    }
+    catch (err) {
+        error = err instanceof Error ? err : new Error(String(err));
+    }
+    if (refreshed === undefined)
+        throw new AuthError(`signed out of ${providerId} (the token could not be refreshed: ${error?.message ?? "unknown"}) — run \`kiso login ${providerId}\``);
+    const written = refreshed;
+    modifyAuthFile((file) => {
+        const latest = file.credentials[providerId];
+        // if a concurrent refresh already wrote a fresher token, keep it
+        if (latest !== undefined && latest.type === "oauth" && latest.expires > written.expires)
+            return file;
+        return { version: 1, credentials: { ...file.credentials, [providerId]: written } };
+    }, path);
+    return readAuthFile(path).credentials[providerId];
+}

package/dist/auth/token.d.ts

@@ -0,0 +1,17 @@
+/**
+ * OR-1 — the token thunk the Responses adapter's ChatGPT target is built
+ * from.
+ *
+ * The adapter awaits this ONCE PER REQUEST, which is the whole point: a
+ * subscription token expires on the hour, and a session that resolved its
+ * token at startup would die mid-task. `ensureFresh` re-reads the store
+ * under its own lock and refreshes only inside the expiry window, so the
+ * per-request call is a file read in the common case and a refresh
+ * exactly when one is due.
+ *
+ * A failure here is the store's own named error ("signed out of chatgpt:
+ * run `kiso login chatgpt`") — the adapter turns it into a failed turn
+ * rather than guessing at a fallback credential.
+ */
+import type { ResponsesOAuthToken } from "@vincemakes/kiso-provider-openai-responses";
+export declare function oauthTokenThunk(providerId: string): () => Promise<ResponsesOAuthToken>;

package/dist/auth/token.js

@@ -0,0 +1,26 @@
+import { AuthError } from "./credentials.js";
+import { ensureFresh } from "./refresh.js";
+/** The OAuth flows a provider id can be refreshed through. One entry
+ *  today; a second sign-in registers here rather than in every caller. */
+async function flowFor(providerId) {
+    if (providerId === "chatgpt") {
+        const { chatgptFlow } = await import("./oauth/chatgpt.js");
+        return chatgptFlow;
+    }
+    throw new AuthError(`no OAuth flow is registered for ${providerId}`);
+}
+export function oauthTokenThunk(providerId) {
+    return async () => {
+        const credential = await ensureFresh(providerId, await flowFor(providerId));
+        if (credential.type !== "oauth") {
+            throw new AuthError(`${providerId}: the stored credential is an API key, not a sign-in — run \`kiso login ${providerId}\``);
+        }
+        if (credential.accountId === undefined) {
+            // The backend refuses a request without the account header, so
+            // a token that carries no account id is unusable — said here,
+            // once, rather than as an opaque 400 per turn.
+            throw new AuthError(`${providerId}: the stored sign-in carries no account id — run \`kiso login ${providerId}\` again`);
+        }
+        return { access: credential.access, accountId: credential.accountId };
+    };
+}

package/dist/chat.d.ts

@@ -38,6 +38,15 @@ export declare function estimateCtxRatio(session: AgentSession): number;
  *  their continuation envelopes, the output reserve when known) over the
  *  window. Still ~ (chars/4). The auto-compact policy does NOT read this
  *  (see autoCompactRatio) — moving the policy's number is A1b's. */
+/** OR-8 (owner, 2026-09-09): the status row names the effort next to the
+ *  model — `gpt-5.6-sol · xhigh` — whenever the live binding carries one;
+ *  the provider's default shows as the bare model, as before. The effort
+ *  is the session's own (the durable profile), never the CLI's memory. */
+export declare function statusModelLabel(session: {
+    readonly reasoning?: {
+        readonly effort: string;
+    };
+}): string;
 export declare function displayCtxRatio(session: AgentSession): number;
 /** A1a: the number the auto-compact decision reads — the pre-A1a estimate,
  *  unchanged this round, named so a gate can pin that it did not move. */
@@ -85,7 +94,7 @@ export interface UsageDelta {
  * absent provider resolves like the tracer's "adapter" identity — the
  * total convention (INPUT_CONVENTIONS), never a crash.
  */
-export declare function usageFromEvent(route: string | undefined, ev: import("@vincemakes/kiso-core").Usage, prevTotal: number | null, model?: string): UsageDelta;
+export declare function usageFromEvent(route: string | undefined, ev: import("@vincemakes/kiso-core").Usage, prevTotal: number | null, model?: string, endpoint?: string): UsageDelta;
 /** v2b: the spinner merged into the STATUS BAR (the v2a standalone glyph
  *  is gone) — docked only, 200ms rotation between the request and the
  *  first event. */