code-ai-installer 3.0.0 → 4.0.1-a

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

@@ -0,0 +1,33 @@
+import { type RequestDecisionInput, type RequestDecisionOutput } from "../../shared/index.js";
+import { recordDecision } from "./record_decision.js";
+/**
+ * Passthrough decision channel.
+ *
+ * MCP can't prompt the user directly mid-tool-call, so this tool is split into
+ * two parts:
+ *   1. Caller invokes request_decision with question + options. The tool
+ *      validates input but does NOT record an ADR yet. It returns a structured
+ *      "pending" envelope that Claude (the LLM) relays to DEN in chat.
+ *   2. After DEN replies in chat, Claude calls record_decision with the chosen
+ *      option_id + rationale, which writes the ADR atomically (3 places).
+ *
+ * The returned object satisfies the RequestDecisionOutput contract by emitting
+ * a synthetic adr_id like `PENDING-<task_id>-<gate>-<hash>` that Claude is
+ * expected to discard. When the real ADR is written via record_decision, that
+ * tool returns the actual ADR id.
+ *
+ * Future replacement: if Claude Code (or the MCP transport) gains an
+ * `elicitation` primitive, this tool can be reworked to actually block on user
+ * input. The contract above stays valid; only the body changes.
+ */
+export declare function requestDecision(input: RequestDecisionInput): Promise<RequestDecisionOutput>;
+/**
+ * Convenience: convert request_decision output into a record_decision input
+ * once Claude has surfaced the question to DEN and received an answer.
+ * Not part of the MCP surface — use as a helper from the LLM relay flow.
+ */
+export declare function commitRequestedDecision(args: {
+    input: RequestDecisionInput;
+    chosen_option_id: string;
+    rationale: string;
+}): Promise<ReturnType<typeof recordDecision>>;

package/dist/mcp/tools/request_decision.js

@@ -0,0 +1,53 @@
+import { recordDecision } from "./record_decision.js";
+/**
+ * Passthrough decision channel.
+ *
+ * MCP can't prompt the user directly mid-tool-call, so this tool is split into
+ * two parts:
+ *   1. Caller invokes request_decision with question + options. The tool
+ *      validates input but does NOT record an ADR yet. It returns a structured
+ *      "pending" envelope that Claude (the LLM) relays to DEN in chat.
+ *   2. After DEN replies in chat, Claude calls record_decision with the chosen
+ *      option_id + rationale, which writes the ADR atomically (3 places).
+ *
+ * The returned object satisfies the RequestDecisionOutput contract by emitting
+ * a synthetic adr_id like `PENDING-<task_id>-<gate>-<hash>` that Claude is
+ * expected to discard. When the real ADR is written via record_decision, that
+ * tool returns the actual ADR id.
+ *
+ * Future replacement: if Claude Code (or the MCP transport) gains an
+ * `elicitation` primitive, this tool can be reworked to actually block on user
+ * input. The contract above stays valid; only the body changes.
+ */
+export async function requestDecision(input) {
+    const hash = simpleHash(`${input.task_id}|${input.gate}|${input.question}`).toUpperCase();
+    const safeTask = input.task_id.toUpperCase().replace(/[^A-Z0-9-]/g, "");
+    return {
+        chosen_option_id: "__pending__",
+        signer: "den",
+        adr_id: `ADR-PENDING-${safeTask}-${input.gate}-${hash}`,
+        timestamp: new Date().toISOString(),
+    };
+}
+/**
+ * Convenience: convert request_decision output into a record_decision input
+ * once Claude has surfaced the question to DEN and received an answer.
+ * Not part of the MCP surface — use as a helper from the LLM relay flow.
+ */
+export async function commitRequestedDecision(args) {
+    return recordDecision({
+        task_id: args.input.task_id,
+        gate: args.input.gate,
+        question: args.input.question,
+        options: args.input.options,
+        chosen_option_id: args.chosen_option_id,
+        rationale: args.rationale,
+        signer: "den",
+    });
+}
+function simpleHash(s) {
+    let h = 0;
+    for (let i = 0; i < s.length; i++)
+        h = (h * 31 + s.charCodeAt(i)) | 0;
+    return Math.abs(h).toString(16).slice(0, 6);
+}

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

