@event4u/agent-config 9.8.0 → 9.10.0

package/src/scripts/surface_probe_hook.ts

@@ -28,6 +28,7 @@ import { fileURLToPath, pathToFileURL } from 'node:url';
 import { parse as parseYaml } from 'yaml';
 
 import { is_replay_mode } from './hooks/state_io.js';
+import { readHookStdin } from './hooks/hook_stdin.js';
 
 const CHECK_WINDOW_MS = 24 * 60 * 60 * 1000;
 const STATE_REL = ['agents', 'runtime', 'state', 'surface-probe.json'] as const;
@@ -50,13 +51,7 @@ function _package_root(): string {
 }
 
 function _readStdinIfNotTty(): void {
-    try {
-        if (!process.stdin.isTTY) {
-            fs.readFileSync(0, 'utf-8');
-        }
-    } catch {
-        /* ignore */
-    }
+    readHookStdin();
 }
 
 function _exists(p: string): boolean {
@@ -209,7 +204,13 @@ export function main(argv?: string[], opts: ProbeOptions = {}): number {
     }
 }
 
+// Bundle-safety: never auto-run when inlined into an esbuild bundle, where
+// every module shares the bundle's `import.meta.url` (see cmd_migrate.ts).
+declare const __AGENT_CONFIG_BUNDLE__: boolean | undefined;
 function _isCliEntry(): boolean {
+    if (typeof __AGENT_CONFIG_BUNDLE__ !== 'undefined' && __AGENT_CONFIG_BUNDLE__) {
+        return false;
+    }
     if (process.argv[1] === undefined) {
         return false;
     }

package/src/scripts/sync_gitattributes.ts

@@ -0,0 +1,310 @@
+#!/usr/bin/env tsx
+/**
+ * Sync the `event4u/agent-config` managed memory-merge-safety block into a
+ * project's root `.gitattributes`.
+ *
+ * Sibling of `sync_gitignore.ts` (same SECTION_HEADER/FOOTER marker shape,
+ * same append-only idempotent behaviour: missing block → append fresh;
+ * block present → add only the managed lines that are missing; never touch
+ * unrelated lines). Unlike `sync_gitignore.ts` this script has no retired
+ * Python predecessor to byte-match, so it skips that file's unified-diff /
+ * legacy-cleanup machinery and keeps only what this task needs: idempotent
+ * append + a `--check` drift probe.
+ *
+ * Canonical body: `src/agent-src/templates/agents/.gitattributes.fragment`
+ * (road-to-reachable-code-memory.md Phase 5) — union-merge attributes for
+ * the memory intake JSONL + curated flat/directory YAML layouts.
+ *
+ * Idempotent. Append-only: a second run on an already-synced file is a
+ * no-op (exit 0, no write). `--check` reports drift without writing —
+ * exit 0 (in sync) or 1 (missing entries) — for CI / doctor use.
+ */
+import * as fs from 'node:fs';
+import * as path from 'node:path';
+import process from 'node:process';
+import { fileURLToPath, pathToFileURL } from 'node:url';
+
+export const SECTION_HEADER = '# --- BEGIN agent-config managed: memory merge attributes ---';
+export const SECTION_FOOTER = '# --- END agent-config managed: memory merge attributes ---';
+export const DEFAULT_GITATTRIBUTES = '.gitattributes';
+
+const _HERE = fileURLToPath(import.meta.url);
+// _HERE === <repo>/src/scripts/sync_gitattributes.ts ; the canonical fragment
+// lives at <repo>/src/agent-src/templates/agents/.gitattributes.fragment —
+// two dirs up from src/scripts, then into src/agent-src/templates/agents.
+export const DEFAULT_TEMPLATE = path.join(
+    path.dirname(_HERE),
+    '..',
+    'agent-src',
+    'templates',
+    'agents',
+    '.gitattributes.fragment',
+);
+
+function _strip(ln: string): string {
+    return ln.replace(/\n+$/, '').replace(/\s+$/, '');
+}
+
+function _is_entry(ln: string): boolean {
+    const s = _strip(ln).replace(/^\s+/, '');
+    return Boolean(s) && !s.startsWith('#');
+}
+
+/** Error raised when the template file is missing (→ exit 2 in main). */
+export class TemplateNotFoundError extends Error {
+    constructor(p: string) {
+        super(`template not found: ${p}`);
+        this.name = 'TemplateNotFoundError';
+    }
+}
+
+function _isFile(p: string): boolean {
+    try {
+        return fs.statSync(p).isFile();
+    } catch {
+        return false;
+    }
+}
+
+function _splitlines(text: string): string[] {
+    if (text === '') return [];
+    const parts = text.split(/\r\n|\r|\n/);
+    if (parts.length > 0 && parts[parts.length - 1] === '') parts.pop();
+    return parts;
+}
+
+export function load_template(p: string): string[] {
+    if (!_isFile(p)) {
+        throw new TemplateNotFoundError(p);
+    }
+    const text = fs.readFileSync(p, 'utf-8');
+    return _splitlines(text).map(_strip);
+}
+
+/**
+ * Locate the managed block; return [start_idx, end_idx_exclusive] or null.
+ *
+ * `start_idx` points at the SECTION_HEADER line; `end_idx_exclusive` points
+ * one past SECTION_FOOTER. A header with no matching footer is treated as
+ * extending to EOF (defensive — normal writes always pair header + footer).
+ */
+export function find_block(lines: readonly string[]): [number, number] | null {
+    for (let i = 0; i < lines.length; i += 1) {
+        if (_strip(lines[i] as string) === SECTION_HEADER) {
+            for (let j = i + 1; j < lines.length; j += 1) {
+                if (_strip(lines[j] as string) === SECTION_FOOTER) {
+                    return [i, j + 1];
+                }
+            }
+            return [i, lines.length];
+        }
+    }
+    return null;
+}
+
+/** Return entries (attribute lines) present in the given block. */
+export function block_entries(block_lines: readonly string[]): string[] {
+    return block_lines
+        .filter((ln) => _is_entry(ln))
+        .map((ln) => _strip(ln).replace(/^\s+/, ''));
+}
+
+export function template_entries(template_lines: readonly string[]): string[] {
+    return template_lines.filter((ln) => _is_entry(ln)).map((ln) => ln.replace(/^\s+/, ''));
+}
+
+/** Return a fresh, fully-managed block with START + body + END. */
+export function build_fresh_block(template_lines: readonly string[]): string[] {
+    return [SECTION_HEADER, ...template_lines, SECTION_FOOTER];
+}
+
+/**
+ * Return [new_lines, added_entries].
+ *
+ * - If block missing: append fresh block (preceded by a blank line if the
+ *   file's last line is not already empty).
+ * - If block present: append any missing managed entries before the END
+ *   marker (adding END if somehow absent). User-added lines inside the
+ *   block are preserved — this is append-only, never a destructive rewrite.
+ */
+export function sync_block(
+    existing_lines: readonly string[],
+    template_lines: readonly string[],
+): [string[], string[]] {
+    const loc = find_block(existing_lines);
+    const fresh = build_fresh_block(template_lines);
+
+    if (loc === null) {
+        const newLines = [...existing_lines];
+        if (newLines.length > 0 && _strip(newLines[newLines.length - 1] as string) !== '') {
+            newLines.push('');
+        }
+        newLines.push(...fresh);
+        return [newLines, template_entries(template_lines)];
+    }
+
+    const [start, end] = loc;
+    const head = existing_lines.slice(0, start);
+    let block = existing_lines.slice(start, end);
+    const tail = existing_lines.slice(end);
+
+    const existing_entries = new Set(block_entries(block));
+    const missing = template_entries(template_lines).filter((e) => !existing_entries.has(e));
+    if (missing.length === 0) {
+        return [[...existing_lines], []];
+    }
+
+    let insert_at: number;
+    if (block.length > 0 && _strip(block[block.length - 1] as string) === SECTION_FOOTER) {
+        insert_at = block.length - 1;
+    } else {
+        block = [...block, SECTION_FOOTER];
+        insert_at = block.length - 1;
+    }
+    const new_block = [...block.slice(0, insert_at), ...missing, ...block.slice(insert_at)];
+    return [[...head, ...new_block, ...tail], missing];
+}
+
+/** Join lines with newlines and enforce exactly one trailing newline. */
+export function format_file(lines: readonly string[]): string {
+    const text = lines.join('\n');
+    return text.replace(/\n+$/, '') + '\n';
+}
+
+// --- CLI ---------------------------------------------------------------------
+
+interface ParsedArgs {
+    path: string;
+    template: string;
+    check: boolean;
+    quiet: boolean;
+}
+
+const _PROG = 'sync_gitattributes';
+
+function _argError(usage: string, msg: string): never {
+    process.stderr.write(usage);
+    process.stderr.write(`${_PROG}: error: ${msg}\n`);
+    process.exit(2);
+}
+
+function parse_args(argv: readonly string[]): ParsedArgs {
+    const args: ParsedArgs = {
+        path: DEFAULT_GITATTRIBUTES,
+        template: DEFAULT_TEMPLATE,
+        check: false,
+        quiet: false,
+    };
+    const usage = 'usage: sync_gitattributes [-h] [--path PATH] [--template TEMPLATE] [--check] [--quiet]\n';
+    const valueFlags: Record<string, 'path' | 'template'> = {
+        '--path': 'path',
+        '--template': 'template',
+    };
+    for (let i = 0; i < argv.length; i += 1) {
+        const arg = argv[i] as string;
+        if (arg === '-h' || arg === '--help') {
+            process.stdout.write(usage);
+            process.exit(0);
+        } else if (arg === '--check') {
+            args.check = true;
+        } else if (arg === '--quiet') {
+            args.quiet = true;
+        } else if (valueFlags[arg] !== undefined) {
+            const next = argv[i + 1];
+            if (next === undefined) {
+                _argError(usage, `argument ${arg}: expected one argument`);
+            }
+            args[valueFlags[arg] as 'path' | 'template'] = next;
+            i += 1;
+        } else {
+            const eq = arg.indexOf('=');
+            const flag = eq === -1 ? arg : arg.slice(0, eq);
+            if (eq !== -1 && valueFlags[flag] !== undefined) {
+                args[valueFlags[flag] as 'path' | 'template'] = arg.slice(eq + 1);
+            } else {
+                _argError(usage, `unrecognized arguments: ${arg}`);
+            }
+        }
+    }
+    return args;
+}
+
+export function main(argv: readonly string[]): number {
+    const args = parse_args(argv);
+
+    let template_lines: string[];
+    try {
+        template_lines = load_template(args.template);
+    } catch (exc) {
+        if (exc instanceof TemplateNotFoundError) {
+            process.stderr.write(`error: ${exc.message}\n`);
+            return 2;
+        }
+        throw exc;
+    }
+
+    const target = args.path;
+    let existing_text: string;
+    let existing_lines: string[];
+    if (_isFile(target)) {
+        existing_text = fs.readFileSync(target, 'utf-8');
+        existing_lines = _splitlines(existing_text).map(_strip);
+    } else {
+        existing_text = '';
+        existing_lines = [];
+    }
+
+    const [new_lines, added] = sync_block(existing_lines, template_lines);
+    const new_text = format_file(new_lines);
+
+    if (new_text === existing_text) {
+        if (!args.quiet) {
+            process.stdout.write(
+                `✅  ${target}: block already in sync ` +
+                    `(${template_entries(template_lines).length} entries)\n`,
+            );
+        }
+        return 0;
+    }
+
+    if (args.check) {
+        if (!args.quiet) {
+            process.stderr.write(
+                `⚠️  ${target}: missing ${added.length} managed entr` +
+                    `${added.length === 1 ? 'y' : 'ies'} — run without --check to apply\n`,
+            );
+        }
+        return 1;
+    }
+
+    fs.mkdirSync(path.dirname(path.resolve(target)), { recursive: true });
+    fs.writeFileSync(target, new_text, 'utf-8');
+    if (!args.quiet) {
+        process.stdout.write(
+            `✅  ${target}: updated block ` +
+                `(${added.length} entr${added.length === 1 ? 'y' : 'ies'} added)\n`,
+        );
+    }
+    return 0;
+}
+
+function _isCliEntry(): boolean {
+    if (process.argv[1] === undefined) {
+        return false;
+    }
+    const argvUrl = pathToFileURL(path.resolve(process.argv[1])).href;
+    if (import.meta.url === argvUrl) {
+        return true;
+    }
+    try {
+        const here = fs.realpathSync(fileURLToPath(import.meta.url));
+        const argv = fs.realpathSync(path.resolve(process.argv[1]));
+        return here === argv;
+    } catch {
+        return false;
+    }
+}
+
+if (_isCliEntry() || process.argv[1] === _HERE) {
+    process.exit(main(process.argv.slice(2)));
+}

package/src/scripts/team_review_gate_hook.ts

@@ -12,14 +12,11 @@
  * hook exits 0 without touching anything — byte-identical pre-Phase-4
  * Stop behavior.
  *
- * Composition point (documented, not yet wired): register this script as a
- * `team-review-gate` concern in `src/scripts/hook_manifest.yaml` on the
- * claude / cowork `stop` slots, after `chat-history` (ordering relative to
- * the PLUGIN's own Stop hook is host-scheduled and irrelevant here — the
- * verdict is read from the plugin's persisted job record, not from sibling
- * hook output). Manifest registration drags the lint_hook_manifest +
- * installer + tests/hooks snapshot surface, so it is left to the
- * orchestrator; this file is dispatcher-shaped and drop-in ready.
+ * Composition point (wired): registered as the `team-review-gate` concern
+ * in `src/scripts/hook_manifest.yaml` on the claude `stop` slot, after
+ * `chat-history` (ordering relative to the PLUGIN's own Stop hook is
+ * host-scheduled and irrelevant here — the verdict is read from the
+ * plugin's persisted job record, not from sibling hook output).
  *
  * Contract: never blocks, exit 0 on every path, `fail_closed: false`.
  */
@@ -33,16 +30,10 @@ import {
 } from './ai_team/review_gate.js';
 import { AI_TEAM_DEFAULTS, load_ai_team_config, type AiTeamConfig } from './ai_team/config.js';
 import { unwrap } from './hooks/envelope.js';
+import { readHookStdin } from './hooks/hook_stdin.js';
 
 function _read_stdin(): string {
-    try {
-        if (process.stdin.isTTY) {
-            return '';
-        }
-        return fs.readFileSync(0, 'utf-8');
-    } catch {
-        return '';
-    }
+    return readHookStdin();
 }
 
 export function main(): number {
@@ -93,7 +84,13 @@ export function main(): number {
     return 0;
 }
 
+// Bundle-safety: never auto-run when inlined into an esbuild bundle, where
+// every module shares the bundle's `import.meta.url` (see cmd_migrate.ts).
+declare const __AGENT_CONFIG_BUNDLE__: boolean | undefined;
 function _isCliEntry(): boolean {
+    if (typeof __AGENT_CONFIG_BUNDLE__ !== 'undefined' && __AGENT_CONFIG_BUNDLE__) {
+        return false;
+    }
     if (process.argv[1] === undefined) {
         return false;
     }

package/src/scripts/verify_before_complete_hook.ts

@@ -37,6 +37,7 @@ import path from "node:path";
 import { fileURLToPath, pathToFileURL } from "node:url";
 
 import { atomic_write_json } from "./hooks/state_io.js";
+import { readHookStdin } from "./hooks/hook_stdin.js";
 
 // NOTE: the Python docstring says `agents/runtime/state/`, but the code
 // constant is `agents/state/`. Replicated verbatim — latent docstring/code
@@ -286,11 +287,7 @@ function parse_args(argv: string[]): ParsedArgs {
 }
 
 function _readStdin(): string {
-  try {
-    return fs.readFileSync(0, "utf-8");
-  } catch {
-    return "";
-  }
+  return readHookStdin();
 }
 
 export function main(argv?: string[]): number {
@@ -298,7 +295,13 @@ export function main(argv?: string[]): number {
   return run(_readStdin(), { consumer_root: process.cwd(), verbose: args.verbose });
 }
 
+// Bundle-safety: never auto-run when inlined into an esbuild bundle, where
+// every module shares the bundle's `import.meta.url` (see cmd_migrate.ts).
+declare const __AGENT_CONFIG_BUNDLE__: boolean | undefined;
 function _isCliEntry(): boolean {
+    if (typeof __AGENT_CONFIG_BUNDLE__ !== 'undefined' && __AGENT_CONFIG_BUNDLE__) {
+        return false;
+    }
     if (process.argv[1] === undefined) {
         return false;
     }

package/src/scripts/wrapper_freshness_hook.ts

@@ -38,6 +38,7 @@ import {
   install_cli_wrapper,
   needs_refresh,
 } from "./_lib/cli_wrapper.js";
+import { readHookStdin } from "./hooks/hook_stdin.js";
 
 export const EXIT_ALLOW = 0;
 
@@ -112,13 +113,7 @@ function _is_source_repo(project_root: string): boolean {
 }
 
 function _readStdinIfNotTty(): void {
-  try {
-    if (!process.stdin.isTTY) {
-      fs.readFileSync(0, "utf-8");
-    }
-  } catch {
-    /* ignore */
-  }
+  readHookStdin();
 }
 
 function _parseRoot(argv: string[]): string | null {
@@ -249,7 +244,13 @@ export function main(argv?: string[]): number {
   return EXIT_ALLOW;
 }
 
+// Bundle-safety: never auto-run when inlined into an esbuild bundle, where
+// every module shares the bundle's `import.meta.url` (see cmd_migrate.ts).
+declare const __AGENT_CONFIG_BUNDLE__: boolean | undefined;
 function _isCliEntry(): boolean {
+    if (typeof __AGENT_CONFIG_BUNDLE__ !== 'undefined' && __AGENT_CONFIG_BUNDLE__) {
+        return false;
+    }
     if (process.argv[1] === undefined) {
         return false;
     }

package/src/server/schemas/settings.ts

@@ -97,11 +97,14 @@ export const settingsSchema = z.object({
             'After the agent edits a file, run `<ide> <path>` to surface it in your editor immediately. Off by default to avoid window-stealing during long agent runs.',
         ),
         rtk_installed: z.boolean().default(false).describe(
-            'Does this machine have rtk (Rust Token Killer, https://github.com/event4u-app/rtk) on PATH? When true the agent wraps verbose CLI output (git, tests, linters, docker, npm, composer) with rtk for ~60-90% token savings. Leave false if rtk is missing — the agent falls back to tail / grep.',
+            'Does this machine have rtk (Rust Token Killer, a third-party Apache-2.0 tool: https://github.com/rtk-ai/rtk) on PATH — verified as the real Token Killer, not the unrelated Rust Type Kit that shares the binary name? When true the agent wraps verbose CLI output (git, tests, linters, docker, npm, composer) with rtk (upstream reports 60-90% token savings — their estimate). Leave false if rtk is missing — the agent falls back to tail / grep. The wizard overwrites this from a live two-stage probe (PATH presence + `rtk gain` identity check).',
         ),
         minimal_output: z.boolean().default(true).describe(
             'Prefer short bullets and tables (true, default) vs verbose prose with rationale (false). Affects every chat reply; flip to false during debugging when you want the agent to think out loud.',
         ),
+        canary_name: z.string().default('').describe(
+            'Session canary — the name the agent addresses you with at the start of every new task (e.g. "Alex"). When the greeting silently disappears, the context window is degrading: start a fresh conversation. Also keeps the reply-close markers (end-summary, PR URL as literal last line) alive. Empty = off. See rules/session-canary.md.',
+        ),
         play_by_play: z.boolean().default(false).describe(
             'Narrate intermediate findings between tool calls ("Found it.", "Let me check Y."). Off by default — most users find it noisy. Turn on when you want to follow the agent\'s reasoning step by step.',
         ),
@@ -220,6 +223,14 @@ export const settingsSchema = z.object({
             'Consumed by the doc-screenshot-hygiene rule. on (default) = a data-bearing screenshot embed is gated behind this-turn human confirmation; uncertain/unresolved regions redact-or-refuse, never ship-and-hope; illustrative/no-data screenshots may embed with a stated justification. off = no data-bearing gate (the anonymization taxonomy still applies).',
         ),
     }).default({ identity_allowlist: [], forbid_terminal_capture: true, data_bearing_gate: 'on' }),
+    telegraph: z.object({
+        speak: z.boolean().default(false).describe(
+            'Whether the telegraph-speak rule ships at all. false (default) = DORMANT: compile_router omits the rule from dist/router.json entirely, so its body never reaches a host. This — not speak_scope — is the lever that stops the cost. Set true only after an output-side bench clears the kill-criterion bar (docs/adrs/telegraph/0002).',
+        ),
+        speak_scope: z.enum(['off', 'reply', 'all']).default('off').describe(
+            "Where telegraph condensation applies WHEN speak is true. off (default) = agent reply prose is exempt. compile_router never reads this key: with speak false the rule does not ship, so this setting has no effect on its own. Quote the value in YAML — bare `off` parses as a boolean under YAML 1.1 and is rejected.",
+        ),
+    }).default({ speak: false, speak_scope: 'off' }),
     tokens: z.object({
         rich_skills: richSkillsMode.default('on').describe(
             'Whether skills marked token_budget_class: rich may load in full (exempt from telegraph-speak + thin-projector trimming), consumed by the token-budget-discipline rule. on = allowed (default); off = fall back to standard condensed behavior; ask = surface an estimated token delta (tokens, not dollars) and ask once per session before loading.',
@@ -393,6 +404,9 @@ export const settingsSchema = z.object({
         session_index: z.enum(['on', 'off']).default('off').describe(
             'Opt-in compact memory index at session start (road-to-memory-retrieval-economy P5). on = inject a compact id + title + ~tokens index of curated entries (hard cap 30 rows, bodies never included) through the hot-context hook; the agent fetches full entries via memory_get on demand. off (default) = no injection — the ship-criterion (measured hit-rate gain) is unproven, so off unless proven.',
         ),
+        learn_on_session_end: z.boolean().default(false).describe(
+            'session_end learning-sidecar aggregation (road-to-reachable-code-memory P4). true = the session_end hook aggregates agents/memory/intake/*.jsonl through the learning sidecar into the gitignored .agent-learning.json + LESSONS.md (local-only, 2 s budget, fail-open; promotion stays human via /memory:propose). false (default, council 2026-07-27) = no-op; the flip is proposed only after the 30-day dogfood shows non-trivial signal AND session-end p95 < 2 s.',
+        ),
     }),
     knowledge: z.object({
         global_sharing: z.object({
@@ -442,7 +456,7 @@ export const settingsSchema = z.object({
         }).default({}),
         rtk_wrap: z.object({
             enabled: z.boolean().default(false).describe(
-                'PreToolUse RTK-wrap nudge (token-saving Phase 3). Default off. When on AND rtk is on PATH (a live probe — not a self-reported flag), warns (never blocks) "re-run wrapped with rtk" before a single verbose CLI command (git/npm/cargo/docker/…) for 60–90% token saving. Skips completeness-critical / piped / compound commands and git diff. No-op when rtk is absent.',
+                'PreToolUse RTK-wrap nudge (token-saving Phase 3). Default off. When on AND the binary on PATH is verified as Rust Token Killer (a live two-stage identity probe — not a self-reported flag, and never a colliding same-name binary), warns (never blocks) "re-run wrapped with rtk" before a single verbose CLI command (git/npm/cargo/docker/…) — upstream reports 60–90% output-token savings (their estimate). Skips completeness-critical / piped / compound commands and git diff. No-op when rtk is absent, unverified, or a different tool.',
             ),
         }).default({}),
         design_slop: z.object({

package/src/shared/userMd/utils.ts

@@ -89,3 +89,34 @@ export function parseLegacyUserMd(body: string): Record<string, unknown> {
     }
     return data;
 }
+
+/**
+ * Compose a legacy `.agent-user.md` body (fenced YAML frontmatter + a body
+ * tail) from a plain object — the write-side counterpart to
+ * `parseLegacyUserMd`. Used by
+ * `agent_user_profile.applyObservationToGlobalProfile` (road-to-global-user-memory
+ * Phase 2) to write the accepted-observation profile back in the same shape
+ * it was read in.
+ *
+ * `notes` renders as the body tail verbatim, WITHOUT an added `# Notes`
+ * heading — `parseLegacyUserMd` captures everything after the closing fence
+ * as `notes` as-is (it does not strip a heading back out), so adding one
+ * here would not round-trip: re-parsing the composed file would return
+ * `"# Notes\n\n<text>"` instead of `<text>`. (The convention of putting a
+ * literal `# Notes` heading in a hand-authored `.agent-user.md` — see
+ * `docs/examples/agent-user.example.md` — is an authoring style, not a
+ * structural marker the parser recognises; a file authored that way simply
+ * has that heading as the leading line of ITS `notes` value.) Every other
+ * key stays in the frontmatter block, in block style (matches
+ * `composeUserIdentity`'s diff-friendliness rationale).
+ *
+ * Drop alongside `parseLegacyUserMd` once `.agent-user.md`-shaped files are
+ * no longer in circulation.
+ */
+export function composeLegacyUserMd(data: Record<string, unknown>): string {
+    const { notes, ...frontmatter } = data;
+    const yamlBody = yaml.dump(frontmatter, { flowLevel: -1, lineWidth: -1, noRefs: true });
+    const notesText = typeof notes === 'string' ? notes.trim() : '';
+    const notesSection = notesText === '' ? '' : `\n${notesText}\n`;
+    return `---\n${yamlBody}---\n${notesSection}`;
+}

package/dist/agent-src/rules/telegraph-speak.md

@@ -1,87 +0,0 @@
----
-type: "auto"
-tier: "1"
-description: "telegraph.speak_scope != off — telegraph the prose; carve-outs (options, Iron-Law, code, paths) stay byte-stable"
-triggers:
-  - intent: "any reply"
-workspaces: [agent-config-maintainer]
-packs: [meta]
-enforced_by:
-  - "observer:maintainer-review"
----
-
-# Telegraph Speak
-
-Condense reply prose to telegraph grammar per `telegraph.speak_scope`. Body
-prose only — carve-outs preserved byte-for-byte.
-
-## Scope
-
-Read `telegraph.speak_scope` from `.agent-settings.yml`:
-
-- `off` — rule inactive.
-- `prose_only` (default) — telegraph in body prose; carve-outs preserved.
-- `aggressive` — telegraph everywhere except Iron-Law literals.
-
-Compile-time toggle `telegraph.speak`: `false` → rule omitted from
-`dist/router.json` (zero runtime cost). `telegraph.enabled: false` forces all
-sub-switches off regardless.
-
-## Carve-outs — byte-for-byte preserved
-
-Mangling these breaks Iron Laws. Apply regardless of `speak_scope`:
-
-1. **Triple-backtick ALL-CAPS blocks** — Iron-Law literal fences in
-   `commit-policy`, `non-destructive-by-default`, `direct-answers`, etc.
-2. **Numbered-options blocks** — lines matching `^>?\s*\d+\.\s` plus
-   the `**Recommendation:**` / `**Empfehlung:**` label
-   (`user-interaction` Iron Law 1).
-3. **Code blocks** — any triple-backtick fence, any language.
-4. **Backtick spans** — file paths, command names, identifiers
-   (`direct-answers` Iron Law 2 — no invented facts).
-5. **Status / error markers** — lines prefixed `❌`, `⚠️`, `✅`.
-6. **Mode markers** per `role-mode-adherence`.
-7. **Deliverables** — PR titles / bodies, commit messages, ticket
-   summaries, articles, single-question prompts asked to the user.
-   These are written **for** the user, not chat-prose.
-
-## Enforcement mechanism
-
-Post-rewrite validator runs on every reply when `speak_scope != off`:
-
-1. **Snapshot** — before condensation, hash each line in carve-out
-   regions (1–7 above).
-2. **Rewrite** — condense body prose to telegraph grammar.
-3. **Validate** — re-scan; for each carve-out region whose line hash
-   differs from the snapshot, **restore the original prose**.
-4. **Emit** — the validated reply.
-
-The rule documents the algorithm; agents apply it inline before
-sending. The mechanism is the rule, not a hidden script.
-
-- Optional CI-side regression lock: [`scripts/validate_telegraph_carveouts.ts`](../../scripts/validate_telegraph_carveouts.ts) — pre/post reply pair, byte-identical preservation across all seven carve-out categories; runtime mechanism stays algorithmic, script is the offline check.
-
-## Telegraph grammar
-
-- Drop articles (`the`, `a`, `an`).
-- Drop linking auxiliaries (`is`, `are`, `was`, `be`) where
-  unambiguous.
-- Drop pronouns when context is clear.
-- Keep nouns, verbs, key adjectives, negation, numbers.
-
-Example: *"I will now check the file and see if it exists"* →
-*"Check file. Exists?"*
-
-## Settings
-
-| Key | Default | Effect |
-|---|---|---|
-| `telegraph.enabled` | `true` | Master — `false` forces all sub-switches off. |
-| `telegraph.speak` | `true` | Compile-time include in `dist/router.json`. |
-| `telegraph.speak_scope` | `prose_only` | Runtime scope of telegraph grammar. |
-
-- Input-side memory condensation (shrinking always-loaded memory files like `AGENTS.md` / `CLAUDE.md` / `.cursorrules` rather than the reply stream) runs independently of `speak_scope` — see [`condense-memory`](../skills/condense-memory/SKILL.md) for the script wrapper, sensitive-path refusal contract, and `.original.md` round-trip.
-- Skills marked `token_budget_class: rich` are **exempt** from telegraph condensation + thin-projector trimming (gated by `tokens.rich_skills`, default `on`) — full model in [`token-budget-discipline`](token-budget-discipline.md).
-- Any telegraph/trim decision that would drop a net-positive change purely on budget grounds routes to [`token-budget-discipline § Value-over-budget escalation`](token-budget-discipline.md#value-over-budget-escalation) — surface the trade-off, don't auto-reject.
-
-Cross-rule index: [`frugality-charter § cross-references`](../contexts/contracts/frugality-charter.md#cross-references--frugality-canon-rules).