@event4u/agent-config 14.18.0 → 14.20.0

package/dist/agent-src/skills/react-shadcn-ui/SKILL.md

@@ -1,7 +1,7 @@
 ---
 model_tier: medium
 name: react-shadcn-ui
-description: "Use when building React UI on shadcn/ui primitives + Tailwind — the apply/review/polish skill dispatched by `directives/ui/*` for the `react-shadcn` stack."
+description: "Building React UI on shadcn/ui primitives + Tailwind — the apply/review/polish skill dispatched by `directives/ui/*` for the `react-shadcn` stack; idiom from tailwind-engineer."
 domain: engineering
 workspaces:
   - engineering

package/dist/agent-src/skills/sequential-thinking/SKILL.md

@@ -129,12 +129,22 @@ Explore alternatives when:
 1. Numbered reasoning steps with conclusions
 2. Final answer or recommendation with confidence level
 
-## Auto-trigger keywords
+## Tool availability — this is a procedure, not a tool call
 
-- problem solving
-- step-by-step
-- reasoning
-- decomposition
+Everything above runs **in-session**: it is a way of structuring reasoning, and
+it needs nothing installed.
+
+The wider MCP ecosystem carries a `sequentialthinking` server exposing a tool of
+that name. **This package registers no MCP server** — `mcp.json` ships
+`{"servers": {}}` — so on a default install that tool is not present, and
+nothing here tries to call it. Registering one is a consumer-side install
+decision this package deliberately does not make for you.
+
+So a reader on a default install can answer the question directly: the tool is
+not available to you, and none of this skill depends on it. If you have
+registered such a server yourself, the once-per-task limit below governs that
+call too — the limit is about looping, not about which mechanism does the
+thinking.
 
 ## Gotcha
 
@@ -145,9 +155,9 @@ Explore alternatives when:
 ## Do NOT
 
 - Do NOT use this for simple, well-understood tasks — it adds unnecessary overhead.
-- Do NOT call `sequentialthinking` more than **once per task**. If you're calling it repeatedly,
-  you're looping — stop and act directly instead.
-- Do NOT use `sequentialthinking` as a "thinking proxy" — if the task is "view a file" or
+- Do NOT run this procedure more than **once per task**. If you are reaching for it
+  repeatedly, you are looping — stop and act directly instead.
+- Do NOT use it as a "thinking proxy" — if the task is "view a file" or
   "run a command", just do it. No thinking step needed.
 - Do NOT skip the validation step — always check the solution against the original problem.
 - Do NOT ignore contradictions — they are signals, not noise.

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/tailwind-engineer/SKILL.md

@@ -1,7 +1,7 @@
 ---
 model_tier: medium
 name: tailwind-engineer
-description: "Use when writing or reviewing Tailwind CSS — utility-first, design-token discipline, no inline-style drift, responsive variants, dark mode — even on 'style this' or 'mach das hübsch'."
+description: "Writing or reviewing Tailwind CSS — utility-first, design tokens, no inline-style drift, responsive variants, dark mode — 'style this' or 'mach das hübsch'. Pairs with react-shadcn-ui."
 personas:
   - frontend-engineer
 domain: engineering

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/skills/ui-apply-generic/SKILL.md

@@ -1,7 +1,7 @@
 ---
 model_tier: medium
 name: ui-apply-generic
-description: "Use when implementing a UI brief on a stack with no framework executor — Svelte, Astro, Angular, plain HTML. Carries the stack-independent contract; idiom comes from the stack corpus."
+description: "Use when implementing a UI brief on a stack with no framework executor — Svelte, Astro, Angular, plain HTML. Stack-independent sibling of react-shadcn-ui; idiom from the stack corpus."
 personas:
   - frontend-engineer
 domain: engineering

package/dist/agent-src/skills/ui-component-architect/SKILL.md

@@ -1,7 +1,7 @@
 ---
 model_tier: high
 name: ui-component-architect
