@event4u/agent-config 14.19.0 → 14.21.0

package/dist/agent-src/skills/skill-improvement-pipeline/SKILL.md

@@ -56,7 +56,7 @@ For each learning, apply ALL of these checks. ALL must be YES to promote:
 |---|---|
 | All YES | **Promote** — continue to Step 3 |
 | One-off, never seen before | **Reject** — do nothing |
-| Seen once, but generalizable | **Note** — use `remember` tool, act on second occurrence |
+| Seen once, but generalizable | **Record** — write a `model-noticed` self-repair record naming the asset it is about; act on the second occurrence |
 | Already covered | **Update existing** — skip to Step 4 with the existing skill/rule |
 | Vague | **Reject** — not actionable |
 
@@ -66,9 +66,26 @@ Show the user:
 > Category: {category-tag}
 > Repeated: {yes/no} | Prevents failure: {yes/no} | Not covered: {yes/no} | Actionable: {yes/no}
 >
-> → {Promote / Reject / Note / Update existing}
+> → {Promote / Reject / Record / Update existing}
 ```
 
+### Where a seen-once learning goes — and why not a host-native memory tool
+
+The **Record** branch writes a `model-noticed` defect record through
+`upsertFinding` in `src/scripts/_lib/self_repair_store.ts`, carrying a `target`
+drawn from the closed `rule: | skill: | command: | hook:` vocabulary and
+resolved against the tree at write time.
+
+It used to route to a host-native memory tool, and that destination could not
+work for this branch by construction: it is not target-addressed, nothing in
+this repository can read it, it appears in no corroboration counter, and it is
+simply absent on hosts that do not ship it. So the ≥2-origin counter at
+`src/scripts/learning_sidecar.ts:39` restarted at one every time, and the second
+occurrence could never be recognised AS the second — which is the whole
+mechanism this branch exists to feed. A record is readable, joinable, and
+counted per target, so a third manifestation against one asset is a fact the
+tree can establish rather than one that depends on a human recalling it.
+
 #### Cross-project promotion signal (surfacing only — never an auto-writer)
 
 If the **same learning** has now been observed in **≥ 2 distinct projects**, it
@@ -82,10 +99,15 @@ to the user — do **not** auto-write it:
 > → surface for promotion (human decides; no auto-write)
 ```
 
-This is a *signal*, not a store: there is no auto-write, no decay, no runtime
-(the writable per-project learning store stays rejected —
-[[council-agent-memory-sunset]]). The human decides whether the cross-project
-recurrence justifies promotion.
+This is a *signal*, not a promotion: there is **no auto-write and no
+auto-promotion** — that half is the live boundary and is unchanged. The other
+two clauses this sentence used to carry are retired, because the tree
+contradicts them: `src/scripts/learning_sidecar.ts:37` sets
+`HALF_LIFE_DAYS = 30` and decays a signal's weight over a per-project intake
+store, and ADR-249 permits a **supervised** resident process in core,
+superseding the blanket no-daemon clause this sentence inherited. Decay and
+runtime are therefore **governed, not prohibited**. The human still decides
+whether the cross-project recurrence justifies promotion.
 
 ### Step 3: Classify
 

package/dist/agent-src/skills/technical-specification/SKILL.md

