code-ai-installer 3.0.0 → 4.0.0

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/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";
+const DEFAULT_DOMAIN = "development";
+/**
+ * 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(DEFAULT_DOMAIN);
+    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>;

package/dist/mcp/tools/current_gate.js

@@ -0,0 +1,35 @@
+import { loadPipeline, getGateConfig, getInitialGate } from "../pipeline.js";
+import { createTaskState, latestClassification, readTaskState } from "../task_state.js";
+const DEFAULT_DOMAIN = "development";
+/**
+ * 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 async function currentGate(input) {
+    const pipeline = await loadPipeline(DEFAULT_DOMAIN);
+    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),
+        });
+    }
+    const gateCfg = getGateConfig(pipeline, state.mode, state.current_gate);
+    const cls = latestClassification(state, state.current_gate);
+    return {
+        mode: state.mode,
+        gate: state.current_gate,
+        allowed_tools: [],
+        required_handoff_fields: ["summary", "deliverable_path", "next_role"],
+        classification_pending: gateCfg.classify_required && cls === null,
+    };
+}

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

@@ -0,0 +1,11 @@
+import type { GetArtifactInput, GetArtifactOutput } from "../../shared/index.js";
+/**
+ * Resolves (task_id, gate) → artifact file content. Uses the per-task index
+ * .code-ai/state/artifacts/<task_id>.jsonl. If multiple writes happened at the
+ * same gate, returns the LATEST one (jsonl order).
+ *
+ * format=summary returns the first 5 lines of the content prepended with a
+ * heading; format=raw returns the full body. v1 keeps summary very simple —
+ * a fancier summarizer (per artifact class) is a future enhancement.
+ */
+export declare function getArtifact(input: GetArtifactInput): Promise<GetArtifactOutput>;

package/dist/mcp/tools/get_artifact.js

@@ -0,0 +1,46 @@
+import { readFile } from "node:fs/promises";
+import { join } from "node:path";
+/**
+ * Resolves (task_id, gate) → artifact file content. Uses the per-task index
+ * .code-ai/state/artifacts/<task_id>.jsonl. If multiple writes happened at the
+ * same gate, returns the LATEST one (jsonl order).
+ *
+ * format=summary returns the first 5 lines of the content prepended with a
+ * heading; format=raw returns the full body. v1 keeps summary very simple —
+ * a fancier summarizer (per artifact class) is a future enhancement.
+ */
+export async function getArtifact(input) {
+    const safe = input.task_id.replace(/[^A-Za-z0-9_.-]/g, "_");
+    const indexPath = join(process.cwd(), ".code-ai", "state", "artifacts", `${safe}.jsonl`);
+    const raw = await readFile(indexPath, "utf8").catch(() => "");
+    if (!raw)
+        return { exists: false };
+    let latestPath = null;
+    for (const line of raw.split("\n")) {
+        if (!line)
+            continue;
+        try {
+            const obj = JSON.parse(line);
+            if (obj.gate === input.gate && typeof obj.path === "string") {
+                latestPath = obj.path; // overwrite — last match wins
+            }
+        }
+        catch {
+            continue;
+        }
+    }
+    if (!latestPath)
+        return { exists: false };
+    const content = await readFile(latestPath, "utf8").catch(() => null);
+    if (content === null)
+        return { exists: false };
+    if (input.format === "summary") {
+        const head = content.split("\n").slice(0, 5).join("\n");
+        return {
+            exists: true,
+            path: latestPath,
+            content: `=== summary of ${latestPath} ===\n${head}`,
+        };
+    }
+    return { exists: true, path: latestPath, content };
+}

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

@@ -0,0 +1,17 @@
+import { type GetSkillInput, type GetSkillOutput } from "../../shared/index.js";
+/**
+ * Reads a single SKILL.md from disk, validates its frontmatter against
+ * SkillFrontmatter (zod), and returns { frontmatter, body }.
+ *
+ * Throws:
+ *   - if the file does not exist (caller passed a name that has no SKILL.md)
+ *   - if the frontmatter block is missing
+ *   - if the YAML is malformed
+ *   - if the frontmatter fails SkillFrontmatter validation
+ *
+ * The body is everything AFTER the closing `---` of the frontmatter, with the
+ * BOM (if any) stripped from the file head. Line cap is NOT enforced here —
+ * `submit_artifact` validates writes; `get_skill` is read-only and surfaces
+ * whatever is on disk so callers can audit oversized bodies.
+ */
+export declare function getSkill(input: GetSkillInput): Promise<GetSkillOutput>;

