specrails-desktop 2.17.0 → 2.18.0

package/server/dist/agent-mcp-config.js

@@ -0,0 +1,208 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.resolveBridgeScript = resolveBridgeScript;
+exports.resolveNodeCommand = resolveNodeCommand;
+exports.buildSpecrailsMcpEntry = buildSpecrailsMcpEntry;
+exports.mergeSpecrailsIntoWorkspaceMcp = mergeSpecrailsIntoWorkspaceMcp;
+exports.buildAgentMcpArgs = buildAgentMcpArgs;
+exports.prepareAgentMcp = prepareAgentMcp;
+const fs_1 = __importDefault(require("fs"));
+const path_1 = __importDefault(require("path"));
+const os_1 = __importDefault(require("os"));
+const path_resolver_1 = require("./path-resolver");
+const agent_tier_1 = require("./agent-tier");
+// ─── Agent MCP wiring (design D8 / D1) ────────────────────────────────────────
+//
+// The in-app agent drives the app by talking to its OWN embedded MCP server. We
+// spawn the AI CLI with `--mcp-config` pointing at a generated config whose sole
+// server is the bundled `specrails-mcp` stdio bridge, which relays to
+// `127.0.0.1:<port>/api/mcp` and reads the scoped token from disk (no token is
+// ever written into the config file). The current Shift+Tab ladder level is
+// forwarded via env → the bridge sets it as a loopback-only header so the tool
+// guard enforces the agent ladder independently of the external Settings tiers.
+function homeDir() {
+    return process.env.SPECRAILS_REGISTRY_HOME || os_1.default.homedir();
+}
+function fileExists(p) {
+    try {
+        return fs_1.default.existsSync(p);
+    }
+    catch {
+        return false;
+    }
+}
+/**
+ * Absolute path to the `specrails-mcp` bridge JS. Resolution order:
+ *   1. SPECRAILS_BUNDLED_MCP_BRIDGE_PATH (set by the Tauri host in the packaged app)
+ *   2. the staged copy under src-tauri/binaries/ (dev + bundled layouts)
+ *   3. the mcp-bridge build output (mcp-bridge/dist/)
+ * Climbs from this module so it works whether running from server/ or server/dist/.
+ */
+function resolveBridgeScript() {
+    const fromEnv = process.env.SPECRAILS_BUNDLED_MCP_BRIDGE_PATH;
+    if (fromEnv && fileExists(fromEnv))
+        return fromEnv;
+    const roots = [
+        path_1.default.resolve(__dirname, '..'),
+        path_1.default.resolve(__dirname, '..', '..'),
+        process.cwd(),
+    ];
+    const rels = [
+        path_1.default.join('src-tauri', 'binaries', 'specrails-mcp.js'),
+        path_1.default.join('mcp-bridge', 'dist', 'specrails-mcp.js'),
+    ];
+    for (const root of roots) {
+        for (const rel of rels) {
+            const candidate = path_1.default.join(root, rel);
+            if (fileExists(candidate))
+                return candidate;
+        }
+    }
+    return null;
+}
+/** The node executable that should run the bridge (bundled in the packaged app, else PATH `node`). */
+function resolveNodeCommand() {
+    return (0, path_resolver_1.resolveBundledNodeExe)() ?? 'node';
+}
+/** Build the `mcpServers.specrails` entry the agent (or a project workspace) uses. */
+function buildSpecrailsMcpEntry(opts) {
+    const bridge = resolveBridgeScript();
+    if (!bridge)
+        return null;
+    const env = {
+        SPECRAILS_MCP_PORT: String(opts.port),
+    };
+    // Preserve the test-home override so the bridge reads the right token file.
+    if (process.env.SPECRAILS_REGISTRY_HOME)
+        env.SPECRAILS_REGISTRY_HOME = process.env.SPECRAILS_REGISTRY_HOME;
+    if (opts.tierLevel != null)
+        env[agent_tier_1.AGENT_TIER_ENV] = (0, agent_tier_1.tierNameForLevel)(opts.tierLevel);
+    if (opts.activeProjectId)
+        env[agent_tier_1.AGENT_PROJECT_ENV] = opts.activeProjectId;
+    return { command: resolveNodeCommand(), args: [bridge], env };
+}
+/**
+ * Part A (design D8): surgically merge the `specrails` MCP server into a
+ * project's app-managed WORKSPACE `.mcp.json` so the project's own rails/explore/
+ * chat spawns can also call the Specrails MCP. NEVER touches the pristine repo.
+ * Additive + idempotent: preserves any existing (e.g. plugin) mcpServers entries,
+ * writes atomically (temp + rename), inlines NO token. Returns true when written.
+ */
+function mergeSpecrailsIntoWorkspaceMcp(workspaceDir, port) {
+    const entry = buildSpecrailsMcpEntry({ port });
+    if (!entry)
+        return false;
+    const file = path_1.default.join(workspaceDir, '.mcp.json');
+    let current = {};
+    try {
+        if (fs_1.default.existsSync(file)) {
+            const parsed = JSON.parse(fs_1.default.readFileSync(file, 'utf-8'));
+            if (parsed && typeof parsed === 'object')
+                current = parsed;
+        }
+    }
+    catch {
+        // Corrupt file → start fresh rather than crash assembly.
+        current = {};
+    }
+    const mcpServers = { ...(current.mcpServers ?? {}), specrails: entry };
+    const next = { ...current, mcpServers };
+    const tmp = `${file}.tmp-${process.pid}`;
+    fs_1.default.mkdirSync(workspaceDir, { recursive: true });
+    fs_1.default.writeFileSync(tmp, JSON.stringify(next, null, 2));
+    fs_1.default.renameSync(tmp, file);
+    return true;
+}
+/**
+ * Writes a per-conversation `--mcp-config` file for the agent and returns the
+ * `['--mcp-config', <file>]` argv to inject into SpawnOptions.extraArgs. Uses the
+ * bundled `specrails-mcp` stdio bridge (shipped inside the app — the user installs
+ * nothing; 100% unattended) which relays to this process's `/api/mcp`. Returns
+ * `[]` when the bridge can't be located (agent then runs tool-less / degraded).
+ */
+function buildAgentMcpArgs(opts) {
+    const entry = buildSpecrailsMcpEntry({ port: opts.port, tierLevel: opts.tierLevel, activeProjectId: opts.activeProjectId });
+    if (!entry)
+        return [];
+    if (!/^[A-Za-z0-9][A-Za-z0-9_-]*$/.test(opts.conversationId)) {
+        throw new Error(`unsafe agent conversation id: ${opts.conversationId}`);
+    }
+    const dir = path_1.default.join(homeDir(), '.specrails', 'agent', opts.conversationId);
+    fs_1.default.mkdirSync(dir, { recursive: true });
+    const file = path_1.default.join(dir, 'mcp.json');
+    fs_1.default.writeFileSync(file, JSON.stringify({ mcpServers: { specrails: entry } }, null, 2), { mode: 0o600 });
+    try {
+        fs_1.default.chmodSync(file, 0o600);
+    }
+    catch {
+        /* best-effort on platforms without chmod */
+    }
+    return ['--mcp-config', file];
+}
+function agentDir(conversationId) {
+    if (!/^[A-Za-z0-9][A-Za-z0-9_-]*$/.test(conversationId)) {
+        throw new Error(`unsafe agent conversation id: ${conversationId}`);
+    }
+    const dir = path_1.default.join(homeDir(), '.specrails', 'agent', conversationId);
+    fs_1.default.mkdirSync(dir, { recursive: true });
+    return dir;
+}
+/**
+ * Codex registers the specrails MCP via inline `-c mcp_servers.specrails.*`
+ * config overrides. This keeps codex on the USER's real CODEX_HOME (auth + model
+ * settings intact — no all-or-nothing 401 from a CODEX_HOME override) and cannot
+ * break codex startup the way an unknown `--mcp-config` flag does: `-c` is a known
+ * flag and unknown config keys are simply set. TOML scalar values reuse JSON
+ * escaping (compatible for our command/path/env inputs).
+ */
+function codexMcpOverrides(entry) {
+    const c = (kv) => ['-c', kv];
+    const args = [
+        ...c(`mcp_servers.specrails.command=${JSON.stringify(entry.command)}`),
+        ...c(`mcp_servers.specrails.args=[${entry.args.map((a) => JSON.stringify(a)).join(', ')}]`),
+    ];
+    for (const [k, v] of Object.entries(entry.env)) {
+        args.push(...c(`mcp_servers.specrails.env.${k}=${JSON.stringify(v)}`));
+    }
+    return args;
+}
+/**
+ * Prepares the specrails MCP for the given provider and returns the spawn
+ * extraArgs + env to merge. Returns empty wiring when the bridge is unavailable
+ * (agent then runs tool-less / degraded).
+ */
+function prepareAgentMcp(opts) {
+    const entry = buildSpecrailsMcpEntry({
+        port: opts.port,
+        tierLevel: opts.tierLevel,
+        activeProjectId: opts.activeProjectId,
+    });
+    if (!entry)
+        return { extraArgs: [], env: {} };
+    if (opts.adapterId === 'codex') {
+        // Inline -c overrides — no CODEX_HOME override, no file mutation; auth intact.
+        return { extraArgs: codexMcpOverrides(entry), env: {} };
+    }
+    if (opts.adapterId === 'claude') {
+        return { extraArgs: buildAgentMcpArgs(opts), env: {} };
+    }
+    // gemini + any other project-json provider: write .mcp.json in the spawn cwd.
+    const file = path_1.default.join(opts.cwd, '.mcp.json');
+    let current = {};
+    try {
+        if (fs_1.default.existsSync(file)) {
+            const parsed = JSON.parse(fs_1.default.readFileSync(file, 'utf-8'));
+            if (parsed && typeof parsed === 'object')
+                current = parsed;
+        }
+    }
+    catch {
+        current = {};
+    }
+    const next = { ...current, mcpServers: { ...(current.mcpServers ?? {}), specrails: entry } };
+    fs_1.default.writeFileSync(file, JSON.stringify(next, null, 2), { mode: 0o600 });
+    return { extraArgs: [], env: {} };
+}

