pi-lens 3.8.70 → 3.8.71

package/dist/clients/dispatch/auxiliary-lsp.js

@@ -17,6 +17,7 @@
  * `role:"auxiliary"` (clients/lsp/server.ts) + one profile entry here.
  */
 import { shouldDegradeAuxiliaryLsp } from "../lsp-budget.js";
+import { isSubagentSession } from "../subagent-mode.js";
 import { findLocalOpengrepConfig } from "../opengrep-config.js";
 import { findLocalTyposConfig } from "../typos-config.js";
 import { findLocalZizmorConfig } from "../zizmor-config.js";
@@ -89,6 +90,11 @@ export const AUXILIARY_LSP_PROFILES = [
         sourceMatch: /ast[-_]?grep/i,
         killSwitchFlag: "no-ast-grep",
         enabledByDefault: true,
+        // Matches the in-process ast-grep-napi runner's own `skipTestFiles: true`
+        // (#687) — that flag stops applying the moment the ast-grep binary is
+        // present, since the napi runner then skips entirely in favor of this
+        // LSP surface, which had no test-file gating of its own.
+        skipTestFiles: true,
         // The ast-grep LSP runs either the repo's own sgconfig (when present) or
         // pi-lens's shipped baseline sgconfig. In both cases the rule severity is
         // deliberate, so preserve ast-grep's severity semantics: ERROR can block,
@@ -144,7 +150,12 @@ export const AUXILIARY_LSP_PROFILES = [
  * per-file: once over budget, this session never spawns its auxiliary fleet,
  * rather than flip-flopping file to file. */
 export function enabledAuxiliaryLspServerIds(getFlag) {
-    if (shouldDegradeAuxiliaryLsp())
+    // #449 slice 2 (budget): skip auxiliaries when machine-wide LSP budget is
+    // exceeded. #713 (subagent light mode): reuse the same seam — a subagent
+    // session also skips auxiliaries; the parent session already runs them on
+    // the same cwd. PI_LENS_SUBAGENT_FULL=1 restores full behavior via
+    // isSubagentSession() returning false.
+    if (shouldDegradeAuxiliaryLsp() || isSubagentSession())
         return [];
     return AUXILIARY_LSP_PROFILES.flatMap((p) => p.enabledByDefault &&
         !(p.killSwitchFlag && getFlag(p.killSwitchFlag) === true)
@@ -194,7 +205,78 @@ export function isAuxiliaryDiagnosticSuppressed(d, content) {
  * equivalent) suppresses a finding identically whether it's seen via the
  * per-edit dispatch runner or a standalone diagnostics query — previously
  * only the former honored it (#586).
+ *
+ * #692: `opts.fileRole` additionally drops a diagnostic whose auxiliary
+ * profile declares `skipTestFiles` (e.g. ast-grep, #687) when the file is a
+ * test file — the per-edit dispatch runner (`clients/dispatch/runners/lsp.ts`)
+ * has applied this gate since #687/#688 via its own inline check; the
+ * `runWorkspaceDiagnostics` workspace sweep (`clients/lsp/index.ts`) called
+ * this function WITHOUT ever passing a fileRole, so ast-grep findings on test
+ * files that are suppressed per-edit reappeared wholesale in every
+ * `mode=full` sweep. Omitting `opts` (or `opts.fileRole`) keeps every existing
+ * 2-arg call site's behavior byte-for-byte unchanged.
+ */
+export function applyAuxiliarySuppressions(diagnostics, content, opts) {
+    return diagnostics.filter((d) => {
+        if (isAuxiliaryDiagnosticSuppressed(d, content))
+            return false;
+        if (opts?.fileRole === "test") {
+            const profile = findAuxiliaryProfileForSource(d.source);
+            if (profile?.skipTestFiles)
+                return false;
+        }
+        return true;
+    });
+}
+/**
+ * #692: shared aux re-tag implementation — extracted from the per-edit
+ * dispatch runner (`clients/dispatch/runners/lsp.ts`) so a scan/sweep path
+ * that reconciles LSP diagnostics into widget state (`lens_diagnostics
+ * mode=full`, `lsp_diagnostics`) gives its auxiliary-sourced findings
+ * (ast-grep, opengrep, zizmor, typos) the SAME tool re-tag, semantic policy,
+ * and defect-class classification the per-edit path always has — previously
+ * only the per-edit runner ran this loop, so a scan-reconciled aux finding
+ * kept `tool: "lsp"` and lost its curated-repo-rules `blockingAllowed`
+ * context entirely (#692).
+ *
+ * `diagnostics` and `rawLspDiags` must be the SAME length and index-aligned —
+ * `convertLspDiagnostics` maps its input 1:1, so this holds for every caller
+ * that passes it the same array it just converted. Mutates and returns the
+ * SURVIVING subset of `diagnostics` (native-inline-suppressed and
+ * `skipTestFiles`-dropped entries removed), mirroring the per-edit runner's
+ * prior inline behavior exactly.
  */
-export function applyAuxiliarySuppressions(diagnostics, content) {
-    return diagnostics.filter((d) => !isAuxiliaryDiagnosticSuppressed(d, content));
+export function retagAuxiliaryDiagnostics(diagnostics, rawLspDiags, content, ctx) {
+    const blockingAllowedByProfile = new Map();
+    const suppressedIndices = new Set();
+    for (let i = 0; i < diagnostics.length; i++) {
+        const profile = findAuxiliaryProfileForSource(rawLspDiags[i]?.source);
+        if (!profile)
+            continue;
+        if (profile.skipTestFiles && ctx.fileRole === "test") {
+            suppressedIndices.add(i);
+            continue;
+        }
+        if (isAuxiliaryDiagnosticSuppressed(rawLspDiags[i], content)) {
+            suppressedIndices.add(i);
+            continue;
+        }
+        let blockingAllowed = blockingAllowedByProfile.get(profile);
+        if (blockingAllowed === undefined) {
+            blockingAllowed = profile.allowBlocking?.(ctx.cwd) ?? false;
+            blockingAllowedByProfile.set(profile, blockingAllowed);
+        }
+        const d = diagnostics[i];
+        d.tool = profile.tool;
+        d.semantic = profile.semantic(rawLspDiags[i], { blockingAllowed });
+        if (d.semantic !== "blocking" && d.severity === "error") {
+            d.severity = "warning";
+        }
+        const defectClass = profile.defectClass?.(rawLspDiags[i]);
+        if (defectClass)
+            d.defectClass = defectClass;
+    }
+    return suppressedIndices.size
+        ? diagnostics.filter((_, i) => !suppressedIndices.has(i))
+        : diagnostics;
 }

package/dist/clients/dispatch/dispatcher.js

@@ -27,6 +27,7 @@ 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 { applyDispositions } from "../diagnostic-dispositions.js";
 import { applyInlineSuppressions } from "./inline-suppressions.js";
 import { getToolPlan } from "./plan.js";
 import { resolveRunnerPath } from "./runner-context.js";
@@ -559,7 +560,11 @@ export async function dispatchForFile(ctx, groups, registry, onRunnerResult) {
     const overlapSuppressed = suppressLintOverlapsWithLsp(dockerOverlapSuppressed);
     const fileContent = ctx.facts.getFileFact(ctx.filePath, "file.content") ?? "";
     const inlineSuppressed = applyInlineSuppressions(overlapSuppressed, fileContent);
-    let visibleDiagnostics = inlineSuppressed;
+    // #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.
+    const dispositionFiltered = applyDispositions(inlineSuppressed, ctx.cwd, ctx.filePath, fileContent);
+    let visibleDiagnostics = dispositionFiltered;
     let resolvedCount = 0;
     if (ctx.deltaMode && previousBaseline) {
         const filtered = filterDelta(visibleDiagnostics, previousBaseline, (d) => d.id);

package/dist/clients/dispatch/integration.js

@@ -821,7 +821,13 @@ export async function computeCascadeForFile(filePath, cwd, options = {}) {
                 coldSnapshotPaths.push(neighborPath);
                 continue;
             }
-            const diags = convertLspDiagnostics(entry.diags.filter((d) => d.severity === 1).slice(0, MAX_PER_FILE), neighborPath, { source: "cascade" });
+            // #692: `source: "cascade"` used to be passed here to label `rule`
+            // (`cascade:<code>`) — that override is gone (identity must come from
+            // the diagnostic's own source; see `scanOrigin`'s doc comment), and
+            // cascade neighbor diagnostics are ephemeral display-only output
+            // (never reconciled into persisted widget/dedup state), so the label
+            // had no remaining purpose and is simply dropped rather than migrated.
+            const diags = convertLspDiagnostics(entry.diags.filter((d) => d.severity === 1).slice(0, MAX_PER_FILE), neighborPath);
             producedLspData = true;
             const durationMs = Date.now() - neighborStart;
             logCascade({
@@ -994,7 +1000,11 @@ export async function computeCascadeForFile(filePath, cwd, options = {}) {
             });
             if (!rawDiags)
                 return undefined;
-            const diags = convertLspDiagnostics(rawDiags.filter((d) => d.severity === 1).slice(0, MAX_PER_FILE), neighborPath, { source: "cascade" });
+            // #692: `source: "cascade"` no longer overrides `rule` (see the
+            // doc comment on the sibling call above) — dropped rather than
+            // migrated to `scanOrigin` since cascade output never touches
+            // persisted widget/dedup state.
+            const diags = convertLspDiagnostics(rawDiags.filter((d) => d.severity === 1).slice(0, MAX_PER_FILE), neighborPath);
             const durationMs = Date.now() - neighborStart;
             // Update cache for this neighbor at the current write sequence
             if (writeSeq != null) {
@@ -1051,10 +1061,13 @@ export async function computeCascadeForFile(filePath, cwd, options = {}) {
                     error: String(result.reason),
                 });
                 const entry = allDiags.get(normalizeMapKey(neighborPath));
+                // #692: `source: "cascade"` dropped (see the doc comment above the
+                // first cascade call site in this file) — no longer affects `rule`
+                // and cascade output never touches persisted widget/dedup state.
                 const diags = entry && Date.now() - entry.ts < CASCADE_TTL_MS
                     ? convertLspDiagnostics(entry.diags
                         .filter((d) => d.severity === 1)
-                        .slice(0, MAX_PER_FILE), neighborPath, { source: "cascade" })
+                        .slice(0, MAX_PER_FILE), neighborPath)
                     : [];
                 neighbors.push({
                     filePath: neighborPath,
@@ -1162,7 +1175,9 @@ function appendFallbackNeighbors(neighbors, allDiags, normalizedFileKey, cwd) {
             continue;
         if (now - ts > CASCADE_TTL_MS)
             continue;
-        const errors = convertLspDiagnostics(diags.filter((d) => d.severity === 1).slice(0, MAX_PER_FILE), diagPath, { source: "cascade" });
+        // #692: `source: "cascade"` dropped — see the doc comment above the
+        // first cascade `convertLspDiagnostics` call site in this file.
+        const errors = convertLspDiagnostics(diags.filter((d) => d.severity === 1).slice(0, MAX_PER_FILE), diagPath);
         if (errors.length === 0)
             continue;
         neighbors.push({

package/dist/clients/dispatch/runners/lsp.js

@@ -16,7 +16,7 @@ import { RUNTIME_CONFIG } from "../../runtime-config.js";
 import { PRIORITY } from "../priorities.js";
 import { resolveRunnerPath } from "../runner-context.js";
 import { convertLspDiagnostics } from "../utils/lsp-diagnostics.js";
-import { enabledAuxiliaryLspServerIds, findAuxiliaryProfileForSource, isAuxiliaryDiagnosticSuppressed, } from "../auxiliary-lsp.js";
+import { enabledAuxiliaryLspServerIds, retagAuxiliaryDiagnostics, } from "../auxiliary-lsp.js";
 import { readFileContent } from "./utils.js";
 const LSP_MAX_FILE_BYTES = RUNTIME_CONFIG.pipeline.lspMaxFileBytes;
 const LSP_MAX_FILE_LINES = RUNTIME_CONFIG.pipeline.lspMaxFileLines;
@@ -225,37 +225,10 @@ const lspRunner = {
         // convertLspDiagnostics maps validLspDiags 1:1, so re-tag any
         // auxiliary-sourced diagnostics (opengrep emits source "Semgrep", …) with
         // their tool id + semantic policy — language-server diagnostics keep "lsp".
-        // blockingAllowed is per-workspace (e.g. curated repo rules), computed once.
-        const blockingAllowedByProfile = new Map();
-        // Diagnostics dropped by the tool's NATIVE inline suppression (e.g. opengrep
-        // `# nosemgrep`, #441). Reuses `content` from the sync read above.
-        const suppressedIndices = new Set();
-        for (let i = 0; i < diagnostics.length; i++) {
-            const profile = findAuxiliaryProfileForSource(validLspDiags[i]?.source);
-            if (!profile)
-                continue;
-            if (isAuxiliaryDiagnosticSuppressed(validLspDiags[i], content)) {
-                suppressedIndices.add(i);
-                continue;
-            }
-            let blockingAllowed = blockingAllowedByProfile.get(profile);
-            if (blockingAllowed === undefined) {
-                blockingAllowed = profile.allowBlocking?.(ctx.cwd) ?? false;
-                blockingAllowedByProfile.set(profile, blockingAllowed);
-            }
-            const d = diagnostics[i];
-            d.tool = profile.tool;
-            d.semantic = profile.semantic(validLspDiags[i], { blockingAllowed });
-            if (d.semantic !== "blocking" && d.severity === "error") {
-                d.severity = "warning";
-            }
-            const defectClass = profile.defectClass?.(validLspDiags[i]);
-            if (defectClass)
-                d.defectClass = defectClass;
-        }
-        const keptDiagnostics = suppressedIndices.size
-            ? diagnostics.filter((_, i) => !suppressedIndices.has(i))
-            : diagnostics;
+        // #692: shared with the scan/sweep reconcile paths (`retagAuxiliaryDiagnostics`
+        // in `../auxiliary-lsp.js`) so a scan-reconciled aux finding gets identical
+        // tool/semantic/defectClass tagging instead of keeping tool "lsp".
+        const keptDiagnostics = retagAuxiliaryDiagnostics(diagnostics, validLspDiags, content, { cwd: ctx.cwd, fileRole: ctx.fileRole });
         const hasErrors = keptDiagnostics.some((d) => d.semantic === "blocking");
         const resultSemantic = hasErrors
             ? "blocking"

package/dist/clients/dispatch/runners/oxlint.js

@@ -44,7 +44,7 @@ const oxlintRunner = {
     appliesTo: ["jsts"],
     priority: PRIORITY.LINT_SECONDARY,
     enabledByDefault: true,
-    skipTestFiles: true,
+    skipTestFiles: false,
     async run(ctx) {
         const cwd = ctx.cwd || process.cwd();
         const policy = getJstsLintPolicyForCwd(cwd);

package/dist/clients/dispatch/suppress-writer.js

@@ -0,0 +1,68 @@
+/**
+ * Writes the `pi-lens-ignore` suppression comment that inline-suppressions.ts
+ * already knows how to read (#690's `suppress` disposition). The reader
+ * accepts either `//` or `#` on any line regardless of language, but the
+ * WRITER must pick the syntactically valid comment character for the target
+ * file — an errant `#` line breaks parsing in a `//`-comment language and
+ * vice versa.
+ */
+import * as path from "node:path";
+const HASH_COMMENT_EXTENSIONS = new Set([
+    ".py",
+    ".rb",
+    ".sh",
+    ".bash",
+    ".zsh",
+    ".yml",
+    ".yaml",
+    ".toml",
+    ".r",
+    ".pl",
+    ".pm",
+    ".ex",
+    ".exs",
+    ".elixir",
+    ".dockerfile",
+    ".gitignore",
+    ".conf",
+    ".cfg",
+    ".ini",
+]);
+function commentPrefixFor(filePath) {
+    const ext = path.extname(filePath).toLowerCase();
+    return HASH_COMMENT_EXTENSIONS.has(ext) ? "#" : "//";
+}
+/**
+ * Insert a `pi-lens-ignore: <rule>` comment on the line immediately above
+ * `line` (1-based), matching inline-suppressions.ts's "same line or line
+ * above" read semantics. If the line above already carries a pi-lens-ignore
+ * comment, the rule is appended to its list instead of adding a duplicate
+ * comment line. Returns the updated content; throws if `line` is out of range.
+ */
+export function insertSuppressComment(content, filePath, line, rule) {
+    const lines = content.split(/\r?\n/);
+    if (line < 1 || line > lines.length) {
+        throw new Error(`line ${line} is out of range (file has ${lines.length} lines)`);
+    }
+    const prefix = commentPrefixFor(filePath);
+    const aboveIdx = line - 2; // 0-based index of the line immediately above
+    const existingAbove = aboveIdx >= 0 ? lines[aboveIdx] : undefined;
+    const suppressRe = /((?:\/\/|#)\s*pi-lens-ignore:\s*)(.+)$/;
+    const match = existingAbove !== undefined ? suppressRe.exec(existingAbove) : null;
+    if (match && existingAbove !== undefined) {
+        const rules = match[2]
+            .split(",")
+            .map((r) => r.trim())
+            .filter(Boolean);
+        if (!rules.includes(rule))
+            rules.push(rule);
+        lines[aboveIdx] = existingAbove.slice(0, match.index) + match[1] + rules.join(", ");
+        return lines.join("\n");
+    }
+    // Match the indentation of the flagged line so the inserted comment lines
+    // up rather than sitting at column 0.
+    const targetLine = lines[line - 1] ?? "";
+    const indent = /^\s*/.exec(targetLine)?.[0] ?? "";
+    lines.splice(line - 1, 0, `${indent}${prefix} pi-lens-ignore: ${rule}`);
+    return lines.join("\n");
+}

package/dist/clients/dispatch/utils/lsp-diagnostics.js

@@ -7,7 +7,9 @@ export function convertLspDiagnostics(diags, filePath, options = {}) {
         const severity = severityMap[d.severity] ?? "info";
         const semantic = d.severity === 1 ? "blocking" : (d.severity === 2 ? "warning" : "none");
         const code = String(d.code ?? "unknown");
-        const source = options.source ?? d.source ?? tool;
+        // #692: identity ALWAYS derives from the diagnostic's own source — never
+        // from a caller-supplied scan label (see `scanOrigin`'s doc comment above).
+        const source = d.source ?? tool;
         const hasSuggestion = options.fixSuggestionByIndex?.has(idx) ?? false;
         return {
             id: `${tool}:${code}:${d.range.start.line}`,
@@ -23,6 +25,7 @@ export function convertLspDiagnostics(diags, filePath, options = {}) {
             autoFixAvailable: false,
             fixKind: hasSuggestion ? "suggestion" : undefined,
             fixSuggestion: options.fixSuggestionByIndex?.get(idx),
+            scanOrigin: options.scanOrigin,
         };
     });
 }

package/dist/clients/disposition-logger.js

@@ -0,0 +1,39 @@
+/**
+ * NDJSON telemetry log for diagnostic disposition marks (#690). Same shape as
+ * clients/actionable-warnings-logger.ts: machine-global (getGlobalPiLensDir),
+ * size-capped with a single `.log.1` backup, isTestMode no-op.
+ *
+ * Why a log at all: #181 identified false-positive marks flowing to telemetry
+ * as THE highest-value rule-tuning signal — which shipped rules misfire, on
+ * what tools, how often — and this is that hookup. The disposition store
+ * itself is not enough: it keeps only the LATEST entry per anchor (a re-mark
+ * overwrites), and `defer` marks never touch the store at all (in-memory by
+ * design), so this log is the only durable trace of both re-mark history and
+ * defer activity.
+ */
+import * as path from "node:path";
+import { isTestMode } from "./env-utils.js";
+import { getGlobalPiLensDir } from "./file-utils.js";
+import { createNdjsonLogger } from "./ndjson-logger.js";
+const DISPOSITION_LOG_DIR = getGlobalPiLensDir();
+const DISPOSITION_LOG_FILE = path.join(DISPOSITION_LOG_DIR, "dispositions.log");
+const DISPOSITION_LOG_BACKUP_FILE = path.join(DISPOSITION_LOG_DIR, "dispositions.log.1");
+const MAX_LOG_BYTES = Math.max(128 * 1024, Number.parseInt(process.env.PI_LENS_DISPOSITION_LOG_MAX_BYTES ?? "1048576", 10) || 1048576);
+const writer = createNdjsonLogger({
+    filePath: DISPOSITION_LOG_FILE,
+    maxBytes: MAX_LOG_BYTES,
+    backupPath: DISPOSITION_LOG_BACKUP_FILE,
+});
+export function logDispositionEvent(entry) {
+    if (isTestMode()) {
+        return;
+    }
+    writer.log({ ts: new Date().toISOString(), ...entry });
+}
+export function getDispositionLogPath() {
+    return DISPOSITION_LOG_FILE;
+}
+/** Resolve once all enqueued disposition writes are on disk. */
+export function flushDispositionLog() {
+    return writer.flush();
+}

package/dist/clients/disposition-publish.js

@@ -0,0 +1,109 @@
+/**
+ * Publishes `pilens:diagnostic:disposition` on pi's shared `pi.events` bus
+ * (#690).
+ *
+ * Sibling to `clients/diagnostics-publish.ts` (#502) rather than a new export
+ * inside it, per the "owns nothing in common" rule spelled out in
+ * format-events-publish.ts's header: the event is diagnostic-DOMAIN, but it
+ * shares none of diagnostics-publish's module state or contract —
+ * dispositions are point-in-time FACTS ("a mark just happened"), not
+ * full-replace state snapshots, so the seq counter, the
+ * previously-reported-dirty set, and the whole staleness/replace consumer
+ * contract over there simply don't apply here. Only the emit plumbing shape
+ * and the `PI_LENS_BUS_PUBLISH` kill switch (`isBusPublishEnabled`, imported
+ * from bus-publish.ts) are shared, same as every other producer sibling.
+ *
+ * Fire-and-forget: publishing must never affect the mark path's success or
+ * latency. Any failure is swallowed; `dbg` fires at most once per process on
+ * first failure so a wired caller can log it without spamming.
+ *
+ * Versioning policy: frozen-additive, same discipline as #482/#502. New
+ * optional fields may be added under `v: 1`; a breaking change to an existing
+ * field's meaning must bump `v`.
+ */
+import { logBusEvent } from "./bus-events-logger.js";
+import { isBusPublishEnabled } from "./bus-publish.js";
+import { normalizeFilePath } from "./path-utils.js";
+export const BUS_DISPOSITION_EVENT = "pilens:diagnostic:disposition";
+export const BUS_DISPOSITION_VERSION = 1;
+let busEmit;
+let hasLoggedFailure = false;
+let hasLoggedUnwired = false;
+let hasLoggedDisabled = false;
+/**
+ * Wire the emit function from pi's `pi.events` bus. Called once at extension
+ * factory time from index.ts, same call as `wireDiagnosticsBusEmitter` (#502)
+ * — both producers share the identical `pi.events.emit` binding. Never called
+ * ⇒ `publishDisposition` no-ops, which is exactly the state unit tests and
+ * the MCP server path run in (no pi host, no `pi.events`).
+ */
+export function wireDispositionBusEmitter(emitFn) {
+    busEmit = emitFn;
+}
+/** Test-only: reset module state between test files. */
+export function _resetDispositionPublishForTests() {
+    busEmit = undefined;
+    hasLoggedFailure = false;
+    hasLoggedUnwired = false;
+    hasLoggedDisabled = false;
+}
+/**
+ * Publish one `pilens:diagnostic:disposition` event for a mark (one event per
+ * markDisposition call). Fire-and-forget: never throws, never awaited.
+ */
+export function publishDisposition(args) {
+    if (!isBusPublishEnabled()) {
+        if (!hasLoggedDisabled) {
+            hasLoggedDisabled = true;
+            logBusEvent({
+                event: BUS_DISPOSITION_EVENT,
+                outcome: "skipped_disabled",
+                cwd: normalizeFilePath(args.cwd),
+            });
+        }
+        return;
+    }
+    if (!busEmit) {
+        if (!hasLoggedUnwired) {
+            hasLoggedUnwired = true;
+            logBusEvent({
+                event: BUS_DISPOSITION_EVENT,
+                outcome: "skipped_unwired",
+                cwd: normalizeFilePath(args.cwd),
+            });
+        }
+        return;
+    }
+    try {
+        const payload = {
+            v: BUS_DISPOSITION_VERSION,
+            source: "pi-lens",
+            cwd: normalizeFilePath(args.cwd),
+            filePath: normalizeFilePath(args.filePath),
+            disposition: args.disposition,
+            tool: args.tool,
+            rule: args.rule,
+            line: args.line,
+            anchor: args.anchor,
+            reason: args.reason,
+        };
+        busEmit(BUS_DISPOSITION_EVENT, payload);
+        logBusEvent({
+            event: BUS_DISPOSITION_EVENT,
+            outcome: "emitted",
+            cwd: payload.cwd,
+        });
+    }
+    catch (err) {
+        logBusEvent({
+            event: BUS_DISPOSITION_EVENT,
+            outcome: "emit_failed",
+            cwd: normalizeFilePath(args.cwd),
+            error: String(err),
+        });
+        if (!hasLoggedFailure) {
+            hasLoggedFailure = true;
+            args.dbg?.(`disposition-publish: pilens:diagnostic:disposition emit failed (further failures suppressed): ${err}`);
+        }
+    }
+}