@herbertgao/pi-extensions 2026.8.4 → 2026.8.5

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

@@ -2,10 +2,12 @@ import * as path from "node:path";
 import { appendActionableWarningsHistory, buildActionableWarningsReport, formatActionableWarningsAdvisory, writeActionableWarningsReport, } from "./actionable-warnings.js";
 import { logActionableWarningsEvent } from "./actionable-warnings-logger.js";
 import { appendCodeQualityWarningsHistory, buildCodeQualityWarningsReport, formatCodeQualityWarningsAdvisory, writeCodeQualityWarningsReport, } from "./code-quality-warnings.js";
+import { clearGitGuardTestFailure, mergeGitGuardTestFailure, writeGitGuardRecord, } from "./git-guard.js";
 import { logCascade } from "./cascade-logger.js";
 import { normalizeMapKey } from "./path-utils.js";
 import { resolveRunnerPath, toRunnerDisplayPath, } from "./dispatch/runner-context.js";
 import { getKnipIgnorePatterns } from "./file-utils.js";
+import { isTestRoleCollateral } from "./collateral-test-role.js";
 import { dedupeSecretFindings, fromAstGrepWarnings, fromGitleaks, fromTrivySecrets, isSecretWarning, secretLocationKey, } from "./secret-findings.js";
 import { formatDeadCodeAdvisory } from "./dead-code-client.js";
 import { PROJECT_DIAGNOSTICS_CACHE_VERSION, writeProjectDiagnosticsDeltaReport, } from "./project-diagnostics/cache.js";
@@ -86,7 +88,7 @@ function capTurnEndMessage(content) {
     return out;
 }
 export async function handleTurnEnd(deps) {
-    const { ctxCwd, getFlag, dbg, runtime, cacheManager, knipClient, deadCodeClients, depChecker, testRunnerClient, resetLSPService, resetFormatService, } = deps;
+    const { ctxCwd, getFlag, dbg, runtime, cacheManager, knipClient, deadCodeClients, depChecker, testRunnerClient, owner, resetLSPService, resetFormatService, } = deps;
     // #449 slice 1: piggyback the instance-registry heartbeat on this existing
     // per-turn touchpoint rather than adding a new timer/interval. Cheap (reads
     // process.memoryUsage().rss, one read-modify-write of instances.json) and
@@ -106,16 +108,40 @@ export async function handleTurnEnd(deps) {
     });
     const cwd = ctxCwd ?? process.cwd();
     let turnState = cacheManager.readTurnState(cwd);
