code-ai-installer 3.0.0 → 4.0.1-a

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/audit_trail.d.ts

@@ -0,0 +1,20 @@
+import type { AuditTrailInput, AuditTrailOutput } from "../../shared/index.js";
+/**
+ * Reconstructs the timeline for a task by merging:
+ *   - task_state classifications (kind: "classify_gate")
+ *   - task_state signoffs (kind: "sign_off")
+ *   - audit_required_at (kind: "circuit_breaker_trip")
+ *   - decisions.jsonl entries for this task (kind: "record_decision")
+ *
+ * Events are returned sorted asc by timestamp. Empty if the task doesn't exist.
+ *
+ * Not yet recorded (TODO for full instrumentation):
+ *   - "advance_gate" events — implicit in sign_off→next-gate; would require
+ *     extending TaskState with an explicit transition log.
+ *   - "submit_artifact" events — partially captured via .code-ai/state/
+ *     artifacts/<task_id>.jsonl when gate is provided.
+ *   - "request_decision" events — pending requests are not persisted yet.
+ *     report_exception entries are surfaced via report_exception output, but
+ *     also folded into the audit trail when present.
+ */
+export declare function auditTrail(input: AuditTrailInput): Promise<AuditTrailOutput>;

package/dist/mcp/tools/audit_trail.js

@@ -0,0 +1,124 @@
+import { readFile } from "node:fs/promises";
+import { join } from "node:path";
+import { readTaskState } from "../task_state.js";
+import { buildDecisionStore } from "../stores/index.js";
+/**
+ * Reconstructs the timeline for a task by merging:
+ *   - task_state classifications (kind: "classify_gate")
+ *   - task_state signoffs (kind: "sign_off")
+ *   - audit_required_at (kind: "circuit_breaker_trip")
+ *   - decisions.jsonl entries for this task (kind: "record_decision")
+ *
+ * Events are returned sorted asc by timestamp. Empty if the task doesn't exist.
+ *
+ * Not yet recorded (TODO for full instrumentation):
+ *   - "advance_gate" events — implicit in sign_off→next-gate; would require
+ *     extending TaskState with an explicit transition log.
+ *   - "submit_artifact" events — partially captured via .code-ai/state/
+ *     artifacts/<task_id>.jsonl when gate is provided.
+ *   - "request_decision" events — pending requests are not persisted yet.
+ *     report_exception entries are surfaced via report_exception output, but
+ *     also folded into the audit trail when present.
+ */
+export async function auditTrail(input) {
+    const state = await readTaskState(input.task_id);
+    const events = [];
+    if (state) {
+        for (const c of state.classifications) {
+            events.push({
+                timestamp: c.timestamp,
+                kind: "classify_gate",
+                gate: c.gate,
+                details: { outcome: c.outcome, rationale: c.rationale },
+            });
+        }
+        for (const s of state.signoffs) {
+            events.push({
+                timestamp: s.timestamp,
+                kind: "sign_off",
+                gate: s.gate,
+                details: { signer: s.signer, evidence: s.evidence ?? null },
+            });
+        }
+        if (state.audit_required_at) {
+            events.push({
+                timestamp: state.audit_required_at,
+                kind: "circuit_breaker_trip",
+                details: { dev_rollback_count: state.dev_rollback_count },
+            });
+        }
+    }
+    // decisions for this task via DecisionStore (canonical JSONL + optional MemPalace mirror)
+    const store = await buildDecisionStore();
+    const decisions = await store.readDecisions({
+        task_id: input.task_id,
+        includePending: true,
+    });
+    for (const entry of decisions) {
+        const kind = entry.adr_id.startsWith("ADR-PENDING-")
+            ? "request_decision"
+            : "record_decision";
+        events.push({
+            timestamp: entry.timestamp,
+            kind,
+            gate: entry.gate,
+            details: {
+                adr_id: entry.adr_id,
+                question: entry.question,
+                chosen_option_id: entry.chosen_option_id,
+                signer: entry.signer,
+            },
+        });
+    }
+    // submit_artifact events (when gate-indexed)
+    const safe = input.task_id.replace(/[^A-Za-z0-9_.-]/g, "_");
+    const artifactsPath = join(process.cwd(), ".code-ai", "state", "artifacts", `${safe}.jsonl`);
+    const rawArt = await readFile(artifactsPath, "utf8").catch(() => "");
+    if (rawArt) {
+        for (const line of rawArt.split("\n")) {
+            if (!line)
+                continue;
+            try {
+                const obj = JSON.parse(line);
+                events.push({
+                    timestamp: obj.timestamp,
+                    kind: "submit_artifact",
+                    gate: obj.gate,
+                    details: { class: obj.class, path: obj.path, line_count: obj.line_count },
+                });
+            }
+            catch {
+                continue;
+            }
+        }
+    }
+    // exceptions.jsonl entries for this task
+    const excPath = join(process.cwd(), ".code-ai", "state", "exceptions.jsonl");
+    const rawExc = await readFile(excPath, "utf8").catch(() => "");
+    if (rawExc) {
+        for (const line of rawExc.split("\n")) {
+            if (!line)
+                continue;
+            try {
+                const obj = JSON.parse(line);
+                if (obj.task_id !== input.task_id)
+                    continue;
+                events.push({
+                    timestamp: obj.timestamp,
+                    kind: "report_exception",
+                    gate: obj.gate,
+                    details: {
+                        exception_id: obj.exception_id,
+                        what_failed: obj.what_failed,
+                        breakdown: obj.breakdown,
+                    },
+                });
+            }
+            catch {
+                continue;
+            }
+        }
+    }
+    events.sort((a, b) => a.timestamp.localeCompare(b.timestamp));
+    return { events };
+}

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;
+}

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

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