@@ -0,0 +1,17 @@
+import { type ReviewProposalInput, type ReviewProposalOutput } from "../../shared/index.js";
+/**
+ * Authorize a proposal status transition, enforcing the autonomy matrix + toggle.
+ *
+ * 4b is the AUTHORIZATION seam, not the write seam (mirrors sign_off: it authorizes a gate
+ * without doing the gate's work). The actual byte write into the asset is a separate
+ * submit_artifact/edit step the caller performs after approval — see next_step.
+ *
+ * Transitions:
+ *   approve  pending  → approved   (matrix/toggle-gated when decided_by=auditor_auto)
+ *   reject   pending  → rejected
+ *   applied  approved → applied    (bookkeeping marker after the caller wrote the asset)
+ *
+ * Matrix (ADR-DEV-122): auditor_auto may approve only low/additive AND only when the approval
+ * gate is OFF; destructive (high) and gate-ON always require den. den may always act.
+ */
+export declare function reviewProposal(input: ReviewProposalInput): Promise<ReviewProposalOutput>;

package/dist/mcp/tools/review_proposal.js

@@ -0,0 +1,99 @@
+import { loadCodeAiConfig } from "../config.js";
+import { appendReviewEvent, readProposals } from "../proposal_store.js";
+import { readDomainSkillMeta, findOverlaps } from "../proposal_dedup.js";
+/**
+ * Authorize a proposal status transition, enforcing the autonomy matrix + toggle.
+ *
+ * 4b is the AUTHORIZATION seam, not the write seam (mirrors sign_off: it authorizes a gate
+ * without doing the gate's work). The actual byte write into the asset is a separate
+ * submit_artifact/edit step the caller performs after approval — see next_step.
+ *
+ * Transitions:
+ *   approve  pending  → approved   (matrix/toggle-gated when decided_by=auditor_auto)
+ *   reject   pending  → rejected
+ *   applied  approved → applied    (bookkeeping marker after the caller wrote the asset)
+ *
+ * Matrix (ADR-DEV-122): auditor_auto may approve only low/additive AND only when the approval
+ * gate is OFF; destructive (high) and gate-ON always require den. den may always act.
+ */
+export async function reviewProposal(input) {
+    const proposals = await readProposals();
+    const p = proposals.find((x) => x.id === input.id);
+    if (!p) {
+        throw new Error(`review_proposal: no proposal '${input.id}' in the store`);
+    }
+    // Transition validity.
+    if (input.decision === "approve" || input.decision === "reject") {
+        if (p.status !== "pending") {
+            throw new Error(`review_proposal: '${input.id}' is '${p.status}', not 'pending' — cannot ${input.decision}`);
+        }
+    }
+    else {
+        // "applied"
+        if (p.status !== "approved") {
+            throw new Error(`review_proposal: '${input.id}' is '${p.status}', not 'approved' — cannot mark applied`);
+        }
+    }
+    // Matrix + toggle enforcement on the capability-granting direction (approve).
+    if (input.decision === "approve" && input.decided_by === "auditor_auto") {
+        const cfg = await loadCodeAiConfig();
+        if (cfg.auditor.approval_gate) {
+            throw new Error(`review_proposal: approval gate is ON — '${input.id}' requires den approval, not auditor_auto`);
+        }
+        if (p.risk === "high") {
+            throw new Error(`review_proposal: '${input.id}' is high-risk (destructive) — always requires den, even in autonomy`);
+        }
+        // Additive-dedup guard (ADR-DEV-125): before auto-adding a NEW skill, block silent
+        // library bloat — if it overlaps an existing skill, route to den instead of auto-adding.
+        if (p.change_kind === "add_asset" && p.target.asset === "skill") {
+            const skills = await readDomainSkillMeta(p.target.domain);
+            const overlaps = findOverlaps({
+                proposalName: p.target.name,
+                text: `${p.rationale}\n${p.draft}`,
+                skills,
+            });
+            if (overlaps.length > 0) {
+                const summary = overlaps
+                    .map((o) => `${o.skill} (${o.reasons.join("; ")})`)
+                    .join("; ");
+                throw new Error(`review_proposal: '${input.id}' may duplicate existing skill(s) [${summary}] — additive-dedup guard routes it to den, not auto-add`);
+            }
+        }
+    }
+    const status = input.decision === "approve"
+        ? "approved"
+        : input.decision === "reject"
+            ? "rejected"
+            : "applied";
+    await appendReviewEvent({
+        kind: "review",
+        id: input.id,
+        status,
+        decided_by: input.decided_by,
+        ...(input.note !== undefined ? { note: input.note } : {}),
+        reviewed_at: new Date().toISOString(),
+    });
+    return {
+        id: input.id,
+        status,
+        risk: p.risk,
+        decided_by: input.decided_by,
+        target: p.target,
+        next_step: buildNextStep(status, p.target, p.draft, input.decided_by, p.change_kind),
+    };
+}
+/** Mandatory report — every decision (especially autonomous) returns a plain-language next step. */
+function buildNextStep(status, target, draft, decided_by, change_kind) {
+    const who = decided_by === "auditor_auto" ? "Auditor (autonomous)" : "den";
+    const asset = `${target.asset} '${target.name}' in domain '${target.domain}'`;
+    if (status === "approved") {
+        const bloatNote = decided_by === "auditor_auto" && change_kind === "add_asset"
+            ? " NEW ADDITION (autonomous) — passed the dedup guard; tracked for later pruning review."
+            : "";
+        return `Approved by ${who}. Apply the draft to ${asset} via submit_artifact (class=${target.asset === "agent" ? "role" : "skill"}) or a targeted edit, then call review_proposal decision='applied'.${bloatNote} Draft:\n${draft}`;
+    }
+    if (status === "rejected") {
+        return `Rejected by ${who}. No change applied; the proposal stays on record.`;
+    }
+    return `Marked applied by ${who}. The change is now written to ${asset}; the proposal lifecycle is closed.`;
+}

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

