code-ai-installer 3.0.0 → 4.0.1-a

package/dist/mcp/scorecard.d.ts

@@ -0,0 +1,140 @@
+import { z } from "zod";
+import type { TaskState } from "./task_state.js";
+/**
+ * Run scorecard — a compact, per-pipeline-run summary derived ENTIRELY from
+ * telemetry the MCP state machine already persists (task state + jsonl side
+ * logs). One scorecard is appended to the run ledger when a run completes
+ * (RG signed). The Auditor's aggregation tool crunches >=3 of these.
+ *
+ * Deliberately records raw signals, not judgments — interpretation belongs to
+ * the aggregator (numbers) and, later, the Auditor agent (findings).
+ *
+ * Attribution note: scorecards record GATES, not agents. The gate→agent mapping
+ * lives in pipeline.yaml (produced_by) and is applied at aggregation time, so
+ * the ledger never duplicates that mapping (single source).
+ */
+export declare const SCORECARD_SCHEMA_VERSION: 1;
+export declare const GateScore: z.ZodObject<{
+    gate: z.ZodEnum<{
+        PM: "PM";
+        UX: "UX";
+        ARCH: "ARCH";
+        DEV: "DEV";
+        REV: "REV";
+        OPS: "OPS";
+        TEST: "TEST";
+        RG: "RG";
+        STRATEGIST: "STRATEGIST";
+        RESEARCHER: "RESEARCHER";
+        COPYWRITER: "COPYWRITER";
+        VISUAL_CONCEPT: "VISUAL_CONCEPT";
+        REVIEWER: "REVIEWER";
+        RELEASE_GATE: "RELEASE_GATE";
+        INTERVIEWER: "INTERVIEWER";
+        DATA_ANALYST: "DATA_ANALYST";
+        MEDIATOR: "MEDIATOR";
+        DESIGNER: "DESIGNER";
+        LAYOUTER: "LAYOUTER";
+        DISCOVERY: "DISCOVERY";
+        PRODUCT_STRATEGIST: "PRODUCT_STRATEGIST";
+        UX_DESIGNER: "UX_DESIGNER";
+        TECH_LEAD: "TECH_LEAD";
+    }>;
+    signoff_count: z.ZodNumber;
+    last_signer: z.ZodNullable<z.ZodEnum<{
+        den: "den";
+        mcp: "mcp";
+        system: "system";
+    }>>;
+    classification: z.ZodNullable<z.ZodEnum<{
+        auto_resolve: "auto_resolve";
+        fork: "fork";
+        exception: "exception";
+    }>>;
+    exceptions_count: z.ZodNumber;
+}, z.core.$strip>;
+export type GateScore = z.infer<typeof GateScore>;
+export declare const SkillInvocationScore: z.ZodObject<{
+    skill: z.ZodString;
+    gate: z.ZodNullable<z.ZodString>;
+    count: z.ZodNumber;
+}, z.core.$strip>;
+export type SkillInvocationScore = z.infer<typeof SkillInvocationScore>;
+export declare const RunScorecard: z.ZodObject<{
+    schema_version: z.ZodLiteral<1>;
+    task_id: z.ZodString;
+    mode: z.ZodEnum<{
+        full: "full";
+        bugfix: "bugfix";
+        hotfix: "hotfix";
+    }>;
+    completed: z.ZodBoolean;
+    created_at: z.ZodString;
+    completed_at: z.ZodNullable<z.ZodString>;
+    gates: z.ZodArray<z.ZodObject<{
+        gate: z.ZodEnum<{
+            PM: "PM";
+            UX: "UX";
+            ARCH: "ARCH";
+            DEV: "DEV";
+            REV: "REV";
+            OPS: "OPS";
+            TEST: "TEST";
+            RG: "RG";
+            STRATEGIST: "STRATEGIST";
+            RESEARCHER: "RESEARCHER";
+            COPYWRITER: "COPYWRITER";
+            VISUAL_CONCEPT: "VISUAL_CONCEPT";
+            REVIEWER: "REVIEWER";
+            RELEASE_GATE: "RELEASE_GATE";
+            INTERVIEWER: "INTERVIEWER";
+            DATA_ANALYST: "DATA_ANALYST";
+            MEDIATOR: "MEDIATOR";
+            DESIGNER: "DESIGNER";
+            LAYOUTER: "LAYOUTER";
+            DISCOVERY: "DISCOVERY";
+            PRODUCT_STRATEGIST: "PRODUCT_STRATEGIST";
+            UX_DESIGNER: "UX_DESIGNER";
+            TECH_LEAD: "TECH_LEAD";
+        }>;
+        signoff_count: z.ZodNumber;
+        last_signer: z.ZodNullable<z.ZodEnum<{
+            den: "den";
+            mcp: "mcp";
+            system: "system";
+        }>>;
+        classification: z.ZodNullable<z.ZodEnum<{
+            auto_resolve: "auto_resolve";
+            fork: "fork";
+            exception: "exception";
+        }>>;
+        exceptions_count: z.ZodNumber;
+    }, z.core.$strip>>;
+    dev_rollback_count: z.ZodNumber;
+    circuit_breaker_tripped: z.ZodBoolean;
+    exceptions_count: z.ZodNumber;
+    decisions_count: z.ZodNumber;
+    skill_invocations: z.ZodDefault<z.ZodArray<z.ZodObject<{
+        skill: z.ZodString;
+        gate: z.ZodNullable<z.ZodString>;
+        count: z.ZodNumber;
+    }, z.core.$strip>>>;
+}, z.core.$strip>;
+export type RunScorecard = z.infer<typeof RunScorecard>;
+/** Side telemetry the builder cannot read from task state alone. */
+export type ScorecardExtras = {
+    /** Exceptions grouped by gate name (from exceptions.jsonl). */
+    exceptions_by_gate: Partial<Record<string, number>>;
+    /** Total ADR decisions recorded for the task (from decisions.jsonl). */
+    decisions_count: number;
+    /** Raw skill-invocation events for the task (from skill_invocations.jsonl). */
+    skill_invocations?: Array<{
+        skill: string;
+        gate: string | null;
+    }>;
+};
+/**
+ * Build a run scorecard from a task's persisted state plus side-log counts.
+ * Pure + synchronous: deterministic and unit-testable on synthetic state.
+ */
+export declare function buildScorecard(state: TaskState, extras: ScorecardExtras): RunScorecard;

