@herbertgao/pi-extensions 2026.9.0 → 2026.9.1

package/node_modules/pi-lens/dist/clients/runtime-agent-end.js

@@ -190,6 +190,7 @@ export async function handleAgentEnd({ ctxCwd, getFlag, getFlagSource, notify, d
         changed: [],
         failed: [],
         skipped: [],
+        unavailable: [],
     };
     // #502 fix provenance: per-path {tool, kind} entries accumulated across the
     // deferred-format loop below, passed as `fixes` on the batch
@@ -348,7 +349,8 @@ export async function handleAgentEnd({ ctxCwd, getFlag, getFlagSource, notify, d
         return !disabled;
     });
     if (formatRecords.length > 0) {
-        const work = new Array(formatRecords.length);
+        const work = [];
+        work.length = formatRecords.length;
         const started = new Set();
         let nextIndex = 0;
         const worker = async () => {
@@ -430,6 +432,18 @@ export async function handleAgentEnd({ ctxCwd, getFlag, getFlagSource, notify, d
                     },
                 ], "format-failed");
             }
+            // #2413: an unavailable formatter is durable, not transient — record it
+            // once and DO NOT requeue. Requeuing here is exactly what made
+            // `spawn oxfmt ENOENT` re-fire on every agent_end for the same files.
+            if (result.formatUnavailable.length > 0) {
+                for (const u of result.formatUnavailable) {
+                    summary.unavailable.push({
+                        filePath,
+                        formatter: u.formatter,
+                        reason: u.reason,
+                    });
+                }
+            }
             if (result.formatChanged) {
                 summary.changed.push(filePath);
                 for (const tool of result.formattersUsed) {
@@ -663,6 +677,7 @@ export async function handleAgentEnd({ ctxCwd, getFlag, getFlagSource, notify, d
             changed: summary.changed.length,
             failed: summary.failed.length,
             skipped: summary.skipped.length,
+            unavailable: summary.unavailable.length,
         },
     });
     logLatency({
@@ -676,9 +691,10 @@ export async function handleAgentEnd({ ctxCwd, getFlag, getFlagSource, notify, d
             changed: summary.changed.length,
             failed: summary.failed.length,
             skipped: summary.skipped.length,
+            unavailable: summary.unavailable.length,
         },
     });
-    dbg(`agent_end deferred_format complete: formatted=${summary.formatted} changed=${summary.changed.length} failed=${summary.failed.length} skipped=${summary.skipped.length}`);
+    dbg(`agent_end deferred_format complete: formatted=${summary.formatted} changed=${summary.changed.length} failed=${summary.failed.length} skipped=${summary.skipped.length} unavailable=${summary.unavailable.length}`);
     if (summary.failed.length > 0) {
         notify(`pi-lens deferred format: ${summary.changed.length} changed, ${summary.failed.length} failed`, "warning");
     }

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

@@ -103,12 +103,58 @@ export function peekTestFindings(cacheManager, cwd, runtime, logDelivery = false
             {
                 role: "user",
                 content: current
-                    ? `${AUTOMATION_FRAMING}Test failures detected last turn — fix before continuing:\n\n${findings.data.content}`
+                    ? `${AUTOMATION_FRAMING}${testFindingsCurrentPrefix(findings.data.runnerErrorOnly)}\n\n${findings.data.content}`
                     : `${AUTOMATION_FRAMING}${historicalTestContent(findings.data.content, findings.data.provenance)}`,
             },
         ],
     };
 }
+/**
+ * #2522: a batch made entirely of RUNNER errors (timeout, missing
+ * provider/binary — see `TestRunnerFindingsCache.runnerErrorOnly`) is not a
+ * failure the agent introduced, so it must not read as a blocker the way a
+ * genuine failing test does.
+ */
+function testFindingsCurrentPrefix(runnerErrorOnly) {
+    return runnerErrorOnly
+        ? "Test runner could not complete last turn (advisory — not a failure introduced this turn):"
+        : "Test failures detected last turn — fix before continuing:";
+}
+/**
+ * Retire a delivered test-findings record: blank the content, keep everything a
+ * delivery does not settle.
+ *
+ * ONE function, called by both `consumeTestFindings` (the in-process context
+ * hook) and `acknowledgeTestFindings` (the MCP Stop-hook commit), because
+ * "what survives a retire" is exactly the kind of rule that rots when it is
+ * stated twice. It already had: round 2 taught the consume copy to preserve
+ * `deferredTargets` and left the acknowledge copy dropping them, and the
+ * acknowledge copy is the LIVE Stop-hook path — including the branch where
+ * `handleTurnEnd` never runs at all — so on that path the deferral set was
+ * wiped before anything could ever dispatch it (#2522 review round 3, F2).
+ *
+ * What survives, and why:
+ *  - `testRunGeneration` — nulling the slot would let a still-in-flight OLDER
+ *    batch read `undefined`, pass the strictly-greater suppression check, and
+ *    resurrect a consumed one-shot advisory with stale results.
+ *  - `deferredTargets` — delivering the advisory says the agent has SEEN the
+ *    deferral, not that those targets ran. Dropping the list silently un-defers
+ *    them and the cut batch is never finished.
+ *  - `retiredTargets` — the session-scoped deferral cap. Dropping it re-arms a
+ *    suite already measured as too slow for the batch budget, which puts the
+ *    livelock back.
+ *
+ * An empty-content record peeks as undelivered while keeping all three intact.
+ */
+function retireTestFindings(cacheManager, cwd) {
+    const prior = cacheManager.readCache("test-runner-findings", cwd)?.data;
+    cacheManager.writeCache("test-runner-findings", {
+        content: "",
+        testRunGeneration: prior?.testRunGeneration,
+        deferredTargets: prior?.deferredTargets,
+        retiredTargets: prior?.retiredTargets,
+    }, cwd);
+}
 export function consumeTestFindings(cacheManager, cwd, runtime) {
     const record = cacheManager.readCache("test-runner-findings", cwd);
     if (!record?.data?.content)
@@ -116,16 +162,7 @@ export function consumeTestFindings(cacheManager, cwd, runtime) {
     const findings = peekTestFindings(cacheManager, cwd, runtime, true);
     if (!findings)
         return;
-    // 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);
+    retireTestFindings(cacheManager, cwd);
     return findings;
 }
 /** Complete an acknowledged MCP delivery without re-validating or re-rendering it. */
@@ -145,11 +182,7 @@ 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);
+    retireTestFindings(cacheManager, cwd);
 }
 export function consumeSessionStartGuidance(cacheManager, cwd) {
     const guidance = cacheManager.readCache("session-start-guidance", cwd);

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

@@ -6,6 +6,7 @@ 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";
+import { PartialApplyRecordStore } from "./partial-edit-apply.js";
 import { ReadGuard } from "./read-guard.js";
 import { RUNTIME_CONFIG } from "./runtime-config.js";
 import { TurnSummaryCollector } from "./turn-summary.js";
@@ -111,6 +112,11 @@ export class RuntimeCoordinator {
     // (cheap, empty Map) but callers gate recording behind the
     // `lens-turn-summary` flag so it's a true no-op when the feature is off.
     _turnSummary = new TurnSummaryCollector();
+    // #2402/#1053: session-scoped applied-edit records for exact-retry
+    // recognition. Both producers (partial-apply commit, full native-edit
+    // success) write here; the preflight consults it before declaring an
+    // oldText miss, so an identical retry never re-executes a committed write.
+    partialApplyRecords = new PartialApplyRecordStore();
     resetForSession(startedAt = Date.now()) {
         this._sessionGeneration += 1;
         this._sessionStartedAt = startedAt;
@@ -159,6 +165,9 @@ export class RuntimeCoordinator {
         this._actionableWarningsThisTurn.clear();
         this._codeQualityWarningsThisTurn.clear();
         this._turnSummary.clear();
+        // #2402: an applied-edit record is a fact about the session that applied
+        // it; a new session must re-resolve identical payloads from content.
+        this.partialApplyRecords.clear();
     }
     get sessionStartedAt() {
         return this._sessionStartedAt;
@@ -317,9 +326,15 @@ export class RuntimeCoordinator {
     get droppedMutationReceiptCount() {
         return this._droppedMutationReceipts;
     }
-    /** Atomically records write/edit ordering before debounce can coalesce it. */
-    recordMutationToolReceipt(filePath, toolName) {
-        if (toolName === "write") {
+    /**
+     * Atomically records write/edit ordering before debounce can coalesce it.
+     *
+     * Takes the classified {@link MutationKind}, not a raw tool name (#2423):
+     * an edit-shaped tool pi-lens does not name still demotes this file to the
+     * deferred pass, which is the safe timing.
+     */
+    recordMutationToolReceipt(filePath, kind) {
+        if (kind === "write") {
             this._writtenThisTurn.set(filePath, true);
         }
         else if (this._writtenThisTurn.has(filePath)) {
@@ -329,7 +344,7 @@ export class RuntimeCoordinator {
             this._fixedThisTurn.delete(filePath);
         }
         return {
-            autofixMode: toolName === "edit" || this._autofixDemotedThisTurn.has(filePath)
+            autofixMode: kind === "edit" || this._autofixDemotedThisTurn.has(filePath)
                 ? "deferred"
                 : "immediate",
         };
@@ -999,7 +1014,9 @@ export class RuntimeCoordinator {
      * for a same-kind re-touch. Callers publish each kind's first transition
      * without spamming repeated edits before `agent_end`.
      */
-    deferMutation(filePath, cwd, toolName, turnStateCwd, kind, ownerSessionId, originCwd) {
+    deferMutation(filePath, cwd, 
+    /** Host tool name; any mutating tool, not just `write`/`edit` (#2423). */
+    toolName, turnStateCwd, kind, ownerSessionId, originCwd) {
         const key = path.resolve(filePath);
         const now = Date.now();
         const resolvedOriginCwd = originCwd ?? turnStateCwd;
@@ -1030,7 +1047,9 @@ export class RuntimeCoordinator {
         });
         return true;
     }
-    deferFormat(filePath, cwd, toolName, turnStateCwd, ownerSessionId, originCwd) {
+    deferFormat(filePath, cwd, 
+    /** Host tool name; any mutating tool, not just `write`/`edit` (#2423). */
+    toolName, turnStateCwd, ownerSessionId, originCwd) {
         return this.deferMutation(filePath, cwd, toolName, turnStateCwd, "format", ownerSessionId, originCwd);
     }
     get pendingDeferredFormatCount() {

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

@@ -16,6 +16,7 @@ import { resetPendingRunnerFindings } from "./dispatch/pending-runner-findings.j
 import { clearAllSessions as clearFileTimeSessions } from "./file-time.js";
 import { getGlobalPiLensDir, getKnipIgnorePatterns, getProjectDataDir, } from "./file-utils.js";
 import { GitleaksClient } from "./gitleaks-client.js";
+import { resetGoAvailability } from "./go-client.js";
 import { GovulncheckClient, } from "./govulncheck-client.js";
 import { sweepAtomicWriteStages } from "./instance-reaper.js";
 import { canRunStartupHeavyScans } from "./language-policy.js";
@@ -36,7 +37,9 @@ import { isPrintMode } from "./print-mode.js";
 import { readLatestProjectSequence, readLatestProjectSequenceAsync, } from "./project-changes.js";
 import { getProjectSnapshotPath, getProjectSnapshotLegacyPath, hydrateRuntimeFromProjectSnapshot, hydrateRuntimeFromProjectSnapshotIfIdle, isProjectSnapshotFresh, isProjectSnapshotMetaStale, loadProjectSnapshot, loadProjectSnapshotExportsAndRules, PROJECT_SNAPSHOT_VERSION, readProjectSnapshotMeta, saveRuntimeProjectSnapshot, } from "./project-snapshot.js";
 import { scanProjectRules } from "./rules-scanner.js";
+import { resetRustAvailability } from "./rust-client.js";
 import { resetSafeSpawnWindowsCommandCache } from "./safe-spawn.js";
+import { resetAnalyzerBootstrapSessionState, } from "./bootstrap.js";
 import { getSlowFsVerdict, isSlowFs, slowFsDegradationNotice, } from "./slow-fs.js";
 import { countRecentSmells, formatSmellsSessionStartLine, resetSmellsSessionState, } from "./smells-rollup.js";
 import { findNearestProjectRoot, getStartupScanMaxEntries, isStartupScanVerdictFresh, resolveStartupScanContext, } from "./startup-scan.js";
@@ -46,10 +49,29 @@ 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 { primePersistedMutationAttribution, resetMutationAttribution, } from "./mutation-attribution.js";
+import { resetObservedMutationNet } from "./observed-mutation.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";
+import { resetTestRunnerDelivery } from "./test-runner-delivery.js";
+import { resetLspMutationNoBridgeDbgLatch } from "./lsp-mutation.js";
+/**
+ * `deps` with resolved analyzer clients merged in, or `null` when the
+ * bootstrap could not be served and the caller must proceed without them.
+ *
+ * No cast and no "is one representative field present?" probe: the seam
+ * answers with all seventeen clients or with `null`, so the two outcomes are
+ * the two branches. A skipped consumer is already counted in the ledger under
+ * `analyzer-bootstrap-unavailable`, so it is never mistaken for a clean one.
+ */
+async function demandBootstrapDeps(deps, reason) {
+    const clients = await deps.bootstrap.request(reason);
+    if (!clients)
+        return null;
+    return { ...deps, ...clients };
+}
 const HOST_STALL_THRESHOLD_MS = 30_000;
 function logHostReadyDelay(deps, cwd) {
     if (!deps.emitHostReadyDelay ||
@@ -772,6 +794,24 @@ async function buildOrRefreshWordIndex(args) {
 // Each consumer already handles the "not ready yet" case gracefully
 // (cachedExports.size > 0, cache miss paths).
 function scheduleStartupScans(deps, runtime, sessionGeneration, analysisRoot, snapshotRoot, languageProfile, dbg) {
+    // #2467: the analyzers these scans drive are loaded HERE, on the deferred
+    // background path, instead of before the handler ran. This function was
+    // already fire-and-forget ("don't block session start"), so resolving them
+    // across one await adds no wait to the interactive path and changes no
+    // ordering its caller depends on — the caller never awaited it.
+    void (async () => {
+        const resolved = await demandBootstrapDeps(deps, "session-start-scans");
+        // Fail open: no analyzers means no scans, said out loud. The demand is
+        // already counted in the ledger, so this is not a silent skip.
+        if (!resolved) {
+            dbg("session_start scans: analyzer bootstrap unavailable — skipped");
+            return;
+        }
+        scheduleStartupScansWithClients(resolved, runtime, sessionGeneration, analysisRoot, snapshotRoot, languageProfile, dbg);
+    })();
+}
+/** The scan bodies, once the analyzers they need are resolved. */
+function scheduleStartupScansWithClients(deps, runtime, sessionGeneration, analysisRoot, snapshotRoot, languageProfile, dbg) {
     const { todoScanner, cacheManager, knipClient, jscpdClient, deadCodeClients, govulncheckClient, gitleaksClient, trivyClient, opengrepClient, astGrepClient, depChecker, } = deps;
     // Some background scans are CPU-heavy and arrive on the event loop
     // just as the user is most likely typing (right after /new). Defer
@@ -1246,6 +1286,20 @@ function scheduleStartupScans(deps, runtime, sessionGeneration, analysisRoot, sn
     });
 }
 function scheduleDeferredToolProbes(deps, languageProfile, startupDefaults, startupScansWillRun, dbg) {
+    // #2467: same deferral as `scheduleStartupScans` — the probes were already
+    // fire-and-forget, so the analyzers they probe load here rather than before
+    // the handler.
+    void (async () => {
+        const resolved = await demandBootstrapDeps(deps, "session-start-tool-probes");
+        if (!resolved) {
+            dbg("session_start tools: analyzer bootstrap unavailable — no probes");
+            return;
+        }
+        scheduleDeferredToolProbesWithClients(resolved, languageProfile, startupDefaults, startupScansWillRun, dbg);
+    })();
+}
+/** The probe bodies, once the analyzers they probe are resolved. */
+function scheduleDeferredToolProbesWithClients(deps, languageProfile, startupDefaults, startupScansWillRun, dbg) {
     const { biomeClient, ruffClient, depChecker } = deps;
     const defaultTools = new Set(startupDefaults);
     const probes = [];
@@ -1299,6 +1353,20 @@ export const SESSION_START_GUIDANCE = [
 ];
 export async function handleSessionStart(deps) {
     resetDegradationLedger();
+    // #2467: re-arm the analyzer bootstrap's shutdown gate. The gate is a
+    // per-SESSION claim ("this session is over") held in process-lived storage,
+    // so without this a replacement session in the same process would find
+    // every analyzer refused for the rest of the process — AGENTS.md defect
+    // shape 17. The resident clients themselves are deliberately kept.
+    resetAnalyzerBootstrapSessionState();
+    resetTestRunnerDelivery();
+    // #2450 fix round 3, catalog shape 17: the "bridge unavailable" dbg latch
+    // (`clients/lsp-mutation.ts`) is a process-lifetime once-per-session flag,
+    // same shape as the ledger's own once-per-subject bookkeeping above, but
+    // kept as its own reset (not folded into `resetDegradationLedger`) to
+    // avoid that module reaching back into this one — see the latch's own
+    // comment for why.
+    resetLspMutationNoBridgeDbgLatch();
     // #1743: the bounded-telemetry per-turn counters. The rising-edge state is
     // NOT here — it is the ledger's own tally, reset on the line above. These
     // counters are keyed by turn index, and a new session restarts turn
@@ -1309,23 +1377,16 @@ export async function handleSessionStart(deps) {
     // live anchor into one bounded previous slot so the queued event keeps the
     // replaced session's attribution until a newer live message_end is seen.
     rotateMessageEndAttribution();
+    // #2526: the once-per-session `config_resolved` claim is NOT re-armed here.
+    // index.ts resolves this session's config in `ensureLSPConfigInitialized`
+    // BEFORE it calls this handler, so a re-arm on this line would fire between
+    // the session's own two resolutions and the deferred `loadLSPConfig` below
+    // would write a second row for one session (review round 2, F1). The re-arm
+    // lives in index.ts's `session_start` closure, ahead of that ensure and
+    // behind the #473 gate — see `resetOncePerSessionPhases`'s doc comment.
     const handlerEnteredAt = Date.now();
     const sessionStartMs = deps.sessionStartFiredAt ?? handlerEnteredAt;
     const cwdForTelemetry = deps.ctxCwd ?? process.cwd();
-    if (deps.bootstrapClientsStartedAt !== undefined &&
-        deps.bootstrapClientsDurationMs !== undefined) {
-        logLatency({
-            type: "phase",
-            filePath: cwdForTelemetry,
-            phase: "bootstrap_clients_load",
-            startedAt: new Date(deps.bootstrapClientsStartedAt).toISOString(),
-            durationMs: deps.bootstrapClientsDurationMs,
-            metadata: {
-                parent: "session_start_prehandler",
-                reason: deps.sessionReason,
-            },
-        });
-    }
     if (deps.sessionStartFiredAt !== undefined) {
         logLatency({
             type: "phase",
@@ -1605,7 +1666,7 @@ export async function handleSessionStart(deps) {
     }
     const allowBootstrapTasks = startupMode === "full";
     const quickMode = startupMode === "quick";
-    const { ctxCwd, getFlag, notify, dbg, log, runtime, metricsClient, knipClient, cacheManager, testRunnerClient, goClient, rustClient, ensureTool, cleanStaleTsBuildInfo, resetDispatchBaselines, resetLSPService, } = deps;
+    const { ctxCwd, getFlag, notify, dbg, log, runtime, cacheManager, ensureTool, cleanStaleTsBuildInfo, resetDispatchBaselines, resetLSPService, } = deps;
     // Lightweight phase timer — resets after each call so each log line shows
     // the cost of that phase alone, not cumulative time from session start.
     let _phaseT = Date.now();
@@ -1613,7 +1674,11 @@ export async function handleSessionStart(deps) {
         dbg(`session_start phase ${name}: ${Date.now() - _phaseT}ms`);
         _phaseT = Date.now();
     };
-    metricsClient.reset();
+    // #2467: `peek`, never a load. A metrics client that was never constructed
+    // holds no per-session state to re-arm, so the reset is vacuous — and
+    // loading the analyzer graph in order to reset nothing is the interactive-
+    // path cost this issue removes.
+    deps.bootstrap.peek()?.metricsClient.reset();
     getDiagnosticTracker().reset();
     clearFileTimeSessions();
     runtime.complexityBaselines.clear();
@@ -1626,6 +1691,14 @@ export async function handleSessionStart(deps) {
     // after reset) and the git-worktree memo must re-probe after a session
     // that may have seen a non-git dir become one.
     resetOpaqueMutationState();
+    // #2430: the observational net's pending baselines are keyed by tool-call
+    // id and its content ledger describes the previous session's files; both
+    // mis-answer forever without this. The learned attribution map is cleared
+    // and then RE-PRIMED from this project's persisted file, so a tool an
+    // earlier session observed is classified by name with no snapshot at all.
+    resetObservedMutationNet();
+    resetMutationAttribution();
+    primePersistedMutationAttribution(ctxCwd);
     // #2026: pending auxiliary baselines are unreachable after generation bump.
     resetPendingAuxiliaryCoverage();
     // #817/#1199: Windows command resolution is cached per (command, canonical
@@ -1665,6 +1738,18 @@ export async function handleSessionStart(deps) {
     // login` and starts a fresh session still reads the previous session's
     // stale "no token" verdict until the cooldown (if any) happens to expire.
     resetZizmorTokenAvailability();
+    // #2455: same #1496/#1535 process-lifetime-latch shape, one caller later —
+    // the `goClient`/`rustClient` singletons each hold their own
+    // `createAvailabilityLatch()` outside the dispatch generation counter above
+    // (they predate `createCwdCachedProbe`). A "missing" verdict never expires
+    // on its own, so without these a go/cargo install between sessions stayed
+    // unobserved for the rest of the process's life. Found by hand while
+    // auditing #2455's detector widening, NOT surfaced by it: the sweep skips
+    // any file exporting no reset at all, and neither client module exported
+    // one, so no container predicate could have yielded them (#2455 fix round 4,
+    // F5 — an earlier draft of this comment had the causality backwards).
+    resetGoAvailability();
+    resetRustAvailability();
     // psscriptanalyzer's three latches (interpreter, module, -File exec) are
     // module-local, so the generation counter above does not reach them
     // (#1490, #1540).
@@ -1712,7 +1797,9 @@ export async function handleSessionStart(deps) {
     // Some embedders inject a capability-shaped Knip client rather than the
     // concrete KnipClient. Session reset is an optional lifecycle capability;
     // its absence must not make session_start fail.
-    knipClient.resetSessionState?.();
+    // #2467: `peek` for the same reason as `metricsClient.reset()` above —
+    // an unloaded knip client has no session state to clear.
+    deps.bootstrap.peek()?.knipClient.resetSessionState?.();
     // #1910: the tier-3 cascade outstanding-touch registry and its
     // sweep-scoped expired/evicted counters (clients/lsp/cascade-tier.ts) are
     // a per-SESSION claim about touches THIS session fired. #1899 bounded the
@@ -1769,6 +1856,12 @@ export async function handleSessionStart(deps) {
     }
     const hasWorkspaceCwd = typeof ctxCwd === "string" && ctxCwd.length > 0;
     const cwd = ctxCwd ?? process.cwd();
+    // #2526 review round 3, S1: this handler no longer predicts whether config
+    // will resolve. `loadLSPConfig` itself publishes a `config_resolution_pending`
+    // mark, from inside the function, at the instant a resolution is actually
+    // attempted — see that function's doc comment (`clients/lsp/config.ts`) for
+    // why a prediction mirrored against this handler's own gates drifted from
+    // what index.ts and this handler's callers actually schedule.
     // #1228: generic atomic-write stages are shared by several project stores,
     // so the review-graph-specific sweep cannot own this namespace. Sweep the
     // project data roots and machine-global registry root once per session start;
@@ -1938,7 +2031,18 @@ export async function handleSessionStart(deps) {
             filePath: cwd,
             startedAt: new Date(sessionStartMs).toISOString(),
             durationMs: totalDurationMs,
-            metadata: { mode: startupMode, reason: deps.sessionReason },
+            metadata: {
+                mode: startupMode,
+                reason: deps.sessionReason,
+                // #2129: the root-identity input decideSessionStart consulted,
+                // alongside `mode` — every start reaching this line already
+                // classified `primary`/`sequential-replacement` (a `secondary-root`
+                // start returns before `handleSessionStart` is ever called).
+                classification: deps.sessionStartClassification,
+                // `undefined` is omitted by JSON.stringify. Keep unknown explicit so
+                // strict log readers can distinguish it from legacy omission.
+                sameRoot: deps.sessionStartSameRoot ?? "unknown",
+            },
         });
         logHostReadyDelay(deps, cwd);
         emitSmellsSessionStartLine(dbg, sessionStartMs);
@@ -2180,13 +2284,19 @@ export async function handleSessionStart(deps) {
     else {
         dbg("session_start: skipping prettier preinstall probe (startup mode)");
     }
-    const detectedRunner = testRunnerClient.detectRunner(analysisRoot);
+    // #2467: the first point on the FULL-mode path that genuinely needs the
+    // analyzer clients, so it is where the load is paid. Quick mode — the
+    // process's first session, the one the user is waiting on — returns above
+    // and never reaches here. Fail open: an unavailable bootstrap drops these
+    // three entries from the "Active tools" line rather than failing the start.
+    const summaryClients = await deps.bootstrap.request("session-start-tools");
+    const detectedRunner = summaryClients?.testRunnerClient.detectRunner(analysisRoot);
     phase("test-runner-detect");
     if (detectedRunner)
         tools.push(`Test runner (${detectedRunner.runner})`);
-    if (await goClient.isGoAvailableAsync())
+    if (await summaryClients?.goClient.isGoAvailableAsync())
         tools.push("Go (go vet)");
-    if (await rustClient.isAvailableAsync())
+    if (await summaryClients?.rustClient.isAvailableAsync())
         tools.push("Rust (cargo)");
     log(`Active tools: ${tools.join(", ")}`);
     dbg(`session_start tools: ${tools.join(", ")}`);
@@ -2282,7 +2392,14 @@ export async function handleSessionStart(deps) {
         filePath: cwd,
         startedAt: new Date(sessionStartMs).toISOString(),
         durationMs: totalDurationMs,
-        metadata: { mode: startupMode, reason: deps.sessionReason },
+        metadata: {
+            mode: startupMode,
+            reason: deps.sessionReason,
+            // #2129: see the quick-mode session_start_total record above.
+            classification: deps.sessionStartClassification,
+            // Keep the full path's durable shape identical to quick mode.
+            sameRoot: deps.sessionStartSameRoot ?? "unknown",
+        },
     });
     logHostReadyDelay(deps, cwd);
     emitSmellsSessionStartLine(dbg, sessionStartMs);