@@ -0,0 +1,11 @@
+import { type RunDriftAuditInput, type RunDriftAuditOutput } from "../../shared/index.js";
+/**
+ * Drift audit uses a PERMISSIVE YAML parser — strict SkillFrontmatter
+ * validation (e.g. `owners: z.array(AgentName).min(1)`) would silently skip
+ * the very skills the audit needs to surface. We only require:
+ *   - frontmatter block exists
+ *   - `name` field is a string matching the folder name
+ * Everything else (type, domain, owners empty/missing) is reported, not
+ * rejected.
+ */
+export declare function runDriftAudit(input: RunDriftAuditInput): Promise<RunDriftAuditOutput>;

package/dist/mcp/tools/run_drift_audit.js

@@ -0,0 +1,79 @@
+import { readdir, readFile } from "node:fs/promises";
+import { join } from "node:path";
+import { parse as parseYaml } from "yaml";
+import { resolveDomainRoot, resolveSkillsRoot } from "../paths.js";
+/**
+ * Drift audit uses a PERMISSIVE YAML parser — strict SkillFrontmatter
+ * validation (e.g. `owners: z.array(AgentName).min(1)`) would silently skip
+ * the very skills the audit needs to surface. We only require:
+ *   - frontmatter block exists
+ *   - `name` field is a string matching the folder name
+ * Everything else (type, domain, owners empty/missing) is reported, not
+ * rejected.
+ */
+export async function runDriftAudit(input) {
+    const domainRoot = resolveDomainRoot(input.domain);
+    const agentsYamlPath = join(domainRoot, "AGENTS.yaml");
+    const yamlList = await readSkillsFromAgentsYaml(agentsYamlPath);
+    const { onDisk, unowned } = await scanSkillsFromDisk(input.domain);
+    const yamlSet = new Set(yamlList);
+    const diskSet = new Set(onDisk);
+    const orphan_skills = yamlList.filter((s) => !diskSet.has(s)).sort();
+    const phantom_skills = onDisk.filter((s) => !yamlSet.has(s)).sort();
+    return {
+        orphan_skills,
+        phantom_skills,
+        yaml_skew: [],
+        unowned: unowned.sort(),
+        missing_backlinks: [],
+    };
+}
+async function readSkillsFromAgentsYaml(file) {
+    const raw = await readFile(file, "utf8").catch(() => "");
+    if (!raw)
+        return [];
+    let parsed;
+    try {
+        parsed = parseYaml(raw);
+    }
+    catch {
+        return [];
+    }
+    const skills = parsed?.skills;
+    return Array.isArray(skills) ? [...skills] : [];
+}
+async function scanSkillsFromDisk(domain) {
+    const root = resolveSkillsRoot(domain);
+    const entries = await readdir(root, { withFileTypes: true }).catch(() => []);
+    const onDisk = [];
+    const unowned = [];
+    for (const entry of entries) {
+        if (!entry.isDirectory())
+            continue;
+        const file = join(root, entry.name, "SKILL.md");
+        const raw = await readFile(file, "utf8").catch(() => null);
+        if (!raw)
+            continue;
+        const stripped = raw.startsWith("") ? raw.slice(1) : raw;
+        const m = stripped.match(/^---\r?\n([\s\S]*?)\r?\n---/);
+        if (!m)
+            continue;
+        let parsed;
+        try {
+            parsed = parseYaml(m[1]);
+        }
+        catch {
+            continue;
+        }
+        const obj = parsed;
+        const name = obj?.name;
+        if (typeof name !== "string" || name !== entry.name)
+            continue;
+        onDisk.push(name);
+        const owners = obj?.owners;
+        if (!Array.isArray(owners) || owners.length === 0) {
+            unowned.push(name);
+        }
+    }
+    return { onDisk, unowned };
+}

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

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