package/dist/mcp/scorecard.js

@@ -0,0 +1,103 @@
+import { z } from "zod";
+import { ClassificationOutcome, GateName, PipelineMode, Signer, } from "../shared/index.js";
+/**
+ * Run scorecard — a compact, per-pipeline-run summary derived ENTIRELY from
+ * telemetry the MCP state machine already persists (task state + jsonl side
+ * logs). One scorecard is appended to the run ledger when a run completes
+ * (RG signed). The Auditor's aggregation tool crunches >=3 of these.
+ *
+ * Deliberately records raw signals, not judgments — interpretation belongs to
+ * the aggregator (numbers) and, later, the Auditor agent (findings).
+ *
+ * Attribution note: scorecards record GATES, not agents. The gate→agent mapping
+ * lives in pipeline.yaml (produced_by) and is applied at aggregation time, so
+ * the ledger never duplicates that mapping (single source).
+ */
+export const SCORECARD_SCHEMA_VERSION = 1;
+export const GateScore = z.object({
+    gate: GateName,
+    /** How many sign-offs this gate received. >1 means the gate was reworked. */
+    signoff_count: z.number().int().nonnegative(),
+    last_signer: Signer.nullable(),
+    /** Latest classification outcome recorded for the gate, if any. */
+    classification: ClassificationOutcome.nullable(),
+    /** Exceptions filed AT this gate (from exceptions.jsonl, grouped by gate). */
+    exceptions_count: z.number().int().nonnegative(),
+});
+export const SkillInvocationScore = z.object({
+    skill: z.string(),
+    /** Gate the skill was pulled at, or null. String (not GateName) — tolerant of
+     *  hand-edited telemetry; this is a surfacing layer, not gate-machine state. */
+    gate: z.string().nullable(),
+    count: z.number().int().positive(),
+});
+export const RunScorecard = z.object({
+    schema_version: z.literal(SCORECARD_SCHEMA_VERSION),
+    task_id: z.string().min(1),
+    mode: PipelineMode,
+    /** True when an RG sign-off exists (the state machine does not set completed_at). */
+    completed: z.boolean(),
+    created_at: z.string(),
+    /** Timestamp of the RG sign-off, or null if not completed. */
+    completed_at: z.string().nullable(),
+    gates: z.array(GateScore),
+    dev_rollback_count: z.number().int().nonnegative(),
+    circuit_breaker_tripped: z.boolean(),
+    exceptions_count: z.number().int().nonnegative(),
+    decisions_count: z.number().int().nonnegative(),
+    /** Skills pulled via get_skill during the run, grouped by skill+gate. */
+    skill_invocations: z.array(SkillInvocationScore).default([]),
+});
+/**
+ * Build a run scorecard from a task's persisted state plus side-log counts.
+ * Pure + synchronous: deterministic and unit-testable on synthetic state.
+ */
+export function buildScorecard(state, extras) {
+    // Group sign-offs by gate: count + last signer (last in chronological array).
+    const signoffCount = new Map();
+    const lastSigner = new Map();
+    for (const s of state.signoffs) {
+        signoffCount.set(s.gate, (signoffCount.get(s.gate) ?? 0) + 1);
+        lastSigner.set(s.gate, s.signer);
+    }
+    // Latest classification per gate (last wins).
+    const lastClass = new Map();
+    for (const c of state.classifications)
+        lastClass.set(c.gate, c.outcome);
+    // Union of gates that have any signal (signoff or classification).
+    const gateNames = new Set([...signoffCount.keys(), ...lastClass.keys()]);
+    const gates = [...gateNames].sort().map((gate) => ({
+        gate: gate,
+        signoff_count: signoffCount.get(gate) ?? 0,
+        last_signer: lastSigner.get(gate) ?? null,
+        classification: lastClass.get(gate) ?? null,
+        exceptions_count: extras.exceptions_by_gate[gate] ?? 0,
+    }));
+    const rgSignoffs = state.signoffs.filter((s) => s.gate === "RG");
+    const completed = rgSignoffs.length > 0;
+    const completed_at = completed ? rgSignoffs[rgSignoffs.length - 1].timestamp : null;
+    const exceptions_count = Object.values(extras.exceptions_by_gate).reduce((a, b) => a + (b ?? 0), 0);
+    // Group skill invocations by skill + gate into counts.
+    const skillAgg = new Map();
+    for (const ev of extras.skill_invocations ?? []) {
+        const key = `${ev.skill}|${ev.gate ?? ""}`;
+        const e = skillAgg.get(key) ?? { skill: ev.skill, gate: ev.gate, count: 0 };
+        e.count++;
+        skillAgg.set(key, e);
+    }
+    const skill_invocations = [...skillAgg.values()].sort((a, b) => (a.skill + (a.gate ?? "")).localeCompare(b.skill + (b.gate ?? "")));
+    return RunScorecard.parse({
+        schema_version: SCORECARD_SCHEMA_VERSION,
+        task_id: state.task_id,
+        mode: state.mode,
+        completed,
+        created_at: state.created_at,
+        completed_at,
+        gates,
+        dev_rollback_count: state.dev_rollback_count,
+        circuit_breaker_tripped: state.audit_required_at !== undefined,
+        exceptions_count,
+        decisions_count: extras.decisions_count,
+        skill_invocations,
+    });
+}

