@adia-ai/gen-ui 0.8.37

package/compose/strategies/zettel/issue-reporter.js

@@ -0,0 +1,607 @@
+/**
+ * Issue-reporter — first-class telemetry surface for the gen-UI engine.
+ *
+ * Three call paths converge here:
+ *   1. LLM self-fire — the `report_issue` MCP tool. ctx.reporter = 'llm'.
+ *   2. Consumer-fire — human user requests a bug ticket. ctx.reporter = 'user'.
+ *   3. Engine auto-fire — internal failure paths trigger `autoReport(reason)`.
+ *      ctx.reporter = 'auto'. Suppressed when ctx.evalMode is true.
+ *
+ * Every issue lands as immutable JSON under `qa/findings/issues/`.
+ * Traces > 200KB spill to a sidecar `.trace.json` next to the issue.
+ *
+ * Spec: .claude/docs/specs/genui-multiturn-architecture.md §3.5 + §4.6 + §11.
+ *
+ * Distinct from the curated `.tickets/` system (corpus/scripts/ticket.mjs):
+ * those are human-authored work items. Issues here are runtime telemetry —
+ * promoted to tickets during weekly triage when patterns emerge (spec §11.5).
+ */
+
+import { mkdir, writeFile } from 'node:fs/promises';
+import { dirname, resolve, join } from 'node:path';
+import { fileURLToPath } from 'node:url';
+
+const __dirname = dirname(fileURLToPath(import.meta.url));
+const REPO_ROOT = resolve(__dirname, '../../../../..');
+const DEFAULT_STORAGE_ROOT = resolve(REPO_ROOT, 'qa/findings/issues');
+const TRACE_INLINE_THRESHOLD_BYTES = 200 * 1024;
+
+const VALID_TYPES = new Set(['bug', 'training-gap', 'protocol-gap', 'ux-feedback']);
+const VALID_SEVERITIES = new Set(['blocker', 'drift', 'nit']);
+const VALID_OWNERS = new Set(['synthesis', 'retrieval', 'validator', 'chunk-corpus', 'mcp-protocol', 'unknown']);
+const VALID_TRACE_DEPTHS = new Set(['full', 'summary', 'none']);
+const VALID_REPORTER_KINDS = new Set(['auto', 'user', 'llm']);
+
+const SEVERITY_RANK = { nit: 0, drift: 1, blocker: 2 };
+
+/**
+ * Auto-fire policy: maps reason → defaults for type/severity/owner/title.
+ * Spec §11.3.
+ */
+export const AUTO_FIRE_POLICY = {
+  'synthesizer-exhausted': {
+    type: 'bug',
+    severity: 'drift',
+    suggested_owner: 'synthesis',
+    titleFor: (ctx) => `Synthesizer exhausted retries${ctx?.intent ? ` for "${truncate(ctx.intent, 50)}"` : ''}`,
+  },
+  'validator-exhausted': {
+    type: 'bug',
+    severity: 'blocker',
+    suggested_owner: 'validator',
+    titleFor: (ctx) => `Validator exhausted retries on ${ctx?.tool || 'refine_composition'}`,
+  },
+  'locator-empty-targets': {
+    type: 'bug',
+    severity: 'drift',
+    suggested_owner: 'synthesis',
+    titleFor: (ctx) => `Locator pass returned empty targets${ctx?.intent ? ` for "${truncate(ctx.intent, 50)}"` : ''}`,
+  },
+  'retrieval-zero-then-synthesis-fail': {
+    type: 'training-gap',
+    severity: 'drift',
+    suggested_owner: 'chunk-corpus',
+    titleFor: (ctx) => `Retrieval returned 0 candidates and synthesis failed${ctx?.intent ? ` for "${truncate(ctx.intent, 40)}"` : ''}`,
+  },
+  'cache-miss-on-known-state': {
+    type: 'bug',
+    severity: 'nit',
+    suggested_owner: 'mcp-protocol',
+    titleFor: (ctx) => `get_state called with unknown state_id "${truncate(ctx?.state_id || 'unknown', 40)}"`,
+  },
+  'ops-failed-after-apply': {
+    type: 'bug',
+    severity: 'drift',
+    suggested_owner: 'validator',
+    titleFor: () => `refine_composition ops_failed list non-empty after apply`,
+  },
+  'scope-drift': {
+    type: 'bug',
+    severity: 'drift',
+    suggested_owner: 'synthesis',
+    titleFor: (ctx) => {
+      const ratio = ctx?.scopeDrift?.ratio != null ? `${ctx.scopeDrift.ratio.toFixed(1)}×` : '';
+      const intent = ctx?.intent ? ` for "${truncate(ctx.intent, 40)}"` : '';
+      return `Scope drift${ratio ? ' ' + ratio : ''}: composed HTML exceeds bound-chunk envelope${intent}`;
+    },
+  },
+  'iteration-synthesis-failure': {
+    type: 'bug',
+    severity: 'drift',
+    suggested_owner: 'synthesis',
+    titleFor: (ctx) => {
+      const turn = ctx?.turn != null ? ` on turn ${ctx.turn}` : '';
+      const intent = ctx?.intent ? ` for "${truncate(ctx.intent, 40)}"` : '';
+      return `Iteration synthesis failed${turn}${intent}`;
+    },
+  },
+};
+
+function truncate(s, n = 60) {
+  if (!s || typeof s !== 'string') return '';
+  return s.length > n ? `${s.slice(0, n - 1)}…` : s;
+}
+
+function slugify(s, max = 40) {
+  return (s || '')
+    .toLowerCase()
+    .replace(/[^a-z0-9]+/g, '-')
+    .replace(/^-+|-+$/g, '')
+    .slice(0, max);
+}
+
+function mintIssueId(title) {
+  const date = new Date().toISOString().slice(0, 10);
+  const titleSlug = slugify(title) || 'issue';
+  const rand4 = Math.floor(Math.random() * 0xffff).toString(16).padStart(4, '0');
+  return `${date}-${titleSlug}-${rand4}`;
+}
+
+function getStorageRoot(ctx) {
+  return ctx?.storageRoot || DEFAULT_STORAGE_ROOT;
+}
+
+function validateInput(input) {
+  if (!input || typeof input !== 'object') {
+    throw new Error('reportIssue: input is required');
+  }
+  if (!input.title || typeof input.title !== 'string') {
+    throw new Error('reportIssue: title (string) is required');
+  }
+  if (input.title.length > 80) {
+    throw new Error('reportIssue: title must be ≤ 80 chars');
+  }
+  if (typeof input.body !== 'string') {
+    throw new Error('reportIssue: body (string) is required');
+  }
+  if (!VALID_TYPES.has(input.type)) {
+    throw new Error(`reportIssue: type must be one of ${[...VALID_TYPES].join('|')}`);
+  }
+  if (!VALID_SEVERITIES.has(input.severity)) {
+    throw new Error(`reportIssue: severity must be one of ${[...VALID_SEVERITIES].join('|')}`);
+  }
+  if (input.suggested_owner != null && !VALID_OWNERS.has(input.suggested_owner)) {
+    throw new Error(`reportIssue: suggested_owner must be one of ${[...VALID_OWNERS].join('|')}`);
+  }
+  if (input.trace != null && !VALID_TRACE_DEPTHS.has(input.trace)) {
+    throw new Error(`reportIssue: trace must be one of ${[...VALID_TRACE_DEPTHS].join('|')}`);
+  }
+  if (input.tags != null && !Array.isArray(input.tags)) {
+    throw new Error('reportIssue: tags must be an array');
+  }
+}
+
+/**
+ * Pull a trace from the cached state-entry.
+ *
+ * `summary` — final intent + last 5 ops + warnings (compact).
+ * `full` — every prompt, every LLM response, every validator result, every retry.
+ *
+ * Returns null when state_id is absent from the cache.
+ *
+ * @param {string} state_id
+ * @param {'full'|'summary'} depth
+ * @param {object} cache — StateCache instance (uses .peek() to avoid touching recency)
+ */
+export async function attachTrace(state_id, depth, cache) {
+  if (!cache || typeof cache.peek !== 'function') return null;
+  const entry = cache.peek(state_id);
+  if (!entry) return null;
+  if (depth === 'none') return null;
+
+  const baseTrace = {
+    state_id,
+    tool: entry.tool ?? null,
+    input: entry.input ?? null,
+  };
+
+  if (depth === 'summary') {
+    return {
+      ...baseTrace,
+      output: {
+        ops: (entry.ops_history || []).slice(-5),
+        delta_summary: entry.delta_summary ?? null,
+      },
+      warnings: entry.warnings || [],
+      duration_ms: entry.duration_ms ?? null,
+    };
+  }
+
+  // 'full' — high-resolution session trace. Includes everything from
+  // summary plus the synthesis breadcrumbs (retrieval log, LLM prompts,
+  // raw responses per attempt, validation, plan, composed HTML preview)
+  // so a human reviewer or future agent can replay the full session.
+  return {
+    ...baseTrace,
+    intent: entry.intent ?? null,
+    source: entry.source ?? null,
+    score: entry.score ?? null,
+    plan: entry.plan ?? null,
+    synthesis: entry.synthesis ?? null, // retrievalTrace, attemptsLog, prompts
+    htmlPreview: entry.html ? truncateHtmlForTrace(entry.html) : null,
+    componentCount: entry.html ? countComponents(entry.html) : null,
+    scopeDrift: entry.scopeDrift ?? null,
+    internal: entry.internal ?? null,
+    output: entry.output ?? {
+      ops: entry.ops_history || [],
+      delta_summary: entry.delta_summary ?? null,
+    },
+    warnings: entry.warnings || [],
+    duration_ms: entry.duration_ms ?? null,
+    parent_state_id: entry.parent_state_id ?? null,
+    created_at: entry.created_at ?? null,
+  };
+}
+
+const HTML_PREVIEW_MAX_BYTES = 8 * 1024;
+
+function truncateHtmlForTrace(html) {
+  if (typeof html !== 'string') return null;
+  if (html.length <= HTML_PREVIEW_MAX_BYTES) return html;
+  return html.slice(0, HTML_PREVIEW_MAX_BYTES) + `\n<!-- ... ${html.length - HTML_PREVIEW_MAX_BYTES} bytes truncated -->`;
+}
+
+function countComponents(html) {
+  if (typeof html !== 'string') return 0;
+  // Count opening tags (excluding void/standalone HTML elements that
+  // don't contribute to A2UI component count). Loose heuristic; signals
+  // scope drift even if it's not a perfect protocol-level count.
+  return (html.match(/<[a-z][a-z0-9-]*/g) || []).length;
+}
+
+/**
+ * Write an issue to disk.
+ *
+ * @returns {Promise<{ issue_id, path, ack: 'logged' }>}
+ */
+export async function reportIssue(input, ctx = {}) {
+  validateInput(input);
+
+  const storageRoot = getStorageRoot(ctx);
+  await mkdir(storageRoot, { recursive: true });
+
+  const issue_id = mintIssueId(input.title);
+  const created_at = new Date().toISOString();
+
+  const reporterKind = ctx.reporter && VALID_REPORTER_KINDS.has(ctx.reporter)
+    ? ctx.reporter
+    : 'user';
+
+  // Default to 'full' when a state_id is provided — high-resolution session
+  // tickets are the design intent (the previous 'summary' default produced
+  // tickets too thin to debug from). Caller can opt down to 'summary' or
+  // 'none' explicitly.
+  const traceDepth = input.trace ?? (input.state_id ? 'full' : 'none');
+  let trace = null;
+  if (input.state_id && traceDepth !== 'none') {
+    trace = await attachTrace(input.state_id, traceDepth, ctx.cache);
+  }
+
+  // Spill oversized traces to a sidecar file
+  let tracePayload = trace;
+  if (trace && JSON.stringify(trace).length > TRACE_INLINE_THRESHOLD_BYTES) {
+    const tracesDir = join(storageRoot, 'traces');
+    await mkdir(tracesDir, { recursive: true });
+    const tracePath = join(tracesDir, `${issue_id}.trace.json`);
+    await writeFile(tracePath, JSON.stringify(trace, null, 2));
+    tracePayload = { sidecar: `traces/${issue_id}.trace.json` };
+  }
+
+  const issue = {
+    issue_id,
+    created_at,
+    type: input.type,
+    severity: input.severity,
+    status: 'open',
+    title: input.title,
+    body: input.body,
+    reporter: {
+      kind: reporterKind,
+      context: ctx.reporterContext ?? null,
+    },
+    trace: tracePayload,
+    environment: ctx.versionInfo ?? null,
+    suggested_owner: input.suggested_owner ?? 'unknown',
+    tags: input.tags ?? [],
+    related_issue_ids: ctx.related_issue_ids ?? [],
+    linked_specs: ctx.linked_specs ?? ['.claude/docs/specs/genui-multiturn-architecture.md'],
+  };
+
+  const path = join(storageRoot, `${issue_id}.json`);
+  await writeFile(path, JSON.stringify(issue, null, 2));
+
+  // Write a sibling Markdown report for human review. The JSON ticket
+  // is the machine-readable source of truth; the .md is the readable
+  // surface a maintainer scans first to triage. Always written when
+  // we have a non-trivial trace (full or summary), so reviewers can
+  // see retrieval log, LLM prompts, attempts, plan, and composed HTML
+  // without reading the raw JSON.
+  let markdown_path = null;
+  if (trace) {
+    markdown_path = join(storageRoot, `${issue_id}.md`);
+    await writeFile(markdown_path, renderTicketMarkdown(issue, trace));
+  }
+
+  return {
+    issue_id,
+    path,                  // .json (machine-readable)
+    markdown_path,         // .md (human-readable; null when trace='none')
+    ack: 'logged',
+    severity: issue.severity,
+    suggested_owner: issue.suggested_owner,
+  };
+}
+
+/**
+ * Render the high-resolution session ticket as Markdown.
+ * Sections (each appears only if relevant data exists):
+ *   1. Header (id, severity, type, title, owner, tags)
+ *   2. Description (body)
+ *   3. Reproduction (intent, state_id, source, score)
+ *   4. Component-count drift (heuristic; flagged when > 50 components)
+ *   5. Retrieval log (Tier 1 hits + Tier 2 catalog summary)
+ *   6. LLM trace (each attempt's raw response)
+ *   7. Composer plan (slot bindings)
+ *   8. HTML preview (first 8KB of generated output)
+ *   9. Warnings + ops history
+ *  10. Environment (mcp/engine/model)
+ */
+function renderTicketMarkdown(issue, trace) {
+  const lines = [];
+  lines.push(`# ${issue.title}`);
+  lines.push('');
+  lines.push(`> **${issue.severity.toUpperCase()}** · ${issue.type} · owner: \`${issue.suggested_owner}\` · ${issue.created_at}`);
+  lines.push('> ');
+  lines.push(`> Issue ID: \`${issue.issue_id}\`${issue.tags?.length ? ' · tags: ' + issue.tags.map((t) => '`' + t + '`').join(' ') : ''}`);
+  lines.push('');
+
+  if (issue.body) {
+    lines.push('## Description');
+    lines.push('');
+    lines.push(issue.body);
+    lines.push('');
+  }
+
+  if (trace.intent || trace.state_id) {
+    lines.push('## Reproduction');
+    lines.push('');
+    if (trace.intent) lines.push(`- **Intent**: \`${trace.intent}\``);
+    if (trace.state_id) lines.push(`- **State ID**: \`${trace.state_id}\``);
+    if (trace.source) lines.push(`- **Source**: ${trace.source}${trace.score != null ? ` (score: ${trace.score.toFixed(3)})` : ''}`);
+    if (trace.parent_state_id) lines.push(`- **Parent state**: \`${trace.parent_state_id}\``);
+    if (trace.duration_ms != null) lines.push(`- **Duration**: ${trace.duration_ms}ms`);
+    lines.push('');
+  }
+
+  if (trace.componentCount != null) {
+    lines.push('## Component count');
+    lines.push('');
+    lines.push(`- **${trace.componentCount}** components in generated HTML`);
+    if (trace.scopeDrift) {
+      const sd = trace.scopeDrift;
+      const flag = sd.drift ? ' ⚠ **scope drift**' : '';
+      const ratio = sd.ratio != null ? `${sd.ratio.toFixed(2)}×` : 'n/a';
+      lines.push(`- Bound-chunk envelope: ${sd.expected} components`);
+      lines.push(`- Ratio (actual / expected): **${ratio}**${flag}`);
+      if (sd.drift) {
+        lines.push('');
+        lines.push(`> The composed HTML's component count exceeds the bound chunks' envelope by more than the drift gate. This is the canvas-drift regression class — the synthesizer materialized markup beyond what the retrieved chunks justify.`);
+      }
+    } else if (trace.componentCount > 50) {
+      lines.push('- ⚠ over-generation candidate (>50 components, no scope-drift signal available)');
+    }
+    lines.push('');
+  }
+
+  if (trace.synthesis?.retrievalTrace) {
+    const r = trace.synthesis.retrievalTrace;
+    lines.push('## Retrieval log');
+    lines.push('');
+    lines.push(`**Tier 1** (semantic-blended, threshold ${r.tier1Threshold}, ${r.tier1Pass ? '✓ pass' : '✗ fall through to Tier 2'})`);
+    lines.push('');
+    lines.push('| rank | score | kind | chunk |');
+    lines.push('|------|------:|------|-------|');
+    r.tier1Hits.forEach((h, i) => lines.push(`| ${i + 1} | ${h.score} | ${h.kind} | \`${h.name}\` |`));
+    lines.push('');
+    if (r.catalogSize) {
+      lines.push(`**Tier 2 catalog**: ${r.catalogSize} chunks (${r.catalogPageNames.length} page · ${r.catalogPanelNames.length} panel · ${r.catalogBlockTopN.length} top-block)`);
+      lines.push('');
+      if (r.catalogBlockTopN.length) {
+        lines.push('Top block candidates:');
+        for (const h of r.catalogBlockTopN) lines.push(`  - ${h.score} \`${h.name}\``);
+        lines.push('');
+      }
+    }
+  }
+
+  if (trace.synthesis?.attemptsLog?.length) {
+    lines.push('## LLM attempts');
+    lines.push('');
+    trace.synthesis.attemptsLog.forEach((att, i) => {
+      lines.push(`### Attempt ${att.attempt ?? i + 1}`);
+      lines.push('');
+      lines.push('```json');
+      lines.push(typeof att.raw === 'string' ? att.raw.slice(0, 2000) : JSON.stringify(att.raw, null, 2).slice(0, 2000));
+      lines.push('```');
+      lines.push('');
+    });
+    if (trace.synthesis.userPrompt) {
+      lines.push('### User prompt sent to LLM');
+      lines.push('');
+      lines.push('```');
+      lines.push(trace.synthesis.userPrompt.slice(0, 3000));
+      if (trace.synthesis.userPrompt.length > 3000) lines.push(`... (${trace.synthesis.userPrompt.length - 3000} more chars)`);
+      lines.push('```');
+      lines.push('');
+      if (trace.synthesis.systemPromptHash) lines.push(`System prompt hash: \`${trace.synthesis.systemPromptHash}\` (matches across attempts)`);
+      lines.push('');
+    }
+  }
+
+  if (trace.plan) {
+    lines.push('## Composer plan');
+    lines.push('');
+    lines.push('```json');
+    lines.push(JSON.stringify(trace.plan, null, 2));
+    lines.push('```');
+    lines.push('');
+  }
+
+  if (trace.htmlPreview) {
+    lines.push('## Generated HTML (preview)');
+    lines.push('');
+    lines.push('```html');
+    lines.push(trace.htmlPreview);
+    lines.push('```');
+    lines.push('');
+  }
+
+  if (trace.warnings?.length) {
+    lines.push('## Warnings');
+    lines.push('');
+    for (const w of trace.warnings) lines.push(`- ${w}`);
+    lines.push('');
+  }
+
+  if (trace.output?.ops?.length) {
+    lines.push('## Ops history (refinement chain)');
+    lines.push('');
+    lines.push(`${trace.output.ops.length} ops applied. ${trace.output.delta_summary ? 'Last delta: ' + trace.output.delta_summary : ''}`);
+    lines.push('');
+  }
+
+  if (issue.environment) {
+    lines.push('## Environment');
+    lines.push('');
+    for (const [k, v] of Object.entries(issue.environment)) lines.push(`- **${k}**: ${v}`);
+    lines.push('');
+  }
+
+  if (issue.related_issue_ids?.length) {
+    lines.push('## Related issues');
+    lines.push('');
+    for (const id of issue.related_issue_ids) lines.push(`- \`${id}\``);
+    lines.push('');
+  }
+
+  return lines.join('\n');
+}
+
+/**
+ * Auto-fire an issue based on a known reason.
+ *
+ * Looks up the policy table, derives type/severity/title/owner; the caller
+ * passes intent / state_id / extra context via `autoCtx`.
+ *
+ * Returns null when ctx.evalMode is true (eval runs don't pollute the ledger);
+ * manual reportIssue calls are unaffected by evalMode.
+ *
+ * @param {keyof typeof AUTO_FIRE_POLICY} reason
+ * @param {object} autoCtx — { intent?, state_id?, tool?, body?, trace?, tags? }
+ * @param {object} ctx — { cache, versionInfo, evalMode, storageRoot }
+ */
+export async function autoReport(reason, autoCtx = {}, ctx = {}) {
+  if (ctx.evalMode) return null;
+  const policy = AUTO_FIRE_POLICY[reason];
+  if (!policy) {
+    throw new Error(
+      `autoReport: unknown reason "${reason}". Valid: ${Object.keys(AUTO_FIRE_POLICY).join(', ')}`
+    );
+  }
+  const title = policy.titleFor(autoCtx);
+  const body = autoCtx.body || `Auto-fired by engine. Reason: \`${reason}\`.`;
+
+  return await reportIssue(
+    {
+      type: policy.type,
+      severity: policy.severity,
+      title,
+      body,
+      state_id: autoCtx.state_id,
+      trace: autoCtx.trace ?? (autoCtx.state_id ? 'summary' : 'none'),
+      suggested_owner: policy.suggested_owner,
+      tags: ['auto-fire', reason, ...(autoCtx.tags || [])],
+    },
+    {
+      ...ctx,
+      reporter: 'auto',
+      reporterContext: reason,
+    }
+  );
+}
+
+/**
+ * Per-tool-call accumulator for auto-fired issues.
+ *
+ * Multiple fires within one call coalesce into a single issue (spec §6.4).
+ * The highest-severity entry dictates type/severity/owner; the body lists
+ * every reason. Engine code creates one accumulator per tool invocation,
+ * pushes auto-fires into it, and flushes at the end.
+ */
+export function createIssueAccumulator() {
+  const entries = [];
+
+  return {
+    add(reason, autoCtx = {}) {
+      if (!AUTO_FIRE_POLICY[reason]) {
+        throw new Error(`accumulator.add: unknown reason "${reason}"`);
+      }
+      entries.push({ reason, autoCtx });
+    },
+
+    size() {
+      return entries.length;
+    },
+
+    reasons() {
+      return entries.map((e) => e.reason);
+    },
+
+    /**
+     * Write the accumulated issue(s).
+     *
+     * - 0 entries → returns null without writing.
+     * - 1 entry  → writes via autoReport (or no-op when evalMode).
+     * - N entries → coalesces into one issue. Highest-severity entry's policy
+     *   wins; body lists every reason; tags include all reasons + 'coalesced'.
+     */
+    async flush(ctx = {}) {
+      if (entries.length === 0) return null;
+
+      if (entries.length === 1) {
+        const { reason, autoCtx } = entries[0];
+        const result = await autoReport(reason, autoCtx, ctx);
+        entries.length = 0;
+        return result;
+      }
+
+      // Coalesce. Sort by severity desc, ties broken by insertion order.
+      const ranked = entries
+        .map((e, i) => ({ ...e, _idx: i }))
+        .sort((a, b) => {
+          const sa = SEVERITY_RANK[AUTO_FIRE_POLICY[a.reason].severity];
+          const sb = SEVERITY_RANK[AUTO_FIRE_POLICY[b.reason].severity];
+          return sb - sa || a._idx - b._idx;
+        });
+
+      const primary = ranked[0];
+      const policy = AUTO_FIRE_POLICY[primary.reason];
+      const reasons = entries.map((e) => e.reason);
+
+      if (ctx.evalMode) {
+        entries.length = 0;
+        return null;
+      }
+
+      const titles = entries.map((e) => AUTO_FIRE_POLICY[e.reason].titleFor(e.autoCtx));
+      const body = [
+        '## Coalesced auto-fires within one tool call',
+        '',
+        ...entries.map((e, i) => `${i + 1}. **\`${e.reason}\`** — ${titles[i]}`),
+        '',
+        `Primary (highest severity) dictates type/severity/owner: \`${primary.reason}\` (severity \`${policy.severity}\`).`,
+      ].join('\n');
+
+      const result = await reportIssue(
+        {
+          type: policy.type,
+          severity: policy.severity,
+          title: truncate(`Coalesced auto-fires: ${reasons.join(', ')}`, 80),
+          body,
+          state_id: primary.autoCtx?.state_id,
+          trace: primary.autoCtx?.trace ?? (primary.autoCtx?.state_id ? 'summary' : 'none'),
+          suggested_owner: policy.suggested_owner,
+          tags: ['auto-fire', 'coalesced', ...new Set(reasons)],
+        },
+        {
+          ...ctx,
+          reporter: 'auto',
+          reporterContext: 'coalesced',
+        }
+      );
+
+      entries.length = 0;
+      return result;
+    },
+  };
+}