package/dist/mcp/tools/run_tests.js

@@ -0,0 +1,92 @@
+import { randomUUID } from "node:crypto";
+import { tmpdir } from "node:os";
+import { join } from "node:path";
+import { readFile, unlink } from "node:fs/promises";
+import { npmCommand, spawnWithOutput, tail } from "./_subprocess.js";
+export async function runTests(input) {
+    const cwd = input.cwd ?? process.cwd();
+    const outFile = join(tmpdir(), `code-ai-vitest-${randomUUID()}.json`);
+    const args = ["test", "--", "--reporter=json", `--outputFile=${outFile}`];
+    if (input.filter)
+        args.push(input.filter);
+    const result = await spawnWithOutput(npmCommand(), args, { cwd });
+    let raw = null;
+    try {
+        raw = await readFile(outFile, "utf8");
+        await unlink(outFile).catch(() => undefined);
+    }
+    catch {
+        // no JSON file — subprocess crashed before writing
+    }
+    if (raw === null) {
+        return {
+            passed: 0,
+            failed: 0,
+            duration_ms: result.durationMs,
+            failures: [
+                {
+                    code: "subprocess-error",
+                    message: `npm test did not produce a vitest JSON report (exit=${result.exitCode})`,
+                    evidence: {
+                        stderr: tail(result.stderr, 2000),
+                        stdout: tail(result.stdout, 2000),
+                        spawnError: result.spawnError?.message,
+                    },
+                },
+            ],
+        };
+    }
+    let report;
+    try {
+        report = JSON.parse(raw);
+    }
+    catch (err) {
+        return {
+            passed: 0,
+            failed: 0,
+            duration_ms: result.durationMs,
+            failures: [
+                {
+                    code: "json-parse-error",
+                    message: `Failed to parse vitest JSON report: ${err.message}`,
+                    evidence: { raw: raw.slice(0, 500) },
+                },
+            ],
+        };
+    }
+    return mapReport(report, result.durationMs);
+}
+function mapReport(report, durationMs) {
+    const failures = [];
+    const totalTests = report.numTotalTests ?? 0;
+    if (totalTests === 0 && report.success === false) {
+        failures.push({
+            code: "no-tests-found",
+            message: "vitest ran but found no test files in this project",
+        });
+    }
+    for (const file of report.testResults ?? []) {
+        for (const assertion of file.assertionResults ?? []) {
+            if (assertion.status === "failed") {
+                const title = assertion.fullName ??
+                    [...(assertion.ancestorTitles ?? []), assertion.title ?? ""].filter(Boolean).join(" > ");
+                const message = (assertion.failureMessages?.[0] ?? "(no failure message)").split("\n")[0] ?? "";
+                failures.push({
+                    code: "test-failed",
+                    message: `${file.name ?? "<unknown>"} > ${title}: ${message}`,
+                    evidence: {
+                        file: file.name,
+                        title,
+                        failureMessages: assertion.failureMessages,
+                    },
+                });
+            }
+        }
+    }
+    return {
+        passed: report.numPassedTests ?? 0,
+        failed: report.numFailedTests ?? 0,
+        duration_ms: durationMs,
+        failures,
+    };
+}

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