package/server/dist/agent-store.js

@@ -0,0 +1,59 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.createAgentConversation = createAgentConversation;
+exports.getAgentConversation = getAgentConversation;
+exports.listAgentConversations = listAgentConversations;
+exports.updateAgentConversation = updateAgentConversation;
+exports.deleteAgentConversation = deleteAgentConversation;
+exports.addAgentMessage = addAgentMessage;
+exports.listAgentMessages = listAgentMessages;
+const crypto_1 = require("crypto");
+const agent_tier_1 = require("./agent-tier");
+function mapConversation(row) {
+    if (!row)
+        return undefined;
+    return { ...row, tier_level: (0, agent_tier_1.normalizeLevel)(row.tier_level) };
+}
+function createAgentConversation(db, input = {}) {
+    const id = (0, crypto_1.randomUUID)();
+    db.prepare(`INSERT INTO agent_conversations (id, provider, model, pinned_project_id, tier_level)
+     VALUES (?, ?, ?, ?, ?)`).run(id, input.provider ?? 'claude', input.model ?? null, input.pinnedProjectId ?? null, input.tierLevel ?? 0);
+    return getAgentConversation(db, id);
+}
+function getAgentConversation(db, id) {
+    return mapConversation(db.prepare('SELECT * FROM agent_conversations WHERE id = ?').get(id));
+}
+function listAgentConversations(db, limit = 100) {
+    return db
+        .prepare('SELECT * FROM agent_conversations ORDER BY updated_at DESC LIMIT ?')
+        .all(limit).map((r) => mapConversation(r));
+}
+/** Patch a conversation. Only the provided fields change; `updated_at` always bumps. */
+function updateAgentConversation(db, id, patch) {
+    const sets = [];
+    const vals = [];
+    for (const [k, v] of Object.entries(patch)) {
+        sets.push(`${k} = ?`);
+        vals.push(v);
+    }
+    sets.push("updated_at = datetime('now')");
+    if (sets.length > 0) {
+        db.prepare(`UPDATE agent_conversations SET ${sets.join(', ')} WHERE id = ?`).run(...vals, id);
+    }
+    return getAgentConversation(db, id);
+}
+function deleteAgentConversation(db, id) {
+    db.prepare('DELETE FROM agent_conversations WHERE id = ?').run(id);
+}
+function addAgentMessage(db, input) {
+    const id = (0, crypto_1.randomUUID)();
+    db.prepare('INSERT INTO agent_messages (id, conversation_id, role, content) VALUES (?, ?, ?, ?)').run(id, input.conversationId, input.role, input.content);
+    // Touch the parent so the list stays ordered by latest activity.
+    db.prepare("UPDATE agent_conversations SET updated_at = datetime('now') WHERE id = ?").run(input.conversationId);
+    return db.prepare('SELECT * FROM agent_messages WHERE id = ?').get(id);
+}
+function listAgentMessages(db, conversationId) {
+    return db
+        .prepare('SELECT * FROM agent_messages WHERE conversation_id = ? ORDER BY created_at ASC, rowid ASC')
+        .all(conversationId);
+}