-    // Evict turn state written by a previous session — it carries stale file
-    // ranges that no longer reflect the current editing context.
-    if (turnState.sessionId &&
-        turnState.sessionId !== runtime.telemetrySessionId) {
-        dbg(`turn_end: evicting stale turn state (session ${turnState.sessionId} ≠ current ${runtime.telemetrySessionId})`);
-        cacheManager.clearTurnState(cwd);
+    // A live foreign writer owns this worklist. Do not clear or consume another
+    // pi/MCP session's files; a dead/aged owner is safely evicted instead.
+    const currentOwner = owner ?? {
+        kind: "pi",
+        id: runtime.telemetrySessionId,
+        pid: process.pid,
+        lastSeen: new Date().toISOString(),
+    };
+    const access = cacheManager.getTurnStateAccess(cwd, currentOwner);
+    const sameProcessPiSessionHandoff = access === "foreign-live" &&
+        currentOwner.kind === "pi" &&
+        turnState.owner?.kind === "pi" &&
+        turnState.owner.pid === process.pid &&
+        turnState.owner.id !== currentOwner.id;
+    if (access === "foreign-live" && !sameProcessPiSessionHandoff) {
+        dbg(`turn_end: foreign live owner retained (${turnState.owner?.kind ?? "legacy"}:${turnState.owner?.id ?? turnState.sessionId})`);
+        return;
+    }
+    if (access === "available" && (turnState.files || turnState.owner || turnState.sessionId)) {
+        dbg("turn_end: evicting stale turn-state owner");
+        cacheManager.clearTurnState(cwd, currentOwner);
         turnState = cacheManager.readTurnState(cwd);
     }
     const files = Object.keys(turnState.files);
     if (files.length === 0) {
+        // A genuinely clean session must invalidate the persisted guard record.
+        // Blocker records are retained only while the runtime still reports one.
+        if (getFlag("lens-guard") && !runtime.gitGuardHasBlockers) {
+            const guardRecord = cacheManager.readCache("turn-end-findings", cwd)?.data;
+            if (guardRecord?.sessionId === runtime.telemetrySessionId &&
+                guardRecord.testFailures !== true) {
+                cacheManager.clearCache("turn-end-findings", cwd);
+            }
+        }
         // #713: subagent sessions use a shorter idle reset (60s) — a short-lived
         // task agent holding a warm fleet for 4 minutes after its last turn is
         // pure waste under fan-out. Classify ONCE here so every tick in this call
@@ -143,7 +169,7 @@ export async function handleTurnEnd(deps) {
     dbg(`turn_end: ${files.length} file(s) modified, cycles: ${turnState.turnCycles}/${turnState.maxCycles}`);
     if (cacheManager.isMaxCyclesExceeded(cwd)) {
         dbg("turn_end: max cycles exceeded, clearing state and forcing through");
-        cacheManager.clearTurnState(cwd);
+        cacheManager.clearTurnState(cwd, currentOwner);
         runtime.fixedThisTurn.clear();
         resetFormatService();
         return;
@@ -155,7 +181,7 @@ export async function handleTurnEnd(deps) {
     const projectDiagnosticsSources = new Set();
     // Re-surface inline blockers from this turn that the agent didn't fix.
     // These were shown inline during write/edit but the agent moved on without resolving them.
-    const unresolvedBlockers = runtime.consumeInlineBlockers();
+    const unresolvedBlockers = runtime.getInlineBlockersSnapshot();
     for (const { filePath: bPath, summary } of unresolvedBlockers) {
         const displayPath = toRunnerDisplayPath(cwd, bPath);
         blockerParts.push(`Unresolved from this turn — ${displayPath}:\n${summary}`);
@@ -180,7 +206,14 @@ export async function handleTurnEnd(deps) {
     //   2. Neighbor-level: each neighbor is claimed by the latest cascade result
     //      that covers it — suppresses stale neighbor state from earlier writes.
     const t0 = Date.now();
-    const cascadeRuns = runtime.consumeCascadeRuns();
+    const cascadeRuns = runtime.consumeCascadeRuns().filter((run) => {
+        const originSeq = run.origin?.projectSeq;
+        const originTurn = run.origin?.turnSeq;
+        // A deferred result from before a later write/turn is not current state.
+        // Old test fixtures without provenance remain accepted for compatibility.
+        return ((originSeq === undefined || originSeq === runtime.projectSeq) &&
+            (originTurn === undefined || originTurn === runtime.turnIndex));
+    });
     const cascadeResults = cascadeRuns.flatMap((r) => r.result ? [r.result] : []);
     if (cascadeResults.length > 0) {
         const seen = new Map();
@@ -249,32 +282,62 @@ export async function handleTurnEnd(deps) {
     // (over-correction guard).
     const indeterminateRuns = cascadeRuns.filter((r) => r.indeterminate);
     if (indeterminateRuns.length > 0) {
-        const byDetail = new Map();
-        for (const r of indeterminateRuns) {
-            const detail = r.indeterminate?.detail ??
-                (r.indeterminate?.reason === "missing_node"
-                    ? "changed file not in the review graph"
-                    : "review graph unavailable");
-            const files = byDetail.get(detail) ?? [];
-            files.push(toRunnerDisplayPath(cwd, r.filePath));
-            byDetail.set(detail, files);
-        }
-        const lines = [];
-        for (const [detail, filesRaw] of byDetail) {
-            const files = [...new Set(filesRaw)];
-            const shown = files.slice(0, 5).join(", ");
-            const more = files.length > 5 ? ` (+${files.length - 5} more)` : "";
-            lines.push(`  • ${detail}: ${shown}${more}`);
-        }
-        const fileCount = new Set(indeterminateRuns.map((r) => normalizeMapKey(r.filePath))).size;
-        const reasons = [...byDetail.keys()].join("; ");
+        // #1104 (review P3 on PR #1143, rides with the resultId main body): this
+        // preamble used to hardcode a graph-unavailability frame for EVERY
+        // indeterminate reason. That's accurate for `graph_degraded`/
+        // `missing_node`/`error` (the graph really couldn't produce a dependent
+        // set), but `lsp_binding_rejected` is a DIFFERENT failure shape — the
+        // graph WAS available and dependents WERE derived; only their LSP
+        // diagnostics display was withheld because a fallback snapshot's content
+        // binding didn't match current disk. Saying "the review graph was
+        // unavailable" for that case mis-attributes the cause. Bucket by reason
+        // family so each gets its own accurate frame.
+        const buildAdvisory = (runs, frame) => {
+            if (runs.length === 0)
+                return undefined;
+            const byDetail = new Map();
+            for (const r of runs) {
+                const detail = r.indeterminate?.detail ?? frame.fallbackDetail(r);
+                const files = byDetail.get(detail) ?? [];
+                files.push(toRunnerDisplayPath(cwd, r.filePath));
+                byDetail.set(detail, files);
+            }
+            const lines = [];
+            for (const [detail, filesRaw] of byDetail) {
+                const files = [...new Set(filesRaw)];
+                const shown = files.slice(0, 5).join(", ");
+                const more = files.length > 5 ? ` (+${files.length - 5} more)` : "";
+                lines.push(`  • ${detail}: ${shown}${more}`);
+            }
+            const fileCount = new Set(runs.map((r) => normalizeMapKey(r.filePath))).size;
+            const reasons = [...byDetail.keys()].join("; ");
+            return `${frame.lead(fileCount, reasons)}\n${lines.join("\n")}`;
+        };
+        const graphRuns = indeterminateRuns.filter((r) => r.indeterminate?.reason !== "lsp_binding_rejected");
+        const bindingRuns = indeterminateRuns.filter((r) => r.indeterminate?.reason === "lsp_binding_rejected");
         // Factual/informational phrasing — the advisory tier wraps this with an
         // "ℹ️ Advisory — no action required this turn:" label, so an imperative
         // ("review dependents manually") would contradict it. The #533 substance
         // stays: a clean cascade result does NOT cover these files' dependents.
-        advisoryParts.push(`Cascade could not compute downstream impact for ${fileCount} edited file(s) this turn — ` +
-            `the review graph was unavailable (${reasons}), so their dependents were not ` +
-            `cascade-checked and a clean cascade result does not cover them.\n${lines.join("\n")}`);
+        const graphAdvisory = buildAdvisory(graphRuns, {
+            lead: (fileCount, reasons) => `Cascade could not compute downstream impact for ${fileCount} edited file(s) this turn — ` +
+                `the review graph was unavailable (${reasons}), so their dependents were not ` +
+                `cascade-checked and a clean cascade result does not cover them.`,
+            fallbackDetail: (r) => r.indeterminate?.reason === "missing_node"
+                ? "changed file not in the review graph"
+                : "review graph unavailable",
+        });
+        if (graphAdvisory)
+            advisoryParts.push(graphAdvisory);
+        const bindingAdvisory = buildAdvisory(bindingRuns, {
+            lead: (fileCount, reasons) => `Cascade identified dependents for ${fileCount} edited file(s) this turn, but their ` +
+                `diagnostics could not be freshly confirmed (${reasons}) and were withheld — a clean ` +
+                `cascade result does not cover them.`,
+            fallbackDetail: () => "cascade diagnostics withheld (binding rejected)",
+        });
+        if (bindingAdvisory)
+            advisoryParts.push(bindingAdvisory);
+        const fileCount = new Set(indeterminateRuns.map((r) => normalizeMapKey(r.filePath))).size;
         logCascade({
             phase: "cascade_indeterminate",
             filePath: files[0] ?? cwd,
@@ -516,6 +579,7 @@ export async function handleTurnEnd(deps) {
         advisoryParts.push(report);
     }
     const t3 = Date.now();
+    let madgeStats;
     if (await depChecker.ensureAvailable()) {
         const madgeFiles = cacheManager.getFilesForMadge(cwd);
         if (madgeFiles.length > 0) {
@@ -524,7 +588,9 @@ export async function handleTurnEnd(deps) {
             // the shared circular-dep state update is deferred/folded inside
             // checkFilesBatch so concurrent spawns can't clobber each other (#766).
             const absFiles = madgeFiles.map((file) => path.resolve(cwd, file));
-            const depResults = await depChecker.checkFilesBatch(absFiles, cwd);
+            const batch = await depChecker.checkFilesBatch(absFiles, cwd);
+            const depResults = batch.results;
+            madgeStats = batch.stats;
             for (const file of madgeFiles) {
                 const absPath = path.resolve(cwd, file);
                 const depResult = depResults.get(absPath);
@@ -550,6 +616,7 @@ export async function handleTurnEnd(deps) {
         filePath: cwd,
         phase: "madge",
         durationMs: Date.now() - t3,
+        ...(madgeStats && { metadata: madgeStats }),
     });
     // --- Test runner: fire once per turn after all edits are done ---
     // Runs for each unique test target across modified files; results appear
@@ -600,6 +667,7 @@ export async function handleTurnEnd(deps) {
         if (targets.length > 0) {
             dbg(`turn_end: firing ${targets.length} test target(s) async (non-blocking)`);
             const firedAtTurn = runtime.turnIndex;
+            const firedSessionId = runtime.telemetrySessionId;
             Promise.allSettled(targets.map((t) => testRunnerClient.runTestFileAsync(t.testFile, cwd, t.runner, t.config)))
                 .then((results) => {
                 // #628: the turn advancing while tests ran no longer means the
@@ -633,9 +701,20 @@ export async function handleTurnEnd(deps) {
                         ? `[from a prior turn — the edit that triggered this run had already been superseded by the time results came back]\n\n${failures.join("\n\n")}`
                         : failures.join("\n\n");
                     cacheManager.writeCache("test-runner-findings", { content, stale, results: resultValues }, cwd);
+                    if (getFlag("lens-guard") && firedSessionId === runtime.telemetrySessionId) {
+                        clearGitGuardTestFailure(cacheManager, cwd, runtime, resultValues
+                            .filter((value) => value.failed === 0)
+                            .map((value) => value.file));
+                        mergeGitGuardTestFailure(cacheManager, cwd, runtime, content, resultValues
+                            .filter((value) => value.failed > 0)
+                            .map((value) => value.file));
+                    }
                     dbg(`turn_end: ${failures.length} test failure(s) cached for next context injection${stale ? " (stale — turn advanced while tests ran)" : ""}`);
                 }
                 else if (results.length > 0) {
+                    if (getFlag("lens-guard") && firedSessionId === runtime.telemetrySessionId) {
+                        clearGitGuardTestFailure(cacheManager, cwd, runtime, resultValues.map((value) => value.file));
+                    }
                     dbg(`turn_end: all tests passed${stale ? " (stale — turn advanced while tests ran)" : ""}`);
                 }
             })
@@ -659,37 +738,68 @@ export async function handleTurnEnd(deps) {
     // would drop the call-graph entries — so lens_diagnostics (which only reads the
     // persisted report) would never surface the findings (#179/#533).
     if (runtime.callGraph && files.length > 0) {
-        try {
-            const { impact, formatImpact } = await import("./call-graph.js");
-            const { callGraphImpactToProjectDiagnostics } = await import("./project-diagnostics/runner-adapters/call-graph-impact.js");
-            const impactLines = [];
-            const impactFindings = [];
-            for (const filePath of files.slice(0, 5)) {
-                // Find callee keys for this file in the call graph
-                const fileCallerKeys = [...runtime.callGraph.callers.keys()].filter((k) => k.startsWith(`${filePath}:`));
-                for (const calleeKey of fileCallerKeys.slice(0, 3)) {
-                    const results = impact(runtime.callGraph, calleeKey);
-                    if (results.length > 0) {
-                        impactFindings.push({ calleeKey, results });
-                        const summary = formatImpact(results, cwd);
-                        if (summary)
-                            impactLines.push(`  ${calleeKey.split(":").pop()}: ${summary}`);
+        const coverage = runtime.callGraph.coverage;
+        if (!coverage || coverage.complete !== true) {
+            // An incomplete graph can still contain useful edges, but emitting them
+            // as ordinary impact findings would turn unsupported/partial extraction
+            // into an authoritative-looking clean result for the rest of the file.
+            // Keep the limitation visible and require a complete graph for this
+            // user-facing impact surface (#1070).
+            advisoryParts.push("Call-graph impact was not emitted because call-graph extraction coverage is incomplete; " +
+                "the affected files may have unreported callers.");
+        }
+        else {
+            try {
+                const { impact, formatImpact, parseSymbolKey } = await import("./call-graph.js");
+                const { callGraphImpactToProjectDiagnostics } = await import("./project-diagnostics/runner-adapters/call-graph-impact.js");
+                const impactLines = [];
+                const impactFindings = [];
+                for (const filePath of files.slice(0, 5)) {
+                    // Turn-state files may be cwd-relative while graph keys are absolute,
+                    // and persisted graphs can contain either slash style/casing. Compare
+                    // through the shared normalized path seam; keep the original filePath
+                    // only for display and diagnostics.
+                    const changedFileKey = normalizeMapKey(resolveRunnerPath(cwd, filePath));
+                    const fileCallerKeys = [...runtime.callGraph.callers.keys()].filter((k) => {
+                        const graphFilePath = parseSymbolKey(k).filePath;
+                        return normalizeMapKey(resolveRunnerPath(cwd, graphFilePath)) === changedFileKey;
+                    });
+                    for (const calleeKey of fileCallerKeys.slice(0, 3)) {
+                        // #1080: drop KNOWN test-role callers BEFORE both the human advisory
+                        // (formatImpact below) and the persisted delta (impactFindings →
+                        // callGraphImpactToProjectDiagnostics) — the advisory is rendered
+                        // first, so the filter must reach the shared `results` set that feeds
+                        // both. A test caller supplied by an old/fixture/expanded graph must
+                        // appear in neither surface. Fail-open: an unparseable/unclassifiable
+                        // key is retained (the adapter re-applies the same predicate).
+                        const results = impact(runtime.callGraph, calleeKey).filter((r) => {
+                            const callerFile = parseSymbolKey(r.symbolKey).filePath;
+                            return (!callerFile ||
+                                !isTestRoleCollateral(resolveRunnerPath(cwd, callerFile)));
+                        });
+                        if (results.length > 0) {
+                            impactFindings.push({ calleeKey, results });
+                            const summary = formatImpact(results, cwd);
+                            if (summary)
+                                impactLines.push(`  ${parseSymbolKey(calleeKey).symbolName ?? calleeKey}: ${summary}`);
+                        }
                     }
                 }
-            }
-            if (impactLines.length > 0) {
-                advisoryParts.push(`📊 Call-graph impact (changed symbols have callers):\n${impactLines.join("\n")}`);
-            }
-            if (impactFindings.length > 0) {
-                const impactDiagnostics = callGraphImpactToProjectDiagnostics(cwd, impactFindings);
-                if (impactDiagnostics.length > 0) {
-                    projectDiagnosticsDelta.push(...impactDiagnostics);
-                    projectDiagnosticsSources.add("call-graph");
+                if (impactLines.length > 0) {
+                    advisoryParts.push(`📊 Call-graph impact (changed symbols have callers):\n${impactLines.join("\n")}`);
                 }
+                if (impactFindings.length > 0) {
+                    const impactDiagnostics = callGraphImpactToProjectDiagnostics(cwd, impactFindings);
+                    if (impactDiagnostics.length > 0) {
+                        projectDiagnosticsDelta.push(...impactDiagnostics);
+                        projectDiagnosticsSources.add("call-graph");
+                    }
+                }
+                // Non-fatal — call graph is best-effort
+            }
+            catch {
+                // Non-fatal — call graph is best-effort
             }
-        }
-        catch {
-            // Non-fatal — call graph is best-effort
         }
     }
     if (projectDiagnosticsDelta.length > 0) {
@@ -838,7 +948,7 @@ export async function handleTurnEnd(deps) {
     catch (err) {
         dbg(`turn_end: dead-code advisory failed: ${err}`);
     }
-    cacheManager.incrementTurnCycle(cwd);
+    cacheManager.incrementTurnCycle(cwd, currentOwner);
     const labeledAdvisoryParts = advisoryParts.map((p) => `ℹ️ Advisory — no action required this turn:\n${p}`);
     const findingParts = [...blockerParts, ...labeledAdvisoryParts];
     if (findingParts.length > 0) {
@@ -852,12 +962,68 @@ export async function handleTurnEnd(deps) {
         if (last?.data?.signature === signature &&
             last?.data?.sessionId === runtime.telemetrySessionId) {
             dbg("turn_end: duplicate findings detected (same session), suppressing re-prompt");
-            cacheManager.clearTurnState(cwd);
+            if (getFlag("lens-guard")) {
+                const existingGuard = cacheManager.readCache("turn-end-findings", cwd)?.data;
+                if (existingGuard) {
+                    writeGitGuardRecord(cacheManager, runtime, cwd, {
+                        ...existingGuard,
+                        content,
+                        blockerContent: blockerParts.length > 0
+                            ? capTurnEndMessage(blockerParts.join("\n\n"))
+                            : undefined,
+                        hasBlockers: blockerParts.length > 0 || existingGuard.testFailures === true,
+                        blockingFiles: blockerParts.length > 0 ? existingGuard.affectedFiles : undefined,
+                        projectSeqStart: runtime.turnStartProjectSeq,
+                        projectSeqEnd: runtime.projectSeq,
+                        fileSeqByPath: Object.fromEntries(runtime.getFileSeqEntries().map(([filePath, seq]) => [normalizeMapKey(path.resolve(filePath)), seq])),
+                        fileContentHashes: {},
+                        consumed: false,
+                    });
+                }
+            }
+            cacheManager.clearTurnState(cwd, currentOwner);
             runtime.fixedThisTurn.clear();
             resetFormatService();
             return;
         }
-        cacheManager.writeCache("turn-end-findings", { content }, cwd);
+        const fileSeqByPath = {};
+        for (const [filePath, seq] of runtime.getFileSeqEntries()) {
+            fileSeqByPath[normalizeMapKey(path.resolve(filePath))] = seq;
+        }
+        if (getFlag("lens-guard")) {
+            const existingGuard = cacheManager.readCache("turn-end-findings", cwd)?.data;
+            const blockingContent = blockerParts.length > 0
+                ? capTurnEndMessage(blockerParts.join("\n\n"))
+                : undefined;
+            const affectedFiles = [
+                ...(existingGuard?.affectedFiles ?? []),
+                ...files.map((file) => resolveRunnerPath(cwd, file)),
+                ...cascadeResults.flatMap((result) => result.neighbors
+                    .filter((neighbor) => neighbor.diagnostics.length > 0)
+                    .map((neighbor) => resolveRunnerPath(cwd, neighbor.filePath))),
+            ];
+            writeGitGuardRecord(cacheManager, runtime, cwd, {
+                content: [content, existingGuard?.testFailureContent]
+                    .filter((value) => !!value)
+                    .join("\n\n"),
+                blockerContent: blockingContent,
+                blockingFiles: blockerParts.length > 0 ? affectedFiles : undefined,
+                hasBlockers: !!blockingContent || existingGuard?.testFailures === true,
+                affectedFiles,
+                sessionId: runtime.telemetrySessionId,
+                projectSeqStart: runtime.turnStartProjectSeq,
+                projectSeqEnd: runtime.projectSeq,
+                fileSeqByPath,
+                fileContentHashes: {},
+                consumed: false,
+                testFailures: existingGuard?.testFailures,
+                testFailureContent: existingGuard?.testFailureContent,
+                testFailureFiles: existingGuard?.testFailureFiles,
+            });
+        }
+        else {
+            cacheManager.writeCache("turn-end-findings", { content }, cwd);
+        }
         cacheManager.writeCache("turn-end-findings-last", {
             signature,
             sessionId: runtime.telemetrySessionId,
@@ -875,7 +1041,14 @@ export async function handleTurnEnd(deps) {
         });
     }
     if (blockerParts.length === 0) {
-        cacheManager.clearTurnState(cwd);
+        cacheManager.clearTurnState(cwd, currentOwner);
+        if (getFlag("lens-guard") && advisoryParts.length === 0 && !runtime.gitGuardHasBlockers) {
+            const guardRecord = cacheManager.readCache("turn-end-findings", cwd)?.data;
+            if (guardRecord?.sessionId === runtime.telemetrySessionId &&
+                guardRecord.testFailures !== true) {
+                cacheManager.clearCache("turn-end-findings", cwd);
+            }
+        }
     }
     runtime.fixedThisTurn.clear();
     runtime.clearActionableWarnings();

package/node_modules/pi-lens/dist/clients/rust-client.js

@@ -6,6 +6,7 @@
  * Requires: cargo (rustup)
  * Docs: https://doc.rust-lang.org/cargo/
  */
+import { createSubsystemLogger } from "./extension-log.js";
 import * as fs from "node:fs";
 import * as path from "node:path";
 import { safeSpawnAsync } from "./safe-spawn.js";
@@ -28,7 +29,7 @@ export class RustClient {
     log;
     constructor(verbose = false) {
         this.log = verbose
-            ? (msg) => console.error(`[rust] ${msg}`)
+            ? createSubsystemLogger("rust")
             : () => { };
     }
     /**