@@ -79,6 +79,8 @@ For complex features or systems. Stored in `agents/features/` or module `agents/
 |---|---|---|---|
 
 ## Open Questions
+{Each line is a question still owed to the user — ask one at a time and move
+the answer into the section it belongs to. Not a storage section.}
 - [ ] {Unresolved question}
 
 ## References
@@ -123,6 +125,8 @@ technical spec, not here.}
 - **{Module name}** — {one-sentence responsibility}
 
 ## Open Questions
+{Each line is a question still owed to the user — ask one at a time and move
+the answer into the section it belongs to. Not a storage section.}
 - [ ] {Unresolved product question — pricing, permission, copy, edge case}
 
 ## References

package/dist/agent-src/skills/test-driven-development/SKILL.md

@@ -120,9 +120,7 @@ RED.
 
 ### Mode inference on resume
 
-Step 0 of any resume: if `agents/runtime/state/HANDOFF.md` exists, resume
-from its Mode + Contract-owed fields (see `/agent-handoff` file mode) instead
-of re-deriving. Otherwise infer the mode from observable state — never
+Step 0 of any resume: infer the mode from observable state — never
 assume Design:
 
 | Observed state | Resume in |

package/dist/agent-src/templates/agents/agent-project-settings.example.yml

@@ -39,7 +39,7 @@ schema_version: 1
 # CI guard: a release bump of `package.json` must update this value
 # in lockstep — see scripts/check_template_pin_drift.ts (road-to-
 # portable-runtime-and-update-check P3.3).
-agent_config_version: "14.19.0"
+agent_config_version: "14.21.0"
 
 # --- Project identity ---
 project:

package/dist/agent-src/templates/features.md

@@ -90,6 +90,11 @@ Reference existing code where helpful.}
 
 ## Open Questions
 
+> Every entry here is a question still **owed to the user** — not a permanent
+> section and not a place to file a decision. Each one is put to the user in the
+> chat, one at a time, and the answer moves out of this list into the section it
+> belongs to. A question that stays here across a session was parked, not asked.
+
 - [ ] {Unresolved question 1}
 - [ ] {Unresolved question 2}
 

package/dist/agent-src/templates/roadmaps.md

@@ -43,7 +43,20 @@ that was never a judgement call.
     - `agents/roadmaps/` — active (in progress or planned **and workable now**)
     - `agents/roadmaps/archive/` — work happened (fully or partially); no further work planned
     - `agents/roadmaps/skipped/` — decision against pursuit; typically 0 items `[x]` (superseded, scope rejected)
-    - `agents/roadmaps/later/` — open work remains but is **blocked-for-later** (gated on an external trigger or a decision); **will resume**. Set `status: later` + a `Blocked until` / `Trigger` line. Roadmaps with open tasks deferred for later are **always** moved here, never left active. Excluded from the dashboard and `/roadmap:process-*`; enforced by `lint_roadmap_later_disposition`.
+    - `agents/roadmaps/later/` — open work remains but is **blocked-for-later** (gated on an external condition or a decision); **will resume**. Roadmaps with open tasks deferred for later are **always** moved here, never left active. Excluded from the dashboard and `/roadmap:process-*`; enforced by `lint_roadmap_later_disposition`. Two frontmatter obligations, both in force **regardless of `status`** — the status word alone stopped satisfying this gate on 2026-09-07, and so did the bare word `trigger`:
+
+        - **A wake condition.** Preferred form is a structured `entry_condition:` mapping naming all three parts:
+
+          ```yaml
+          entry_condition:
+            what: what would change the decision
+            when: when that could arrive
+            who:  who would have to act   # `none` is a legal answer; blank is not
+          ```
+
+          A condition that cannot be observed is a deferral wearing a condition's clothes, which is why all three are required and why a **scalar** `entry_condition` or a blank part fails hard rather than being baselined. The legacy body-line form (`Blocked until` / `Resume when`) still passes and is what the shrink-only ratchet is walking down from.
+
+        - **`review_by:`** — a date. A park with no review date is indistinguishable from an abandonment. Ratcheted from the count measured when the obligation landed; a **newly** parked roadmap must carry it.
 
     See the `roadmap-management` skill for the exact trigger matrix and user-confirmation flow.
 13. **No tags, releases, or version numbers.** Roadmaps describe work, not shipping.
@@ -288,6 +301,21 @@ that was never a judgement call.
     step gated by a specific blocker may cross-reference it inline:
     `- [ ] … <!-- blocked-by: <blocker-id> -->`.
 
+    **A user-decision blocker's annotation records whether the question
+    was actually put.** Where the blocker's `Owner:` is the maintainer,
+    the user or the owner, the marker carries an `asked:` field —
+    `<!-- blocked-by: <id> | asked: yes -->` when the question reached
+    the user, `<!-- blocked-by: <id> | asked: no — <reason> -->` when it
+    did not. `lint_roadmap_blockers` fails on a missing field and on an
+    `asked: no` with no reason. Without it a decision only the user can
+    make can be filed, correctly labelled, in a file nobody is watching,
+    and a later reader cannot tell a declined decision from one that was
+    never offered. On an interactive host the question is put FIRST;
+    only a decline, a timeout, or a non-interactive context writes the
+    marker, and a timeout is never consent — see
+    [`roadmap-process-loop`](../contexts/execution/roadmap-process-loop.md)
+    § Ask before park.
+
     **A blocker is a decision the owner can make in one sitting, or it
     is not finished being written.** The five original fields describe
     the *situation*; they do not make it decidable, and a blocker that

package/dist/agent-src/templates/scripts/telemetry/mcp_lite.ts

@@ -0,0 +1,213 @@
+/**
+ * MCP-lite call reading for `telemetry:report` (roadmap step 4.2).
+ *
+ * Reads the sink the stdio-lite MCP server writes — the same
+ * `agents/runtime/mcp-telemetry/calls.jsonl` the kernel MCP server already
+ * used, not a second store — and aggregates it per tool and per host.
+ *
+ * WHY THIS IS A SEPARATE MODULE. The engagement aggregator models artefacts
+ * with a consulted/applied ratio; a `tools/call` has neither. Forcing MCP rows
+ * through it would have meant either widening the engagement schema or
+ * mislabelling a tool call as a "skill consulted", and both would have made the
+ * quartile buckets mean two different things at once.
+ *
+ * PUBLISH THE ZERO. `render_mcp_lite_markdown` emits the section even when the
+ * count is zero, and says so in words. The adjacent archived roadmaps in this
+ * family closed at `measured-null` precisely because nulls were published
+ * rather than buried; a section that disappears when empty would make "nobody
+ * used it" and "nobody looked" indistinguishable.
+ *
+ * WHAT A ZERO DOES NOT MEAN. The emitter that fills this sink did not exist
+ * before this roadmap, and it is gated off by default. A zero is therefore a
+ * statement about the age and the default of the instrument first, and about
+ * consumer behaviour only once a machine has run with the gate on. The rendered
+ * section says this itself, so a reader cannot lift the number away from it.
+ */
+
+import * as fs from 'node:fs';
+import { check_id_redaction } from './engagement.js';
+
+/** Where the stdio-lite server writes, relative to the consumer root. */
+export const MCP_LITE_LOG_REL = 'agents/runtime/mcp-telemetry/calls.jsonl';
+
+/** The transport label the stdio-lite surface stamps on every row it writes. */
+export const MCP_LITE_TRANSPORT = 'stdio-lite';
+
+export interface McpLiteAggregate {
+    /** The file that was read, whether or not it existed. */
+    log_path: string;
+    /** Rows on this transport that parsed and fell inside the window. */
+    calls: number;
+    /** Lines that did not parse as JSON, or carried no usable tool name. */
+    skipped_lines: number;
+    /** Rows that parsed but belong to another transport (the kernel server). */
+    other_transport: number;
+    by_tool: Map<string, number>;
+    by_host: Map<string, number>;
+    by_outcome: Map<string, number>;
+    earliest_ts: string | null;
+    latest_ts: string | null;
+}
+
+function _empty(log_path: string): McpLiteAggregate {
+    return {
+        log_path,
+        calls: 0,
+        skipped_lines: 0,
+        other_transport: 0,
+        by_tool: new Map(),
+        by_host: new Map(),
+        by_outcome: new Map(),
+        earliest_ts: null,
+        latest_ts: null,
+    };
+}
+
+function _bump(m: Map<string, number>, k: string): void {
+    m.set(k, (m.get(k) ?? 0) + 1);
+}
+
+/** Epoch ms for an ISO-8601 stamp, or `null` when it does not parse. */
+function _ms(ts: unknown): number | null {
+    if (typeof ts !== 'string') return null;
+    const v = Date.parse(ts);
+    return Number.isNaN(v) ? null : v;
+}
+
+/**
+ * Aggregate the lite surface's calls.
+ *
+ * A missing file is an empty reading, never an error: the overwhelmingly common
+ * case is a machine that has simply never run the server, and that is a zero,
+ * not a failure. `since` is an epoch-ms lower bound, matching the engagement
+ * aggregator's own window semantics; a row with an unreadable timestamp is
+ * kept when there is no window and dropped when there is, because it cannot be
+ * shown to fall inside one.
+ */
+export function aggregate_mcp_lite(
+    log_path: string,
+    opts: { since?: number | null } = {},
+): McpLiteAggregate {
+    const since = opts.since ?? null;
+    const out = _empty(log_path);
+    let text: string;
+    try {
+        text = fs.readFileSync(log_path, 'utf-8');
+    } catch {
+        return out;
+    }
+    for (const raw of text.split(/\r\n|\r|\n/)) {
+        if (raw.trim() === '') continue;
+        let rec: Record<string, unknown>;
+        try {
+            const parsed: unknown = JSON.parse(raw);
+            if (typeof parsed !== 'object' || parsed === null || Array.isArray(parsed)) {
+                out.skipped_lines += 1;
+                continue;
+            }
+            rec = parsed as Record<string, unknown>;
+        } catch {
+            out.skipped_lines += 1;
+            continue;
+        }
+        if (rec.transport !== MCP_LITE_TRANSPORT) {
+            out.other_transport += 1;
+            continue;
+        }
+        const tool = typeof rec.tool_name === 'string' ? rec.tool_name : '';
+        if (tool === '') {
+            out.skipped_lines += 1;
+            continue;
+        }
+        const ms = _ms(rec.ts);
+        if (since !== null && (ms === null || ms < since)) continue;
+
+        out.calls += 1;
+        _bump(out.by_tool, tool);
+        _bump(out.by_host, typeof rec.host === 'string' && rec.host !== '' ? rec.host : 'unknown');
+        _bump(out.by_outcome, typeof rec.outcome === 'string' ? rec.outcome : 'unknown');
+        const ts = typeof rec.ts === 'string' ? rec.ts : null;
+        if (ts !== null) {
+            if (out.earliest_ts === null || ts < out.earliest_ts) out.earliest_ts = ts;
+            if (out.latest_ts === null || ts > out.latest_ts) out.latest_ts = ts;
+        }
+    }
+    return out;
+}
+
+/** Descending by count, then by name, so the rendering is deterministic. */
+function _sorted(m: Map<string, number>): [string, number][] {
+    return [...m.entries()].sort((a, b) => (b[1] - a[1]) || (a[0] < b[0] ? -1 : a[0] > b[0] ? 1 : 0));
+}
+
+const ZERO_NOTE =
+    '_No calls recorded. The lite-surface emitter is default-off '
+    + '(`telemetry.artifact_engagement.enabled`), so a zero here says the '
+    + 'instrument was off or unused on this machine — it is not a measurement '
+    + 'of what consumers do._';
+
+/**
+ * The markdown section. Always renders, zero included.
+ *
+ * Ids are re-validated through the engagement redaction floor even though the
+ * emitter already clamps them: this renderer prints whatever is in the file,
+ * and a file is not a boundary the emitter controls.
+ */
+export function render_mcp_lite_markdown(agg: McpLiteAggregate): string {
+    const lines: string[] = [];
+    lines.push('## MCP lite surface');
+    lines.push('');
+    lines.push(`- calls recorded: **${agg.calls}**`);
+    if (agg.earliest_ts && agg.latest_ts) {
+        lines.push(`- ts range: \`${agg.earliest_ts}\` → \`${agg.latest_ts}\``);
+    }
+    lines.push('');
+    if (agg.calls === 0) {
+        lines.push(ZERO_NOTE);
+        lines.push('');
+        return `${lines.join('\n')}`;
+    }
+    lines.push('| tool | calls |');
+    lines.push('|---|---:|');
+    for (const [tool, n] of _sorted(agg.by_tool)) {
+        check_id_redaction('mcp_lite.by_tool.id', tool);
+        lines.push(`| ${tool} | ${n} |`);
+    }
+    lines.push('');
+    lines.push('| host | calls |');
+    lines.push('|---|---:|');
+    for (const [host, n] of _sorted(agg.by_host)) {
+        check_id_redaction('mcp_lite.by_host.id', host);
+        lines.push(`| ${host} | ${n} |`);
+    }
+    lines.push('');
+    return `${lines.join('\n')}`;
+}
+
+/** Plain object for the JSON format. Same validation as the markdown path. */
+export function mcp_lite_json(agg: McpLiteAggregate): Record<string, unknown> {
+    const by_tool: Record<string, number> = {};
+    for (const [tool, n] of _sorted(agg.by_tool)) {
+        check_id_redaction('mcp_lite.by_tool.id', tool);
+        by_tool[tool] = n;
+    }
+    const by_host: Record<string, number> = {};
+    for (const [host, n] of _sorted(agg.by_host)) {
+        check_id_redaction('mcp_lite.by_host.id', host);
+        by_host[host] = n;
+    }
+    const by_outcome: Record<string, number> = {};
+    for (const [outcome, n] of _sorted(agg.by_outcome)) {
+        by_outcome[outcome] = n;
+    }
+    return {
+        log_path: agg.log_path,
+        calls: agg.calls,
+        skipped_lines: agg.skipped_lines,
+        by_tool,
+        by_host,
+        by_outcome,
+        earliest_ts: agg.earliest_ts,
+        latest_ts: agg.latest_ts,
+    };
+}

