@vincemakes/kiso-code 0.34.0 → 0.37.0

package/dist/auth/adapter-options.d.ts

@@ -0,0 +1,22 @@
+import type { ModelProfile } from "../config.js";
+/** The credential shape both call sites can produce: `authForProfile`'s
+ *  return value, and the startup path's already-narrowed `resolved`. */
+export type AdapterAuth = {
+    readonly type: "oauth";
+    readonly providerId: string;
+} | {
+    readonly type: "api-key";
+    readonly apiKey: string;
+};
+/** Exactly the runtime `buildAdapter` option set. */
+export interface AdapterOptions {
+    readonly apiKey?: string;
+    readonly baseUrl?: string;
+    readonly promptCaching?: boolean;
+    readonly oauth?: () => Promise<{
+        readonly access: string;
+        readonly accountId: string;
+    }>;
+    readonly promptCacheKey?: string;
+}
+export declare function adapterOptionsFor(profile: ModelProfile, auth: AdapterAuth, sessionId?: string): AdapterOptions;

package/dist/auth/adapter-options.js

@@ -0,0 +1,57 @@
+/**
+ * Astra F1 (P0) — THE ONE PLACE THE ADAPTER'S WIRE CONFIG IS BUILT.
+ *
+ * The P0's mechanism is a single sentence: the CLI hands the adapter an
+ * EXPLICIT endpoint, so the provider SDKs never read `ANTHROPIC_BASE_URL` /
+ * `OPENAI_BASE_URL` for themselves while `authForProfile` has already
+ * chosen the STORED VENDOR KEY for the vendor's own origin.
+ *
+ * That sentence had no home. It was a spread written out twice — at startup
+ * in index.ts and on the `/model` switch in dispatch.ts — which is F1's own
+ * defect class: one rule, two copies, and the copies drift. The first fix
+ * for this finding edited both copies. This gives the rule somewhere to
+ * live, and a test somewhere to point.
+ *
+ * The extraction found the two sites had ALREADY drifted:
+ *
+ *   - `promptCacheKey` was passed at startup whenever the session had an
+ *     id, but on `/model` only for an OAuth profile. Both sites pass it
+ *     identically now, which is a tidiness fix and NOT a wire change —
+ *     finding IA-0360-F1 corrects the claim this comment used to make.
+ *     The Responses adapter serializes it on the ChatGPT (OAuth) target
+ *     ALONE; the first-party API-key target builds an empty `extraBody`
+ *     (provider-openai-responses `resolveTarget`), so it never carried a
+ *     cache key and still does not. Passing an internal option at two
+ *     construction sites is not evidence that the adapter puts it on the
+ *     wire on both authentication paths — I traced the field as far as the
+ *     provider's constructor and stopped one level short of the branch
+ *     that drops it.
+ *   - `streamIdleMs` is set at startup and not on `/model`. It is NOT an
+ *     adapter option — it is an agent-definition field the runtime reads —
+ *     so it is out of this function's scope and stays where it is, noted
+ *     here so the next reader does not think it was missed.
+ */
+import { effectiveBaseUrl } from "./credentials.js";
+import { oauthTokenThunk } from "./token.js";
+export function adapterOptionsFor(profile, auth, sessionId) {
+    // 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. PH-1c (PH-F19): a keyless profile is an
+    // unauthenticated endpoint and its placeholder satisfies the SDK's ctor.
+    const credential = auth.type === "oauth" ? { oauth: oauthTokenThunk(auth.providerId) } : { apiKey: auth.apiKey };
+    // Astra F1 (P0): ALWAYS EXPLICIT. Passing nothing let the SDK read its
+    // own environment variable, and a profile with no baseUrl then sent the
+    // stored vendor key wherever that variable pointed.
+    const url = effectiveBaseUrl(profile.kind, profile.baseUrl);
+    return {
+        ...credential,
+        ...(url !== undefined ? { baseUrl: url } : {}),
+        // 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 with no session id is `kiso sessions`, a
+        // read-only listing that streams nothing, so its absence costs no
+        // cache.
+        ...(sessionId !== undefined ? { promptCacheKey: sessionId } : {}),
+        ...(profile.promptCaching !== undefined ? { promptCaching: profile.promptCaching } : {}),
+    };
+}

