code-ai-installer 4.0.0 → 4.0.1-a

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.js

@@ -1,6 +1,6 @@
 import { loadPipeline, getInitialGate } from "../pipeline.js";
 import { createTaskState, readTaskState, writeTaskState, } from "../task_state.js";
-const DEFAULT_DOMAIN = "development";
+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.
@@ -14,7 +14,7 @@ const DEFAULT_DOMAIN = "development";
  * a new classification entry. latestClassification() returns the most recent.
  */
 export async function classifyGate(input) {
-    const pipeline = await loadPipeline(DEFAULT_DOMAIN);
+    const pipeline = await loadPipeline(await resolveActiveDomain());
     let state = await readTaskState(input.task_id);
     if (!state) {
         state = await createTaskState({

package/dist/mcp/tools/current_gate.js

@@ -1,6 +1,6 @@
 import { loadPipeline, getGateConfig, getInitialGate } from "../pipeline.js";
 import { createTaskState, latestClassification, readTaskState } from "../task_state.js";
-const DEFAULT_DOMAIN = "development";
+import { resolveActiveDomain } from "../config.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 —
@@ -14,7 +14,7 @@ const DEFAULT_DOMAIN = "development";
  *   classification_pending: true if classify_required && no classification yet.
  */
 export async function currentGate(input) {
-    const pipeline = await loadPipeline(DEFAULT_DOMAIN);
+    const pipeline = await loadPipeline(await resolveActiveDomain());
     let state = await readTaskState(input.task_id);
     if (!state) {
         state = await createTaskState({

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

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

package/dist/mcp/tools/dependency_supply_chain.js

@@ -0,0 +1,59 @@
+import { npmCommand, spawnWithOutput, tail } from "./_subprocess.js";
+export async function dependencySupplyChain(input) {
+    const cwd = input.cwd ?? process.cwd();
+    const result = await spawnWithOutput(npmCommand(), ["audit", "--json"], { cwd });
+    if (!result.stdout.trim()) {
+        return {
+            vulnerabilities: [
+                {
+                    code: "subprocess-error",
+                    message: `npm audit produced no output (exit=${result.exitCode})`,
+                    evidence: {
+                        stderr: tail(result.stderr, 2000),
+                        spawnError: result.spawnError?.message,
+                    },
+                },
+            ],
+            total_deps: 0,
+        };
+    }
+    let report;
+    try {
+        report = JSON.parse(result.stdout);
+    }
+    catch (err) {
+        return {
+            vulnerabilities: [
+                {
+                    code: "json-parse-error",
+                    message: `Failed to parse npm audit JSON: ${err.message}`,
+                    evidence: { raw: result.stdout.slice(0, 500) },
+                },
+            ],
+            total_deps: 0,
+        };
+    }
+    const vulnerabilities = [];
+    for (const [pkg, info] of Object.entries(report.vulnerabilities ?? {})) {
+        const severity = info.severity ?? "unknown";
+        const range = info.range ?? "";
+        const viaList = (info.via ?? [])
+            .map((v) => typeof v === "string" ? v : (v.title ?? v.name ?? ""))
+            .filter(Boolean);
+        vulnerabilities.push({
+            code: `npm-audit-${severity}-${pkg}`,
+            message: `${pkg}${range ? ` ${range}` : ""} — ${severity} severity${viaList.length ? `: ${viaList[0]}` : ""}`,
+            evidence: {
+                package: pkg,
+                severity,
+                range,
+                via: info.via,
+                effects: info.effects,
+            },
+        });
+    }
+    return {
+        vulnerabilities,
+        total_deps: report.metadata?.dependencies?.total ?? 0,
+    };
+}

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

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

package/dist/mcp/tools/docker_compose.js

@@ -0,0 +1,24 @@
+import { spawnWithOutput } from "./_subprocess.js";
+const DOCKER = process.platform === "win32" ? "docker.exe" : "docker";
+export async function dockerCompose(input) {
+    const cwd = input.cwd ?? process.cwd();
+    const args = buildArgs(input.command);
+    const result = await spawnWithOutput(DOCKER, args, { cwd });
+    return {
+        exit_code: result.exitCode ?? -1,
+        stdout: result.stdout,
+        stderr: result.stderr,
+    };
+}
+function buildArgs(command) {
+    switch (command) {
+        case "up":
+            return ["compose", "up", "-d"];
+        case "down":
+            return ["compose", "down"];
+        case "ps":
+            return ["compose", "ps"];
+        case "logs":
+            return ["compose", "logs", "--no-color", "--tail=200"];
+    }
+}

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

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

package/dist/mcp/tools/e2e_playwright.js

@@ -0,0 +1,88 @@
+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 e2ePlaywright(input) {
+    const cwd = input.cwd ?? process.cwd();
+    const outFile = join(tmpdir(), `code-ai-playwright-${randomUUID()}.json`);
+    const args = ["exec", "--", "playwright", "test", "--reporter=json"];
+    if (input.spec)
+        args.push("--grep", input.spec);
+    const result = await spawnWithOutput(npmCommand(), args, {
+        cwd,
+        env: { PLAYWRIGHT_JSON_OUTPUT_NAME: outFile },
+    });
+    let raw = null;
+    try {
+        raw = await readFile(outFile, "utf8");
+        await unlink(outFile).catch(() => undefined);
+    }
+    catch {
+        raw = result.stdout.trim() || null;
+    }
+    if (!raw) {
+        return {
+            passed: 0,
+            failed: 0,
+            failures: [
+                {
+                    code: "subprocess-error",
+                    message: `playwright did not produce a 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,
+            failures: [
+                {
+                    code: "json-parse-error",
+                    message: `Failed to parse playwright JSON report: ${err.message}`,
+                    evidence: { raw: raw.slice(0, 500) },
+                },
+            ],
+        };
+    }
+    return mapReport(report);
+}
+function mapReport(report) {
+    const passed = report.stats?.expected ?? 0;
+    const failed = (report.stats?.unexpected ?? 0) + (report.stats?.flaky ?? 0);
+    const failures = [];
+    walkSuites(report.suites ?? [], failures);
+    return { passed, failed, failures };
+}
+function walkSuites(suites, failures) {
+    for (const suite of suites) {
+        for (const spec of suite.specs ?? []) {
+            if (spec.ok === false) {
+                const lastTest = spec.tests?.[spec.tests.length - 1];
+                const lastResult = lastTest?.results?.[lastTest.results.length - 1];
+                const msg = (lastResult?.error?.message ?? "(no error message)").split("\n")[0] ??
+                    "";
+                failures.push({
+                    code: "playwright-test-failed",
+                    message: `${spec.file ?? suite.file ?? "<unknown>"} > ${spec.title ?? "<untitled>"}: ${msg}`,
+                    evidence: {
+                        file: spec.file ?? suite.file,
+                        title: spec.title,
+                        error: lastResult?.error,
+                    },
+                });
+            }
+        }
+        walkSuites(suite.suites ?? [], failures);
+    }
+}

package/dist/mcp/tools/get_skill.js

@@ -3,6 +3,7 @@ import { join } from "node:path";
 import { parse as parseYaml } from "yaml";
 import { SkillFrontmatter, } from "../../shared/index.js";
 import { resolveSkillsRoot } from "../paths.js";
+import { recordSkillInvocation } from "../skill_invocations.js";
 /**
  * Reads a single SKILL.md from disk, validates its frontmatter against
  * SkillFrontmatter (zod), and returns { frontmatter, body }.
@@ -43,5 +44,21 @@ export async function getSkill(input) {
         throw new Error(`get_skill: frontmatter validation failed for ${file} — ${fm.error.issues.map((i) => `${i.path.join(".")}: ${i.message}`).join("; ")}`);
     }
     const body = stripped.slice(m[0].length);
+    // Auditor telemetry (ADR-DEV-121): when associated with a run, log the fetch
+    // as a skill invocation. Best-effort — a logging failure must never break a
+    // read (telemetry is not load-bearing for get_skill).
+    if (input.task_id !== undefined) {
+        try {
+            await recordSkillInvocation({
+                task_id: input.task_id,
+                gate: input.gate ?? null,
+                skill: input.name,
+                timestamp: new Date().toISOString(),
+            });
+        }
+        catch {
+            /* swallow */
+        }
+    }
     return { frontmatter: fm.data, body };
 }

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

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

package/dist/mcp/tools/git_commit.js

@@ -0,0 +1,30 @@
+import { randomUUID } from "node:crypto";
+import { tmpdir } from "node:os";
+import { join } from "node:path";
+import { writeFile, unlink } from "node:fs/promises";
+import { spawnWithOutput, tail } from "./_subprocess.js";
+const GIT = process.platform === "win32" ? "git.exe" : "git";
+export async function gitCommit(input) {
+    const cwd = input.cwd ?? process.cwd();
+    if (input.paths.length > 0) {
+        const add = await spawnWithOutput(GIT, ["add", "--", ...input.paths], { cwd });
+        if (add.exitCode !== 0) {
+            throw new Error(`git add failed (exit=${add.exitCode}): ${tail(add.stderr, 2000) || tail(add.stdout, 2000)}`);
+        }
+    }
+    const msgPath = join(tmpdir(), `code-ai-commit-msg-${randomUUID()}.txt`);
+    await writeFile(msgPath, input.message, "utf8");
+    const args = input.paths.length === 0
+        ? ["commit", "-a", "-F", msgPath]
+        : ["commit", "-F", msgPath];
+    const commit = await spawnWithOutput(GIT, args, { cwd });
+    await unlink(msgPath).catch(() => undefined);
+    if (commit.exitCode !== 0) {
+        throw new Error(`git commit failed (exit=${commit.exitCode}): ${tail(commit.stderr, 2000) || tail(commit.stdout, 2000)}`);
+    }
+    const sha = await spawnWithOutput(GIT, ["rev-parse", "HEAD"], { cwd });
+    if (sha.exitCode !== 0) {
+        throw new Error(`git rev-parse HEAD failed: ${tail(sha.stderr, 1000)}`);
+    }
+    return { sha: sha.stdout.trim() };
+}

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

@@ -0,0 +1,6 @@
+import { type ListProposalsInput, type ListProposalsOutput } from "../../shared/index.js";
+/**
+ * List stored proposals, newest first, with optional surfacing filters
+ * (status / risk / domain). Read-only — never mutates the store.
+ */
+export declare function listProposals(input: ListProposalsInput): Promise<ListProposalsOutput>;

package/dist/mcp/tools/list_proposals.js

@@ -0,0 +1,16 @@
+import { readProposals } from "../proposal_store.js";
+/**
+ * List stored proposals, newest first, with optional surfacing filters
+ * (status / risk / domain). Read-only — never mutates the store.
+ */
+export async function listProposals(input) {
+    let proposals = await readProposals();
+    if (input.status)
+        proposals = proposals.filter((p) => p.status === input.status);
+    if (input.risk)
+        proposals = proposals.filter((p) => p.risk === input.risk);
+    if (input.domain)
+        proposals = proposals.filter((p) => p.target.domain === input.domain);
+    proposals.sort((a, b) => b.created_at.localeCompare(a.created_at));
+    return { proposals };
+}

package/dist/mcp/tools/list_skills.js

@@ -1,6 +1,7 @@
 import { readdir, readFile } from "node:fs/promises";
 import { join } from "node:path";
 import { parse as parseYaml } from "yaml";
+import { SkillFrontmatter, } from "../../shared/index.js";
 import { resolveSkillsRoot } from "../paths.js";
 /**
  * Reads every SKILL.md under the given domain's `.agents/skills/<name>/SKILL.md`
@@ -45,10 +46,17 @@ function parseFrontmatter(raw) {
     const m = stripped.match(/^---\r?\n([\s\S]*?)\r?\n---/);
     if (!m)
         return null;
+    let parsed;
     try {
-        return parseYaml(m[1]);
+        parsed = parseYaml(m[1]);
     }
     catch {
         return null;
     }
+    // Strict validation — skills with garbage frontmatter (missing type, bad
+    // enum, etc.) are silently skipped. Drift detection is run_drift_audit's job;
+    // list_skills returns only schema-conformant skills so downstream output.parse
+    // never sees a partially-typed entry.
+    const result = SkillFrontmatter.safeParse(parsed);
+    return result.success ? result.data : null;
 }

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

@@ -2,10 +2,9 @@ import { type LoadRoleInput, type LoadRoleOutput } from "../../shared/index.js";
 /**
  * SessionStart loader for an agent role.
  *
- * For pre-req #3, persona files live in docs/architecture-redesign/ (not yet
- * migrated to installer/domains/<domain>/persona/ — awaiting DEN sign-off).
- * Path is hard-coded here; will become configurable once persona moves into
- * the installer ship.
+ * Base persona ships inside the package at
+ * `domains/<domain>/persona/persona-base.md` (resolved per active domain via
+ * resolvePersonaBase); absent file degrades gracefully to no base layer.
  *
  * User-layer persona is currently always absent (persona-user-denis.md is
  * gitignored and not loaded by name match). Future versions read the user

package/dist/mcp/tools/load_role.js

@@ -1,17 +1,14 @@
 import { readFile } from "node:fs/promises";
-import { join } from "node:path";
 import { parse as parseYaml } from "yaml";
 import { RoleFrontmatter, } from "../../shared/index.js";
-import { PERSONA_ROOT, resolveAgentMd } from "../paths.js";
+import { resolvePersonaBase, resolveAgentMd } from "../paths.js";
 import { listSkills } from "./list_skills.js";
-const PERSONA_BASE = join(PERSONA_ROOT, "persona-base.md");
 /**
  * SessionStart loader for an agent role.
  *
- * For pre-req #3, persona files live in docs/architecture-redesign/ (not yet
- * migrated to installer/domains/<domain>/persona/ — awaiting DEN sign-off).
- * Path is hard-coded here; will become configurable once persona moves into
- * the installer ship.
+ * Base persona ships inside the package at
+ * `domains/<domain>/persona/persona-base.md` (resolved per active domain via
+ * resolvePersonaBase); absent file degrades gracefully to no base layer.
  *
  * User-layer persona is currently always absent (persona-user-denis.md is
  * gitignored and not loaded by name match). Future versions read the user
@@ -19,7 +16,7 @@ const PERSONA_BASE = join(PERSONA_ROOT, "persona-base.md");
  */
 export async function loadRole(input) {
     const roleMd = await readFile(resolveAgentMd(input.domain, input.role_name), "utf8");
-    const personaBase = await loadPersonaBase();
+    const personaBase = await loadPersonaBase(input.domain);
     const personaUser = await loadPersonaUserLayer();
     const persona = mergePersona(personaBase, personaUser);
     const skillsForRole = await listSkills({
@@ -34,6 +31,7 @@ export async function loadRole(input) {
         name: input.role_name,
         description: extractFirstHeading(roleMd) ?? `Agent: ${input.role_name}`,
         domain: input.domain,
+        kind: "gate",
         signs_off_at: inferSignsOffAt(input.role_name),
         tool_allowlist: `role:${input.role_name}`,
         budget_lines: 250,
@@ -79,13 +77,13 @@ function stripFrontmatter(raw) {
     const m = stripped.match(/^---\r?\n[\s\S]*?\r?\n---\r?\n+/);
     return m ? stripped.slice(m[0].length) : stripped;
 }
-async function loadPersonaBase() {
-    const raw = await readFile(PERSONA_BASE, "utf8").catch(() => null);
+async function loadPersonaBase(domain) {
+    const raw = await readFile(resolvePersonaBase(domain), "utf8").catch(() => null);
     if (!raw)
         return null;
-    // Persona files in docs/architecture-redesign/ are markdown with section
-    // headings, not yaml. For pre-req #3 we extract sections by heading and
-    // treat each list item as a PersonaProperty with manual provenance.
+    // Persona files are markdown with section headings, not yaml: extract
+    // sections by heading and treat each list item as a PersonaProperty with
+    // manual provenance.
     return parsePersonaMarkdown(raw, "base");
 }
 async function loadPersonaUserLayer() {

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

@@ -0,0 +1,8 @@
+import { type ProposeChangeInput, type ProposeChangeOutput } from "../../shared/index.js";
+/**
+ * Record an Auditor proposal as a pending entry in the local proposal store.
+ *
+ * Pure surfacing: writing a proposal changes NO asset — it is inert until the
+ * approval/apply layer (item 4b) acts on it. Status is always "pending" here.
+ */
+export declare function proposeChange(input: ProposeChangeInput): Promise<ProposeChangeOutput>;

package/dist/mcp/tools/propose_change.js

@@ -0,0 +1,36 @@
+import { appendProposal, nextProposalId } from "../proposal_store.js";
+import { resolveProposalsPath } from "../paths.js";
+/** Map a change kind to its autonomy-matrix risk tier (ADR-DEV-122). */
+function riskFor(kind) {
+    switch (kind) {
+        case "edit_minor":
+            return "low";
+        case "add_asset":
+            return "additive";
+        case "destructive":
+            return "high";
+    }
+}
+/**
+ * Record an Auditor proposal as a pending entry in the local proposal store.
+ *
+ * Pure surfacing: writing a proposal changes NO asset — it is inert until the
+ * approval/apply layer (item 4b) acts on it. Status is always "pending" here.
+ */
+export async function proposeChange(input) {
+    const id = await nextProposalId();
+    const risk = riskFor(input.change_kind);
+    await appendProposal({
+        id,
+        created_at: new Date().toISOString(),
+        status: "pending",
+        risk,
+        target: input.target,
+        change_kind: input.change_kind,
+        rationale: input.rationale,
+        evidence: input.evidence,
+        threshold_met: input.threshold_met,
+        draft: input.draft,
+    });
+    return { id, status: "pending", risk, path: resolveProposalsPath() };
+}

package/dist/mcp/tools/record_decision.js

@@ -4,7 +4,7 @@ import { resolveAdrRoot } from "../paths.js";
 import { loadPipeline } from "../pipeline.js";
 import { readTaskState, writeTaskState } from "../task_state.js";
 import { buildDecisionStore } from "../stores/index.js";
-const DEFAULT_DOMAIN = "development";
+import { resolveActiveDomain } from "../config.js";
 /**
  * Atomic 3-place ADR write:
  *   1. docs/adr/ADR-{DOMAIN}-{NNN}.md  — versioned on disk
@@ -74,7 +74,7 @@ async function maybeResetCircuitBreaker(taskId, gate) {
         return;
     let pipeline;
     try {
-        pipeline = await loadPipeline(DEFAULT_DOMAIN);
+        pipeline = await loadPipeline(await resolveActiveDomain());
     }
     catch {
         return; // No pipeline → nothing to reset against.
@@ -117,29 +117,29 @@ function renderAdr(a) {
     const supersedesBlock = a.supersedes
         ? `\n\n## Supersedes\n${a.supersedes}\n`
         : "";
-    return `# ${a.adrId}: ${a.question}
-
-- **Status:** Accepted
-- **Date:** ${a.today}
-- **Task:** ${a.task_id}
-- **Gate:** ${a.gate}
-- **Signer:** ${a.signer}
-
-## Question
-
-${a.question}
-
-## Options Considered
-
-${optionsList}
-
-## Decision
-
-Chose **${a.chosen.id}**${a.chosen.label ? `: ${a.chosen.label}` : ""}.
-
-## Rationale
-
-${a.rationale}
+    return `# ${a.adrId}: ${a.question}
+
+- **Status:** Accepted
+- **Date:** ${a.today}
+- **Task:** ${a.task_id}
+- **Gate:** ${a.gate}
+- **Signer:** ${a.signer}
+
+## Question
+
+${a.question}
+
+## Options Considered
+
+${optionsList}
+
+## Decision
+
+Chose **${a.chosen.id}**${a.chosen.label ? `: ${a.chosen.label}` : ""}.
+
+## Rationale
+
+${a.rationale}
 ${supersedesBlock}`;
 }
 function shortHash(s) {

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