code-ai-installer 4.0.0 → 4.0.1-b

package/README.md

@@ -1,7 +1,7 @@
 <div align="center">
   <h1>🤖 Code-AI Installer</h1>
-  <p><b>The ultimate CLI tool to orchestrate AI Agents, Skills, and Workflows across multiple AI Coding Assistants.</b></p>
-  
+  <p><b>Write a gated, multi-agent pipeline once — deploy it to any AI coding assistant, and run it through a bundled MCP orchestration server.</b></p>
+
   [![npm version](https://img.shields.io/npm/v/code-ai-installer.svg)](https://www.npmjs.com/package/code-ai-installer)
   [![License: MIT](https://img.shields.io/badge/License-MIT-blue.svg)](https://opensource.org/licenses/MIT)
   [![Node.js](https://img.shields.io/badge/Node.js-%3E%3D20-green.svg)](https://nodejs.org)
@@ -9,149 +9,165 @@
 
 <br/>
 
-**Code-AI Installer** (`code-ai`) is a powerful, production-ready CLI that injects your `.agents/`, `.agents/skills/`, and `.agents/workflows/` directly into the specific environment layouts required by different AI tools. Write your agentic pipelines once, and deploy them universally to Copilot, Codex, Claude, Qwen, or Google Antigravity.
+**Code-AI Installer** ships two things in one npm package:
+
+1. **`code-ai`** — a production-ready CLI that injects your `.agents/`, `.agents/skills/`, and `.agents/workflows/` into the exact environment layout each AI tool expects. Author your agentic pipelines once, deploy them to Copilot, Codex, Claude, Qwen, Kimi, or Google Antigravity.
+2. **`code-ai-mcp`** — a bundled MCP (Model Context Protocol) server that turns those agents and skills into a **governed, gate-by-gate pipeline**: each stage produces an artifact, gets classified, and waits for a human sign-off before the next stage runs. Auto-registered for Claude via `.mcp.json`.
+
+> The agents, the skills, and the MCP server are one product: the agents assume the MCP gate tools exist, and the MCP server assumes the installer registered it. `npm install -g code-ai-installer` brings the whole thing.
 
 ---
 
 ## ✨ Features
 
-- 🚀 **Interactive Wizard**: Out-of-the-box interactive CLI to easily pick targets, agents, and skills.
-- 🌍 **Multi-AI Support**: Automatically adapts instructions, reasoning hints, and files for Copilot, GPT Codex, Claude, Qwen 3.5, and Google Antigravity.
-- 📦 **Standalone & Global**: Bundled with base templates—run it from anywhere on your machine!
-- 🛡️ **Bulletproof Safety**: Default `dry-run` mode, automatic backups to `.code-ai-installer/backups/`, and built-in rollbacks.
-- 🧠 **Smart Transformation**: Normalizes markdown content. Automatically translates target-native AI hints (e.g., mapping `codex reasoning` to `claude thinking` or `gemini reasoning`).
-- 🌐 **Localization**: First-class support for English (`en`) and Russian (`ru`).
+- 🚪 **Gate-based pipeline** — agents don't free-run. Work advances through ordered gates (classify → produce → human sign-off → advance), enforced by the MCP server's state machine, with a circuit breaker on repeated rollbacks.
+- 🧰 **Bundled MCP server** — `code-ai-mcp` exposes 31 tools (gate machine, skill fetch with telemetry, artifact/decision log, audit + action tools). Auto-wired into Claude's `.mcp.json` at install time.
+- 🔭 **Self-improving Auditor** — a meta-agent reads aggregate run metrics after ≥3 completed runs and *proposes* (never forces) tweaks to skills/agents; the human approves.
+- 🚀 **Interactive wizard** — pick target, domain, agents, and skills from a guided CLI.
+- 🌍 **Multi-AI support** — adapts instructions, reasoning hints, and file layout for Copilot, GPT Codex, Claude, Qwen 3.5, Moonshot Kimi, and Google Antigravity.
+- 🛡️ **Bulletproof safety** — default `dry-run`, automatic backups, built-in rollbacks.
+- 🧠 **Smart transformation** — normalizes markdown and translates native AI hints (e.g. maps `codex reasoning` to `claude thinking` / `gemini reasoning`).
+- 🌐 **Localization** — first-class English (`en`) and Russian (`ru`).
 
 ---
 
 ## 🏛️ Domain Architecture
 
-Code-AI Installer comes pre-bundled with dedicated professional systems separated by **Domains** to cleanly isolate workflows based on your project needs. You can choose which domain to deploy during installation:
+Code-AI ships dedicated, self-contained professional systems separated by **domain**, each with its own roles, skills, and gate pipeline. Pick one per project at install time.
+
+| Domain | Gates | What it is |
+|---|:---:|---|
+| 💻 **`development`** | 8 | End-to-end web app delivery: PM → UX → Architecture → Dev → Review → Ops → Test → Release Gate. Roles: Product Manager, UX/UI Designer, Architect, Senior Full-Stack, Reviewer, DevOps, QA Tester. |
+| 📝 **`content`** | 6 | Digital content production: Strategist → Researcher → Copywriter → Visual Concept → Reviewer → Release Gate. |
+| 📊 **`analytics`** | 8 | Business analysis modeled adversarially (Analysts vs Critics with a Mediator): Interviewer → Researcher → Data Analyst → Strategist → Mediator → Designer → Layouter → Release Gate. Strategic frameworks (SWOT, PEST, Porter, BCG, Blue Ocean, Ansoff, Unit Economics, Cohort, …). |
+| 📦 **`product`** | 10 | B2B SaaS product management: Discovery → Product Strategist → PM → UX Designer → Tech Lead → Data Analyst → Mediator → Designer → Layouter → Release Gate. |
+
+Every domain also carries a meta **Auditor** beside the pipeline. Each skill declares structured metadata (`type`, `owners`, `gates`, `triggers`) so the MCP server can surface the right skill at the right gate. Large reference libraries are split into a lean workflow skill + a `*-reference` companion.
+
+---
+
+## 🚪 The MCP Gate Pipeline
 
-- 💻 **Software Development Domain** (`development`): An 8-gate robust agentic pipeline tailored for end-to-end web app development. Includes roles like Product Manager, UX/UI Designer, Architect, Senior Full Stack Developer, Reviewer, DevOps, and QA Tester.
-- 📝 **Content Production Domain** (`content`): A creative pipeline dedicated to producing digital content (social media, blogs, visuals). Orchestrates roles such as Content Strategist, Copywriter, Researcher, and Visual Concept Designer.
-- 📊 **Business Analytics Domain** (`analytics`): An adversarial analytical pipeline with two competing teams (Analysts vs Critics) and a Mediator — plus Designer and Layouter for PDF reports. Strategic frameworks (SWOT, PEST, Porter's Five Forces, BCG, Blue Ocean, Ansoff, Unit Economics, Cohort, etc.).
-- 📦 **Product Management Domain** (`product`): A B2B SaaS product management pipeline — discovery → strategy → prioritization → PRD → UX → release → measurement. Dual adversarial axes: Customer-Champion vs Business-Champion on strategy, Build-Camp vs Cut-Camp on prioritization. Includes Discovery, Product Strategist, PM, UX Designer, Tech Lead, Data Analyst, Mediator, Designer, Layouter.
+When you install for **Claude**, the installer registers `code-ai-mcp` in your project's `.mcp.json`. From then on, the agents drive the work *through the server*, not by free-form prompting:
 
-*(You can select your target domain during the interactive installation process!)*
+1. **`current_gate` / `classify_gate`** — the conductor reads where the run is and classifies the gate outcome (`auto_resolve` / `fork` / `exception`).
+2. **`get_skill`** — the active role fetches the skills it owns at this gate (the fetch is logged as telemetry for the Auditor).
+3. **`submit_artifact` / `verify_claim`** — the role produces its deliverable; structured frontmatter and budgets are validated.
+4. **`sign_off` → `advance_gate`** — a human (or, where wired, an auto-check) signs the gate; only then does the pipeline move on. A circuit breaker halts repeated dev rollbacks and escalates to an architecture audit.
+5. **`record_decision` / `audit_trail`** — ADR-style decisions and exceptions are logged per run.
+
+After enough completed runs, the **Auditor** calls `aggregate_run_metrics` and files `propose_change` suggestions (reviewed via `review_proposal`) — a build → run → measure → improve loop for the toolkit itself.
+
+> MCP is currently a **Claude-specific** capability. Other targets receive the agent/skill markdown and run them as plain instructions.
 
 ---
 
 ## 🎯 Supported AI Targets
 
-- `vscode-copilot` / `copilot`
-- `gpt-codex` / `codex`
-- `claude`
-- `qwen-3.5` / `qwen`
-- `google-antigravity` / `antigravity`
-- `moonshot-kimi` / `kimi` (Kimi CLI + Kimi Code for VS Code)
+| CLI target (and aliases) | Tool |
+|---|---|
+| `vscode-copilot` / `copilot` | VS Code Copilot |
+| `gpt-codex` / `codex` | GPT Codex |
+| `claude` | Claude (Claude Code) — **MCP server auto-wired** |
+| `qwen-3.5` / `qwen` | Qwen 3.5 |
+| `google-antigravity` / `antigravity` | Google Antigravity |
+| `moonshot-kimi` / `kimi` | Moonshot Kimi (Kimi CLI + Kimi Code for VS Code) |
 
 ---
 
 ## 🔧 Installation
 
-### 1. Global Installation (Recommended)
-
-Install the CLI globally to run it in any of your projects:
+### Global (recommended)
 
 ```bash
-# via npm
 npm install -g code-ai-installer
-
-# via pnpm, yarn, or bun
-pnpm add -g code-ai-installer
-yarn global add code-ai-installer
-bun add -g code-ai-installer
+# or: pnpm add -g code-ai-installer / yarn global add code-ai-installer / bun add -g code-ai-installer
 ```
 
-Verify the installation:
+Verify:
 ```bash
 code-ai --help
 ```
 
-### 2. Local Installation (For Development)
+### From source (for development / contributing)
+
+This is an npm-workspaces monorepo; the published package lives in `packages/installer`.
 
-If you are cloning this repository to build or contribute:
 ```bash
-git clone https://github.com/denish12/codex-ai-agent-and-skills.git
-cd codex-ai-agent-and-skills
+git clone https://github.com/denish12/code-ai-monorepo.git
+cd code-ai-monorepo
 npm install
 npm run build
-npm install -g .
+npm install -g ./packages/installer
 ```
 
 ---
 
 ## 🚀 Usage
 
-### The Interactive Wizard
-Just run `code-ai` inside your project directory to trigger the fully interactive guide:
+### Interactive wizard
+
+Run `code-ai` inside your project to launch the guided installer (it also offers to wire the MCP server for Claude):
+
 ```bash
 code-ai
 ```
 
-### CLI Commands & Flags
+### CLI commands & flags
 
 ```bash
-# List all supported targets
+# List supported targets
 code-ai targets
 
-# List available agents and skills (--domain required since v3.0.0)
+# List agents and skills in a domain (--domain required since v3.0.0)
 code-ai list --domain development
 code-ai list --domain content --lang en
 
-# Check system health and compatibility for a specific target + domain
+# Health-check a target + domain
 code-ai doctor --target claude --domain development
 
-# Run a safe Dry-Run installation preview (Default)
+# Dry-run preview (default — writes nothing)
 code-ai install --target claude --domain development --agents conductor,reviewer --skills board
 
-# Apply Installation (actually write files)
+# Apply for real
 code-ai install --target gpt-codex --domain analytics --agents all --skills all --apply
 
-# Overwrite existing files securely
+# Overwrite existing files
 code-ai install --target claude --domain content --agents all --skills all --overwrite --apply
 
-# Strict Mode (Enforces explicit target hints in agent files)
-code-ai install --target claude --domain product --agents all --skills all --strict-hints --apply
+# For Claude: skip the optional MemPalace memory server (code-ai-mcp is still wired)
+code-ai install --target claude --domain product --agents all --skills all --no-mempalace --apply
 
-# Uninstall / Clean up AI assets securely
+# Uninstall / clean up AI assets
 code-ai uninstall --target claude --apply
 ```
 
 ---
 
-## ⚠️ Migrating from v2.x to v3.0.0
-
-**v3.0.0 is a breaking release.** The legacy root layout (`AGENTS.md` + `agents/` + `.agents/` at package root) was removed. The CLI now exclusively reads from the `domains/<id>/` layout.
+## 🏗️ What gets generated?
 
-| Change | Before (v2.x) | After (v3.0.0) |
-|---|---|---|
-| Required flag | `--domain` optional | `--domain <name>` required (or `cwd` must contain a `domains/` directory) |
-| EN locale path | `locales/en/` | `domains/<id>/locales/en/` |
-| `--project-dir` accepts | legacy root or `domains/` layout | `domains/` layout only |
-| Bundled files | 11 entries incl. root `AGENTS.md` | 4 entries: `dist`, `LICENSE`, `README.md`, `domains` |
+Depending on `--target`, `code-ai` restructures your project:
 
-**To migrate**: add `--domain development` (or `content`, `analytics`, `product`) to every CLI call. If you used a custom source via `--project-dir`, restructure it to contain `domains/<id>/domain.json` instead of a flat `AGENTS.md` + `agents/` layout.
+1. **Orchestration entry** — `AGENTS.md` (plus tool aliases like `CLAUDE.md`, `CODEX.md`, `GEMINI.md`, `QWEN.md`, `KIMI.md`).
+2. **Agents** — roles copied into the target's layout (e.g. `.claude/agents/<role>.md`, `.github/copilot-instructions.md`).
+3. **Skills & workflows** — the execution skillsets, with per-tool metadata sidecars.
+4. **MCP wiring (Claude only)** — `.mcp.json` registering `code-ai-mcp` (run as `npx -p code-ai-installer code-ai-mcp`), plus an optional [MemPalace](https://www.npmjs.com/package/mempalace) memory server when present, and a `.code-ai/config.json` that records the active domain and decision-store backend.
 
 ---
 
-## 🏗️ What Gets Generated?
+## 🧬 Versions & migration
 
-Depending on the chosen `--target`, `code-ai` restructures your environment intelligently:
+`code-ai-installer` is on **v4.0.0**.
 
-1. **Root Orchestration Rules**: Generates `AGENTS.md` (and alias files like `CLAUDE.md`, `CODEX.md`, `GEMINI.md`, etc.).
-2. **Agents**: Copies roles to target-specific directories (e.g., `.gemini/agents/<agent>/prompt.md`, `.github/copilot-instructions.md`).
-3. **Skills & Workflows**: Deploys the necessary execution skillsets and custom workflows specific to the target AI.
-4. **Configuration**: Generates workspace settings (e.g., `.qwen/settings.json`).
+- **v4.0.0** — consolidated the previously separate `code-ai-mcp` and types packages into this single package with **two bins** (`code-ai` + `code-ai-mcp`). Installing the CLI now also delivers the MCP server; for Claude it is auto-registered in `.mcp.json`. Existing 3.x CLI behavior is unchanged.
+- **v3.0.0 (breaking)** — removed the legacy flat root layout (`AGENTS.md` + `agents/` + `.agents/` at package root); the CLI now reads exclusively from `domains/<id>/`. **Migrating from v2.x:** add `--domain <development|content|analytics|product>` to every CLI call. If you used a custom `--project-dir`, restructure it to `domains/<id>/` instead of a flat layout.
 
 ---
 
 ## 🤝 Contributing
 
-Contributions, issues, and feature requests are welcome!  
-Feel free to check out the [issues page](https://github.com/denish12/codex-ai-agent-and-skills/issues).
+Contributions, issues, and feature requests are welcome — see the [issues page](https://github.com/denish12/code-ai-monorepo/issues).
 
 ## 📄 License
 
-This project is [MIT](https://opensource.org/licenses/MIT) licensed.
+[MIT](https://opensource.org/licenses/MIT).

package/dist/index.js

@@ -224,6 +224,7 @@ program
                 destinationDir,
                 wantMempalace: options.withMempalace,
                 dryRun: false,
+                ...(domainId ? { domain: domainId } : {}),
             });
             for (const notice of report.notices)
                 info(`  ${notice}`);
@@ -484,6 +485,7 @@ async function runInteractiveWizard() {
                 destinationDir,
                 wantMempalace,
                 dryRun: false,
+                ...(selectedDomainId ? { domain: selectedDomainId } : {}),
             });
             for (const notice of report.notices)
                 info(`  ${notice}`);

package/dist/mcp/audit_ledger.d.ts

@@ -0,0 +1,12 @@
+import { RunScorecard } from "./scorecard.js";
+import type { TaskState } from "./task_state.js";
+/** Append one scorecard as a JSON line to the run ledger (creates dir if needed). */
+export declare function appendScorecard(card: RunScorecard): Promise<void>;
+/** Read all scorecards from the ledger. Malformed / partial lines are skipped. */
+export declare function readLedger(): Promise<RunScorecard[]>;
+/**
+ * Build + append a scorecard for a completed run. Called from sign_off when RG
+ * is signed. Best-effort by contract: callers MUST NOT let a ledger failure
+ * break a sign-off (telemetry is never load-bearing for the gate).
+ */
+export declare function recordRunScorecard(state: TaskState): Promise<void>;

package/dist/mcp/audit_ledger.js

@@ -0,0 +1,82 @@
+import { mkdir, readFile, appendFile } from "node:fs/promises";
+import { dirname, join } from "node:path";
+import { resolveAuditLedgerPath } from "./paths.js";
+import { RunScorecard, buildScorecard } from "./scorecard.js";
+import { readSkillInvocations } from "./skill_invocations.js";
+/** Append one scorecard as a JSON line to the run ledger (creates dir if needed). */
+export async function appendScorecard(card) {
+    const path = resolveAuditLedgerPath();
+    await mkdir(dirname(path), { recursive: true });
+    await appendFile(path, JSON.stringify(card) + "\n", "utf8");
+}
+/** Read all scorecards from the ledger. Malformed / partial lines are skipped. */
+export async function readLedger() {
+    const raw = await readFile(resolveAuditLedgerPath(), "utf8").catch(() => "");
+    if (!raw)
+        return [];
+    const cards = [];
+    for (const line of raw.split("\n")) {
+        if (!line.trim())
+            continue;
+        try {
+            cards.push(RunScorecard.parse(JSON.parse(line)));
+        }
+        catch {
+            continue; // tolerate hand-edits / schema drift; surfacing tool, not enforcer
+        }
+    }
+    return cards;
+}
+/**
+ * Count exceptions (grouped by gate) and decisions for a task from the jsonl
+ * side logs. Plain reads — no DecisionStore/MemPalace dependency in the hot path.
+ */
+async function readSideCounts(taskId) {
+    const stateDir = join(process.cwd(), ".code-ai", "state");
+    const exceptions_by_gate = {};
+    const rawExc = await readFile(join(stateDir, "exceptions.jsonl"), "utf8").catch(() => "");
+    for (const line of rawExc.split("\n")) {
+        if (!line.trim())
+            continue;
+        try {
+            const o = JSON.parse(line);
+            if (o.task_id !== taskId)
+                continue;
+            const g = typeof o.gate === "string" ? o.gate : "unknown";
+            exceptions_by_gate[g] = (exceptions_by_gate[g] ?? 0) + 1;
+        }
+        catch {
+            continue;
+        }
+    }
+    let decisions_count = 0;
+    const rawDec = await readFile(join(stateDir, "decisions.jsonl"), "utf8").catch(() => "");
+    for (const line of rawDec.split("\n")) {
+        if (!line.trim())
+            continue;
+        try {
+            const o = JSON.parse(line);
+            if (o.task_id === taskId && !String(o.adr_id ?? "").startsWith("ADR-PENDING-")) {
+                decisions_count++;
+            }
+        }
+        catch {
+            continue;
+        }
+    }
+    const skillEvents = await readSkillInvocations(taskId);
+    return {
+        exceptions_by_gate,
+        decisions_count,
+        skill_invocations: skillEvents.map((e) => ({ skill: e.skill, gate: e.gate })),
+    };
+}
+/**
+ * Build + append a scorecard for a completed run. Called from sign_off when RG
+ * is signed. Best-effort by contract: callers MUST NOT let a ledger failure
+ * break a sign-off (telemetry is never load-bearing for the gate).
+ */
+export async function recordRunScorecard(state) {
+    const extras = await readSideCounts(state.task_id);
+    await appendScorecard(buildScorecard(state, extras));
+}

package/dist/mcp/cli.js

@@ -26,7 +26,7 @@ const SERVER_INFO = {
 const TOOL_DESCRIPTIONS = {
     load_role: "Load an agent role: frontmatter, body, merged persona, and the role's skill list. Use at SessionStart for an agent.",
     list_skills: "List skills in a domain. Optional filters: type, gate, tech, topic, owner.",
-    get_skill: "Fetch a skill's frontmatter + body by name.",
+    get_skill: "Fetch a skill's frontmatter + body by name. Pass task_id (+ optional gate) to log the fetch as a skill invocation for Auditor telemetry; omit for plain lookups.",
     request_decision: "Open a pending decision envelope. Returns a synthetic ADR-PENDING id; Claude relays the question to DEN in chat, then commits the answer via record_decision.",
     record_decision: "Commit a chosen decision: writes ADR file, decision log entry, and KG triple. Resets the circuit breaker on new ARCH ADR.",
     classify_gate: "Record the current gate's classification (auto_resolve / fork / exception) with a rationale.",
@@ -42,6 +42,12 @@ const TOOL_DESCRIPTIONS = {
     recent_decisions: "Read recent ADR decisions from the decision log with optional domain/signer/since filters.",
     regenerate_manifest: "Regenerate AGENTS.yaml skills list from disk SKILL.md frontmatter. Detects AGENTS.md drift (skills on disk but not referenced).",
     run_drift_audit: "[stub] Detect drift between SKILL.md frontmatter and AGENTS.md references.",
+    audit_budget_compliance: "Audit budget_lines compliance for agent.md and SKILL.md across a domain. Surfaces schema-cap violations (declared > schema max) and budget violations (actual lines > declared budget). Pass domain='*' to scan all domains. Read-only; scans both RU and EN locales.",
+    audit_bilocale_parity: "Audit RU/EN locale parity for agent.md and SKILL.md across a domain. Pairs each file with its sibling in the other locale and surfaces declared-budget mismatches (ru budget_lines != en), actual line-count mismatches (ru lines != en — the design-intake drift class), and orphans (file present in one locale only). Pass domain='*' to scan all domains. Read-only.",
+    aggregate_run_metrics: "Aggregate completed-run scorecards from the local audit ledger (.code-ai/state/audit/runs.jsonl) into deterministic per-agent (gate→role), per-workflow (mode), and per-skill (invocation frequency) statistics. min_runs (default 3) guards small samples. Read-only; the Auditor's data foundation — numbers only, no judgment.",
+    propose_change: "Record an Auditor proposal (a draft change to an agent/skill) as a pending entry in the local proposal store (.code-ai/state/audit/proposals.jsonl). Carries change_kind (edit_minor/add_asset/destructive → risk tier), rationale, evidence, threshold_met, and the inline draft. Pure surfacing — writes nothing to the asset; inert until approved/applied (item 4b).",
+    list_proposals: "List stored Auditor proposals, newest first, with optional filters (status / risk / domain). Read-only.",
+    review_proposal: "Authorize a proposal status transition (approve/reject a pending one; mark an approved one applied) and get a mandatory report. Enforces the autonomy matrix + .code-ai/config.json approval gate: decided_by='auditor_auto' may approve only low/additive AND only when the gate is OFF; destructive (high) and gate-ON always require den. Auto-adding a new skill also runs an additive-dedup guard — if it overlaps an existing skill it is routed to den, not auto-added. Authorization only — the byte write into the asset is a separate submit_artifact/edit step (see next_step).",
     run_tests: "[stub] Run the test suite for a target (vitest / pytest).",
     apply_diff: "[stub] Apply a unified diff to a file with safety checks.",
     git_commit: "[stub] Stage and commit changes through a typed contract instead of raw shell.",

package/dist/mcp/config.d.ts

@@ -1,4 +1,5 @@
 import { z } from "zod";
+import { DomainId } from "../shared/index.js";
 /**
  * Runtime configuration read from `.code-ai/config.json` (cwd-relative).
  *
@@ -15,8 +16,17 @@ declare const CodeAiConfigSchema: z.ZodObject<{
         mempalace: "mempalace";
         jsonl: "jsonl";
     }>>;
+    domain: z.ZodDefault<z.ZodEnum<{
+        development: "development";
+        content: "content";
+        analytics: "analytics";
+        product: "product";
+    }>>;
     mempalace_command: z.ZodDefault<z.ZodString>;
     mempalace_args: z.ZodDefault<z.ZodArray<z.ZodString>>;
+    auditor: z.ZodDefault<z.ZodObject<{
+        approval_gate: z.ZodDefault<z.ZodBoolean>;
+    }, z.core.$strip>>;
 }, z.core.$strip>;
 export type CodeAiConfig = z.infer<typeof CodeAiConfigSchema>;
 /**
@@ -25,4 +35,17 @@ export type CodeAiConfig = z.infer<typeof CodeAiConfigSchema>;
  * Failure is silent — the caller proceeds with `JsonlStore`.
  */
 export declare function loadCodeAiConfig(): Promise<CodeAiConfig>;
+/**
+ * The active domain for this project — which `pipeline.yaml` the gate tools
+ * (classify_gate, advance_gate, current_gate, sign_off, record_decision,
+ * aggregate_run_metrics) read. Sourced from `.code-ai/config.json`; defaults to
+ * "development" when unset.
+ *
+ * This is an ADDRESS, not a safety control: gate enforcement (no skipping,
+ * sign-off-before-advance, classify-required, circuit breaker) lives in the
+ * tool logic + the domain's `pipeline.yaml`, not in this string. De-hardcoding
+ * the address only makes each project read its OWN pipeline instead of always
+ * development's.
+ */
+export declare function resolveActiveDomain(): Promise<DomainId>;
 export {};

package/dist/mcp/config.js

@@ -1,6 +1,7 @@
 import { readFile } from "node:fs/promises";
 import { join } from "node:path";
 import { z } from "zod";
+import { DomainId } from "../shared/index.js";
 /**
  * Runtime configuration read from `.code-ai/config.json` (cwd-relative).
  *
@@ -14,16 +15,38 @@ import { z } from "zod";
  */
 const CodeAiConfigSchema = z.object({
     decision_store: z.enum(["jsonl", "mempalace"]).default("jsonl"),
-    /** Override the binary name for the MemPalace MCP server. */
-    mempalace_command: z.string().min(1).default("mempalace"),
-    /** Optional extra args appended after the `mcp` subcommand. */
-    mempalace_args: z.array(z.string()).default(["mcp"]),
+    /**
+     * The active domain — which `domains/<domain>/pipeline.yaml` the gate tools
+     * read. Written by the installer at install time. Defaults to "development"
+     * for backward compatibility: a project with no `domain` field (or no config
+     * file at all) behaves exactly as before this field existed.
+     */
+    domain: DomainId.default("development"),
+    /** Override the binary for the MemPalace MCP server (dedicated stdio bin). */
+    mempalace_command: z.string().min(1).default("mempalace-mcp"),
+    /** Args for the MemPalace MCP server. The dedicated `mempalace-mcp` bin needs
+     *  none; the old `mempalace mcp` subcommand pollutes stdout and breaks the
+     *  stdio MCP handshake, so it is no longer the default. */
+    mempalace_args: z.array(z.string()).default([]),
+    /** Auditor self-improvement controls (ADR-DEV-124). */
+    auditor: z
+        .object({
+        /**
+         * Approval gate. true (default) = Auditor proposes, a human approves every change.
+         * false = autonomy on: the Auditor may self-approve low/additive changes; destructive
+         * always still needs a human (ADR-DEV-122 matrix). Enforced in review_proposal.
+         */
+        approval_gate: z.boolean().default(true),
+    })
+        .default({ approval_gate: true }),
 });
 /** Empty config defaults — returned when the file is missing or unreadable. */
 const DEFAULT_CONFIG = {
     decision_store: "jsonl",
-    mempalace_command: "mempalace",
-    mempalace_args: ["mcp"],
+    mempalace_command: "mempalace-mcp",
+    mempalace_args: [],
+    auditor: { approval_gate: true },
+    domain: "development",
 };
 /**
  * Load `.code-ai/config.json` relative to `process.cwd()`. Returns safe
@@ -46,3 +69,18 @@ export async function loadCodeAiConfig() {
         return DEFAULT_CONFIG;
     }
 }
+/**
+ * The active domain for this project — which `pipeline.yaml` the gate tools
+ * (classify_gate, advance_gate, current_gate, sign_off, record_decision,
+ * aggregate_run_metrics) read. Sourced from `.code-ai/config.json`; defaults to
+ * "development" when unset.
+ *
+ * This is an ADDRESS, not a safety control: gate enforcement (no skipping,
+ * sign-off-before-advance, classify-required, circuit breaker) lives in the
+ * tool logic + the domain's `pipeline.yaml`, not in this string. De-hardcoding
+ * the address only makes each project read its OWN pipeline instead of always
+ * development's.
+ */
+export async function resolveActiveDomain() {
+    return (await loadCodeAiConfig()).domain;
+}

package/dist/mcp/index.d.ts

@@ -6,8 +6,7 @@
  * stubs until pre-req #3 (baseline prototype) wires the first four:
  *   load_role, list_skills, request_decision, record_decision.
  *
- * See README.md for the full tool surface, and ../../docs/architecture-redesign/
- * for the architectural plan this package implements.
+ * See README.md for the full tool surface and architectural overview.
  */
 export declare const VERSION = "0.0.0";
 export { CodeAiMcpServer } from "./server.js";

package/dist/mcp/index.js

@@ -6,8 +6,7 @@
  * stubs until pre-req #3 (baseline prototype) wires the first four:
  *   load_role, list_skills, request_decision, record_decision.
  *
- * See README.md for the full tool surface, and ../../docs/architecture-redesign/
- * for the architectural plan this package implements.
+ * See README.md for the full tool surface and architectural overview.
  */
 export const VERSION = "0.0.0";
 export { CodeAiMcpServer } from "./server.js";

package/dist/mcp/paths.d.ts

@@ -1,7 +1,5 @@
 import { type DomainId } from "../shared/index.js";
 export declare const INSTALLER_ROOT: string;
-export declare const DOCS_ROOT: string;
-export declare const PERSONA_ROOT: string;
 /**
  * ADR write root. Resolved at call time relative to process.cwd() so the MCP
  * doesn't pollute the monorepo when invoked from a user project. Tests rely
@@ -9,6 +7,12 @@ export declare const PERSONA_ROOT: string;
  */
 export declare function resolveAdrRoot(): string;
 export declare function resolveDomainRoot(domain: DomainId): string;
+/**
+ * Universal base-persona markdown for a domain. Shipped inside the package at
+ * `domains/<domain>/persona/persona-base.md` (was `docs/architecture-redesign/`
+ * pre-migration, which never shipped to npm). Same content across domains.
+ */
+export declare function resolvePersonaBase(domain: DomainId): string;
 export declare function resolveSkillsRoot(domain: DomainId): string;
 export declare function resolveAgentsDir(domain: DomainId): string;
 export declare function resolveAgentMd(domain: DomainId, role: string): string;
@@ -18,3 +22,17 @@ export declare function resolvePipelineYaml(domain: DomainId): string;
  * convention as resolveAdrRoot() so the MCP doesn't pollute the host repo.
  */
 export declare function resolveTaskStateRoot(): string;
+/**
+ * Audit run-ledger path. Same cwd-relative convention as resolveTaskStateRoot()
+ * so the Auditor reads the user-install's local history; tests chdir into a tmp
+ * dir. Append-only JSONL, one run scorecard per line.
+ */
+export declare function resolveAuditLedgerPath(): string;
+/** Skill-invocation telemetry log. Same cwd-relative convention as the run ledger. */
+export declare function resolveSkillInvocationsPath(): string;
+/**
+ * Auditor proposal store. Same cwd-relative convention as the run ledger;
+ * append-only JSONL, one proposal per line. Written by propose_change, read by
+ * list_proposals (and later the approval/apply machinery, item 4b).
+ */
+export declare function resolveProposalsPath(): string;

package/dist/mcp/paths.js

@@ -5,7 +5,7 @@ import { dirname, join, resolve } from "node:path";
  *
  * Convention: the MCP runs from inside the `code-ai-installer` package, so we
  * walk up from this file's location to the installer root (where `domains/`
- * lives) and to the monorepo root (where `docs/` lives during development).
+ * lives — everything the runtime reads ships under it).
  *
  * Layout reference:
  *   src layout (vitest, tsx):
@@ -17,10 +17,6 @@ import { dirname, join, resolve } from "node:path";
 const HERE = dirname(fileURLToPath(import.meta.url));
 // .../packages/installer/{src|dist}/mcp/paths.{ts|js} → .../packages/installer
 export const INSTALLER_ROOT = resolve(HERE, "..", "..");
-// → .../packages → monorepo
-const MONOREPO_ROOT = resolve(INSTALLER_ROOT, "..", "..");
-export const DOCS_ROOT = join(MONOREPO_ROOT, "docs");
-export const PERSONA_ROOT = join(DOCS_ROOT, "architecture-redesign");
 /**
  * ADR write root. Resolved at call time relative to process.cwd() so the MCP
  * doesn't pollute the monorepo when invoked from a user project. Tests rely
@@ -32,6 +28,14 @@ export function resolveAdrRoot() {
 export function resolveDomainRoot(domain) {
     return join(INSTALLER_ROOT, "domains", domain);
 }
+/**
+ * Universal base-persona markdown for a domain. Shipped inside the package at
+ * `domains/<domain>/persona/persona-base.md` (was `docs/architecture-redesign/`
+ * pre-migration, which never shipped to npm). Same content across domains.
+ */
+export function resolvePersonaBase(domain) {
+    return join(resolveDomainRoot(domain), "persona", "persona-base.md");
+}
 export function resolveSkillsRoot(domain) {
     return join(resolveDomainRoot(domain), ".agents", "skills");
 }
@@ -51,3 +55,23 @@ export function resolvePipelineYaml(domain) {
 export function resolveTaskStateRoot() {
     return join(process.cwd(), ".code-ai", "state", "tasks");
 }
+/**
+ * Audit run-ledger path. Same cwd-relative convention as resolveTaskStateRoot()
+ * so the Auditor reads the user-install's local history; tests chdir into a tmp
+ * dir. Append-only JSONL, one run scorecard per line.
+ */
+export function resolveAuditLedgerPath() {
+    return join(process.cwd(), ".code-ai", "state", "audit", "runs.jsonl");
+}
+/** Skill-invocation telemetry log. Same cwd-relative convention as the run ledger. */
+export function resolveSkillInvocationsPath() {
+    return join(process.cwd(), ".code-ai", "state", "skill_invocations.jsonl");
+}
+/**
+ * Auditor proposal store. Same cwd-relative convention as the run ledger;
+ * append-only JSONL, one proposal per line. Written by propose_change, read by
+ * list_proposals (and later the approval/apply machinery, item 4b).
+ */
+export function resolveProposalsPath() {
+    return join(process.cwd(), ".code-ai", "state", "audit", "proposals.jsonl");
+}