package/server/dist/agent-tier.js

@@ -0,0 +1,86 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.AGENT_PROJECT_ENV = exports.AGENT_PROJECT_HEADER = exports.AGENT_TIER_ENV = exports.AGENT_TIER_HEADER = exports.AGENT_TIER_NAMES = void 0;
+exports.tierNameForLevel = tierNameForLevel;
+exports.levelForTierName = levelForTierName;
+exports.normalizeLevel = normalizeLevel;
+exports.nextLevel = nextLevel;
+exports.levelAllowsTier = levelAllowsTier;
+exports.levelFromHeader = levelFromHeader;
+exports.tierNeedsApproval = tierNeedsApproval;
+exports.AGENT_TIER_NAMES = [
+    'observe',
+    'edit',
+    'operate',
+    'autonomous',
+];
+/** The HTTP header the agent's MCP bridge sets so the tool guard can read the level. */
+exports.AGENT_TIER_HEADER = 'x-specrails-agent-tier';
+/** Env var the AgentChatManager sets on the bridge spawn; the bridge forwards it as the header. */
+exports.AGENT_TIER_ENV = 'SPECRAILS_AGENT_TIER';
+/** Header carrying the pinned project id so tools resolve it per-request. */
+exports.AGENT_PROJECT_HEADER = 'x-specrails-active-project';
+/** Env var the manager sets on the bridge spawn; the bridge forwards it as the project header. */
+exports.AGENT_PROJECT_ENV = 'SPECRAILS_ACTIVE_PROJECT';
+/** Which MCP tiers a given ladder level unlocks (cumulative). */
+const TIERS_BY_LEVEL = {
+    0: new Set(['read']),
+    1: new Set(['read', 'write']),
+    2: new Set(['read', 'write', 'ai-spawn']),
+    3: new Set(['read', 'write', 'ai-spawn', 'destructive']),
+};
+function tierNameForLevel(level) {
+    return exports.AGENT_TIER_NAMES[level];
+}
+function levelForTierName(name) {
+    const idx = exports.AGENT_TIER_NAMES.indexOf(name);
+    return idx === -1 ? null : idx;
+}
+/** Clamp an arbitrary number/string to a valid ladder level (default observe). */
+function normalizeLevel(value) {
+    const n = typeof value === 'string' ? Number(value) : value;
+    if (typeof n === 'number' && Number.isInteger(n) && n >= 0 && n <= 3) {
+        return n;
+    }
+    // Allow the name form too.
+    if (typeof value === 'string') {
+        const byName = levelForTierName(value);
+        if (byName !== null)
+            return byName;
+    }
+    return 0;
+}
+/** Cycle Shift+Tab: 0→1→2→3→0. */
+function nextLevel(level) {
+    return ((level + 1) % 4);
+}
+/** True when the given MCP tier is permitted at the given ladder level. */
+function levelAllowsTier(level, tier) {
+    return TIERS_BY_LEVEL[level].has(tier);
+}
+/**
+ * Parse the agent-tier header value into a level, or null when absent/invalid.
+ * The header carries the tier NAME (observe/edit/operate/autonomous) or the
+ * numeric level; anything else yields null (→ fall back to Settings tiers).
+ */
+function levelFromHeader(headerValue) {
+    if (headerValue == null)
+        return null;
+    const raw = Array.isArray(headerValue) ? headerValue[0] : headerValue;
+    if (typeof raw !== 'string' || raw.trim() === '')
+        return null;
+    const byName = levelForTierName(raw.trim());
+    if (byName !== null)
+        return byName;
+    const n = Number(raw.trim());
+    if (Number.isInteger(n) && n >= 0 && n <= 3)
+        return n;
+    return null;
+}
+/**
+ * Whether a cost/destructive action needs an explicit inline approval (Option C):
+ * reversible writes (read/write) run silently; ai-spawn and destructive prompt.
+ */
+function tierNeedsApproval(tier) {
+    return tier === 'ai-spawn' || tier === 'destructive';
+}