-description: "Use when shaping a UI component tree — composition vs inheritance, slot patterns, prop API design, controlled vs uncontrolled, polymorphic — even on 'split this component'."
+description: "Shaping a UI component tree — composition vs inheritance, slot patterns, prop API design, controlled vs uncontrolled, polymorphic — on 'split this component'. Feeds react-shadcn-ui."
 personas:
   - frontend-engineer
 domain: engineering

package/dist/agent-src/skills/using-git-worktrees/SKILL.md

@@ -105,7 +105,9 @@ Ask format:
 
 > 1. `.worktrees/` — project-local, hidden
 > 2. `worktrees/` — project-local, visible
-> 3. `~/.event4u/agent-config/worktrees/<project>/` — global
+> 3. `~/.event4u/agent-config/worktrees/<project>/` — global, **outside the
+>    repository root**: costs the persistent shell cwd (see below) and requires
+>    declaring the parent in the host's working-directory allowlist
 
 **Recommendation: 1 — `.worktrees/`** — project-local keeps the worktree next to the repo (easy cleanup), and the leading dot keeps it out of `ls`. Caveat: pick 3 if multiple repos must share a single worktree root.
 
@@ -135,9 +137,22 @@ passes. For the global location, skip — path is outside the repo.
 
 ```bash
 git worktree add .worktrees/<branch-name> -b <branch-name>
-cd .worktrees/<branch-name>
 ```
 
+**Then address the worktree by flag, not by `cd`.** Every tool that matters
+takes a directory flag, and the flag survives where a `cd` does not:
+
+```bash
+git -C .worktrees/<branch-name> status
+npm --prefix .worktrees/<branch-name> test
+composer -d .worktrees/<branch-name> install
+```
+
+A `cd X && …` compound re-enters the directory on every single call, and the
+one call that forgets it edits the main checkout silently — the failure is
+invisible because the command succeeds. Where a tool genuinely has no directory
+flag, use a subshell so the change cannot leak: `( cd <path> && <cmd> )`.
+
 Branch names must match the project convention — see
 `commit-conventions` rule.
 

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.18.0"
+agent_config_version: "14.20.0"
 
 # --- Project identity ---
 project:

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.

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/commands/recordTriggerEval.js

@@ -3,7 +3,7 @@
  *
  * Records a live trigger-eval result into a corpus manifest's `upstream`
  * block (the second half of the corpus-refresh DoD, ADR-061 §6). It does
- * NOT run the eval — `skill_trigger_eval.py`'s confirmation gate hard-aborts
+ * NOT run the eval — `skill_trigger_eval`'s confirmation gate hard-aborts
  * under automation by design, so the live run stays a human, interactive
  * step. This command is a *post-processor*: it reads the `EvalResult` JSON the
  * live run wrote (`--output`), enforces a precision/recall floor, and writes
@@ -36,7 +36,7 @@ import { logger } from '../log/logger.js';
 // Floors shared with the weekly canary rotation (ADR-118 §4) — values
 // unchanged, single source of truth.
 import { floor_for } from '../../scripts/_lib/trigger_eval_floors.js';
-/** Subset of `skill_trigger_eval.py`'s `EvalResult` we depend on. */
+/** Subset of `skill_trigger_eval`'s `EvalResult` we depend on. */
 const EvalResultSchema = z.object({
     skill: z.string().optional(),
     model: z.string().optional(),

package/dist/cli/main.js

@@ -83,7 +83,7 @@ async function main(rawArgv) {
     program
         .command('eval:record')
         .description('Record a live trigger-eval result into a corpus manifest (ADR-061 §6 refresh DoD)')
-        .requiredOption('--eval-json <path>', 'EvalResult JSON written by skill_trigger_eval.py --output')
+        .requiredOption('--eval-json <path>', 'EvalResult JSON written by skill_trigger_eval --output')
         .requiredOption('--manifest <path>', 'corpus manifest.json to patch')
         .option('--min-recall <n>', 'Recall floor override (per-skill default otherwise)', (v) => Number.parseFloat(v))
         .option('--min-precision <n>', 'Precision floor override (per-skill default otherwise)', (v) => Number.parseFloat(v))

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