@herbertgao/pi-extensions 2026.8.4 → 2026.8.6

package/node_modules/pi-lens/dist/clients/diagnostic-dispositions.js

@@ -56,7 +56,7 @@
 import { createHash } from "node:crypto";
 import * as fs from "node:fs";
 import * as path from "node:path";
-import { writeFileAtomic } from "./atomic-write.js";
+import { commitDurableStore } from "./durable-store.js";
 import { logDispositionEvent } from "./disposition-logger.js";
 import { publishDisposition } from "./disposition-publish.js";
 import { getProjectDataDir } from "./file-utils.js";
@@ -140,11 +140,27 @@ function statePath(cwd) {
     return path.join(getProjectDataDir(cwd), "cache", "diagnostic-dispositions.json");
 }
 let stateCache = null;
+const DISPOSITION_LOCK_WAIT_MS = 2_000;
+const DISPOSITION_LOCK_RETRY_MS = 10;
+let beforeDispositionCommitForTests = null;
+let beforeDispositionCacheRefreshForTests = null;
+let dispositionStatSync = fs.statSync;
+/** Test seam after the caller's cached read and before commit lock acquisition. */
+export function _setBeforeDispositionCommitForTests(hook) {
+    beforeDispositionCommitForTests = hook;
+}
+/** Test seam immediately before the committed state refreshes the cache. */
+export function _setBeforeDispositionCacheRefreshForTests(hook) {
+    beforeDispositionCacheRefreshForTests = hook;
+}
+export function _setDispositionStatForTests(statSync) {
+    dispositionStatSync = statSync ?? fs.statSync;
+}
 function readState(cwd) {
     const p = statePath(cwd);
     let stat;
     try {
-        stat = fs.statSync(p);
+        stat = dispositionStatSync(p);
     }
     catch {
         if (stateCache && stateCache.path === p && stateCache.missing) {
@@ -188,6 +204,17 @@ function readState(cwd) {
     };
     return state;
 }
+function deserializeState(contents) {
+    try {
+        const parsed = JSON.parse(contents ?? "");
+        return parsed && typeof parsed === "object"
+            ? parsed
+            : {};
+    }
+    catch {
+        return {};
+    }
+}
 // Atomic tmp+rename via clients/atomic-write.ts (#762; shared with
 // instance-registry.ts / recent-touches.ts / review-graph/builder.ts): a
 // cross-process reader must never observe a partially-written file —
@@ -198,10 +225,7 @@ function readState(cwd) {
 // failure still propagates (matches the pre-atomic writeFileSync's behavior,
 // which never swallowed errors either) — a disposition mark silently vanishing
 // is a correctness bug for this store, not just a lost observability sample.
-function writeState(cwd, state) {
-    const p = statePath(cwd);
-    fs.mkdirSync(path.dirname(p), { recursive: true });
-    writeFileAtomic(p, JSON.stringify(state, null, 2), { bestEffort: false });
+function refreshStateCache(p, state) {
     // Refresh the cache from the write we just did instead of invalidating it —
     // avoids an immediate re-stat+re-parse of the file we already have in hand,
     // and guards against coarse filesystem mtime granularity making a
@@ -215,6 +239,33 @@ function writeState(cwd, state) {
         state,
     };
 }
+function commitDisposition(cwd, anchor, entry) {
+    const p = statePath(cwd);
+    fs.mkdirSync(path.dirname(p), { recursive: true });
+    const hook = beforeDispositionCommitForTests;
+    beforeDispositionCommitForTests = null;
+    hook?.();
+    commitDurableStore({
+        path: p,
+        deserialize: deserializeState,
+        merge: (state) => {
+            state.dispositions ??= {};
+            state.dispositions[anchor] = entry;
+            return state;
+        },
+        serialize: (state) => JSON.stringify(state, null, 2),
+        waitMs: DISPOSITION_LOCK_WAIT_MS,
+        retryMs: DISPOSITION_LOCK_RETRY_MS,
+        timeoutMessage: "timed out acquiring diagnostic disposition store lock",
+        onContention: "throw",
+        afterWriteLocked: (state) => {
+            const cacheHook = beforeDispositionCacheRefreshForTests;
+            beforeDispositionCacheRefreshForTests = null;
+            cacheHook?.();
+            refreshStateCache(p, state);
+        },
+    });
+}
 /** Test-only escape hatch — the state cache is module-level, so tests that
  * write the store file out-of-band (or across separate cwds sharing a stat
  * coincidence) need to reset it between cases. */
@@ -227,7 +278,7 @@ export function _resetStateCacheForTests() {
  * Neither can throw into the mark path; both are already internally
  * fail-safe, but the try/catch keeps a future regression in either from
  * breaking a mark. */
-function emitMarkTelemetry(cwd, target, disposition, anchor, reason, existing) {
+function emitMarkTelemetry(cwd, target, disposition, anchor, reason, existing, identity) {
     try {
         logDispositionEvent({
             event: "mark",
@@ -239,6 +290,8 @@ function emitMarkTelemetry(cwd, target, disposition, anchor, reason, existing) {
             reason,
             anchor,
             previousDisposition: existing?.disposition,
+            model: identity?.model || undefined,
+            provider: identity?.provider || undefined,
         });
         publishDisposition({
             cwd,
@@ -266,7 +319,7 @@ function emitMarkTelemetry(cwd, target, disposition, anchor, reason, existing) {
  * hang off it, so the agent tool and any future UI caller are covered without
  * per-caller wiring.
  */
-export function markDisposition(cwd, target, disposition, reason) {
+export function markDisposition(cwd, target, disposition, reason, identity) {
     const anchor = disposition === "false-positive"
         ? computeStrictAnchor(target)
         : computeWeakAnchor(target);
@@ -274,19 +327,17 @@ export function markDisposition(cwd, target, disposition, reason) {
     // entry can already exist at the same weak anchor (a prior flagged/suppress
     // mark) — the log should record what this mark shadowed either way.
     const existing = readState(cwd).dispositions?.[anchor];
-    emitMarkTelemetry(cwd, target, disposition, anchor, reason, existing);
     if (disposition === "defer") {
         deferredThisSession.add(anchor);
+        emitMarkTelemetry(cwd, target, disposition, anchor, reason, existing, identity);
         return anchor;
     }
-    const state = readState(cwd);
-    state.dispositions ??= {};
     const now = new Date().toISOString();
     const capturesFixContext = disposition === "flagged";
     const lineText = capturesFixContext
         ? (target.content?.split(/\r?\n/)[target.line !== undefined ? target.line - 1 : -1] ?? existing?.lineText)?.trim()
         : existing?.lineText;
-    state.dispositions[anchor] = {
+    const entry = {
         disposition,
         reason: reason ?? existing?.reason,
         createdAt: existing?.createdAt ?? now,
@@ -294,7 +345,8 @@ export function markDisposition(cwd, target, disposition, reason) {
         line: capturesFixContext ? (target.line ?? existing?.line) : existing?.line,
         lineText,
     };
-    writeState(cwd, state);
+    commitDisposition(cwd, anchor, entry);
+    emitMarkTelemetry(cwd, target, disposition, anchor, reason, existing, identity);
     return anchor;
 }
 export function getDisposition(cwd, anchor) {

package/node_modules/pi-lens/dist/clients/diagnostics-publish.js

@@ -61,12 +61,13 @@
  */
 import { logBusEvent } from "./bus-events-logger.js";
 import { normalizeFilePath } from "./path-utils.js";
+import { createLiveBusEmitter, recordStaleBusFailure, resolveLiveBusEmitter, } from "./live-bus-emitter.js";
 import { isBusPublishEnabled } from "./bus-publish.js";
 export const BUS_DIAGNOSTICS_EVENT = "pilens:diagnostics";
 export const BUS_DIAGNOSTICS_VERSION = 1;
 /** Max diagnostics carried per file per event — aligned with the widget's own per-file storage cap (`MAX_STORED_DIAGNOSTICS_PER_FILE`, clients/widget-state.ts). */
 export const MAX_DIAGNOSTICS_PER_FILE_EVENT = 12;
-let busEmit;
+const liveEmitter = createLiveBusEmitter();
 let hasLoggedFailure = false;
 let hasLoggedUnwired = false;
 let hasLoggedDisabled = false;
@@ -79,11 +80,14 @@ const reportedDirtyPaths = new Set();
  * producers share the identical `pi.events.emit` binding.
  */
 export function wireDiagnosticsBusEmitter(emitFn) {
-    busEmit = emitFn;
+    liveEmitter.wire(emitFn);
+}
+export function wireDiagnosticsBusEmitterGetter(getter) {
+    liveEmitter.wireGetter(getter);
 }
 /** Test-only: reset module state between test files. */
 export function _resetDiagnosticsPublishForTests() {
-    busEmit = undefined;
+    liveEmitter.reset();
     hasLoggedFailure = false;
     hasLoggedUnwired = false;
     hasLoggedDisabled = false;
@@ -145,7 +149,13 @@ export function publishDiagnostics(args) {
         }
         return;
     }
-    if (!busEmit) {
+    const resolution = resolveLiveBusEmitter(liveEmitter, () => ({
+        event: BUS_DIAGNOSTICS_EVENT,
+        cwd: normalizeFilePath(args.cwd),
+    }));
+    if (resolution.outcome === "stale-session")
+        return;
+    if (resolution.outcome === "unwired") {
         if (!hasLoggedUnwired) {
             hasLoggedUnwired = true;
             logBusEvent({
@@ -156,6 +166,7 @@ export function publishDiagnostics(args) {
         }
         return;
     }
+    const busEmit = resolution.emit;
     try {
         const fileEntries = args.files.map((f) => {
             const normPath = normalizeFilePath(f.path);
@@ -184,6 +195,7 @@ export function publishDiagnostics(args) {
             files: fileEntries,
         };
         busEmit(BUS_DIAGNOSTICS_EVENT, payload);
+        hasLoggedFailure = false;
         logBusEvent({
             event: BUS_DIAGNOSTICS_EVENT,
             outcome: "emitted",
@@ -198,9 +210,11 @@ export function publishDiagnostics(args) {
             outcome: "emit_failed",
             cwd: normalizeFilePath(args.cwd),
             error: String(err),
+            ctxSource: resolution.ctxSource,
         });
         if (!hasLoggedFailure) {
             hasLoggedFailure = true;
+            recordStaleBusFailure(BUS_DIAGNOSTICS_EVENT, err);
             args.dbg?.(`diagnostics-publish: pilens:diagnostics emit failed (further failures suppressed): ${err}`);
         }
     }

package/node_modules/pi-lens/dist/clients/dispatch/dispatcher.js

@@ -13,6 +13,7 @@
  * - OutputSemantic: How to display (blocking, warning, silent, etc.)
  * - BaselineStore: Track pre-existing issues for delta mode
  */
+import { logExtension } from "../extension-log.js";
 import * as fs from "node:fs";
 import * as path from "node:path";
 import { recordRunner } from "../widget-state.js";
@@ -28,10 +29,12 @@ import { loadPiLensProjectConfig } from "../project-lens-config.js";
 import { RUNTIME_CONFIG, getRunnerTimeoutFloorMs } from "../runtime-config.js";
 import { safeSpawnAsync } from "../safe-spawn.js";
 import { classifyDiagnostic } from "./diagnostic-taxonomy.js";
+import { classifyProbeFailure, logAvailabilityDecision, startHostStallSampler, transientRetryDelayMs, } from "./runners/utils/availability-policy.js";
 import { applyDispositions } from "../diagnostic-dispositions.js";
 import { applyInlineSuppressions } from "./inline-suppressions.js";
 import { getToolPlan } from "./plan.js";
 import { resolveRunnerPath } from "./runner-context.js";
+import { applyRulePolicy, rulePolicyMapFromConfig } from "./rule-policy.js";
 import { getToolProfile } from "./tool-profile.js";
 import { formatDiagnostics } from "./utils/format-utils.js";
 // --- Runner Registry ---
@@ -74,12 +77,49 @@ export function normalizeCacheKey(cmd) {
     const normalized = cmd.replace(/\.(cmd|exe)$/i, "").toLowerCase();
     return `session.toolCache.${normalized}`;
 }
-async function checkToolAvailability(command, facts) {
+/** Probe budget for the generic `hasTool` availability check, ms. */
+const TOOL_PROBE_TIMEOUT_MS = 5000;
+/**
+ * Session fact holding the epoch ms after which a TRANSIENT verdict for a
+ * command may be re-probed. Kept beside the boolean fact so both share the
+ * session's lifetime — no second global to reset (#1476).
+ */
+function transientRetryKey(command) {
+    return `${normalizeCacheKey(command)}.retryAt`;
+}
+/**
+ * Consecutive transient verdicts for a command, so the cooldown ESCALATES the
+ * way the policy documents (30 s, 60 s, 120 s … capped at 5 min) instead of
+ * sitting flat at 30 s.
+ *
+ * This is the highest-traffic availability consumer in the product. A flat
+ * cooldown here means a permanently sick host is re-probed every 30 s per
+ * command for the whole session — ten times the storm the policy claims to
+ * bound, and the one place the bound matters most. `createAvailabilityChecker`
+ * tracks the same counter; this keeps the two seams telling one story.
+ */
+function transientAttemptsKey(command) {
+    return `${normalizeCacheKey(command)}.transientAttempts`;
+}
+/**
+ * Is `command` usable right now? Cached per session.
+ *
+ * Latch policy (#1467/#1476): a `false` from a genuine absence is durable and
+ * is remembered for the session. A `false` from a TIMED-OUT probe is not — this
+ * is the highest-traffic availability consumer in the codebase, and caching a
+ * host stall here silently disabled a healthy tool for every later dispatch in
+ * the session. A transient verdict instead holds only for a bounded cooldown,
+ * which also stops a sick host from being re-probed on every dispatch.
+ */
+export async function checkToolAvailability(command, facts) {
     const key = normalizeCacheKey(command);
     const cached = facts.getSessionFact(key);
     if (cached !== undefined) {
         return cached;
     }
+    const retryAt = facts.getSessionFact(transientRetryKey(command));
+    if (retryAt !== undefined && Date.now() < retryAt)
+        return false;
     // A command that isn't even on disk can't pass a --version probe; the ~μs
     // stat/PATH walk saves a guaranteed-to-fail spawn round-trip per cold tool.
     if (!(await isSpawnableCommand(command))) {
@@ -87,12 +127,68 @@ async function checkToolAvailability(command, facts) {
         return false;
     }
     try {
-        const result = await safeSpawnAsync(command, ["--version"], {
-            timeout: 5000,
+        // The budget is enforced by a HOST-side timer, so measure the loop stall
+        // that overlapped the window and let the shared classifier read it.
+        const sampler = startHostStallSampler();
+        const startedAt = Date.now();
+        let result;
+        let hostStallMs;
+        try {
+            result = await safeSpawnAsync(command, ["--version"], {
+                timeout: TOOL_PROBE_TIMEOUT_MS,
+            });
+        }
+        finally {
+            hostStallMs = sampler.stop();
+        }
+        const elapsedMs = Date.now() - startedAt;
+        if (result.status === 0) {
+            facts.setSessionFact(key, true);
+            // The tool answered: retire the cooldown facts rather than leaving a
+            // stale retry deadline behind a `true`.
+            facts.setSessionFact(transientRetryKey(command), 0);
+            facts.setSessionFact(transientAttemptsKey(command), 0);
+            logAvailabilityDecision({
+                tool: command,
+                verdict: "available",
+                outcome: "success",
+                cause: "ok",
+                elapsedMs,
+                latched: true,
+                hostStallMs,
+                budgetMs: TOOL_PROBE_TIMEOUT_MS,
+            });
+            return true;
+        }
+        // `missing` for anything unclassified preserves the pre-#1476 meaning of
+        // a non-zero exit: durable, cached for the session.
+        const { outcome, cause } = classifyProbeFailure(result, {
+            hostStallMs,
+            unclassifiedFailureOutcome: "missing",
+        });
+        let retryAfterMs;
+        if (outcome === "transient") {
+            const attempts = (facts.getSessionFact(transientAttemptsKey(command)) ?? 0) + 1;
+            facts.setSessionFact(transientAttemptsKey(command), attempts);
+            retryAfterMs = transientRetryDelayMs(attempts, cause);
+            facts.setSessionFact(transientRetryKey(command), Date.now() + retryAfterMs);
+        }
+        else {
+            facts.setSessionFact(key, false);
+            facts.setSessionFact(transientAttemptsKey(command), 0);
+        }
+        logAvailabilityDecision({
+            tool: command,
+            verdict: "unavailable",
+            outcome,
+            cause,
+            elapsedMs,
+            latched: outcome !== "transient",
+            hostStallMs,
+            ...(retryAfterMs !== undefined && { retryAfterMs }),
+            budgetMs: TOOL_PROBE_TIMEOUT_MS,
         });
-        const available = result.status === 0;
-        facts.setSessionFact(key, available);
-        return available;
+        return false;
     }
     catch {
         facts.setSessionFact(key, false);
@@ -122,9 +218,16 @@ function readFilePrefix(filePath, maxBytes = 4096) {
         }
     }
 }
-export function createDispatchContext(filePath, cwd, pi, facts, blockingOnly, modifiedRanges) {
+export function createDispatchContext(filePath, cwd, pi, facts, blockingOnly, modifiedRanges, 
+/** Authoritative workspace root; `cwd` may be a nested language root. */
+projectRoot, 
+/** Ordered per-file pipeline token, when this is a post-write dispatch. */
+writeIndex, 
+/** Runtime telemetry identity, when known (#1448) — threaded to the
+ * worklog append; see DispatchContext.telemetryModel's doc. */
+telemetryModel, telemetryProvider) {
     const absoluteFilePath = resolveRunnerPath(cwd, filePath);
-    const normalizedProjectRoot = normalizeMapKey(path.resolve(cwd));
+    const normalizedProjectRoot = normalizeMapKey(path.resolve(projectRoot ?? cwd));
     const normalizedCwd = normalizeMapKey(resolveLanguageRootForFile(absoluteFilePath, cwd));
     const normalizedFilePath = normalizeMapKey(absoluteFilePath);
     const kind = detectFileKind(normalizedFilePath);
@@ -143,11 +246,20 @@ export function createDispatchContext(filePath, cwd, pi, facts, blockingOnly, mo
         projectConfig,
         blockingOnly,
         modifiedRanges,
+        writeIndex,
+        telemetryModel,
+        telemetryProvider,
         async hasTool(command) {
             return checkToolAvailability(command, facts);
         },
         log(message) {
-            console.error(`[dispatch] ${message}`);
+            // #1333: pi owns the terminal — a runner advisory must never be a raw
+            // write. Every DispatchContext.log line lands in extension.log instead.
+            logExtension({
+                subsystem: "dispatch",
+                message,
+                metadata: { filePath: normalizedFilePath, kind },
+            });
         },
     };
 }
@@ -493,7 +605,7 @@ async function runGroup(ctx, group, registry, onRunnerResult) {
                 }
                 : undefined,
         });
-        recordRunner(ctx.filePath, runnerId, result.status, result.diagnostics.length, duration);
+        recordRunner(ctx.filePath, runnerId, result.status, result.diagnostics.length, duration, ctx.writeIndex);
         diagnostics.push(...result.diagnostics);
         const resultSemantic = result.semantic ?? semantic;
         if ((resultSemantic === "blocking" && result.diagnostics.length > 0) ||
@@ -563,26 +675,56 @@ export async function dispatchForFile(ctx, groups, registry, onRunnerResult) {
     // Apply delta mode ONCE across the full diagnostic set.
     // This avoids partial-baseline corruption when processing multiple groups.
     const dedupedDiagnostics = dedupeOverlappingDiagnostics(allDiagnostics);
-    const dockerOverlapSuppressed = suppressTrivyConfigDockerOverlap(dedupedDiagnostics);
-    const overlapSuppressed = suppressLintOverlapsWithLsp(dockerOverlapSuppressed);
     const fileContent = ctx.facts.getFileFact(ctx.filePath, "file.content") ?? "";
-    const inlineSuppressed = applyInlineSuppressions(overlapSuppressed, fileContent);
-    // #690: agent/user disposition layer — drop false-positive/suppress marks
-    // and anything deferred this session. flagged marks are left in place;
-    // lens_diagnostics tags them at render time via the same anchor.
+    // Project rule policy (`.pi-lens.json` `rules.<id>.disable`/`select`).
     //
-    // #1030: anchor + store MUST key off the PROJECT ROOT, not ctx.cwd. In a
-    // monorepo ctx.cwd is the nested language root (resolveLanguageRootForFile,
-    // used for tool/config resolution), but the mark tool writes dispositions
-    // under runtime.projectRoot. Keying the read on ctx.cwd computed a different
-    // anchor AND opened a different diagnostic-dispositions.json (getProjectDataDir
-    // is keyed on cwd), so every false-positive/flagged/defer on a file under a
-    // nested marker silently no-op'd. Read from the project root to match the write.
-    const dispositionFiltered = applyDispositions(inlineSuppressed, ctx.projectRoot ?? ctx.cwd, ctx.filePath, fileContent);
-    let visibleDiagnostics = dispositionFiltered;
+    // Resolved from `ctx.projectRoot` (falling back to `ctx.cwd`), NOT
+    // `ctx.projectConfig` — `ctx.projectConfig` is loaded from the nested
+    // LANGUAGE root (`resolveLanguageRootForFile`), so in a monorepo where a
+    // package directory has its own `.pi-lens.json`, `discoverPiLensProjectConfig`'s
+    // upward walk stops there and never sees a repo-root policy.
+    // `lens_diagnostics` loads its policy map from `runtime.projectRoot`; using
+    // the same root here keeps the two surfaces in agreement. `ctx.projectConfig`
+    // itself is untouched — thresholds and mutation flags keep their existing
+    // language-root resolution.
+    const rulePolicy = rulePolicyMapFromConfig(loadPiLensProjectConfig(ctx.projectRoot ?? ctx.cwd).rules);
+    // The output-only filter pipeline: LSP/docker overlap suppression + inline
+    // `pi-lens-ignore` + agent/user dispositions + project rule policy. Applied
+    // AFTER dedupe so the pi renderer, widget, and delta all see one filtered
+    // set. #690: dispositions drop false-positive/suppress marks and anything
+    // deferred this session (flagged marks stay; lens_diagnostics tags them at
+    // render time). #1030: the disposition anchor + store MUST key off the
+    // PROJECT ROOT, not ctx.cwd — the mark tool writes dispositions under
+    // runtime.projectRoot, so reading from ctx.cwd (the nested language root in
+    // a monorepo) opened a different diagnostic-dispositions.json and silently
+    // no-op'd every mark under a nested marker.
+    //
+    // #1087: "silencing is not fixing" applies to the WHOLE class, not just the
+    // policy member. This single pipeline is applied identically to the live set
+    // AND (below) to the delta baseline, so a finding persistently dropped by
+    // ANY layer — overlap, inline suppression, disposition, or policy — is
+    // absent from both sides of the delta and never oscillates into `fixed`
+    // (which `trackAgentFixed` would otherwise inflate forever). The stored
+    // baseline remains the unfiltered `dedupedDiagnostics`, so editing a
+    // project's policy/suppressions never resets or corrupts the user-authored
+    // delta baseline — the filtering is re-derived on read for both sides.
+    const applyOutputFilters = (diags) => {
+        const dockerOverlap = suppressTrivyConfigDockerOverlap(diags);
+        const overlap = suppressLintOverlapsWithLsp(dockerOverlap);
+        const inline = applyInlineSuppressions(overlap, fileContent);
+        const disposition = applyDispositions(inline, ctx.projectRoot ?? ctx.cwd, ctx.filePath, fileContent);
+        return applyRulePolicy(disposition, rulePolicy);
+    };
+    let visibleDiagnostics = applyOutputFilters(dedupedDiagnostics);
     let resolvedCount = 0;
     if (ctx.deltaMode && previousBaseline) {
-        const filtered = filterDelta(visibleDiagnostics, previousBaseline, (d) => d.id);
+        // Silencing a rule is not fixing it. The stored baseline is deliberately
+        // unfiltered (below), so compare against a fully-filtered view of it
+        // through the SAME pipeline — otherwise every persistently-suppressed
+        // finding sits in `fixed` on every dispatch and inflates the agent's
+        // resolved tally (trackAgentFixed) forever. Only `fixed` changes:
+        // filtered-out ids are absent from `after` either way.
+        const filtered = filterDelta(visibleDiagnostics, applyOutputFilters(previousBaseline), (d) => d.id);
         visibleDiagnostics = promoteDeltaUnusedToBlockers(filtered.new);
         resolvedCount = filtered.fixed.length;
     }
@@ -595,11 +737,16 @@ export async function dispatchForFile(ctx, groups, registry, onRunnerResult) {
     const blockers = visibleDiagnostics.filter((d) => d.semantic === "blocking");
     const warnings = visibleDiagnostics.filter((d) => d.semantic === "warning" || d.semantic === "none");
     const fixedItems = visibleDiagnostics.filter((d) => d.semantic === "fixed");
-    // Append fixed and fixable diagnostics to the persistent worklog
+    // Append fixed and fixable diagnostics to the persistent worklog, attributed
+    // to the runtime's active model/provider when known (#1448).
+    const worklogIdentity = {
+        model: ctx.telemetryModel,
+        provider: ctx.telemetryProvider,
+    };
     if (fixedItems.length > 0) {
         import("../fix-worklog.js")
             .then(({ appendToWorklog }) => {
-            appendToWorklog(ctx.cwd, fixedItems, true);
+            appendToWorklog(ctx.cwd, fixedItems, true, worklogIdentity);
         })
             .catch(() => { });
     }
@@ -607,7 +754,7 @@ export async function dispatchForFile(ctx, groups, registry, onRunnerResult) {
     if (fixableWarnings.length > 0) {
         import("../fix-worklog.js")
             .then(({ appendToWorklog }) => {
-            appendToWorklog(ctx.cwd, fixableWarnings, false);
+            appendToWorklog(ctx.cwd, fixableWarnings, false, worklogIdentity);
         })
             .catch(() => { });
     }

package/node_modules/pi-lens/dist/clients/dispatch/facts/function-facts.js

@@ -1,3 +1,4 @@
+import { isJstsFactFile } from "../../file-kinds.js";
 import { findOwnerName } from "../../symbol-containment.js";
 import { extractFactsFromTree, firstChildOfType, walk, } from "./tree-sitter-facts.js";
 const BOUNDARY_PREFIXES = [
@@ -56,12 +57,26 @@ function getParameters(node) {
     if (!fp)
         return [];
     return (fp.children ?? []).filter((c) => c &&
-        (c.type === "required_parameter" ||
+        (c.type === "identifier" ||
+            c.type === "required_parameter" ||
             c.type === "optional_parameter" ||
-            c.type === "rest_pattern"));
+            c.type === "rest_pattern" ||
+            c.type === "assignment_pattern" ||
+            // Plain JavaScript's grammar places a top-level destructured
+            // parameter directly as an object_pattern/array_pattern child
+            // of formal_parameters — no required_parameter wrapper (the TS
+            // grammar always wraps every parameter, destructured or not,
+            // which is why the wrapper types above already covered TS).
+            // Without this, `function f({a, b})` counted 0 params in JS
+            // while the TS-annotated equivalent counted correctly (#1089 P3-4).
+            c.type === "object_pattern" ||
+            c.type === "array_pattern"));
 }
 function parameterName(param) {
-    return firstNamedChild(param)?.text ?? "";
+    // JavaScript's grammar keeps a leaf parameter as the identifier itself;
+    // there is no named child to unwrap. TypeScript parameter wrapper nodes still
+    // use their first named child (type annotation/default/rest target).
+    return param.type === "identifier" ? param.text : firstNamedChild(param)?.text ?? "";
 }
 function getFunctionName(node) {
     if (node.type === "function_declaration") {
@@ -254,10 +269,10 @@ function hasReturnAwaitCall(node) {
 }
 export const functionFactProvider = {
     id: "fact.file.functions",
-    provides: ["file.functionSummaries"],
+    provides: ["file.functionSummaries", "file.functionFactsCoverage"],
     requires: ["file.content"],
     appliesTo(ctx) {
-        return /\.tsx?$/.test(ctx.filePath);
+        return isJstsFactFile(ctx.filePath);
     },
     async run(ctx, store) {
         await extractFactsFromTree(ctx, store, { "file.functionSummaries": [] }, (root) => {
@@ -309,7 +324,8 @@ export const functionFactProvider = {
                     addSummary(node);
                 if (node.type === "class_declaration" ||
                     node.type === "interface_declaration") {
-                    const nameNode = firstChildOfType(node, "type_identifier");
+                    const nameNode = firstChildOfType(node, "type_identifier") ??
+                        firstChildOfType(node, "identifier");
                     if (nameNode) {
                         containers.push({
                             name: nameNode.text,
@@ -325,6 +341,6 @@ export const functionFactProvider = {
                     summary.owner = owner;
             }
             return { "file.functionSummaries": summaries };
-        });
+        }, "file.functionFactsCoverage");
     },
 };

package/node_modules/pi-lens/dist/clients/dispatch/facts/import-facts.js

@@ -1,18 +1,6 @@
 import { logLatency } from "../../latency-logger.js";
+import { isJstsFactFile } from "../../file-kinds.js";
 import { childrenOfType, firstChildOfType, withFactTree, walk, } from "./tree-sitter-facts.js";
-// JS/TS extensions this provider handles (→ tree-sitter typescript/tsx/javascript
-// grammars via resolveTreeSitterLanguage). Ported off the `typescript` compiler API
-// onto tree-sitter (#402) — the parse is served from the shared, cached client.
-const JSTS_EXTS = new Set([
-    ".ts",
-    ".tsx",
-    ".mts",
-    ".cts",
-    ".js",
-    ".jsx",
-    ".mjs",
-    ".cjs",
-]);
 function stripQuotes(raw) {
     return raw.replace(/^["'`]+|["'`]+$/g, "");
 }
@@ -78,19 +66,19 @@ function parseReExport(node) {
 }
 export const importFactProvider = {
     id: "fact.file.imports",
-    provides: ["file.imports", "file.reexports"],
+    provides: ["file.imports", "file.reexports", "file.importFactsCoverage"],
     requires: ["file.content"],
     appliesTo(ctx) {
-        const ext = ctx.filePath.slice(ctx.filePath.lastIndexOf(".")).toLowerCase();
-        return JSTS_EXTS.has(ext);
+        return isJstsFactFile(ctx.filePath);
     },
     async run(ctx, store) {
         const content = store.getFileFact(ctx.filePath, "file.content");
-        const setEmpty = () => {
+        const setEmpty = (complete = false) => {
             store.setFileFact(ctx.filePath, "file.imports", []);
             store.setFileFact(ctx.filePath, "file.reexports", []);
+            store.setFileFact(ctx.filePath, "file.importFactsCoverage", complete ? "complete" : "unavailable");
         };
-        if (!content) {
+        if (content == null) {
             setEmpty();
             return;
         }
@@ -205,5 +193,7 @@ export const importFactProvider = {
         });
         if (!parsed.parsed)
             setEmpty();
+        else
+            store.setFileFact(ctx.filePath, "file.importFactsCoverage", "complete");
     },
 };