@event4u/agent-config 7.4.0 → 8.0.0

package/src/scripts/bench_ab_v2_stats.ts

@@ -46,6 +46,12 @@ const COMPARISONS: Array<[string, string, string]> = [
     // renders ONLY when a `package-recursive` arm is present — existing runs
     // (no such arm) are byte-identical, golden parity preserved.
     ['package-recursive', 'package', 'recursion novel lift (D₂ − D₁)'],
+    // Cost-factor sweep (2026-07): trimmed rule-subset arms vs vanilla — how
+    // much of the weak-host lift survives at a fraction of the loaded-context
+    // cost. Arm-guarded like the rows above: rendered only when present.
+    ['rules-kernel-dc', 'vanilla', 'kernel+downstream rules lift'],
+    ['rules-balanced', 'vanilla', 'balanced-profile rules lift'],
+    ['package', 'rules-kernel-dc', 'full package residual over kernel+downstream'],
 ];
 
 // ── CPython math.erf / math.comb ports ────────────────────────────────────

package/src/scripts/bench_matrix.ts

@@ -0,0 +1,266 @@
+#!/usr/bin/env tsx
+/**
+ * Bench matrix runner — road-to-flow-learnings Phase 3.
+ *
+ * Declares one matrix (task-family × host × arm) in a YAML file and expands
+ * it into the EXISTING `bench_ab_v2_run.ts` invocations — no new runner, no
+ * new science. The paired design is preserved by construction: all arms of a
+ * cell run inside ONE runner invocation (pairing happens per task inside the
+ * runner), so a cell = (host × family) and the arm axis rides along.
+ *
+ * Matrix YAML shape:
+ *
+ *   families: [trapE, capH]        # archetype values from the corpus
+ *   hosts: [claude, codex]
+ *   arms: [vanilla, package]
+ *   seeds: 3
+ *   model: claude-haiku-4-5
+ *   budget: 1.0
+ *
+ * `--expand` (default) prints the deterministic invocation plan — one line
+ * per cell — and never spends. `--run` executes the cells sequentially
+ * (live API spend; operator-gated).
+ *
+ * Exit: 0 ok · 1 a live cell failed · 2 config error.
+ */
+
+import { spawnSync } from 'node:child_process';
+import * as fs from 'node:fs';
+import * as path from 'node:path';
+import process from 'node:process';
+import { fileURLToPath, pathToFileURL } from 'node:url';
+
+import { parse as parseYaml } from 'yaml';
+
+import { ARMS, CODEX_VALID_ARMS } from './bench_ab_v2_run.js';
+
+const _HERE = fileURLToPath(import.meta.url);
+export const REPO_ROOT = path.resolve(path.dirname(_HERE), '..', '..');
+const DEFAULT_CORPUS = path.join(REPO_ROOT, 'internal', 'bench', 'corpora', 'ab-trackb-v2.yaml');
+const RUNNER = path.join(REPO_ROOT, 'src', 'scripts', 'bench_ab_v2_run.ts');
+
+type Dict = Record<string, unknown>;
+
+const VALID_HOSTS = ['claude', 'codex'] as const;
+
+export interface MatrixSpec {
+    readonly families: readonly string[];
+    readonly hosts: readonly string[];
+    readonly arms: readonly string[];
+    readonly seeds: number;
+    readonly model: string;
+    readonly budget: number;
+    readonly timeout: number;
+}
+
+export class MatrixConfigError extends Error {}
+
+function strList(obj: Dict, key: string): string[] {
+    const raw = obj[key];
+    if (!Array.isArray(raw) || raw.length === 0 || !raw.every((v) => typeof v === 'string')) {
+        throw new MatrixConfigError(`\`${key}\` must be a non-empty string list`);
+    }
+    return raw as string[];
+}
+
+/** Parse + validate the matrix YAML against the runner's own registries. */
+export function parseMatrixSpec(text: string): MatrixSpec {
+    let raw: unknown;
+    try {
+        raw = parseYaml(text);
+    } catch (exc) {
+        throw new MatrixConfigError(`matrix config does not parse: ${(exc as Error).message}`);
+    }
+    if (raw === null || typeof raw !== 'object' || Array.isArray(raw)) {
+        throw new MatrixConfigError('matrix config must be a mapping');
+    }
+    const obj = raw as Dict;
+    const spec: MatrixSpec = {
+        families: strList(obj, 'families'),
+        hosts: strList(obj, 'hosts'),
+        arms: strList(obj, 'arms'),
+        seeds: typeof obj['seeds'] === 'number' ? (obj['seeds'] as number) : 3,
+        model: typeof obj['model'] === 'string' ? (obj['model'] as string) : 'claude-haiku-4-5',
+        budget: typeof obj['budget'] === 'number' ? (obj['budget'] as number) : 1.0,
+        timeout: typeof obj['timeout'] === 'number' ? (obj['timeout'] as number) : 180,
+    };
+    for (const h of spec.hosts) {
+        if (!VALID_HOSTS.includes(h as (typeof VALID_HOSTS)[number])) {
+            throw new MatrixConfigError(`unknown host '${h}' (valid: ${VALID_HOSTS.join(', ')})`);
+        }
+    }
+    for (const a of spec.arms) {
+        if (!(a in ARMS)) {
+            throw new MatrixConfigError(`unknown arm '${a}' (valid: ${Object.keys(ARMS).join(', ')})`);
+        }
+    }
+    if (spec.hosts.includes('codex')) {
+        for (const a of spec.arms) {
+            if (!CODEX_VALID_ARMS.includes(a)) {
+                throw new MatrixConfigError(
+                    `arm '${a}' is not valid for host codex (valid: ${CODEX_VALID_ARMS.join(', ')})`,
+                );
+            }
+        }
+    }
+    if (!Number.isInteger(spec.seeds) || spec.seeds < 1) {
+        throw new MatrixConfigError('`seeds` must be a positive integer');
+    }
+    return spec;
+}
+
+/** Group corpus task ids by archetype (the family axis). */
+export function familyTaskIds(corpusText: string): Map<string, string[]> {
+    const corpus = parseYaml(corpusText, { version: '1.1' }) as Dict | null;
+    const tasks = Array.isArray(corpus?.['tasks']) ? (corpus?.['tasks'] as Dict[]) : [];
+    const out = new Map<string, string[]>();
+    for (const t of tasks) {
+        const family = String(t['archetype'] ?? '');
+        const id = String(t['id'] ?? '');
+        if (!family || !id) continue;
+        const list = out.get(family) ?? [];
+        list.push(id);
+        out.set(family, list);
+    }
+    return out;
+}
+
+/** One expanded cell — a single runner invocation covering all matrix arms. */
+export interface MatrixCell {
+    readonly host: string;
+    readonly family: string;
+    readonly taskIds: readonly string[];
+    readonly argv: readonly string[];
+}
+
+/**
+ * Deterministic expansion: cells in (host, family) document order. Throws
+ * {@link MatrixConfigError} when a family matches zero corpus tasks — a
+ * silent empty cell would read as coverage that never ran.
+ */
+export function expandMatrix(spec: MatrixSpec, corpusText: string, mode: 'dry-run' | 'live'): MatrixCell[] {
+    const byFamily = familyTaskIds(corpusText);
+    const cells: MatrixCell[] = [];
+    for (const host of spec.hosts) {
+        for (const family of spec.families) {
+            const taskIds = byFamily.get(family) ?? [];
+            if (taskIds.length === 0) {
+                throw new MatrixConfigError(
+                    `family '${family}' matches no corpus task (known: ${[...byFamily.keys()].join(', ')})`,
+                );
+            }
+            cells.push({
+                host,
+                family,
+                taskIds,
+                argv: [
+                    RUNNER,
+                    '--arms', spec.arms.join(','),
+                    '--tasks', taskIds.join(','),
+                    '--seeds', String(spec.seeds),
+                    '--model', spec.model,
+                    '--budget', String(spec.budget),
+                    '--timeout', String(spec.timeout),
+                    '--host', host,
+                    '--mode', mode,
+                ],
+            });
+        }
+    }
+    return cells;
+}
+
+/** One line per cell — the snapshot-tested plan format. */
+export function planLines(cells: readonly MatrixCell[]): string[] {
+    return cells.map(
+        (c) =>
+            `cell host=${c.host} family=${c.family} tasks=${c.taskIds.length} :: ` +
+            `bench_ab_v2_run ${c.argv.slice(1).join(' ')}`,
+    );
+}
+
+const USAGE =
+    'usage: bench_matrix [-h] --config matrix.yaml [--corpus PATH] [--expand | --run]\n';
+
+export function main(argv: string[] | null = null): number {
+    const args = argv !== null ? Array.from(argv) : process.argv.slice(2);
+    let configPath: string | null = null;
+    let corpusPath = DEFAULT_CORPUS;
+    let run = false;
+    let i = 0;
+    while (i < args.length) {
+        const a = args[i] as string;
+        if (a === '-h' || a === '--help') {
+            process.stdout.write(USAGE);
+            return 0;
+        }
+        if (a === '--run') {
+            run = true;
+        } else if (a === '--expand') {
+            run = false;
+        } else if (a === '--config' || a.startsWith('--config=')) {
+            configPath = a.includes('=') ? a.slice(a.indexOf('=') + 1) : String(args[(i += 1)] ?? '');
+        } else if (a === '--corpus' || a.startsWith('--corpus=')) {
+            corpusPath = a.includes('=') ? a.slice(a.indexOf('=') + 1) : String(args[(i += 1)] ?? '');
+        } else {
+            process.stderr.write(USAGE);
+            process.stderr.write(`bench_matrix: error: unrecognized argument ${a}\n`);
+            return 2;
+        }
+        i += 1;
+    }
+    if (!configPath || !fs.existsSync(configPath)) {
+        process.stderr.write(USAGE);
+        process.stderr.write('bench_matrix: error: --config path missing or not found\n');
+        return 2;
+    }
+    if (!fs.existsSync(corpusPath)) {
+        process.stderr.write(`bench_matrix: error: corpus not found: ${corpusPath}\n`);
+        return 2;
+    }
+    let cells: MatrixCell[];
+    try {
+        const spec = parseMatrixSpec(fs.readFileSync(configPath, 'utf-8'));
+        cells = expandMatrix(spec, fs.readFileSync(corpusPath, 'utf-8'), run ? 'live' : 'dry-run');
+    } catch (exc) {
+        if (exc instanceof MatrixConfigError) {
+            process.stderr.write(`bench_matrix: error: ${exc.message}\n`);
+            return 2;
+        }
+        throw exc;
+    }
+
+    for (const line of planLines(cells)) {
+        process.stdout.write(`${line}\n`);
+    }
+    if (!run) {
+        process.stdout.write(`bench_matrix: EXPAND — ${cells.length} cell(s). No spend.\n`);
+        return 0;
+    }
+    // Live execution: sequential by design — the runner already parallelises
+    // nothing internally, and live bench spend must stay easy to abort.
+    for (const [idx, cell] of cells.entries()) {
+        process.stderr.write(`bench_matrix: [${idx + 1}/${cells.length}] host=${cell.host} family=${cell.family}\n`);
+        const proc = spawnSync(process.execPath, ['--import', 'tsx', ...cell.argv], {
+            stdio: 'inherit',
+            cwd: REPO_ROOT,
+        });
+        if (proc.status !== 0) {
+            process.stderr.write(
+                `bench_matrix: cell failed (exit ${proc.status}) — aborting remaining cells\n`,
+            );
+            return 1;
+        }
+    }
+    process.stdout.write(`bench_matrix: ${cells.length} cell(s) complete.\n`);
+    return 0;
+}
+
+// --- CLI entry ---
+
+const _isCliEntry =
+    process.argv[1] !== undefined &&
+    import.meta.url === pathToFileURL(path.resolve(process.argv[1])).href;
+if (_isCliEntry || process.argv[1] === _HERE) {
+    process.exitCode = main(process.argv.slice(2));
+}