package/dist/mcp/server.d.ts

@@ -0,0 +1,24 @@
+import type { z } from "zod";
+import { TOOL_REGISTRY, type ToolName } from "../shared/index.js";
+import { type ToolHandler } from "./tools/stubs.js";
+/**
+ * Minimal MCP-style dispatch surface.
+ *
+ * Real wiring (stdio / WS / Claude Code transport) lands in pre-req #3.
+ * This class exists so callers can hold a typed dispatcher today.
+ */
+export declare class CodeAiMcpServer {
+    private readonly handlers;
+    constructor(overrides?: Partial<{
+        [N in ToolName]: ToolHandler<N>;
+    }>);
+    /** Replace a single handler — used by prototype to ship one tool at a time. */
+    setHandler<N extends ToolName>(name: N, handler: ToolHandler<N>): void;
+    /**
+     * Dispatch by tool name. Input is validated against the contract; output is
+     * also validated before return so a buggy handler can't ship malformed data.
+     */
+    call<N extends ToolName>(name: N, rawInput: unknown): Promise<z.infer<(typeof TOOL_REGISTRY)[N]["output"]>>;
+    /** List every tool name registered in the contracts. */
+    listTools(): ToolName[];
+}

package/dist/mcp/server.js

@@ -0,0 +1,33 @@
+import { TOOL_REGISTRY } from "../shared/index.js";
+import { DEFAULT_HANDLERS } from "./tools/stubs.js";
+/**
+ * Minimal MCP-style dispatch surface.
+ *
+ * Real wiring (stdio / WS / Claude Code transport) lands in pre-req #3.
+ * This class exists so callers can hold a typed dispatcher today.
+ */
+export class CodeAiMcpServer {
+    handlers;
+    constructor(overrides = {}) {
+        this.handlers = { ...DEFAULT_HANDLERS, ...overrides };
+    }
+    /** Replace a single handler — used by prototype to ship one tool at a time. */
+    setHandler(name, handler) {
+        this.handlers[name] =
+            handler;
+    }
+    /**
+     * Dispatch by tool name. Input is validated against the contract; output is
+     * also validated before return so a buggy handler can't ship malformed data.
+     */
+    async call(name, rawInput) {
+        const { input, output } = TOOL_REGISTRY[name];
+        const parsedInput = input.parse(rawInput);
+        const result = await this.handlers[name](parsedInput);
+        return output.parse(result);
+    }
+    /** List every tool name registered in the contracts. */
+    listTools() {
+        return Object.keys(TOOL_REGISTRY);
+    }
+}