package/dist/auth/credentials.d.ts

@@ -23,6 +23,29 @@ export declare class AuthError extends Error {
 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[];
+/**
+ * Astra F1 (P0) — THE ONE RESOLVED EFFECTIVE ENDPOINT.
+ *
+ * `providerIdOf` read an ABSENT `baseUrl` as the vendor's own endpoint and
+ * returned the vendor id, so `authForProfile` handed back the STORED vendor
+ * key. Correct in isolation. But the adapter factories passed `baseURL` to the
+ * SDK only when the profile NAMED one, and with none named the Anthropic and
+ * OpenAI SDKs read `ANTHROPIC_BASE_URL` / `OPENAI_BASE_URL` from the
+ * environment themselves — so the saved official key went to whatever the
+ * environment named.
+ *
+ * Two sides disagreed about what "no baseUrl" meant. THE FIX IS TO RESOLVE IT
+ * ONCE, here, and give both sides the same answer: the credential resolver
+ * decides which key may go, the adapter is handed an EXPLICIT url so the SDK
+ * never consults its environment.
+ *
+ * 0.32.2's R1 bound the explicit-URL path. This is the absent-URL path, which
+ * is the common configuration.
+ */
+export declare const VENDOR_DEFAULT: Readonly<Record<string, string>>;
+/** The endpoint a profile ACTUALLY talks to: its own, or the vendor's
+ *  default for its kind. Never the environment's — that is the defect. */
+export declare function effectiveBaseUrl(kind: string, baseUrl?: string): string | undefined;
 /** 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;

package/dist/auth/credentials.js

@@ -50,6 +50,35 @@ const CHATGPT_ORIGIN = "https://chatgpt.com";
  *  the dialect it speaks. */
 const ANTHROPIC_ORIGIN = "https://api.anthropic.com";
 const OPENAI_ORIGIN = "https://api.openai.com";
+/**
+ * Astra F1 (P0) — THE ONE RESOLVED EFFECTIVE ENDPOINT.
+ *
+ * `providerIdOf` read an ABSENT `baseUrl` as the vendor's own endpoint and
+ * returned the vendor id, so `authForProfile` handed back the STORED vendor
+ * key. Correct in isolation. But the adapter factories passed `baseURL` to the
+ * SDK only when the profile NAMED one, and with none named the Anthropic and
+ * OpenAI SDKs read `ANTHROPIC_BASE_URL` / `OPENAI_BASE_URL` from the
+ * environment themselves — so the saved official key went to whatever the
+ * environment named.
+ *
+ * Two sides disagreed about what "no baseUrl" meant. THE FIX IS TO RESOLVE IT
+ * ONCE, here, and give both sides the same answer: the credential resolver
+ * decides which key may go, the adapter is handed an EXPLICIT url so the SDK
+ * never consults its environment.
+ *
+ * 0.32.2's R1 bound the explicit-URL path. This is the absent-URL path, which
+ * is the common configuration.
+ */
+export const VENDOR_DEFAULT = {
+    anthropic: ANTHROPIC_ORIGIN,
+    "openai-compat": `${OPENAI_ORIGIN}/v1`,
+    "openai-responses": `${OPENAI_ORIGIN}/v1`,
+};
+/** The endpoint a profile ACTUALLY talks to: its own, or the vendor's
+ *  default for its kind. Never the environment's — that is the defect. */
+export function effectiveBaseUrl(kind, baseUrl) {
+    return baseUrl ?? VENDOR_DEFAULT[kind];
+}
 /** 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) {
@@ -74,23 +103,24 @@ export function providerIdOf(kind, baseUrl) {
     // The compat kind was already right — an unrecognized origin resolves
     // to null and the env var pays — so this makes the other two agree with
     // the one that had the rule.
-    const origin = originOf(baseUrl);
-    if (kind === "anthropic") {
-        if (baseUrl === undefined)
-            return "anthropic"; // the vendor's own default endpoint
+    //
+    // Astra F1: THE SAME RESOLVER THE ADAPTER USES. An absent baseUrl used to
+    // be a special case here — three `if (baseUrl === undefined) return "<the
+    // vendor>"` branches — and a DIFFERENT special case at the adapter, where
+    // it meant "let the SDK read the environment". Two copies of one rule is
+    // how the two sides came to disagree. Resolved once, this function is left
+    // with the single question it exists to ask: does that origin belong to
+    // the vendor?
+    const origin = originOf(effectiveBaseUrl(kind, baseUrl));
+    if (kind === "anthropic")
         return origin === ANTHROPIC_ORIGIN ? "anthropic" : null;
-    }
     if (kind === "openai-responses") {
-        if (baseUrl === undefined)
-            return "openai"; // the vendor's own default endpoint
         if (origin === CHATGPT_ORIGIN)
             return "chatgpt";
         return origin === OPENAI_ORIGIN ? "openai" : null;
     }
     if (kind !== "openai-compat")
         return null;
-    if (baseUrl === undefined)
-        return "openai";
     return origin === null ? null : (ORIGIN_TO_PROVIDER[origin] ?? null);
 }
 function originOf(baseUrl) {

package/dist/breaker.d.ts

@@ -18,8 +18,8 @@
  * deny beat `bypass` — and the model receives it as the call's result with
  * the reason (the 1c grammar: refuse with a reason and continue), so the
  * next turn has to change course. The human sees the denial on the
- * transcript with `decidedBy: breaker`; the 50-turn checkpoint (part two)
- * is where a human is asked.
+ * transcript with `decidedBy: breaker`. LT2B-F1 removes the periodic
+ * turn-count question; this evidence-based refusal remains independent.
  *
  * Counting: CONSECUTIVE failed results of one (tool, input) key within a
  * run. A success, a different call, or the run's terminal resets it. The

package/dist/breaker.js

@@ -18,8 +18,8 @@
  * deny beat `bypass` — and the model receives it as the call's result with
  * the reason (the 1c grammar: refuse with a reason and continue), so the
  * next turn has to change course. The human sees the denial on the
- * transcript with `decidedBy: breaker`; the 50-turn checkpoint (part two)
- * is where a human is asked.
+ * transcript with `decidedBy: breaker`. LT2B-F1 removes the periodic
+ * turn-count question; this evidence-based refusal remains independent.
  *
  * Counting: CONSECUTIVE failed results of one (tool, input) key within a
  * run. A success, a different call, or the run's terminal resets it. The

package/dist/builtin.d.ts

@@ -5,4 +5,9 @@ export declare function builtInLayer(user: readonly KisoExtension[], project: re
  *  bridge exists (an interactive TTY). No bridge, no fourth built-in:
  *  a headless session never pays the rent for a question nobody could
  *  answer, and its tool table cannot mention ask_user. */
-ask?: AskUI): Promise<readonly KisoExtension[]>;
+ask?: AskUI, 
+/** Astra F7: the env-var NAMES the configured profiles authenticate with.
+ *  The mcp extension spawns its stdio children while it is being
+ *  constructed, so the names have to arrive here — after construction is
+ *  too late. Only the config knows them; nothing else can. */
+secretEnvNames?: readonly string[]): Promise<readonly KisoExtension[]>;

