@ours.network/fleet 0.18.1 → 0.19.0-nightly.10

package/dist/doctor.js

@@ -1,5 +1,6 @@
 import { userInfo } from 'node:os';
 import { existsSync, readFileSync } from 'node:fs';
+import { attachOursClient, } from '@ours.network/sdk/client';
 import { realExec } from './exec.js';
 import { isolationContextFor, loadConfig } from './config.js';
 import { getAdapter, productionAdapters } from './harness/registry.js';
@@ -76,7 +77,7 @@ function installChecks(scan) {
     ];
 }
 /** Host-level + per-harness prerequisite report with actionable messages. */
-export async function doctor(opts = {}, exec = realExec, platform = process.platform, fetchImpl = (u, i) => globalThis.fetch(u, i)) {
+export async function doctor(opts = {}, exec = realExec, platform = process.platform, fetchImpl = (u, i) => globalThis.fetch(u, i), attachDaemon = attachOursClient) {
     const checks = [];
     // First: which artifact is producing this report. Everything below is only as
     // trustworthy as the answer, and a second install with the same semver and
@@ -105,6 +106,126 @@ export async function doctor(opts = {}, exec = realExec, platform = process.plat
                 ok: true,
                 detail: `warning: ${diagnostic.message}`,
             });
+    // ── Rooms/tasks checks (§5.3) ────────────────────────────────────────
+    if (loaded.ok && loaded.rooms) {
+        const rooms = loaded.rooms;
+        // Cowork socket reachability
+        const coworkConfig = rooms.cowork?.config;
+        try {
+            const { createCoworkAdapter } = await import('./rooms-tasks/cowork-adapter.js');
+            const adapter = createCoworkAdapter({ configPath: coworkConfig });
+            const reachable = await adapter.available();
+            checks.push({
+                name: 'cowork', ok: reachable,
+                detail: reachable
+                    ? 'management socket reachable'
+                    : `management socket unreachable${coworkConfig ? ` (config: ${coworkConfig})` : ''}`,
+            });
+        }
+        catch (e) {
+            checks.push({
+                name: 'cowork', ok: false,
+                detail: `management socket error${coworkConfig ? ` (config: ${coworkConfig})` : ''}: ${e?.message ?? e}`,
+            });
+        }
+        // Owner CID shape
+        const cidOk = /^[0-9a-fA-F]{64}$/.test(rooms.owner.expected_cid);
+        checks.push({
+            name: 'rooms: owner CID', ok: cidOk,
+            detail: cidOk ? 'valid 64-hex CID' : `invalid CID shape: ${rooms.owner.expected_cid.slice(0, 16)}...`,
+        });
+        // Invite presence (never content)
+        checks.push({
+            name: 'rooms: owner invite',
+            ok: !!loaded.ownerInviteFingerprint,
+            detail: loaded.ownerInviteFingerprint
+                ? `present (fingerprint: ${loaded.ownerInviteFingerprint.slice(0, 12)}...)`
+                : 'not configured — room owner attachment will use waiting_owner_invite',
+        });
+        // Template validity and referenced role validity
+        const { listTemplates, resolveTemplate } = await import('./rooms-tasks/templates.js');
+        const customs = loaded.roomTemplates ?? {};
+        const templates = listTemplates(customs);
+        const roleNames = new Set(roles.map(r => r.name));
+        for (const t of templates) {
+            const badRefs = t.members
+                .filter(m => m.role_ref && !roleNames.has(m.role_ref))
+                .map(m => m.role_ref);
+            if (badRefs.length) {
+                checks.push({
+                    name: `template: ${t.name}@${t.version}`,
+                    ok: true,
+                    detail: `warning: role_ref(s) ${badRefs.join(', ')} not found in configured roles`,
+                });
+            }
+        }
+        // Default template validity
+        const defaultTemplate = loaded.rooms.defaults?.template
+            ?? loaded.tasks?.default_room_template;
+        if (defaultTemplate) {
+            const resolved = resolveTemplate(defaultTemplate, customs);
+            checks.push({
+                name: 'rooms: default template',
+                ok: !!resolved,
+                detail: resolved
+                    ? `${resolved.name}@${resolved.version}`
+                    : `template '${defaultTemplate}' not found`,
+            });
+        }
+        // Shared-daemon selection coherence
+        if (rooms.cowork?.config) {
+            const { existsSync: exists } = await import('node:fs');
+            const configOk = exists(rooms.cowork.config);
+            checks.push({
+                name: 'rooms: cowork config', ok: configOk,
+                detail: configOk
+                    ? `cowork config at ${rooms.cowork.config}`
+                    : `cowork config not found: ${rooms.cowork.config}`,
+            });
+        }
+        // Hard prerelease capability check
+        try {
+            const { createCoworkAdapter } = await import('./rooms-tasks/cowork-adapter.js');
+            const adapter = createCoworkAdapter({ configPath: coworkConfig });
+            const roomList = await adapter.listRooms();
+            checks.push({
+                name: 'rooms: capability', ok: true,
+                detail: `cowork room management operational (${roomList.length} room(s))`,
+            });
+        }
+        catch (e) {
+            const msg = e?.message ?? String(e);
+            const isProto = msg.includes('protocol') || msg.includes('invalid');
+            checks.push({
+                name: 'rooms: capability', ok: false,
+                detail: isProto
+                    ? `cowork does not support room management protocol — upgrade ours-cowork to prerelease`
+                    : `room management check failed: ${msg}`,
+            });
+        }
+        // Stale task/room warnings
+        try {
+            const { listTasks } = await import('./rooms-tasks/task-state.js');
+            const { listRoomRecords } = await import('./rooms-tasks/room-state.js');
+            const tasks = listTasks();
+            const roomRecords = listRoomRecords();
+            const roomIds = new Set(roomRecords.map(r => r.room_id));
+            const taskIds = new Set(tasks.map(t => t.task_id));
+            const orphanedTasks = tasks.filter(t => t.room_id && !roomIds.has(t.room_id));
+            const orphanedRooms = roomRecords.filter(r => r.task_id && !taskIds.has(r.task_id));
+            if (orphanedTasks.length)
+                checks.push({
+                    name: 'rooms: stale tasks', ok: true,
+                    detail: `warning: ${orphanedTasks.length} task(s) reference missing rooms: ${orphanedTasks.map(t => t.task_id).join(', ')}`,
+                });
+            if (orphanedRooms.length)
+                checks.push({
+                    name: 'rooms: stale rooms', ok: true,
+                    detail: `warning: ${orphanedRooms.length} room(s) reference missing tasks: ${orphanedRooms.map(r => r.room_id).join(', ')}`,
+                });
+        }
+        catch { /* state dir may not exist yet */ }
+    }
     if (roles.length === 0 || roles.some(role => (role.session ?? 'tmux') === 'tmux')) {
         const tmux = await exec('tmux', ['-V']);
         checks.push({
@@ -112,16 +233,22 @@ export async function doctor(opts = {}, exec = realExec, platform = process.plat
             detail: tmux.code === 0 ? tmux.stdout.trim() : 'not found — apt install tmux / brew install tmux',
         });
     }
-    const mcp = await exec('ours-mcp', ['--version']);
-    checks.push({
-        name: 'ours-mcp', ok: mcp.code === 0,
-        detail: mcp.code === 0 ? mcp.stdout.trim() : 'not found — npm i -g @ours.network/mcp',
-    });
-    if (mcp.code === 0) {
-        const st = await exec('ours-mcp', ['status']);
+    try {
+        const client = await attachDaemon({
+            env: process.env,
+            leaseToken: `ours-fleet-doctor-${process.pid}`,
+            clientPid: process.pid,
+        });
+        const info = await client.version();
+        if (info.name !== 'ours' || typeof info.version !== 'string')
+            throw new Error('the selected endpoint did not return a valid ours daemon identity');
+        checks.push({ name: 'ours daemon', ok: true, detail: `running (${info.version})` });
+    }
+    catch (error) {
         checks.push({
-            name: 'ours-mcp daemon', ok: st.code === 0,
-            detail: st.code === 0 ? 'running' : 'not running — start it with: ours-mcp start',
+            name: 'ours daemon', ok: false,
+            detail: `not reachable through the SDK — start it with: ours daemon start `
+                + `[${error?.message ?? String(error)}]`,
         });
     }
     if (platform === 'linux') {
@@ -288,7 +415,7 @@ export async function doctor(opts = {}, exec = realExec, platform = process.plat
         }
         catch (e) {
             detail = `unreachable on :${endpoint.port} — monitored roles run degraded until it is up ` +
-                `(start it: ours-mcp start) [${e?.message ?? e}]`;
+                `(start it: ours daemon start) [${e?.message ?? e}]`;
         }
         checks.push({ name: checkName, ok, detail });
     }
@@ -398,7 +525,11 @@ export async function doctor(opts = {}, exec = realExec, platform = process.plat
 function loadConfigResult(configPath, yamlMode) {
     try {
         const cfg = loadConfig(configPath, { yamlMode });
-        return { ok: true, roles: cfg.roles, files: cfg.files, diagnostics: cfg.diagnostics };
+        return {
+            ok: true, roles: cfg.roles, files: cfg.files, diagnostics: cfg.diagnostics,
+            rooms: cfg.rooms, roomTemplates: cfg.roomTemplates, tasks: cfg.tasks,
+            ownerInviteFingerprint: cfg.ownerInviteFingerprint,
+        };
     }
     catch (e) {
         return { ok: false, error: e instanceof Error ? e.message : String(e) };

package/dist/fleet-proxy.d.ts

@@ -12,11 +12,6 @@ export interface ManagedFleetSpawnResult {
     session: 'tmux' | 'acp';
     model?: string;
     monitor: Pick<MonitorConfig, 'mode' | 'interrupt'>;
-    /** Adapter-resolved portable policy and exact native runtime mode. */
-    permissionMode?: {
-        fleetMode: 'ask' | 'auto' | 'allow';
-        nativeMode: string;
-    };
     inherited: string[];
     creationActionId: string;
 }

package/dist/harness/acp-agent.js

@@ -1,23 +1,18 @@
 import { createRequire } from 'node:module';
-import { readFileSync, realpathSync, statSync } from 'node:fs';
-import { dirname, isAbsolute, relative, resolve, sep } from 'node:path';
+import { existsSync, readFileSync } from 'node:fs';
+import { dirname, resolve } from 'node:path';
 const require = createRequire(import.meta.url);
 export function resolveBundledAcpAgent(packageName, binName, fallbackCommand) {
     try {
         const manifestPath = require.resolve(`${packageName}/package.json`);
         const manifest = JSON.parse(readFileSync(manifestPath, 'utf8'));
-        const declaredEntrypoint = typeof manifest.bin === 'string'
+        const relative = typeof manifest.bin === 'string'
             ? manifest.bin
             : manifest.bin?.[binName];
-        if (!declaredEntrypoint)
+        if (!relative)
             return { argv: [fallbackCommand], bundled: false };
-        const packageRoot = realpathSync(dirname(manifestPath));
-        const entrypoint = realpathSync(resolve(packageRoot, declaredEntrypoint));
-        const entrypointFromRoot = relative(packageRoot, entrypoint);
-        if (entrypointFromRoot === '..'
-            || entrypointFromRoot.startsWith(`..${sep}`)
-            || isAbsolute(entrypointFromRoot)
-            || !statSync(entrypoint).isFile())
+        const entrypoint = resolve(dirname(manifestPath), relative);
+        if (!existsSync(entrypoint))
             return { argv: [fallbackCommand], bundled: false };
         return {
             argv: [process.execPath, entrypoint], bundled: true, manifestPath,

package/dist/harness/claude-code.js

@@ -6,98 +6,8 @@ import { registerAdapter } from './registry.js';
 import { replaceFileAtomically, withFileLock } from '../atomic-file.js';
 import { harnessRuntimeDir } from '../isolation/policy.js';
 import { bundledAcpAgent } from './acp-agent.js';
-const OPTION_KEYS = [
-    'plugins', 'mem_palace', 'mem_palace_midsession_autosave', 'permission_mode', 'effort',
-    'mcp_servers', 'mcp_servers_only',
-];
+const OPTION_KEYS = ['plugins', 'mem_palace', 'mem_palace_midsession_autosave', 'permission_mode', 'effort'];
 const EFFORT_LEVELS = ['low', 'medium', 'high', 'xhigh', 'max'];
-/** `.mcp.json` server types. Absent means stdio, as the file format has it. */
-const MCP_SERVER_TYPES = ['stdio', 'http', 'sse'];
-/** A role that names its own ACP command runs a process fleet did not choose. */
-const customAcpCommand = (role) => role.session === 'acp' && role.session_options?.acp?.command != null;
-/**
- * Does this server set include the ours connector?
- *
- * Load-bearing, and the reason it is a check rather than a doc line:
- * `mcp_servers_only` maps to `--strict-mcp-config`, which ignores EVERY other MCP
- * configuration — project `.mcp.json`, user settings, and **plugins**. On a
- * normal install the ours connector arrives as a plugin
- * (`~/.claude/plugins/.../plugin.json` declares `ours`), so a role that turns
- * strict mode on without re-declaring it loses `send_message` and `get_messages`
- * and cannot report that it has: a mute agent looks exactly like a quiet one.
- *
- * Matched on the command line rather than the server's NAME, because the name is
- * the operator's to choose and would make this trivially satisfiable by writing
- * `ours:` above the wrong command.
- */
-const declaresOursConnector = (servers) => Object.values(servers).some(s => [s.command ?? '', ...(s.args ?? [])].some(part => /(^|[/\\])ours-mcp($|\s)|@ours\.network[/\\]mcp/.test(part)));
-/** Shape-check `harness_options.mcp_servers` against `.mcp.json`'s own rules. */
-function validateMcpServers(servers) {
-    if (servers == null)
-        return [];
-    const at = (k = '') => ({ path: `harness_options.mcp_servers${k}` });
-    if (typeof servers !== 'object' || Array.isArray(servers))
-        return [{ ...at(), message: 'must be a map of server name to server definition' }];
-    const entries = Object.entries(servers);
-    if (!entries.length)
-        return [{ ...at(), message: 'must declare at least one server, or be omitted' }];
-    const errors = [];
-    for (const [name, raw] of entries) {
-        const p = `.${name}`;
-        if (!/^[A-Za-z0-9_-]+$/.test(name)) {
-            errors.push({ ...at(p), message: 'server name must be [A-Za-z0-9_-]' });
-            continue;
-        }
-        if (raw == null || typeof raw !== 'object' || Array.isArray(raw)) {
-            errors.push({ ...at(p), message: 'must be a map' });
-            continue;
-        }
-        const s = raw;
-        if (s.type != null && !MCP_SERVER_TYPES.includes(s.type))
-            errors.push({ ...at(`${p}.type`), message: `must be one of: ${MCP_SERVER_TYPES.join(', ')}` });
-        const remote = s.type === 'http' || s.type === 'sse';
-        if (remote) {
-            if (typeof s.url !== 'string' || !s.url.trim())
-                errors.push({ ...at(`${p}.url`), message: `must be a non-empty URL for a ${s.type} server` });
-            if (s.command != null)
-                errors.push({ ...at(`${p}.command`), message: `must not be set for a ${s.type} server` });
-        }
-        else {
-            if (typeof s.command !== 'string' || !s.command.trim())
-                errors.push({ ...at(`${p}.command`), message: 'must be a non-empty command for a stdio server' });
-            if (s.args != null && (!Array.isArray(s.args) || s.args.some(a => typeof a !== 'string')))
-                errors.push({ ...at(`${p}.args`), message: 'must be an array of strings' });
-            if (s.url != null)
-                errors.push({ ...at(`${p}.url`), message: 'must not be set for a stdio server' });
-        }
-        for (const key of ['env', 'headers']) {
-            const v = s[key];
-            if (v == null)
-                continue;
-            if (typeof v !== 'object' || Array.isArray(v)
-                || Object.values(v).some(x => typeof x !== 'string'))
-                errors.push({ ...at(`${p}.${key}`), message: 'must be a map of string to string' });
-        }
-    }
-    return errors;
-}
-/** `harness_options.mcp_servers` in ACP's `session/new` array shape. */
-function acpMcpServersFor(servers) {
-    if (!servers)
-        return [];
-    // `env` and `headers` are REQUIRED arrays in the protocol, so they are always
-    // sent — empty when the role declared none.
-    const pairs = (r) => Object.entries(r ?? {}).map(([name, value]) => ({ name, value }));
-    return Object.entries(servers).map(([name, s]) => {
-        if (s.type === 'http' || s.type === 'sse')
-            return { name, type: s.type, url: s.url, headers: pairs(s.headers) };
-        // Stdio carries NO `type` field: ACP's stdio variant is the one without it,
-        // and the bundled agent keys on exactly that (claude-agent-acp
-        // acp-agent.js:4058, `!("type" in server)`), so sending `type: 'stdio'`
-        // would drop the server on the floor.
-        return { name, command: s.command, args: s.args ?? [], env: pairs(s.env) };
-    });
-}
 /** Claude Code's accepted --permission-mode values. */
 const PERMISSION_MODES = ['default', 'acceptEdits', 'plan', 'dontAsk', 'bypassPermissions'];
 /**
@@ -217,8 +127,11 @@ export async function pretrust(dir, deps = {}) {
  * it must be the Monitor TOOL, not a background Bash task (which never wakes the
  * agent on output → an armed-looking but deaf monitor).
  */
+const shellQuote = (value) => `'${value.replace(/'/g, `'"'"'`)}'`;
+const watchCommand = (id) => 'ours api watch-notifications --input '
+    + shellQuote(JSON.stringify({ identity: id, since: 'tip' })) + ' --json';
 const armMonitor = (id) => 'arm a **persistent Monitor** (the Monitor TOOL — NOT a background Bash command; a ' +
-    `background Bash task never wakes you on output) running \`ours-mcp watch "${id}"\` ` +
+    `background Bash task never wakes you on output) running \`${watchCommand(id)}\` ` +
     'so inbound ours mail wakes you';
 export function makeClaudeCodeAdapter(exec = realExec) {
     return {
@@ -236,7 +149,7 @@ export function makeClaudeCodeAdapter(exec = realExec) {
                     }],
             };
         },
-        validateOptions(opts, role) {
+        validateOptions(opts) {
             if (opts == null)
                 return [];
             if (typeof opts !== 'object' || Array.isArray(opts))
@@ -244,44 +157,9 @@ export function makeClaudeCodeAdapter(exec = realExec) {
             const errors = Object.keys(opts)
                 .filter(k => !OPTION_KEYS.includes(k))
                 .map(k => ({ path: `harness_options.${k}`, message: `unknown option; allowed: ${OPTION_KEYS.join(', ')}` }));
-            const o = opts;
-            const effort = o.effort;
+            const effort = opts.effort;
             if (effort != null && !EFFORT_LEVELS.includes(effort))
                 errors.push({ path: 'harness_options.effort', message: `must be one of: ${EFFORT_LEVELS.join(', ')}` });
-            if (o.mcp_servers_only != null && typeof o.mcp_servers_only !== 'boolean')
-                errors.push({ path: 'harness_options.mcp_servers_only', message: 'must be a boolean' });
-            errors.push(...validateMcpServers(o.mcp_servers));
-            if (o.mcp_servers_only === true && !o.mcp_servers)
-                errors.push({
-                    path: 'harness_options.mcp_servers_only',
-                    message: 'requires harness_options.mcp_servers; on its own it would leave the role with no MCP servers at all',
-                });
-            // The muteness gate. Only when the declared set is otherwise well-formed —
-            // a shape error already told the operator to look here.
-            if (o.mcp_servers_only === true && o.mcp_servers && errors.length === 0
-                && !declaresOursConnector(o.mcp_servers))
-                errors.push({
-                    path: 'harness_options.mcp_servers',
-                    message: 'mcp_servers_only ignores every other MCP configuration, INCLUDING plugins — and the ours '
-                        + 'connector is normally a plugin, so this role would have no send_message or get_messages and no way '
-                        + 'to report that. Declare it explicitly, e.g. ours: { command: ours-mcp, args: [proxy] }',
-                });
-            // Session-aware refusals. Both options reach an ACP session through the
-            // bundled agent's `_meta` vocabulary, so a role that launches a DIFFERENT
-            // ACP agent cannot be promised either one. Refuse rather than send it and
-            // hope: silently dropping the config is the defect being fixed here.
-            if (role && customAcpCommand(role)) {
-                for (const key of ['plugins', 'mcp_servers', 'mcp_servers_only']) {
-                    if (o[key] == null)
-                        continue;
-                    errors.push({
-                        path: `harness_options.${key}`,
-                        message: 'cannot be honoured with session_options.acp.command: it is delivered through the bundled '
-                            + 'Claude ACP agent\'s _meta vocabulary, which another agent has no reason to read. Drop the '
-                            + 'custom ACP command, or drop this option',
-                    });
-                }
-            }
             return errors;
         },
         async prepareSession(role, dirs) {
@@ -300,15 +178,6 @@ export function makeClaudeCodeAdapter(exec = realExec) {
                 CLAUDE_AUTOCOMPACT_PCT_OVERRIDE: String(autocompactPct(role)),
                 MEMPALACE_HOOKS_AUTO_SAVE: 'false',
                 MEMPALACE_MIDSESSION_AUTOSAVE: o.mem_palace_midsession_autosave ? 'true' : 'false',
-                // The role's identity, for the ours connector to bind at startup instead of
-                // the briefing telling the MODEL to call choose_identity. Both launches
-                // return `prep.env`, so this one line covers tmux and ACP alike.
-                //
-                // The bind the connector performs is PLAIN and fail-closed: it can never
-                // evict a live session, and a role whose identity does not exist yet simply
-                // boots unbound and falls through to the briefing's create-if-missing step.
-                // Nothing here may ever grow a force flag.
-                OURS_BIND_IDENTITY: role.identity,
             };
             if (!memPalace)
                 env.MEMPALACE_DISABLED = 'true';
@@ -319,29 +188,12 @@ export function makeClaudeCodeAdapter(exec = realExec) {
             if (role.isolation)
                 mkdirSync(harnessRuntimeDir(dirs.stateDir, 'claude'), { recursive: true });
             const argv = [];
-            let settingsOverlay;
             if (Object.keys(enabledPlugins).length) {
-                settingsOverlay = join(dirs.stateDir, '.settings-overlay.json');
-                writeFileSync(settingsOverlay, JSON.stringify({ enabledPlugins }, null, 2));
-                argv.push('--settings', settingsOverlay);
+                const overlay = join(dirs.stateDir, '.settings-overlay.json');
+                writeFileSync(overlay, JSON.stringify({ enabledPlugins }, null, 2));
+                argv.push('--settings', overlay);
             }
-            // `harness_options.mcp_servers` — the tmux delivery. `--mcp-config` ADDS the
-            // file's servers; `--strict-mcp-config` is what makes the set exclusive, and
-            // it is opt-in per role because it drops everything else the user has,
-            // plugins included (see `declaresOursConnector`).
-            let mcpConfigFile;
-            if (o.mcp_servers) {
-                mcpConfigFile = join(dirs.stateDir, '.mcp-config.json');
-                writeFileSync(mcpConfigFile, JSON.stringify({ mcpServers: o.mcp_servers }, null, 2), { mode: 0o600 });
-                argv.push('--mcp-config', mcpConfigFile);
-                if (o.mcp_servers_only === true)
-                    argv.push('--strict-mcp-config');
-            }
-            return {
-                argv, env,
-                ...(settingsOverlay ? { settingsOverlay } : {}),
-                ...(mcpConfigFile ? { mcpConfigFile } : {}),
-            };
+            return { argv, env };
         },
         buildLaunch(role, mode, s, prep) {
             const stateDir = roleStateDir(role);
@@ -371,46 +223,6 @@ export function makeClaudeCodeAdapter(exec = realExec) {
         acpPermissionModeId(role) {
             return permissionMode(role);
         },
-        /**
-         * Deliver, over ACP, the two things the tmux launch delivers as flags.
-         *
-         * `buildAcpLaunch` builds its own argv and cannot carry `prep.argv`: the
-         * process it launches is the ACP agent, not `claude`, and it takes none of
-         * claude's flags. That is why `harness_options.plugins` did nothing at all on
-         * an ACP role — the overlay was written and then dropped, and the mem-palace
-         * toggle rode `prep.env` and survived, so the failure was silent AND
-         * selective.
-         *
-         * `_meta.claudeCode.options` is the bundled agent's own passthrough into the
-         * Claude Agent SDK (@agentclientprotocol/claude-agent-acp, acp-agent.js:4092
-         * → the `options` object at :4144). `settings` takes the same overlay path
-         * `--settings` takes; `strictMcpConfig` is the SDK's spelling of
-         * `--strict-mcp-config`. Both are spread BEFORE the fields the agent forces,
-         * so neither is overwritten.
-         *
-         * ⚠ RETURNS NOTHING FOR A ROLE THAT NAMES ITS OWN ACP COMMAND. That process
-         * is not the bundled agent and has no reason to read this vocabulary; sending
-         * it anyway would be the silent drop again, one level down. `validateOptions`
-         * refuses those roles instead.
-         */
-        acpSessionMeta(role, prep) {
-            if (customAcpCommand(role))
-                return undefined;
-            const options = {};
-            if (prep.settingsOverlay)
-                options.settings = prep.settingsOverlay;
-            if (role.harness_options?.mcp_servers_only === true)
-                options.strictMcpConfig = true;
-            return Object.keys(options).length ? { claudeCode: { options } } : undefined;
-        },
-        /**
-         * The declared servers, in ACP's array shape. Sent on `session/new` and on
-         * resume/load, because the SDK builds its server set once per session and a
-         * resumed session that dropped them would quietly lose its tools.
-         */
-        acpMcpServers(role) {
-            return acpMcpServersFor(role.harness_options?.mcp_servers);
-        },
         isolationPaths(_role, _dirs) {
             const claudeHome = join(home(), '.claude');
             return {
@@ -473,7 +285,6 @@ export function makeClaudeCodeAdapter(exec = realExec) {
             currentIdentityTool: 'current_identity',
             sendTool: 'send_message',
             getMessagesTool: 'get_messages',
-            watchCommand: id => `ours-mcp watch "${id}"`,
             monitorInstruction: id => {
                 const m = armMonitor(id);
                 return `${m.charAt(0).toUpperCase()}${m.slice(1)}.`;

package/dist/harness/codex.d.ts

@@ -1,13 +1,10 @@
 import { type Exec } from '../exec.js';
-import type { AcpLaunch, HarnessAdapter, UnattendedCapability } from './types.js';
-import { type AcpAgentResolution } from './acp-agent.js';
+import type { HarnessAdapter, UnattendedCapability } from './types.js';
 /**
  * What an unattended role can actually do under Codex's native settings.
  * `on-request` and `untrusted` stop to ask, and with no console attached that
  * request is refused rather than answered — so the role can only read.
  */
 export declare function codexCapabilities(approval: string, sandbox: string): UnattendedCapability[];
-/** Bind launch argv and metadata provenance to one already-completed resolution. */
-export declare function codexAcpLaunchForResolution(resolution: AcpAgentResolution): Pick<AcpLaunch, 'argv' | 'permissionMetadataSource'>;
 export declare function makeCodexAdapter(exec?: Exec): HarnessAdapter;
 export declare const codexAdapter: HarnessAdapter;