@vincemakes/kiso-runtime 0.40.2 → 0.40.3

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/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

@@ -73,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

package/dist/session.d.ts

@@ -501,6 +501,14 @@ export interface ContextPolicy {
          *  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 {
@@ -521,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

@@ -30,6 +30,7 @@
 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
@@ -126,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;
@@ -199,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;
     }
@@ -241,6 +245,13 @@ export class AgentSession {
     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();
@@ -342,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 } : {}),
@@ -357,7 +369,7 @@ export class AgentSession {
             // 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(this.#adapter, () => this.overflowMeasure());
+            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" };
         }
@@ -499,6 +511,26 @@ 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() {
@@ -570,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, {
@@ -585,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({
@@ -595,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,
@@ -696,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,
@@ -706,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

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.2",
+	"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.2"
+		"@vincemakes/kiso-core": "0.40.3"
 	},
 	"peerDependencies": {
-		"@vincemakes/kiso-provider-anthropic": "0.40.2",
-		"@vincemakes/kiso-provider-openai": "0.40.2",
-		"@vincemakes/kiso-provider-openai-responses": "0.40.2"
+		"@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.2",
+		"@vincemakes/kiso-evals": "0.40.3",
 		"@types/node": "^26.1.2",
 		"typescript": "^5.7.2",
 		"vitest": "^3.0.0"