package/dist/mcp/skill_invocations.d.ts

@@ -0,0 +1,15 @@
+/**
+ * Skill-invocation telemetry. A `get_skill` fetch associated with a run is the
+ * invocation signal — the agent decided the skill was relevant and pulled it.
+ * Append-only JSONL; one event per line. Read back per task by the scorecard
+ * builder. Best-effort by contract: a logging failure must never break a read.
+ */
+export type SkillInvocation = {
+    task_id: string;
+    gate: string | null;
+    skill: string;
+    timestamp: string;
+};
+export declare function recordSkillInvocation(ev: SkillInvocation): Promise<void>;
+/** All invocation events for one task. Malformed / partial lines are skipped. */
+export declare function readSkillInvocations(taskId: string): Promise<SkillInvocation[]>;

package/dist/mcp/skill_invocations.js

@@ -0,0 +1,28 @@
+import { mkdir, readFile, appendFile } from "node:fs/promises";
+import { dirname } from "node:path";
+import { resolveSkillInvocationsPath } from "./paths.js";
+export async function recordSkillInvocation(ev) {
+    const path = resolveSkillInvocationsPath();
+    await mkdir(dirname(path), { recursive: true });
+    await appendFile(path, JSON.stringify(ev) + "\n", "utf8");
+}
+/** All invocation events for one task. Malformed / partial lines are skipped. */
+export async function readSkillInvocations(taskId) {
+    const raw = await readFile(resolveSkillInvocationsPath(), "utf8").catch(() => "");
+    if (!raw)
+        return [];
+    const out = [];
+    for (const line of raw.split("\n")) {
+        if (!line.trim())
+            continue;
+        try {
+            const o = JSON.parse(line);
+            if (o.task_id === taskId)
+                out.push(o);
+        }
+        catch {
+            continue;
+        }
+    }
+    return out;
+}

