@herbertgao/pi-extensions 2026.8.5 → 2026.8.6

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

@@ -1,22 +1,72 @@
+import { provenanceStamp, validateAdvisoryProvenance, } from "./advisory-provenance.js";
+import { logLatency } from "./latency-logger.js";
 // Exported so the Stop-hook bin strips exactly what these bridges prepend.
 export const AUTOMATION_FRAMING = "[pi-lens automated check — not a user request] ";
-function turnEndMessage(content) {
+// #1432 review (S3b): a multi-file bash write can carry hundreds of changed
+// paths, one `reasons` entry apiece — logging all of them shrinks the
+// smells-rollup tail window (a fixed-size ring) to a handful of these
+// records. Cap what this decision row carries; the full list is never
+// needed for triage, only "how many and roughly what kind".
+const MAX_LOGGED_REASONS = 8;
+function boundedReasons(reasons) {
+    if (reasons.length <= MAX_LOGGED_REASONS)
+        return reasons;
+    return [
+        ...reasons.slice(0, MAX_LOGGED_REASONS),
+        `+${reasons.length - MAX_LOGGED_REASONS} more`,
+    ];
+}
+function logProvenanceDecision(validation, provenance, advisoryKind, cwd) {
+    logLatency({
+        type: "phase",
+        phase: "advisory_provenance_decision",
+        filePath: cwd,
+        durationMs: 0,
+        metadata: {
+            decision: validation.status === "current" ? "current" : "historical",
+            reasons: boundedReasons(validation.reasons),
+            changedPathCount: validation.changedPathCount,
+            provenanceStamp: provenanceStamp(provenance),
+            advisoryKind,
+        },
+    });
+}
+function historicalPrefix(provenance) {
+    return `Historical finding; workspace changed since capture; re-run to confirm. (${provenanceStamp(provenance)})`;
+}
+function historicalTestContent(content, provenance) {
+    return content.startsWith("[from a prior turn")
+        ? content
+        : `${historicalPrefix(provenance)}\n\n${content}`;
+}
+function turnEndMessage(content, current, provenance) {
     return {
         role: "user",
-        content: `${AUTOMATION_FRAMING}Address 🔴 blockers before continuing; ℹ️ advisories are informational only.\n\n${content}`,
+        content: current
+            ? `${AUTOMATION_FRAMING}Address 🔴 blockers before continuing; ℹ️ advisories are informational only.\n\n${content}`
+            : `${AUTOMATION_FRAMING}${historicalPrefix(provenance)}\n\n${content}`,
     };
 }
 /** Read a turn-end finding without changing its durable delivery state. */
-export function peekTurnEndFindings(cacheManager, cwd) {
+export function peekTurnEndFindings(cacheManager, cwd, runtime, logDelivery = false) {
     const findings = cacheManager.readCache("turn-end-findings", cwd);
     if (!findings?.data?.content || findings.data.consumed === true)
         return;
-    return { messages: [turnEndMessage(findings.data.content)] };
+    const validation = validateAdvisoryProvenance(findings.data, cwd, runtime);
+    if (logDelivery)
+        logProvenanceDecision(validation, findings.data.provenance, "turn-end", cwd);
+    if (validation.allFilesDeleted)
+        return;
+    return {
+        messages: [turnEndMessage(findings.data.content, validation.status === "current", findings.data.provenance)],
+    };
 }
-export function consumeTurnEndFindings(cacheManager, cwd) {
+export function consumeTurnEndFindings(cacheManager, cwd, runtime) {
     const findings = cacheManager.readCache("turn-end-findings", cwd);
     if (!findings?.data?.content || findings.data.consumed === true)
         return;
+    const validation = validateAdvisoryProvenance(findings.data, cwd, runtime);
+    logProvenanceDecision(validation, findings.data.provenance, "turn-end", cwd);
     // A blocker record is also the opt-in commit gate's durable state. Mark the
     // context message consumed without deleting the record; clean/advisory-only
     // records retain the historical consume-and-clear behavior.
@@ -27,29 +77,72 @@ export function consumeTurnEndFindings(cacheManager, cwd) {
     else {
         cacheManager.clearCache("turn-end-findings", cwd);
     }
-    return { messages: [turnEndMessage(findings.data.content)] };
+    if (validation.allFilesDeleted)
+        return;
+    return {
+        messages: [turnEndMessage(findings.data.content, validation.status === "current", findings.data.provenance)],
+    };
 }
 /** Read test findings without consuming them; used by acknowledged IPC delivery. */
-export function peekTestFindings(cacheManager, cwd) {
+export function peekTestFindings(cacheManager, cwd, runtime, logDelivery = false) {
     const findings = cacheManager.readCache("test-runner-findings", cwd);
     if (!findings?.data?.content)
         return;
+    const validation = validateAdvisoryProvenance(findings.data, cwd, runtime);
+    if (logDelivery)
+        logProvenanceDecision(validation, findings.data.provenance, "test-findings", cwd);
+    if (validation.allFilesDeleted)
+        return;
+    const current = validation.status === "current";
     return {
         messages: [
             {
                 role: "user",
-                content: `${AUTOMATION_FRAMING}Test failures detected last turn — fix before continuing:\n\n${findings.data.content}`,
+                content: current
+                    ? `${AUTOMATION_FRAMING}Test failures detected last turn — fix before continuing:\n\n${findings.data.content}`
+                    : `${AUTOMATION_FRAMING}${historicalTestContent(findings.data.content, findings.data.provenance)}`,
             },
         ],
     };
 }
-export function consumeTestFindings(cacheManager, cwd) {
-    const findings = peekTestFindings(cacheManager, cwd);
+export function consumeTestFindings(cacheManager, cwd, runtime) {
+    const record = cacheManager.readCache("test-runner-findings", cwd);
+    if (!record?.data?.content)
+        return;
+    const findings = peekTestFindings(cacheManager, cwd, runtime, true);
     if (!findings)
         return;
-    cacheManager.writeCache("test-runner-findings", null, cwd);
+    // Retire the content but PRESERVE the generation high-water mark: nulling
+    // the whole slot would let a still-in-flight OLDER batch see `undefined`,
+    // pass the strictly-greater suppression check, and resurrect a consumed
+    // one-shot advisory with stale results. An empty-content record peeks as
+    // undelivered while keeping late-generation ordering intact.
+    const priorGeneration = cacheManager.readCache("test-runner-findings", cwd)?.data?.testRunGeneration;
+    cacheManager.writeCache("test-runner-findings", { content: "", testRunGeneration: priorGeneration }, cwd);
     return findings;
 }
+/** Complete an acknowledged MCP delivery without re-validating or re-rendering it. */
+export function acknowledgeTurnEndFindings(cacheManager, cwd) {
+    const findings = cacheManager.readCache("turn-end-findings", cwd);
+    if (!findings?.data?.content || findings.data.consumed === true)
+        return;
+    if (findings.data.hasBlockers === true && typeof findings.data.sessionId === "string") {
+        cacheManager.writeCache("turn-end-findings", { ...findings.data, consumed: true }, cwd);
+    }
+    else {
+        cacheManager.clearCache("turn-end-findings", cwd);
+    }
+}
+export function acknowledgeTestFindings(cacheManager, cwd) {
+    const findings = cacheManager.readCache("test-runner-findings", cwd);
+    if (!findings?.data?.content)
+        return;
+    // Same high-water-mark preservation as consumeTestFindings.
+    cacheManager.writeCache("test-runner-findings", {
+        content: "",
+        testRunGeneration: findings.data.testRunGeneration,
+    }, cwd);
+}
 export function consumeSessionStartGuidance(cacheManager, cwd) {
     const guidance = cacheManager.readCache("session-start-guidance", cwd);
     if (!guidance?.data?.content)

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

@@ -1,11 +1,13 @@
 import { randomBytes } from "node:crypto";
 import * as fs from "node:fs";
 import * as path from "node:path";
+import { logCascade } from "./cascade-logger.js";
 import { normalizeMapKey } from "./path-utils.js";
 import { PathKeyedMap } from "./path-keyed-map.js";
 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";
 export class RuntimeCoordinator {
     _projectRoot = normalizeMapKey(process.cwd());
     _sessionGeneration = 0;
@@ -25,7 +27,9 @@ export class RuntimeCoordinator {
         coldSnapshotTouches: 0,
     };
     _complexityBaselines = new Map();
-    _fixedThisTurn = new Set();
+    _fixedThisTurn = new PathKeyedMap(normalizeMapKey);
+    _writtenThisTurn = new PathKeyedMap(normalizeMapKey);
+    _autofixDemotedThisTurn = new PathKeyedMap(normalizeMapKey);
     _reportedThisTurn = new Set();
     _projectRulesScan = {
         rules: [],
@@ -35,6 +39,19 @@ export class RuntimeCoordinator {
     _lifecycleReason;
     _hasStableSessionId = false;
     _telemetryModel = "unknown";
+    // Raw model/provider identity, separate from the combined `provider/model`
+    // display string above — worklog/disposition attribution (#1448) wants the
+    // two fields apart, blank when the host never supplied them. `_telemetryProvider`
+    // is the explicit host value when given, else derived from the model id
+    // (deriveProviderFromModelId, blank on ambiguity — never guessed).
+    _telemetryModelId = "";
+    _telemetryProvider = "";
+    // True once a host has supplied an explicit provider this session. An
+    // explicit provider is never downgraded by a derivation from a later
+    // model-only call; a DERIVED provider, by contrast, is re-derived on
+    // every model-only call so a mid-session model switch (e.g. gpt-5-mini →
+    // claude-sonnet-4-5) doesn't leave a stale provider from the old model.
+    _telemetryProviderIsExplicit = false;
     _turnIndex = 0;
     _writeIndex = 0;
     _projectSeq = 0;
@@ -51,7 +68,7 @@ export class RuntimeCoordinator {
     callGraph = null;
     wordIndex = null;
     _readGuard = null;
-    _pendingDeferredFormatFiles = new Map();
+    _pendingDeferredMutations = new PathKeyedMap(normalizeMapKey);
     _lspReadWarmState = new Map();
     _pendingInlineBlockers = new PathKeyedMap(normalizeMapKey);
     _actionableWarningsThisTurn = new Map();
@@ -78,10 +95,15 @@ export class RuntimeCoordinator {
             coldSnapshotTouches: 0,
         };
         this._fixedThisTurn.clear();
+        this._writtenThisTurn.clear();
+        this._autofixDemotedThisTurn.clear();
         this._reportedThisTurn.clear();
         this._telemetrySessionId = `lens-${Date.now().toString(36)}-${randomBytes(4).toString("hex")}`;
         this._hasStableSessionId = false;
         this._telemetryModel = "unknown";
+        this._telemetryModelId = "";
+        this._telemetryProvider = "";
+        this._telemetryProviderIsExplicit = false;
         this._turnIndex = 0;
         this._writeIndex = 0;
         this._projectSeq = 0;
@@ -92,7 +114,7 @@ export class RuntimeCoordinator {
         this._gitGuardSummary = "";
         this._gitGuardCacheUnknownReason = undefined;
         this._readGuard = null;
-        this._pendingDeferredFormatFiles.clear();
+        this._pendingDeferredMutations.clear();
         this._lspReadWarmState.clear();
         this._pendingInlineBlockers.clear();
         this._actionableWarningsThisTurn.clear();
@@ -145,7 +167,30 @@ export class RuntimeCoordinator {
         return this._gitGuardCacheUnknownReason;
     }
     beginTurn() {
-        this._cascadeRuns = [];
+        // #1443: runs sitting here at turn_start were appended AFTER the last
+        // turn_end drained them (consumeCascadeRuns) — the quiet-window reconcile's
+        // late re-injection (`onResolvedFound`, clients/lsp/cascade-tier.ts) lands
+        // in exactly that window. Wiping them dead-ended that delivery path: the
+        // finding was computed, formatted, appended, and then deleted before any
+        // turn_end could render it. Carry them into THIS turn instead, exactly
+        // once: `carriedTurns` is stamped on the way through and a run that the
+        // next turn_end still did not consume is dropped here with a log line
+        // rather than queued forever (a stale finding must not outlive the state
+        // it describes, and an unbounded queue would replay it every turn).
+        this._cascadeRuns = this._cascadeRuns.flatMap((run) => {
+            const carriedTurns = (run.carriedTurns ?? 0) + 1;
+            if (carriedTurns > 1) {
+                logCascade({
+                    phase: "cascade_carry_over_drop",
+                    filePath: run.filePath,
+                    neighborCount: run.neighborCount,
+                    diagnosticCount: run.diagnosticCount,
+                    metadata: { carriedTurns, turnIndex: this._turnIndex },
+                });
+                return [];
+            }
+            return [{ ...run, carriedTurns }];
+        });
         // _pendingCascadeRuns is deliberately NOT cleared here: a cascade compute
         // still in flight past last turn_end's settle cap (fresh graph builds have
         // measured up to ~19s) must surface on the NEXT turn_end, not be dropped —
@@ -166,6 +211,25 @@ export class RuntimeCoordinator {
         this._turnIndex += 1;
         this._writeIndex = 0;
         this._reportedThisTurn.clear();
+        this._writtenThisTurn.clear();
+        this._autofixDemotedThisTurn.clear();
+    }
+    /** Atomically records write/edit ordering before debounce can coalesce it. */
+    recordMutationToolReceipt(filePath, toolName) {
+        if (toolName === "write") {
+            this._writtenThisTurn.set(filePath, true);
+        }
+        else if (this._writtenThisTurn.has(filePath)) {
+            this._autofixDemotedThisTurn.set(filePath, true);
+            // A later edit establishes a new final state that must be eligible for
+            // the deferred pass even if the preceding write was fixed immediately.
+            this._fixedThisTurn.delete(filePath);
+        }
+        return {
+            autofixMode: toolName === "edit" || this._autofixDemotedThisTurn.has(filePath)
+                ? "deferred"
+                : "immediate",
+        };
     }
     get reportedThisTurn() {
         return this._reportedThisTurn;
@@ -192,6 +256,23 @@ export class RuntimeCoordinator {
         else if (provider) {
             this._telemetryModel = provider;
         }
+        if (model)
+            this._telemetryModelId = model;
+        if (provider) {
+            this._telemetryProvider = provider;
+            this._telemetryProviderIsExplicit = true;
+        }
+        else if (model && !this._telemetryProviderIsExplicit) {
+            // No explicit provider has ever been reported this session, so the
+            // provider is (still) a derivation — re-derive it from the CURRENT
+            // model id every time. Without this, a stale derived provider from
+            // an earlier model would survive a mid-session model switch (e.g.
+            // gpt-5-mini → claude-sonnet-4-5 with no explicit provider on
+            // either call) because the old "has any provider ever been set"
+            // guard treated the derived value as sticky. An explicit provider,
+            // once set, is never touched here regardless of later model calls.
+            this._telemetryProvider = deriveProviderFromModelId(model);
+        }
     }
     get telemetrySessionId() {
         return this._telemetrySessionId;
@@ -220,6 +301,17 @@ export class RuntimeCoordinator {
     get telemetryModel() {
         return this._telemetryModel;
     }
+    /** Raw model id (never the combined `provider/model` display string), blank
+     * when the host hasn't reported one this session. Worklog/disposition
+     * attribution (#1448) reads this, not {@link telemetryModel}. */
+    get telemetryModelId() {
+        return this._telemetryModelId;
+    }
+    /** Explicit host-reported provider, or a conservative derivation from the
+     * model id (see clients/model-provider.ts), blank when neither is known. */
+    get telemetryProviderId() {
+        return this._telemetryProvider;
+    }
     get turnIndex() {
         return this._turnIndex;
     }
@@ -378,6 +470,26 @@ export class RuntimeCoordinator {
         this._cascadeRuns = [];
         return runs;
     }
+    /**
+     * R1 (#1443 follow-up): non-destructive peek used by turn_end's read-only
+     * fast path. A carried cascade run (or one still in flight) represents a
+     * DELIVERY OPPORTUNITY, not turn activity — an agent that answers a question
+     * without editing anything must still get yesterday's late finding. Before
+     * this, the files-empty early return skipped `settleCascadeRuns` /
+     * `consumeCascadeRuns` entirely on a read-only turn, so `beginTurn`'s next
+     * carry pass saw the run as having survived a turn_start with no offsetting
+     * drain and dropped it — burning the one-turn carry allowance on a turn that
+     * never had a chance to deliver.
+     */
+    hasCascadeRuns() {
+        // Carried, ALREADY-BUILT runs only. Pending (still-settling) computes are
+        // deliberately excluded: a read-only turn that fell through for a pending
+        // run would block on the full settle cap — every turn, forever, when the
+        // compute never resolves (re-review finding F1). A pending run loses
+        // nothing by waiting: settleCascadeRuns re-parks it and the next turn
+        // that actually settles it delivers it.
+        return this._cascadeRuns.length > 0;
+    }
     recordInlineBlockers(filePath, summary) {
         this._pendingInlineBlockers.set(path.resolve(filePath), {
             filePath,
@@ -462,7 +574,19 @@ export class RuntimeCoordinator {
         return this._complexityBaselines;
     }
     get fixedThisTurn() {
-        return this._fixedThisTurn;
+        // Self-referencing local so chained add() returns the same facade
+        // instead of re-entering this getter and allocating a new one per call
+        // (sonar S7725).
+        const facade = {
+            add: (filePath) => {
+                this._fixedThisTurn.set(filePath, true);
+                return facade;
+            },
+            has: (filePath) => this._fixedThisTurn.has(filePath),
+            delete: (filePath) => this._fixedThisTurn.delete(filePath),
+            clear: () => this._fixedThisTurn.clear(),
+        };
+        return facade;
     }
     get projectRulesScan() {
         return this._projectRulesScan;
@@ -475,39 +599,47 @@ export class RuntimeCoordinator {
         return this._readGuard;
     }
     /**
-     * Queue `filePath` for deferred formatting at `agent_end`. Returns `true`
-     * when this call created a NEW pending entry, `false` when it re-touched
-     * an already-queued file. #673: the caller uses this to publish
-     * `pilens:format:queued` only on first queue entry, so repeated edits to
-     * the same already-queued file before `agent_end` don't spam the bus.
+     * Queue one mutation kind for `filePath` at `agent_end`. Returns `true`
+     * when this call created a pending entry or added a new kind, and `false`
+     * for a same-kind re-touch. Callers publish each kind's first transition
+     * without spamming repeated edits before `agent_end`.
      */
-    deferFormat(filePath, cwd, toolName, turnStateCwd, ownerSessionId) {
+    deferMutation(filePath, cwd, toolName, turnStateCwd, kind, ownerSessionId) {
         const key = path.resolve(filePath);
         const now = Date.now();
-        const existing = this._pendingDeferredFormatFiles.get(key);
+        const existing = this._pendingDeferredMutations.get(key);
         if (existing) {
+            const addedKind = !existing.kinds.has(kind);
             existing.lastTouchedAt = now;
             existing.cwd = cwd;
             existing.turnStateCwd = turnStateCwd;
             existing.toolNames.add(toolName);
+            existing.kinds.add(kind);
             existing.queuedTurnIndex = this._turnIndex;
             existing.ownerSessionId = ownerSessionId;
-            return false;
+            return addedKind;
         }
-        this._pendingDeferredFormatFiles.set(key, {
+        this._pendingDeferredMutations.set(key, {
             filePath: key,
             cwd,
             turnStateCwd,
             firstTouchedAt: now,
             lastTouchedAt: now,
             toolNames: new Set([toolName]),
+            kinds: new Set([kind]),
             queuedTurnIndex: this._turnIndex,
             ownerSessionId,
         });
         return true;
     }
+    deferFormat(filePath, cwd, toolName, turnStateCwd, ownerSessionId) {
+        return this.deferMutation(filePath, cwd, toolName, turnStateCwd, "format", ownerSessionId);
+    }
     get pendingDeferredFormatCount() {
-        return this._pendingDeferredFormatFiles.size;
+        return this._pendingDeferredMutations.size;
+    }
+    get pendingDeferredMutationCount() {
+        return this._pendingDeferredMutations.size;
     }
     /**
      * Legacy unconditional drain — still exposed for any caller that
@@ -515,8 +647,8 @@ export class RuntimeCoordinator {
      * flush call sites should prefer {@link claimDeferredFormatFiles}.
      */
     consumeDeferredFormatFiles() {
-        const records = [...this._pendingDeferredFormatFiles.values()];
-        this._pendingDeferredFormatFiles.clear();
+        const records = [...this._pendingDeferredMutations.values()];
+        this._pendingDeferredMutations.clear();
         return records;
     }
     /**
@@ -540,19 +672,19 @@ export class RuntimeCoordinator {
         const claimed = [];
         const staleClaimed = [];
         const deferredToOwner = [];
-        for (const [key, record] of this._pendingDeferredFormatFiles) {
+        for (const [key, record] of this._pendingDeferredMutations) {
             const sameSession = record.ownerSessionId === undefined ||
                 currentSessionId === undefined ||
                 record.ownerSessionId === currentSessionId;
             if (sameSession) {
                 claimed.push(record);
-                this._pendingDeferredFormatFiles.delete(key);
+                this._pendingDeferredMutations.delete(key);
                 continue;
             }
             const age = now - record.lastTouchedAt;
             if (age > staleAfterMs) {
                 staleClaimed.push(record);
-                this._pendingDeferredFormatFiles.delete(key);
+                this._pendingDeferredMutations.delete(key);
                 continue;
             }
             deferredToOwner.push(record);
@@ -563,11 +695,27 @@ export class RuntimeCoordinator {
     requeueDeferredFormatFiles(records) {
         for (const record of records) {
             const key = path.resolve(record.filePath);
-            if (!this._pendingDeferredFormatFiles.has(key)) {
-                this._pendingDeferredFormatFiles.set(key, record);
+            const existing = this._pendingDeferredMutations.get(key);
+            if (existing) {
+                for (const kind of record.kinds)
+                    existing.kinds.add(kind);
+                for (const toolName of record.toolNames)
+                    existing.toolNames.add(toolName);
+                continue;
             }
+            this._pendingDeferredMutations.set(key, {
+                ...record,
+                kinds: new Set(record.kinds),
+                toolNames: new Set(record.toolNames),
+            });
         }
     }
+    claimDeferredMutations(currentSessionId, now, staleAfterMs) {
+        return this.claimDeferredFormatFiles(currentSessionId, now, staleAfterMs);
+    }
+    requeueDeferredMutations(records) {
+        this.requeueDeferredFormatFiles(records);
+    }
     shouldWarmLspOnRead(filePath, maxAgeMs = 120_000) {
         const state = this._lspReadWarmState.get(path.resolve(filePath));
         if (!state)

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

@@ -1,15 +1,16 @@
 import * as nodeFs from "node:fs";
 import * as path from "node:path";
+import { createDeadline, yieldIfOverBudget } from "./cooperative-budget.js";
 import { deadCodeIssueCount } from "./dead-code-client.js";
 import { logDeadCodeScan } from "./dead-code-logger.js";
-import { getDiagnosticTracker } from "./diagnostic-tracker.js";
 import { resetDegradationLedger } from "./degradation-ledger.js";
+import { getDiagnosticTracker } from "./diagnostic-tracker.js";
 import { resetDispatchAvailabilityState } from "./dispatch/runners/utils/runner-helpers.js";
 import { clearAllSessions as clearFileTimeSessions } from "./file-time.js";
-import { createDeadline, yieldIfOverBudget } from "./cooperative-budget.js";
 import { getGlobalPiLensDir, getKnipIgnorePatterns, getProjectDataDir, } from "./file-utils.js";
 import { GitleaksClient } from "./gitleaks-client.js";
 import { GovulncheckClient, } from "./govulncheck-client.js";
+import { sweepAtomicWriteStages } from "./instance-reaper.js";
 import { canRunStartupHeavyScans } from "./language-policy.js";
 import { detectProjectLanguageProfile, getDefaultStartupTools, } from "./language-profile.js";
 import { logLatency } from "./latency-logger.js";
@@ -27,7 +28,6 @@ import { getSlowFsVerdict, isSlowFs, slowFsDegradationNotice, } from "./slow-fs.
 import { countRecentSmells, formatSmellsSessionStartLine, resetSmellsSessionState, } from "./smells-rollup.js";
 import { findNearestProjectRoot, getStartupScanMaxEntries, isStartupScanVerdictFresh, resolveStartupScanContext, } from "./startup-scan.js";
 import { getSubagentIdentity, isSubagentSession, subagentLightModeNotice, } from "./subagent-mode.js";
-import { sweepAtomicWriteStages } from "./instance-reaper.js";
 import { TrivyClient } from "./trivy-client.js";
 import { isWarmAttached } from "./warm-attach.js";
 import { setSessionLanguages } from "./widget-state.js";
@@ -452,10 +452,14 @@ async function buildOrRefreshWordIndex(args) {
     let rebuildPreflightFiles;
     const latestSeq = readLatestProjectSequence(snapshotRoot, snapshotSequenceBase(snapshotRoot));
     const effectiveSeq = runtime.projectSeq ?? latestSeq.projectSeq;
+    const snapshotLoadStartMs = Date.now();
     const snapshot = loadProjectSnapshot(snapshotRoot);
+    const snapshotLoadMs = Date.now() - snapshotLoadStartMs;
     if (snapshot?.wordIndex) {
         const { deserializeWordIndex, refreshWordIndexIncrementally } = await import("./word-index.js");
+        const deserializeStartMs = Date.now();
         const index = deserializeWordIndex(snapshot.wordIndex);
+        const deserializeMs = Date.now() - deserializeStartMs;
         if (index) {
             try {
                 const result = await refreshWordIndexIncrementally(index, analysisRoot, () => runtime.isCurrentSession(sessionGeneration));
@@ -469,10 +473,16 @@ async function buildOrRefreshWordIndex(args) {
                         cwd: snapshotRoot,
                         trigger: "session_start",
                         reason: result.reason,
+                        phaseDurationsMs: {
+                            snapshotLoadMs,
+                            deserializeMs,
+                            ...result.timings,
+                        },
                     });
                 }
                 else {
                     runtime.wordIndex = index;
+                    let snapshotSaveSyncMs = 0;
                     // A stale project seq must be advanced even when mtimes prove every
                     // indexed document reusable. Fresh snapshots with no changes avoid
                     // an unnecessary rewrite of the large shared snapshot.
@@ -480,9 +490,15 @@ async function buildOrRefreshWordIndex(args) {
                         result.refreshed > 0 ||
                         result.dropped > 0 ||
                         snapshot.wordIndex.truncated !== index.truncated) {
+                        const serializeSaveEnqueueStartMs = Date.now();
                         saveRuntimeProjectSnapshot({ cwd: snapshotRoot, runtime, dbg });
+                        snapshotSaveSyncMs = Date.now() - serializeSaveEnqueueStartMs;
                     }
-                    dbg(`session_start word-index: incremental (seq=${effectiveSeq}, refreshed=${result.refreshed}, dropped=${result.dropped}, skipped=${result.skipped}, reused=${result.reused}, ${Date.now() - startMs}ms)`);
+                    const phases = `snapshot-load=${snapshotLoadMs}ms, deserialize=${deserializeMs}ms, ` +
+                        `source-walk=${result.timings.sourceWalkMs}ms, stat-walk=${result.timings.statWalkMs}ms, ` +
+                        `refresh-reads=${result.timings.refreshReadsMs}ms, ` +
+                        `snapshot-save-sync=${snapshotSaveSyncMs}ms`;
+                    dbg(`session_start word-index: incremental (seq=${effectiveSeq}, refreshed=${result.refreshed}, dropped=${result.dropped}, skipped=${result.skipped}, reused=${result.reused}, ${Date.now() - startMs}ms, phases: ${phases})`);
                     // M2, #958: the incremental-vs-full decision + honest coverage
                     // (indexedFileCount/truncated/skipped), independent of host `dbg`.
                     logWordIndex({
@@ -493,6 +509,12 @@ async function buildOrRefreshWordIndex(args) {
                         indexedFileCount: index.docCount,
                         tokens: index.postings.size,
                         truncated: index.truncated,
+                        phaseDurationsMs: {
+                            snapshotLoadMs,
+                            deserializeMs,
+                            ...result.timings,
+                            snapshotSaveSyncMs,
+                        },
                         refreshed: result.refreshed,
                         dropped: result.dropped,
                         skipped: result.skipped,
@@ -516,6 +538,7 @@ async function buildOrRefreshWordIndex(args) {
                     cwd: snapshotRoot,
                     trigger: "session_start",
                     reason: err instanceof Error ? err.message : String(err),
+                    phaseDurationsMs: { snapshotLoadMs, deserializeMs },
                 });
             }
         }
@@ -1004,7 +1027,7 @@ function scheduleStartupScans(deps, runtime, sessionGeneration, analysisRoot, sn
             return;
         if (!runtime.callGraph)
             return;
-        const { buildCodebaseModel, saveCodebaseModel, DEFAULT_CODEBASE_MODEL_TOKEN_BUDGET } = await import("./codebase-model.js");
+        const { buildCodebaseModel, saveCodebaseModel, DEFAULT_CODEBASE_MODEL_TOKEN_BUDGET, } = await import("./codebase-model.js");
         if (!callGraphIdentity)
             return;
         const model = buildCodebaseModel(runtime.callGraph, analysisRoot, DEFAULT_CODEBASE_MODEL_TOKEN_BUDGET, callGraphIdentity);