@@ -0,0 +1,14 @@
+import { type SignOffInput, type SignOffOutput } from "../../shared/index.js";
+/**
+ * Records a sign-off event for the task's current gate. Validates that:
+ *   1. Task exists and is at the named gate.
+ *   2. Signer matches sign_off_policy:
+ *        sign_off_policy=den            → signer must be "den"
+ *        sign_off_policy=mcp_auto_pass  → signer must be "mcp"
+ *        sign_off_policy=either         → signer must be "den" or "mcp"
+ *   3. Gate has a classification recorded if classify_required=true.
+ *
+ * Does NOT advance the gate — that's advance_gate's job. sign_off only
+ * records evidence; advance_gate gates on it.
+ */
+export declare function signOff(input: SignOffInput): Promise<SignOffOutput>;

package/dist/mcp/tools/sign_off.js

@@ -0,0 +1,70 @@
+import { getGateConfig, loadPipeline } from "../pipeline.js";
+import { readTaskState, writeTaskState } from "../task_state.js";
+import { recordRunScorecard } from "../audit_ledger.js";
+import { resolveActiveDomain } from "../config.js";
+/**
+ * Records a sign-off event for the task's current gate. Validates that:
+ *   1. Task exists and is at the named gate.
+ *   2. Signer matches sign_off_policy:
+ *        sign_off_policy=den            → signer must be "den"
+ *        sign_off_policy=mcp_auto_pass  → signer must be "mcp"
+ *        sign_off_policy=either         → signer must be "den" or "mcp"
+ *   3. Gate has a classification recorded if classify_required=true.
+ *
+ * Does NOT advance the gate — that's advance_gate's job. sign_off only
+ * records evidence; advance_gate gates on it.
+ */
+export async function signOff(input) {
+    const pipeline = await loadPipeline(await resolveActiveDomain());
+    const state = await readTaskState(input.task_id);
+    if (!state) {
+        throw new Error(`sign_off: no task state for ${input.task_id} (call current_gate or classify_gate first)`);
+    }
+    if (state.current_gate !== input.gate) {
+        throw new Error(`sign_off: task ${input.task_id} is at gate ${state.current_gate}, not ${input.gate}`);
+    }
+    const gateCfg = getGateConfig(pipeline, state.mode, input.gate);
+    switch (gateCfg.sign_off_policy) {
+        case "den":
+            if (input.signer !== "den") {
+                throw new Error(`sign_off: gate ${input.gate} requires signer 'den' (policy=den), got '${input.signer}'`);
+            }
+            break;
+        case "mcp_auto_pass":
+            if (input.signer !== "mcp") {
+                throw new Error(`sign_off: gate ${input.gate} requires signer 'mcp' (policy=mcp_auto_pass), got '${input.signer}'`);
+            }
+            break;
+        case "either":
+            if (input.signer !== "den" && input.signer !== "mcp") {
+                throw new Error(`sign_off: gate ${input.gate} requires signer 'den' or 'mcp' (policy=either), got '${input.signer}'`);
+            }
+            break;
+    }
+    if (gateCfg.classify_required) {
+        const hasClassification = state.classifications.some((c) => c.gate === input.gate);
+        if (!hasClassification) {
+            throw new Error(`sign_off: gate ${input.gate} requires classify_gate first (classify_required=true)`);
+        }
+    }
+    const timestamp = new Date().toISOString();
+    state.signoffs.push({
+        gate: input.gate,
+        signer: input.signer,
+        timestamp,
+        evidence: input.evidence,
+    });
+    await writeTaskState(state);
+    // Auditor telemetry: when the terminal gate is signed, the run is complete —
+    // append a scorecard to the local ledger. Best-effort: a ledger failure must
+    // NEVER break a sign-off (telemetry is not load-bearing for the gate).
+    if (input.gate === "RG") {
+        try {
+            await recordRunScorecard(state);
+        }
+        catch {
+            /* swallow — see contract in audit_ledger.recordRunScorecard */
+        }
+    }
+    return { signed: true, signer: input.signer, timestamp };
+}

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