package/dist/agent-src/templates/scripts/telemetry/report_renderer.ts

@@ -12,6 +12,7 @@ import {
     rank_artefacts,
 } from './aggregator.js';
 import { ALLOWED_OUTCOMES, check_id_redaction } from './engagement.js';
+import { mcp_lite_json, render_mcp_lite_markdown, type McpLiteAggregate } from './mcp_lite.js';
 
 export const QUARTILE_TOP_RATIO = 0.20;
 export const QUARTILE_BOTTOM_RATIO = 0.20;
@@ -57,6 +58,17 @@ export function bucketise(stats: ArtefactStat[]): BucketedStat[] {
 export interface RenderOptions {
     top?: number | null;
     since_label?: string | null;
+    /**
+     * The MCP-lite reading, when the caller resolved one (step 4.2).
+     *
+     * Optional, and ABSENT is the default: a caller that does not supply it
+     * gets exactly the report this renderer produced before, byte for byte.
+     * That matters concretely — the Python→TS parity goldens for this script
+     * are frozen snapshots of a `.py` that no longer exists and can never be
+     * re-captured, so a section that rendered unconditionally would break a
+     * pin that cannot be repaired.
+     */
+    mcp_lite?: McpLiteAggregate | null;
 }
 
 /** Render a markdown report. `top` truncates each bucket; null keeps all. */
@@ -137,6 +149,9 @@ export function render_markdown(aggregate: AggregateResult, opts: RenderOptions
         }
         lines.push('');
     }