package/dist/mcp/stores/index.d.ts

@@ -0,0 +1,15 @@
+import type { DecisionStore } from "../decision_store.js";
+/**
+ * Factory — picks the decision store backend based on `.code-ai/config.json`.
+ *
+ * Safe default: `JsonlStore` (no external deps). Selecting `mempalace` wraps
+ * JsonlStore in MempalaceStore for opt-in mirroring.
+ *
+ * Construct fresh per call: the underlying file I/O is cheap and the runtime
+ * config could change between calls in long-running scenarios (rare but
+ * cheap to handle). For most callers a single store instance per tool call
+ * is fine.
+ */
+export declare function buildDecisionStore(): Promise<DecisionStore>;
+export { JsonlStore } from "./jsonl_store.js";
+export { MempalaceStore } from "./mempalace_store.js";

package/dist/mcp/stores/index.js

@@ -0,0 +1,24 @@
+import { loadCodeAiConfig } from "../config.js";
+import { JsonlStore } from "./jsonl_store.js";
+import { MempalaceStore } from "./mempalace_store.js";
+/**
+ * Factory — picks the decision store backend based on `.code-ai/config.json`.
+ *
+ * Safe default: `JsonlStore` (no external deps). Selecting `mempalace` wraps
+ * JsonlStore in MempalaceStore for opt-in mirroring.
+ *
+ * Construct fresh per call: the underlying file I/O is cheap and the runtime
+ * config could change between calls in long-running scenarios (rare but
+ * cheap to handle). For most callers a single store instance per tool call
+ * is fine.
+ */
+export async function buildDecisionStore() {
+    const cfg = await loadCodeAiConfig();
+    const jsonl = new JsonlStore();
+    if (cfg.decision_store === "mempalace") {
+        return new MempalaceStore(jsonl, cfg.mempalace_command, cfg.mempalace_args);
+    }
+    return jsonl;
+}
+export { JsonlStore } from "./jsonl_store.js";
+export { MempalaceStore } from "./mempalace_store.js";

package/dist/mcp/stores/jsonl_store.d.ts

@@ -0,0 +1,18 @@
+import type { DecisionLogEntry, DecisionLogInput, DecisionReadFilters, DecisionStore } from "../decision_store.js";
+/**
+ * Canonical decision-log backend. Appends JSON lines to
+ * `.code-ai/state/decisions.jsonl` (cwd-relative); reads back with optional
+ * filters.
+ *
+ * This is the baseline implementation lifted from the pre-DEV-099
+ * `record_decision.appendDecisionLog` helper, the `recent_decisions` reader,
+ * and the `audit_trail` decision-log merging code. Behaviour preserved except
+ * for one normalization: new writes emit the `adr_id` field (snake_case) only;
+ * reads tolerate the legacy `adrId` field too.
+ */
+export declare class JsonlStore implements DecisionStore {
+    /** Returns the `.code-ai/state/decisions.jsonl` path for the current cwd. */
+    private logPath;
+    appendDecision(entry: DecisionLogInput): Promise<string>;
+    readDecisions(filters: DecisionReadFilters): Promise<DecisionLogEntry[]>;
+}

package/dist/mcp/stores/jsonl_store.js