package/src/scripts/bootstrap_knowledge.ts

@@ -0,0 +1,267 @@
+#!/usr/bin/env tsx
+/**
+ * Project familiarization bootstrap — road-to-knowledge-system Phase 6.
+ * Deterministic, static-analysis-only seed for a fresh consumer project:
+ * scans directory NAMES and known config FILENAMES only — never reads file
+ * CONTENTS beyond the project's own manifest files, so secrets/PII/business
+ * logic can never leak into the staged output by construction (the same
+ * exclusion-by-construction principle as PII-safe log schemas: a script that
+ * cannot read arbitrary file bodies has no redaction pass to fail).
+ *
+ * Every detected fact carries an evidence pointer (the path that proves it).
+ * Every inferential line (a suggestion the human still has to confirm) is
+ * marked `[HUMAN: verify]` — this script never invents a claim.
+ *
+ * Output goes to a GITIGNORED staging directory, never directly to
+ * `agents/knowledge/`. The `/team-knowledge bootstrap` command reviews the
+ * staged pages with the user before moving anything into the tracked tree.
+ *
+ * Usage:
+ *   bootstrap_knowledge.ts [--dir <repo-root>] [--staging-dir <dir>]
+ *
+ * Exit codes: 0 = staged, 1 = usage error.
+ */
+import * as fs from 'node:fs';
+import * as path from 'node:path';
+import process from 'node:process';
+import { fileURLToPath } from 'node:url';
+
+const PROG = 'bootstrap_knowledge.ts';
+const DEFAULT_STAGING_DIR = path.join('agents', '.bootstrap-staging');
+
+// Directory names never worth surfacing as "project structure" — build
+// output, dependency caches, and VCS internals.
+const NOISE_DIRS = new Set([
+    'node_modules', 'vendor', '.git', 'dist', 'build', '.next', '.nuxt',
+    'coverage', '.venv', 'venv', '__pycache__', '.turbo', '.cache',
+]);
+
+interface ManifestSignal {
+    ecosystem: string;
+    file: string;
+}
+
+const MANIFEST_FILES: ManifestSignal[] = [
+    { ecosystem: 'Node/JS/TS', file: 'package.json' },
+    { ecosystem: 'PHP/Composer', file: 'composer.json' },
+    { ecosystem: 'Python', file: 'pyproject.toml' },
+    { ecosystem: 'Python (legacy)', file: 'requirements.txt' },
+    { ecosystem: 'Go', file: 'go.mod' },
+    { ecosystem: 'Ruby', file: 'Gemfile' },
+    { ecosystem: 'Rust', file: 'Cargo.toml' },
+];
+
+// Per standards-from-config's own detection list — existence only, never content.
+const STANDARDS_CONFIG_FILES = [
+    '.editorconfig', '.eslintrc.json', '.eslintrc.js', 'eslint.config.js',
+    '.prettierrc', '.prettierrc.json', 'biome.json', 'tsconfig.json',
+    'pint.json', '.php-cs-fixer.dist.php', 'phpcs.xml',
+    'ruff.toml', 'setup.cfg', '.rubocop.yml', '.golangci.yml',
+];
+
+const TEST_CONFIG_FILES = [
+    'jest.config.js', 'jest.config.ts', 'vitest.config.ts', 'vitest.config.js',
+    'phpunit.xml', 'phpunit.xml.dist', 'pytest.ini', 'pest.config.php',
+];
+
+export interface DetectedFact {
+    label: string;
+    evidence: string; // the file/dir path proving this fact
+}
+
+export interface BootstrapResult {
+    manifests: DetectedFact[];
+    topLevelDirs: DetectedFact[];
+    standardsConfigs: DetectedFact[];
+    testConfigs: DetectedFact[];
+}
+
+function exists(p: string): boolean {
+    try {
+        fs.accessSync(p);
+        return true;
+    } catch {
+        return false;
+    }
+}
+
+/** Pure detection over a given root — filenames and directory names only, never file content. */
+export function detect(root: string): BootstrapResult {
+    const manifests: DetectedFact[] = [];
+    for (const m of MANIFEST_FILES) {
+        if (exists(path.join(root, m.file))) manifests.push({ label: m.ecosystem, evidence: m.file });
+    }
+
+    let topLevelDirs: DetectedFact[] = [];
+    try {
+        topLevelDirs = fs
+            .readdirSync(root, { withFileTypes: true })
+            .filter((e) => e.isDirectory() && !e.name.startsWith('.') && !NOISE_DIRS.has(e.name))
+            .map((e) => ({ label: e.name, evidence: `${e.name}/` }))
+            .sort((a, b) => (a.label < b.label ? -1 : a.label > b.label ? 1 : 0));
+    } catch {
+        topLevelDirs = [];
+    }
+
+    const standardsConfigs = STANDARDS_CONFIG_FILES.filter((f) => exists(path.join(root, f))).map((f) => ({
+        label: f,
+        evidence: f,
+    }));
+
+    const testConfigs = TEST_CONFIG_FILES.filter((f) => exists(path.join(root, f))).map((f) => ({
+        label: f,
+        evidence: f,
+    }));
+
+    return { manifests, topLevelDirs, standardsConfigs, testConfigs };
+}
+
+function renderStructurePage(result: BootstrapResult): string {
+    const lines: string[] = [
+        '---',
+        'type: concept',
+        '---',
+        '',
+        '# Project Structure',
+        '',
+        '_Staged by `src/scripts/bootstrap_knowledge.ts` — review before committing._',
+        '',
+        '## Detected package manifests',
+        '',
+    ];
+    if (result.manifests.length === 0) {
+        lines.push('- No known manifest file found. `[HUMAN: verify]` — name the ecosystem.');
+    } else {
+        for (const m of result.manifests) lines.push(`- ${m.label} (\`${m.evidence}\`)`);
+    }
+    lines.push('', '## Top-level directories', '');
+    if (result.topLevelDirs.length === 0) {
+        lines.push('- None detected.');
+    } else {
+        for (const d of result.topLevelDirs) {
+            lines.push(`- \`${d.evidence}\` — \`[HUMAN: verify]\` purpose/ownership`);
+        }
+    }
+    lines.push('');
+    return lines.join('\n');
+}
+
+function renderStandardsPage(result: BootstrapResult): string {
+    const lines: string[] = [
+        '---',
+        'type: concept',
+        '---',
+        '',
+        '# Coding Standards (config-derived seed)',
+        '',
+        '_Staged by `src/scripts/bootstrap_knowledge.ts` — this lists WHICH config',
+        'files exist, not their content. Run `standards-from-config` for the full',
+        'pointer+digest derivation before relying on this page._',
+        '',
+    ];
+    if (result.standardsConfigs.length === 0) {
+        lines.push('- No recognized lint/format config found. `[HUMAN: verify]`.');
+    } else {
+        for (const c of result.standardsConfigs) lines.push(`- \`${c.evidence}\` present — \`[HUMAN: verify]\` derive the actual rule via \`standards-from-config\``);
+    }
+    lines.push('', '## Test framework', '');
+    if (result.testConfigs.length === 0) {
+        lines.push('- No recognized test config found. `[HUMAN: verify]`.');
+    } else {
+        for (const t of result.testConfigs) lines.push(`- \`${t.evidence}\` present`);
+    }
+    lines.push('');
+    return lines.join('\n');
+}
+
+const MODULES_PAGE = [
+    '---',
+    'type: concept',
+    '---',
+    '',
+    '# Module Structure',
+    '',
+    '_Staged by `src/scripts/bootstrap_knowledge.ts` as an EMPTY seed — module',
+    'boundaries require reading actual code, which this deterministic bootstrap',
+    'never does. Run `module-detect-on-the-fly` to fill this in, or delete this',
+    'page if the project has no module system._',
+    '',
+    '`[HUMAN: verify]` — run module-detect-on-the-fly and fill this page in.',
+    '',
+].join('\n');
+
+const API_CONVENTIONS_PAGE = [
+    '---',
+    'type: procedure',
+    '---',
+    '',
+    '# API Conventions',
+    '',
+    '_Staged by `src/scripts/bootstrap_knowledge.ts` as an EMPTY seed — API shapes',
+    'are learned from real request/response observation (`api_shape_learned`',
+    'events), which this deterministic bootstrap never fabricates._',
+    '',
+    '`[HUMAN: verify]` — this page fills in as `api_shape_learned` events',
+    'consolidate, or via manual documentation.',
+    '',
+].join('\n');
+
+const COMMON_MISTAKES_PAGE = [
+    '---',
+    'type: session',
+    '---',
+    '',
+    '# Common Mistakes',
+    '',
+    '_Staged by `src/scripts/bootstrap_knowledge.ts` as an EMPTY seed — this fills',
+    'in from `mistake_made` events as the team works, never fabricated up front._',
+    '',
+].join('\n');
+
+export function stagePages(root: string, stagingDir: string): void {
+    const result = detect(root);
+    fs.mkdirSync(path.join(stagingDir, 'concepts'), { recursive: true });
+    fs.mkdirSync(path.join(stagingDir, 'procedures'), { recursive: true });
+    fs.mkdirSync(path.join(stagingDir, 'sessions'), { recursive: true });
+
+    fs.writeFileSync(path.join(stagingDir, 'concepts', 'structure.md'), renderStructurePage(result), 'utf8');
+    fs.writeFileSync(path.join(stagingDir, 'concepts', 'standards.md'), renderStandardsPage(result), 'utf8');
+    fs.writeFileSync(path.join(stagingDir, 'concepts', 'modules.md'), MODULES_PAGE, 'utf8');
+    fs.writeFileSync(path.join(stagingDir, 'procedures', 'api-conventions.md'), API_CONVENTIONS_PAGE, 'utf8');
+    fs.writeFileSync(path.join(stagingDir, 'sessions', 'common-mistakes.md'), COMMON_MISTAKES_PAGE, 'utf8');
+}
+
+function printUsage(): void {
+    process.stdout.write(`usage: ${PROG} [--dir DIR] [--staging-dir DIR]\n`);
+}
+
+export function main(argv: string[]): number {
+    let dir = process.cwd();
+    let stagingDir = DEFAULT_STAGING_DIR;
+
+    for (let i = 0; i < argv.length; i++) {
+        const arg = argv[i];
+        if (arg === '-h' || arg === '--help') {
+            printUsage();
+            return 0;
+        } else if (arg === '--dir') {
+            dir = argv[++i] ?? dir;
+        } else if (arg === '--staging-dir') {
+            stagingDir = argv[++i] ?? stagingDir;
+        } else {
+            process.stderr.write(`${PROG}: error: unrecognized argument: ${arg}\n`);
+            printUsage();
+            return 1;
+        }
+    }
+
+    stagePages(dir, stagingDir);
+    process.stdout.write(
+        `${PROG}: staged 5 template page(s) under ${stagingDir}/ — review before moving into agents/knowledge/.\n`,
+    );
+    return 0;
+}
+
+if (fileURLToPath(import.meta.url) === path.resolve(process.argv[1] ?? '')) {
+    process.exit(main(process.argv.slice(2)));
+}