+    if (opts.mcp_lite) {
+        lines.push(render_mcp_lite_markdown(opts.mcp_lite));
+    }
     return `${_pyRStrip(lines.join('\n'))}\n`;
 }
 
@@ -181,6 +196,7 @@ export function render_json(aggregate: AggregateResult, opts: RenderOptions = {}
         },
         outcomes: outcomes_payload,
         buckets: grouped,
+        ...(opts.mcp_lite ? { mcp_lite: mcp_lite_json(opts.mcp_lite) } : {}),
     };
     return `${_py_json_dumps_indent2_sorted(payload)}\n`;
 }

package/dist/agent-src/templates/scripts/telemetry_report.ts

@@ -19,6 +19,7 @@ import { aggregate } from './telemetry/aggregator.js';
 import { EngagementSchemaError } from './telemetry/engagement.js';
 import { render_json, render_markdown } from './telemetry/report_renderer.js';
 import { read_settings } from './telemetry/settings.js';
+import { MCP_LITE_LOG_REL, aggregate_mcp_lite } from './telemetry/mcp_lite.js';
 
 const _DURATION_RE = /^\s*(\d+)\s*([dhm])\s*$/u;
 
@@ -59,6 +60,7 @@ interface ReportArgs {
     format: string;
     log_path: string | null;
     settings: string;
+    mcp_log_path: string | null;
 }
 
 class ArgError extends Error {}