package/dist/builtin.js

@@ -30,8 +30,13 @@ export async function builtInLayer(user, project,
  *  bridge exists (an interactive TTY). No bridge, no fourth built-in:
  *  a headless session never pays the rent for a question nobody could
  *  answer, and its tool table cannot mention ask_user. */
-ask) {
-    const all = await Promise.all([createMcp(), createSkills(), createSubagent(), ...(ask === undefined ? [] : [createAsk(ask)])]);
+ask, 
+/** Astra F7: the env-var NAMES the configured profiles authenticate with.
+ *  The mcp extension spawns its stdio children while it is being
+ *  constructed, so the names have to arrive here — after construction is
+ *  too late. Only the config knows them; nothing else can. */
+secretEnvNames = []) {
+    const all = await Promise.all([createMcp({ secretEnvNames }), createSkills(), createSubagent(), ...(ask === undefined ? [] : [createAsk(ask)])]);
     const shadowed = all.filter((b) => user.some((u) => u.name === b.name));
     for (const s of shadowed) {
         console.error(`[extensions] user extension "${s.name}" shadows the built-in — the built-in is not loaded`);

package/dist/chat.d.ts

@@ -26,8 +26,58 @@ export declare function autoCompactFromEnv(): AutoCompact | undefined;
  * config window (merge round 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.
+ *
+ * CTX-1: with no argument this reads the LIVE binding, which is what every
+ * display caller wants. `/model` needs the window of the model it is
+ * switching TO, before that binding is live, so it passes the pair
+ * explicitly. Reading module state a caller is about to change is how the
+ * threshold got stuck in the first place.
+ *
+ * The argument is a PAIR, never two optional halves: a profile with no
+ * `baseUrl` is endpoint-less, and a half-given argument would have it
+ * inherit the OUTGOING model's endpoint — the same bug one field over.
+ */
+/**
+ * THE WINDOW SOMEBODY STATED, or null when nobody has.
+ *
+ * Three sources, in order: the config/profile window, KISO_CONTEXT_WINDOW,
+ * and the metadata registry. Each is a claim someone made and dated. When
+ * none of them speaks, this returns NULL rather than a number — because
+ * the question "how much of the window is left" has no answer without a
+ * window, and every display that shows a percentage needs this one, not
+ * the policy value below.
+ *
+ * DeepSeek is the live case: its /models endpoint returns ids only, the
+ * responses carry no window, and the registry records null on purpose. The
+ * display used to divide by a hardcoded 200,000 anyway and print a
+ * confident `ctx left ~82%` against a figure nobody had measured.
+ */
+export declare function knownContextWindow(of?: {
+    readonly model: string;
+    readonly baseUrl?: string;
+}): number | null;
+export declare function contextWindowTokens(of?: {
+    readonly model: string;
+    readonly baseUrl?: string;
+}): number;
+/**
+ * CTX-1: THE ONE derivation of the compaction threshold from the window.
+ *
+ * Startup (`index.ts`) and the `/model` switch (`dispatch.ts`) both need
+ * this number, and two call sites computing the same thing is how
+ * `promptCacheKey` drifted before `adapterOptionsFor` collected it. The
+ * policy — half the window — lives here and nowhere else.
+ *
+ * CAPACITY is not POLICY. The window is what the model can hold; this is
+ * when we choose to clear old tool results. They are 2:1 today because
+ * that ratio has never been measured, not because it is derived from
+ * anything. Moving the policy means changing this line, and the whole
+ * product moves with it.
  */
-export declare function contextWindowTokens(): number;
+export declare function microcompactThresholdFor(of?: {
+    readonly model: string;
+    readonly baseUrl?: string;
+}): number;
 /**
  * B area: approximate context ratio — chars/4 of the projected messages vs
  * the model window. Marked ~ everywhere it is shown; no counting API.
@@ -95,6 +145,56 @@ export interface UsageDelta {
  * 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, endpoint?: string): UsageDelta;
+/** W22 (owner, 2026-09-14) — the TURN's usage, summed across its calls.
+ *
+ *  EXISTING-BEHAVIOR CHANGE — declared, never a silent side-fix:
+ *  the recap and the running row carried the LAST call's figures
+ *  (`usage = delta.usage`), and read as the turn's by everyone who saw
+ *  them: the owner's own dogfood, a nine-call turn that had spent 120,358
+ *  prompt tokens and 4,608 output tokens, reported `in 412 out 924 ·
+ *  cache 98%` — the ninth call's fresh input and the ninth call's output.
+ *  The variables are the same and the definitions are unchanged; the SCOPE
+ *  is the turn's.
+ *
+ *  Two rules, inherited rather than invented:
+ *  - `in` stays the canonical FRESH count (E2, R2a-1): the turn's sum is
+ *    the input the turn actually bought at full price. `cache` is summed
+ *    too, but only the recap's ratio reads it (cache/(in+cache)) — the raw
+ *    total is the ledger's business, never the row's, because a sum over
+ *    calls counts the same prefix once per call.
+ *  - an unmeasured term makes the sum unmeasured (OR-10's rule, applied to
+ *    the sum): `null` propagates, and one call with `known: false` makes
+ *    the turn's figure unknown rather than a lower bound dressed as a
+ *    total. The row then says nothing, as it always did for an unknown
+ *    call.
+ *
+ *  The miss estimate and the decode rate stay PER CALL: `missed` is the
+ *  overlap of consecutive prompts (a total-side quantity), and the rate is
+ *  the call that just settled timing itself. */
+export declare function accumulateUsage(prev: RunUsage, delta: RunUsage): RunUsage;
+/**
+ * W22-R1 (Astra): the turn's usage ledger, as ONE definition.
+ *
+ * A TURN is the sum over its CALLS; a CALL is its LATEST report. Both
+ * halves are load-bearing: the openai-compat adapter yields a usage event
+ * from either of two stream shapes and its `usageSent` flag only decides
+ * whether to append a trailing unknown — it does not stop both from
+ * firing. W22 substituted, so a second report silently replaced the first
+ * and no screen changed; summing without the call boundary turned the same
+ * stream into a WRONG NUMBER (a ledger of fresh 80 / out 10 shown as
+ * 160 / 15).
+ *
+ * It is a function rather than three variables in the loop because the rule
+ * then has one place to be right — the same reason `microcompactThresholdFor`
+ * exists, and the drift `promptCacheKey` demonstrated when it did not.
+ */
+export declare function turnUsageLedger(): {
+    observe: (ev: {
+        readonly type: string;
+    }) => void;
+    report: (u: RunUsage) => void;
+    total: () => RunUsage | null;
+};
 /** 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. */
@@ -170,19 +270,6 @@ export declare function parseSaferOptions(text: string): SaferOption[] | null;
  * echo is UI, the chip is the record; the momentary double-render is
  * the design's explicit point).
  */
-/** LT-2b — the turn checkpoint (kiso-doc/kiso-lt1-mini-spec-2026-09-09.md,
- *  part two). R3e stands: no hard turn limit on an interactive session. What
- *  a long run gets instead is a QUESTION every CHECKPOINT_TURNS model turns —
- *  the run is paused between two model turns (the generator is simply not
- *  pulled while the panel is up; the kernel does nothing meanwhile) and the
- *  human answers. "Keep going" resumes it, the next question one checkpoint
- *  later; "Stop here" aborts the run — `aborted by user`, resumable, never
- *  silent. A decline (esc) is "keep going": the run was already running, and
- *  esc on a panel is the panel's decline, not the run's abort. Headless
- *  entries never see it: the panel needs the dock, and a pipe, `-p` or a
- *  task file has none. 50 is named here; a finding moves it, never a stray
- *  edit. */
-export declare const CHECKPOINT_TURNS = 50;
 export declare function consumeRun(session: AgentSession, run: Run, input: LineInput, turnNo: number, faux: boolean, statusCb: ((usage: RunUsage, ctxRatio: number, costUsd?: number | null, tokPerSec?: number | null) => void) | null, 
 /** W21: the amend words ("Yes + feedback") ride the NEXT user turn —
  *  threaded from chat's submitTurn; absent in the recovery flow