@cortexkit/opencode-magic-context 0.43.2 → 0.44.1

package/src/shared/sqlite-transaction-mode-guard.test.ts

@@ -0,0 +1,198 @@
+import { describe, expect, it } from "bun:test";
+import { readdirSync, readFileSync } from "node:fs";
+import { join, relative, resolve } from "node:path";
+import ts from "typescript";
+
+/**
+ * A deferred transaction (`db.transaction(fn)()`, `.deferred()`, `.default()`)
+ * starts with no lock. If it reads before it writes, the write must upgrade a read
+ * snapshot to a write lock, and SQLite never runs the busy handler for that
+ * upgrade: under another process's write it fails at once with SQLITE_BUSY, or
+ * with SQLITE_BUSY_SNAPSHOT when another commit landed after the read, and
+ * busy_timeout never applies. Many OpenCode and Pi processes share one context.db,
+ * so every transaction that writes must start with `.immediate()` (or
+ * `.exclusive()`), which takes the write lock at BEGIN where busy_timeout covers it.
+ *
+ * Only read-only transactions may stay deferred. Each one is listed here, keyed
+ * by file and the nearest named enclosing function, with the reason it never
+ * writes. A read-only snapshot must not take the write lock, because that would
+ * block every writer for the length of the read.
+ */
+const READ_ONLY_DEFERRED_TRANSACTIONS: Record<string, string> = {
+    "packages/plugin/src/v2/store-reader.ts#window":
+        "reads the latest compaction and the rows after it as one consistent snapshot of the OpenCode 2 store; never writes",
+    "packages/pi-plugin/src/inject-compartments-pi.ts#readFrozenM0InputsPi":
+        "reads the m[0] render sources and their watermarks as one consistent snapshot; never writes",
+};
+
+const REPOSITORY_ROOT = resolve(import.meta.dir, "../../../..");
+const SOURCE_ROOTS = ["packages/plugin/src", "packages/pi-plugin/src"];
+const LOCKING_MODES = new Set(["immediate", "exclusive"]);
+
+function sourceFiles(directory: string): string[] {
+    const result: string[] = [];
+    for (const entry of readdirSync(directory, { withFileTypes: true })) {
+        const path = join(directory, entry.name);
+        if (entry.isDirectory()) {
+            if (entry.name === "node_modules") continue;
+            result.push(...sourceFiles(path));
+        } else if (
+            /\.tsx?$/.test(entry.name) &&
+            !/\.test\.tsx?$/.test(entry.name) &&
+            !/\.d\.ts$/.test(entry.name)
+        ) {
+            result.push(path);
+        }
+    }
+    return result;
+}
+
+function isTransactionCall(node: ts.Node): node is ts.CallExpression {
+    return (
+        ts.isCallExpression(node) &&
+        ts.isPropertyAccessExpression(node.expression) &&
+        node.expression.name.text === "transaction"
+    );
+}
+
+/** True when `node` is the receiver of a called `.immediate()` / `.exclusive()`. */
+function isCalledWithLockingMode(node: ts.Node): boolean {
+    const access = node.parent;
+    return (
+        access !== undefined &&
+        ts.isPropertyAccessExpression(access) &&
+        access.expression === node &&
+        LOCKING_MODES.has(access.name.text) &&
+        access.parent !== undefined &&
+        ts.isCallExpression(access.parent) &&
+        access.parent.expression === access
+    );
+}
+
+function enclosingFunctionName(node: ts.Node): string {
+    for (let current = node.parent; current; current = current.parent) {
+        if (
+            (ts.isFunctionDeclaration(current) || ts.isMethodDeclaration(current)) &&
+            current.name
+        ) {
+            return current.name.getText();
+        }
+        if (
+            (ts.isArrowFunction(current) || ts.isFunctionExpression(current)) &&
+            current.parent &&
+            (ts.isVariableDeclaration(current.parent) || ts.isPropertyAssignment(current.parent))
+        ) {
+            return current.parent.name.getText();
+        }
+    }
+    return "<module>";
+}
+
+/**
+ * A transaction stored in a variable is locking only when every use of that
+ * variable calls `.immediate()` or `.exclusive()` on it.
+ */
+function storedTransactionLocks(call: ts.CallExpression, source: ts.SourceFile): boolean {
+    const declaration = call.parent;
+    if (!ts.isVariableDeclaration(declaration) || !ts.isIdentifier(declaration.name)) return false;
+    const name = declaration.name.text;
+    let scope: ts.Node = source;
+    for (let current: ts.Node | undefined = declaration.parent; current; current = current.parent) {
+        if (ts.isBlock(current)) {
+            scope = current;
+            break;
+        }
+    }
+    const uses: ts.Identifier[] = [];
+    const visit = (node: ts.Node): void => {
+        if (ts.isIdentifier(node) && node.text === name && node !== declaration.name) {
+            uses.push(node);
+        }
+        ts.forEachChild(node, visit);
+    };
+    visit(scope);
+    return uses.length > 0 && uses.every(isCalledWithLockingMode);
+}
+
+interface TransactionScan {
+    deferredSites: Map<string, string[]>;
+    lockingSites: number;
+}
+
+function scanTransactionModes(files: Array<{ path: string; text: string }>): TransactionScan {
+    const deferredSites = new Map<string, string[]>();
+    let lockingSites = 0;
+    for (const file of files) {
+        if (!file.text.includes(".transaction(")) continue;
+        const source = ts.createSourceFile(file.path, file.text, ts.ScriptTarget.Latest, true);
+        const visit = (node: ts.Node): void => {
+            if (isTransactionCall(node)) {
+                if (isCalledWithLockingMode(node) || storedTransactionLocks(node, source)) {
+                    lockingSites += 1;
+                } else {
+                    const key = `${file.path}#${enclosingFunctionName(node)}`;
+                    const line = source.getLineAndCharacterOfPosition(node.getStart(source)).line;
+                    const locations = deferredSites.get(key) ?? [];
+                    locations.push(`${file.path}:${line + 1}`);
+                    deferredSites.set(key, locations);
+                }
+            }
+            ts.forEachChild(node, visit);
+        };
+        visit(source);
+    }
+    return { deferredSites, lockingSites };
+}
+
+function repositorySources(): Array<{ path: string; text: string }> {
+    return SOURCE_ROOTS.flatMap((root) =>
+        sourceFiles(resolve(REPOSITORY_ROOT, root)).map((path) => ({
+            path: relative(REPOSITORY_ROOT, path),
+            text: readFileSync(path, "utf8"),
+        })),
+    );
+}
+
+describe("SQLite transaction lock mode", () => {
+    it("starts every writing transaction with .immediate() or .exclusive()", () => {
+        const { deferredSites, lockingSites } = scanTransactionModes(repositorySources());
+        // The scan must actually see the codebase's transactions.
+        expect(lockingSites).toBeGreaterThan(50);
+
+        const unlisted = [...deferredSites]
+            .filter(([key]) => !(key in READ_ONLY_DEFERRED_TRANSACTIONS))
+            .flatMap(([, locations]) => locations);
+        expect(unlisted).toEqual([]);
+
+        // One deferred transaction per listed function, so a second one added
+        // beside a read-only snapshot is not waved through by the same entry.
+        const repeated = [...deferredSites].filter(([, locations]) => locations.length > 1);
+        expect(repeated).toEqual([]);
+
+        // A listed entry whose transaction is gone or now locks must be removed.
+        const stale = Object.keys(READ_ONLY_DEFERRED_TRANSACTIONS).filter(
+            (key) => !deferredSites.has(key),
+        );
+        expect(stale).toEqual([]);
+    });
+
+    it("recognises each deferred and locking shape", () => {
+        const text = `
+            function plainCall(db) { db.transaction(() => write())(); }
+            function explicitDeferred(db) { db.transaction(() => write()).deferred(); }
+            function stored(db) { const tx = db.transaction(() => write()); tx(); }
+            function storedMixed(db) { const tx = db.transaction(() => write()); tx.immediate(); tx(); }
+            function immediate(db) { db.transaction(() => write()).immediate(); }
+            function chained(db) { return db\n.transaction(() => write())\n.exclusive(); }
+            function storedImmediate(db) { const tx = db.transaction(() => write()); return tx.immediate(); }
+        `;
+        const { deferredSites, lockingSites } = scanTransactionModes([{ path: "x.ts", text }]);
+        expect([...deferredSites.keys()].sort()).toEqual([
+            "x.ts#explicitDeferred",
+            "x.ts#plainCall",
+            "x.ts#stored",
+            "x.ts#storedMixed",
+        ]);
+        expect(lockingSites).toBe(3);
+    });
+});