@@ -70,6 +72,7 @@ function _parseArgs(argv: string[]): ReportArgs {
         format: 'markdown',
         log_path: null,
         settings: '.agent-settings.yml',
+        mcp_log_path: null,
     };
     const formatChoices = ['markdown', 'json'];
     for (let i = 0; i < argv.length; i += 1) {
@@ -104,6 +107,7 @@ function _parseArgs(argv: string[]): ReportArgs {
             }
             a.format = v;
         } else if (tok === '--log-path') a.log_path = next();
+        else if (tok === '--mcp-log-path') a.mcp_log_path = next();
         else if (tok === '--settings') a.settings = next();
         else throw new ArgError(`unrecognized arguments: ${argv[i]}`);
     }
@@ -155,13 +159,29 @@ export function main(argv: string[] = process.argv.slice(2)): number {
         return 2;
     }
 
+    // The MCP-lite section (step 4.2) renders in the DEFAULT, settings-driven
+    // invocation — which is what `agent-config telemetry:report` is — and when
+    // a caller names the sink explicitly. It does NOT render when the caller
+    // pointed `--log-path` at one specific engagement log and named no MCP
+    // sink: in that mode the report is scoped to the file it was handed and
+    // does not go looking for other stores on the machine. That rule also keeps
+    // the frozen Python-parity goldens intact, since every pinned invocation
+    // passes `--log-path`; the goldens cannot be re-captured, the `.py` having
+    // been retired, so an unconditional section would break a pin permanently.
+    const want_mcp = args.mcp_log_path !== null || args.log_path === null;
+    const mcp_lite = want_mcp
+        ? aggregate_mcp_lite(args.mcp_log_path ?? path.join(process.cwd(), MCP_LITE_LOG_REL), {
+              since: cutoff,
+          })
+        : null;
+
     const top = args.top <= 0 ? null : args.top;
     let rendered: string;
     try {
         if (args.format === 'json') {
-            rendered = render_json(result, { top, since_label });
+            rendered = render_json(result, { top, since_label, mcp_lite });
         } else {
-            rendered = render_markdown(result, { top, since_label });
+            rendered = render_markdown(result, { top, since_label, mcp_lite });
         }
     } catch (exc) {
         if (exc instanceof EngagementSchemaError) {

package/dist/cli/mcp/dispatch.js

@@ -167,6 +167,16 @@ export const LITE_TOOLS = [
     },
 ];
 const LITE_TOOL_NAMES = new Set(LITE_TOOLS.map((t) => t.name));
+/**
+ * Is this name one of the two tools this surface actually runs?
+ *
+ * Exported so the impure transport shell can classify a call's outcome without
+ * re-deriving the tool list — one reader of one fact, the same discipline
+ * `describeHostCapabilities` applies to the capability manifest.
+ */
+export function isLiteTool(name) {
+    return LITE_TOOL_NAMES.has(name);
+}
 /** Chars/4 over the served `tools/list` payload — the figure the cap is on. */
 export function liteToolsTokenCost() {
     return Math.round(JSON.stringify({ tools: LITE_TOOLS }).length / 4);

package/dist/cli/mcp/stdio.js

@@ -10,9 +10,16 @@
  * a single stray stdout byte breaks the JSON-RPC stream for the client.
  *
  * Notifications (no `id`) receive no response, per JSON-RPC 2.0.
+ *
+ * This shell is also where call telemetry is emitted (roadmap step 4.1):
+ * `dispatch` is pure — no I/O, no clock — and stays that way, so the one row
+ * per `tools/call` is written here, from the impure side, after the response
+ * has been produced. The recorder is default-off and never throws; see
+ * `./telemetry.js` for the gate and the closed host vocabulary.
  */
 import { createInterface } from 'node:readline';
-import { dispatch, rpcError, RPC_PARSE_ERROR, RPC_INVALID_REQUEST, } from './dispatch.js';
+import { dispatch, isLiteTool, rpcError, RPC_PARSE_ERROR, RPC_INVALID_REQUEST, } from './dispatch.js';
+import { HOST_UNKNOWN, normalizeHost, recordLiteCall } from './telemetry.js';
 function isNotification(value) {
     return typeof value === 'object' && value !== null && !('id' in value);
 }
@@ -24,6 +31,10 @@ function isNotification(value) {
 export function runStdioServer(tree, identity, opts = {}) {
     const input = opts.input ?? process.stdin;
     const output = opts.output ?? process.stdout;
+    // The client's own name, learned at `initialize` and resolved onto the
+    // closed host vocabulary. A client that calls a tool before initializing
+    // records `unknown` — which is the truth, not a guess.
+    let host = HOST_UNKNOWN;
     const write = (resp) => {
         output.write(`${JSON.stringify(resp)}\n`);
     };
@@ -51,7 +62,27 @@ export function runStdioServer(tree, identity, opts = {}) {
                 write(rpcError(id, RPC_INVALID_REQUEST, 'Invalid Request'));
                 return;
             }
-            write(dispatch(tree, identity, parsed));
+            const req = parsed;
+            if (req.method === 'initialize') {
+                const p = (req.params ?? {});
+                const info = (p.clientInfo ?? {});
+                host = normalizeHost(info.name);
+            }
+            write(dispatch(tree, identity, req));
+            // Exactly one row per `tools/call` that named a tool. A call with
+            // no `name` is a malformed request, not a call to a tool, and has
+            // nothing to attribute a row to.
+            if (req.method === 'tools/call') {
+                const p = (req.params ?? {});
+                const name = typeof p.name === 'string' ? p.name : '';
+                recordLiteCall({
+                    toolName: name,
+                    isLiteTool: isLiteTool(name),
+                    host,
+                    consumerRoot: opts.consumerRoot,
+                    settingsPath: opts.settingsPath,
+                });
+            }
         });
         rl.on('close', () => {
             // Drain any buffered stdout before resolving — on macOS a pipe write