package/src/scripts/build_discovery_manifest.ts

@@ -152,7 +152,7 @@ const _TRUST_REQ = ['level', 'confidence', 'human_review_required'] as const;
 const _INSTALL_REQ = ['default', 'removable'] as const;
 const _LIFECYCLE_VALUES = ['active', 'experimental', 'deprecated', 'archived'] as const;
 const _TRUST_VALUES = ['core', 'professional', 'experimental', 'advisory', 'restricted'] as const;
-const _CATEGORY_VALUES = ['skill', 'rule', 'command', 'template'] as const;
+const _CATEGORY_VALUES = ['skill', 'rule', 'command', 'template', 'subagent'] as const;
 
 // build_discovery_manifest._FRONTMATTER_RE (imported from validate_frontmatter
 // in Python; the literal pattern is `^---\n(.*?)\n---\n` with re.DOTALL).
@@ -164,6 +164,7 @@ const _CATEGORY_SCHEMA: Record<string, string> = {
     skill: 'skill',
     rule: 'rule',
     command: 'command',
+    subagent: 'subagent',
 };
 
 // --- Filesystem helpers reproducing pathlib semantics ------------------------
@@ -414,6 +415,14 @@ function* _iter_artefacts(): Generator<[string, string]> {
         }
         yield [p, 'template'];
     }
