@herbertgao/pi-extensions 2026.8.11 → 2026.8.13

package/node_modules/pi-lens/dist/clients/runtime-coordinator.js

@@ -2,6 +2,7 @@ import { randomBytes } from "node:crypto";
 import * as fs from "node:fs";
 import * as path from "node:path";
 import { logCascade } from "./cascade-logger.js";
+import { appendProjectChange, } from "./project-changes.js";
 import { normalizeMapKey, pathsEqual } from "./path-utils.js";
 import { PathKeyedMap } from "./path-keyed-map.js";
 import { BoundedLruCache } from "./bounded-cache.js";
@@ -9,6 +10,15 @@ import { ReadGuard } from "./read-guard.js";
 import { RUNTIME_CONFIG } from "./runtime-config.js";
 import { TurnSummaryCollector } from "./turn-summary.js";
 import { deriveProviderFromModelId } from "./model-provider.js";
+/**
+ * Bounded receipt ring capacity (defect shape 9: bound the axis that grows —
+ * per-mutation receipts are unbounded across a long session). Oldest receipts
+ * evict first; eviction is counted and surfaced via
+ * {@link RuntimeCoordinator.droppedMutationReceiptCount} so a consumer that
+ * needs a complete window knows the answer was truncated, never silently
+ * incomplete (#936 honesty rule).
+ */
+const MAX_MUTATION_RECEIPTS = 512;
 /**
  * Bound on in-flight tool_call → tool_result correlations. A tool_result
  * follows its tool_call almost immediately, so this only needs to cover
@@ -49,6 +59,8 @@ export class RuntimeCoordinator {
     _writtenThisTurn = new PathKeyedMap(normalizeMapKey);
     _autofixDemotedThisTurn = new PathKeyedMap(normalizeMapKey);
     _reportedThisTurn = new Set();
+    _mutationReceipts = [];
+    _droppedMutationReceipts = 0;
     _projectRulesScan = {
         rules: [],
         hasCustomRules: false,
@@ -119,6 +131,8 @@ export class RuntimeCoordinator {
         this._writtenThisTurn.clear();
         this._autofixDemotedThisTurn.clear();
         this._reportedThisTurn.clear();
+        this._mutationReceipts = [];
+        this._droppedMutationReceipts = 0;
         this._telemetrySessionId = `lens-${Date.now().toString(36)}-${randomBytes(4).toString("hex")}`;
         this._hasStableSessionId = false;
         this._telemetryModel = "unknown";
@@ -174,7 +188,9 @@ export class RuntimeCoordinator {
         const summaries = this.getInlineBlockersSnapshot()
             .map((entry) => entry.summary.trim())
             .filter(Boolean);
-        this._gitGuardSummary = (summaries[0] ?? firstLine ?? "Unresolved blockers detected").slice(0, 160);
+        this._gitGuardSummary = (summaries[0] ??
+            firstLine ??
+            "Unresolved blockers detected").slice(0, 160);
     }
     get gitGuardHasBlockers() {
         return this._gitGuardHasBlockers;
@@ -239,6 +255,68 @@ export class RuntimeCoordinator {
         this._writtenThisTurn.clear();
         this._autofixDemotedThisTurn.clear();
     }
+    /**
+     * THE one mutation seam. Every producer of an in-project file mutation —
+     * native write/edit, recognized bash writes, format/autofix, LSP workspace
+     * edits, and (phase 2) opaque script-write recovery — records through here,
+     * once: it bumps the seq store (`bumpFileSeq`), appends a bounded attributed
+     * receipt, and optionally appends the durable change-log entry. Consumers
+     * derive from `getFilesChangedSince` / `getMutationsSince`; no producer or
+     * consumer may hand-roll a parallel bump+log pairing (#2000 phase 1).
+     *
+     * Receipt recording never throws; change-log append failures route to
+     * `onAppendError` (default: swallowed) so telemetry cannot break dispatch.
+     */
+    recordProjectMutation(args) {
+        const { projectSeq, fileSeq, key } = this.bumpFileSeq(args.filePath);
+        if (this._mutationReceipts.length >= MAX_MUTATION_RECEIPTS) {
+            this._mutationReceipts.shift();
+            this._droppedMutationReceipts += 1;
+        }
+        this._mutationReceipts.push({
+            seq: projectSeq,
+            // Reuse the bump's normalized key (~200us realpath on Windows) —
+            // never re-derive it here.
+            filePath: key,
+            source: args.source,
+            turnIndex: this._turnIndex,
+            ts: Date.now(),
+        });
+        if (args.cwd !== undefined) {
+            try {
+                appendProjectChange(args.cwd, {
+                    seq: projectSeq,
+                    timestamp: new Date().toISOString(),
+                    sessionId: this.telemetrySessionId,
+                    turnIndex: this.turnIndex,
+                    source: args.source,
+                    filePath: path.resolve(args.filePath),
+                    fileSeq,
+                    changedRange: args.changedRange,
+                });
+            }
+            catch (err) {
+                args.onAppendError?.(err);
+            }
+        }
+        return { projectSeq, fileSeq };
+    }
+    /**
+     * Attributed mutations whose seq is strictly after `seq` — the receipt-level
+     * counterpart of {@link getFilesChangedSince}. Bounded: entries evicted by
+     * the ring cap are gone; compare `droppedMutationReceiptCount` against zero
+     * before treating the result as a complete window.
+     */
+    getMutationsSince(seq) {
+        // Shallow copies: a consumer mutating a returned receipt must not
+        // corrupt the ring's internal state.
+        return this._mutationReceipts
+            .filter((r) => r.seq > seq)
+            .map((r) => ({ ...r }));
+    }
+    get droppedMutationReceiptCount() {
+        return this._droppedMutationReceipts;
+    }
     /** Atomically records write/edit ordering before debounce can coalesce it. */
     recordMutationToolReceipt(filePath, toolName) {
         if (toolName === "write") {
@@ -359,12 +437,14 @@ export class RuntimeCoordinator {
         }
     }
     bumpFileSeq(filePath) {
+        // normalizeMapKey costs ~200us/call on Windows (realpath); every caller
+        // that also needs the key must reuse this one instead of paying it twice.
         const key = normalizeMapKey(path.resolve(filePath));
         this._projectSeq += 1;
         const fileSeq = (this._fileSeq.get(key) ?? 0) + 1;
         this._fileSeq.set(key, fileSeq);
         this._fileLastProjectSeq.set(key, this._projectSeq);
-        return { projectSeq: this._projectSeq, fileSeq };
+        return { projectSeq: this._projectSeq, fileSeq, key };
     }
     /**
      * Files whose most recent bump happened AFTER `seq` — i.e. every file the
@@ -1036,8 +1116,7 @@ export class RuntimeCoordinator {
  */
 export function readHostModelIdentity(ctx) {
     try {
-        const model = ctx
-            ?.model;
+        const model = ctx?.model;
         return {
             model: typeof model?.id === "string" ? model.id : undefined,
             provider: typeof model?.provider === "string" ? model.provider : undefined,

package/node_modules/pi-lens/dist/clients/runtime-session.js

@@ -43,8 +43,11 @@ import { TrivyClient } from "./trivy-client.js";
 import { isWarmAttached } from "./warm-attach.js";
 import { setSessionLanguages } from "./widget-state.js";
 import { logWordIndex } from "./word-index-logger.js";
+import { resetOpaqueMutationState } from "./opaque-mutation-scan.js";
+import { resetPendingAuxiliaryCoverage } from "./lsp/pending-aux-coverage.js";
 import { resetWorkspaceTopology } from "./workspace-topology.js";
 import { resetZizmorTokenAvailability } from "./zizmor-config.js";
+import { resetSpawnTimeoutCooldowns } from "./spawn-timeout-cooldown.js";
 const HOST_STALL_THRESHOLD_MS = 30_000;
 function logHostReadyDelay(deps, cwd) {
     if (!deps.emitHostReadyDelay ||
@@ -1608,6 +1611,12 @@ export async function handleSessionStart(deps) {
     // previously session-lived with no reset hook at all).
     resetWorkspaceTopology();
     clearTsconfigPathsCache();
+    // #2000: opaque-recovery baselines are keyed cwd:generation (unreachable
+    // after reset) and the git-worktree memo must re-probe after a session
+    // that may have seen a non-git dir become one.
+    resetOpaqueMutationState();
+    // #2026: pending auxiliary baselines are unreachable after generation bump.
+    resetPendingAuxiliaryCoverage();
     // #817/#1199: Windows command resolution is cached per (command, canonical
     // effective child PATH/PATHEXT/cwd/per-drive provenance); drop it each
     // session so environment changes (e.g.
@@ -1621,6 +1630,11 @@ export async function handleSessionStart(deps) {
     // the tool for the rest of the process lifetime. Clear it here, same
     // boundary as the other per-session caches on this line.
     resetDispatchAvailabilityState();
+    // #1995: a command that TIMED OUT (not merely failed a probe) cools down
+    // for the rest of the session so a hot loop of edits cannot hand the same
+    // wedged .cmd shim a second budget. A new session may retry: the executable
+    // or its environment may have changed.
+    resetSpawnTimeoutCooldowns();
     // #1895: formatter PATH verdicts are session-scoped, but they live in
     // formatters.ts and are not covered by the dispatch generation. Re-arm them
     // here so a formatter installed or removed between sessions is observed by

package/node_modules/pi-lens/dist/clients/runtime-tool-call.js

@@ -4,7 +4,10 @@ import { loadBootstrapClients } from "./bootstrap.js";
 import { recordDegradationOnce } from "./degradation-ledger.js";
 import { detectFileKind } from "./file-kinds.js";
 import { isPathIgnoredByProject } from "./file-utils.js";
-import { evaluateGitGuard, isGitCommitOrPushAttempt, } from "./git-guard.js";
+import { evaluateGitGuard, isGitCommitOrPushAttempt } from "./git-guard.js";
+import { logLatency } from "./latency-logger.js";
+import { normalizeMapKey } from "./path-utils.js";
+import { captureFileStats, getOpaqueBaselineStore, isGitWorktree, } from "./opaque-mutation-scan.js";
 import { normalizeForGuardMatch } from "./host-edit-normalize.js";
 import { retargetReplacementIndentation } from "./indent-retarget.js";
 import { LANGUAGE_POLICY } from "./language-policy.js";
@@ -17,7 +20,7 @@ import { EXPANSION_BUDGET_MS, EXPANSION_LIMIT_LINES, tryExpandRead, } from "./re
 import { boundedIndexesForCount, createReadGuardEditBatchSummary, getReadGuardCorrelationId, logReadGuardEvent, } from "./read-guard-logger.js";
 import { countFileLines, getTouchedLinesForGuard, relocateEditRange, tryCorrectIndentationMismatch, tryCorrectIndentationMismatchFromContent, } from "./read-guard-tool-lines.js";
 import { handleToolResult } from "./runtime-tool-result.js";
-import { isToolCallEventType, resolveToolCallCorrelationId } from "./tool-event.js";
+import { isToolCallEventType, resolveToolCallCorrelationId, } from "./tool-event.js";
 import { getSharedTreeSitterClient } from "./tree-sitter-shared.js";
 const LSP_TOOLCALL_NAV_TOUCH_BUDGET_MS = Math.max(0, Number.parseInt(process.env.PI_LENS_TOOLCALL_NAV_TOUCH_MS ??
     process.env.PI_LENS_LSP_NAV_CLIENT_WAIT_MS ??
@@ -317,6 +320,59 @@ async function handleToolCallImpl(deps) {
     });
     if (!lensEnabled)
         return;
+    // #2000 phase 2: opaque-command pre-snapshot. A bash command whose writes
+    // the extractor will not recognize gets a bounded stat snapshot of the
+    // project source universe BEFORE it runs; the tool_result side diffs it.
+    // Fire-and-forget capture is WRONG here (the child may finish first), but
+    // the capture is stat-only and budgeted, so awaiting it is bounded work on
+    // an already-second-scale bash path.
+    if (toolName === "bash") {
+        const commandInput = event.input;
+        if (typeof commandInput?.command === "string" && commandInput.command) {
+            const scanRoot = ctx.cwd ?? runtime.projectRoot;
+            if (scanRoot) {
+                const started = Date.now();
+                const rootKey = `${normalizeMapKey(path.resolve(scanRoot))}:${runtime.sessionGeneration}`;
+                let baseline;
+                let resultNote;
+                if (await isGitWorktree(scanRoot)) {
+                    // Git-first: the timestamp IS the baseline; git answers what
+                    // changed, at any repo size, with no file-universe cap.
+                    baseline = { startedAt: started, strategy: "git" };
+                    resultNote = "git";
+                }
+                else {
+                    const outcome = await captureFileStats(scanRoot, {
+                        withHashes: true,
+                    });
+                    baseline = outcome.snapshot
+                        ? {
+                            startedAt: started,
+                            strategy: "stat-diff",
+                            stats: outcome.snapshot,
+                        }
+                        : {
+                            startedAt: started,
+                            strategy: "stat-diff",
+                            statsUnknownReason: outcome.unknownReason ?? "walk-failed",
+                        };
+                    resultNote =
+                        outcome.unknownReason ?? `scanned:${outcome.scannedCount}`;
+                }
+                // Session-stamped key: a concurrent-secondary session (#473)
+                // replacing this slot must yield a no-pending-snapshot UNKNOWN
+                // for us - never a diff against another session's baseline.
+                getOpaqueBaselineStore().record(rootKey, baseline);
+                logLatency({
+                    type: "phase",
+                    phase: "opaque_mutation_prescan",
+                    filePath: commandInput.command.slice(0, 80),
+                    durationMs: Date.now() - started,
+                    result: resultNote,
+                });
+            }
+        }
+    }
     if (getFlag("lens-guard") &&
         isGitCommitOrPushAttempt(toolName, event.input)) {
         const guard = evaluateGitGuard(runtime, cacheManager, ctx.cwd ?? runtime.projectRoot);
@@ -456,7 +512,7 @@ async function handleToolCallImpl(deps) {
                     }
                 }
                 if (ctx.ui) {
-                    ctx.ui && updateLspStatus(ctx.ui.setStatus, ctx.ui.theme);
+                    updateLspStatus(ctx.ui.setStatus, ctx.ui.theme);
                 }
             })
                 .catch((err) => {

package/node_modules/pi-lens/dist/clients/runtime-tool-result.js

@@ -2,13 +2,15 @@ import * as nodeCrypto from "node:crypto";
 import * as nodeFs from "node:fs";
 import * as path from "node:path";
 import { noteAuthoritativeContentAttachment } from "./agent-nudge.js";
+import { captureFileStats, diffFileStats, getOpaqueBaselineStore, recoverOpaqueChangesViaGit, } from "./opaque-mutation-scan.js";
+import { normalizeMapKey } from "./path-utils.js";
 import { extractReadPathsFromCommand, extractDeletedPathsFromCommand, extractGrepSearchReadsFromOutput, extractWrittenPathsFromCommand, } from "./bash-file-access.js";
 import { registerSearchReads, } from "./search-read-registration.js";
 import { createFileTime } from "./file-time.js";
 import { publishFormatQueued } from "./format-events-publish.js";
 import { isPathIgnoredByProject } from "./file-utils.js";
 import { getFormatService } from "./format-service.js";
-import { isExternalOrVendorFile, normalizeEphemeralMapKey, pathsEqual } from "./path-utils.js";
+import { isExternalOrVendorFile, normalizeEphemeralMapKey, pathsEqual, } from "./path-utils.js";
 import { PathKeyedMap } from "./path-keyed-map.js";
 import { resolveLanguageRootForFile } from "./language-profile.js";
 import { logLatency } from "./latency-logger.js";
@@ -17,7 +19,6 @@ import { boundedIndexesForCount, createReadGuardEditBatchSummary, getReadGuardCo
 import { notifyExternalFileChange } from "./lsp/index.js";
 import { runPipeline } from "./pipeline.js";
 import { renderPostAutofixNotice, } from "./post-autofix-notice.js";
-import { appendProjectChange, } from "./project-changes.js";
 import { syncGitGuardRecord } from "./git-guard.js";
 import { scheduleWordIndexPersist } from "./word-index.js";
 import { RUNTIME_CONFIG } from "./runtime-config.js";
@@ -111,7 +112,8 @@ function scheduleDebounced(filePath, debounceMs, deps) {
     const existing = debouncedPipelines.get(filePath);
     if (existing) {
         clearTimeout(existing.timer);
-        const incomingId = deps._telemetryParticipantIds?.[0] ?? getReadGuardCorrelationId(deps.event);
+        const incomingId = deps._telemetryParticipantIds?.[0] ??
+            getReadGuardCorrelationId(deps.event);
         const priorIds = existing.latestDeps._telemetryParticipantIds ?? [];
         existing.latestDeps = {
             ...deps,
@@ -133,7 +135,9 @@ function scheduleDebounced(filePath, debounceMs, deps) {
         resolveFn = res;
         rejectFn = rej;
     });
-    const initialParticipantIds = deps._telemetryParticipantIds ?? [getReadGuardCorrelationId(deps.event)];
+    const initialParticipantIds = deps._telemetryParticipantIds ?? [
+        getReadGuardCorrelationId(deps.event),
+    ];
     const entry = {
         timer: setTimeout(() => {
             debouncedPipelines.delete(filePath);
@@ -183,25 +187,16 @@ function singleRange(ranges) {
     return ranges?.length === 1 ? ranges[0] : undefined;
 }
 function recordProjectChange(args) {
-    const bump = args.runtime.bumpFileSeq;
-    if (!bump)
-        return;
-    const { projectSeq, fileSeq } = bump.call(args.runtime, args.filePath);
-    try {
-        appendProjectChange(args.cwd, {
-            seq: projectSeq,
-            timestamp: new Date().toISOString(),
-            sessionId: args.runtime.telemetrySessionId,
-            turnIndex: args.runtime.turnIndex,
-            source: args.source,
-            filePath: path.resolve(args.filePath),
-            fileSeq,
-            changedRange: args.changedRange,
-        });
-    }
-    catch (err) {
-        args.dbg(`project change log append failed for ${args.filePath}: ${err}`);
-    }
+    // One mutation seam (#2000 phase 1): bump + receipt + change-log live in
+    // RuntimeCoordinator.recordProjectMutation; this wrapper only carries the
+    // legacy dbg shape.
+    args.runtime.recordProjectMutation?.({
+        filePath: args.filePath,
+        source: args.source,
+        cwd: args.cwd,
+        changedRange: args.changedRange,
+        onAppendError: (err) => args.dbg(`project change log append failed for ${args.filePath}: ${err}`),
+    });
 }
 export async function handleToolResult(deps) {
     const { event, getFlag, getFlagSource, dbg, runtime, cacheManager, biomeClient, ruffClient, metricsClient, resetLSPService, agentBehaviorRecord, formatBehaviorWarnings, } = deps;
@@ -233,7 +228,9 @@ export async function handleToolResult(deps) {
     if (attribution) {
         resolutionBasis = attribution.originCwd;
     }
-    else if (toolCallId !== undefined && rawFilePath && !path.isAbsolute(rawFilePath)) {
+    else if (toolCallId !== undefined &&
+        rawFilePath &&
+        !path.isAbsolute(rawFilePath)) {
         // A real correlation id existed (the host DOES support one) but no
         // attribution was recorded under it — evicted, cleared because the
         // call was blocked before it could execute, or simply never seen by
@@ -316,22 +313,128 @@ export async function handleToolResult(deps) {
     if (event.toolName === "bash" &&
         typeof event.input.command === "string") {
         const command = event.input.command;
-        const written = extractWrittenPathsFromCommand(command, workspaceRoot).filter((wp) => event.isError !== true &&
-            !isExternalOrVendorFile(wp, workspaceRoot) &&
-            !isPathIgnoredByProject(wp, workspaceRoot, false));
+        const recognized = extractWrittenPathsFromCommand(command, workspaceRoot);
+        // The SURVIVING recognized set: what will actually dispatch. Failure
+        // atomicity (#2000 invariant 5) means opaque recovery must subtract
+        // THIS set, not raw recognized - otherwise a redirect target dropped
+        // by the isError filter would be subtracted from recovery AND
+        // excluded here, attributed nowhere.
+        const recognizedWritten = event.isError !== true
+            ? recognized.filter((wp) => !isExternalOrVendorFile(wp, workspaceRoot) &&
+                !isPathIgnoredByProject(wp, workspaceRoot, false))
+            : [];
+        // #2000 phase 2: when the extractor recognizes NOTHING, the command is
+        // opaque-candidate — recover its actual changed set by diffing the pre
+        // snapshot taken at tool_call. Partial writes that landed before a
+        // nonzero exit ARE attributed (the files changed and the agent authored
+        // them) — a deliberate divergence from the isError filter above, which
+        // exists for restore semantics where attribution would lie.
+        let opaquePaths = [];
+        // Recovery runs for EVERY bash command with a pending baseline - not
+        // only recognized-empty ones. A mixed command (`python x.py > out.ts`
+        // plus script-internal writes) previously skipped observation entirely
+        // with zero telemetry; git-first recovery is cheap enough (~60ms) to
+        // close that gap, subtracting already-recognized paths so nothing
+        // double-dispatches.
+        if (workspaceRoot && !getFlag("no-read-guard")) {
+            const scanRoot = workspaceRoot;
+            const started = Date.now();
+            const pending = getOpaqueBaselineStore().take(`${normalizeMapKey(path.resolve(scanRoot))}:${runtime.sessionGeneration}`);
+            let unknownReason;
+            if (!pending && recognized.length > 0) {
+                // Partial coverage without observation: the explicit verdict
+                // invariant 1 demands (never silently imply no change).
+                unknownReason = "partial-recognition-no-baseline";
+            }
+            else if (!pending) {
+                unknownReason = "no-pending-snapshot";
+            }
+            else if (pending.strategy === "git") {
+                // Git-first: no universe cap - works on any repo size.
+                const recovery = await recoverOpaqueChangesViaGit(scanRoot, pending.startedAt);
+                if (recovery.verdict === "recovered") {
+                    opaquePaths = recovery.paths.filter((p) => !isExternalOrVendorFile(p, scanRoot) &&
+                        !isPathIgnoredByProject(p, scanRoot, false));
+                }
+                else if (recovery.verdict === "unknown" && recognized.length > 0) {
+                    // Git hiccup on a partially-recognized command: the
+                    // remainder's coverage is unknown, never clean-by-default.
+                    unknownReason = recovery.unknownReason;
+                }
+            }
+            else if (pending.stats) {
+                const outcome = await captureFileStats(scanRoot, {
+                    withHashes: true,
+                });
+                if (outcome.snapshot && !outcome.unknownReason) {
+                    opaquePaths = diffFileStats(pending.stats, outcome.snapshot);
+                }
+                else {
+                    unknownReason =
+                        outcome.unknownReason ??
+                            pending.statsUnknownReason ??
+                            "walk-failed";
+                }
+            }
+            else {
+                unknownReason = pending.statsUnknownReason ?? "walk-failed";
+            }
+            if (opaquePaths.length > 0 && recognizedWritten.length > 0) {
+                const survivingKeys = new Set(recognizedWritten.map((p) => normalizeMapKey(path.resolve(p))));
+                opaquePaths = opaquePaths.filter((p) => !survivingKeys.has(p));
+            }
+            if (unknownReason) {
+                logLatency({
+                    type: "phase",
+                    phase: "opaque_mutation_coverage_unknown",
+                    filePath: command.slice(0, 80),
+                    durationMs: Date.now() - started,
+                    result: unknownReason,
+                });
+            }
+            if (opaquePaths.length > 0) {
+                logLatency({
+                    type: "phase",
+                    phase: "opaque_mutation_recovered",
+                    filePath: opaquePaths.slice(0, 5).join(","),
+                    durationMs: Date.now() - started,
+                    result: `changed:${opaquePaths.length}`,
+                });
+            }
+        }
+        // wp iterates opaquePaths VERBATIM (already normalizeMapKey keys), so the
+        // set must hold those exact strings - no re-resolution.
+        const opaqueSet = new Set(opaquePaths);
+        const written = [...recognizedWritten, ...opaquePaths];
         for (const wp of written) {
             if (!getFlag("no-read-guard"))
                 deps.readGuard?.recordWritten(wp);
-            const receipt = runtime.recordMutationToolReceipt;
+            const receipt = runtime
+                .recordMutationToolReceipt;
             const autofixMode = receipt
                 ? receipt.call(runtime, wp, "write").autofixMode
                 : "immediate";
+            // Recovered opaque writes carry their own source so the change log
+            // distinguishes them from parsed writes (auditable in production).
+            const isOpaque = opaqueSet.has(wp);
+            // Failure atomicity: an opaque-recovered file VERIFIABLY exists on
+            // disk, so its synthetic event must not inherit isError - the main
+            // path early-returns on failed host results before attribution,
+            // which would silently drop exactly the partial writes invariant 5
+            // says to attribute.
+            const syntheticEvent = {
+                ...event,
+                toolName: "write",
+                input: { path: wp },
+                isError: false,
+            };
             const syntheticResult = await handleToolResult({
                 ...deps,
-                event: { ...event, toolName: "write", input: { path: wp } },
+                event: syntheticEvent,
                 _bypassDebounce: true,
                 _autofixMode: autofixMode,
                 _attachmentBudget: syntheticAttachmentBudget,
+                _mutationSourceOverride: isOpaque ? "opaque-script" : undefined,
             });
             if (syntheticResult) {
                 // #1590: forward verbatim. The synthetic call already charged the
@@ -475,9 +578,11 @@ export async function handleToolResult(deps) {
     }
     // Must happen before debounce admission: latestDeps intentionally retains only
     // the latest event, but write -> edit is a sticky turn transition.
-    const receipt = runtime.recordMutationToolReceipt;
+    const receipt = runtime
+        .recordMutationToolReceipt;
     const autofixMode = deps._bypassDebounce
-        ? (deps._autofixMode ?? (event.toolName === "edit" ? "deferred" : "immediate"))
+        ? (deps._autofixMode ??
+            (event.toolName === "edit" ? "deferred" : "immediate"))
         : receipt
             ? receipt.call(runtime, filePath, event.toolName).autofixMode
             : event.toolName === "edit"
@@ -612,7 +717,8 @@ export async function handleToolResult(deps) {
         runtime,
         cwd: turnStateCwd,
         filePath,
-        source: sourceForToolName(event.toolName, event.details),
+        source: deps._mutationSourceOverride ??
+            sourceForToolName(event.toolName, event.details),
         changedRange: singleRange(modifiedRanges),
         dbg,
     });
@@ -807,7 +913,9 @@ export async function handleToolResult(deps) {
         }
     }
     let autofixNewlyQueued = false;
-    if (!result.isError && autofixMode === "deferred" && nodeFs.existsSync(filePath)) {
+    if (!result.isError &&
+        autofixMode === "deferred" &&
+        nodeFs.existsSync(filePath)) {
         autofixNewlyQueued =
             runtime.deferMutation?.call(runtime, filePath, dispatchCwd, event.toolName, turnStateCwd, "autofix", deps.sessionId, resolutionBasis) ?? false;
         dbg(`tool_result: queued deferred autofix for ${filePath}`);
@@ -841,7 +949,13 @@ export async function handleToolResult(deps) {
         }
     }
     if (autofixNewlyQueued && !formatQueued) {
-        publishFormatQueued({ filePath, cwd: dispatchCwd, tool: event.toolName, kinds: ["autofix"], dbg });
+        publishFormatQueued({
+            filePath,
+            cwd: dispatchCwd,
+            tool: event.toolName,
+            kinds: ["autofix"],
+            dbg,
+        });
     }
     for (const changedFile of result.changedFiles ?? []) {
         const resolvedChanged = path.resolve(changedFile);