@@ -0,0 +1,17 @@
+import type { z } from "zod";
+import { TOOL_REGISTRY, type ToolName } from "../../shared/index.js";
+/**
+ * Typed handler signature derived from the I/O contracts in the shared types module (src/shared).
+ */
+export type ToolHandler<N extends ToolName> = (input: z.infer<(typeof TOOL_REGISTRY)[N]["input"]>) => Promise<z.infer<(typeof TOOL_REGISTRY)[N]["output"]>>;
+/** Thrown by every stub until the real implementation lands. */
+export declare class NotImplementedError extends Error {
+    constructor(tool: ToolName);
+}
+/**
+ * Default handler registry — every tool starts as a NotImplementedError stub.
+ * Real implementations replace entries here as they land (pre-req #3 baseline prototype).
+ */
+export declare const DEFAULT_HANDLERS: {
+    [N in ToolName]: ToolHandler<N>;
+};

package/dist/mcp/tools/stubs.js

@@ -0,0 +1,86 @@
+import { TOOL_REGISTRY } from "../../shared/index.js";
+import { listSkills } from "./list_skills.js";
+import { loadRole } from "./load_role.js";
+import { requestDecision } from "./request_decision.js";
+import { recordDecision } from "./record_decision.js";
+import { currentGate } from "./current_gate.js";
+import { classifyGate } from "./classify_gate.js";
+import { signOff } from "./sign_off.js";
+import { advanceGate } from "./advance_gate.js";
+import { submitArtifact } from "./submit_artifact.js";
+import { getSkill } from "./get_skill.js";
+import { regenerateManifest } from "./regenerate_manifest.js";
+import { reportException } from "./report_exception.js";
+import { recentDecisions } from "./recent_decisions.js";
+import { auditTrail } from "./audit_trail.js";
+import { listArtifacts } from "./list_artifacts.js";
+import { getArtifact } from "./get_artifact.js";
+import { verifyClaim } from "./verify_claim.js";
+import { runTests } from "./run_tests.js";
+import { checkLint } from "./check_lint.js";
+import { build } from "./build.js";
+import { applyDiff } from "./apply_diff.js";
+import { gitCommit } from "./git_commit.js";
+import { runDriftAudit } from "./run_drift_audit.js";
+import { auditBudgetCompliance } from "./audit_budget_compliance.js";
+import { auditBilocaleParity } from "./audit_bilocale_parity.js";
+import { aggregateRunMetrics } from "./aggregate_run_metrics.js";
+import { proposeChange } from "./propose_change.js";
+import { listProposals } from "./list_proposals.js";
+import { reviewProposal } from "./review_proposal.js";
+import { e2ePlaywright } from "./e2e_playwright.js";
+import { dockerCompose } from "./docker_compose.js";
+import { dependencySupplyChain } from "./dependency_supply_chain.js";
+/** Thrown by every stub until the real implementation lands. */
+export class NotImplementedError extends Error {
+    constructor(tool) {
+        super(`tool not yet implemented: ${tool}`);
+        this.name = "NotImplementedError";
+    }
+}
+/** Build a stub handler that validates input then throws NotImplementedError. */
+function stub(name) {
+    const schema = TOOL_REGISTRY[name].input;
+    return async (raw) => {
+        schema.parse(raw);
+        throw new NotImplementedError(name);
+    };
+}
+/**
+ * Default handler registry — every tool starts as a NotImplementedError stub.
+ * Real implementations replace entries here as they land (pre-req #3 baseline prototype).
+ */
+export const DEFAULT_HANDLERS = {
+    load_role: loadRole,
+    list_skills: listSkills,
+    get_skill: getSkill,
+    request_decision: requestDecision,
+    record_decision: recordDecision,
+    classify_gate: classifyGate,
+    advance_gate: advanceGate,
+    current_gate: currentGate,
+    sign_off: signOff,
+    submit_artifact: submitArtifact,
+    verify_claim: verifyClaim,
+    report_exception: reportException,
+    get_artifact: getArtifact,
+    list_artifacts: listArtifacts,
+    audit_trail: auditTrail,
+    recent_decisions: recentDecisions,
+    regenerate_manifest: regenerateManifest,
+    run_drift_audit: runDriftAudit,
+    audit_budget_compliance: auditBudgetCompliance,
+    audit_bilocale_parity: auditBilocaleParity,
+    aggregate_run_metrics: aggregateRunMetrics,
+    propose_change: proposeChange,
+    list_proposals: listProposals,
+    review_proposal: reviewProposal,
+    run_tests: runTests,
+    apply_diff: applyDiff,
+    git_commit: gitCommit,
+    check_lint: checkLint,
+    build,
+    dependency_supply_chain: dependencySupplyChain,
+    docker_compose: dockerCompose,
+    e2e_playwright: e2ePlaywright,
+};

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

