@event4u/agent-config 14.18.0 → 14.20.0

package/src/scripts/mcp_server/telemetry.ts

@@ -3,7 +3,9 @@
 // Per `agents/roadmaps/archive/road-to-mcp-full-coverage.md` §Phase 1 J4 +
 // `docs/contracts/mcp-tool-stub-envelope.md`, both transports log every
 // `tools/call` with `{tool_name, client_id_hash, ts, transport,
-// outcome}`. Payload bodies are never logged; the client identifier is
+// outcome}`. The stdio-lite surface (`src/cli/mcp/`) appends a sixth,
+// optional `host` field; callers that do not know their client omit it and
+// their records stay byte-identical to the frozen five-field envelope. Payload bodies are never logged; the client identifier is
 // hashed at the server boundary so the queryable store never sees raw
 // identity.
 //
@@ -107,15 +109,26 @@ export function build_record(options: {
     transport: string;
     client_id_hash_value?: string | null | undefined;
     ts?: string | null | undefined;
+    host?: string | null | undefined;
 }): Record<string, unknown> {
-    const { tool_name, outcome, transport, client_id_hash_value, ts } = options;
-    return {
+    const { tool_name, outcome, transport, client_id_hash_value, ts, host } = options;
+    const record: Record<string, unknown> = {
         tool_name,
         client_id_hash: client_id_hash_value || hash_client_id(),
         ts: ts || _now_iso(),
         transport,
         outcome,
     };
+    // `host` is APPENDED, and only when a caller supplies one, so a record
+    // written by a caller that does not know its client stays byte-identical
+    // to the five-field envelope the stub contract froze. It is a closed
+    // vocabulary resolved at the boundary (see `src/cli/mcp/telemetry.ts`),
+    // never a free-form string: a record type that cannot hold arbitrary text
+    // has no scrubber to fail.
+    if (typeof host === 'string' && host !== '') {
+        record.host = host;
+    }
+    return record;
 }
 
 /**
@@ -132,13 +145,15 @@ export function record_call(options: {
     transport: string;
     consumer_root?: string | null | undefined;
     client_id_hash_value?: string | null | undefined;
+    host?: string | null | undefined;
 }): Record<string, unknown> | null {
-    const { tool_name, outcome, transport, consumer_root, client_id_hash_value } = options;
+    const { tool_name, outcome, transport, consumer_root, client_id_hash_value, host } = options;
     const record = build_record({
         tool_name,
         outcome,
         transport,
         client_id_hash_value,
+        host,
     });
     const target = _resolve_log_path(consumer_root ?? undefined);
     try {

package/src/scripts/measure_sibling_naming.ts

@@ -0,0 +1,150 @@
+/**
+ * measure_sibling_naming — how many skill descriptions name another skill.
+ *
+ * `road-to-one-motion-authority` step 5.2. An inbox census claimed "44/299
+ * descriptions name a sibling" and shipped no definition of *naming* and no
+ * script, so the figure could be neither reproduced nor refuted. A companion
+ * claim of "218/299 bodies" reproduced under no reading of the tree at all.
+ * This script exists so the next such number is falsifiable.
+ *
+ * WHAT "NAMES A SIBLING" MEANS HERE, stated because the census did not.
+ *
+ * A description names a sibling when it contains the exact `name:` value of a
+ * DIFFERENT shipped skill, delimited so it is not a fragment of a longer
+ * identifier. `\b` is not enough: it puts a boundary between `brand` and the
+ * hyphen in `brand-identity`, so a bare `\b`-matched `brand` would score every
+ * mention of `brand-identity` as naming `brand` too. The delimiter here is
+ * "not `[A-Za-z0-9-]`" on both sides, which is the smallest rule that keeps
+ * `mcp` out of `mcp-builder` and `laravel` out of `laravel-dto`.
+ *
+ * A skill naming ITSELF does not count — that is a description, not a pointer.
+ *
+ * WHAT THE NUMBER IS AND IS NOT.
+ *
+ * A KNOWN AND UNFIXABLE FALSE POSITIVE, named rather than left for a reader to
+ * find: some skill names are ordinary English words, so a description can score
+ * a match by accident. `canvas-design` scores `brand` on the phrase "brand
+ * assets", which is not a pointer to the `brand` skill. Excluding short or
+ * common names would trade this for a false negative on the skills whose names
+ * really are those words, and there is no rule that gets both. The count is
+ * therefore an upper bound; the per-skill list is printed so a reader can see
+ * which matches are real.
+ *
+ * It is a count of descriptions that mention a sibling by name. It is NOT a
+ * measure of routing quality: a description can name a sibling uselessly, and a
+ * description that names none can be perfectly routable on its own keywords.
+ * The reason the count is worth having is narrower — the router reads
+ * descriptions and nothing else, so a family whose members never point at each
+ * other is a family the router cannot traverse.
+ *
+ * Exit code is 0 unless `--min <n>` is given and the count falls below it.
+ */
+
+import fs from 'node:fs';
+import path from 'node:path';
+import { fileURLToPath, pathToFileURL } from 'node:url';
+
+const HERE = path.dirname(fileURLToPath(import.meta.url));
+const REPO_ROOT = path.resolve(HERE, '..', '..');
+const SKILLS_REL = path.join('src', 'skills');
+
+export interface SkillRecord { name: string; description: string }
+
+/** Read `name:` and `description:` out of a SKILL.md frontmatter block. */
+export function parseSkill(text: string): SkillRecord | null {
+    if (!text.startsWith('---')) return null;
+    const end = text.indexOf('\n---', 3);
+    if (end < 0) return null;
+    const fm = text.slice(3, end);
+    const name = /^name:\s*(.+)$/m.exec(fm)?.[1]?.trim() ?? '';
+    let description = /^description:\s*(.+)$/m.exec(fm)?.[1]?.trim() ?? '';
+    if ((description.startsWith('"') && description.endsWith('"'))
+        || (description.startsWith("'") && description.endsWith("'"))) {
+        description = description.slice(1, -1);
+    }
+    description = description.replace(/\\"/g, '"');
+    if (name === '') return null;
+    return { name, description };
+}
+
+export function loadSkills(root: string): SkillRecord[] {
+    const dir = path.join(root, SKILLS_REL);
+    if (!fs.existsSync(dir)) return [];
+    const out: SkillRecord[] = [];
+    for (const entry of fs.readdirSync(dir, { withFileTypes: true })) {
+        if (!entry.isDirectory()) continue;
+        const file = path.join(dir, entry.name, 'SKILL.md');
+        if (!fs.existsSync(file)) continue;
+        const rec = parseSkill(fs.readFileSync(file, 'utf-8'));
+        if (rec !== null) out.push(rec);
+    }
+    return out.sort((a, b) => a.name.localeCompare(b.name));
+}
+
+/** Identifier-boundary containment: `mcp` is not found inside `mcp-builder`. */
+export function namesIdentifier(haystack: string, id: string): boolean {
+    let from = 0;
+    for (;;) {
+        const i = haystack.indexOf(id, from);
+        if (i < 0) return false;
+        const before = i === 0 ? '' : haystack[i - 1] ?? '';
+        const after = haystack[i + id.length] ?? '';
+        const isPart = (c: string): boolean => c !== '' && /[A-Za-z0-9-]/.test(c);
+        if (!isPart(before) && !isPart(after)) return true;
+        from = i + 1;
+    }
+}
+
+/** For each skill, the OTHER skills its description names. Sorted, deterministic. */
+export function siblingsNamed(skills: readonly SkillRecord[]): Map<string, string[]> {
+    const names = skills.map((s) => s.name);
+    const out = new Map<string, string[]>();
+    for (const s of skills) {
+        const hits = names
+            .filter((n) => n !== s.name && namesIdentifier(s.description, n))
+            .sort();
+        out.set(s.name, hits);
+    }
+    return out;
+}
+
+export function main(argv: readonly string[] = process.argv.slice(2)): number {
+    const rootFlag = argv.indexOf('--root');
+    const root = rootFlag >= 0 ? (argv[rootFlag + 1] ?? REPO_ROOT) : REPO_ROOT;
+    const minFlag = argv.indexOf('--min');
+    const min = minFlag >= 0 ? Number(argv[minFlag + 1]) : null;
+    const json = argv.includes('--json');
+
+    const skills = loadSkills(root);
+    const map = siblingsNamed(skills);
+    const naming = [...map].filter(([, v]) => v.length > 0);
+
+    if (json) {
+        process.stdout.write(`${JSON.stringify({
+            total: skills.length,
+            naming: naming.length,
+            entries: Object.fromEntries(naming),
+        }, null, 1)}\n`);
+    } else {
+        process.stdout.write(`scanned: ${String(skills.length)}\n`);
+        process.stdout.write(
+            `sibling-naming: ${String(naming.length)}/${String(skills.length)} description(s) name at least one other shipped skill\n\n`,
+        );
+        for (const [name, hits] of naming) {
+            process.stdout.write(`  ${name} → ${hits.join(', ')}\n`);
+        }
+    }
+
+    if (min !== null && Number.isFinite(min) && naming.length < min) {
+        process.stderr.write(
+            `\n❌  measure_sibling_naming: ${String(naming.length)} below the declared floor of ${String(min)}\n`,
+        );
+        return 1;
+    }
+    return 0;
+}
+
+if (process.argv[1] !== undefined) {
+    const invoked = pathToFileURL(path.resolve(process.argv[1])).href;
+    if (invoked === import.meta.url) process.exitCode = main();
+}

package/src/scripts/orchestration_record.ts

@@ -10,7 +10,7 @@
  *   ./scripts-run src/scripts/orchestration_record \
  *     --spawn-count 1 --token-delta -72000 --provenance measured \
  *     --tier-chosen lite --tier-source inferred --task-class read-only-fanout \
- *     [--tiers sonnet,opus] [--agent-combo implementer,judge] [--wall-clock-ms 18500] [--dispatch-outcome DONE] \
+ *     [--rules-applied a,b] [--tiers sonnet,opus] [--agent-combo implementer,judge] [--wall-clock-ms 18500] [--dispatch-outcome DONE] \
  *     [--first-pass-success true|false] [--escalated true|false] \
  *     [--init-tokens 1200] [--payload-hash <hex8-64>] [--lookup-class definition|references|string-existence|report-run] \
  *     [--route-taken primitive|subagent|ask] [--budget-hit true|false] [--correctness-match true|false] \
@@ -141,6 +141,17 @@ export function main(argv: string[] = process.argv.slice(2)): number {
             if (raw === undefined) return undefined;
             return raw.split(',').map((v) => v.trim()).filter(Boolean);
         })(),
+        // `--rules-applied=a,b` records the rules the run actually carried.
+        // Unlike `--skills-applied`, an OMITTED flag and an empty value mean
+        // the same thing here: audit-log-v1 makes `rules_applied` mandatory on
+        // every line, so `[]` is how "nothing observed" is spelled, and there
+        // is no absent-key slot to distinguish it from. What this flag replaced
+        // is the fabricated `['delegation-policy']` this producer wrote on
+        // every line until 2026-09-07.
+        rules_applied: str(flags, 'rules-applied')
+            ?.split(',')
+            .map((v) => v.trim())
+            .filter(Boolean),
         task_size_estimate: int(flags, 'task-size-estimate'),
         wall_clock_ms: int(flags, 'wall-clock-ms'),
         dispatch_tokens: int(flags, 'dispatch-tokens'),

package/src/scripts/redact_hook_capture.ts

@@ -4,7 +4,7 @@
  *
  * Ported from the retired Python `redact_hook_capture.py` (Phase 8 / Wave 8g).
  *
- * Reads JSON capture files written by `dispatch_hook.py` (when
+ * Reads JSON capture files written by `dispatch_hook.ts` (when
  * `AGENT_HOOK_CAPTURE_DIR` is set) and produces a redacted version
  * suitable for pasting into the verified-platforms roadmap.
  *

package/src/scripts/release.ts

@@ -49,8 +49,10 @@
  * Idempotency: pass `--resume` to recover from a partial failure. Each
  * step then probes existing state (branch, commit, PR, tag, GitHub
  * Release) and skips work that is already done, instead of erroring out.
- * Without `--resume` the pipeline still mutates git/network state, so
- * re-running on a dirty tree needs `--resume` (or a manual cleanup). The
+ * Re-running from `release/{target}` needs neither the flag nor a clean
+ * tree — that position, dirty, is the state `guard_release_curation` leaves
+ * behind, and `preflightPosition` accepts it (a dirty `main` still refuses).
+ * The
  * two entry points guard against colliding with each other via these same
  * probes plus the CI workflow's concurrency group — whichever starts
  * second sees the other's in-progress state and skips or refuses cleanly.
@@ -124,6 +126,7 @@ import {
     derive_category_hits,
     render_derived_head_values,
 } from './_lib/release_highlights.js';
+import { preflightPosition } from './_lib/release_position.js';
 import {
     RELEASE_HEAD_DEFAULT,
     extract_changelog_section,
@@ -784,17 +787,17 @@ export function assert_scheduled_deprecations_clear(
 /**
  * Fail fast on conditions that would break the release mid-flight.
  *
- * In `--resume` mode two invariants are relaxed:
+ * The start position — which branch, and whether a dirty tree is tolerated —
+ * is `preflightPosition` in `_lib/release_position.ts`, and it is NO LONGER
+ * gated on `--resume`:
+ * `release/{target}` is where `guard_release_curation` leaves the operator, so
+ * refusing it there made the guard's own remedy unreachable. Read that
+ * function's header for the measurement.
  *
- * - The starting branch may be `release/{target}` in addition to `main` —
- *   both are valid resume positions (mid-pipeline crash after step 1 leaves
- *   you on the release branch).
- * - The target-tag-exists check is dropped — execute() probes for existing
- *   tags/releases and skips them.
+ * `--resume` still relaxes ONE invariant here: the target-tag-exists check is
+ * dropped, because execute() probes for existing tags/releases and skips them.
  *
- * Tree cleanliness, gh auth, and `main` in-sync with origin are still
- * enforced, so resuming has the same starting posture as a fresh run; only
- * step-level outcomes differ.
+ * gh auth and `main` in-sync with origin are enforced either way.
  *
  * `opts.ci` swaps the gh-auth probe (see below) for the CI-mode variant —
  * everything else is identical between the two entry points.
@@ -832,20 +835,17 @@ function preflight(target: string, opts: { resume?: boolean; ci?: boolean } = {}
 
     const branch = git(['rev-parse', '--abbrev-ref', 'HEAD'], { capture: true });
     const release_branch = `release/${target}`;
-    const allowed = resume ? new Set([MAIN_BRANCH, release_branch]) : new Set([MAIN_BRANCH]);
-    if (!allowed.has(branch)) {
-        if (resume) {
-            die(
-                `resume must run from '${MAIN_BRANCH}' or '${release_branch}', ` +
-                    `currently on '${branch}'`,
-            );
-        }
-        die(`release must run from '${MAIN_BRANCH}', currently on '${branch}'`);
+    const position = preflightPosition({
+        branch,
+        mainBranch: MAIN_BRANCH,
+        releaseBranch: release_branch,
+        porcelain: git(['status', '--porcelain'], { capture: true }),
+    });
+    if (!position.proceed) {
+        die(position.message ?? `release cannot start from '${branch}'`);
     }
-
-    const porcelain = git(['status', '--porcelain'], { capture: true });
-    if (porcelain) {
-        die('working tree is not clean; commit or stash first');
+    if (position.notice) {
+        process.stdout.write(`\u26a0\ufe0f  ${position.notice}\n`);
     }
 
     // --force lets the remote's tag positions win over stale local tags.

package/src/scripts/release_publication.ts

@@ -731,8 +731,12 @@ export function guard_release_curation(version: string, prMerged = false): void
                   marked.join('\n')
                 : '') +
             '\n    Stopped BEFORE committing — no release commit, no branch on ' +
-            `${REMOTE}, no pull request, no tag. Curate the ` +
-            '`### Release highlights` head, then re-run `task release`.',
+            `${REMOTE}, no pull request, no tag. HEAD is on the LOCAL ` +
+            `\`release/${version}\` branch and the generated section is in the working ` +
+            'tree: curate the `### Release highlights` head in `CHANGELOG.md` there, then ' +
+            're-run `task release`. That re-run works from this position — `preflightPosition` ' +
+            'accepts the release branch with the uncommitted step-2 output, which it did not ' +
+            'until 2026-09-07 (both spellings of the re-run were refused before step 1).',
     );
 }