@@ -0,0 +1,85 @@
+import { appendFile, mkdir, readFile } from "node:fs/promises";
+import { join } from "node:path";
+/**
+ * Canonical decision-log backend. Appends JSON lines to
+ * `.code-ai/state/decisions.jsonl` (cwd-relative); reads back with optional
+ * filters.
+ *
+ * This is the baseline implementation lifted from the pre-DEV-099
+ * `record_decision.appendDecisionLog` helper, the `recent_decisions` reader,
+ * and the `audit_trail` decision-log merging code. Behaviour preserved except
+ * for one normalization: new writes emit the `adr_id` field (snake_case) only;
+ * reads tolerate the legacy `adrId` field too.
+ */
+export class JsonlStore {
+    /** Returns the `.code-ai/state/decisions.jsonl` path for the current cwd. */
+    logPath() {
+        return join(process.cwd(), ".code-ai", "state", "decisions.jsonl");
+    }
+    async appendDecision(entry) {
+        const stateDir = join(process.cwd(), ".code-ai", "state");
+        await mkdir(stateDir, { recursive: true });
+        const drawerId = `${entry.adr_id}#${Date.now()}`;
+        const line = JSON.stringify({
+            drawer_id: drawerId,
+            adr_id: entry.adr_id,
+            task_id: entry.task_id,
+            gate: entry.gate,
+            question: entry.question,
+            chosen_option_id: entry.chosen_option_id,
+            signer: entry.signer,
+            timestamp: entry.timestamp,
+        }) + "\n";
+        await appendFile(this.logPath(), line, "utf8");
+        return drawerId;
+    }
+    async readDecisions(filters) {
+        const raw = await readFile(this.logPath(), "utf8").catch(() => "");
+        if (!raw)
+            return [];
+        const out = [];
+        const domainPrefix = filters.domain
+            ? `ADR-${filters.domain.slice(0, 3).toUpperCase()}-`
+            : null;
+        for (const line of raw.split("\n")) {
+            if (line.length === 0)
+                continue;
+            let obj;
+            try {
+                obj = JSON.parse(line);
+            }
+            catch {
+                continue;
+            }
+            // Tolerate legacy `adrId` field name from pre-DEV-099 writes.
+            const adrId = (obj.adr_id ?? obj.adrId);
+            if (!adrId)
+                continue;
+            if (!filters.includePending && adrId.startsWith("ADR-PENDING-"))
+                continue;
+            if (domainPrefix && !adrId.startsWith(domainPrefix))
+                continue;
+            if (filters.task_id && obj.task_id !== filters.task_id)
+                continue;
+            if (filters.signer && obj.signer !== filters.signer)
+                continue;
+            if (filters.since &&
+                typeof obj.timestamp === "string" &&
+                obj.timestamp < filters.since) {
+                continue;
+            }
+            out.push({
+                drawer_id: obj.drawer_id ?? `${adrId}#0`,
+                adr_id: adrId,
+                task_id: obj.task_id ?? "",
+                gate: obj.gate ?? "",
+                question: obj.question ?? "",
+                chosen_option_id: obj.chosen_option_id ?? "",
+                signer: obj.signer ?? "",
+                timestamp: obj.timestamp ?? "",
+            });
+        }
+        out.sort((a, b) => a.timestamp.localeCompare(b.timestamp));
+        return out;
+    }
+}

package/dist/mcp/stores/mempalace_store.d.ts

@@ -0,0 +1,29 @@
+import type { DecisionLogEntry, DecisionLogInput, DecisionReadFilters, DecisionStore } from "../decision_store.js";
+/**
+ * Opt-in mirror that wraps a canonical `JsonlStore`. On `appendDecision`:
+ *
+ *   1. Inner JSONL write runs FIRST and MUST succeed (canonical source of truth).
+ *   2. Spawn MemPalace MCP server via StdioClientTransport (per ADR-DEV-099
+ *      gate-1 choice Q1=Variant A — spawn-on-demand, no long-lived connection),
+ *      connect, call `mempalace_add_drawer` + `mempalace_kg_add`, then close.
+ *   3. ANY MemPalace error is caught and logged to stderr. JSONL succeeded;
+ *      data is not lost. Graceful degradation per ADR-DEV-098 Amendment 2026-06-02.
+ *
+ * `readDecisions` delegates to the inner store unchanged — JSONL is canonical.
+ * Future enrichment with MemPalace drawer queries is explicitly deferred.
+ */
+export declare class MempalaceStore implements DecisionStore {
+    private readonly inner;
+    private readonly mempalaceCommand;
+    private readonly mempalaceArgs;
+    constructor(inner: DecisionStore, mempalaceCommand: string, mempalaceArgs: string[]);
+    appendDecision(entry: DecisionLogInput): Promise<string>;
+    readDecisions(filters: DecisionReadFilters): Promise<DecisionLogEntry[]>;
+    /**
+     * Send the decision to MemPalace as a drawer + KG triple. Each invocation
+     * spawns a fresh MemPalace process; latency cost (~500ms-2s) is acceptable
+     * because record_decision is a rare operation.
+     */
+    private mirrorToMempalace;
+    private formatDrawerContent;
+}

