@vincemakes/kiso-runtime 0.40.1 → 0.40.3

package/dist/aborted-calls.d.ts

@@ -0,0 +1,18 @@
+import type { StoreRecord } from "./store.js";
+export interface UnansweredCall {
+    /** The run that owns the call — the repair rides it, so no new open run appears. */
+    readonly runId: string;
+    readonly callId: string;
+    /** The call's own seq (its invocation). */
+    readonly invocationSeq: number;
+}
+/** The result a repaired call receives — the kernel's own words for an
+ *  abort that lands after the started event. */
+export declare const ABORTED_BEFORE_EXECUTION = "aborted before execution";
+/**
+ * Every committed `tool_call_end` with neither a started event nor a
+ * result, in a run whose terminal is `aborted`. Committed: a `stop` follows
+ * the call inside its turn. Voided model output (a `model_output_abandoned`
+ * range) is not a call at all.
+ */
+export declare function unansweredAbortedCalls(records: readonly StoreRecord[]): UnansweredCall[];

package/dist/aborted-calls.js

@@ -0,0 +1,57 @@
+/** The result a repaired call receives — the kernel's own words for an
+ *  abort that lands after the started event. */
+export const ABORTED_BEFORE_EXECUTION = "aborted before execution";
+/**
+ * Every committed `tool_call_end` with neither a started event nor a
+ * result, in a run whose terminal is `aborted`. Committed: a `stop` follows
+ * the call inside its turn. Voided model output (a `model_output_abandoned`
+ * range) is not a call at all.
+ */
+export function unansweredAbortedCalls(records) {
+    const byRun = new Map();
+    for (const r of records) {
+        const events = byRun.get(r.runId) ?? [];
+        events.push(r.event);
+        byRun.set(r.runId, events);
+    }
+    // Answered = a started event or a result for THIS invocation. Both carry
+    // invocationSeq today; a legacy result without it answers the latest
+    // earlier call with its callId (providers may reuse a callId across turns).
+    const answeredSeqs = new Set();
+    const legacy = [];
+    for (const r of records) {
+        const e = r.event;
+        if (e.type !== "tool_result" && e.type !== "tool_execution_started")
+            continue;
+        const invocationSeq = e.invocationSeq;
+        if (invocationSeq !== undefined)
+            answeredSeqs.add(invocationSeq);
+        else
+            legacy.push({ callId: e.callId, seq: e.seq });
+    }
+    const answered = (call) => answeredSeqs.has(call.seq) || legacy.some((l) => l.callId === call.callId && l.seq > call.seq);
+    const out = [];
+    for (const [runId, events] of byRun) {
+        const terminal = events.find((e) => e.type === "terminal");
+        if (terminal === undefined || terminal.type !== "terminal" || terminal.outcome.kind !== "aborted")
+            continue;
+        const voided = events.flatMap((e) => (e.type === "model_output_abandoned" ? [{ from: e.voidFromSeq, to: e.seq }] : []));
+        let turn = [];
+        for (const e of events) {
+            // an abandoned draft's calls and stop are model output that never was
+            if ((e.type === "tool_call_end" || e.type === "stop") && voided.some((v) => e.seq > v.from && e.seq <= v.to))
+                continue;
+            if (e.type === "tool_call_end")
+                turn.push(e);
+            else if (e.type === "stop") {
+                for (const call of turn)
+                    if (!answered(call))
+                        out.push({ runId, callId: call.callId, invocationSeq: call.seq });
+                turn = [];
+            }
+            else if (e.type === "user_input" || e.type === "terminal")
+                turn = [];
+        }
+    }
+    return out;
+}

package/dist/agent.js

@@ -87,6 +87,7 @@ export class AgentRuntime {
         });
         let restored = null;
         let profilePending = false;