+    // ADR-109: subagents are the 5th discovery category. Appended last so the
+    // existing skills→rules→commands→templates ordering is undisturbed. They
+    // carry the minimal subagent-v1 schema (no workspaces/packs/install); the
+    // `_classify` subagent branch derives the manifest payload (default-off,
+    // packs:[]) — static projection only, never runtime-dispatched.
+    for (const p of _collect('subagents', '*.md')) {
+        yield [p, 'subagent'];
+    }
 }
 
 function _trusted(p: string): boolean {
@@ -450,10 +459,41 @@ function _classify(
     fm: JsonObject | null,
     wsIds: Set<string>,
     packIds: Set<string>,
+    category?: string,
 ): [JsonObject | null, string | null] {
     if (fm === null) {
         return [null, 'missing or unparseable frontmatter'];
     }
+    // ADR-109 (Option B): subagents do NOT carry workspaces/packs/install — their
+    // schema is deliberately minimal and they are default-off, opt-in-by-name
+    // (never pack-scoped). Derive the manifest payload from the subagent-v1
+    // fields instead of the pack/workspace contract. `packs: []` is legitimate
+    // ("recommended for no one"); manifest consumers guard against empty packs.
+    if (category === 'subagent') {
+        const lc = fm['lifecycle'];
+        if (!(_LIFECYCLE_VALUES as readonly Json[]).includes(lc)) {
+            return [null, `lifecycle: invalid value '${String(lc)}'`];
+        }
+        const trust = fm['trust'];
+        if (!_isObject(trust) || _TRUST_REQ.some((k) => !(k in trust))) {
+            return [null, `trust: missing required key(s) ${_pyTupleRepr(_TRUST_REQ)}`];
+        }
+        if (!(_TRUST_VALUES as readonly Json[]).includes(trust['level'])) {
+            return [null, `trust.level: invalid '${String(trust['level'])}'`];
+        }
+        const payload: JsonObject = {
+            workspaces: [],
+            packs: [],
+            lifecycle: lc,
+            trust: {
+                level: trust['level'],
+                confidence: trust['confidence'],
+                human_review_required: trust['human_review_required'],
+            },
+            install: { default: false, removable: true },
+        };
+        return [payload, null];
+    }
     const missing = _FM_KEYS.filter((k) => !(k in fm));
     if (missing.length > 0) {
         return [null, `missing required key(s): ${missing.join(', ')}`];
@@ -596,7 +636,7 @@ function _build(strict: boolean): [JsonObject, JsonObject[]] {
             continue;
         }
         const fm = _parse(p, category);
-        const [payload, reason] = _classify(fm, wsIds, packIds);
+        const [payload, reason] = _classify(fm, wsIds, packIds, category);
         if (reason !== null) {
             unassigned.push({ path: rel, category, reason });
             continue;