package/dist/mcp/stores/mempalace_store.js

@@ -0,0 +1,89 @@
+import { Client } from "@modelcontextprotocol/sdk/client/index.js";
+import { StdioClientTransport } from "@modelcontextprotocol/sdk/client/stdio.js";
+/**
+ * Opt-in mirror that wraps a canonical `JsonlStore`. On `appendDecision`:
+ *
+ *   1. Inner JSONL write runs FIRST and MUST succeed (canonical source of truth).
+ *   2. Spawn MemPalace MCP server via StdioClientTransport (per ADR-DEV-099
+ *      gate-1 choice Q1=Variant A — spawn-on-demand, no long-lived connection),
+ *      connect, call `mempalace_add_drawer` + `mempalace_kg_add`, then close.
+ *   3. ANY MemPalace error is caught and logged to stderr. JSONL succeeded;
+ *      data is not lost. Graceful degradation per ADR-DEV-098 Amendment 2026-06-02.
+ *
+ * `readDecisions` delegates to the inner store unchanged — JSONL is canonical.
+ * Future enrichment with MemPalace drawer queries is explicitly deferred.
+ */
+export class MempalaceStore {
+    inner;
+    mempalaceCommand;
+    mempalaceArgs;
+    constructor(inner, mempalaceCommand, mempalaceArgs) {
+        this.inner = inner;
+        this.mempalaceCommand = mempalaceCommand;
+        this.mempalaceArgs = mempalaceArgs;
+    }
+    async appendDecision(entry) {
+        const drawerId = await this.inner.appendDecision(entry);
+        await this.mirrorToMempalace(entry, drawerId).catch((err) => {
+            const message = err instanceof Error ? err.message : String(err);
+            process.stderr.write(`[code-ai-mcp] MemPalace mirror failed (decision still recorded in JSONL): ${message}\n`);
+        });
+        return drawerId;
+    }
+    async readDecisions(filters) {
+        return this.inner.readDecisions(filters);
+    }
+    /**
+     * Send the decision to MemPalace as a drawer + KG triple. Each invocation
+     * spawns a fresh MemPalace process; latency cost (~500ms-2s) is acceptable
+     * because record_decision is a rare operation.
+     */
+    async mirrorToMempalace(entry, drawerId) {
+        const transport = new StdioClientTransport({
+            command: this.mempalaceCommand,
+            args: this.mempalaceArgs,
+            stderr: "pipe",
+        });
+        const client = new Client({
+            name: "code-ai-mcp-mempalace-mirror",
+            version: "0.1.0",
+        });
+        try {
+            await client.connect(transport);
+            await client.callTool({
+                name: "mempalace_add_drawer",
+                arguments: {
+                    wing: "wing_codex_product",
+                    room: "decisions",
+                    content: this.formatDrawerContent(entry, drawerId),
+                    added_by: "code-ai-mcp",
+                },
+            });
+            await client.callTool({
+                name: "mempalace_kg_add",
+                arguments: {
+                    subject: entry.task_id,
+                    predicate: "decided",
+                    object: entry.chosen_option_id,
+                    valid_from: entry.timestamp.slice(0, 10),
+                },
+            });
+        }
+        finally {
+            await client.close().catch(() => undefined);
+            await transport.close().catch(() => undefined);
+        }
+    }
+    formatDrawerContent(entry, drawerId) {
+        return [
+            `ADR ${entry.adr_id} — ${entry.question}`,
+            ``,
+            `Task: ${entry.task_id}`,
+            `Gate: ${entry.gate}`,
+            `Chosen option: ${entry.chosen_option_id}`,
+            `Signer: ${entry.signer}`,
+            `Timestamp: ${entry.timestamp}`,
+            `Drawer id: ${drawerId}`,
+        ].join("\n");
+    }
+}