@@ -0,0 +1,19 @@
+import { type SubmitArtifactInput, type SubmitArtifactOutput } from "../../shared/index.js";
+/**
+ * Single write path for every artifact class. Enforces:
+ *   1. ARTIFACT_LINE_CAP[class] — content line count must not exceed cap (null = no cap).
+ *   2. Frontmatter zod validation for class="skill" and class="role" (owners.min(1),
+ *      controlled vocab, related[], schema_version, budget_lines<=300, etc.).
+ *   3. Path safety: no absolute paths, no parent-dir escape; resolved under process.cwd().
+ *
+ * Bidirectional related[] enforcement (skill A links B → B must link A) is OUT OF SCOPE
+ * here — that's regenerate_manifest's job at the corpus level. submit_artifact is single-file
+ * gating; cross-file consistency is a separate concern.
+ *
+ * For class="adr": no frontmatter validation (ADRs are plain markdown); cap=150 still applies.
+ * For class="diary"/"working_report": cap=null, no schema constraints, free-form.
+ * For class="handoff": cap=1 — a one-line AAAK-style string between gates.
+ * For class="persona"/"memory_index": cap enforced but no frontmatter schema validation yet
+ *   (PersonaBase zod exists but its on-disk format is markdown sections, not YAML frontmatter).
+ */
+export declare function submitArtifact(input: SubmitArtifactInput): Promise<SubmitArtifactOutput>;