package/dist/mcp/tools/get_skill.js

@@ -0,0 +1,47 @@
+import { 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 a single SKILL.md from disk, validates its frontmatter against
+ * SkillFrontmatter (zod), and returns { frontmatter, body }.
+ *
+ * Throws:
+ *   - if the file does not exist (caller passed a name that has no SKILL.md)
+ *   - if the frontmatter block is missing
+ *   - if the YAML is malformed
+ *   - if the frontmatter fails SkillFrontmatter validation
+ *
+ * The body is everything AFTER the closing `---` of the frontmatter, with the
+ * BOM (if any) stripped from the file head. Line cap is NOT enforced here —
+ * `submit_artifact` validates writes; `get_skill` is read-only and surfaces
+ * whatever is on disk so callers can audit oversized bodies.
+ */
+export async function getSkill(input) {
+    const file = join(resolveSkillsRoot(input.domain), input.name, "SKILL.md");
+    const raw = await readFile(file, "utf8").catch((err) => {
+        if (err.code === "ENOENT") {
+            throw new Error(`get_skill: SKILL.md not found for '${input.name}' in domain '${input.domain}' (expected at ${file})`);
+        }
+        throw err;
+    });
+    const stripped = raw.startsWith("") ? raw.slice(1) : raw;
+    const m = stripped.match(/^---\r?\n([\s\S]*?)\r?\n---\r?\n?/);
+    if (!m) {
+        throw new Error(`get_skill: no frontmatter block found in ${file}`);
+    }
+    let parsedYaml;
+    try {
+        parsedYaml = parseYaml(m[1]);
+    }
+    catch (err) {
+        throw new Error(`get_skill: malformed YAML frontmatter in ${file} — ${err.message}`);
+    }
+    const fm = SkillFrontmatter.safeParse(parsedYaml);
+    if (!fm.success) {
+        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);
+    return { frontmatter: fm.data, body };
+}

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

@@ -0,0 +1,8 @@
+import type { ListArtifactsInput, ListArtifactsOutput } from "../../shared/index.js";
+/**
+ * Returns artifacts written via submit_artifact with `gate` provided.
+ * Source: .code-ai/state/artifacts/<task_id>.jsonl (one line per write).
+ * Empty array if no artifacts were indexed for this task (older callers may
+ * have written without the gate field; those won't show up here).
+ */
+export declare function listArtifacts(input: ListArtifactsInput): Promise<ListArtifactsOutput>;

package/dist/mcp/tools/list_artifacts.js

@@ -0,0 +1,35 @@
+import { readFile } from "node:fs/promises";
+import { join } from "node:path";
+/**
+ * Returns artifacts written via submit_artifact with `gate` provided.
+ * Source: .code-ai/state/artifacts/<task_id>.jsonl (one line per write).
+ * Empty array if no artifacts were indexed for this task (older callers may
+ * have written without the gate field; those won't show up here).
+ */
+export async function listArtifacts(input) {
+    const safe = input.task_id.replace(/[^A-Za-z0-9_.-]/g, "_");
+    const indexPath = join(process.cwd(), ".code-ai", "state", "artifacts", `${safe}.jsonl`);
+    const raw = await readFile(indexPath, "utf8").catch(() => "");
+    if (!raw)
+        return { artifacts: [] };
+    const artifacts = [];
+    for (const line of raw.split("\n")) {
+        if (!line)
+            continue;
+        try {
+            const obj = JSON.parse(line);
+            if (typeof obj.gate !== "string" || typeof obj.class !== "string")
+                continue;
+            artifacts.push({
+                gate: obj.gate,
+                class: obj.class,
+                path: obj.path,
+                line_count: obj.line_count,
+            });
+        }
+        catch {
+            continue;
+        }
+    }
+    return { artifacts };
+}

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

@@ -0,0 +1,8 @@
+import { type ListSkillsInput, type ListSkillsOutput } from "../../shared/index.js";
+/**
+ * Reads every SKILL.md under the given domain's `.agents/skills/<name>/SKILL.md`
+ * and returns the subset matching the filter. Frontmatter is parsed via the YAML
+ * lib (BOM-aware) and the type-narrowing is done at the filter step — we don't
+ * fail the whole call if one skill has a malformed frontmatter; we just skip it.
+ */
+export declare function listSkills(input: ListSkillsInput): Promise<ListSkillsOutput>;

package/dist/mcp/tools/list_skills.js

@@ -0,0 +1,54 @@
+import { readdir, readFile } from "node:fs/promises";
+import { join } from "node:path";
+import { parse as parseYaml } from "yaml";
+import { resolveSkillsRoot } from "../paths.js";
+/**
+ * Reads every SKILL.md under the given domain's `.agents/skills/<name>/SKILL.md`
+ * and returns the subset matching the filter. Frontmatter is parsed via the YAML
+ * lib (BOM-aware) and the type-narrowing is done at the filter step — we don't
+ * fail the whole call if one skill has a malformed frontmatter; we just skip it.
+ */
+export async function listSkills(input) {
+    const domain = input.domain ?? "development";
+    const root = resolveSkillsRoot(domain);
+    const dirs = (await readdir(root, { withFileTypes: true })).filter((d) => d.isDirectory());
+    const out = [];
+    for (const dir of dirs) {
+        const md = await readFile(join(root, dir.name, "SKILL.md"), "utf8").catch(() => null);
+        if (!md)
+            continue;
+        const fm = parseFrontmatter(md);
+        if (!fm)
+            continue;
+        if (input.type && fm.type !== input.type)
+            continue;
+        if (input.gate && !(fm.gates ?? []).includes(input.gate))
+            continue;
+        if (input.tech && !(fm.tech ?? []).includes(input.tech))
+            continue;
+        if (input.topic && !(fm.topic ?? []).includes(input.topic))
+            continue;
+        if (input.owner && !(fm.owners ?? []).includes(input.owner))
+            continue;
+        out.push({
+            name: fm.name,
+            description: fm.description,
+            type: fm.type,
+            gates: fm.gates ?? [],
+        });
+    }
+    out.sort((a, b) => a.name.localeCompare(b.name));
+    return { skills: out };
+}
+function parseFrontmatter(raw) {
+    const stripped = raw.startsWith("") ? raw.slice(1) : raw;
+    const m = stripped.match(/^---\r?\n([\s\S]*?)\r?\n---/);
+    if (!m)
+        return null;
+    try {
+        return parseYaml(m[1]);
+    }
+    catch {
+        return null;
+    }
+}

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

@@ -0,0 +1,14 @@
+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.
+ *
+ * User-layer persona is currently always absent (persona-user-denis.md is
+ * gitignored and not loaded by name match). Future versions read the user
+ * handle from env or config.
+ */
+export declare function loadRole(input: LoadRoleInput): Promise<LoadRoleOutput>;

package/dist/mcp/tools/load_role.js

@@ -0,0 +1,170 @@
+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 { 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.
+ *
+ * User-layer persona is currently always absent (persona-user-denis.md is
+ * gitignored and not loaded by name match). Future versions read the user
+ * handle from env or config.
+ */
+export async function loadRole(input) {
+    const roleMd = await readFile(resolveAgentMd(input.domain, input.role_name), "utf8");
+    const personaBase = await loadPersonaBase();
+    const personaUser = await loadPersonaUserLayer();
+    const persona = mergePersona(personaBase, personaUser);
+    const skillsForRole = await listSkills({
+        domain: input.domain,
+        owner: input.role_name,
+    });
+    // Prefer real RoleFrontmatter from disk (post-walkthrough). If absent or
+    // invalid, fall back to synthesis from role name + ROLE_TO_GATES table. The
+    // fallback preserves load_role behaviour for un-migrated domains.
+    const parsed = parseRoleFrontmatter(roleMd, input.domain);
+    const role = parsed ?? {
+        name: input.role_name,
+        description: extractFirstHeading(roleMd) ?? `Agent: ${input.role_name}`,
+        domain: input.domain,
+        signs_off_at: inferSignsOffAt(input.role_name),
+        tool_allowlist: `role:${input.role_name}`,
+        budget_lines: 250,
+        schema_version: 1,
+    };
+    const role_body = parsed ? stripFrontmatter(roleMd) : roleMd;
+    return {
+        role,
+        role_body,
+        persona,
+        tool_allowlist: [], // resolved by hook layer from role.tool_allowlist; empty in prototype
+        available_skills: skillsForRole.skills.map((s) => s.name),
+    };
+}
+/**
+ * Parse RoleFrontmatter from agent.md. Returns null on missing frontmatter,
+ * malformed YAML, or zod validation failure — caller falls back to synthesis.
+ *
+ * Also enforces that the frontmatter `domain` matches the requesting domain;
+ * mismatch returns null to prevent cross-domain role load via misplaced file.
+ */
+function parseRoleFrontmatter(raw, expectedDomain) {
+    const stripped = raw.startsWith("") ? raw.slice(1) : raw;
+    const m = stripped.match(/^---\r?\n([\s\S]*?)\r?\n---/);
+    if (!m)
+        return null;
+    let yaml;
+    try {
+        yaml = parseYaml(m[1]);
+    }
+    catch {
+        return null;
+    }
+    const parsed = RoleFrontmatter.safeParse(yaml);
+    if (!parsed.success)
+        return null;
+    if (parsed.data.domain !== expectedDomain)
+        return null;
+    return parsed.data;
+}
+function stripFrontmatter(raw) {
+    const stripped = raw.startsWith("") ? raw.slice(1) : 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);
+    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.
+    return parsePersonaMarkdown(raw, "base");
+}
+async function loadPersonaUserLayer() {
+    // No automatic user-layer load in prototype — gitignored file, no handle resolution.
+    return null;
+}
+function parsePersonaMarkdown(raw, layer) {
+    const today = new Date().toISOString().slice(0, 10);
+    const sections = ["epistemic_stance", "defaults", "values", "style"];
+    const result = {
+        epistemic_stance: [],
+        defaults: [],
+        values: [],
+        style: [],
+    };
+    for (const section of sections) {
+        const headingRe = new RegExp(`^##\\s+${section.replace(/_/g, "[ _-]")}\\b`, "im");
+        const m = raw.match(headingRe);
+        if (!m || m.index === undefined)
+            continue;
+        const start = m.index + m[0].length;
+        const rest = raw.slice(start);
+        const nextHeading = rest.search(/^##\s+/m);
+        const body = nextHeading === -1 ? rest : rest.slice(0, nextHeading);
+        for (const line of body.split(/\r?\n/)) {
+            const item = line.match(/^\s*[-*]\s+(.+)$/);
+            if (!item)
+                continue;
+            result[section].push({
+                value: item[1].trim(),
+                provenance: [
+                    { source: "manual", ref: "persona-base.md", date: today },
+                ],
+            });
+        }
+    }
+    if (layer === "base") {
+        return {
+            schema_version: 1,
+            layer: "base",
+            ...result,
+        };
+    }
+    return {
+        schema_version: 1,
+        layer: "user",
+        user_handle: "unknown",
+        local_only: true,
+        ...result,
+    };
+}
+function mergePersona(base, user) {
+    const empty = { epistemic_stance: [], defaults: [], values: [], style: [] };
+    const b = base ?? { ...empty };
+    const u = user ?? { ...empty };
+    return {
+        base_version: base ? "1" : "0",
+        user_handle: user?.user_handle ?? null,
+        epistemic_stance: [...b.epistemic_stance, ...u.epistemic_stance],
+        defaults: [...b.defaults, ...u.defaults],
+        values: [...b.values, ...u.values],
+        style: [...b.style, ...u.style],
+    };
+}
+function extractFirstHeading(md) {
+    const m = md.match(/^#\s+(.+)$/m);
+    return m ? m[1].trim() : null;
+}
+function inferSignsOffAt(role) {
+    // Mirror ROLE_TO_GATES from migrate-frontmatter.ts. Hardcoded for prototype.
+    const map = {
+        architect: ["ARCH"],
+        conductor: ["PM", "UX", "ARCH", "DEV", "REV", "OPS", "TEST", "RG"],
+        devops: ["OPS"],
+        product_manager: ["PM"],
+        reviewer: ["REV"],
+        senior_full_stack: ["DEV"],
+        tester: ["TEST"],
+        ux_ui_designer: ["UX"],
+    };
+    return map[role] ?? ["RG"];
+}

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

@@ -0,0 +1,13 @@
+import { type RecentDecisionsInput, type RecentDecisionsOutput } from "../../shared/index.js";
+/**
+ * Returns the most recent record_decision entries, sorted desc by timestamp.
+ *
+ * Backed by `DecisionStore` (DEV-099) — defaults to `JsonlStore` reading
+ * `.code-ai/state/decisions.jsonl`. When `decision_store: "mempalace"` is set
+ * in `.code-ai/config.json`, `MempalaceStore` is selected but reads still come
+ * from JSONL (canonical) — see `../stores/mempalace_store.ts`.
+ *
+ * Skips `ADR-PENDING-*` entries — those come from request_decision (not yet
+ * resolved). Filters by domain when provided (mapped to ADR id prefix).
+ */
+export declare function recentDecisions(input: RecentDecisionsInput): Promise<RecentDecisionsOutput>;