@vincemakes/kiso-runtime 0.31.1 → 0.32.1

package/dist/agent.d.ts

@@ -65,6 +65,10 @@ export interface AgentDefinition {
     /** E6: the session context policy (run-start actions, injection-side only). */
     readonly contextPolicy?: import("./session.js").ContextPolicy;
     readonly maxRetries?: number;
+    /** LT-1: the stream watchdog — milliseconds between adapter events
+     *  before the request is aborted and retried (default 120 s; 0 off).
+     *  Type-only additive; read by the runtime's idle guard. */
+    readonly streamIdleMs?: number;
     /** E1: loaded extensions — their tools merge into the registry (a name
      *  collision with a built-in is a loud startup error), their hooks
      *  compose after the agent's own (the existing come first), their approvals join the

package/dist/agent.js

@@ -145,6 +145,7 @@ export class AgentRuntime {
             ...(this.#definition.microcompact !== undefined ? { microcompact: this.#definition.microcompact } : {}),
             ...(this.#definition.contextPolicy !== undefined ? { contextPolicy: this.#definition.contextPolicy } : {}),
             ...(this.#definition.maxRetries !== undefined ? { maxRetries: this.#definition.maxRetries } : {}),
+            ...(this.#definition.streamIdleMs !== undefined ? { streamIdleMs: this.#definition.streamIdleMs } : {}),
             ...(this.#definition.extensions !== undefined ? { extensions: this.#definition.extensions } : {}),
         };
         return new AgentSession(options.id, log, store, adapter, config);

package/dist/extensions.js

@@ -28,6 +28,27 @@ export async function loadProjectExtensions(dir, existing = []) {
     }
     return projectExts;
 }
+/**
+ * §2.5 — the load counter behind the import URL's `?load=` query.
+ *
+ * Node caches ESM modules by URL forever. Without a distinguishing query
+ * a second load of the same directory returns the FIRST load's modules,
+ * so `/reload` would report success and change nothing — and a
+ * module-level Set held across the boundary would be mutated by one side
+ * and read by the other.
+ *
+ * It is unconditional on purpose. A parameter would put a stale mode
+ * back within reach and would move `loadExtensions` in the public
+ * surface file for no gain: at startup this is one load and invisible,
+ * and on a reload it is the entire point.
+ *
+ * The cost, stated rather than hidden: Node has no module unloader, so
+ * each superseded module object stays allocated and unreachable for the
+ * life of the process — one per extension file per reload. The only
+ * real resources an extension holds are its MCP servers, and those are
+ * torn down by `disposeExtensions`, which whoever loaded them owes.
+ */
+let loadSerial = 0;
 export async function loadExtensions(dir) {
     let files;
     try {
@@ -39,10 +60,11 @@ export async function loadExtensions(dir) {
         throw err;
     }
     const out = [];
+    const serial = ++loadSerial; // one nonce per CALL — a directory's files load together
     for (const file of files) {
         let ext;
         try {
-            const mod = (await import(pathToFileURL(join(dir, file)).href));
+            const mod = (await import(`${pathToFileURL(join(dir, file)).href}?load=${serial}`));
             ext = mod.default;
             if (typeof ext === "function")
                 ext = await ext(); // a factory

package/dist/idle-guard.d.ts

@@ -0,0 +1,38 @@
+/**
+ * LT-1 — the stream watchdog (kiso-doc/kiso-lt1-mini-spec-2026-09-09.md).
+ *
+ * The third guard beside `truncationGuard` and `traceGuard`: it wraps the
+ * adapter's `stream()` so that a request whose events STOP ARRIVING is
+ * ended rather than waited on forever. Before this, a model stream that
+ * went silent — a hung socket, an upstream that stopped writing without
+ * closing — held the run open until a human pressed esc; the 0.31.0
+ * review filed it as the one long-task hazard nothing handled.
+ *
+ * The rule is per EVENT, not per request: a long think that keeps
+ * streaming is never tripped, a socket that stops is tripped `idleMs`
+ * after its last byte. On a trip the guard aborts the UNDERLYING request
+ * through a controller it owns (combined with the caller's signal, so
+ * esc still wins) and throws a retryable `network` StructuredError. From
+ * there the kernel's existing mid-stream retry does the rest: the
+ * attempt is voided (`model_output_abandoned` with this reason), the
+ * request is retried with backoff, and when the budget is spent the run
+ * ends in the error terminal the CLI prints (OR-5). Nothing new is
+ * written to the log; the kernel is untouched.
+ *
+ * `idleMs` ≤ 0 (or absent) returns the adapter itself: the guard is
+ * declared off, not silently ignored.
+ */
+import type { Adapter, StructuredError } from "@vincemakes/kiso-core";
+/** The default: 120 s between events. The ChatGPT backend at a high effort
+ *  can think without writing (no reasoning summaries are requested), and
+ *  no measured bound exists for an `ultra` turn — 120 s is the order of
+ *  magnitude the reference implementation allows a whole request, applied
+ *  here per event: stricter where it matters, looser where it should be.
+ *  A knob (`streamIdleMs` on the profile) because the first dogfood may
+ *  move it. */
+export declare const DEFAULT_STREAM_IDLE_MS = 120000;
+export declare function idleGuard(adapter: Adapter, idleMs: number | undefined): Adapter;
+/** The error the kernel receives on a trip — the same shape the adapters
+ *  produce for a connection failure, so the retry authority (ADR-0005)
+ *  treats a stall exactly like a dropped socket. */
+export declare function stalledError(idleMs: number, elapsedMs: number): StructuredError;

package/dist/idle-guard.js

@@ -0,0 +1,122 @@
+/**
+ * LT-1 — the stream watchdog (kiso-doc/kiso-lt1-mini-spec-2026-09-09.md).
+ *
+ * The third guard beside `truncationGuard` and `traceGuard`: it wraps the
+ * adapter's `stream()` so that a request whose events STOP ARRIVING is
+ * ended rather than waited on forever. Before this, a model stream that
+ * went silent — a hung socket, an upstream that stopped writing without
+ * closing — held the run open until a human pressed esc; the 0.31.0
+ * review filed it as the one long-task hazard nothing handled.
+ *
+ * The rule is per EVENT, not per request: a long think that keeps
+ * streaming is never tripped, a socket that stops is tripped `idleMs`
+ * after its last byte. On a trip the guard aborts the UNDERLYING request
+ * through a controller it owns (combined with the caller's signal, so
+ * esc still wins) and throws a retryable `network` StructuredError. From
+ * there the kernel's existing mid-stream retry does the rest: the
+ * attempt is voided (`model_output_abandoned` with this reason), the
+ * request is retried with backoff, and when the budget is spent the run
+ * ends in the error terminal the CLI prints (OR-5). Nothing new is
+ * written to the log; the kernel is untouched.
+ *
+ * `idleMs` ≤ 0 (or absent) returns the adapter itself: the guard is
+ * declared off, not silently ignored.
+ */
+/** The default: 120 s between events. The ChatGPT backend at a high effort
+ *  can think without writing (no reasoning summaries are requested), and
+ *  no measured bound exists for an `ultra` turn — 120 s is the order of
+ *  magnitude the reference implementation allows a whole request, applied
+ *  here per event: stricter where it matters, looser where it should be.
+ *  A knob (`streamIdleMs` on the profile) because the first dogfood may
+ *  move it. */
+export const DEFAULT_STREAM_IDLE_MS = 120_000;
+export function idleGuard(adapter, idleMs) {
+    if (idleMs === undefined || !(idleMs > 0))
+        return adapter;
+    return {
+        stream: (options) => guardStream(adapter, options, idleMs),
+    };
+}
+/** The error the kernel receives on a trip — the same shape the adapters
+ *  produce for a connection failure, so the retry authority (ADR-0005)
+ *  treats a stall exactly like a dropped socket. */
+export function stalledError(idleMs, elapsedMs) {
+    return {
+        code: "network",
+        retryable: true,
+        message: `stream stalled: no event for ${Math.round(idleMs / 1000)}s (${Math.round(elapsedMs / 1000)}s into the request)`,
+    };
+}
+/** The caller's abort, as the kernel's catch reads it: an error NAMED
+ *  AbortError with the signal set — `aborted by user`, never a stall. */
+function abortError() {
+    const err = new Error("stream aborted by the caller");
+    err.name = "AbortError";
+    return err;
+}
+async function* guardStream(adapter, options, idleMs) {
+    const own = new AbortController();
+    const caller = options.signal;
+    // the caller's abort (esc) reaches the adapter through OUR controller —
+    // one signal goes down — and it also settles OUR wait at once: an
+    // adapter that ignores its signal (a stub, a transport that only
+    // notices on the next write) must not turn the caller's abort into a
+    // stall by keeping the guard waiting until the idle timer fires.
+    let rejectOnCallerAbort = () => undefined;
+    const callerAborted = new Promise((_, reject) => {
+        rejectOnCallerAbort = reject;
+    });
+    callerAborted.catch(() => undefined); // settled only when raced; never an unhandled rejection
+    const onCallerAbort = () => {
+        own.abort();
+        rejectOnCallerAbort(abortError());
+    };
+    if (caller?.aborted === true)
+        onCallerAbort();
+    else
+        caller?.addEventListener("abort", onCallerAbort, { once: true });
+    const iterator = adapter.stream({ ...options, signal: own.signal })[Symbol.asyncIterator]();
+    const started = Date.now();
+    let tripped = false;
+    try {
+        for (;;) {
+            let timer;
+            const stall = new Promise((_, reject) => {
+                timer = setTimeout(() => {
+                    if (caller?.aborted === true) {
+                        // the caller gave up first; the silence is theirs, not a stall
+                        reject(abortError());
+                        return;
+                    }
+                    tripped = true;
+                    own.abort();
+                    reject(stalledError(idleMs, Date.now() - started));
+                }, idleMs);
+            });
+            let next;
+            try {
+                next = await Promise.race([iterator.next(), stall, callerAborted]);
+            }
+            catch (err) {
+                // an abort the CALLER asked for is theirs (the kernel reads its
+                // own signal and records `aborted by user`); an abort WE caused
+                // is the stall, whatever shape the adapter turned it into
+                if (tripped && caller?.aborted !== true)
+                    throw stalledError(idleMs, Date.now() - started);
+                throw err;
+            }
+            finally {
+                clearTimeout(timer);
+            }
+            if (next.done)
+                return;
+            yield next.value;
+        }
+    }
+    finally {
+        caller?.removeEventListener("abort", onCallerAbort);
+        // release the underlying generator whichever way this one ends
+        // (a trip, the caller's abort, or the consumer walking away)
+        await iterator.return?.().catch(() => undefined);
+    }
+}

package/dist/provider/metadata.js

@@ -246,6 +246,36 @@ const ENTRIES = [
     openaiRow("gpt-5.6-sol", "medium", { inputPerM: 4, outputPerM: 20, cacheReadPerM: 0.4 }, "https://developers.openai.com/api/docs/models/gpt-5.6-sol", { levels: ["none", "low", "medium", "high", "xhigh", "max"], asOf: OPENAI_MODELS_ASOF_2 }),
     chatgptRow("gpt-6-astra", { levels: ULTRA_LADDER, default: "low", source: CHATGPT_PRESETS_SOURCE_2, asOf: OPENAI_MODELS_ASOF_2 }),
     chatgptRow("gpt-5.6-sol", { levels: ULTRA_LADDER, default: "low", source: CHATGPT_PRESETS_SOURCE_2, asOf: OPENAI_MODELS_ASOF_2 }),
+    // The compat table's SECOND row (roadmap R3.2 §1a step 1): GLM 5.3 Flash
+    // through OpenRouter, read from OpenRouter's models API on 2026-09-09. The
+    // id is OpenRouter's, so the row is keyed to that origin; the
+    // continuation scope stamps such a profile `custom` at openrouter.ai
+    // (manifest.ts's KNOWN_ORIGINS is deliberately not widened — the scope
+    // identity is a durable fact and this row needs only the lookup). The
+    // window is the TOP provider's (1,048,576), not the listing's 1,310,720:
+    // what a request actually gets. No default effort — the page states
+    // none. `reasoning_effort` is in the model's supported parameters; the
+    // stream's think arrives as `reasoning` (GLM-F1, the compat adapter).
+    {
+        model: "z-ai/glm-5.3-flash",
+        endpoint: "https://openrouter.ai",
+        capabilities: {
+            contextWindow: 1_048_576,
+            maxOutputTokens: 131_072,
+            promptCaching: "automatic",
+            reasoning: {
+                emitsThinkingStream: true,
+                thinking: null,
+                effort: { levels: ["low", "medium", "high"], default: null, wire: "reasoning_effort" },
+                asOf: "2026-09-09",
+                source: "https://openrouter.ai/docs/use-cases/reasoning-tokens",
+            },
+            inputModalities: null,
+        },
+        capabilitiesAsOf: "2026-09-09",
+        capabilitiesSource: "https://openrouter.ai/api/v1/models",
+        pricing: { inputPerM: 0.075, outputPerM: 0.25, cacheReadPerM: 0.015, cacheWritePerM: 0, asOf: "2026-09-09", source: "https://openrouter.ai/api/v1/models" },
+    },
 ];
 /**
  * Look a model up. `endpoint` narrows: an entry WITH an endpoint only

package/dist/run.js

@@ -9,6 +9,7 @@ import { resolveReasoning } from "./provider/metadata.js";
 import { deriveRecoveryPlan, invocationSeqOf } from "./recovery-plan.js";
 import { composeApprovalChain, composeSystemPrompt, composeToolTable, microcompactFor } from "./compose.js";
 import { truncationGuard } from "./truncation-guard.js";
+import { DEFAULT_STREAM_IDLE_MS, idleGuard } from "./idle-guard.js";
 import { RequestTracer, traceGuard } from "./trace/guard.js";
 import { runtimeVersion } from "./trace/writer.js";
 import { ResumeBlockedError } from "./session.js";
@@ -121,7 +122,10 @@ export class Run {
             const loopConfig = () => ({
                 // 0.1.40 (R-C item 3): the truncation guard gates the model
                 // stream — a truncated turn's tool batch never executes.
-                adapter: traceGuard(tracer, truncationGuard(this.#adapter)), // tracer assigned above, before loopConfig
+                // 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
                 model: this.#config.model,
                 sessionId: this.#session.id, // P3: tools see their session (ToolContext.sessionId)
                 ...(systemPrompt !== undefined ? { systemPrompt } : {}),

package/dist/session.d.ts

@@ -414,6 +414,8 @@ export interface SessionConfig {
     /** E6: the session context policy (run-start actions, injection-side only). */
     readonly contextPolicy?: ContextPolicy;
     readonly maxRetries?: number;
+    /** LT-1: the stream watchdog's idle bound (ms); default 120 s, 0 off. */
+    readonly streamIdleMs?: number;
     /**
      * E1: loaded extensions — their tools join the registry (idempotently;
      * a collision with a built-in name was already rejected at agent

package/dist/session.js

@@ -47,6 +47,7 @@ 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).
 import { RequestTracer, traceGuard } from "./trace/guard.js";
+import { DEFAULT_STREAM_IDLE_MS, idleGuard } from "./idle-guard.js";
 import { runtimeVersion } from "./trace/writer.js";
 /** A session whose disk write was rejected (stale handle) is PERMANENTLY
  * poisoned: its in-memory log no longer matches the disk, so no further
@@ -338,7 +339,8 @@ export class AgentSession {
             rentParts: { base: options.systemPrompt, appends: [] },
         });
         tracer.init();
-        const guarded = traceGuard(tracer, this.#adapter);
+        // LT-1: the summary request is a model stream too — the same watchdog
+        const guarded = traceGuard(tracer, idleGuard(this.#adapter, this.#config.streamIdleMs ?? DEFAULT_STREAM_IDLE_MS));
         let text = "";
         try {
             for await (const ev of guarded.stream({

package/dist/store.js

@@ -108,7 +108,14 @@ export function sessionTitle(records) {
     if (asked.length === 0)
         return "(no prompt)";
     const substantive = asked.find((t) => !isOpener(t));
-    return (substantive ?? asked[0]).slice(0, 60);
+    // HF-2 (0.32.1): a title is a LABEL and goes on one row — the resume
+    // picker's card row, `kiso sessions`, the session card. A pasted
+    // heredoc as the first turn kept its newlines here and reached the
+    // compositor's one-physical-row check through the picker (the HF-1
+    // family). Projected at the source, where the value is produced, so
+    // the three consumers cannot differ: a break or a tab is one space,
+    // runs collapse, and the cut applies to the projected line.
+    return (substantive ?? asked[0]).replace(/[\r\n\t ]+/g, " ").trim().slice(0, 60);
 }
 export class SessionStore {
     root;

package/package.json

@@ -1,6 +1,6 @@
 {
 	"name": "@vincemakes/kiso-runtime",
-	"version": "0.31.1",
+	"version": "0.32.1",
 	"description": "kiso runtime — 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.31.1"
+		"@vincemakes/kiso-core": "0.32.1"
 	},
 	"peerDependencies": {
-		"@vincemakes/kiso-provider-anthropic": "0.31.1",
-		"@vincemakes/kiso-provider-openai": "0.31.1",
-		"@vincemakes/kiso-provider-openai-responses": "0.31.1"
+		"@vincemakes/kiso-provider-anthropic": "0.32.1",
+		"@vincemakes/kiso-provider-openai": "0.32.1",
+		"@vincemakes/kiso-provider-openai-responses": "0.32.1"
 	},
 	"peerDependenciesMeta": {
 		"@vincemakes/kiso-provider-anthropic": {
@@ -44,7 +44,7 @@
 		}
 	},
 	"devDependencies": {
-		"@vincemakes/kiso-evals": "0.31.1",
+		"@vincemakes/kiso-evals": "0.32.1",
 		"@types/node": "^26.1.2",
 		"typescript": "^5.7.2",
 		"vitest": "^3.0.0"