@retaw106/mmc-oc 2.1.2 → 2.2.0

package/src/shared/rpc-utils.test.ts

@@ -64,8 +64,8 @@ const OMP_PI_ARC_COMMAND =
     "C:\\Users\\qiiks\\.bun\\bin\\omp.exe C:\\Users\\qiiks\\AppData\\Roaming\\npm\\node_modules\\@oh-my-pi\\pi-coding-agent\\dist\\cli.js";
 const BUN_PI_CHILD_COMMAND =
     "C:\\Users\\qiiks\\.bun\\bin\\bun.exe C:\\Users\\qiiks\\AppData\\Roaming\\npm\\node_modules\\@oh-my-pi\\pi-coding-agent\\dist\\cli.js";
-// fork trim: OMP harness support is removed (T-003); bare `pi.exe` stands in
-// for the "image-only, no Pi arc" cases upstream covered with bare `omp.exe`.
+// Bare Pi and OMP images are insufficient to verify a harness without a Pi arc;
+// these discovery fixtures use bare `pi.exe` for that shared negative case.
 const BARE_PI_COMMAND = "C:\\Users\\qiiks\\.bun\\bin\\pi.exe";
 
 function padWmi(value: number, width = 2): string {
@@ -735,9 +735,7 @@ describe("proving a discovery record stale from the record's own start time", ()
     });
 
     test("an unreadable start time with an image no host can run is a reused PID", () => {
-        // fork trim: bare `omp.exe` joins this list — OMP harness support is
-        // removed (T-003), so an OMP image cannot be an mmc RPC host.
-        for (const imageName of ["svchost.exe", "WinAutomation.UserAgent.exe", "omp.exe"]) {
+        for (const imageName of ["svchost.exe", "WinAutomation.UserAgent.exe"]) {
             expect(
                 isPidIdentityPlausible(windowsRecord(RECORDED), {
                     startTime: null,
@@ -753,6 +751,7 @@ describe("proving a discovery record stale from the record's own start time", ()
             "opencode.exe",
             "OpenChamber.exe",
             "pi.exe",
+            "omp.exe",
             "bun.exe",
             "node.exe",
             "ck-mc.exe",

package/src/shared/sqlite-640-review.test.ts

@@ -0,0 +1,184 @@
+import { expect, test } from "bun:test";
+import { Database, SqliteAcquisitionBusyError, withAsyncPrivilegedWriter } from "./sqlite";
+
+function fixture() {
+    const db = new Database(":memory:");
+    db.exec("CREATE TABLE context_privilege_state(id INTEGER PRIMARY KEY, enabled INTEGER)");
+    db.exec("CREATE TABLE writes(value INTEGER)");
+    return db;
+}
+
+test("review: shared async admission rolls back callback busy without retrying side effects", async () => {
+    const db = fixture();
+    let callbacks = 0;
+    let recoveries = 0;
+    try {
+        await expect(
+            withAsyncPrivilegedWriter(
+                db,
+                () => {
+                    callbacks++;
+                    db.prepare("INSERT INTO writes VALUES (1)").run();
+                    throw new SqliteAcquisitionBusyError(new Error("nested acquisition busy"));
+                },
+                {
+                    beforeRetry: () => {
+                        recoveries++;
+                    },
+                },
+            ),
+        ).rejects.toThrow("SQLite writer acquisition remained busy");
+        expect(callbacks).toBe(1);
+        expect(recoveries).toBe(0);
+        expect(db.prepare("SELECT * FROM writes").all()).toEqual([]);
+        expect(db.inTransaction).toBe(false);
+    } finally {
+        db.close();
+    }
+});
+
+test("review: default OpenCode empty admission retries BEGIN only and preserves output bytes", async () => {
+    const db = fixture();
+    // Capture the currently routed exec; delegate through the original
+    // reference and restore it on exit (writer routing stays intact).
+    const originalExec = db.exec;
+    let attempts = 0;
+    db.exec = (sql) => {
+        if (sql === "BEGIN IMMEDIATE" && ++attempts === 1)
+            throw Object.assign(new Error("busy"), { code: "SQLITE_BUSY" });
+        return originalExec.call(db, sql);
+    };
+    try {
+        const output = [{ role: "user", content: "§1§ managed input" }];
+        const before = JSON.stringify(output);
+        await withAsyncPrivilegedWriter(db, () => undefined);
+        expect(attempts).toBe(2);
+        expect(JSON.stringify(output)).toBe(before);
+        expect(db.inTransaction).toBe(false);
+    } finally {
+        db.exec = originalExec;
+        db.close();
+    }
+});
+
+test("review: COMMIT busy after empty admission is surfaced once and transaction is released", async () => {
+    const db = fixture();
+    const originalExec = db.exec;
+    let callbacks = 0;
+    let commits = 0;
+    db.exec = (sql) => {
+        if (sql === "COMMIT") {
+            commits++;
+            // Controlled fault injection (not a real rollback-journal lock):
+            // verifies the writer surfaces the COMMIT rejection exactly once,
+            // never replays the callback, and releases the transaction.
+            throw Object.assign(new Error("reader holds rollback-journal lock"), {
+                code: "SQLITE_BUSY",
+            });
+        }
+        return originalExec.call(db, sql);
+    };
+    try {
+        await expect(
+            withAsyncPrivilegedWriter(db, () => {
+                callbacks++;
+            }),
+        ).rejects.toThrow("reader holds rollback-journal lock");
+        expect(callbacks).toBe(1);
+        expect(commits).toBe(1);
+        expect(db.inTransaction).toBe(false);
+    } finally {
+        db.exec = originalExec;
+        db.close();
+    }
+});
+
+// Negative control for the COMMIT fault above: with the injection removed,
+// the same empty admission resolves and commits normally.
+test("review: uninstrumented commit resolves normally after empty admission", async () => {
+    const db = fixture();
+    let callbacks = 0;
+    try {
+        await withAsyncPrivilegedWriter(db, () => {
+            callbacks++;
+        });
+        expect(callbacks).toBe(1);
+        expect(db.inTransaction).toBe(false);
+    } finally {
+        db.close();
+    }
+});
+
+test("review: three busy admissions still deliver the callback result exactly once", async () => {
+    const db = fixture();
+    const originalExec = db.exec;
+    let attempts = 0;
+    let callbacks = 0;
+    let recoveries = 0;
+    db.exec = (sql) => {
+        if (sql === "BEGIN IMMEDIATE" && ++attempts <= 3)
+            throw Object.assign(new Error("busy"), { code: "SQLITE_BUSY" });
+        return originalExec.call(db, sql);
+    };
+    try {
+        const payload = { messages: [{ role: "user", content: "unchanged" }] };
+        const before = JSON.stringify(payload);
+        const result = await withAsyncPrivilegedWriter(
+            db,
+            () => {
+                callbacks++;
+                db.prepare("INSERT INTO writes VALUES (1)").run();
+                return payload;
+            },
+            {
+                budgetMs: 10_000,
+                // Count-only observer: never adds side effects between retries.
+                beforeRetry: () => {
+                    recoveries++;
+                },
+            },
+        );
+        expect(attempts).toBe(4);
+        expect(callbacks).toBe(1);
+        expect(recoveries).toBe(3);
+        expect(JSON.stringify(result)).toBe(before);
+        expect(db.prepare("SELECT * FROM writes").all()).toEqual([{ value: 1 }]);
+        expect(db.inTransaction).toBe(false);
+    } finally {
+        db.exec = originalExec;
+        db.close();
+    }
+}, 10_000);
+
+// Control: no admission contention — one attempt, one callback, same delivery.
+test("review: uninstrumented admission delivers the callback result on the first attempt", async () => {
+    const db = fixture();
+    const originalExec = db.exec;
+    let admissions = 0;
+    db.exec = (sql) => {
+        if (sql === "BEGIN IMMEDIATE") admissions++;
+        return originalExec.call(db, sql);
+    };
+    let callbacks = 0;
+    try {
+        const payload = { messages: [{ role: "user", content: "unchanged" }] };
+        const before = JSON.stringify(payload);
+        const result = await withAsyncPrivilegedWriter(
+            db,
+            () => {
+                callbacks++;
+                db.prepare("INSERT INTO writes VALUES (1)").run();
+                return payload;
+            },
+            { budgetMs: 10_000 },
+        );
+        expect(JSON.stringify(result)).toBe(before);
+        expect(admissions).toBe(1);
+        expect(callbacks).toBe(1);
+        expect(db.prepare("SELECT * FROM writes").all()).toEqual([{ value: 1 }]);
+        expect(db.inTransaction).toBe(false);
+    } finally {
+        db.exec = originalExec;
+        db.close();
+    }
+}, 10_000);

package/src/shared/sqlite-context-pragmas.test.ts

@@ -0,0 +1,105 @@
+import { afterEach, describe, expect, it, spyOn } from "bun:test";
+import { readFileSync, rmSync } from "node:fs";
+import { tmpdir } from "node:os";
+import { join } from "node:path";
+import {
+    closeDatabase,
+    openDatabase,
+    openDatabaseAsync,
+} from "../features/magic-context/storage-db";
+import { Database } from "./sqlite";
+import { configureContextDatabasePragmas } from "./sqlite-context-pragmas";
+import { createTestTempDirFromPath } from "./test-temp-dir";
+
+const roots: string[] = [];
+function fixturePath(): string {
+    const root = createTestTempDirFromPath(join(tmpdir(), "mc-context-pragmas-"));
+    roots.push(root);
+    return join(root, "context.db");
+}
+afterEach(() => {
+    closeDatabase();
+    for (const root of roots.splice(0)) rmSync(root, { recursive: true, force: true });
+});
+
+describe("context database durability", () => {
+    it("fresh synchronous open uses WAL and synchronous=NORMAL", () => {
+        const db = openDatabase(fixturePath());
+        expect(db?.prepare("PRAGMA journal_mode").get()).toEqual({ journal_mode: "wal" });
+        expect(db?.prepare("PRAGMA synchronous").get()).toEqual({ synchronous: 1 });
+    });
+
+    it("fresh async open uses WAL and synchronous=NORMAL", async () => {
+        const db = await openDatabaseAsync({ dbPath: fixturePath() });
+        expect(db?.prepare("PRAGMA journal_mode").get()).toEqual({ journal_mode: "wal" });
+        expect(db?.prepare("PRAGMA synchronous").get()).toEqual({ synchronous: 1 });
+    });
+
+    it("refuses NORMAL when SQLite cannot activate WAL", () => {
+        const db = new Database(fixturePath());
+        const prepare = db.prepare.bind(db);
+        const spy = spyOn(db, "prepare").mockImplementation((sql: string) =>
+            prepare(sql === "PRAGMA journal_mode=WAL" ? "PRAGMA journal_mode" : sql),
+        );
+        try {
+            expect(() => configureContextDatabasePragmas(db)).toThrow("requires WAL");
+            expect(prepare("PRAGMA synchronous").get()).toEqual({ synchronous: 2 });
+        } finally {
+            spy.mockRestore();
+            db.close();
+        }
+    });
+
+    it("read-only inspection leaves a rollback-journal store unchanged", () => {
+        const path = fixturePath();
+        const writer = new Database(path);
+        writer.exec("CREATE TABLE probe(id INTEGER)");
+        writer.close();
+        const bytes = readFileSync(path);
+        const reader = new Database(path, { readonly: true });
+        try {
+            configureContextDatabasePragmas(reader, true);
+            expect(reader.prepare("PRAGMA journal_mode").get()).toEqual({ journal_mode: "delete" });
+            expect(reader.prepare("PRAGMA synchronous").get()).toEqual({ synchronous: 2 });
+        } finally {
+            reader.close();
+        }
+        expect(readFileSync(path)).toEqual(bytes);
+    });
+
+    it("an independently reopened WAL writer receives the connection-local policy", () => {
+        const path = fixturePath();
+        const first = new Database(path);
+        configureContextDatabasePragmas(first);
+        first.close();
+        const reopened = new Database(path);
+        try {
+            // Bun defaults WAL to NORMAL; Node defaults it to FULL. Exercise an
+            // explicit FULL connection so the assertion is portable to both.
+            reopened.exec("PRAGMA synchronous=FULL");
+            expect(reopened.prepare("PRAGMA synchronous").get()).toEqual({ synchronous: 2 });
+            configureContextDatabasePragmas(reopened);
+            expect(reopened.prepare("PRAGMA synchronous").get()).toEqual({ synchronous: 1 });
+        } finally {
+            reopened.close();
+        }
+    });
+
+    it("WAL configuration releases its read cursor before a sibling commits", () => {
+        const path = fixturePath();
+        const db = new Database(path);
+        const sibling = new Database(path);
+        try {
+            configureContextDatabasePragmas(db);
+            db.exec(
+                "CREATE TABLE probe(id INTEGER PRIMARY KEY, value INTEGER); INSERT INTO probe VALUES (1, 0)",
+            );
+            sibling.exec("UPDATE probe SET value = 1 WHERE id = 1");
+            db.exec("UPDATE probe SET value = 2 WHERE id = 1");
+            expect(db.prepare("SELECT value FROM probe").get()).toEqual({ value: 2 });
+        } finally {
+            db.close();
+            sibling.close();
+        }
+    });
+});

package/src/shared/sqlite-writer-diagnostics.test.ts

@@ -0,0 +1,136 @@
+import { afterAll, beforeAll, describe, expect, test } from "bun:test";
+import { existsSync, mkdirSync, readFileSync, rmSync } from "node:fs";
+import { tmpdir } from "node:os";
+import { join } from "node:path";
+import { createTestTempDirFromPath } from "./test-temp-dir";
+
+// The scenario runs in a child process with NODE_ENV=production because the
+// shared logger is silent under test. It imports storage-db for its side effect
+// of registering the real log sink, then drives three privileged writes and one
+// background writer through two connections on a throwaway database:
+//   wait  - another connection holds the lock for 300 ms, the hold is short
+//   hold  - the lock comes at once, the operation keeps it for 300 ms
+//   fast  - neither crosses the threshold, so nothing is logged
+//   async - beginSqliteWriterAsync acquires at once and holds for 300 ms
+const scenario = `
+    await import(${JSON.stringify(new URL("../features/magic-context/storage-db.ts", import.meta.url).href)});
+    const sqlite = await import(${JSON.stringify(new URL("./sqlite.ts", import.meta.url).href)});
+    const logger = await import(${JSON.stringify(new URL("./logger.ts", import.meta.url).href)});
+    const dbPath = process.env.SCENARIO_DB_PATH;
+    const holder = new sqlite.Database(dbPath);
+    holder.exec("PRAGMA journal_mode=WAL; CREATE TABLE context_privilege_state(id INTEGER PRIMARY KEY, enabled INTEGER)");
+    const writer = new sqlite.Database(dbPath);
+    const spin = (ms) => { const end = performance.now() + ms; while (performance.now() < end) {} };
+
+    holder.exec("BEGIN IMMEDIATE");
+    setTimeout(() => holder.exec("COMMIT"), 300);
+    await sqlite.withAsyncPrivilegedWriter(writer, () => undefined);
+
+    await sqlite.withAsyncPrivilegedWriter(writer, () => spin(300));
+
+    await sqlite.withAsyncPrivilegedWriter(writer, () => undefined);
+
+    await sqlite.beginSqliteWriterAsync(writer, "historian-publish");
+    spin(300);
+    writer.exec("COMMIT");
+
+    logger.flushLogger();
+    writer.close();
+    holder.close();
+`;
+
+let root: string | null = null;
+let logLines: string[] = [];
+let consoleOutput = "";
+
+function field(line: string, name: string): number {
+    const value = new RegExp(`\\b${name}=(\\d+)`).exec(line)?.[1];
+    if (value === undefined) throw new Error(`${name} missing from: ${line}`);
+    return Number(value);
+}
+
+describe("sqlite writer diagnostics", () => {
+    beforeAll(async () => {
+        root = createTestTempDirFromPath(join(tmpdir(), "mc-sqlite-writer-diagnostics-"));
+        const logPath = join(root, "magic-context.log");
+        const env: Record<string, string> = {
+            ...(process.env as Record<string, string>),
+            NODE_ENV: "production",
+            MMC_LOG_PATH: logPath,
+            MMC_STORAGE_DIR: join(root, "storage"),
+            SCENARIO_DB_PATH: join(root, "writer.db"),
+        };
+        for (const key of [
+            "HOME",
+            "OPENCODE_CONFIG_DIR",
+            "XDG_DATA_HOME",
+            "XDG_CONFIG_HOME",
+            "XDG_STATE_HOME",
+            "XDG_CACHE_HOME",
+        ]) {
+            env[key] = join(root, key);
+            mkdirSync(env[key]);
+        }
+        const child = Bun.spawn({
+            windowsHide: true,
+            cmd: ["bun", "--eval", scenario],
+            cwd: import.meta.dir,
+            env,
+            stdout: "pipe",
+            stderr: "pipe",
+        });
+        const [exitCode, stdout, stderr] = await Promise.all([
+            child.exited,
+            new Response(child.stdout).text(),
+            new Response(child.stderr).text(),
+        ]);
+        expect(exitCode, stderr).toBe(0);
+        consoleOutput = stdout + stderr;
+        logLines = existsSync(logPath)
+            ? readFileSync(logPath, "utf8")
+                  .split("\n")
+                  .filter((line) => line.includes("sqlite writer"))
+            : [];
+    }, 30_000);
+
+    afterAll(() => {
+        if (root) rmSync(root, { recursive: true, force: true });
+        root = null;
+    });
+
+    test("nothing reaches the host console", () => {
+        expect(consoleOutput).not.toContain("[magic-context]");
+        expect(consoleOutput).not.toContain("sqlite writer");
+    });
+
+    test("a writer that waited for the lock reports the wait, not its short hold", () => {
+        const waited = logLines.find((line) => line.includes("attempts=2"));
+        if (!waited) throw new Error(`no retried acquisition logged:\n${logLines.join("\n")}`);
+        expect(waited).toContain("[magic-context] sqlite writer site=privileged_writer");
+        expect(waited).toContain("lane=foreground");
+        expect(waited).toContain("outcome=committed");
+        expect(field(waited, "acquire_ms")).toBeGreaterThanOrEqual(250);
+        expect(field(waited, "hold_ms")).toBeLessThan(250);
+    });
+
+    test("a writer that held the lock reports the hold, not its quick acquisition", () => {
+        const held = logLines.filter(
+            (line) => line.includes("site=privileged_writer") && line.includes("attempts=1"),
+        );
+        expect(held).toHaveLength(1);
+        expect(field(held[0], "acquire_ms")).toBeLessThan(250);
+        expect(field(held[0], "hold_ms")).toBeGreaterThanOrEqual(300);
+    });
+
+    test("an async background writer reports its hold under its own site", () => {
+        const held = logLines.filter((line) => line.includes("site=historian-publish"));
+        expect(held).toHaveLength(1);
+        expect(held[0]).toContain("lane=background");
+        expect(field(held[0], "acquire_ms")).toBeLessThan(250);
+        expect(field(held[0], "hold_ms")).toBeGreaterThanOrEqual(300);
+    });
+
+    test("a fast writer stays out of the log", () => {
+        expect(logLines.filter((line) => line.includes("site=privileged_writer"))).toHaveLength(2);
+    });
+});

package/src/shared/subagent-runner.ts

@@ -31,6 +31,17 @@
 
 import type { ModelInput } from "./model-resolution";
 
+/**
+ * Hard ceiling on historian carrier steps per invocation (upstream 1c8526be
+ * parity: `hidden-agent-registrations` caps historian/recomp/editor at 4 —
+ * each pass emits one XML answer, so a small fixed cap bounds a runaway
+ * zero-tool loop; a per-request output cap or a timeout cannot bound step
+ * count). Shared by both harnesses: the OpenCode registration and executor
+ * safeguard clamp to it, and the Pi runner enforces it against assistant
+ * steps in the child's event stream.
+ */
+export const HISTORIAN_STEP_CAP = 4;
+
 /**
  * Configuration for one subagent invocation.
  *
@@ -84,6 +95,16 @@ export interface SubagentRunOptions {
      */
     thinkingLevel?: string | undefined;
 
+    /**
+     * Pi only: hard cap on assistant steps for this child run (kill with
+     * `step_limit` past it). OpenCode ignores this field — its step caps ride
+     * the host agent registration plus the hidden-child executor wiring.
+     * Absent on Pi → the historian default (`HISTORIAN_STEP_CAP`); used by
+     * the Pi maintenance runner (stage A fixed cap, stage B per-round
+     * remaining-budget cap).
+     */
+    stepCap?: number | undefined;
+
     /**
      * Optional progress callback. The runner invokes it for milestone events
      * during the run: spawn, first event received, terminal stop reason
@@ -158,6 +179,8 @@ export type SubagentProgressEvent =
  * - `reason`: failure category, one of:
  *     - `"invalid_prompt"`: a known zero-tool child was given no system prompt
  *     - `"timeout"`: hit `timeoutMs` before the child finished
+ *     - `"step_limit"`: the child exceeded its per-agent step cap
+ *       (historian; `HISTORIAN_STEP_CAP`)
  *     - `"abort"`: caller's `signal` was triggered
  *     - `"model_failed"`: every configured model + fallback returned an error
  *     - `"truncated"`: child stopped because model output hit length limits
@@ -203,6 +226,7 @@ export type SubagentRunResult =
               | "invalid_prompt"
               | "timeout"
               | "abort"
+              | "step_limit"
               | "model_failed"
               | "truncated"
               | "spawn_failed"

package/src/shared/tag-transcript.test.ts

@@ -177,6 +177,61 @@ class FakeDb {
 }
 
 describe("tagTranscript tool aggregation", () => {
+    it("exposes exact part references in mutationParts for aggregate, text, and tool targets", () => {
+        const tagger = new FakeTagger();
+        const firstUse = new TestPart("tool_use", "read:32", '{"file":"long-a"}');
+        const firstResult = new TestPart("tool_result", "read:32", "r1");
+        const textPart = new TestPart("text", undefined as unknown as string, "plain text");
+        const toolPart = new TestPart("tool_use", "read:77", '{"file":"other"}');
+        const transcript: Transcript = {
+            harness: "pi",
+            messages: [
+                { info: { id: "assistant-1", role: "assistant" }, parts: [firstUse, textPart] },
+                { info: { id: "user-1", role: "user" }, parts: [firstResult] },
+                { info: { id: "assistant-2", role: "assistant" }, parts: [toolPart] },
+            ],
+            commit() {},
+        };
+
+        const { targets } = tagTranscript(
+            "session-1",
+            transcript,
+            tagger,
+            new FakeDb() as unknown as ContextDatabase,
+        );
+
+        // Aggregate target: the projection carries the live part objects and
+        // the owner-scoped message info stubs, in occurrence order.
+        const aggregateTag = tagger.getToolTag("session-1", "read:32", "assistant-1");
+        const aggregate = targets.get(aggregateTag ?? -1);
+        expect(aggregate?.mutationParts).toEqual([
+            {
+                message: { info: { id: "assistant-1", role: "assistant" }, parts: [] },
+                part: firstUse,
+            },
+            { message: { info: { id: "user-1", role: "user" }, parts: [] }, part: firstResult },
+        ]);
+        expect(aggregate?.mutationParts?.[0]?.part).toBe(firstUse);
+        expect(aggregate?.mutationParts?.[1]?.part).toBe(firstResult);
+
+        // Text and single-tool targets: exact single-part projection.
+        let textTarget: { mutationParts?: unknown } | undefined;
+        let toolTarget: { mutationParts?: unknown } | undefined;
+        for (const target of targets.values()) {
+            const parts = (target as { mutationParts?: Array<{ part: unknown }> }).mutationParts;
+            if (parts?.length === 1 && parts[0].part === textPart) textTarget = target;
+            if (parts?.length === 1 && parts[0].part === toolPart) toolTarget = target;
+        }
+        expect(textTarget).toBeDefined();
+        expect(toolTarget).toBeDefined();
+        expect(
+            (textTarget as { mutationParts: Array<{ part: unknown }> }).mutationParts[0].part,
+        ).toBe(textPart);
+        expect(
+            (toolTarget as { mutationParts: Array<{ part: unknown }> }).mutationParts[0].part,
+        ).toBe(toolPart);
+    });
+
     it("keeps repeated callIds in separate owner-scoped aggregate targets", () => {
         const tagger = new FakeTagger();
         const firstUse = new TestPart("tool_use", "read:32", '{"file":"long-a"}');

package/src/shared/tag-transcript.ts

@@ -1157,6 +1157,10 @@ function buildAggregateTarget(
     };
 
     return {
+        mutationParts: occurrences.map((occ) => ({
+            message: { info: occ.message.info, parts: [] },
+            part: occ.part,
+        })),
         measureReclaim(skeleton) {
             let beforeTools = 0;
             let afterTools = 0;
@@ -1319,6 +1323,7 @@ function buildTextTarget(
     textPrefix: string,
 ): TagTarget {
     return {
+        mutationParts: [{ message: { info: message.info, parts: [] }, part }],
         textPrefix,
         setContent(content: string): boolean {
             return part.setText(content);
@@ -1351,6 +1356,7 @@ function buildToolTarget(
     tagId: number,
 ): TagTarget {
     return {
+        mutationParts: [{ message: { info: message.info, parts: [] }, part }],
         setContent(content: string): boolean {
             return setToolContentOrText(part, content);
         },

package/src/shared/write-transaction-attribution.test.ts

@@ -87,6 +87,10 @@ const nonBeginCoveredSites: Array<{ path: string; site: string }> = [
         path: "packages/plugin/src/features/magic-context/message-fts-rowid-map.ts",
         site: "message_fts_rowid_backfill",
     },
+    {
+        path: "packages/plugin/src/hooks/magic-context/lkg-persist.ts",
+        site: "lkg_stale_gc",
+    },
 ];
 
 let scenarioRoot: string | null = null;

package/src/shared/write-transaction-timing.test.ts

@@ -0,0 +1,39 @@
+import { expect, spyOn, test } from "bun:test";
+import * as logger from "./logger";
+import { logSlowWriteTransaction } from "./write-transaction-timing";
+
+test("slow-write diagnostics distinguish preparation from held rendering and writes", () => {
+    const log = spyOn(logger, "log").mockImplementation(() => {});
+    try {
+        logSlowWriteTransaction("fold", 100, 1000, 1400, {
+            pre_metadata: 1,
+            pre_onFoldPrepare: 200,
+            staleCheck: 5,
+            m1Render: 100,
+            persistCachedM0: 600,
+            sessionMeta: 5,
+            onFoldCommit: 10,
+            commit: 580,
+        });
+        expect(log.mock.calls).toEqual([
+            [
+                "[magic-context] slow write transaction: site=fold held=1300.0ms pre_metadata=1.0ms pre_onFoldPrepare=200.0ms staleCheck=5.0ms m1Render=100.0ms persistCachedM0=600.0ms sessionMeta=5.0ms onFoldCommit=10.0ms commit=580.0ms",
+            ],
+        ]);
+        logSlowWriteTransaction("fast", 100, 1000, 101);
+        expect(log).toHaveBeenCalledTimes(1);
+    } finally {
+        log.mockRestore();
+    }
+});
+
+test("step diagnostics cannot make a committed write appear to fail", () => {
+    const log = spyOn(logger, "log").mockImplementation(() => {
+        throw new Error("logging failed");
+    });
+    try {
+        expect(() => logSlowWriteTransaction("fold", 0, 1000, 2000, { commit: 10 })).not.toThrow();
+    } finally {
+        log.mockRestore();
+    }
+});