package/server/dist/desktop-db.js

@@ -351,6 +351,33 @@ function applyDesktopMigrations(db) {
           ('seed-min-coverage', 'MIN_COVERAGE', '80');
       `);
         },
+        // 17: app-global agent chat (design D2). The agent chat lives ABOVE projects,
+        // so its conversations are stored in the app registry DB (not any per-project
+        // jobs.sqlite). `pinned_project_id` records the Cursor-style selector target
+        // (NULL = Home / app-global); `tier_level` records the Shift+Tab ladder.
+        () => {
+            db.exec(`
+        CREATE TABLE IF NOT EXISTS agent_conversations (
+          id                TEXT PRIMARY KEY,
+          title             TEXT,
+          provider          TEXT NOT NULL DEFAULT 'claude',
+          model             TEXT,
+          session_id        TEXT,
+          pinned_project_id TEXT,
+          tier_level        INTEGER NOT NULL DEFAULT 0,
+          created_at        TEXT NOT NULL DEFAULT (datetime('now')),
+          updated_at        TEXT NOT NULL DEFAULT (datetime('now'))
+        );
+        CREATE TABLE IF NOT EXISTS agent_messages (
+          id              TEXT PRIMARY KEY,
+          conversation_id TEXT NOT NULL REFERENCES agent_conversations(id) ON DELETE CASCADE,
+          role            TEXT NOT NULL,
+          content         TEXT NOT NULL,
+          created_at      TEXT NOT NULL DEFAULT (datetime('now'))
+        );
+        CREATE INDEX IF NOT EXISTS idx_agent_messages_conv ON agent_messages(conversation_id, created_at);
+      `);
+        },
     ];
     for (let i = 0; i < migrations.length; i++) {
         const version = i + 1;

package/server/dist/index.js

@@ -24,6 +24,8 @@ const terminal_shell_integration_1 = require("./terminal-shell-integration");
 const feature_flags_1 = require("./feature-flags");
 const mobile_1 = require("./mobile");
 const mcp_1 = require("./mcp");
+const agent_chat_manager_1 = require("./agent-chat-manager");
+const agent_chat_router_1 = require("./agent-chat-router");
 const browser_playwright_1 = require("./browser-playwright");
 const telemetry_receiver_1 = require("./telemetry-receiver");
 const telemetry_compactor_1 = require("./telemetry-compactor");
@@ -235,6 +237,7 @@ let _registry = null;
 /** The mobile companion gateway (off by default); torn down on shutdown. */
 let _mobileGateway = null;
 let _mcpManager = null;
+let _agentChatManager = null;
 server.on('upgrade', (request, socket, head) => {
     const urlStr = request.url ?? '/';
     const auth = authorizeUpgrade(request);
@@ -536,6 +539,10 @@ function applyPtyWsRateLimiting(ws) {
     if (mcpManager.isEnabledSetting()) {
         mcpManager.start().catch((err) => console.error('[mcp] boot start failed:', err));
     }
+    // ─── App-global agent chat (drives the app via its own MCP) ────────────────
+    const agentChatManager = new agent_chat_manager_1.AgentChatManager(broadcast, registry.desktopDb, port);
+    _agentChatManager = agentChatManager;
+    app.use('/api/agent', (0, agent_chat_router_1.createAgentChatRouter)({ manager: agentChatManager, desktopDb: registry.desktopDb }));
     // App-level routes. CRITICAL mount order: the desktop router is mounted at
     // '/api' BEFORE the project router below so its exact routes (e.g.
     // GET /api/projects, DELETE /api/projects/:id) are handled here, while
@@ -641,6 +648,7 @@ async function shutdown() {
     try {
         await _mobileGateway?.stop();
         await _mcpManager?.stop();
+        await _agentChatManager?.shutdown();
     }
     catch { /* ignore */ }
     try {

package/server/dist/mcp/tools/setup.js

@@ -7,20 +7,23 @@ const types_1 = require("./types");
  * The setup-wizard domain facade. Mixes APP-LEVEL operations (prerequisites,
  * available_providers, add_project — mounted at `/api` with NO `:projectId`)
  * with PER-PROJECT operations (install-config, install, checkpoints, abort,
- * integration-contract, enrich — under `/api/projects/:projectId/*`).
+ * integration-contract — under `/api/projects/:projectId/*`).
+ *
+ * QUICK-only: the agent path provisions the quick (offline) tier and installs
+ * every registered provider in ONE `install` call (the server chains them). The
+ * legacy full/enrich AI flow is intentionally NOT exposed through the MCP.
  *
  * LIFECYCLE the caller must respect:
  *   1. prerequisites → must be ok before adding a project
  *   2. add_project   → creates the ProjectContext + slug + registry mirror + workspace
- *   3. install_config (one POST per provider for multi-provider projects)
- *   4. install        → 202 async; the real result arrives only via WS / checkpoints
+ *   3. install_config (one POST per provider for multi-provider projects; tier forced to quick)
+ *   4. install        → 202 async; installs ALL providers; result arrives via WS / checkpoints
  *   5. poll checkpoints (or stream WS) until isInstalling === false
- *   6. optional enrich / enrich_message for the legacy full AI flow
  *
- * The async actions (install, enrich, enrich_message) return immediately (HTTP
- * 202) and do the real, long-running work in a detached child whose only output
- * channel is WebSocket — so they return a hint to poll `checkpoints` (which also
- * exposes isInstalling/isEnriching/logLines/summary) for true completion.
+ * The async `install` action returns immediately (HTTP 202) and does the real,
+ * long-running work in a detached child whose only output channel is WebSocket —
+ * so it returns a hint to poll `checkpoints` (which also exposes
+ * isInstalling/logLines/summary) for true completion.
  */
 function setupTools() {
     return [
@@ -31,15 +34,15 @@ function setupTools() {
                 'App-level actions ignore projectId: prerequisites (probe node/npm/npx/git + provider CLIs), ' +
                 'available_providers (which AI CLIs are detected + install tiers), add_project (register a repo path). ' +
                 'Per-project actions: install_config (persist install-config.yaml), install (spawn offline framework scaffold — async/202), ' +
-                'checkpoints (poll live setup/install/enrich state — the canonical completion signal when not streaming WS), ' +
-                'abort (SIGTERM/SIGKILL the in-progress install+enrich child), integration_contract (read the ticket-provider contract), ' +
-                'enrich (spawn the legacy full AI flow — async/202, COST-INCURRING), enrich_message (resume an enrich session with a reply — async, COST-INCURRING).',
+                'checkpoints (poll live setup/install state — the canonical completion signal when not streaming WS), ' +
+                'abort (SIGTERM/SIGKILL the in-progress install child), integration_contract (read the ticket-provider contract). ' +
+                'Install is QUICK-only and provisions every registered provider in one shot; the legacy full/enrich AI flow is not exposed here.',
             hintTier: 'read',
             tier: (a) => {
                 const action = a.action;
                 if (action === 'abort')
                     return 'destructive';
-                if (action === 'install' || action === 'enrich' || action === 'enrich_message')
+                if (action === 'install')
                     return 'ai-spawn';
                 if (action === 'add_project' || action === 'install_config')
                     return 'write';
@@ -56,14 +59,12 @@ function setupTools() {
                     'checkpoints',
                     'abort',
                     'integration_contract',
-                    'enrich',
-                    'enrich_message',
                 ])
                     .describe('Setup operation to perform'),
                 projectId: zod_1.z
                     .string()
                     .optional()
-                    .describe('Project id for per-project actions (install_config/install/checkpoints/abort/integration_contract/enrich/enrich_message). Ignored by app-level actions.'),
+                    .describe('Project id for per-project actions (install_config/install/checkpoints/abort/integration_contract). Ignored by app-level actions.'),
                 // prerequisites
                 diagnostic: zod_1.z
                     .boolean()
@@ -81,7 +82,7 @@ function setupTools() {
                 provider: zod_1.z
                     .string()
                     .optional()
-                    .describe('add_project: legacy single primary provider; install/enrich: which per-provider install-config to read'),
+                    .describe('add_project: legacy single primary provider; install: which per-provider install-config to read'),
                 providers: zod_1.z
                     .array(zod_1.z.string())
                     .optional()
@@ -91,15 +92,6 @@ function setupTools() {
                     .record(zod_1.z.unknown())
                     .optional()
                     .describe('install_config: the install-config object to serialize (e.g. { tier:"quick", provider, agents }); required for install_config'),
-                // enrich_message
-                sessionId: zod_1.z
-                    .string()
-                    .optional()
-                    .describe('enrich_message: the enrich session id to resume (required for enrich_message)'),
-                message: zod_1.z
-                    .string()
-                    .optional()
-                    .describe('enrich_message: the user reply to send into the enrich session (required for enrich_message)'),
             },
             async handler(ctx, args) {
                 const action = args.action;
@@ -131,17 +123,27 @@ function setupTools() {
                         if (config === undefined || typeof config !== 'object' || Array.isArray(config)) {
                             throw new Error('install_config requires a "config" object.');
                         }
-                        return (0, types_1.apiCall)(ctx, 'POST', `${base}/setup/install-config`, config);
+                        // The MCP/agent path is QUICK-only — force the tier so a full/enrich
+                        // install can never be provisioned through the agent (deprecated).
+                        const quickConfig = { ...config, tier: 'quick' };
+                        return (0, types_1.apiCall)(ctx, 'POST', `${base}/setup/install-config`, quickConfig);
                     }
                     case 'install': {
                         const base = (0, types_1.projectPath)(ctx, args.projectId);
+                        // Quick-only, all-provider install: by default provision EVERY provider
+                        // the project is registered with in one shot (server chains them). An
+                        // explicit `providers` list narrows it; a single `provider` still works.
                         const body = {};
-                        if (typeof args.provider === 'string')
+                        if (Array.isArray(args.providers))
+                            body.providers = args.providers;
+                        else if (typeof args.provider === 'string')
                             body.provider = args.provider;
+                        else
+                            body.all = true;
                         const r = await (0, types_1.apiCall)(ctx, 'POST', `${base}/setup/install`, body);
                         return {
                             ...(typeof r === 'object' && r !== null ? r : { result: r }),
-                            hint: 'Install is async (HTTP 202). Poll specrails_setup(checkpoints) until isInstalling === false (and watch summary for the result), or stream the setup_install_done / setup_error WS events.',
+                            hint: 'Install is async (HTTP 202). Installs ALL registered providers (quick tier) in one shot; poll specrails_setup(checkpoints) until isInstalling === false, or stream the setup_install_done / setup_error WS events.',
                         };
                     }
                     case 'checkpoints': {
@@ -156,28 +158,6 @@ function setupTools() {
                         const base = (0, types_1.projectPath)(ctx, args.projectId);
                         return (0, types_1.apiCall)(ctx, 'GET', `${base}/integration-contract`);
                     }
-                    case 'enrich': {
-                        const base = (0, types_1.projectPath)(ctx, args.projectId);
-                        const r = await (0, types_1.apiCall)(ctx, 'POST', `${base}/enrich/start`, {});
-                        return {
-                            ...(typeof r === 'object' && r !== null ? r : { result: r }),
-                            hint: 'Enrich is async (HTTP 202) and COST-INCURRING. Poll specrails_setup(checkpoints) until isEnriching === false, or stream the setup_complete / setup_turn_done / setup_error WS events. Use enrich_message to answer clarifying questions.',
-                        };
-                    }
-                    case 'enrich_message': {
-                        const base = (0, types_1.projectPath)(ctx, args.projectId);
-                        const sessionId = args.sessionId;
-                        const message = args.message;
-                        if (!sessionId)
-                            throw new Error('enrich_message requires a "sessionId".');
-                        if (!message || !message.trim())
-                            throw new Error('enrich_message requires a non-empty "message".');
-                        const r = await (0, types_1.apiCall)(ctx, 'POST', `${base}/enrich/message`, { sessionId, message });
-                        return {
-                            ...(typeof r === 'object' && r !== null ? r : { result: r }),
-                            hint: 'Enrich-message is async (HTTP 202) and COST-INCURRING. Poll specrails_setup(checkpoints) until isEnriching === false, or stream the setup_turn_done / setup_error WS events.',
-                        };
-                    }
                     default:
                         throw new Error(`Unknown action "${action}".`);
                 }

package/server/dist/mcp/tools/types.js

@@ -8,6 +8,7 @@ exports.getActiveProject = getActiveProject;
 exports.registerTieredTool = registerTieredTool;
 const mcp_tiers_1 = require("../mcp-tiers");
 const auth_1 = require("../../auth");
+const agent_tier_1 = require("../../agent-tier");
 /**
  * Calls the app's own REST API over loopback using the MASTER token (held
  * server-side, never exposed to the MCP client). This reuses every router's
@@ -119,9 +120,27 @@ function registerTieredTool(server, ctx, spec) {
         description: spec.description,
         inputSchema: spec.inputSchema,
         annotations: tierAnnotations(hintTier),
-    }, async (args) => {
+    }, async (args, extra) => {
+        // In-app agent: a per-request active-project header (loopback-only, set by
+        // the agent's bridge from the Cursor-style selector) pins the project for
+        // this call so project-scoped tools resolve without specrails_select_project.
+        const projectHeader = extra?.requestInfo?.headers?.[agent_tier_1.AGENT_PROJECT_HEADER];
+        if (projectHeader != null) {
+            const pid = Array.isArray(projectHeader) ? projectHeader[0] : projectHeader;
+            if (typeof pid === 'string' && pid.trim())
+                setActiveProject(pid.trim());
+        }
         const tier = typeof spec.tier === 'function' ? spec.tier(args ?? {}) : spec.tier;
-        if (!(0, mcp_tiers_1.isTierEnabled)(ctx.desktopDb, tier)) {
+        // In-app agent: when the request carries the loopback-only agent-tier header,
+        // enforce the cumulative ladder instead of the external Settings checkboxes
+        // (design D4). Absent header → external client → unchanged Settings gate.
+        const agentLevel = (0, agent_tier_1.levelFromHeader)(extra?.requestInfo?.headers?.[agent_tier_1.AGENT_TIER_HEADER]);
+        if (agentLevel !== null) {
+            if (!(0, agent_tier_1.levelAllowsTier)(agentLevel, tier)) {
+                return errorResult((0, mcp_tiers_1.tierRefusalMessage)(tier));
+            }
+        }
+        else if (!(0, mcp_tiers_1.isTierEnabled)(ctx.desktopDb, tier)) {
             return errorResult((0, mcp_tiers_1.tierRefusalMessage)(tier));
         }
         try {

package/server/dist/project-router-setup.js

@@ -67,7 +67,21 @@ function registerSetupRoutes(deps) {
         const requested = (req.body ?? {});
         const provider = typeof requested.provider === 'string' ? requested.provider : undefined;
         res.status(202).json({ ok: true });
-        setupManager.startInstall(project.id, project.path, project.slug, provider);
+        // One-shot multi-provider install: an explicit `providers` list, or `all:true`
+        // to install every provider the project is registered with (used by the MCP/
+        // agent so a single `install` provisions them all). Else single-provider.
+        const explicit = Array.isArray(requested.providers)
+            ? requested.providers.filter((p) => typeof p === 'string')
+            : undefined;
+        if (explicit && explicit.length > 0) {
+            setupManager.startInstallProviders(project.id, project.path, project.slug, explicit);
+        }
+        else if (requested.all === true) {
+            setupManager.startInstallProviders(project.id, project.path, project.slug, project.providers);
+        }
+        else {
+            setupManager.startInstall(project.id, project.path, project.slug, provider);
+        }
     });
     router.post('/:projectId/enrich/start', (req, res) => {
         const { project, setupManager } = ctx(req);