code-ai-installer 4.0.0 → 4.0.1-b

package/dist/mcp/tools/_subprocess.js

@@ -0,0 +1,56 @@
+import { spawn } from "node:child_process";
+import { performance } from "node:perf_hooks";
+export function npmCommand() {
+    return process.platform === "win32" ? "npm.cmd" : "npm";
+}
+export async function spawnWithOutput(command, args, opts) {
+    return new Promise((resolve) => {
+        const start = performance.now();
+        let stdout = "";
+        let stderr = "";
+        const env = opts.env ? { ...process.env, ...opts.env } : process.env;
+        // Windows: Node 20+ refuses to spawn .cmd/.bat without a shell (CVE-2024-27980).
+        // `npm` and `npx` are .cmd shims on Windows, so we run through cmd.exe there.
+        // We control args (no untrusted user input), so shell: true is safe here.
+        const useShell = process.platform === "win32";
+        const stdinMode = opts.stdin !== undefined ? "pipe" : "ignore";
+        const proc = spawn(command, args, {
+            cwd: opts.cwd,
+            env,
+            stdio: [stdinMode, "pipe", "pipe"],
+            shell: useShell,
+        });
+        if (opts.stdin !== undefined && proc.stdin) {
+            proc.stdin.write(opts.stdin);
+            proc.stdin.end();
+        }
+        proc.stdout?.on("data", (chunk) => {
+            stdout += chunk.toString("utf8");
+        });
+        proc.stderr?.on("data", (chunk) => {
+            stderr += chunk.toString("utf8");
+        });
+        proc.on("error", (err) => {
+            resolve({
+                exitCode: null,
+                stdout,
+                stderr,
+                durationMs: Math.round(performance.now() - start),
+                spawnError: err,
+            });
+        });
+        proc.on("close", (code) => {
+            resolve({
+                exitCode: code,
+                stdout,
+                stderr,
+                durationMs: Math.round(performance.now() - start),
+            });
+        });
+    });
+}
+export function tail(text, maxBytes) {
+    if (text.length <= maxBytes)
+        return text;
+    return "…" + text.slice(text.length - maxBytes);
+}

package/dist/mcp/tools/advance_gate.js

@@ -1,6 +1,6 @@
 import { getGateConfig, getNextGate, loadPipeline } from "../pipeline.js";
 import { latestSignoff, readTaskState, writeTaskState } from "../task_state.js";