package/src/shared/sqlite-write-locker-test-support.ts

@@ -0,0 +1,62 @@
+/**
+ * Holds a SQLite write lock from a separate process, for lock-contention tests.
+ *
+ * Run directly as `bun sqlite-write-locker-test-support.ts <db> <holdMs>`, the file
+ * opens the database, takes the write lock with BEGIN IMMEDIATE, prints `LOCKED`,
+ * holds the lock for `holdMs`, commits and prints `RELEASED`. Tests start it
+ * through `startSqliteWriteLocker`.
+ *
+ * The lock has to come from a different process. A second connection in the
+ * test's own process cannot release its lock while the test's main thread is
+ * blocked inside SQLite's busy wait, so the wait would always time out and a test
+ * could never observe a writer that waits and then succeeds.
+ */
+import { Database } from "bun:sqlite";
+
+export interface SqliteWriteLocker {
+    /** Resolves with the locker's exit code after it has committed and exited. */
+    exited: Promise<number>;
+}
+
+/** Start the locker and resolve once it reports that it holds the write lock. */
+export async function startSqliteWriteLocker(
+    dbPath: string,
+    holdMs: number,
+): Promise<SqliteWriteLocker> {
+    const child = Bun.spawn(["bun", import.meta.path, dbPath, String(holdMs)], {
+        stdout: "pipe",
+        stderr: "pipe",
+    });
+    const reader = child.stdout.getReader();
+    const decoder = new TextDecoder();
+    let seen = "";
+    while (!seen.includes("LOCKED\n")) {
+        const chunk = await reader.read();
+        if (chunk.done) {
+            const stderr = await new Response(child.stderr).text();
+            throw new Error(`sqlite write locker exited before locking: ${stderr}`);
+        }
+        seen += decoder.decode(chunk.value, { stream: true });
+    }
+    reader.releaseLock();
+    return { exited: child.exited };
+}
+
+function main(): void {
+    const [dbPath, holdArg] = process.argv.slice(2);
+    const holdMs = Number(holdArg);
+    if (!dbPath || !Number.isFinite(holdMs) || holdMs < 0) {
+        process.stderr.write("usage: sqlite-write-locker-test-support.ts <db> <holdMs>\n");
+        process.exit(2);
+    }
+    const db = new Database(dbPath);
+    db.exec("PRAGMA busy_timeout = 5000");
+    db.exec("BEGIN IMMEDIATE");
+    process.stdout.write("LOCKED\n");
+    Bun.sleepSync(holdMs);
+    db.exec("COMMIT");
+    db.close();
+    process.stdout.write("RELEASED\n");
+}
+
+if (import.meta.main) main();

