@vincemakes/kiso-runtime 0.26.2 → 0.27.0

package/dist/agent.d.ts

@@ -46,15 +46,6 @@ export interface AgentDefinition {
     readonly maxTurns?: number;
     readonly maxTokens?: number;
     readonly temperature?: number;
-    /**
-     * DEPRECATED (ADR-0044): the classic auto-compaction path is retired —
-     * the loop ignores this (microcompact absorbed the responsibility; old
-     * sessions' `compacted` events still replay). Kept so old definitions
-     * type-check; removed at 1.0.
-     */
-    readonly compaction?: {
-        readonly thresholdTokens: number;
-    };
     /** C area: microcompact threshold — passed through to every session. */
     readonly microcompact?: {
         readonly thresholdTokens: number;

package/dist/agent.js

@@ -139,7 +139,6 @@ export class AgentRuntime {
             ...(this.#definition.maxTurns !== undefined ? { maxTurns: this.#definition.maxTurns } : {}),
             ...(this.#definition.maxTokens !== undefined ? { maxTokens: this.#definition.maxTokens } : {}),
             ...(this.#definition.temperature !== undefined ? { temperature: this.#definition.temperature } : {}),
-            ...(this.#definition.compaction !== undefined ? { compaction: this.#definition.compaction } : {}),
             ...(this.#definition.microcompact !== undefined ? { microcompact: this.#definition.microcompact } : {}),
             ...(this.#definition.contextPolicy !== undefined ? { contextPolicy: this.#definition.contextPolicy } : {}),
             ...(this.#definition.maxRetries !== undefined ? { maxRetries: this.#definition.maxRetries } : {}),

package/dist/compose.js

@@ -73,7 +73,7 @@ export function composeHooks(existing, extensions) {
                 await h(payload, ctx);
         };
     };
-    for (const key of ["onPreLlm", "onEvent", "onPreCompact", "onPostCompact", "onPause", "onStop"]) {
+    for (const key of ["onPreLlm", "onEvent", "onPause", "onStop"]) {
         const handler = observers((h) => h[key]);
         if (handler !== undefined)
             out[key] = handler;

package/dist/run.js

@@ -32,7 +32,6 @@ export class Run {
     #abort = new AbortController();
     #externalSignal;
     #decisionIds = [];
-    #uncertaintyIds = [];
     #started = false;
     constructor(store, adapter, config, session, input, externalSignal, resume, 
     // TV-1B: durable PROVENANCE for the input (e.g. the verification
@@ -129,7 +128,6 @@ export class Run {
                 ...(this.#config.maxTurns !== undefined ? { maxTurns: this.#config.maxTurns } : {}),
                 ...(this.#config.maxTokens !== undefined ? { maxTokens: this.#config.maxTokens } : {}),
                 ...(this.#config.temperature !== undefined ? { temperature: this.#config.temperature } : {}),
-                ...(this.#config.compaction !== undefined ? { compaction: this.#config.compaction } : {}),
                 ...(microcompact !== undefined ? { microcompact } : {}),
                 ...(this.#config.maxRetries !== undefined ? { maxRetries: this.#config.maxRetries } : {}),
                 // MG-1 (A5): the kernel stamps committed envelopes with this.
@@ -151,11 +149,6 @@ export class Run {
                 // the human gave in the same instant as the abort is
                 // recorded, exactly once.
                 approvalVerdict: (decisionId) => this.#session.approvalVerdict(decisionId),
-                uncertaintyVerdict: (executionId) => this.#session.uncertaintyVerdict(executionId),
-                resolveUncertainty: (executionId) => new Promise((resolve) => {
-                    this.#uncertaintyIds.push(executionId);
-                    this.#session.registerUncertaintyResolver(executionId, resolve);
-                }),
             });
             const self = this;
             const runLoop = async function* () {
@@ -287,9 +280,6 @@ export class Run {
             for (const decisionId of this.#decisionIds) {
                 this.#session.dropResolver(decisionId);
             }
-            for (const executionId of this.#uncertaintyIds) {
-                this.#session.dropUncertaintyResolver(executionId);
-            }
             // E1: the run's ledger story — the run_end lands synchronously
             // (a killed run leaves no run_end, and the next init marks it).
             tracer?.finishRun();

package/dist/session.d.ts

@@ -287,13 +287,9 @@ export declare class AgentSession {
     resolveUncertain(executionId: string, resolution: "rerun" | "abandoned"): Promise<void>;
     /** The runId that owns an execution — from its durable started record. */
     private runIdFor;
-    registerUncertaintyResolver(executionId: string, resolve: (resolution: "rerun" | "abandoned") => void): void;
-    dropUncertaintyResolver(executionId: string): void;
     registerResolver(decisionId: string, resolve: (decision: PermissionDecision) => void): void;
     /** round 4 (adversarial): a verdict the human already gave for a live decision. */
     approvalVerdict(decisionId: string): boolean | undefined;
-    /** round 4 (adversarial): a verdict the human already gave for a live execution. */
-    uncertaintyVerdict(executionId: string): "rerun" | "abandoned" | undefined;
     /**
      * round 5(P1-5): flush every verdict submitted to a live resolver that is
      * not yet durable. Called from the Run iterator's FINALLY — whether the
@@ -386,13 +382,6 @@ export interface SessionConfig {
     readonly maxTurns?: number;
     readonly maxTokens?: number;
     readonly temperature?: number;
-    /**
-     * DEPRECATED (ADR-0044): forwarded to the loop's deprecated field,
-     * which IGNORES it — kept for type compatibility, removed at 1.0.
-     */
-    readonly compaction?: {
-        readonly thresholdTokens: number;
-    };
     /** C area: microcompact threshold — passed through to the loop verbatim. */
     readonly microcompact?: {
         readonly thresholdTokens: number;

package/dist/session.js

@@ -93,26 +93,21 @@ export class AgentSession {
     // selection or first request — never eagerly at open.
     #profilePending;
     #pendingResolvers = new Map();
-    #uncertaintyResolvers = new Map();
     #answered = new Set();
-    /** round 7: verdicts already passed to a live resolver — the resolution event
-     *  lands in the log asynchronously (the loop owns it), so the ledger
-     *  alone cannot make resolveUncertain idempotent across the same tick. */
-    #uncertaintyAnswered = new Set();
     /** round 4 (adversarial): verdicts the human GAVE, recorded when passed to a live
      *  resolver. If an abort races the verdict, the loop / recovery queries
      *  these and records the decision (exactly once) instead of losing it. */
     #approvalVerdicts = new Map();
-    #uncertaintyVerdicts = new Map();
     /** round 5(P1-5): verdicts submitted to a LIVE resolver but not yet known
-     *  durable. An async generator only advances on next(), so approve()/
-     *  resolveUncertain() CANNOT wait for the loop to persist — that would
-     *  deadlock (the consumer waits while the generator needs a next()).
-     *  Instead the verdict is recorded here, and the Run's iterator FINALLY
-     *  flushes every not-yet-durable verdict to disk — an abandoned generator
-     *  can never lose a verdict the human gave. */
+     *  durable. An async generator only advances on next(), so approve()
+     *  CANNOT wait for the loop to persist — that would deadlock (the
+     *  consumer waits while the generator needs a next()). Instead the
+     *  verdict is recorded here, and the Run's iterator FINALLY flushes
+     *  every not-yet-durable verdict to disk — an abandoned generator can
+     *  never lose a verdict the human gave. (CT-1: uncertainty verdicts no
+     *  longer have a live resolver — the loop never took one since
+     *  ADR-0038 — so they always take the direct-persist path below.) */
     #pendingDurableApprovals = new Map();
-    #pendingDurableUncertainties = new Map();
     #poisoned = null;
     /** E6 (h): the circuit-breaker counter — consecutive auto-policy
      *  summary failures this session (a success resets it). */
@@ -668,30 +663,10 @@ export class AgentSession {
         if (!record)
             throw new Error(`no execution record for ${executionId}`);
         if (record.status !== "uncertain")
-            return; // idempotent + irreversible
-        // round 7: a verdict already passed to a live resolver is FINAL — the
-        // loop's resolution event lands asynchronously, so the ledger alone
-        // cannot make this idempotent across the same tick.
-        if (this.#uncertaintyAnswered.has(executionId))
-            return;
-        this.#uncertaintyAnswered.add(executionId);
-        // round 7: with a LIVE resolver, the active loop / recovery generator
-        // OWNS the resolution event — it appends, yields, and persists it
-        // through the Run, so the consumer's stream and the durable log
-        // stay identical. We only pass the verdict; a hidden append here
-        // would leave a seq gap. round 4 (adversarial): the verdict is recorded so an
-        // abort racing it cannot lose it.
-        const resolver = this.#uncertaintyResolvers.get(executionId);
-        if (resolver !== undefined) {
-            this.#uncertaintyVerdicts.set(executionId, resolution);
-            // round 5(P1-5): submitted — flushed to disk by the Run's finally
-            // if the generator never persists it.
-            this.#pendingDurableUncertainties.set(executionId, { resolution, callId: record.callId });
-            this.#uncertaintyResolvers.delete(executionId);
-            resolver(resolution);
-            return;
-        }
-        // round 7: OFFLINE verdict — no live resolver: persist directly.
+            return; // idempotent + irreversible (the append below is synchronous, so a same-tick second call sees it)
+        // CT-1 (ADR-0051 Amendment 6): the verdict is persisted directly — there
+        // is no live resolver to hand it to (the loop never read one since
+        // ADR-0038; the round-7 live branch that waited for it was unreachable).
         // round 4: the verdict is attributed to the ORIGINAL run of the execution
         // — never the fake runId "resolution".
         const runId = this.runIdFor(executionId);
@@ -738,12 +713,6 @@ export class AgentSession {
             throw new Error(`no durable execution record for ${executionId}`);
         return rec.runId;
     }
-    registerUncertaintyResolver(executionId, resolve) {
-        this.#uncertaintyResolvers.set(executionId, resolve);
-    }
-    dropUncertaintyResolver(executionId) {
-        this.#uncertaintyResolvers.delete(executionId);
-    }
     // ── internal: the resolver registry ──────────────────────────────────
     registerResolver(decisionId, resolve) {
         this.#pendingResolvers.set(decisionId, resolve);
@@ -752,10 +721,6 @@ export class AgentSession {
     approvalVerdict(decisionId) {
         return this.#approvalVerdicts.get(decisionId);
     }
-    /** round 4 (adversarial): a verdict the human already gave for a live execution. */
-    uncertaintyVerdict(executionId) {
-        return this.#uncertaintyVerdicts.get(executionId);
-    }
     /**
      * round 5(P1-5): flush every verdict submitted to a live resolver that is
      * not yet durable. Called from the Run iterator's FINALLY — whether the
@@ -777,19 +742,6 @@ export class AgentSession {
             }
             this.#pendingDurableApprovals.delete(decisionId);
         }
-        for (const [executionId, pending] of this.#pendingDurableUncertainties) {
-            const resolved = log.all.find((e) => e.type === "tool_execution_resolved" && e.executionId === executionId);
-            if (resolved === undefined) {
-                const app = log.append({
-                    type: "tool_execution_resolved",
-                    executionId,
-                    callId: pending.callId,
-                    resolution: pending.resolution,
-                });
-                await this.persist(runId, app);
-            }
-            this.#pendingDurableUncertainties.delete(executionId);
-        }
     }
     dropResolver(decisionId) {
         this.#pendingResolvers.delete(decisionId);

package/package.json

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