package/dist/mcp/tools/check_lint.js

@@ -0,0 +1,23 @@
+import { npmCommand, spawnWithOutput, tail } from "./_subprocess.js";
+export async function checkLint(input) {
+    const cwd = input.cwd ?? process.cwd();
+    const result = await spawnWithOutput(npmCommand(), ["run", "lint"], { cwd });
+    if (result.exitCode === 0) {
+        return { clean: true, issues: [] };
+    }
+    return {
+        clean: false,
+        issues: [
+            {
+                code: "lint-failure",
+                message: `lint command exited with code ${result.exitCode}`,
+                evidence: {
+                    stdout: tail(result.stdout, 4000),
+                    stderr: tail(result.stderr, 4000),
+                    duration_ms: result.durationMs,
+                    spawnError: result.spawnError?.message,
+                },
+            },
+        ],
+    };
+}

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

@@ -0,0 +1,14 @@
+import { type ClassifyGateInput, type ClassifyGateOutput } from "../../shared/index.js";
+/**
+ * Records the classification for the current gate. Must be called before the
+ * artifact is produced when the gate has classify_required=true.
+ *
+ * Outcomes map to next_required_action:
+ *   auto_resolve → produce_artifact (silent path)
+ *   fork         → open_request_decision (DEN must choose)
+ *   exception    → open_report_exception (auto-check failed; needs DEN review)
+ *
+ * No-op-safe if called multiple times for the same gate — each call appends
+ * a new classification entry. latestClassification() returns the most recent.
+ */
+export declare function classifyGate(input: ClassifyGateInput): Promise<ClassifyGateOutput>;

package/dist/mcp/tools/classify_gate.js

@@ -0,0 +1,42 @@
+import { loadPipeline, getInitialGate } from "../pipeline.js";
+import { createTaskState, readTaskState, writeTaskState, } from "../task_state.js";
+import { resolveActiveDomain } from "../config.js";
+/**
+ * Records the classification for the current gate. Must be called before the
+ * artifact is produced when the gate has classify_required=true.
+ *
+ * Outcomes map to next_required_action:
+ *   auto_resolve → produce_artifact (silent path)
+ *   fork         → open_request_decision (DEN must choose)
+ *   exception    → open_report_exception (auto-check failed; needs DEN review)
+ *
+ * No-op-safe if called multiple times for the same gate — each call appends
+ * a new classification entry. latestClassification() returns the most recent.
+ */
+export async function classifyGate(input) {
+    const pipeline = await loadPipeline(await resolveActiveDomain());
+    let state = await readTaskState(input.task_id);
+    if (!state) {
+        state = await createTaskState({
+            task_id: input.task_id,
+            mode: pipeline.default_mode,
+            initial_gate: getInitialGate(pipeline, pipeline.default_mode),
+        });
+    }
+    if (state.current_gate !== input.gate) {
+        throw new Error(`classify_gate: task ${input.task_id} is at gate ${state.current_gate}, not ${input.gate}`);
+    }
+    state.classifications.push({
+        gate: input.gate,
+        outcome: input.outcome,
+        rationale: input.rationale,
+        timestamp: new Date().toISOString(),
+    });
+    await writeTaskState(state);
+    const next_required_action = input.outcome === "auto_resolve"
+        ? "produce_artifact"
+        : input.outcome === "fork"
+            ? "open_request_decision"
+            : "open_report_exception";
+    return { acknowledged: true, next_required_action };
+}

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

@@ -0,0 +1,14 @@
+import { type CurrentGateInput, type CurrentGateOutput } from "../../shared/index.js";
+/**
+ * Returns the task's current gate. Auto-creates the task state with the
+ * pipeline's default_mode and initial gate if no state file exists yet —
+ * there is no separate start_task tool in the v0 surface, so first-touch
+ * is implicit.
+ *
+ * The contract output includes allowed_tools and required_handoff_fields.
+ * For the prototype both are derived from the gate config in pipeline.yaml:
+ *   allowed_tools: empty array — hook layer resolves real tool allowlists.
+ *   required_handoff_fields: ["summary", "deliverable_path", "next_role"]
+ *   classification_pending: true if classify_required && no classification yet.
+ */
+export declare function currentGate(input: CurrentGateInput): Promise<CurrentGateOutput>;