package/src/shared/status-detail-text.test.ts

@@ -217,6 +217,29 @@ describe("status detail text", () => {
         );
     });
 
+    test("says which runner ran the session's completions and why", () => {
+        const status = formatStatusDetailMarkdown({
+            ...STATUS_FIXTURE,
+            historianRunner: {
+                runner: "host",
+                source: "default_for_harness",
+                harness: "opencode",
+                observed: "last_completion",
+            },
+            dreamerRunner: {
+                runner: "broca",
+                source: "configured",
+                harness: "opencode",
+                observed: "resolved_for_route",
+            },
+        });
+
+        expect(status).toMatch(
+            /^- \*\*Historian runner:\*\* host \(default for harness opencode\)$/m,
+        );
+        expect(status).toContain("- **Dreamer runner:** broca (configured) · no completion yet");
+    });
+
     test("does not expose module routing in the summary", () => {
         const rustStatus = formatStatusDetailMarkdown({
             ...STATUS_FIXTURE,

package/src/shared/status-summary.ts

@@ -1,5 +1,5 @@
 import { formatCacheTtlDisplay } from "./cache-ttl-display";
-import type { StatusDetail } from "./rpc-types";
+import type { RunnerStatus, StatusDetail } from "./rpc-types";
 import { renderUserFacingFailure, type UserFacingFailureKey } from "./user-facing-codes";
 
 export type StatusCompressionState = "off" | "compressing" | "ready" | "waiting";
@@ -32,6 +32,8 @@ export interface UserStatusSummary {
         detail: string;
     };
     compactionMarker?: StatusDetail["compactionMarker"];
+    historianRunner?: RunnerStatus;
+    dreamerRunner?: RunnerStatus;
     warnings: UserFacingFailureKey[];
     hiddenVariantWarnings?: string[];
 }
@@ -96,6 +98,8 @@ export function statusSummaryFromDetail(detail: StatusDetail): UserStatusSummary
             total: 0,
         },
         historianRefusal: detail.historianRefusal,
+        historianRunner: detail.historianRunner,
+        dreamerRunner: detail.dreamerRunner,
         compactionMarker: detail.compactionMarker,
         warnings: [...new Set(warnings)],
         hiddenVariantWarnings: detail.hiddenVariantWarnings ?? [],
@@ -122,6 +126,20 @@ function compressionText(summary: UserStatusSummary): string {
     }
 }
 
+/**
+ * `host (default for harness opencode)` or `broca (configured)`, plus a note when
+ * no completion has run yet in the module's current process and the value is
+ * only what the session's route resolves to.
+ */
+export function runnerText(status: RunnerStatus): string {
+    const why =
+        status.source === "configured"
+            ? "configured"
+            : `default for harness ${status.harness || "unknown"}`;
+    const observed = status.observed === "last_completion" ? "" : " · no completion yet";
+    return `${status.runner} (${why})${observed}`;
+}
+
 function reclaimableText(summary: UserStatusSummary): string {
     const count = Math.max(0, Math.floor(summary.reclaimable.toolOutputCount));
     if (count === 0) return "none";
@@ -170,6 +188,12 @@ export function renderUserStatusSummary(
         ],
         ["Search indexing", embeddingText(summary)],
     ];
+    if (summary.historianRunner) {
+        values.push(["Historian runner", runnerText(summary.historianRunner)]);
+    }
+    if (summary.dreamerRunner) {
+        values.push(["Dreamer runner", runnerText(summary.dreamerRunner)]);
+    }
     if (summary.historianRefusal) {
         values.push([
             "Historian refusal",

package/src/shared/status-view.ts

@@ -124,7 +124,7 @@ export interface StatusViewSource {
     readonly protectedTagCount: number;
     readonly isSubagent: boolean;
     readonly cacheTtl: string;
-    readonly cacheTtlSource?: "config" | "session" | "default";
+    readonly cacheTtlSource?: import("./cache-ttl-display").CacheTtlDisplaySource;
     readonly cacheTtlModelKey?: string;
     readonly lastResponseTime: number;
     readonly cacheRemainingMs: number;

package/src/shared/tag-transcript.ts

@@ -66,6 +66,7 @@ import {
     stripWellFormedLeadingTagPrefix,
 } from "../hooks/magic-context/tag-content-primitives";
 import type { TagTarget } from "../hooks/magic-context/tag-messages";
+import { toolInputStringBytes } from "../hooks/magic-context/tool-input-size";
 import type { Transcript, TranscriptMessage, TranscriptPart } from "./transcript";
 
 export const TEXT_TAG_IDENTITY_MARKER = ":mc-text-v1:";
@@ -161,6 +162,12 @@ interface ToolOccurrence {
     message: { info: { id?: string; role: string } };
     part: TranscriptPart;
     kind: "tool_use" | "tool_result";
+    /**
+     * The call's real input, captured the first time this pass overwrote it
+     * with the legacy marker, so a later real-argument render in the same pass
+     * can put it back.
+     */
+    originalInput?: Record<string, unknown>;
 }
 
 interface TagTranscriptTiming {
@@ -1093,10 +1100,13 @@ function buildAggregateTarget(
     const truncate = (): "truncated" | "absent" => {
         // Keep the tool call and its result, but replace the call arguments with
         // a non-executable marker and the result content with the dropped marker.
+        // Legacy render, replayed only for `drop_mode = 'truncated'` tags until a
+        // HARD fold converts them; new drops use skeletonReal().
         const sentinel = `[dropped \u00a7${tagId}\u00a7]`;
         let any = false;
         for (const occ of occurrences) {
             if (occ.kind === "tool_use" && occ.part.setToolInput) {
+                occ.originalInput ??= occ.part.getToolInput?.() ?? undefined;
                 if (occ.part.setToolInput(droppedInputMarker(tagId))) any = true;
             } else if (setToolContentOrText(occ.part, sentinel)) {
                 any = true;
@@ -1105,6 +1115,38 @@ function buildAggregateTarget(
         return any ? "truncated" : "absent";
     };
 
+    const complete = (): boolean =>
+        occurrences.some((occ) => occ.kind === "tool_use") &&
+        occurrences.some((occ) => occ.kind === "tool_result");
+
+    const skeletonReal = (): "truncated" | "absent" | "incomplete" => {
+        // Keep the tool call with the arguments the host gave it and replace
+        // only the result content with the dropped marker. Nothing is written
+        // into the argument position unless an earlier render this pass did,
+        // in which case the real input goes back.
+        if (!complete()) return "incomplete";
+        const sentinel = `[dropped \u00a7${tagId}\u00a7]`;
+        let any = false;
+        for (const occ of occurrences) {
+            if (occ.kind === "tool_use") {
+                if (occ.originalInput && occ.part.setToolInput?.(occ.originalInput)) any = true;
+            } else if (setToolContentOrText(occ.part, sentinel)) {
+                any = true;
+            }
+        }
+        return any ? "truncated" : "absent";
+    };
+
+    // Adapters without structural removal (or arcs that must keep their pair
+    // beside native reasoning) cannot remove the call; drop() would keep it.
+    const cannotRemove = (): boolean => {
+        if (requiresToolArcSkeleton) return true;
+        const authorization = occurrences.map((occ) => occ.part.canRemove?.());
+        return !occurrences.every(
+            (occ, index) => occ.part.remove && authorization[index] !== false,
+        );
+    };
+
     return {
         measureReclaim(skeleton) {
             let beforeTools = 0;
@@ -1125,10 +1167,8 @@ function buildAggregateTarget(
                         : (occ.part.getText() ?? "");
                 beforeTools += estimateTokens(before);
                 if (skeleton || !removable) {
-                    const after =
-                        occ.kind === "tool_use"
-                            ? JSON.stringify(droppedInputMarker(tagId))
-                            : `[dropped §${tagId}§]`;
+                    // A kept call keeps its real arguments; only the result shrinks.
+                    const after = occ.kind === "tool_use" ? before : `[dropped §${tagId}§]`;
                     afterTools += estimateTokens(after);
                 }
             }
@@ -1163,10 +1203,7 @@ function buildAggregateTarget(
             return occurrences[0]?.part.getText() ?? null;
         },
         drop(): "removed" | "truncated" | "absent" | "incomplete" {
-            const complete =
-                occurrences.some((occ) => occ.kind === "tool_use") &&
-                occurrences.some((occ) => occ.kind === "tool_result");
-            if (!complete) return "incomplete";
+            if (!complete()) return "incomplete";
             if (!requiresToolArcSkeleton) {
                 const authorization = occurrences.map((occ) => occ.part.canRemove?.());
                 // A failed durable marker is not permission to substitute a new
@@ -1178,19 +1215,23 @@ function buildAggregateTarget(
                     )
                 ) {
                     // If removing this call's result would leave the provider
-                    // request ending on an assistant turn, keep a call skeleton
-                    // plus placeholder result instead. "truncated" tells callers
-                    // to persist that mode, so later passes serve the same bytes.
+                    // request ending on an assistant turn, keep the call with its
+                    // REAL arguments plus the placeholder result instead.
+                    // "truncated" tells callers to persist that mode
+                    // (`skeleton_real`), so later passes serve the same bytes.
                     // (The sentinel fallback below keeps call and result in place,
                     // so it needs no exception.)
-                    if (conversationEnd?.wouldStrand(occurrences)) return truncate();
+                    if (conversationEnd?.wouldStrand(occurrences)) return skeletonReal();
                     let removed = false;
                     for (const occ of occurrences) removed = occ.part.remove?.() || removed;
                     if (removed) conversationEnd?.noteRemoved(occurrences);
                     return removed ? "removed" : "absent";
                 }
             }
-            // Adapters without structural removal retain paired sentinels.
+            // Adapters without structural removal retain paired sentinels. This
+            // writes a marker into the call's arguments, so only replays of
+            // existing `full` tags reach it: new drops check cannotRemove() and
+            // use skeletonReal(), and a HARD fold converts the existing ones.
             const sentinel = `[dropped \u00a7${tagId}\u00a7]`;
             let any = false;
             for (const occ of occurrences) {
@@ -1199,6 +1240,18 @@ function buildAggregateTarget(
             return any ? "removed" : "absent";
         },
         truncate,
+        skeletonReal,
+        cannotRemove,
+        inputStringBytes(): number | null {
+            for (const occ of occurrences) {
+                if (occ.kind !== "tool_use") continue;
+                return toolInputStringBytes(occ.originalInput ?? occ.part.getToolInput?.() ?? null);
+            }
+            return null;
+        },
+        wouldStrandConversationEnd(): boolean {
+            return conversationEnd?.wouldStrand(occurrences) ?? false;
+        },
         editMarker(): "truncated" | "absent" {
             // Edit-marker: preserve the tool_use input's filePath + a region
             // hint of the diff, sentinelize the result half. Separate from
@@ -1222,12 +1275,7 @@ function buildAggregateTarget(
             return any ? "truncated" : "absent";
         },
         // Open invocations still belong to the current turn; only complete arcs reclaim.
-        canDrop(): boolean {
-            return (
-                occurrences.some((occ) => occ.kind === "tool_use") &&
-                occurrences.some((occ) => occ.kind === "tool_result")
-            );
-        },
+        canDrop: complete,
         requiresToolArcSkeleton,
         // Non-mutating read of the invocation input (the tool_use occurrence
         // carries the arguments). Used by smart-drops supersession selection.
@@ -1310,11 +1358,26 @@ function buildToolTarget(
             return replaced ? "removed" : "absent";
         },
         truncate(): "truncated" | "absent" {
+            // Legacy render, replayed only for unconverted `truncated` tags.
             const changed = part.setToolInput
                 ? part.setToolInput(droppedInputMarker(tagId))
                 : setToolContentOrText(part, `[dropped \u00a7${tagId}\u00a7]`);
             return changed ? "truncated" : "absent";
         },
+        skeletonReal(): "truncated" | "absent" {
+            // An invocation part keeps its real arguments untouched; a result
+            // part's content becomes the dropped marker.
+            if (part.setToolInput) return "truncated";
+            return setToolContentOrText(part, `[dropped \u00a7${tagId}\u00a7]`)
+                ? "truncated"
+                : "absent";
+        },
+        // drop() replaces an invocation part's arguments with a marker, so a
+        // new drop of one keeps its real arguments instead.
+        cannotRemove: () => part.setToolInput !== undefined,
+        inputStringBytes(): number | null {
+            return part.setToolInput ? toolInputStringBytes(part.getToolInput?.() ?? null) : 0;
+        },
         message: {
             info: { id: message.info.id, role: message.info.role },
             parts: [],

package/src/shared/user-facing-codes.ts

@@ -33,6 +33,11 @@ export const USER_FACING_FAILURES = {
         sentence: "Memory maintenance could not reach its model.",
         action: "Check the model connection, then run /ctx-dream again.",
     },
+    dream_step_limit: {
+        code: "MC-D10",
+        sentence: "Memory maintenance stopped at its hidden agent step limit.",
+        action: "This task needs less work per run; changing the model connection will not help.",
+    },
     dream_empty_completion: {
         code: "MC-D03",
         sentence: "Memory maintenance received no usable response.",
@@ -199,6 +204,12 @@ export const USER_FACING_FAILURES = {
         sentence: "Magic Context is temporarily unavailable.",
         action: "Retry in a moment.",
     },
+    store_ahead_of_binary: {
+        code: "MC-C13",
+        sentence:
+            "Magic Context refused to start: its store (store.db) was migrated by a newer ck-mc build than the one running.",
+        action: "Update ck-mc, or roll back by restoring ck-mc together with context.db and store.db from the same backup.",
+    },
     compaction_marker_missing: {
         code: "MC-C11",
         sentence:
@@ -215,11 +226,6 @@ export const USER_FACING_FAILURES = {
         sentence: "Memory authority is inconsistent between the host and module.",
         action: "Run `ck doctor drain-authority` before changing Rust mode.",
     },
-    rust_mode_unsupported: {
-        code: "MC-S06",
-        sentence: "Experimental Rust transform mode is not available on this OpenCode host.",
-        action: 'Magic Context is running its TypeScript mode instead; set `transform_mode` to "ts" to stop requesting Rust.',
-    },
     dreamer_task_failing: {
         code: "MC-S05",
         sentence: "A background maintenance task keeps failing on its schedule.",
@@ -278,6 +284,7 @@ export function capabilityRefusalCode(capability: CapabilityRefusal): string {
 const DREAM_FAILURE_KEYS = {
     provider_timeout: "dream_provider_timeout",
     provider_error: "dream_provider_error",
+    step_limit: "dream_step_limit",
     empty_completion: "dream_empty_completion",
     no_models: "dream_no_models",
     child_aborted: "dream_child_aborted",

package/src/shared/window-geometry.ts

@@ -645,9 +645,12 @@ export function hasTrustedAbsoluteWall(geometry: WindowGeometryResult): boolean
 }
 
 /**
- * Successful requests can disprove static catalog metadata, but cannot
- * disprove a provider, overlay, or observed-overflow wall. A reading beyond
- * that wall is malformed usage accounting and must not enlarge the geometry.
+ * Successful requests can disprove static catalog metadata, but do not widen a
+ * provider, overlay, or observed-overflow wall here. A provider or overlay wall
+ * is the configured limit: a reading beyond it is real pressure against that
+ * limit (the usage handlers count it in full), not proof that the geometry
+ * should grow. An observed-overflow wall that a larger accepted request
+ * disproves is cleared by the usage handlers instead.
  */
 export function applyProvenInputFloor(
     geometry: WindowGeometryResult,

package/dist/v2/hooks/provider-admission.d.ts

@@ -1,22 +0,0 @@
-export interface ProviderAdmissionInput {
-    /** Input + cached-read + cached-write tokens of the newest assistant reply. */
-    inputTokens: number;
-    /** The provider's own context window for the outgoing model, when the catalog knows it. */
-    rawContextLimit: number | undefined;
-    /** True when the host wrote a compaction after the reply the tokens were read from. */
-    hostCompactionReducedUsage: boolean;
-}
-/**
- * Whether the OpenCode 2 context hook must stop a request before it reaches the
- * provider.
- *
- * The provider's own context window is the only admission boundary here. Every
- * other kind of pressure — in particular usage that fits the window but not the
- * room reserved for the reply — has to be admitted, because the work that
- * relieves it (compacting history into a compartment, and the high-pressure
- * handling around it) all happens further down this same pass. A request stopped
- * here runs none of it, so a session refused for pressure Magic Context could
- * have removed is refused again on every following turn.
- */
-export declare function refusesBeforeProvider(input: ProviderAdmissionInput): boolean;
-//# sourceMappingURL=provider-admission.d.ts.map

package/dist/v2/hooks/provider-admission.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"provider-admission.d.ts","sourceRoot":"","sources":["../../../src/v2/hooks/provider-admission.ts"],"names":[],"mappings":"AAAA,MAAM,WAAW,sBAAsB;IACnC,+EAA+E;IAC/E,WAAW,EAAE,MAAM,CAAC;IACpB,2FAA2F;IAC3F,eAAe,EAAE,MAAM,GAAG,SAAS,CAAC;IACpC,uFAAuF;IACvF,0BAA0B,EAAE,OAAO,CAAC;CACvC;AAKD;;;;;;;;;;;GAWG;AACH,wBAAgB,qBAAqB,CAAC,KAAK,EAAE,sBAAsB,GAAG,OAAO,CAkB5E"}

package/dist/wrapup-orchestrator-8xzbpvm8.js

@@ -1,18 +0,0 @@
-import {
-  runManagedWrapup2
-} from "./index-pa67brzn.js";
-import"./index-g6hpfkqa.js";
-import"./index-sd3egckz.js";
-import"./index-0ccmyzbj.js";
-import"./index-jgnag7sa.js";
-import"./index-tdrv6nd0.js";
-import"./index-y5145x8k.js";
-import"./index-bmzt6xgy.js";
-import"./index-9r1cbh9e.js";
-import"./index-jdxxq8cz.js";
-import"./index-febg06dy.js";
-import"./index-wgzyeyf5.js";
-import"./index-6z9g64js.js";
-export {
-  runManagedWrapup2 as runManagedWrapup
-};