@vincemakes/kiso-code 0.40.2 → 0.40.3

package/dist/chat.d.ts

@@ -9,6 +9,7 @@ import { type RunUsage } from "@vincemakes/kiso-tui";
 import { type SaferFailure, type SaferOption } from "@vincemakes/kiso-tui";
 import type { AgentSession, Run } from "@vincemakes/kiso-runtime";
 import { type LineInput } from "./state.js";
+import { type ContextWindowSource } from "@vincemakes/kiso-runtime/internal";
 /**
  * The ergonomics batch C8 — the /compact auto-trigger, OPT-IN (default off: only an
  * explicit KISO_AUTO_COMPACT=<ratio> enables it — the CLI never defaults
@@ -42,7 +43,9 @@ export declare function autoCompactFromEnv(): AutoCompact | undefined;
  * 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
+ * and the metadata registry (CW-1: this endpoint's row, the upstream's,
+ * then the model's own — see lookupContextWindow). 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
@@ -57,6 +60,37 @@ export declare function knownContextWindow(of?: {
     readonly model: string;
     readonly baseUrl?: string;
 }): number | null;
+/** CW-1: a stated window and WHO stated it — `set` is the user (profile,
+ *  config or KISO_CONTEXT_WINDOW), `faux` is ours, the rest are the
+ *  registry's steps (lookupContextWindow). */
+export interface StatedWindow {
+    readonly tokens: number;
+    readonly source: "set" | "faux" | "learned" | ContextWindowSource;
+    /** the registry row's model id, for the registry's steps */
+    readonly from?: string;
+    /** CW-1 batch 2: the day an endpoint's refusal stated it, for `learned` */
+    readonly observedAt?: string;
+}
+/** CW-1: `knownContextWindow` with its source — the chain the displays name.
+ *  The user's figure is the live binding's unless `own` carries a
+ *  profile's: the /model listing passes each row's, and a row with none
+ *  must not borrow the live one (`own: { configured: undefined }` — an
+ *  optional parameter defaulted to the live value would take it back,
+ *  since an explicit undefined selects the default). */
+export declare function statedContextWindow(of?: {
+    readonly model: string;
+    readonly baseUrl?: string;
+    readonly upstream?: string;
+}, own?: {
+    readonly configured: number | undefined;
+}): StatedWindow | null;
+/** CW-1: a window as the displays write it — `1M`, `1.05M`, `272K`,
+ *  `1,048,576` (a figure that is not round is shown whole). */
+export declare function windowLabel(tokens: number): string;
+/** CW-1: the source, said. The short form rides a /model row; the long
+ *  form is /status's. Only the model step is marked in the short form —
+ *  it is the one figure no row states for this endpoint. */
+export declare function windowSourceNote(w: StatedWindow | null, form: "short" | "long"): string;
 export declare function contextWindowTokens(of?: {
     readonly model: string;
     readonly baseUrl?: string;
@@ -101,9 +135,13 @@ export declare function statusModelLabel(session: {
     };
 }): string;
 /** ADR-0055 Amendment 2 (decision 5): with no stated window the status row
- *  shows `ctx ?`, yet the compaction tiers still assume the 200K fallback
+ *  shows `ctx ?`, yet the compaction tiers still assume the fallback (128K
+ *  since CW-1 batch 2)
  *  — the assumption is said out loud once, at agent build. */
 export declare function unknownWindowNotice(model: string): string;
+/** CW-1 batch 2: said once, when an endpoint's refusal states its cap — the
+ *  tiers aim below it from the next request, and later sessions start on it. */
+export declare function windowLearnedNotice(model: string, host: string, tokens: number): string;
 /** ADR-0055 Amendment 2: the notice for a checkpoint the shrink invariant
  *  discarded — chars/4 sizes only; the checkpoint's text is the owner's
  *  work and never reaches the screen. */
@@ -231,6 +269,28 @@ export declare function turnUsageLedger(): {
     report: (u: RunUsage) => void;
     total: () => RunUsage | null;
 };
+/**
+ * The per-CALL view of usage reports for the two figures that must not
+ * double: the cache-miss estimate and the session's running cost.
+ *
+ * A call may report its usage more than once — the op gateway sent two
+ * usage chunks for one request (the owner's session
+ * 2026-09-23T03-00-01-230c: `fresh 3k · miss 3k` on a first turn, both
+ * reports 3,041 in / 69 out). The ledger above already makes a call's
+ * LATEST report replace the earlier; the miss and the cost were read per
+ * EVENT, so the second report compared itself with the first and called
+ * the whole prompt a miss, and a priced route would have been charged
+ * twice. Here the carrier is the PREVIOUS call's total, and a call's cost
+ * is added as the difference from what that call already added.
+ */
+export declare function callUsageMeter(): {
+    /** what a report's miss is measured against: the previous call's total */
+    carrier: () => number | null;
+    /** one report of the current call; returns the cost to ADD (or null) */
+    report: (total: number | null, costUsd: number | null) => number | null;
+    /** a stop ends the call */
+    endCall: () => void;
+};
 /** 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. */

package/dist/chat.js

@@ -14,14 +14,19 @@ import { canonicalizeUsage } from "@vincemakes/kiso-runtime";
 import { canonicalizeUsageForModel, requestBudget } from "@vincemakes/kiso-runtime/internal";
 import { dispatch, abortBangCommand } from "./dispatch.js";
 import { paintWindowTitle } from "./window-title.js";
-import { agentBaseUrl, agentModel, body, bodyLog, configuredWindow, dock, retryOnRow, retryShown, setRetryShown, floorOn, protectedFiles } from "./state.js";
+import { agentBaseUrl, agentModel, body, bodyLog, configuredWindow, dock, retryOnRow, retryShown, setRetryShown, floorOn, protectedFiles, upstreamOf } from "./state.js";
 import { attachImages } from "./attachments.js";
-import { lookupModelMetadata } from "@vincemakes/kiso-runtime/internal";
+import { learnedWindowFor } from "./learned-windows.js";
+import { lookupContextWindow, lookupModelMetadata } from "@vincemakes/kiso-runtime/internal";
 import { addDontAskAgainRule, askPanel, fixHintFor, pendingAsk, resolveUncertains } from "./trust-ui.js";
 import { FauxExhaustionError, failOnFauxExhaustion } from "./faux-glue.js";
 import { OFFERED_MODES, getMode, setMode } from "./mode.js";
-/** B area: default context window for the ~ctx estimate (config overridable). */
-const DEFAULT_CONTEXT_WINDOW = 200_000;
+/** B area: default context window for the ~ctx estimate (config overridable).
+ *  CW-1 batch 2: 128,000, down from 200,000 — the figure a model nobody
+ *  states a window for is assumed to hold (the reference implementation's
+ *  default too). Too small costs an early compaction; too large costs a
+ *  refused request on a 128K model. Registered models never reach it. */
+const DEFAULT_CONTEXT_WINDOW = 128_000;
 /** The in-process fake provider's id, and the window we declare for it.
  *  Ours to state: faux is not a vendor's model, so "nobody published a
  *  window" — the reason a real model's capacity is unknown — cannot apply.
@@ -61,7 +66,9 @@ export function autoCompactFromEnv() {
  * 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
+ * and the metadata registry (CW-1: this endpoint's row, the upstream's,
+ * then the model's own — see lookupContextWindow). 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
@@ -73,11 +80,21 @@ export function autoCompactFromEnv() {
  * confident `ctx left ~82%` against a figure nobody had measured.
  */
 export function knownContextWindow(of) {
-    if (configuredWindow !== undefined)
-        return configuredWindow;
+    return statedContextWindow(of)?.tokens ?? null;
+}
+/** CW-1: `knownContextWindow` with its source — the chain the displays name.
+ *  The user's figure is the live binding's unless `own` carries a
+ *  profile's: the /model listing passes each row's, and a row with none
+ *  must not borrow the live one (`own: { configured: undefined }` — an
+ *  optional parameter defaulted to the live value would take it back,
+ *  since an explicit undefined selects the default). */
+export function statedContextWindow(of, own) {
+    const configured = own !== undefined ? own.configured : configuredWindow;
+    if (configured !== undefined)
+        return { tokens: configured, source: "set" };
     const env = Number.parseInt(process.env.KISO_CONTEXT_WINDOW ?? "", 10);
     if (Number.isFinite(env) && env > 0)
-        return env;
+        return { tokens: env, source: "set" };
     const model = of?.model ?? agentModel;
     // `faux` is OURS. The registry carries no row for it because it is not a
     // vendor's model, but the reason the window is unknown elsewhere — nobody
@@ -86,9 +103,47 @@ export function knownContextWindow(of) {
     // keeps faux mode showing a real percentage instead of the `ctx ?` that
     // belongs to models whose capacity genuinely nobody states.
     if (model === FAUX_MODEL)
-        return FAUX_CONTEXT_WINDOW;
-    const known = lookupModelMetadata(model, of !== undefined ? of.baseUrl : agentBaseUrl)?.capabilities.contextWindow;
-    return known ?? null;
+        return { tokens: FAUX_CONTEXT_WINDOW, source: "faux" };
+    const baseUrl = of !== undefined ? of.baseUrl : agentBaseUrl;
+    // CW-1 batch 2: what this endpoint's own refusal stated, before any
+    // statement about the model — a measurement of the route.
+    const learned = learnedWindowFor(model, baseUrl);
+    if (learned !== undefined)
+        return { tokens: learned.tokens, source: "learned", observedAt: learned.observedAt };
+    return lookupContextWindow(model, baseUrl, of?.upstream ?? upstreamOf(baseUrl));
+}
+/** CW-1: a window as the displays write it — `1M`, `1.05M`, `272K`,
+ *  `1,048,576` (a figure that is not round is shown whole). */
+export function windowLabel(tokens) {
+    if (tokens >= 1_000_000 && tokens % 10_000 === 0)
+        return `${tokens / 1_000_000}M`;
+    if (tokens % 1000 === 0)
+        return `${tokens / 1000}K`;
+    return tokens.toLocaleString("en-US");
+}
+/** CW-1: the source, said. The short form rides a /model row; the long
+ *  form is /status's. Only the model step is marked in the short form —
+ *  it is the one figure no row states for this endpoint. */
+export function windowSourceNote(w, form) {
+    if (w === null)
+        return form === "short" ? "ctx ?" : `window unknown — compaction assumes ${windowLabel(DEFAULT_CONTEXT_WINDOW)}; set contextWindow on the profile to state it`;
+    const size = windowLabel(w.tokens);
+    if (form === "short")
+        return w.source === "model" ? `ctx ${size} inferred` : `ctx ${size}`;
+    switch (w.source) {
+        case "set":
+            return `window ${size}, as you set it`;
+        case "faux":
+            return `window ${size} (faux)`;
+        case "learned":
+            return `window ${size}, learned from this endpoint's refusal (${w.observedAt ?? "date unknown"})`;
+        case "route":
+            return `window ${size}, the registry's for this endpoint`;
+        case "upstream":
+            return `window ${size}, the registry's for the upstream`;
+        case "model":
+            return `window ${size}, inferred from the model (${w.from}) — not stated for this endpoint`;
+    }
 }
 export function contextWindowTokens(of) {
     const windowOverride = configuredWindow;
@@ -112,9 +167,21 @@ export function contextWindowTokens(of) {
     // asked again. The claim is true now because the switch path calls
     // `microcompactThresholdFor` below, not because deriving a number
     // from this function makes anything follow it.
-    const known = lookupModelMetadata(of?.model ?? agentModel, of !== undefined ? of.baseUrl : agentBaseUrl)?.capabilities.contextWindow;
-    if (known !== undefined && known !== null)
-        return known;
+    //
+    // CW-1: the registry's steps are lookupContextWindow's — the route's row,
+    // the upstream's, then the model's own identity — the same chain
+    // `statedContextWindow` names for the displays.
+    const baseUrl = of !== undefined ? of.baseUrl : agentBaseUrl;
+    // CW-1 batch 2: faux is declared here too — it read the old 200K
+    // fallback by accident, and the fallback moving must not move it.
+    if ((of?.model ?? agentModel) === FAUX_MODEL)
+        return FAUX_CONTEXT_WINDOW;
+    const learned = learnedWindowFor(of?.model ?? agentModel, baseUrl);
+    if (learned !== undefined)
+        return learned.tokens;
+    const known = lookupContextWindow(of?.model ?? agentModel, baseUrl, upstreamOf(baseUrl));
+    if (known !== null)
+        return known.tokens;
     return DEFAULT_CONTEXT_WINDOW;
 }
 /**
@@ -167,11 +234,17 @@ export function statusModelLabel(session) {
     return effort !== undefined && effort !== "default" ? `${name} · ${effort}` : name;
 }
 /** ADR-0055 Amendment 2 (decision 5): with no stated window the status row
- *  shows `ctx ?`, yet the compaction tiers still assume the 200K fallback
+ *  shows `ctx ?`, yet the compaction tiers still assume the fallback (128K
+ *  since CW-1 batch 2)
  *  — the assumption is said out loud once, at agent build. */
 export function unknownWindowNotice(model) {
     return `[kiso] context window unknown for ${model} at this endpoint — compaction assumes ${DEFAULT_CONTEXT_WINDOW / 1000}K; set contextWindow on the profile to state it`;
 }
+/** CW-1 batch 2: said once, when an endpoint's refusal states its cap — the
+ *  tiers aim below it from the next request, and later sessions start on it. */
+export function windowLearnedNotice(model, host, tokens) {
+    return `✦ window learned — ${host === "" ? "the endpoint" : host} refused ${model} past ${windowLabel(tokens)} tokens; compaction now aims below it`;
+}
 /** ADR-0055 Amendment 2: the notice for a checkpoint the shrink invariant
  *  discarded — chars/4 sizes only; the checkpoint's text is the owner's
  *  work and never reaches the screen. */
@@ -179,7 +252,7 @@ export function compactionDiscardedNotice(d) {
     return `✦ compaction discarded — the checkpoint did not shrink the context (~${kUnit(d.pre)} → ~${kUnit(d.post)}; it wrote ~${kUnit(d.summary)})`;
 }
 export function displayCtxRatio(session) {
-    // CAPACITY is not POLICY. `contextWindowTokens` falls back to 200,000 so
+    // CAPACITY is not POLICY. `contextWindowTokens` falls back to 128,000 so
     // that the compaction threshold always HAS a value — a policy needs a
     // number. A percentage on screen is a different kind of thing: it is a
     // claim about the model, and an unstated window makes it unanswerable.
@@ -385,6 +458,43 @@ export function turnUsageLedger() {
         },
     };
 }
+/**
+ * The per-CALL view of usage reports for the two figures that must not
+ * double: the cache-miss estimate and the session's running cost.
+ *
+ * A call may report its usage more than once — the op gateway sent two
+ * usage chunks for one request (the owner's session
+ * 2026-09-23T03-00-01-230c: `fresh 3k · miss 3k` on a first turn, both
+ * reports 3,041 in / 69 out). The ledger above already makes a call's
+ * LATEST report replace the earlier; the miss and the cost were read per
+ * EVENT, so the second report compared itself with the first and called
+ * the whole prompt a miss, and a priced route would have been charged
+ * twice. Here the carrier is the PREVIOUS call's total, and a call's cost
+ * is added as the difference from what that call already added.
+ */
+export function callUsageMeter() {
+    let prevCallTotal = null;
+    let callTotal = null;
+    let callCost = null;
+    return {
+        carrier: () => prevCallTotal,
+        report(total, costUsd) {
+            if (total !== null)
+                callTotal = total;
+            if (costUsd === null)
+                return null;
+            const add = costUsd - (callCost ?? 0);
+            callCost = costUsd;
+            return add;
+        },
+        endCall() {
+            if (callTotal !== null)
+                prevCallTotal = callTotal;
+            callTotal = null;
+            callCost = 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. */
@@ -807,7 +917,7 @@ submitTurn) {
     // and read at that call's usage event. Per CALL, not per turn — a turn
     // with three model calls reports the third, and each one times itself.
     let callFirstEventAt = null;
-    let prevTotal = null;
+    const meter = callUsageMeter();
     let missed = null;
     // v3 §02: the recap line derives ENTIRELY from the local event stream
     // (zero tokens). R3g: what it derives is the turn's COST — wall
@@ -844,6 +954,8 @@ submitTurn) {
             // the stream watchdog and the repeated-failure breaker remain active.
             // W22-R1: the ledger sees every event; a stop is what ends a call.
             ledger.observe(ev);
+            if (ev.type === "stop")
+                meter.endCall();
             // ADR-0055 Amendment 1 (A1b): a compaction inside the run says so, once.
             if (ev.type === "summarized" || ev.type === "microcompacted") {
                 const r = displayCtxRatio(session);
@@ -960,11 +1072,12 @@ submitTurn) {
                     body.notice("stream interrupted — the draft above is abandoned");
                     break;
                 case "usage": {
-                    const delta = usageFromEvent(session.provider, ev, prevTotal, agentModel, session.baseUrl);
+                    const delta = usageFromEvent(session.provider, ev, meter.carrier(), agentModel, session.baseUrl);
                     // W22-R1: this call's LATEST report replaces its earlier one;
-                    // the turn's figure is the settled calls plus this one.
+                    // the turn's figure is the settled calls plus this one. The
+                    // miss and the cost follow the same rule (callUsageMeter).
                     ledger.report(delta.usage);
-                    prevTotal = delta.total;
+                    const costToAdd = meter.report(delta.total, delta.costUsd);
                     missed = delta.missed;
                     // TUI2-R1 (E): the request's canonical cost rides the same
                     // callback the usage does — one settled request, one addition.
@@ -973,7 +1086,7 @@ submitTurn) {
                     // second call is timed from ITS own first event.
                     const tokPerSec = callFirstEventAt === null ? null : decodeRate(ev.outputTokens, Date.now() - callFirstEventAt);
                     callFirstEventAt = null;
-                    statusCb?.(turnUsage() ?? UNKNOWN_USAGE, displayCtxRatio(session), delta.costUsd, tokPerSec);
+                    statusCb?.(turnUsage() ?? UNKNOWN_USAGE, displayCtxRatio(session), costToAdd, tokPerSec);
                     break;
                 }
                 case "uncertain_pending":

package/dist/config.d.ts

@@ -11,7 +11,8 @@
  *                      direct write (provider: "openai-compat" |
  *                      "anthropic" | "openai-responses")
  *   models?: { [name]: { kind: "openai-compat"|"anthropic"|"openai-responses",
- *                        baseUrl?: string, model: string, apiKeyEnv: string } }
+ *                        baseUrl?: string, model: string, apiKeyEnv: string,
+ *                        upstream?: string } }   — upstream: never where requests go
  *   mode?: "manual"|"default"|"accept-edits"|"plan"|"bypass"|"dontAsk"
  *   contextWindow?: number      — tokens
  *   autoCompact?: { thresholdRatio: number }   — 0<r<1; default off
@@ -64,6 +65,16 @@ export interface ModelProfile {
      * registry, where every figure has to carry a source.
      */
     readonly contextWindow?: number;
+    /**
+     * What this endpoint FORWARDS to, when `baseUrl` is a local proxy — a URL
+     * (`https://gateway.example/v1`) or a name (`my gateway`). It never
+     * moves a request — they still go to `baseUrl`. The owner, 2026-09-23: a
+     * profile behind a local forwarder showed `@127.0.0.1:47821`, which says
+     * where the bytes go and not who is billed; the row now reads
+     * `@gateway.example via 127.0.0.1:47821`. CW-1: a URL here is also where
+     * the registry looks for this model's window when `baseUrl` has no row.
+     */
+    readonly upstream?: string;
 }
 export interface AutoCompactConfig {
     readonly thresholdRatio: number;

package/dist/config.js

@@ -11,7 +11,8 @@
  *                      direct write (provider: "openai-compat" |
  *                      "anthropic" | "openai-responses")
  *   models?: { [name]: { kind: "openai-compat"|"anthropic"|"openai-responses",
- *                        baseUrl?: string, model: string, apiKeyEnv: string } }
+ *                        baseUrl?: string, model: string, apiKeyEnv: string,
+ *                        upstream?: string } }   — upstream: never where requests go
  *   mode?: "manual"|"default"|"accept-edits"|"plan"|"bypass"|"dontAsk"
  *   contextWindow?: number      — tokens
  *   autoCompact?: { thresholdRatio: number }   — 0<r<1; default off
@@ -146,6 +147,8 @@ export function parseConfig(text, source) {
             // your profile") had never done anything.
             if (p.contextWindow !== undefined && (typeof p.contextWindow !== "number" || !Number.isFinite(p.contextWindow) || p.contextWindow <= 0))
                 fail(`models.${name}.contextWindow`, "expected a positive token count");
+            if (p.upstream !== undefined && (typeof p.upstream !== "string" || p.upstream.trim() === ""))
+                fail(`models.${name}.upstream`, "expected the URL or name of what this endpoint forwards to");
             models[name] = {
                 kind: p.kind,
                 model: p.model,
@@ -154,6 +157,7 @@ export function parseConfig(text, source) {
                 ...(typeof p.promptCaching === "boolean" ? { promptCaching: p.promptCaching } : {}),
                 ...(typeof p.streamIdleMs === "number" ? { streamIdleMs: p.streamIdleMs } : {}),
                 ...(typeof p.contextWindow === "number" ? { contextWindow: p.contextWindow } : {}),
+                ...(typeof p.upstream === "string" ? { upstream: p.upstream.trim() } : {}),
             };
         }
         out.models = models;

package/dist/dispatch.js

@@ -9,11 +9,11 @@ import { buildAdapter, lookupModelMetadata, resolveContinuationScope, resolveRea
 import { MODES, MODE_NOTE, OFFERED_MODES, getMode, setMode } from "./mode.js";
 import { clipboardWrite, lastAnswer } from "./clipboard.js";
 import { protectedBangReason, protectedShellVerdict } from "./protected-shell.js";
-import { agentBaseUrl, currentProfileName, setCurrentProfileName, currentModelName, agentModel, body, bodyLog, codingToolOptions, protectedFiles, kisoHome, configModels, dock, lastBinding, loadedSkillsCatalog, mergedConfig, readContextLedger, retryOnRow, sessionsDir, setAgentModel, setConfiguredWindow, setCurrentModelName, setModelChoice, setRetryShown, setLastBinding } from "./state.js";
+import { agentBaseUrl, currentProfileName, setCurrentProfileName, currentModelName, agentModel, body, bodyLog, codingToolOptions, protectedFiles, kisoHome, configModels, dock, lastBinding, loadedSkillsCatalog, mergedConfig, readContextLedger, retryOnRow, sessionsDir, setAgentModel, setConfiguredWindow, setCurrentModelName, setModelChoice, setRetryShown, upstreamOf, setLastBinding } from "./state.js";
 import { adapterOptionsFor } from "./auth/adapter-options.js";
 import { profileProviderLabel, providerLabel } from "./provider-label.js";
 import { queuedSwitchLines } from "./state.js";
-import { contextWindowTokens, microcompactThresholdFor, startStatusSpinner } from "./chat.js";
+import { contextWindowTokens, microcompactThresholdFor, startStatusSpinner, statedContextWindow, windowSourceNote } from "./chat.js";
 import { authForProfile, directWriteProfile, profileAvailable, resolveContextWindow, unavailableReason } from "./config.js";
 import { shellTool } from "@vincemakes/kiso-tools-node";
 import { dirname, join } from "node:path";
@@ -109,6 +109,14 @@ function signInNote(p) {
     }
     return p.apiKeyEnv ?? "no key";
 }
+/** CW-1 (owner, 2026-09-23): a profile's window on its /model row — the
+ *  profile's own stated figure first, then the registry's chain for its
+ *  model, endpoint and upstream; `inferred` marks the one no row states
+ *  for that endpoint. */
+function windowNoteOf(p) {
+    const w = statedContextWindow({ model: p.model, ...(p.baseUrl !== undefined ? { baseUrl: p.baseUrl } : {}), ...(p.upstream !== undefined ? { upstream: p.upstream } : {}) }, { configured: resolveContextWindow(mergedConfig, p) });
+    return windowSourceNote(w, "short");
+}
 /** 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
@@ -487,7 +495,10 @@ export function dispatch(line, ctx) {
             const ctxPct = Number.isFinite(ctxRatio) ? `~${Math.round(ctxRatio * 100)}%` : "~?";
             bodyLog(`session ${ctx.session.id}`);
             bodyLog(`${ctx.session.log.all.length} events`);
-            bodyLog(`ctx ${ctxPct}`);
+            // CW-1: the percentage names its denominator and who stated it — a
+            // window inferred from the model reads differently from one the
+            // registry states for this endpoint.
+            bodyLog(`ctx ${ctxPct} · ${windowSourceNote(statedContextWindow(), "long")}`);
             // The owner, 2026-09-21: /status is where "what am I actually
             // running on" is answered, so the identity is spelled out HERE —
             // the model, the host the request goes to, the profile it came
@@ -502,7 +513,7 @@ export function dispatch(line, ctx) {
             // restored, not switched. (The real fix is to stop overloading that
             // variable; until then, a label that cannot lie.)
             const profileOf = currentProfileName === null ? "" : ` · profile ${currentProfileName}`;
-            bodyLog(`model ${agentModel}${providerLabel(agentBaseUrl)}${profileOf}`);
+            bodyLog(`model ${agentModel}${providerLabel(agentBaseUrl, upstreamOf(agentBaseUrl))}${profileOf}`);
             ctx.input.prompt();
         });
         return;
@@ -607,8 +618,10 @@ export function dispatch(line, ctx) {
                             // profile key is what `/model <name>` takes, not what a chooser
                             // reading a list needs. What remains is what the chooser CANNOT
                             // infer: availability, and which one is live.
-                            const marks = [...(profileAvailable(profile) ? [] : ["unavailable"]), ...(name === currentProfileName ? ["current"] : [])];
-                            const host = profileProviderLabel(profile.kind, profile.baseUrl);
+                            // CW-1: the window rides LAST — availability and the live mark
+                            // are what a narrow row must keep.
+                            const marks = [...(profileAvailable(profile) ? [] : ["unavailable"]), ...(name === currentProfileName ? ["current"] : []), windowNoteOf(profile)];
+                            const host = profileProviderLabel(profile.kind, profile.baseUrl, profile.upstream);
                             return { label: `${profile.kind}/${profile.model}${host === "" ? "" : ` ${host}`}`, note: marks.join(" · "), ...effortAxis(profile) };
                         }),
                         // PH-1a (finding PH-F4): the example must be a syntax
@@ -658,8 +671,8 @@ export function dispatch(line, ctx) {
                 else {
                     for (const name of names) {
                         const p = configModels[name];
-                        const hostOf = profileProviderLabel(p.kind, p.baseUrl);
-                        bodyLog(`  ${name} → ${p.kind}/${p.model}${hostOf === "" ? "" : ` ${hostOf}`} · ${signInNote(p)} ${profileAvailable(p) ? "(available)" : "(unavailable)"} · ${effortNote(p)}`);
+                        const hostOf = profileProviderLabel(p.kind, p.baseUrl, p.upstream);
+                        bodyLog(`  ${name} → ${p.kind}/${p.model}${hostOf === "" ? "" : ` ${hostOf}`} · ${signInNote(p)} ${profileAvailable(p) ? "(available)" : "(unavailable)"} · ${effortNote(p)} · ${windowNoteOf(p)}`);
                     }
                 }
                 bodyLog("switch with /model <profile-name|provider/model>");
@@ -775,7 +788,7 @@ export function dispatch(line, ctx) {
                             // (and the owner's) read `gpt-6-astra · CH 92%`, the new
                             // model beside the previous model's figure.
                             ctx.modelSwitched();
-                            body.notice(`model → ${profName} (${profile.model}${providerLabel(profile.baseUrl) === "" ? "" : ` ${providerLabel(profile.baseUrl)}`}${effortTok !== undefined ? ` · ${effortTok}` : ""}) — takes effect on the next turn`);
+                            body.notice(`model → ${profName} (${profile.model}${providerLabel(profile.baseUrl, profile.upstream) === "" ? "" : ` ${providerLabel(profile.baseUrl, profile.upstream)}`}${effortTok !== undefined ? ` · ${effortTok}` : ""}) — takes effect on the next turn`);
                         }
                     }
                 }

package/dist/empty-sessions.d.ts

@@ -0,0 +1,22 @@
+export interface EmptySession {
+    /** The session folder (a project folder, or the legacy sessions dir). */
+    readonly dir: string;
+    readonly id: string;
+    /** The files that name it, relative to `dir`. */
+    readonly files: readonly string[];
+}
+export interface EmptyScan {
+    readonly empty: readonly EmptySession[];
+    /** Empty by the files, but a live process holds the lock. */
+    readonly inUse: number;
+}
+/** A lock whose pid answers signal 0 belongs to a running process. */
+export declare function pidAlive(pid: number): boolean;
+/** Every session in `dirs` with a sidecar and no log. Reads only. */
+export declare function findEmptySessions(dirs: readonly string[], alive?: (pid: number) => boolean): EmptyScan;
+/** The platform's Trash: ~/.Trash on macOS, the freedesktop one elsewhere. */
+export declare function defaultTrashRoot(): string;
+/** Move the sessions into one new folder under `trashRoot`, keeping each
+ *  session folder's name; returns that folder. Never deletes: a file that
+ *  cannot be renamed across devices is copied, then unlinked. */
+export declare function moveToTrash(sessions: readonly EmptySession[], trashRoot: string, now?: Date): string;

package/dist/empty-sessions.js

@@ -0,0 +1,102 @@
+/**
+ * DC-60 — the empty sessions an older kiso left behind.
+ *
+ * Until DC-60 every process that opened a session wrote its sidecar (and,
+ * through the start-up recovery, a trace) whether or not anything ever
+ * happened in it: a started-and-closed kiso, a /resume that went nowhere, a
+ * delegated child that failed before its first turn. Each left a sidecar
+ * with no log, and each showed up in /resume as a card with no summary.
+ * The owner's disk held 28 on 2026-09-23.
+ *
+ * `kiso sessions --prune-empty` lists them. With `--yes` it MOVES them to
+ * the Trash — never deletes — keeping each project folder's name, so a
+ * mistake is a drag back. A session whose lock names a live process is
+ * skipped: something is using it right now.
+ */
+import { copyFileSync, existsSync, mkdirSync, readdirSync, readFileSync, renameSync, unlinkSync } from "node:fs";
+import { homedir } from "node:os";
+import { basename, join } from "node:path";
+const SIDECAR = ".meta.json";
+/** A lock whose pid answers signal 0 belongs to a running process. */
+export function pidAlive(pid) {
+    try {
+        process.kill(pid, 0);
+        return true;
+    }
+    catch (err) {
+        return err.code === "EPERM";
+    }
+}
+function lockPid(path) {
+    try {
+        const pid = JSON.parse(readFileSync(path, "utf8")).pid;
+        return typeof pid === "number" && Number.isInteger(pid) && pid > 0 ? pid : null;
+    }
+    catch {
+        return null;
+    }
+}
+/** Every session in `dirs` with a sidecar and no log. Reads only. */
+export function findEmptySessions(dirs, alive = pidAlive) {
+    const empty = [];
+    let inUse = 0;
+    for (const dir of dirs) {
+        let names;
+        try {
+            names = readdirSync(dir);
+        }
+        catch {
+            continue;
+        }
+        for (const name of names) {
+            if (!name.endsWith(SIDECAR))
+                continue;
+            const id = name.slice(0, -SIDECAR.length);
+            if (names.includes(`${id}.jsonl`))
+                continue;
+            const lock = `${id}.lock`;
+            if (names.includes(lock)) {
+                const pid = lockPid(join(dir, lock));
+                if (pid !== null && alive(pid)) {
+                    inUse += 1;
+                    continue;
+                }
+            }
+            const files = [name];
+            if (names.includes(lock))
+                files.push(lock);
+            if (existsSync(join(dir, "traces", `${id}.jsonl`)))
+                files.push(join("traces", `${id}.jsonl`));
+            empty.push({ dir, id, files });
+        }
+    }
+    return { empty, inUse };
+}
+/** The platform's Trash: ~/.Trash on macOS, the freedesktop one elsewhere. */
+export function defaultTrashRoot() {
+    if (process.platform === "darwin")
+        return join(homedir(), ".Trash");
+    return join(process.env.XDG_DATA_HOME ?? join(homedir(), ".local", "share"), "Trash", "files");
+}
+/** Move the sessions into one new folder under `trashRoot`, keeping each
+ *  session folder's name; returns that folder. Never deletes: a file that
+ *  cannot be renamed across devices is copied, then unlinked. */
+export function moveToTrash(sessions, trashRoot, now = new Date()) {
+    const target = join(trashRoot, `kiso-empty-sessions-${now.toISOString().replace(/[:.]/g, "-")}`);
+    for (const s of sessions) {
+        for (const file of s.files) {
+            const to = join(target, basename(s.dir), file);
+            mkdirSync(join(to, ".."), { recursive: true });
+            try {
+                renameSync(join(s.dir, file), to);
+            }
+            catch (err) {
+                if (err.code !== "EXDEV")
+                    throw err;
+                copyFileSync(join(s.dir, file), to);
+                unlinkSync(join(s.dir, file));
+            }
+        }
+    }
+    return target;
+}

package/dist/index.js

@@ -29,13 +29,14 @@ import { newSessionId } from "./session-id.js";
 import { createInterface } from "node:readline";
 import { Readable } from "node:stream";
 import { fileURLToPath } from "node:url";
-import { join } from "node:path";
+import { basename, join } from "node:path";
 import { Body, Editor, PROMPT, bannerLines, currentGround, resolveGround, setGround, escapeTerminal, extensionsBannerText, idColumn, idleStatus, interactivePrompt, palette, renderSessionLine, sessionListFooter, sessionListHeader, sessionListRow, sessionListUnknownLine, slashCommandNames } from "@vincemakes/kiso-tui";
 import { createAgent, disposeExtensions, loadExtensions, loadProjectExtensions, SessionStore, } from "@vincemakes/kiso-runtime";
 import { listSessionSidecars, migrateSummaries, readProfile, runsACheck, summaryMigrationPending } from "@vincemakes/kiso-runtime/internal";
 import { skillMenuItems } from "./skill-invoke.js";
 import { canonicalPath, claimProjectDir, hasSession, locateSession, projectLayoutActive, sessionFolders } from "./projects.js";
 import { migrationNotice, pendingLegacyIds, planMigration, reverseMigration, runMigration } from "./session-migration.js";
+import { defaultTrashRoot, findEmptySessions, moveToTrash } from "./empty-sessions.js";
 import { createFauxProvider } from "@vincemakes/kiso-evals";
 import { createCodingTools, isProtectedPath, protectedIdentity, PROTECTED_REFUSAL } from "@vincemakes/kiso-tools-node";
 import { MODES, OFFERED_MODES, getMode, modeExtensions, modeFromEnv, modeSystemPrompt, setMode } from "./mode.js";
@@ -50,7 +51,9 @@ import { maxRetriesFromEnv } from "./retries.js";
 import { askUi, resolveProjectTrust } from "./trust-ui.js";
 import { isFirstRun, scaffoldFirstRun } from "./first-run.js";
 import { fauxSkip, readFauxScript } from "./faux-glue.js";
-import { chat, compactionDiscardedNotice, contextWindowTokens, displayCtxRatio, knownContextWindow, microcompactThresholdFor, statusModelLabel, unknownWindowNotice } from "./chat.js";
+import { chat, compactionDiscardedNotice, contextWindowTokens, displayCtxRatio, knownContextWindow, microcompactThresholdFor, statusModelLabel, unknownWindowNotice, windowLearnedNotice } from "./chat.js";
+import { recordLearnedWindow, useLearnedWindows } from "./learned-windows.js";
+import { providerHost } from "./provider-label.js";
 import { adapterOptionsFor } from "./auth/adapter-options.js";
 import { loadProjectConfig, loadUserConfig, mergeConfigs, resolveAutoCompact, resolveContextWindow, resolveModel } from "./config.js";
 import { checkForUpdate, knownUpdate, updateCardLines } from "./update-check.js";
@@ -775,6 +778,9 @@ async function makeAgent(sessionId, input, modelFlag) {
     // shell tool would then write into this project's folder.
     process.env.KISO_DELEGATION_CONFIG_JSON = JSON.stringify({ checks: merged.checks ?? {}, profiles: Object.keys(merged.models ?? {}), sessionsDir: sessionsDir() });
     setConfigModels(merged.models ?? {});
+    // CW-1 batch 2: the windows endpoints stated by refusing — read before the
+    // first window is asked for (the unknown-window notice below).
+    useLearnedWindows();
     const resolved = resolveModel(modelFlag, merged);
     // AFTER the model resolves: the window a PROFILE states is about that
     // profile's model, so it cannot be read before we know which profile is
@@ -795,7 +801,8 @@ async function makeAgent(sessionId, input, modelFlag) {
     }
     setAgentModel(model, resolved?.profile.baseUrl); // v2b: the status bar shows it; OR-1: the endpoint rides along
     // ADR-0055 Amendment 2: the row says `ctx ?` for an unstated window, but
-    // the tiers still need a number and assume 200K — say so, once, at build.
+    // the tiers still need a number and assume the fallback — say so, once,
+    // at build.
     if (!unknownWindowNoticed && knownContextWindow() === null) {
         unknownWindowNoticed = true;
         console.error(unknownWindowNotice(model));
@@ -873,8 +880,16 @@ async function makeAgent(sessionId, input, modelFlag) {
                 onDiscard: (d) => body.notice(compactionDiscardedNotice(d)),
                 // ADR-0055 Amendment 2 (decision 3): only a window someone stated
                 // arms the overflow belt — read from the LIVE binding, so it moves
-                // with /model and /resume; the 200K fallback reads as null.
+                // with /model and /resume; the fallback reads as null.
                 statedWindow: () => knownContextWindow(),
+                // CW-1 batch 2: an endpoint's refusal stated its cap. The tiers
+                // took it already; kept, it is where the next session starts, and
+                // the status row's denominator moves with it. Said once per new
+                // figure — a refusal at a cap already kept says nothing.
+                onWindowLearned: (w) => {
+                    if (recordLearnedWindow(w.model, w.baseUrl, w.tokens))
+                        body.notice(windowLearnedNotice(w.model, providerHost(w.baseUrl) ?? "", w.tokens));
+                },
             },
         },
         // R3e (owner ruling, 2026-08-28): NO turn limit on an interactive
@@ -1662,7 +1677,18 @@ async function main() {
     // = each form's default (TTY: current; pipe: all, today's bytes).
     let listScope;
     let reverseManifest;
+    // DC-60: `kiso sessions --prune-empty [--yes]` — list the sessions that
+    // never began; with --yes, move them to the Trash
+    let pruneEmpty;
     if (args[0] === "sessions") {
+        const pe = args.indexOf("--prune-empty");
+        if (pe !== -1) {
+            args.splice(pe, 1);
+            const yes = args.indexOf("--yes");
+            if (yes !== -1)
+                args.splice(yes, 1);
+            pruneEmpty = yes !== -1 ? "move" : "list";
+        }
         // 0.40.0: the undo of the per-project move, named by its manifest
         const r = args.indexOf("--reverse-migration");
         if (r !== -1) {
@@ -1890,6 +1916,25 @@ async function main() {
                 // "reading 'question'" on the dock-less branch). The input
                 // exists so the gate's ask can be answered; the listing
                 // itself never touches it.
+                if (pruneEmpty !== undefined) {
+                    // DC-60: before makeAgent — the scan only reads, and nothing
+                    // needs an agent to move a file to the Trash
+                    const { empty, inUse } = findEmptySessions(listingFolders().map((f) => f.dir));
+                    const n = (k, w) => `${k} ${w}${k === 1 ? "" : "s"}`;
+                    if (empty.length === 0)
+                        console.log("no empty sessions");
+                    else if (pruneEmpty === "list") {
+                        console.log(`${n(empty.length, "empty session")} — a sidecar and no log; none of them ever ran:`);
+                        for (const s of empty)
+                            console.log(`  ${basename(s.dir)}/${s.id}`);
+                        console.log("kiso sessions --prune-empty --yes moves them to the Trash");
+                    }
+                    else
+                        console.log(`moved ${n(empty.length, "empty session")} to ${moveToTrash(empty, defaultTrashRoot())}`);
+                    if (inUse > 0)
+                        console.log(`skipped ${n(inUse, "empty session")} in use — a live process holds the lock`);
+                    break;
+                }
                 if (reverseManifest !== undefined) {
                     // before makeAgent: its folder preparation would otherwise run
                     // the very move this undoes

package/dist/learned-windows.d.ts

@@ -0,0 +1,23 @@
+export interface LearnedWindow {
+    readonly tokens: number;
+    /** the day the refusal was read, YYYY-MM-DD */
+    readonly observedAt: string;
+}
+export declare function learnedWindowsPath(home?: string): string;
+/** The key for one model at one endpoint; no baseUrl is the provider's own. */
+export declare function learnedKey(model: string, baseUrl: string | undefined): string;
+/** Startup: read the file and keep figures learned from here on in it.
+ *  Until this is called, nothing is read and nothing is kept. */
+export declare function useLearnedWindows(path?: string): void;
+/** The learned window for a model at an endpoint, if a refusal stated one. */
+export declare function learnedWindowFor(model: string, baseUrl: string | undefined): LearnedWindow | undefined;
+/**
+ * Keep a refusal's cap. Returns true when it changed what is kept (a new
+ * key, or a smaller figure), false when a figure at or below it is kept
+ * already — or when no file was named (`useLearnedWindows`). The file is
+ * re-read before the write, so a figure another process learned meanwhile
+ * is not lost.
+ */
+export declare function recordLearnedWindow(model: string, baseUrl: string | undefined, tokens: number, today?: Date): boolean;
+/** Tests: back to the state before startup — nothing read, nothing kept. */
+export declare function resetLearnedWindows(): void;

package/dist/learned-windows.js

@@ -0,0 +1,100 @@
+/**
+ * CW-1 batch 2 — the windows endpoints have STATED by refusing a request,
+ * kept across sessions in `<KISO_HOME>/learned-windows.json`.
+ *
+ * A refusal like "maximum context length is 1048576 tokens" is the one
+ * window source that is right for any route, relays included (the runtime
+ * reads it: window-learner.ts). The runtime's tiers take it at once; this
+ * file keeps it, so the next session starts on the real figure instead of
+ * meeting the wall again. It sits in the window chain after what the user
+ * set and before the registry: a measurement of this endpoint beats a
+ * statement about the model.
+ *
+ * Keyed by the endpoint (the baseUrl, trailing slashes dropped — a
+ * forwarder can send two paths to two upstreams) and the model id. A
+ * figure only ever goes DOWN for a key: a later, larger refusal cannot
+ * widen what a route already refused. The file is private (0600, tmp +
+ * rename); a missing or unreadable file is an empty one — the chain falls
+ * through to the registry, as it did before anything was learned.
+ *
+ * Nothing is read until the CLI's startup names the file
+ * (`useLearnedWindows`): the window chain is library code that in-process
+ * tests call, and a chain that read `~/.kiso` on its own would make their
+ * verdict depend on the machine they run on.
+ */
+import { mkdirSync, readFileSync, renameSync, writeFileSync } from "node:fs";
+import { dirname, join } from "node:path";
+import { kisoHome } from "./state.js";
+let table = null;
+let tablePath = null;
+export function learnedWindowsPath(home = kisoHome()) {
+    return join(home, "learned-windows.json");
+}
+/** The key for one model at one endpoint; no baseUrl is the provider's own. */
+export function learnedKey(model, baseUrl) {
+    return `${baseUrl === undefined ? "-" : baseUrl.replace(/\/+$/, "")} ${model}`;
+}
+function read(path) {
+    try {
+        const parsed = JSON.parse(readFileSync(path, "utf8"));
+        if (typeof parsed !== "object" || parsed === null || Array.isArray(parsed))
+            return {};
+        const out = {};
+        for (const [k, v] of Object.entries(parsed)) {
+            const w = v;
+            if (w !== null && typeof w === "object" && typeof w.tokens === "number" && Number.isSafeInteger(w.tokens) && w.tokens > 0 && typeof w.observedAt === "string") {
+                out[k] = { tokens: w.tokens, observedAt: w.observedAt };
+            }
+        }
+        return out;
+    }
+    catch {
+        return {};
+    }
+}
+/** Startup: read the file and keep figures learned from here on in it.
+ *  Until this is called, nothing is read and nothing is kept. */
+export function useLearnedWindows(path = learnedWindowsPath()) {
+    tablePath = path;
+    table = read(path);
+}
+/** The learned window for a model at an endpoint, if a refusal stated one. */
+export function learnedWindowFor(model, baseUrl) {
+    return table === null ? undefined : table[learnedKey(model, baseUrl)];
+}
+/**
+ * Keep a refusal's cap. Returns true when it changed what is kept (a new
+ * key, or a smaller figure), false when a figure at or below it is kept
+ * already — or when no file was named (`useLearnedWindows`). The file is
+ * re-read before the write, so a figure another process learned meanwhile
+ * is not lost.
+ */
+export function recordLearnedWindow(model, baseUrl, tokens, today = new Date()) {
+    const path = tablePath;
+    if (path === null)
+        return false;
+    const key = learnedKey(model, baseUrl);
+    const current = read(path);
+    const held = current[key];
+    if (held !== undefined && held.tokens <= tokens) {
+        table = current;
+        return false;
+    }
+    const next = { ...current, [key]: { tokens, observedAt: today.toISOString().slice(0, 10) } };
+    table = next;
+    try {
+        mkdirSync(dirname(path), { recursive: true });
+        const tmp = `${path}.${process.pid}.tmp`;
+        writeFileSync(tmp, `${JSON.stringify(next, null, 2)}\n`, { mode: 0o600 });
+        renameSync(tmp, path);
+    }
+    catch {
+        // unwritable home: the figure still holds for this process
+    }
+    return true;
+}
+/** Tests: back to the state before startup — nothing read, nothing kept. */
+export function resetLearnedWindows() {
+    table = null;
+    tablePath = null;
+}

package/dist/provider-label.d.ts

@@ -24,9 +24,14 @@
 export declare function providerHost(baseUrl?: string): string | null;
 /** `@commandcode.ai` — the provider named beside a model. `""` when the
  *  binding names no endpoint (the provider's own default origin), so a row
- *  that has nothing to say does not print a stray `@`. */
-export declare function providerLabel(baseUrl?: string): string;
+ *  that has nothing to say does not print a stray `@`.
+ *
+ *  With an `upstream` (a profile whose baseUrl is a local forwarder), the
+ *  label names who is billed FIRST and where the bytes go second:
+ *  `@gateway.example via 127.0.0.1:47821`. A name that is not a URL is shown as
+ *  written. */
+export declare function providerLabel(baseUrl?: string, upstream?: string): string;
 /** The same label for a PROFILE, which knows its kind as well as its URL: a
  *  profile with no baseUrl (a first-party provider) still names itself by
  *  providerId, because a row that shows two profiles must tell them apart. */
-export declare function profileProviderLabel(kind: string, baseUrl?: string): string;
+export declare function profileProviderLabel(kind: string, baseUrl?: string, upstream?: string): string;

package/dist/provider-label.js

@@ -40,14 +40,22 @@ export function providerHost(baseUrl) {
 }
 /** `@commandcode.ai` — the provider named beside a model. `""` when the
  *  binding names no endpoint (the provider's own default origin), so a row
- *  that has nothing to say does not print a stray `@`. */
-export function providerLabel(baseUrl) {
+ *  that has nothing to say does not print a stray `@`.
+ *
+ *  With an `upstream` (a profile whose baseUrl is a local forwarder), the
+ *  label names who is billed FIRST and where the bytes go second:
+ *  `@gateway.example via 127.0.0.1:47821`. A name that is not a URL is shown as
+ *  written. */
+export function providerLabel(baseUrl, upstream) {
     const host = providerHost(baseUrl);
+    const up = upstream === undefined || upstream.trim() === "" ? null : (providerHost(upstream) ?? upstream.trim());
+    if (up !== null)
+        return host === null || host === up ? `@${up}` : `@${up} via ${host}`;
     return host === null ? "" : `@${host}`;
 }
 /** The same label for a PROFILE, which knows its kind as well as its URL: a
  *  profile with no baseUrl (a first-party provider) still names itself by
  *  providerId, because a row that shows two profiles must tell them apart. */
-export function profileProviderLabel(kind, baseUrl) {
-    return providerLabel(baseUrl) || `@${providerIdOf(kind, baseUrl)}`;
+export function profileProviderLabel(kind, baseUrl, upstream) {
+    return providerLabel(baseUrl, upstream) || `@${providerIdOf(kind, baseUrl)}`;
 }

package/dist/state.d.ts

@@ -253,6 +253,10 @@ export declare function setConfiguredWindow(value: number | undefined): void;
  *  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;
+/** CW-1: the upstream a forwarder at `baseUrl` names — a fact about the
+ *  ADDRESS, so a resumed session (no profile name in hand) finds it too:
+ *  the first profile at that address that names one. */
+export declare function upstreamOf(baseUrl: string | undefined): string | undefined;
 /** The name of the model currently driving the session ("faux" or the
  *  profile name / provider/model write / env model). */
 /**

package/dist/state.js

@@ -342,6 +342,17 @@ export let configModels = {};
 export function setConfigModels(models) {
     configModels = models;
 }
+/** CW-1: the upstream a forwarder at `baseUrl` names — a fact about the
+ *  ADDRESS, so a resumed session (no profile name in hand) finds it too:
+ *  the first profile at that address that names one. */
+export function upstreamOf(baseUrl) {
+    if (baseUrl === undefined)
+        return undefined;
+    for (const p of Object.values(configModels))
+        if (p.baseUrl === baseUrl && p.upstream !== undefined)
+            return p.upstream;
+    return undefined;
+}
 /** The name of the model currently driving the session ("faux" or the
  *  profile name / provider/model write / env model). */
 /**

package/package.json

@@ -1,6 +1,6 @@
 {
 	"name": "@vincemakes/kiso-code",
-	"version": "0.40.2",
+	"version": "0.40.3",
 	"description": "kiso-code \u2014 the coding agent on kiso, the durable runtime for AI agents: kiso chat / kiso resume / kiso sessions.",
 	"type": "module",
 	"license": "MIT",
@@ -18,20 +18,20 @@
 		"test": "vitest run"
 	},
 	"dependencies": {
-		"@vincemakes/kiso-ask-ext": "0.40.2",
-		"@vincemakes/kiso-core": "0.40.2",
-		"@vincemakes/kiso-evals": "0.40.2",
-		"@vincemakes/kiso-mcp-ext": "0.40.2",
-		"@vincemakes/kiso-provider-anthropic": "0.40.2",
-		"@vincemakes/kiso-provider-openai": "0.40.2",
-		"@vincemakes/kiso-provider-openai-responses": "0.40.2",
-		"@vincemakes/kiso-runtime": "0.40.2",
-		"@vincemakes/kiso-skills-ext": "0.40.2",
-		"@vincemakes/kiso-subagent-ext": "0.40.2",
-		"@vincemakes/kiso-task-ext": "0.40.2",
-		"@vincemakes/kiso-tools-node": "0.40.2",
-		"@vincemakes/kiso-tui": "0.40.2",
-		"@vincemakes/kiso-tui-cells": "0.40.2"
+		"@vincemakes/kiso-ask-ext": "0.40.3",
+		"@vincemakes/kiso-core": "0.40.3",
+		"@vincemakes/kiso-evals": "0.40.3",
+		"@vincemakes/kiso-mcp-ext": "0.40.3",
+		"@vincemakes/kiso-provider-anthropic": "0.40.3",
+		"@vincemakes/kiso-provider-openai": "0.40.3",
+		"@vincemakes/kiso-provider-openai-responses": "0.40.3",
+		"@vincemakes/kiso-runtime": "0.40.3",
+		"@vincemakes/kiso-skills-ext": "0.40.3",
+		"@vincemakes/kiso-subagent-ext": "0.40.3",
+		"@vincemakes/kiso-task-ext": "0.40.3",
+		"@vincemakes/kiso-tools-node": "0.40.3",
+		"@vincemakes/kiso-tui": "0.40.3",
+		"@vincemakes/kiso-tui-cells": "0.40.3"
 	},
 	"devDependencies": {
 		"@types/node": "^26.1.2",