-const DEFAULT_DOMAIN = "development";
+import { resolveActiveDomain } from "../config.js";
 /**
  * Advances the task from `from_gate` to `to_gate`.
  *
@@ -20,7 +20,7 @@ const DEFAULT_DOMAIN = "development";
  * Future call resets dev_rollback_count if pipeline.reset_on includes rg_pass.
  */
 export async function advanceGate(input) {
-    const pipeline = await loadPipeline(DEFAULT_DOMAIN);
+    const pipeline = await loadPipeline(await resolveActiveDomain());
     const state = await readTaskState(input.task_id);
     if (!state) {
         throw new Error(`advance_gate: no task state for ${input.task_id}`);

package/dist/mcp/tools/aggregate_run_metrics.d.ts

@@ -0,0 +1,19 @@
+import type { AggregateRunMetricsInput, AggregateRunMetricsOutput } from "../../shared/index.js";
+/**
+ * Aggregate run scorecards from the local ledger into deterministic per-agent
+ * and per-workflow statistics. Read-only surfacing tool (like
+ * audit_budget_compliance): it reports numbers, it does not judge — judgment is
+ * the Auditor agent's job (a later ADR).
+ *
+ * Attribution: per-AGENT via gate→produced_by[0] from pipeline.yaml (single
+ * source); per-WORKFLOW via mode. Only COMPLETED runs (RG signed) are
+ * aggregated; `min_runs` (default 3) is the design's small-sample guard — below
+ * it `met_threshold=false` and the Auditor should stay silent.
+ *
+ * Honest gaps surfaced in `notes`, not faked: skill invocations ARE captured as
+ * per_skill (incl. the gates a skill was pulled at) via get_skill instrumentation
+ * (ADR-DEV-121) — the remaining gap is trigger_accuracy (relevant-vs-invoked),
+ * which needs a relevance oracle; no explicit human-rejection signal; completed =
+ * RG signed (completed_at unset).
+ */
+export declare function aggregateRunMetrics(input: AggregateRunMetricsInput): Promise<AggregateRunMetricsOutput>;

package/dist/mcp/tools/aggregate_run_metrics.js

@@ -0,0 +1,139 @@
+import { loadPipeline } from "../pipeline.js";
+import { readLedger } from "../audit_ledger.js";
+import { resolveActiveDomain } from "../config.js";
+/**
+ * Aggregate run scorecards from the local ledger into deterministic per-agent
+ * and per-workflow statistics. Read-only surfacing tool (like
+ * audit_budget_compliance): it reports numbers, it does not judge — judgment is
+ * the Auditor agent's job (a later ADR).
+ *
+ * Attribution: per-AGENT via gate→produced_by[0] from pipeline.yaml (single
+ * source); per-WORKFLOW via mode. Only COMPLETED runs (RG signed) are
+ * aggregated; `min_runs` (default 3) is the design's small-sample guard — below
+ * it `met_threshold=false` and the Auditor should stay silent.
+ *
+ * Honest gaps surfaced in `notes`, not faked: skill invocations ARE captured as
+ * per_skill (incl. the gates a skill was pulled at) via get_skill instrumentation
+ * (ADR-DEV-121) — the remaining gap is trigger_accuracy (relevant-vs-invoked),
+ * which needs a relevance oracle; no explicit human-rejection signal; completed =
+ * RG signed (completed_at unset).
+ */
+export async function aggregateRunMetrics(input) {
+    const minRuns = input.min_runs;
+    const cards = await readLedger();
+    const completed = cards.filter((c) => c.completed);
+    // gate → owning role, from pipeline.yaml (first produced_by per gate).
+    const pipeline = await loadPipeline(await resolveActiveDomain());
+    const gateRole = new Map();
+    for (const m of pipeline.modes) {
+        for (const g of m.gates) {
+            if (!gateRole.has(g.gate) && g.produced_by.length > 0) {
+                gateRole.set(g.gate, g.produced_by[0]);
+            }
+        }
+    }
+    // ── per-workflow (mode) ──
+    const wf = new Map();
+    for (const c of completed) {
+        const e = wf.get(c.mode) ?? { runs: 0, completed: 0, rollbacks: 0, cb: 0, exceptions: 0 };
+        e.runs++;
+        e.completed++;
+        e.rollbacks += c.dev_rollback_count;
+        e.cb += c.circuit_breaker_tripped ? 1 : 0;
+        e.exceptions += c.exceptions_count;
+        wf.set(c.mode, e);
+    }
+    const per_workflow = [...wf.entries()].sort().map(([mode, e]) => ({
+        mode: mode,
+        runs: e.runs,
+        completed: e.completed,
+        avg_dev_rollbacks: round2(e.rollbacks / e.runs),
+        circuit_breaker_trips: e.cb,
+        total_exceptions: e.exceptions,
+    }));
+    const agents = new Map();
+    for (const c of completed) {
+        for (const g of c.gates) {
+            const role = gateRole.get(g.gate) ?? "unknown";
+            const key = `${role}|${g.gate}`;
+            const a = agents.get(key) ??
+                {
+                    role,
+                    gate: g.gate,
+                    runs_involved: 0,
+                    reworked: 0,
+                    exceptions: 0,
+                    auto_resolve: 0,
+                    fork: 0,
+                    exception: 0,
+                };
+            a.runs_involved++;
+            if (g.signoff_count > 1)
+                a.reworked++;
+            a.exceptions += g.exceptions_count;
+            if (g.classification === "auto_resolve")
+                a.auto_resolve++;
+            else if (g.classification === "fork")
+                a.fork++;
+            else if (g.classification === "exception")
+                a.exception++;
+            agents.set(key, a);
+        }
+    }
+    const per_agent = [...agents.values()]
+        .sort((x, y) => (x.role + x.gate).localeCompare(y.role + y.gate))
+        .map((a) => ({
+        role: a.role,
+        gate: a.gate,
+        runs_involved: a.runs_involved,
+        reworked: a.reworked,
+        first_try_rate: round2((a.runs_involved - a.reworked) / a.runs_involved),
+        exceptions: a.exceptions,
+        classification_breakdown: {
+            auto_resolve: a.auto_resolve,
+            fork: a.fork,
+            exception: a.exception,
+        },
+    }));
+    // ── per-skill (invocation frequency + gate/run co-occurrence) ──
+    const skills = new Map();
+    for (const c of completed) {
+        for (const s of c.skill_invocations) {
+            const a = skills.get(s.skill) ??
+                { skill: s.skill, invocations: 0, runs: new Set(), gates: new Set() };
+            a.invocations += s.count;
+            a.runs.add(c.task_id);
+            if (s.gate)
+                a.gates.add(s.gate);
+            skills.set(s.skill, a);
+        }
+    }
+    const per_skill = [...skills.values()]
+        .sort((x, y) => x.skill.localeCompare(y.skill))
+        .map((a) => ({
+        skill: a.skill,
+        invocations: a.invocations,
+        runs_invoked_in: a.runs.size,
+        gates: [...a.gates].sort(),
+    }));
+    const notes = [
+        "completed = RG sign-off present (state machine does not populate completed_at).",
+        "Skill invocations ARE captured (get_skill instrumentation, ADR-DEV-121): per_skill carries invocation counts + the gates each skill was pulled at, so skill.gates can be tuned to observed usage. The remaining gap is trigger_accuracy (relevant-vs-invoked), which needs a relevance oracle — not this data layer.",
+        "No explicit human gate-rejection signal; rejections manifest as rollbacks/exceptions.",
+        "Per-agent attribution uses gate→produced_by[0] from the active domain's pipeline.yaml.",
+        "Skill invocation = a get_skill fetch tied to a run (proxy: a skill applied from memory without re-fetching is invisible). trigger_accuracy (relevant-vs-invoked) is the Auditor agent's judgment — needs a relevance oracle, not in this data layer.",
+    ];
+    return {
+        runs_in_ledger: cards.length,
+        runs_completed: completed.length,
+        min_runs: minRuns,
+        met_threshold: completed.length >= minRuns,
+        per_workflow,
+        per_agent,
+        per_skill,
+        notes,
+    };
+}
+function round2(n) {
+    return Number.isFinite(n) ? Math.round(n * 100) / 100 : 0;
+}

package/dist/mcp/tools/apply_diff.d.ts

@@ -0,0 +1,2 @@
+import { type ApplyDiffInput, type ApplyDiffOutput } from "../../shared/index.js";
+export declare function applyDiff(input: ApplyDiffInput): Promise<ApplyDiffOutput>;

package/dist/mcp/tools/apply_diff.js

@@ -0,0 +1,29 @@
+import { spawnWithOutput, tail } from "./_subprocess.js";
+const GIT = process.platform === "win32" ? "git.exe" : "git";
+export async function applyDiff(input) {
+    const cwd = input.cwd ?? process.cwd();
+    const apply = await spawnWithOutput(GIT, ["apply", "--whitespace=nowarn", "-"], {
+        cwd,
+        stdin: input.diff,
+    });
+    if (apply.exitCode !== 0) {
+        throw new Error(`git apply failed (exit=${apply.exitCode}): ${tail(apply.stderr, 2000) || tail(apply.stdout, 2000)}`);
+    }
+    const status = await spawnWithOutput(GIT, ["status", "--porcelain"], { cwd });
+    if (status.exitCode !== 0) {
+        throw new Error(`git status failed after apply (exit=${status.exitCode}): ${tail(status.stderr, 1000)}`);
+    }
+    const files = parsePorcelain(status.stdout);
+    return { files_changed: files };
+}
+function parsePorcelain(out) {
+    const lines = out.split(/\r?\n/).filter((l) => l.length > 0);
+    const seen = new Set();
+    for (const line of lines) {
+        const rest = line.slice(3);
+        const arrow = rest.indexOf(" -> ");
+        const path = arrow >= 0 ? rest.slice(arrow + 4) : rest;
+        seen.add(path);
+    }
+    return [...seen].sort();
+}

package/dist/mcp/tools/audit_bilocale_parity.d.ts

@@ -0,0 +1,2 @@
+import { type AuditBilocaleParityInput, type AuditBilocaleParityOutput } from "../../shared/index.js";
+export declare function auditBilocaleParity(input: AuditBilocaleParityInput): Promise<AuditBilocaleParityOutput>;

package/dist/mcp/tools/audit_bilocale_parity.js

@@ -0,0 +1,146 @@
+import { readdir, readFile } from "node:fs/promises";
+import { join } from "node:path";
+import { DomainId, } from "../../shared/index.js";
+import { resolveDomainRoot } from "../paths.js";
+import { countLines, parseDeclaredBudget } from "./audit_budget_compliance.js";
+export async function auditBilocaleParity(input) {
+    const domains = input.domain === "*" ? [...DomainId.options] : [input.domain];
+    const declared_mismatches = [];
+    const actual_mismatches = [];
+    const orphans = [];
+    let pairsScanned = 0;
+    let agentsScanned = 0;
+    let skillsScanned = 0;
+    for (const domain of domains) {
+        const r = await scanDomain(domain);
+        declared_mismatches.push(...r.declared_mismatches);
+        actual_mismatches.push(...r.actual_mismatches);
+        orphans.push(...r.orphans);
+        pairsScanned += r.pairs;
+        agentsScanned += r.agents;
+        skillsScanned += r.skills;
+    }
+    return {
+        declared_mismatches,
+        actual_mismatches,
+        orphans,
+        scanned: { pairs: pairsScanned, agents: agentsScanned, skills: skillsScanned },
+    };
+}
+async function scanDomain(domain) {
+    const domainRoot = resolveDomainRoot(domain);
+    const pairs = await collectPairs(domainRoot);
+    const declared_mismatches = [];
+    const actual_mismatches = [];
+    const orphans = [];
+    let agentsScanned = 0;
+    let skillsScanned = 0;
+    for (const p of pairs) {
+        if (p.kind === "agent")
+            agentsScanned++;
+        else
+            skillsScanned++;
+        if (p.ru_abs === null || p.en_abs === null) {
+            const present_locale = p.ru_abs === null ? "en" : "ru";
+            const present_path = p.ru_abs === null ? p.en_rel_path : p.ru_rel_path;
+            const missing_locale = p.ru_abs === null ? "ru" : "en";
+            orphans.push({
+                domain,
+                id: p.id,
+                file_type: p.kind,
+                present_locale,
+                present_path,
+                missing_locale,
+                message: `${p.kind} '${p.id}' exists only in ${present_locale} (${present_path}); no ${missing_locale} sibling`,
+            });
+            continue;
+        }
+        const ruRaw = await readFile(p.ru_abs, "utf8").catch(() => null);
+        const enRaw = await readFile(p.en_abs, "utf8").catch(() => null);
+        if (ruRaw === null || enRaw === null)
+            continue;
+        const ruDeclared = parseDeclaredBudget(ruRaw);
+        const enDeclared = parseDeclaredBudget(enRaw);
+        if (ruDeclared !== null && enDeclared !== null && ruDeclared !== enDeclared) {
+            declared_mismatches.push({
+                domain,
+                id: p.id,
+                file_type: p.kind,
+                ru_path: p.ru_rel_path,
+                en_path: p.en_rel_path,
+                ru_declared: ruDeclared,
+                en_declared: enDeclared,
+                message: `${p.kind} '${p.id}' declares budget_lines=${ruDeclared} (ru) vs ${enDeclared} (en)`,
+            });
+        }
+        const ruActual = countLines(ruRaw);
+        const enActual = countLines(enRaw);
+        if (ruActual !== enActual) {
+            actual_mismatches.push({
+                domain,
+                id: p.id,
+                file_type: p.kind,
+                ru_path: p.ru_rel_path,
+                en_path: p.en_rel_path,
+                ru_actual: ruActual,
+                en_actual: enActual,
+                diff: ruActual - enActual,
+                message: `${p.kind} '${p.id}' has ${ruActual} lines (ru) vs ${enActual} lines (en) (diff=${ruActual - enActual})`,
+            });
+        }
+    }
+    return {
+        declared_mismatches,
+        actual_mismatches,
+        orphans,
+        pairs: pairs.length,
+        agents: agentsScanned,
+        skills: skillsScanned,
+    };
+}
+async function collectPairs(domainRoot) {
+    const pairs = [];
+    // Agents: pair by filename across agents/ (ru) and locales/en/agents/ (en).
+    const ruAgentsDir = join(domainRoot, "agents");
+    const enAgentsDir = join(domainRoot, "locales", "en", "agents");
+    const ruAgents = new Set(await listMdFiles(ruAgentsDir));
+    const enAgents = new Set(await listMdFiles(enAgentsDir));
+    for (const f of union(ruAgents, enAgents)) {
+        pairs.push({
+            kind: "agent",
+            id: f,
+            ru_rel_path: `agents/${f}`,
+            en_rel_path: `locales/en/agents/${f}`,
+            ru_abs: ruAgents.has(f) ? join(ruAgentsDir, f) : null,
+            en_abs: enAgents.has(f) ? join(enAgentsDir, f) : null,
+        });
+    }
+    // Skills: pair by skill-dir name across .agents/skills/ (ru) and
+    // locales/en/.agents/skills/ (en). SKILL.md is the file inside each dir.
+    const ruSkillsRoot = join(domainRoot, ".agents", "skills");
+    const enSkillsRoot = join(domainRoot, "locales", "en", ".agents", "skills");
+    const ruSkills = new Set(await listSubdirs(ruSkillsRoot));
+    const enSkills = new Set(await listSubdirs(enSkillsRoot));
+    for (const d of union(ruSkills, enSkills)) {
+        pairs.push({
+            kind: "skill",
+            id: d,
+            ru_rel_path: `.agents/skills/${d}/SKILL.md`,
+            en_rel_path: `locales/en/.agents/skills/${d}/SKILL.md`,
+            ru_abs: ruSkills.has(d) ? join(ruSkillsRoot, d, "SKILL.md") : null,
+            en_abs: enSkills.has(d) ? join(enSkillsRoot, d, "SKILL.md") : null,
+        });
+    }
+    return pairs;
+}
+function union(a, b) {
+    return [...new Set([...a, ...b])].sort();
+}
+async function listMdFiles(dir) {
+    const entries = await readdir(dir, { withFileTypes: true }).catch(() => []);
+    return entries.filter((e) => e.isFile() && e.name.endsWith(".md")).map((e) => e.name);
+}
+async function listSubdirs(dir) {
+    const entries = await readdir(dir, { withFileTypes: true }).catch(() => []);
+    return entries.filter((e) => e.isDirectory()).map((e) => e.name);
+}

package/dist/mcp/tools/audit_budget_compliance.d.ts

@@ -0,0 +1,35 @@
+import { type AuditBudgetComplianceInput, type AuditBudgetComplianceOutput } from "../../shared/index.js";
+/**
+ * Audit two classes of budget violations across agent.md + SKILL.md files:
+ *
+ *   1. SCHEMA CAP — declared `budget_lines` in frontmatter exceeds the schema
+ *      maximum (RoleFrontmatter: 500, SkillFrontmatter: 800). When this
+ *      happens, RoleFrontmatter / SkillFrontmatter safeParse silently rejects
+ *      the whole frontmatter; load_role / list_skills / get_skill then fall
+ *      back to H1-synthesized stubs. This was the DEV-107 latent bug.
+ *
+ *   2. BUDGET EXCEEDED — actual file line count exceeds the declared
+ *      `budget_lines`. Nothing enforces this today; files can silently grow.
+ *
+ * Scans both RU canonical and EN sidecar locales. Each file declares its own
+ * budget_lines, so they are audited independently.
+ */
+/**
+ * Count lines the way an editor / `wc -l` does: a trailing newline terminates
+ * the final line, it does not create a phantom empty line. A file with no
+ * trailing newline still counts its final unterminated line.
+ *
+ * Fixes an off-by-one where `raw.split(/\r?\n/).length` counted the empty
+ * segment after the final newline — inflating every file's line count by 1 and
+ * falsely flagging files that sit exactly at their declared budget.
+ */
+export declare function countLines(raw: string): number;
+/**
+ * Parse the declared `budget_lines` from a file's frontmatter. Returns null when
+ * there is no frontmatter block, the YAML is malformed, or budget_lines is
+ * absent / non-numeric — callers skip such files. Shared with
+ * audit_bilocale_parity so both tools read declared budgets identically
+ * (single source, ADR-DEV-116; same spirit as the DEV-115 schema-cap exports).
+ */
+export declare function parseDeclaredBudget(raw: string): number | null;
+export declare function auditBudgetCompliance(input: AuditBudgetComplianceInput): Promise<AuditBudgetComplianceOutput>;

package/dist/mcp/tools/audit_budget_compliance.js

@@ -0,0 +1,172 @@
+import { readdir, readFile } from "node:fs/promises";
+import { join } from "node:path";
+import { parse as parseYaml } from "yaml";
+import { DomainId, ROLE_BUDGET_LINES_MAX, SKILL_BUDGET_LINES_MAX, } from "../../shared/index.js";
+import { resolveDomainRoot } from "../paths.js";
+/**
+ * Audit two classes of budget violations across agent.md + SKILL.md files:
+ *
+ *   1. SCHEMA CAP — declared `budget_lines` in frontmatter exceeds the schema
+ *      maximum (RoleFrontmatter: 500, SkillFrontmatter: 800). When this
+ *      happens, RoleFrontmatter / SkillFrontmatter safeParse silently rejects
+ *      the whole frontmatter; load_role / list_skills / get_skill then fall
+ *      back to H1-synthesized stubs. This was the DEV-107 latent bug.
+ *
+ *   2. BUDGET EXCEEDED — actual file line count exceeds the declared
+ *      `budget_lines`. Nothing enforces this today; files can silently grow.
+ *
+ * Scans both RU canonical and EN sidecar locales. Each file declares its own
+ * budget_lines, so they are audited independently.
+ */
+/**
+ * Count lines the way an editor / `wc -l` does: a trailing newline terminates
+ * the final line, it does not create a phantom empty line. A file with no
+ * trailing newline still counts its final unterminated line.
+ *
+ * Fixes an off-by-one where `raw.split(/\r?\n/).length` counted the empty
+ * segment after the final newline — inflating every file's line count by 1 and
+ * falsely flagging files that sit exactly at their declared budget.
+ */
+export function countLines(raw) {
+    if (raw === "")
+        return 0;
+    const body = raw.replace(/\r?\n$/, "");
+    return body.split(/\r?\n/).length;
+}
+/**
+ * Parse the declared `budget_lines` from a file's frontmatter. Returns null when
+ * there is no frontmatter block, the YAML is malformed, or budget_lines is
+ * absent / non-numeric — callers skip such files. Shared with
+ * audit_bilocale_parity so both tools read declared budgets identically
+ * (single source, ADR-DEV-116; same spirit as the DEV-115 schema-cap exports).
+ */
+export function parseDeclaredBudget(raw) {
+    const stripped = raw.startsWith("") ? raw.slice(1) : raw;
+    const m = stripped.match(/^---\r?\n([\s\S]*?)\r?\n---/);
+    if (!m)
+        return null;
+    let parsedYaml;
+    try {
+        parsedYaml = parseYaml(m[1]);
+    }
+    catch {
+        return null;
+    }
+    const declaredRaw = parsedYaml?.budget_lines;
+    return typeof declaredRaw === "number" ? declaredRaw : null;
+}
+export async function auditBudgetCompliance(input) {
+    const domains = input.domain === "*" ? [...DomainId.options] : [input.domain];
+    const schema_violations = [];
+    const budget_violations = [];
+    let agentsScanned = 0;
+    let skillsScanned = 0;
+    for (const domain of domains) {
+        const r = await scanDomain(domain);
+        schema_violations.push(...r.schema_violations);
+        budget_violations.push(...r.budget_violations);
+        agentsScanned += r.agents;
+        skillsScanned += r.skills;
+    }
+    return {
+        schema_violations,
+        budget_violations,
+        scanned: { agents: agentsScanned, skills: skillsScanned },
+    };
+}
+async function scanDomain(domain) {
+    const domainRoot = resolveDomainRoot(domain);
+    const targets = await collectTargets(domainRoot);
+    const schema_violations = [];
+    const budget_violations = [];
+    let agentsScanned = 0;
+    let skillsScanned = 0;
+    for (const t of targets) {
+        const raw = await readFile(t.abs_path, "utf8").catch(() => null);
+        if (raw === null)
+            continue;
+        if (t.kind === "agent")
+            agentsScanned++;
+        else
+            skillsScanned++;
+        const declared = parseDeclaredBudget(raw);
+        if (declared === null)
+            continue;
+        const schemaMax = t.kind === "agent" ? ROLE_BUDGET_LINES_MAX : SKILL_BUDGET_LINES_MAX;
+        if (declared > schemaMax) {
+            schema_violations.push({
+                domain,
+                file: t.rel_path,
+                file_type: t.kind,
+                declared_budget: declared,
+                schema_max: schemaMax,
+                message: `${t.kind} '${t.rel_path}' declares budget_lines=${declared} which exceeds schema cap ${schemaMax}; safeParse will silently fall back`,
+            });
+            // Skip budget-exceeded check when declared itself is rejected.
+            continue;
+        }
+        const actual = countLines(raw);
+        if (actual > declared) {
+            budget_violations.push({
+                domain,
+                file: t.rel_path,
+                file_type: t.kind,
+                declared_budget: declared,
+                actual_lines: actual,
+                overage: actual - declared,
+                message: `${t.kind} '${t.rel_path}' has ${actual} lines but declares budget_lines=${declared} (overage=${actual - declared})`,
+            });
+        }
+    }
+    return { schema_violations, budget_violations, agents: agentsScanned, skills: skillsScanned };
+}
+async function collectTargets(domainRoot) {
+    const result = [];
+    const ruAgentsDir = join(domainRoot, "agents");
+    for (const f of await listMdFiles(ruAgentsDir)) {
+        result.push({
+            locale: "ru",
+            kind: "agent",
+            abs_path: join(ruAgentsDir, f),
+            rel_path: `agents/${f}`,
+        });
+    }
+    const enAgentsDir = join(domainRoot, "locales", "en", "agents");
+    for (const f of await listMdFiles(enAgentsDir)) {
+        result.push({
+            locale: "en",
+            kind: "agent",
+            abs_path: join(enAgentsDir, f),
+            rel_path: `locales/en/agents/${f}`,
+        });
+    }
+    const ruSkillsRoot = join(domainRoot, ".agents", "skills");
+    for (const d of await listSubdirs(ruSkillsRoot)) {
+        result.push({
+            locale: "ru",
+            kind: "skill",
+            abs_path: join(ruSkillsRoot, d, "SKILL.md"),
+            rel_path: `.agents/skills/${d}/SKILL.md`,
+        });
+    }
+    const enSkillsRoot = join(domainRoot, "locales", "en", ".agents", "skills");
+    for (const d of await listSubdirs(enSkillsRoot)) {
+        result.push({
+            locale: "en",
+            kind: "skill",
+            abs_path: join(enSkillsRoot, d, "SKILL.md"),
+            rel_path: `locales/en/.agents/skills/${d}/SKILL.md`,
+        });
+    }
+    return result;
+}
+async function listMdFiles(dir) {
+    const entries = await readdir(dir, { withFileTypes: true }).catch(() => []);
+    return entries
+        .filter((e) => e.isFile() && e.name.endsWith(".md"))
+        .map((e) => e.name);
+}
+async function listSubdirs(dir) {
+    const entries = await readdir(dir, { withFileTypes: true }).catch(() => []);
+    return entries.filter((e) => e.isDirectory()).map((e) => e.name);
+}

package/dist/mcp/tools/build.d.ts

@@ -0,0 +1,2 @@
+import { type BuildInput, type BuildOutput } from "../../shared/index.js";
+export declare function build(input: BuildInput): Promise<BuildOutput>;

package/dist/mcp/tools/build.js

@@ -0,0 +1,47 @@
+import { npmCommand, spawnWithOutput, tail } from "./_subprocess.js";
+const TSC_LINE = /^(.+?)\((\d+),(\d+)\):\s+error\s+(TS\d+):\s+(.+)$/gm;
+export async function build(input) {
+    const cwd = input.cwd ?? process.cwd();
+    const result = await spawnWithOutput(npmCommand(), ["run", "build"], { cwd });
+    if (result.exitCode === 0) {
+        return { succeeded: true, errors: [] };
+    }
+    const tscErrors = parseTscErrors(`${result.stdout}\n${result.stderr}`);
+    if (tscErrors.length > 0) {
+        return { succeeded: false, errors: tscErrors };
+    }
+    return {
+        succeeded: false,
+        errors: [
+            {
+                code: "build-failure",
+                message: `build exited with code ${result.exitCode}`,
+                evidence: {
+                    stdout: tail(result.stdout, 4000),
+                    stderr: tail(result.stderr, 4000),
+                    duration_ms: result.durationMs,
+                    spawnError: result.spawnError?.message,
+                },
+            },
+        ],
+    };
+}
+function parseTscErrors(text) {
+    const out = [];
+    TSC_LINE.lastIndex = 0;
+    for (const m of text.matchAll(TSC_LINE)) {
+        const [, file, line, col, code, msg] = m;
+        const normalizedFile = file.replace(/\\/g, "/");
+        out.push({
+            code: `${code}-${normalizedFile}-L${line}`,
+            message: `${file}(${line},${col}) ${code}: ${msg}`,
+            evidence: {
+                file: normalizedFile,
+                line: Number(line),
+                column: Number(col),
+                tsCode: code,
+            },
+        });
+    }
+    return out;
+}