+        let newSession = null;
         let driftAcknowledgement = null;
         if (meta.kind === "ok") {
             const drift = assessProfileDrift(meta.profile, {
@@ -134,8 +135,10 @@ export class AgentRuntime {
             }
         }
         else if (log.all.length === 0) {
-            // a NEW session: revision 1 lands BEFORE any durable event.
-            writeProfile(store.root, options.id, { ...candidate, revision: 1 });
+            // a NEW session. DC-60: nothing of it reaches the disk before its
+            // first durable event — revision 1 (with the workspace it opened in)
+            // lands WITH that event, still before it (session.ts persist).
+            newSession = { workspace: candidate.workspace };
         }
         else {
             // legacy (pre-XP log, no sidecar): generation absence is not
@@ -154,6 +157,7 @@ export class AgentRuntime {
                 : {}),
             ...(restored !== null ? { reasoning: restored.reasoning } : {}),
             ...(profilePending ? { profilePending: true } : {}),
+            ...(newSession !== null ? { newSession } : {}),
             ...(this.#definition.profileName !== undefined ? { profileName: this.#definition.profileName } : {}),
             ...(driftAcknowledgement !== null ? { driftAcknowledgement } : {}),
             ...(this.#definition.systemPrompt !== undefined ? { systemPrompt: this.#definition.systemPrompt } : {}),

package/dist/compaction-policy.d.ts

@@ -23,6 +23,17 @@ export interface Tiers {
     readonly emergency: number;
     readonly tail: number;
 }
+/** ADR-0055 Amendment 2 (decision 4): the output an endpoint may grant when
+ *  neither kiso nor the registry states one. kiso sends no `max_tokens`
+ *  where it sends none today, so the endpoint's own default applies — and
+ *  the one default observed is 131,072 (the op gateway's refusal on
+ *  2026-09-22: "you requested 131072 output tokens" with no max_tokens
+ *  sent). Reserving 32K there put the emergency tier 99K too high. */
+export declare const UNKNOWN_MAX_OUTPUT = 131072;
+/** The emergency reserve: what the request asks for when kiso sends a
+ *  `max_tokens`, else the registry's max output for the served endpoint,
+ *  else UNKNOWN_MAX_OUTPUT — never below the summary budget. */
+export declare function outputReserve(maxTokens: number | undefined, registryMaxOutput: number | null | undefined, floor: number): number;
 export declare function tiersFor(windowTokens: number, reserve: number): Tiers;
 /**
  * A1 — which tier a measured context is past, the most urgent first; the

package/dist/compaction-policy.js

@@ -11,6 +11,19 @@
  */
 import { DO_NOT_COMPACT, MICROCOMPACTABLE } from "@vincemakes/kiso-core";
 import { estimateEventTokens } from "./summarize.js";
+/** ADR-0055 Amendment 2 (decision 4): the output an endpoint may grant when
+ *  neither kiso nor the registry states one. kiso sends no `max_tokens`
+ *  where it sends none today, so the endpoint's own default applies — and
+ *  the one default observed is 131,072 (the op gateway's refusal on
+ *  2026-09-22: "you requested 131072 output tokens" with no max_tokens
+ *  sent). Reserving 32K there put the emergency tier 99K too high. */
+export const UNKNOWN_MAX_OUTPUT = 131_072;
+/** The emergency reserve: what the request asks for when kiso sends a
+ *  `max_tokens`, else the registry's max output for the served endpoint,
+ *  else UNKNOWN_MAX_OUTPUT — never below the summary budget. */
+export function outputReserve(maxTokens, registryMaxOutput, floor) {
+    return Math.max(maxTokens ?? registryMaxOutput ?? UNKNOWN_MAX_OUTPUT, floor);
+}
 export function tiersFor(windowTokens, reserve) {
     return {
         soft: Math.min(0.5 * windowTokens, 400_000),

package/dist/overflow-belt.d.ts

@@ -0,0 +1,34 @@
+/**
+ * ADR-0055 Amendment 2 (decision 3) — the overflow belt: a runtime adapter
+ * wrapper, beside the idle and truncation guards.
+ *
+ * WHY: d7aa's last request carried an anchored 1,047,981 tokens to a model
+ * whose window is 1,048,576. The gateway answered `500 Internal server
+ * error` — no text a classifier could read — and the kernel, told a 5xx is
+ * retryable, re-sent a request that could not fit ten times: the twelve-
+ * minute freeze. kiso already KNEW the request could not fit. This belt
+ * says so: when a request is sent with the anchored context at or above
+ * the stated window minus the output reserve, any provider error it meets
+ * is `context_overflow`, not retryable, and the kernel's one compaction and
+ * one retry take over.
+ *
+ * It is a belt, not the cure — the cure is that the context never gets
+ * there (decisions 1, 2 and 4). Below the limit nothing changes: a bare
+ * 5xx keeps its retries. The limit is measured ONCE, at send time, from a
+ * STATED window only; the caller's `measure` returns null when no window is
+ * stated (the 200K policy fallback never arms it — keyed on the fallback, a
+ * session at 170K on a real 1M model would lose its retries to every
+ * transient 5xx) or when no bill anchors the context.
+ *
+ * A caller's abort passes through untouched: it is not the provider's error.
+ */
+import type { Adapter } from "@vincemakes/kiso-core";
+export interface OverflowMeasure {
+    /** The anchored context the request carries (the last bill + what was appended since). */
+    readonly used: number;
+    /** The stated window. */
+    readonly window: number;
+    /** The output the endpoint may grant (compaction-policy.ts outputReserve). */
+    readonly reserve: number;
+}
+export declare function overflowBelt(adapter: Adapter, measure: () => OverflowMeasure | null): Adapter;

package/dist/overflow-belt.js

@@ -0,0 +1,28 @@
+export function overflowBelt(adapter, measure) {
+    return {
+        stream: (options) => {
+            const m = measure();
+            if (m === null || m.used < m.window - m.reserve)
+                return adapter.stream(options);
+            return belted(adapter, options, m);
+        },
+    };
+}
+async function* belted(adapter, options, m) {
+    try {
+        yield* adapter.stream(options);
+    }
+    catch (err) {
+        if (options.signal?.aborted === true || !isStructured(err))
+            throw err;
+        throw {
+            ...err,
+            code: "context_overflow",
+            retryable: false,
+            message: `${err.message} — the request carried ~${m.used} tokens against a stated ${m.window}-token window less a ${m.reserve}-token output reserve; it could not fit, so it is not retried`,
+        };
+    }
+}
+function isStructured(err) {
+    return err !== null && typeof err === "object" && typeof err.code === "string" && typeof err.message === "string";
+}

package/dist/provider/metadata.d.ts

@@ -126,6 +126,48 @@ export interface ModelMetadataEntry {
  * one matches any endpoint. Unknown model → null, never a default.
  */
 export declare function lookupModelMetadata(model: string, endpoint?: string): ModelMetadataEntry | null;
+/** CW-1: the aliases, for the gate that holds each one to a dated source
+ *  and a registered target. */
+export declare function modelAliases(): Readonly<Record<string, {
+    readonly is: string;
+    readonly asOf: string;
+    readonly source: string;
+}>>;
+/** CW-1: a model id reduced to the weights it names — `deepseek/DeepSeek-V4.1-Flash`
+ *  and `deepseek-v4.1-flash` are both `deepseek-flash`. A variant suffix
+ *  (`:free`) is NOT folded: a variant may serve a smaller window. */
+export declare function modelIdentity(model: string): string;
+/** Where a resolved window came from — the source a display names. */
+export type ContextWindowSource = "route" | "upstream" | "model";
+export interface ResolvedContextWindow {
+    readonly tokens: number;
+    readonly source: ContextWindowSource;
+    /** the registry row's model id the figure was read from */
+    readonly from: string;
+}
+/**
+ * CW-1 (owner, 2026-09-23) — the context window for a route the registry
+ * has no row for.
+ *
+ * Rows are keyed by (model, endpoint) because a route can answer
+ * differently from the vendor — gpt-5.5 is 1,050,000 at the first-party
+ * API and 272,000 at the subscription backend. The same key made every
+ * forwarder, relay and gateway a miss: `deepseek-v4.1-flash` behind a local
+ * forwarder to a model gateway read `ctx ?`, and the tiers compacted a 1M model
+ * against the CLI's 200K fallback. A window belongs to the weights; a
+ * route can only cap it lower. In order:
+ *
+ *   route    — this model's row at this endpoint (lookupModelMetadata);
+ *   upstream — its row at the endpoint a forwarder names as its upstream;
+ *   model    — every row of the same model identity, at any endpoint;
+ *              where rows disagree, the SMALLEST — the one figure no row
+ *              contradicts.
+ *
+ * A null window falls through; after the last step, null. Only the window
+ * resolves this way: price, reasoning wire fields and max output are
+ * facts about a route and stay on lookupModelMetadata.
+ */
+export declare function lookupContextWindow(model: string, endpoint?: string, upstream?: string): ResolvedContextWindow | null;
 /**
  * XP-1 §4.2 — native-only resolution. The rules, in order:
  *   default/default → NO wire fields (the byte-identity anchor — a

package/dist/provider/metadata.js

@@ -455,6 +455,70 @@ export function lookupModelMetadata(model, endpoint) {
     }
     return null;
 }
+/**
+ * CW-1 — names one set of weights answers to across routes, each a dated
+ * vendor statement. The key is the FOLDED name a route serves (vendor
+ * prefix off, lower case); the value names the registry row.
+ */
+const MODEL_ALIASES = {
+    // The pricing table: `deepseek-flash` IS DeepSeek-V4.1-Flash. Gateways
+    // serve it by the version name (`deepseek-v4.1-flash`).
+    "deepseek-v4.1-flash": { is: "deepseek-flash", asOf: "2026-09-17", source: "https://api-docs.deepseek.com/quick_start/pricing/" },
+};
+/** CW-1: the aliases, for the gate that holds each one to a dated source
+ *  and a registered target. */
+export function modelAliases() {
+    return MODEL_ALIASES;
+}
+/** CW-1: a model id reduced to the weights it names — `deepseek/DeepSeek-V4.1-Flash`
+ *  and `deepseek-v4.1-flash` are both `deepseek-flash`. A variant suffix
+ *  (`:free`) is NOT folded: a variant may serve a smaller window. */
+export function modelIdentity(model) {
+    const folded = model.slice(model.lastIndexOf("/") + 1).toLowerCase();
+    return MODEL_ALIASES[folded]?.is ?? folded;
+}
+/**
+ * CW-1 (owner, 2026-09-23) — the context window for a route the registry
+ * has no row for.
+ *
+ * Rows are keyed by (model, endpoint) because a route can answer
+ * differently from the vendor — gpt-5.5 is 1,050,000 at the first-party
+ * API and 272,000 at the subscription backend. The same key made every
+ * forwarder, relay and gateway a miss: `deepseek-v4.1-flash` behind a local
+ * forwarder to a model gateway read `ctx ?`, and the tiers compacted a 1M model
+ * against the CLI's 200K fallback. A window belongs to the weights; a
+ * route can only cap it lower. In order:
+ *
+ *   route    — this model's row at this endpoint (lookupModelMetadata);
+ *   upstream — its row at the endpoint a forwarder names as its upstream;
+ *   model    — every row of the same model identity, at any endpoint;
+ *              where rows disagree, the SMALLEST — the one figure no row
+ *              contradicts.
+ *
+ * A null window falls through; after the last step, null. Only the window
+ * resolves this way: price, reasoning wire fields and max output are
+ * facts about a route and stay on lookupModelMetadata.
+ */
+export function lookupContextWindow(model, endpoint, upstream) {
+    const route = lookupModelMetadata(model, endpoint);
+    if (route !== null && route.capabilities.contextWindow !== null)
+        return { tokens: route.capabilities.contextWindow, source: "route", from: route.model };
+    if (upstream !== undefined) {
+        const up = lookupModelMetadata(model, upstream);
+        if (up !== null && up.capabilities.contextWindow !== null)
+            return { tokens: up.capabilities.contextWindow, source: "upstream", from: up.model };
+    }
+    const identity = modelIdentity(model);
+    let found = null;
+    for (const entry of ENTRIES) {
+        const tokens = entry.capabilities.contextWindow;
+        if (tokens === null || modelIdentity(entry.model) !== identity)
+            continue;
+        if (found === null || tokens < found.tokens)
+            found = { tokens, source: "model", from: entry.model };
+    }
+    return found;
+}
 function originOf(endpoint) {
     try {
         return new URL(endpoint).origin;

package/dist/run.js

@@ -9,6 +9,7 @@ import { resolveReasoning } from "./provider/metadata.js";
 import { deriveRecoveryPlan, invocationSeqOf } from "./recovery-plan.js";
 import { composeApprovalChain, composeSystemPrompt, runBasePrompt } from "./compose.js";
 import { truncationGuard } from "./truncation-guard.js";
+import { overflowBelt } from "./overflow-belt.js";
 import { DEFAULT_STREAM_IDLE_MS, idleGuard } from "./idle-guard.js";
 import { RequestTracer, traceGuard } from "./trace/guard.js";
 import { runtimeVersion } from "./trace/writer.js";
@@ -72,6 +73,11 @@ export class Run {
             // here, before any log or disk mutation.
             this.#session.ensureHealthy();
             this.#session.beginRun(this);
+            // DC-60: a resume of a session with no durable event has nothing to
+            // recover — and writes nothing (no trace header, no summary row) for
+            // a session that never began. The CLI runs one at every start.
+            if (this.#resume && this.#session.log.all.length === 0)
+                return;
             const log = this.#session.log;
             // The static prompt parts — computed ONCE, before the tracer, and
             // reused for both the composed string (below) and the rent ledger
@@ -145,7 +151,10 @@ export class Run {
                 // LT-1: the idle guard sits closest to the adapter — a stall is
                 // aborted and thrown there, the truncation guard and the tracer see
                 // the same events and the same error every other transport failure shows them.
-                adapter: traceGuard(tracer, truncationGuard(idleGuard(this.#adapter, this.#config.streamIdleMs ?? DEFAULT_STREAM_IDLE_MS))), // tracer assigned above, before loopConfig
+                // ADR-0055 Amendment 2 (decision 3): the overflow belt sits outside
+                // the guards, so a stall or a cut on a request known not to fit is
+                // classified as the overflow it is, and the tracer records that.
+                adapter: traceGuard(tracer, overflowBelt(truncationGuard(idleGuard(this.#adapter, this.#config.streamIdleMs ?? DEFAULT_STREAM_IDLE_MS)), () => this.#session.overflowMeasure())), // tracer assigned above, before loopConfig
                 model: this.#config.model,
                 sessionId: this.#session.id, // P3: tools see their session (ToolContext.sessionId)
                 ...(systemPrompt !== undefined ? { systemPrompt } : {}),
@@ -195,6 +204,9 @@ export class Run {
                 // dangling approvals closed (permission_expired) — a dead
                 // run's approval is never re-presented or resurrected.
                 const records = this.#store.load(this.#session.id);
+                // 0.40.2: a dead run's committed calls that never ran are answered
+                // before anything below projects the session into a request.
+                await this.#session.repairAbortedCalls(records);
                 const runs = new Map();
                 const order = [];
                 for (const r of records) {
@@ -267,10 +279,14 @@ export class Run {
             // persistence layer — a second open run would be permanently
             // orphaned (recovery only ever recovers the last one). The
             // open run is continued via resume(), never by starting another.
-            const openRun = openRunId(this.#store.load(this.#session.id));
+            const records = this.#store.load(this.#session.id);
+            const openRun = openRunId(records);
             if (openRun !== undefined) {
                 throw new Error(`session ${this.#session.id} still has an open run (${openRun}) — resume() it instead of starting a new run`);
             }
+            // 0.40.2: an aborted run's committed calls that never ran are
+            // answered before this run's first request projects them.
+            await this.#session.repairAbortedCalls(records);
             // E6 — the run-start context policy: BEFORE this run's
             // user_input lands, the policy may persist one `summarized`
             // fact through the existing summarize() path (the manual

package/dist/session.d.ts

@@ -28,10 +28,11 @@
  * same package, same exports (index.ts re-exports all four).
  */
 import { EventLog, type AbortSignalLike, type Adapter, type Event, type KisoExtension, type Message, type PermissionDecision, type Tool, type ToolSpec, type EventInput } from "@vincemakes/kiso-core";
+import { type OverflowMeasure } from "./overflow-belt.js";
 import { type TaskAssessment } from "./task-assessment.js";
 import { type ContinuationScope } from "@vincemakes/kiso-core";
 import { type ReasoningSetting } from "./provider/metadata.js";
-import { type SessionStore } from "./store.js";
+import { type SessionStore, type StoreRecord } from "./store.js";
 import { Run } from "./run.js";
 /** TUI2-R3v2 ③ — one off-trajectory model request (session.sideQuery).
  *  Deliberately tiny: a purpose to mark it in the trace, its own short
@@ -109,6 +110,16 @@ export declare class AgentSession {
      *  the cause (stale handle, corruption, a live external writer, an I/O
      *  fault) — so no further run, resume, or log mutation may proceed.
      *  The health check runs BEFORE every write, on every path. */
+    /**
+     * 0.40.2 — a committed call an aborted run left with no started and no
+     * result gets ONE durable result, "aborted before execution", riding the
+     * run that owns it (aborted-calls.ts). Every path that projects the
+     * session into a request calls this first — a run's start (fresh or
+     * resumed) and /compact — so no dangling tool_use reaches a provider,
+     * and the already-poisoned logs heal with no migration. Idempotent per
+     * invocation: a crash between two repairs leaves the rest for next time.
+     */
+    repairAbortedCalls(records: readonly StoreRecord[]): Promise<void>;
     persist(runId: string, event: Event): Promise<void>;
     beginRun(run: Run): void;
     endRun(run: Run): void;
@@ -208,6 +219,9 @@ export declare class AgentSession {
      * every open.
      */
     setMicrocompactThreshold(thresholdTokens: number): void;
+    /** ADR-0055 Amendment 2 (decision 3): the overflow belt's measure at send
+     *  time — null unless a window is STATED and a bill anchors the context. */
+    overflowMeasure(): OverflowMeasure | null;
     /** A1b: the window the in-run tiers are drawn from, for a restored or
      *  re-bound session (the CLI's one binding step calls both). */
     setContextWindow(windowTokens: number): void;
@@ -474,6 +488,27 @@ export interface ContextPolicy {
         readonly windowTokens: number;
         readonly isCheck?: (command: string) => boolean;
         readonly maxFailures?: number;
+        /** ADR-0055 Amendment 2: told when a checkpoint is discarded because it
+         *  did not shrink the context — chars/4 estimates only, never text. */
+        readonly onDiscard?: (info: {
+            readonly reason: string;
+            readonly pre: number;
+            readonly post: number;
+            readonly summary: number;
+        }) => void;
+        /** ADR-0055 Amendment 2 (decision 3): the window someone STATED for the
+         *  live binding, or null when the tiers run on a fallback. Absent, the
+         *  caller's own windowTokens counts as stated. Only a stated window
+         *  arms the overflow belt. */
+        readonly statedWindow?: () => number | null;
+        /** CW-1 batch 2: told when an endpoint's refusal states its cap — the
+         *  binding it was learned for rides along. The tiers have already
+         *  taken it (only ever down); the caller keeps it for later sessions. */
+        readonly onWindowLearned?: (learned: {
+            readonly tokens: number;
+            readonly model: string;
+            readonly baseUrl?: string;
+        }) => void;
     };
 }
 export interface SessionConfig {
@@ -494,6 +529,11 @@ export interface SessionConfig {
     readonly reasoning?: import("./provider/metadata.js").ReasoningSetting;
     /** XP-1 internal: a legacy session's deferred revision-1 write. */
     readonly profilePending?: true;
+    /** DC-60 internal: a NEW session — nothing is on disk yet; its revision 1
+     *  (with the workspace it opened in) lands with its first durable event. */
+    readonly newSession?: {
+        readonly workspace: string | null;
+    };
     /** 0.40.0: the config profile name in force — recorded per revision. */
     readonly profileName?: string;
     /** 0.40.0: set when this open acknowledged material drift. */

package/dist/session.js

@@ -27,8 +27,10 @@
  * support in recovery.ts, the E1/E2 composition helpers in compose.ts —
  * same package, same exports (index.ts re-exports all four).
  */
-import { EventLog, projectMessages, } from "@vincemakes/kiso-core";
+import { EventLog, projectMessages, SUMMARY_FRAMING, } from "@vincemakes/kiso-core";
 import { executionLedger } from "./ledger.js";
+import { overflowBelt } from "./overflow-belt.js";
+import { windowLearner } from "./window-learner.js";
 import { assessTasks } from "./task-assessment.js";
 /** TV-1A — the session-level evidence policy: the PURE projection defaults
  *  to ∅ (never inventing evidence); the session names the one built-in
@@ -47,7 +49,8 @@ import { estimateTokens } from "@vincemakes/kiso-core";
 import { StaleWriterError } from "./store.js";
 import { composeHooks, composeSystemPrompt, microcompactFor, runBasePrompt } from "./compose.js";
 import { checkpointBoundarySeq } from "./checkpoint.js";
-import { breakEvenFactor, guardedPruneSeq, KEEP_COMPACTABLE_RESULTS, microcompactBoundarySeq, phaseEnd, runsACheck, tierReason, tiersFor } from "./compaction-policy.js";
+import { ABORTED_BEFORE_EXECUTION, unansweredAbortedCalls } from "./aborted-calls.js";
+import { breakEvenFactor, guardedPruneSeq, KEEP_COMPACTABLE_RESULTS, microcompactBoundarySeq, outputReserve, phaseEnd, runsACheck, tierReason, tiersFor } from "./compaction-policy.js";
 import { Run } from "./run.js";
 // TUI2-R3v2 ③ — the side query rides the SAME tracer the runs ride; that
 // sameness is the whole point (one ledger, one shape, no second path).
@@ -124,6 +127,8 @@ export class AgentSession {
     // XP-1: a legacy session records revision 1 at the next explicit
     // selection or first request — never eagerly at open.
     #profilePending;
+    /** DC-60: set until a NEW session's first durable event lands. */
+    #newSession;
     /** 0.40.0: the config profile name of the live binding (configuration:
      *  each revision records the name in force when it is written). */
     #profileName;
@@ -197,6 +202,7 @@ export class AgentSession {
         // CTX-1: starts as the startup policy, then follows the binding.
         this.#microcompact = config.microcompact;
         this.#profilePending = config.profilePending === true;
+        this.#newSession = config.newSession;
         this.#profileName = config.profileName ?? null;
         this.driftAcknowledgement = config.driftAcknowledgement ?? null;
     }
@@ -221,9 +227,31 @@ export class AgentSession {
      *  the cause (stale handle, corruption, a live external writer, an I/O
      *  fault) — so no further run, resume, or log mutation may proceed.
      *  The health check runs BEFORE every write, on every path. */
+    /**
+     * 0.40.2 — a committed call an aborted run left with no started and no
+     * result gets ONE durable result, "aborted before execution", riding the
+     * run that owns it (aborted-calls.ts). Every path that projects the
+     * session into a request calls this first — a run's start (fresh or
+     * resumed) and /compact — so no dangling tool_use reaches a provider,
+     * and the already-poisoned logs heal with no migration. Idempotent per
+     * invocation: a crash between two repairs leaves the rest for next time.
+     */
+    async repairAbortedCalls(records) {
+        for (const c of unansweredAbortedCalls(records)) {
+            const ev = this.log.append({ type: "tool_result", callId: c.callId, invocationSeq: c.invocationSeq, content: ABORTED_BEFORE_EXECUTION, isError: true, errorKind: "precondition" });
+            await this.persist(c.runId, ev);
+        }
+    }
     async persist(runId, event) {
         this.ensureHealthy();
         try {
+            // DC-60: a NEW session's revision 1 lands with its first durable
+            // event and BEFORE it — a log line never exists without its profile.
+            if (this.#newSession !== undefined) {
+                const { workspace } = this.#newSession;
+                this.#newSession = undefined;
+                this.#writeProfileRevision(workspace);
+            }
             await this.#store.append(this.id, runId, event);
             if (event.type === "usage" && event.known)
                 this.#lastUsageAt = Date.now();
@@ -293,16 +321,20 @@ export class AgentSession {
                 return beforeSeq === undefined ? [] : [{ type: "microcompacted", beforeSeq }];
             }
             const window = this.#tiersWindow ?? tiersPolicy.windowTokens;
-            const maxOutput = this.#config.maxTokens ?? lookupModelMetadata(this.#model, this.#baseUrl)?.capabilities.maxOutputTokens ?? 0;
-            const t = tiersFor(window, Math.max(maxOutput, MANUAL_SUMMARY_BUDGET));
+            const t = tiersFor(window, this.#outputReserve());
             const isCheck = tiersPolicy.isCheck ?? ((command) => runsACheck(command));
             const reason = tierReason(used, t, why, () => phaseEnd(events, lastSummaryPoint(events), isCheck));
             if (reason === null)
                 return [];
             const urgent = reason === "overflow" || reason === "emergency";
-            if (!urgent && this.#summaryFailures >= (tiersPolicy.maxFailures ?? MAX_SUMMARY_FAILURES))
+            // ADR-0055 Amendment 2: the breaker stands at every tier but
+            // overflow (once per request by construction). An urgent tier that
+            // meets it skips the summary call and keeps the prune fallback — a
+            // session whose checkpoints cannot shrink it stops paying for them.
+            const breakerOpen = reason !== "overflow" && this.#summaryFailures >= (tiersPolicy.maxFailures ?? MAX_SUMMARY_FAILURES);
+            if (breakerOpen && !urgent)
                 return [];
-            const summarized = await this.#summarizeInRun(events, messages, t.tail, reason, run);
+            const summarized = breakerOpen ? null : await this.#summarizeInRun(events, messages, t.tail, reason, run, tiersPolicy.onDiscard);
             if (summarized !== null)
                 return [summarized];
             if (!urgent)
@@ -321,8 +353,9 @@ export class AgentSession {
      * abort is never answered with the second call. Throws when both fail.
      */
     async #checkpointCall(args) {
+        const learned = this.#learning(this.#adapter);
         const common = {
-            adapter: this.#adapter,
+            adapter: learned,
             model: this.#model,
             maxOutputTokens: args.budget,
             ...(args.signal !== undefined ? { signal: args.signal } : {}),
@@ -333,7 +366,11 @@ export class AgentSession {
             ...(args.onProgress !== undefined ? { onProgress: args.onProgress } : {}),
         };
         try {
-            const result = await summarizeConversation({ ...common, messages: args.messages, inBand: args.inBand, ...(args.reasoning !== undefined ? { reasoning: args.reasoning } : {}) });
+            // The in-band call carries the run's whole context, so the overflow
+            // belt applies to it; the serialised fallback below is small, and
+            // its failures keep their own classification.
+            const inBandAdapter = overflowBelt(learned, () => this.overflowMeasure());
+            const result = await summarizeConversation({ ...common, adapter: inBandAdapter, messages: args.messages, inBand: args.inBand, ...(args.reasoning !== undefined ? { reasoning: args.reasoning } : {}) });
             return { result, path: "in-band" };
         }
         catch (err) {
@@ -353,7 +390,7 @@ export class AgentSession {
     /** A2 — one in-run summary: in-band first, the serialised form once on
      *  a rejection; null when neither produced a valid checkpoint. The
      *  summary call's usage and path ride the trace ledger, as /compact's do. */
-    async #summarizeInRun(events, messages, tail, reason, run) {
+    async #summarizeInRun(events, messages, tail, reason, run, onDiscard) {
         const boundary = checkpointBoundarySeq(events, { keepTokens: tail });
         if (boundary === undefined)
             return null;
@@ -375,20 +412,43 @@ export class AgentSession {
                 this.#summaryFailures += 1;
             return null;
         }
-        this.#summaryFailures = 0;
+        // ADR-0055 Amendment 2 (the shrink invariant): a fire is kept only if
+        // it removes at least what it writes — post ≤ pre − summary, all by
+        // the chars/4 estimate over the SAME projection (never the bill
+        // against an estimate). A checkpoint that fails it is discarded:
+        // nothing is appended, the run goes on as before, and the failure
+        // counts toward the breaker.
+        const fire = { type: "summarized", coversToSeq: boundary, summary: result.text };
+        const pre = estimateTokens(projectMessages(events));
+        const post = estimateTokens(projectMessages([...events, { ...fire, seq: (events.at(-1)?.seq ?? -1) + 1 }]));
+        const written = estimateTokens([{ role: "user", content: `${SUMMARY_FRAMING}\n\n${result.text}` }]);
+        const shrinks = pre - post >= written;
         // Every in-run fire is recorded — its reason and path are what the
-        // measurement counts — and its usage when the provider reported one.
+        // measurement counts — and its usage when the provider reported one;
+        // a discarded one too (it was paid for), marked so.
         {
             try {
                 const canonical = result.usage === null ? null : canonicalizeUsageForModel(this.#model, this.#baseUrl, this.#provider ?? "adapter", result.usage);
                 mkdirSync(join(this.#store.root, "traces"), { recursive: true, mode: 0o700 });
-                appendFileSync(join(this.#store.root, "traces", `${this.id}.jsonl`), `${JSON.stringify({ kind: "summary", canonical, reason, path })}\n`, { mode: 0o600 });
+                appendFileSync(join(this.#store.root, "traces", `${this.id}.jsonl`), `${JSON.stringify({ kind: "summary", canonical, reason, path, ...(shrinks ? {} : { discarded: "no-shrink" }) })}\n`, { mode: 0o600 });
             }
             catch (err) {
                 console.error(`[kiso] summary usage ledger degraded (${err instanceof Error ? err.message : String(err)}); the summary call's cost is not recorded`);
             }
         }
-        return { type: "summarized", coversToSeq: boundary, summary: result.text };
+        if (!shrinks) {
+            this.#summaryFailures += 1;
+            // sizes only — the checkpoint's text is the owner's work
+            try {
+                onDiscard?.({ reason, pre, post, summary: written });
+            }
+            catch {
+                // observation only — a notice that cannot be shown changes nothing
+            }
+            return null;
+        }
+        this.#summaryFailures = 0;
+        return fire;
     }
     /**
      * merge round B (/model): replace the adapter for SUBSEQUENT runs. The
@@ -451,6 +511,41 @@ export class AgentSession {
     setMicrocompactThreshold(thresholdTokens) {
         this.#microcompact = { thresholdTokens };
     }
+    /** CW-1 batch 2: the adapter as a run or a summary uses it — a refusal
+     *  that states a cap is learned for the binding in force NOW, the one
+     *  this adapter belongs to (a /model mid-run must not receive it). */
+    #learning(adapter) {
+        const at = { model: this.#model, baseUrl: this.#baseUrl };
+        return windowLearner(adapter, (tokens) => this.#learnWindow(tokens, at));
+    }
+    /** CW-1 batch 2: a route stated its cap. The in-run tiers take it at once
+     *  — the kernel's one overflow compaction runs next and must aim at the
+     *  real window, not past it — and only ever DOWN; the caller is told, to
+     *  keep it for the next session and to say so. */
+    #learnWindow(tokens, at) {
+        const tiers = this.#config.contextPolicy?.tiers;
+        if (at.model === this.#model && at.baseUrl === this.#baseUrl) {
+            const current = this.#tiersWindow ?? tiers?.windowTokens;
+            if (current === undefined || tokens < current)
+                this.#tiersWindow = tokens;
+        }
+        tiers?.onWindowLearned?.({ tokens, model: at.model, ...(at.baseUrl !== undefined ? { baseUrl: at.baseUrl } : {}) });
+    }
+    /** ADR-0055 Amendment 2 (decision 3): the overflow belt's measure at send
+     *  time — null unless a window is STATED and a bill anchors the context. */
+    overflowMeasure() {
+        const tiers = this.#config.contextPolicy?.tiers;
+        if (tiers === undefined)
+            return null;
+        const window = tiers.statedWindow !== undefined ? tiers.statedWindow() : (this.#tiersWindow ?? tiers.windowTokens);
+        const used = this.contextAnchor();
+        return window === null || used === undefined ? null : { used, window, reserve: this.#outputReserve() };
+    }
+    /** ADR-0055 Amendment 2 (decision 4): the emergency reserve — what the
+     *  endpoint may grant for this binding (compaction-policy.ts). */
+    #outputReserve() {
+        return outputReserve(this.#config.maxTokens, lookupModelMetadata(this.#model, this.#baseUrl)?.capabilities.maxOutputTokens, MANUAL_SUMMARY_BUDGET);
+    }
     /** The raw tail a manual cut at a settled round keeps: the tiers' tail
      *  when a window is known, else the policy's keep floor. */
     #manualTailTokens() {
@@ -507,6 +602,10 @@ export class AgentSession {
      * recovery, projection or a request reads it.
      */
     recordSummary(open) {
+        // DC-60: a session with no durable event has no row — writing one made
+        // a session that never began appear in the list.
+        if (this.log.all.length === 0)
+            return;
         try {
             const prior = readProfile(this.#store.root, this.id);
             writeSummary(this.#store.root, this.id, summarizeEvents(this.log.all, {
@@ -522,8 +621,18 @@ export class AgentSession {
         }
     }
     /** XP-1: record the live binding as the next durable profile revision
-     *  (read-modify-write under the session's single-writer ownership). */
+     *  (read-modify-write under the session's single-writer ownership).
+     *  DC-60: a NEW session keeps the binding in memory until its first
+     *  durable event, which records it (persist). */
     #recordProfile() {
+        if (this.#newSession !== undefined)
+            return;
+        this.#writeProfileRevision(null);
+    }
+    /** The next profile revision from the live binding. `startWorkspace` is
+     *  the workspace a NEW session opened in; with no prior revision and no
+     *  start (a legacy session's first revision) the start is unknown: null. */
+    #writeProfileRevision(startWorkspace) {
         const prior = readProfile(this.#store.root, this.id);
         const revision = prior.kind === "ok" ? prior.profile.revision + 1 : 1;
         writeProfile(this.#store.root, this.id, buildProfile({
@@ -532,9 +641,9 @@ export class AgentSession {
             provider: this.#continuationScope ?? null,
             profileName: this.#profileName,
             // 0.40.0: history is CARRIED from the prior revision, never
-            // re-derived from this process. With no prior (a legacy
-            // session's first revision) the start is unknown: null.
-            workspace: prior.kind === "ok" ? prior.profile.workspace : null,
+            // re-derived from this process. With no prior, a NEW session's
+            // start is the workspace it opened in; a legacy one's is unknown.
+            workspace: prior.kind === "ok" ? prior.profile.workspace : startWorkspace,
             reasoning: this.#reasoning,
             ...(this.#config.systemPrompt !== undefined ? { systemPrompt: this.#config.systemPrompt } : {}),
             registry: this.#config.registry,
@@ -633,7 +742,7 @@ export class AgentSession {
         this.ensureHealthy();
         if (this.#profilePending)
             this.#recordProfile(); // XP-1: legacy revision 1, before the first request
-        return new Run(this.#store, this.#adapter, this.#effectiveConfig(), this, input, options?.signal, false, options?.source, options?.via);
+        return new Run(this.#store, this.#learning(this.#adapter), this.#effectiveConfig(), this, input, options?.signal, false, options?.source, options?.via);
     }
     /**
      * Continue the interrupted run (Area 2): apply durable decisions,
@@ -643,7 +752,7 @@ export class AgentSession {
      */
     resume() {
         this.ensureHealthy();
-        return new Run(this.#store, this.#adapter, this.#effectiveConfig(), this, undefined, undefined, true);
+        return new Run(this.#store, this.#learning(this.#adapter), this.#effectiveConfig(), this, undefined, undefined, true);
     }
     /**
      * /compact (ADR-0044): compress the older conversation with a model
@@ -675,6 +784,7 @@ export class AgentSession {
         const cancelled = () => new Error("the compaction was cancelled");
         if (options.signal !== undefined && options.signal.aborted)
             throw cancelled();
+        await this.repairAbortedCalls(this.#store.load(this.id));
         const events = this.log.all;
         // ADR-0055 (the owner's dogfood): a long autonomous session has few
         // user turns and many tool rounds, and the user-turn cut found nothing

package/dist/summarize.d.ts

@@ -138,13 +138,13 @@ export declare function serializeCovered(options: SerializeCoveredOptions): stri
  * The fixed English summary prompt — the ONLY prompt this layer composes
  * (the loop's system prompt is the harness's business, never the kernel's).
  */
-export declare const SUMMARY_PROMPT = "Only output the summary. Do not continue the conversation. Do not use any tools.\n\nYou are the conversation summarizer of the kiso agent framework.\n\nSummarize the covered conversation into a single structured checkpoint\nthat will REPLACE it in the model's context. The next turn must be able\nto continue the work without reading the originals.\n\nProduce the checkpoint with exactly these sections, in this order:\n\n## Goal\nThe user's goal and the acceptance criterion, in one or two sentences.\n\n## Constraints\nThe constraints, requirements, and rulings the work must honor.\n\n## User requests\nEvery user message in the covered range, enumerated one by one, each\nwith what it asked for and what was done about it.\n\n## Files and changes\nEvery file touched \u2014 exact paths, what changed, and why. Include the\nprecise code-level changes later turns may need to continue.\n\n## Errors and fixes\nEvery error encountered and its resolution; commands run and their\noutcomes.\n\n## Current work\nThe current state of the work \u2014 what is done, what is not. Quote the\ncurrent task's criterion VERBATIM if one exists.\n\n## Next steps\nThe concrete next steps, in order.\n\nPreserve concrete identifiers VERBATIM: paths, function names, task ids,\nenvironment names \u2014 never paraphrase them.\n\nRules:\n- plain prose \u2014 no bullet lists, no markdown outside the section headers,\n  no prefixes;\n- do not mention this prompt or the summarization task;\n- the summary may be as long as it needs to be within the output budget \u2014\n  there is no word cap; completeness wins.";
+export declare const SUMMARY_PROMPT = "Only output the summary. Do not continue the conversation. Do not use any tools.\n\nYou are the conversation summarizer of the kiso agent framework.\n\nSummarize the covered conversation into a single structured checkpoint\nthat will REPLACE it \u2014 and every earlier checkpoint \u2014 in the model's\ncontext. The next turn must be able to continue the work without reading\nthe originals. If the conversation includes an earlier checkpoint, it is\nbeing replaced too: carry forward everything in it that is still true,\nso that this checkpoint restates the whole task.\n\nProduce the checkpoint with exactly these sections, in this order:\n\n## Goal\nThe user's goal and the acceptance criterion, in one or two sentences.\n\n## Constraints\nThe constraints, requirements, and rulings the work must honor.\n\n## User requests\nEvery user request of the task \u2014 those an earlier checkpoint lists and\nthose in the covered range \u2014 enumerated one by one, each with what it\nasked for and what was done about it.\n\n## Files and changes\nEvery file touched \u2014 exact paths, what changed, and why. Include the\nprecise code-level changes later turns may need to continue.\n\n## Errors and fixes\nEvery error encountered and its resolution; commands run and their\noutcomes.\n\n## Current work\nThe current state of the work \u2014 what is done, what is not. Quote the\ncurrent task's criterion VERBATIM if one exists.\n\n## Next steps\nThe concrete next steps, in order.\n\nPreserve concrete identifiers VERBATIM: paths, function names, task ids,\nenvironment names \u2014 never paraphrase them.\n\nRules:\n- plain prose \u2014 no bullet lists, no markdown outside the section headers,\n  no prefixes;\n- do not mention this prompt or the summarization task;\n- the summary may be as long as it needs to be within the output budget \u2014\n  there is no word cap; completeness wins.";
 /**
  * ADR-0055 A2 — the IN-BAND form: the run's own request with this appended
  * as the last user message, so everything before it reads at the cache-hit
  * price. The same sections, the same validation; the guard sentence first.
  */
-export declare const SUMMARY_IN_BAND = "Stop the task for this one reply and write a checkpoint of the conversation above instead.\n\nOnly output the summary. Do not continue the conversation. Do not use any tools.\n\nYou are the conversation summarizer of the kiso agent framework.\n\nSummarize the covered conversation into a single structured checkpoint\nthat will REPLACE it in the model's context. The next turn must be able\nto continue the work without reading the originals.\n\nProduce the checkpoint with exactly these sections, in this order:\n\n## Goal\nThe user's goal and the acceptance criterion, in one or two sentences.\n\n## Constraints\nThe constraints, requirements, and rulings the work must honor.\n\n## User requests\nEvery user message in the covered range, enumerated one by one, each\nwith what it asked for and what was done about it.\n\n## Files and changes\nEvery file touched \u2014 exact paths, what changed, and why. Include the\nprecise code-level changes later turns may need to continue.\n\n## Errors and fixes\nEvery error encountered and its resolution; commands run and their\noutcomes.\n\n## Current work\nThe current state of the work \u2014 what is done, what is not. Quote the\ncurrent task's criterion VERBATIM if one exists.\n\n## Next steps\nThe concrete next steps, in order.\n\nPreserve concrete identifiers VERBATIM: paths, function names, task ids,\nenvironment names \u2014 never paraphrase them.\n\nRules:\n- plain prose \u2014 no bullet lists, no markdown outside the section headers,\n  no prefixes;\n- do not mention this prompt or the summarization task;\n- the summary may be as long as it needs to be within the output budget \u2014\n  there is no word cap; completeness wins.";
+export declare const SUMMARY_IN_BAND = "Stop the task for this one reply and write a checkpoint of the conversation above instead.\n\nOnly output the summary. Do not continue the conversation. Do not use any tools.\n\nYou are the conversation summarizer of the kiso agent framework.\n\nSummarize the covered conversation into a single structured checkpoint\nthat will REPLACE it \u2014 and every earlier checkpoint \u2014 in the model's\ncontext. The next turn must be able to continue the work without reading\nthe originals. If the conversation includes an earlier checkpoint, it is\nbeing replaced too: carry forward everything in it that is still true,\nso that this checkpoint restates the whole task.\n\nProduce the checkpoint with exactly these sections, in this order:\n\n## Goal\nThe user's goal and the acceptance criterion, in one or two sentences.\n\n## Constraints\nThe constraints, requirements, and rulings the work must honor.\n\n## User requests\nEvery user request of the task \u2014 those an earlier checkpoint lists and\nthose in the covered range \u2014 enumerated one by one, each with what it\nasked for and what was done about it.\n\n## Files and changes\nEvery file touched \u2014 exact paths, what changed, and why. Include the\nprecise code-level changes later turns may need to continue.\n\n## Errors and fixes\nEvery error encountered and its resolution; commands run and their\noutcomes.\n\n## Current work\nThe current state of the work \u2014 what is done, what is not. Quote the\ncurrent task's criterion VERBATIM if one exists.\n\n## Next steps\nThe concrete next steps, in order.\n\nPreserve concrete identifiers VERBATIM: paths, function names, task ids,\nenvironment names \u2014 never paraphrase them.\n\nRules:\n- plain prose \u2014 no bullet lists, no markdown outside the section headers,\n  no prefixes;\n- do not mention this prompt or the summarization task;\n- the summary may be as long as it needs to be within the output budget \u2014\n  there is no word cap; completeness wins.";
 /**
  * E6 (b) — the output-side validation (the finding E6-F4/F5 follow-up):
  * a summary must be a complete checkpoint or NOTHING. The marker family

package/dist/summarize.js

@@ -122,16 +122,20 @@ export const MAX_SUMMARY_FAILURES = 3;
 export function serializeCovered(options) {
     const { events, prevPoint, boundary } = options;
     const lines = ["<conversation>"];
-    // E6 (d) (the order's R4): the old summary texts are RETAINED CONTEXT —
-    // the durable record of the earlier ranges. They render first, labeled
-    // do-not-re-summarize: the summarizer must know what the earlier
-    // summaries covered, but never fold them into the new checkpoint.
-    const retained = events.filter((e) => e.type === "summarized" && e.coversToSeq <= prevPoint);
-    if (retained.length > 0) {
-        lines.push("[retained context — do not re-summarize]");
-        for (const r of retained)
-            lines.push(`[summary covers to seq ${r.coversToSeq}] ${r.summary}`);
-        lines.push("[end retained context]");
+    // ADR-0055 Amendment 2 (E6 (d)'s "do not re-summarize" retired): the
+    // new checkpoint REPLACES the previous one, so the summariser is given
+    // exactly the checkpoint the projection shows — the latest at or before
+    // prevPoint — as material to fold in. The superseded ones are not shown:
+    // the latest already restates them.
+    let previous;
+    for (const e of events) {
+        if (e.type === "summarized" && e.coversToSeq <= prevPoint && (previous === undefined || e.coversToSeq >= previous.coversToSeq))
+            previous = e;
+    }
+    if (previous !== undefined) {
+        lines.push("[previous checkpoint — the new checkpoint replaces it: carry forward everything in it that is still true]");
+        lines.push(previous.summary);
+        lines.push("[end previous checkpoint]");
     }
     for (const ev of events) {
         if (ev.seq <= prevPoint || ev.seq > boundary || ev.type === "summarized")
@@ -173,8 +177,11 @@ export const SUMMARY_PROMPT = `${SUMMARY_GUARD}
 You are the conversation summarizer of the kiso agent framework.
 
 Summarize the covered conversation into a single structured checkpoint
-that will REPLACE it in the model's context. The next turn must be able
-to continue the work without reading the originals.
+that will REPLACE it — and every earlier checkpoint — in the model's
+context. The next turn must be able to continue the work without reading
+the originals. If the conversation includes an earlier checkpoint, it is
+being replaced too: carry forward everything in it that is still true,
+so that this checkpoint restates the whole task.
 
 Produce the checkpoint with exactly these sections, in this order:
 
@@ -185,8 +192,9 @@ The user's goal and the acceptance criterion, in one or two sentences.
 The constraints, requirements, and rulings the work must honor.
 
 ## User requests
-Every user message in the covered range, enumerated one by one, each
-with what it asked for and what was done about it.
+Every user request of the task — those an earlier checkpoint lists and
+those in the covered range — enumerated one by one, each with what it
+asked for and what was done about it.
 
 ## Files and changes
 Every file touched — exact paths, what changed, and why. Include the

package/dist/window-learner.d.ts

@@ -0,0 +1,26 @@
+/**
+ * CW-1 batch 2 — a route's real window, read from its own refusal.
+ *
+ * Batch 1 gives a registered model a window at any endpoint, and at an
+ * endpoint no row names that window is the model's — a vendor statement
+ * about the weights, which a relay may cap lower. The one source that is
+ * right for ANY route is the route itself, and a route that refuses an
+ * oversize request usually states its cap. d4fc (2026-09-22) died on:
+ *
+ *   This model's maximum context length is 1048576 tokens. However, you
+ *   requested 131072 output tokens and your prompt contains at least
+ *   917505 input tokens ...
+ *
+ * The kernel already compacts once and retries once on context_overflow;
+ * what it lacked is the figure, so the compaction and every request after
+ * it aimed at the wrong window. This wrapper reads the figure off the
+ * refusal and hands it on, then rethrows the error untouched — it changes
+ * no classification and no retry.
+ */
+import type { Adapter } from "@vincemakes/kiso-core";
+/** The cap a refusal states, or null — anything that does not say one in
+ *  the two wordings above is null, never a guess. */
+export declare function overflowCap(message: string): number | null;
+/** Wraps an adapter so a refusal that states a cap is reported once, and
+ *  then thrown on exactly as it came. A caller's abort passes untouched. */
+export declare function windowLearner(adapter: Adapter, onCap: (tokens: number) => void): Adapter;

package/dist/window-learner.js

@@ -0,0 +1,40 @@
+/** The two wordings the providers kiso speaks to use for the cap:
+ *  OpenAI-shaped and vLLM-shaped servers (and gateways in front of them)
+ *  say `maximum context length is N tokens`; Anthropic-shaped ones say
+ *  `prompt is too long: A tokens > N maximum`. */
+const CAP_PATTERNS = [/maximum context length is\s+(\d[\d,_]*)\s*tokens/i, /prompt is too long:\s*\d[\d,_]*\s*tokens\s*>\s*(\d[\d,_]*)\s*maximum/i];
+/** A window below this, or above the second bound, is not a window a
+ *  refusal would state — a figure outside them is a misread, never a cap. */
+const MIN_CAP = 1_000;
+const MAX_CAP = 100_000_000;
+/** The cap a refusal states, or null — anything that does not say one in
+ *  the two wordings above is null, never a guess. */
+export function overflowCap(message) {
+    for (const re of CAP_PATTERNS) {
+        const m = re.exec(message);
+        if (m === null)
+            continue;
+        const n = Number(m[1].replace(/[,_]/g, ""));
+        return Number.isSafeInteger(n) && n >= MIN_CAP && n <= MAX_CAP ? n : null;
+    }
+    return null;
+}
+/** Wraps an adapter so a refusal that states a cap is reported once, and
+ *  then thrown on exactly as it came. A caller's abort passes untouched. */
+export function windowLearner(adapter, onCap) {
+    return { stream: (options) => learning(adapter, options, onCap) };
+}
+async function* learning(adapter, options, onCap) {
+    try {
+        yield* adapter.stream(options);
+    }
+    catch (err) {
+        if (options.signal?.aborted !== true) {
+            const message = typeof err === "object" && err !== null && typeof err.message === "string" ? err.message : null;
+            const cap = message === null ? null : overflowCap(message);
+            if (cap !== null)
+                onCap(cap);
+        }
+        throw err;
+    }
+}

package/package.json

@@ -1,6 +1,6 @@
 {
 	"name": "@vincemakes/kiso-runtime",
-	"version": "0.40.1",
+	"version": "0.40.3",
 	"description": "kiso runtime \u2014 durable multi-turn agent sessions: AgentDefinition, AgentRuntime, AgentSession, Run, append-only JSONL store.",
 	"type": "module",
 	"license": "MIT",
@@ -25,12 +25,12 @@
 		"test": "vitest run"
 	},
 	"dependencies": {
-		"@vincemakes/kiso-core": "0.40.1"
+		"@vincemakes/kiso-core": "0.40.3"
 	},
 	"peerDependencies": {
-		"@vincemakes/kiso-provider-anthropic": "0.40.1",
-		"@vincemakes/kiso-provider-openai": "0.40.1",
-		"@vincemakes/kiso-provider-openai-responses": "0.40.1"
+		"@vincemakes/kiso-provider-anthropic": "0.40.3",
+		"@vincemakes/kiso-provider-openai": "0.40.3",
+		"@vincemakes/kiso-provider-openai-responses": "0.40.3"
 	},
 	"peerDependenciesMeta": {
 		"@vincemakes/kiso-provider-anthropic": {
@@ -44,7 +44,7 @@
 		}
 	},
 	"devDependencies": {
-		"@vincemakes/kiso-evals": "0.40.1",
+		"@vincemakes/kiso-evals": "0.40.3",
 		"@types/node": "^26.1.2",
 		"typescript": "^5.7.2",
 		"vitest": "^3.0.0"