@ours.network/fleet 1.0.5 → 1.1.0-nightly.2

package/dist/harness/agent-session.d.ts

@@ -0,0 +1,46 @@
+import type { CommonPermissions, FleetPermissionMode, ResolvedRole } from '../config.js';
+import type { AgentSession } from '../session/types.js';
+import type { Launch, SessionPrep } from './types.js';
+/**
+ * Command selected by a harness adapter. The runner may wrap argv for its
+ * isolation/resource boundary, but never interprets adapter-specific fields.
+ */
+export interface PreparedAgentSessionLaunch extends Launch {
+    readonly adapterState?: unknown;
+}
+export interface BrainSelection {
+    model?: string | null;
+    effort?: string;
+    harnessOptions?: Record<string, unknown>;
+}
+export interface ResolvedBrainSelection {
+    model?: string | null;
+    harnessOptions?: Record<string, unknown>;
+}
+export interface AgentSessionStartOptions {
+    role: ResolvedRole;
+    prep: SessionPrep;
+    launch: PreparedAgentSessionLaunch;
+    cwd: string;
+    stateDir: string;
+    mode: 'fresh' | 'resume';
+    permissions: CommonPermissions;
+    permissionMode: {
+        fleetMode: FleetPermissionMode;
+        nativeMode: string;
+    };
+    log(line: string): void;
+}
+/**
+ * The sole harness-specific boundary for creating a live agent session.
+ * Lifecycle orchestration remains in the runner; ACP normalization remains in
+ * the shared transport implementation.
+ */
+export interface AgentSessionAdapter {
+    /** Harness-owned translation of neutral Brain selection into launch state. */
+    resolveBrain(brain: BrainSelection): ResolvedBrainSelection;
+    /** Harness-owned environment channel used to pin/recover a model, if any. */
+    modelEnvironmentVariable(): string | undefined;
+    prepareLaunch(role: ResolvedRole, prep: SessionPrep): PreparedAgentSessionLaunch;
+    start(options: AgentSessionStartOptions): Promise<AgentSession>;
+}

package/dist/harness/agent-session.js

@@ -0,0 +1 @@
+export {};

package/dist/harness/claude-code-session.d.ts

@@ -0,0 +1,22 @@
+import type { ResolvedRole } from '../config.js';
+import type { AcpMcpServer, SessionPrep } from './types.js';
+import type { AgentSessionAdapter, AgentSessionStartOptions, PreparedAgentSessionLaunch } from './agent-session.js';
+import { type AcpSessionTransport } from './acp-session-transport.js';
+export interface ClaudeCodeSessionStrategy {
+    resolveBrain: AgentSessionAdapter['resolveBrain'];
+    modelEnvironmentVariable: AgentSessionAdapter['modelEnvironmentVariable'];
+    prepareLaunch(role: ResolvedRole, prep: SessionPrep): PreparedAgentSessionLaunch;
+    permissionModeId(role: ResolvedRole): string | undefined;
+    mcpServers(role: ResolvedRole): AcpMcpServer[] | undefined;
+    sessionMeta(role: ResolvedRole, prep: SessionPrep): Record<string, unknown> | undefined;
+}
+/** Explicit Claude Code implementation of Fleet's shared agent-session factory. */
+export declare class ClaudeCodeAgentSessionAdapter implements AgentSessionAdapter {
+    private readonly strategy;
+    private readonly transport;
+    constructor(strategy: ClaudeCodeSessionStrategy, transport?: AcpSessionTransport);
+    resolveBrain(brain: Parameters<AgentSessionAdapter['resolveBrain']>[0]): import("./agent-session.js").ResolvedBrainSelection;
+    modelEnvironmentVariable(): string | undefined;
+    prepareLaunch(role: ResolvedRole, prep: SessionPrep): PreparedAgentSessionLaunch;
+    start(options: AgentSessionStartOptions): Promise<import("../index.js").AgentSession>;
+}

package/dist/harness/claude-code-session.js

@@ -0,0 +1,32 @@
+import { AcpSession } from '../session/acp.js';
+import { acpAdapterState, } from './acp-session-transport.js';
+/** Explicit Claude Code implementation of Fleet's shared agent-session factory. */
+export class ClaudeCodeAgentSessionAdapter {
+    strategy;
+    transport;
+    constructor(strategy, transport = AcpSession.start) {
+        this.strategy = strategy;
+        this.transport = transport;
+    }
+    resolveBrain(brain) {
+        return this.strategy.resolveBrain(brain);
+    }
+    modelEnvironmentVariable() { return this.strategy.modelEnvironmentVariable(); }
+    prepareLaunch(role, prep) {
+        return this.strategy.prepareLaunch(role, prep);
+    }
+    start(options) {
+        const { role, prep, launch } = options;
+        return this.transport({
+            name: role.name, argv: launch.argv, cwd: options.cwd, env: launch.env,
+            stateDir: options.stateDir, mode: options.mode, permissions: options.permissions,
+            modeId: this.strategy.permissionModeId(role),
+            mcpServers: this.strategy.mcpServers(role),
+            sessionMeta: this.strategy.sessionMeta(role, prep),
+            permissionMode: options.permissionMode,
+            permissionMetadataSource: acpAdapterState(launch.adapterState).permissionMetadataSource,
+            scrubObsoleteOursAutostart: true,
+            log: options.log,
+        });
+    }
+}

package/dist/harness/claude-code.d.ts

@@ -2,6 +2,7 @@ import { type Exec } from '../exec.js';
 import type { ResolvedRole } from '../config.js';
 import type { HarnessAdapter, UnattendedCapability } from './types.js';
 import { type LockDeps } from '../atomic-file.js';
+import type { AcpSessionTransport } from './acp-session-transport.js';
 /**
  * Neutral approval → native Claude mode. The ONE definition, shared by launch
  * and by translation so the two can never disagree about what a role will run
@@ -40,5 +41,5 @@ export declare function pretrust(dir: string, deps?: {
     log?(line: string): void;
     lock?: LockDeps;
 }): Promise<void>;
-export declare function makeClaudeCodeAdapter(exec?: Exec): HarnessAdapter;
+export declare function makeClaudeCodeAdapter(exec?: Exec, transport?: AcpSessionTransport): HarnessAdapter;
 export declare const claudeCodeAdapter: HarnessAdapter;

package/dist/harness/claude-code.js

@@ -6,6 +6,7 @@ import { registerAdapter } from './registry.js';
 import { replaceFileAtomically, withFileLock } from '../atomic-file.js';
 import { harnessRuntimeDir } from '../isolation/policy.js';
 import { bundledAcpAgent } from './acp-agent.js';
+import { ClaudeCodeAgentSessionAdapter } from './claude-code-session.js';
 const OPTION_KEYS = [
     'plugins', 'mem_palace', 'mem_palace_midsession_autosave', 'permission_mode', 'effort',
     'mcp_servers', 'mcp_servers_only',
@@ -223,9 +224,42 @@ const watchCommand = (id) => 'ours api watch-notifications --input '
 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 \`${watchCommand(id)}\` ` +
     'so inbound ours mail wakes you';
-export function makeClaudeCodeAdapter(exec = realExec) {
+export function makeClaudeCodeAdapter(exec = realExec, transport) {
     return {
         id: 'claude-code',
+        agentSession: new ClaudeCodeAgentSessionAdapter({
+            resolveBrain(brain) {
+                if (brain.effort != null
+                    && (typeof brain.effort !== 'string' || !EFFORT_LEVELS.includes(brain.effort)))
+                    throw new Error(`Claude Code Brain effort must be one of: ${EFFORT_LEVELS.join(', ')}`);
+                return {
+                    model: brain.model,
+                    harnessOptions: { ...(brain.harnessOptions ?? {}), ...(brain.effort ? { effort: brain.effort } : {}) },
+                };
+            },
+            modelEnvironmentVariable: () => 'ANTHROPIC_MODEL',
+            prepareLaunch(role, prep) {
+                const configured = role.session_options?.acp?.command;
+                const argv = Array.isArray(configured)
+                    ? [...configured]
+                    : typeof configured === 'string'
+                        ? ['sh', '-c', configured]
+                        : bundledAcpAgent('@agentclientprotocol/claude-agent-acp', 'claude-agent-acp', 'claude-agent-acp');
+                return { argv, env: prep.env };
+            },
+            permissionModeId: role => permissionMode(role),
+            mcpServers: role => acpMcpServersFor(role.harness_options?.mcp_servers),
+            sessionMeta(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;
+            },
+        }, transport),
         supportsResume: true,
         async checkPrereqs() {
             const r = await exec('claude', ['--version']);
@@ -305,7 +339,7 @@ export function makeClaudeCodeAdapter(exec = realExec) {
                 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.
+                // reaches the adapter-owned ACP child through `prep.env`.
                 //
                 // 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
@@ -321,99 +355,23 @@ export function makeClaudeCodeAdapter(exec = realExec) {
             // sandbox needs this directory to exist before entry.
             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);
             }
-            // `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`).
+            // Keep the MCP config artifact for diagnostics and adapter metadata.
             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,
+                env,
                 ...(settingsOverlay ? { settingsOverlay } : {}),
                 ...(mcpConfigFile ? { mcpConfigFile } : {}),
             };
         },
-        buildLaunch(role, mode, s, prep) {
-            const stateDir = roleStateDir(role);
-            const pm = permissionMode(role);
-            const o = role.harness_options;
-            const base = ['claude', ...(role.model ? ['--model', role.model] : []),
-                ...(o?.effort ? ['--effort', o.effort] : []),
-                ...(pm ? ['--permission-mode', pm] : []),
-                ...prep.argv, '--remote-control', role.name];
-            const argv = mode === 'fresh'
-                ? [...base, '--session-id', s.sessionId, `Read and follow ${join(stateDir, 'briefing.md')} now.`]
-                : [...base, '--resume', s.sessionId,
-                    this.vocabulary.restartPrompt(role.identity, join(stateDir, 'WORKLOG.md'), role)];
-            return { argv, env: prep.env };
-        },
-        buildAcpLaunch(role, prep) {
-            const configured = role.session_options?.acp?.command;
-            const argv = Array.isArray(configured)
-                ? [...configured]
-                : typeof configured === 'string'
-                    ? ['sh', '-c', configured]
-                    : bundledAcpAgent('@agentclientprotocol/claude-agent-acp', 'claude-agent-acp', 'claude-agent-acp');
-            return { argv, env: prep.env };
-        },
-        // Same source as buildLaunch's --permission-mode flag, so the tmux and ACP
-        // backends cannot disagree about what a role's permissions translate to.
-        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 {
@@ -501,7 +459,7 @@ export function makeClaudeCodeAdapter(exec = realExec) {
 }
 // The adapter needs the state dir for briefing/worklog paths in launch prompts.
 // Roles' state dirs are canonical: agentDir(name) — temp roles carry their dir in cwd handling
-// by the runner, which passes dirs to prepareSession; buildLaunch derives from the same rule.
+// by the runner, which passes dirs to prepareSession.
 import { agentDir } from '../paths.js';
 function roleStateDir(role) {
     // Temp roles are marked by the runner via a private field to keep the interface small.

package/dist/harness/codex-session.d.ts

@@ -0,0 +1,22 @@
+import type { ResolvedRole } from '../config.js';
+import type { AcpMcpServer, SessionPrep } from './types.js';
+import type { AgentSessionAdapter, AgentSessionStartOptions, PreparedAgentSessionLaunch } from './agent-session.js';
+import { type AcpSessionTransport } from './acp-session-transport.js';
+export interface CodexSessionStrategy {
+    resolveBrain: AgentSessionAdapter['resolveBrain'];
+    modelEnvironmentVariable: AgentSessionAdapter['modelEnvironmentVariable'];
+    prepareLaunch(role: ResolvedRole, prep: SessionPrep): PreparedAgentSessionLaunch;
+    permissionModeId(role: ResolvedRole): string | undefined;
+    mcpServers(role: ResolvedRole): AcpMcpServer[] | undefined;
+    sessionMeta(role: ResolvedRole, prep: SessionPrep): Record<string, unknown> | undefined;
+}
+/** Explicit Codex implementation of Fleet's shared agent-session factory. */
+export declare class CodexAgentSessionAdapter implements AgentSessionAdapter {
+    private readonly strategy;
+    private readonly transport;
+    constructor(strategy: CodexSessionStrategy, transport?: AcpSessionTransport);
+    resolveBrain(brain: Parameters<AgentSessionAdapter['resolveBrain']>[0]): import("./agent-session.js").ResolvedBrainSelection;
+    modelEnvironmentVariable(): string | undefined;
+    prepareLaunch(role: ResolvedRole, prep: SessionPrep): PreparedAgentSessionLaunch;
+    start(options: AgentSessionStartOptions): Promise<import("../index.js").AgentSession>;
+}

package/dist/harness/codex-session.js

@@ -0,0 +1,32 @@
+import { AcpSession } from '../session/acp.js';
+import { acpAdapterState, } from './acp-session-transport.js';
+/** Explicit Codex implementation of Fleet's shared agent-session factory. */
+export class CodexAgentSessionAdapter {
+    strategy;
+    transport;
+    constructor(strategy, transport = AcpSession.start) {
+        this.strategy = strategy;
+        this.transport = transport;
+    }
+    resolveBrain(brain) {
+        return this.strategy.resolveBrain(brain);
+    }
+    modelEnvironmentVariable() { return this.strategy.modelEnvironmentVariable(); }
+    prepareLaunch(role, prep) {
+        return this.strategy.prepareLaunch(role, prep);
+    }
+    start(options) {
+        const { role, prep, launch } = options;
+        return this.transport({
+            name: role.name, argv: launch.argv, cwd: options.cwd, env: launch.env,
+            stateDir: options.stateDir, mode: options.mode, permissions: options.permissions,
+            modeId: this.strategy.permissionModeId(role),
+            mcpServers: this.strategy.mcpServers(role),
+            sessionMeta: this.strategy.sessionMeta(role, prep),
+            permissionMode: options.permissionMode,
+            permissionMetadataSource: acpAdapterState(launch.adapterState).permissionMetadataSource,
+            scrubObsoleteOursAutostart: true,
+            log: options.log,
+        });
+    }
+}

package/dist/harness/codex.d.ts

@@ -1,6 +1,7 @@
 import { type Exec } from '../exec.js';
 import type { AcpLaunch, HarnessAdapter, UnattendedCapability } from './types.js';
 import { type AcpAgentResolution } from './acp-agent.js';
+import type { AcpSessionTransport } from './acp-session-transport.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
@@ -9,5 +10,5 @@ import { type AcpAgentResolution } from './acp-agent.js';
 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 function makeCodexAdapter(exec?: Exec, transport?: AcpSessionTransport): HarnessAdapter;
 export declare const codexAdapter: HarnessAdapter;

package/dist/harness/codex.js

@@ -6,6 +6,7 @@ import { realExec } from '../exec.js';
 import { registerAdapter } from './registry.js';
 import { harnessRuntimeDir } from '../isolation/policy.js';
 import { resolveBundledAcpAgent, } from './acp-agent.js';
+import { CodexAgentSessionAdapter } from './codex-session.js';
 const OPTION_KEYS = [
     'launcher', 'sandbox', 'approval', 'permission_mode', 'search', 'profile', 'config', 'add_dirs',
     'monitor',
@@ -124,6 +125,24 @@ function launcherMode(role) {
 function bundledCodexAcp() {
     return resolveBundledAcpAgent(CODEX_ACP_PACKAGE, 'codex-acp', 'codex-acp');
 }
+function codexAgentLaunch(role, prep) {
+    const configured = role.session_options?.acp?.command;
+    const resolved = configured == null
+        ? codexAcpLaunchForResolution(bundledCodexAcp())
+        : undefined;
+    const argv = Array.isArray(configured)
+        ? [...configured]
+        : typeof configured === 'string'
+            ? ['sh', '-c', configured]
+            : resolved.argv;
+    const initialMode = acpAgentMode(role);
+    return {
+        argv,
+        env: initialMode ? { ...prep.env, INITIAL_AGENT_MODE: initialMode } : prep.env,
+        ...(resolved?.permissionMetadataSource
+            ? { permissionMetadataSource: resolved.permissionMetadataSource } : {}),
+    };
+}
 /** Bind launch argv and metadata provenance to one already-completed resolution. */
 export function codexAcpLaunchForResolution(resolution) {
     const permissionMetadataSource = resolution.bundled
@@ -228,9 +247,37 @@ function hasInstalledOursPlugin(output) {
         return false;
     }
 }
-export function makeCodexAdapter(exec = realExec) {
+export function makeCodexAdapter(exec = realExec, transport) {
     return {
         id: 'codex',
+        agentSession: new CodexAgentSessionAdapter({
+            resolveBrain(brain) {
+                const levels = ['low', 'medium', 'high', 'xhigh', 'max', 'ultra'];
+                if (brain.effort != null
+                    && (typeof brain.effort !== 'string' || !levels.includes(brain.effort)))
+                    throw new Error(`Codex Brain effort must be one of: ${levels.join(', ')}`);
+                const harnessOptions = { ...(brain.harnessOptions ?? {}) };
+                if (brain.effort)
+                    harnessOptions.config = {
+                        ...(harnessOptions.config ?? {}),
+                        model_reasoning_effort: brain.effort,
+                    };
+                return { model: brain.model, harnessOptions };
+            },
+            modelEnvironmentVariable: () => undefined,
+            prepareLaunch(role, prep) {
+                const launch = codexAgentLaunch(role, prep);
+                const { permissionMetadataSource, ...neutral } = launch;
+                return {
+                    ...neutral,
+                    ...(permissionMetadataSource
+                        ? { adapterState: { permissionMetadataSource } } : {}),
+                };
+            },
+            permissionModeId: role => acpAgentMode(role),
+            mcpServers: () => undefined,
+            sessionMeta: () => undefined,
+        }, transport),
         supportsResume: true,
         async checkPrereqs() {
             const [r, hasOursCodex, plugins] = await Promise.all([
@@ -314,58 +361,15 @@ export function makeCodexAdapter(exec = realExec) {
             // sandbox needs this directory to exist before entry.
             if (role.isolation)
                 mkdirSync(harnessRuntimeDir(dirs.stateDir, 'codex'), { recursive: true });
-            const requested = launcherMode(role);
-            const hasOursCodex = await commandAvailable('ours-codex', exec);
-            if (requested === 'ours-codex' && !hasOursCodex)
-                throw new Error('harness_options.launcher is ours-codex, but ours-codex is not on PATH; install @ours.network/codex or use launcher: auto');
-            const command = requested === 'codex' ? 'codex' : hasOursCodex ? 'ours-codex' : 'codex';
             return {
-                argv: [],
                 // OURS_BIND_IDENTITY is the connector's startup bind seed — see the note in
                 // claude-code.ts's prepareSession. It belongs on EVERY harness that runs a
                 // role with an ours identity, not just claude-code: a seed that works on one
                 // harness and silently does nothing on the other is the same class of defect
                 // as a config key that only works on one session type.
                 env: { OURS_BIND_IDENTITY: role.identity, ...codexAcpEnvironment(role, dirs) },
-                command,
-            };
-        },
-        buildLaunch(role, mode, _s, prep) {
-            const stateDir = roleStateDir(role);
-            const flags = commonFlags(role);
-            const command = prep.command ?? 'codex';
-            const argv = mode === 'fresh'
-                ? [command, ...flags, ...prep.argv, `Read and follow ${join(stateDir, 'briefing.md')} now.`]
-                : [command, 'resume', '--last', ...flags, ...prep.argv,
-                    this.vocabulary.restartPrompt(role.identity, join(stateDir, 'WORKLOG.md'), role)];
-            return { argv, env: prep.env };
-        },
-        buildAcpLaunch(role, prep) {
-            const configured = role.session_options?.acp?.command;
-            // Resolve once: both argv and permission-metadata provenance must describe
-            // the same artifact. A bare PATH fallback is launchable for compatibility,
-            // but is never authenticated for protected-MCP auto-approval.
-            const resolved = configured == null
-                ? codexAcpLaunchForResolution(bundledCodexAcp())
-                : undefined;
-            const argv = Array.isArray(configured)
-                ? [...configured]
-                : typeof configured === 'string'
-                    ? ['sh', '-c', configured]
-                    : resolved.argv;
-            const initialMode = acpAgentMode(role);
-            return {
-                argv,
-                env: initialMode ? { ...prep.env, INITIAL_AGENT_MODE: initialMode } : prep.env,
-                ...(resolved?.permissionMetadataSource
-                    ? { permissionMetadataSource: resolved.permissionMetadataSource } : {}),
             };
         },
-        // INITIAL_AGENT_MODE covers session/new in codex-acp; session/set_mode
-        // keeps resumed/loaded sessions and live status on the identical mode.
-        acpPermissionModeId(role) {
-            return acpAgentMode(role);
-        },
         isolationPaths(role, _dirs) {
             const codexHome = join(home(), '.codex');
             const profile = role.harness_options?.profile;
@@ -508,7 +512,7 @@ export function makeCodexAdapter(exec = realExec) {
 }
 // The adapter needs the state dir for briefing/worklog paths in launch prompts.
 // Roles' state dirs are canonical: agentDir(name) — temp roles carry their dir in cwd handling
-// by the runner, which passes dirs to prepareSession; buildLaunch derives from the same rule.
+// by the runner, which passes dirs to prepareSession.
 function roleStateDir(role) {
     // Temp roles are marked by the runner via a private field to keep the interface small.
     const temp = role.__temp === true;

package/dist/harness/registry.js

@@ -1,5 +1,9 @@
 const adapters = new Map();
 export function registerAdapter(a) {
+    if (typeof a.agentSession?.resolveBrain !== 'function')
+        throw new Error(`harness adapter '${a.id}' must implement agentSession.resolveBrain(): translate neutral model/effort`);
+    if (typeof a.agentSession?.modelEnvironmentVariable !== 'function')
+        throw new Error(`harness adapter '${a.id}' must implement agentSession.modelEnvironmentVariable()`);
     // Enforced here rather than left to the type system: an adapter that silently
     // omits the capability is how the neutral-permission warnings ended up with no
     // caller and no reader.

package/dist/harness/types.d.ts

@@ -1,5 +1,6 @@
 import type { McpServer } from '@agentclientprotocol/sdk';
 import type { CommonPermissions, FleetPermissionMode, ResolvedRole } from '../config.js';
+import type { AgentSessionAdapter } from './agent-session.js';
 export interface PrereqCheck {
     name: string;
     ok: boolean;
@@ -13,27 +14,19 @@ export interface RoleDirs {
     stateDir: string;
     runCwd: string;
 }
-export interface SessionState {
-    sessionId: string;
-}
 /** Extra command/argv/env contributed by prepareSession (overlays, trust, limits). */
 export interface SessionPrep {
-    argv: string[];
     env: Record<string, string>;
-    /** Optional launcher selected after runtime prerequisite probing. */
-    command?: string;
     /**
      * The settings overlay prepareSession wrote, if it wrote one.
      *
-     * The tmux launch delivers this as `--settings <path>` in `argv`; an ACP agent
-     * takes no flags, so it needs the PATH rather than the flag. Recorded here so
-     * the two deliveries read one value instead of each re-deriving the filename.
+     * Claude's ACP agent takes no settings flag, so it needs the path in session
+     * metadata. Record it here rather than re-deriving the filename.
      */
     settingsOverlay?: string;
     /**
      * The MCP config file prepareSession wrote for `harness_options.mcp_servers`,
-     * if the role declared any. Same reason as `settingsOverlay`: the tmux launch
-     * passes the file, the ACP launch has to send the servers themselves.
+     * if the role declared any. The ACP launch sends the parsed servers themselves.
      */
     mcpConfigFile?: string;
 }
@@ -121,6 +114,8 @@ export interface ValidationError {
 }
 export interface HarnessAdapter {
     id: string;
+    /** Harness-specific construction behind Fleet's shared live-session contract. */
+    agentSession: AgentSessionAdapter;
     supportsResume: boolean;
     checkPrereqs(): Promise<PrereqReport>;
     /**
@@ -131,33 +126,6 @@ export interface HarnessAdapter {
      */
     validateOptions(opts: unknown, role?: ResolvedRole): ValidationError[];
     prepareSession(role: ResolvedRole, dirs: RoleDirs): Promise<SessionPrep>;
-    buildLaunch(role: ResolvedRole, mode: 'fresh' | 'resume', s: SessionState, prep: SessionPrep): Launch;
-    buildAcpLaunch?(role: ResolvedRole, prep: SessionPrep): AcpLaunch;
-    /**
-     * The native permission-mode id an ACP session should run at, from the same
-     * translation `buildLaunch` uses for its CLI flag. `undefined` keeps the
-     * agent's default. Omit for a harness whose ACP agent has no modes.
-     */
-    acpPermissionModeId?(role: ResolvedRole): string | undefined;
-    /**
-     * The MCP servers this role declares, for the `mcpServers` array of ACP's
-     * `session/new` / `resume` / `load`. ACP requires an array on the wire, so
-     * `undefined` is encoded as `[]` while the authenticated bundled adapter is
-     * left to preserve its inherited configuration. An explicit empty array uses
-     * that adapter's compatibility path to disable all inherited servers.
-     */
-    acpMcpServers?(role: ResolvedRole): AcpMcpServer[] | undefined;
-    /**
-     * Agent-specific `_meta` for `session/new` — how a capability the CLI takes as
-     * a flag reaches an ACP agent that accepts no flags.
-     *
-     * ⚠ THIS IS A PER-AGENT VOCABULARY, NOT PROTOCOL. `_meta` is free-form in ACP,
-     * so what an adapter puts here is only honoured by the agent it was written
-     * for. An adapter must therefore return nothing for an ACP command it did not
-     * choose, and the options that depend on it must be refused at validation for
-     * such a role rather than sent and silently ignored.
-     */
-    acpSessionMeta?(role: ResolvedRole, prep: SessionPrep): Record<string, unknown> | undefined;
     /** Effective portable policy and harness-native approval mode after native overrides win. */
     effectivePermissionMode?(role: ResolvedRole): {
         fleetMode: FleetPermissionMode;

package/dist/index.d.ts

@@ -1,11 +1,10 @@
 export { loadConfig, findRole, resolvePermissions, ConfigError } from './config.js';
 export type { FleetConfig, ResolvedRole, RoleConfig, OverseeEntry, SessionBackendId, CommonPermissions, FleetPermissionMode, ApprovalMode, SessionOptions, OwnerChannelConfig, } from './config.js';
-export type { HarnessAdapter, BriefingVocab, ExitPolicy, PrereqReport, PrereqCheck, SessionPrep, SessionState, Launch, AcpLaunch, PermissionTranslation, RoleDirs, ValidationError, } from './harness/types.js';
-export type { SessionHandle, SessionSnapshot, SessionEvent, TurnResult, InterruptOutcome, InterruptResult, TurnCancellationSource, QueuedPrompt, ExitRecord, } from './session/types.js';
+export type { HarnessAdapter, BriefingVocab, ExitPolicy, PrereqReport, PrereqCheck, SessionPrep, Launch, AcpLaunch, PermissionTranslation, RoleDirs, ValidationError, } from './harness/types.js';
+export type { AgentSession, SessionHandle, SessionSnapshot, SessionEvent, TurnResult, InterruptOutcome, InterruptResult, TurnCancellationSource, QueuedPrompt, ExitRecord, } from './session/types.js';
 export { interruptOutcome } from './session/types.js';
 export { AcpSession } from './session/acp.js';
 export { OwnerChannel } from './owner-channel/channel.js';
-export { TmuxSession } from './session/tmux.js';
 export { registerAdapter, getAdapter, knownAdapters } from './harness/registry.js';
 export { claudeCodeAdapter, makeClaudeCodeAdapter } from './harness/claude-code.js';
 export { codexAdapter, makeCodexAdapter } from './harness/codex.js';
@@ -17,7 +16,7 @@ export { up, down, restartRoles, rmRole, applyRole } from './ops.js';
 export { spawnPermanent, spawnTemp, buildRoleConfig, profileValues, validateSpawnOpts, } from './spawn.js';
 export { RoleRepository } from './application/role-repository.js';
 export { FleetQueryService } from './application/fleet-query-service.js';
-export { AcpRoleSessionAdapter, TmuxRoleSessionAdapter } from './application/session-control.js';
+export { AcpRoleSessionAdapter } from './application/session-control.js';
 export { RoleCreationService } from './application/role-creation-service.js';
 export { RoleCommandService, RoleLifecycleService } from './application/role-command-service.js';
 export { StructuredLogService } from './application/log-service.js';
@@ -26,5 +25,4 @@ export { FleetError, normalizeError } from './application/errors.js';
 export type * from './application/types.js';
 export { doctor } from './doctor.js';
 export { runOnce, runTemp } from './runner.js';
-export { Tmux } from './tmux.js';
 export { VERSION } from './version.js';

package/dist/index.js

@@ -2,7 +2,6 @@ export { loadConfig, findRole, resolvePermissions, ConfigError } from './config.
 export { interruptOutcome } from './session/types.js';
 export { AcpSession } from './session/acp.js';
 export { OwnerChannel } from './owner-channel/channel.js';
-export { TmuxSession } from './session/tmux.js';
 export { registerAdapter, getAdapter, knownAdapters } from './harness/registry.js';
 export { claudeCodeAdapter, makeClaudeCodeAdapter } from './harness/claude-code.js';
 export { codexAdapter, makeCodexAdapter } from './harness/codex.js';
@@ -13,7 +12,7 @@ export { up, down, restartRoles, rmRole, applyRole } from './ops.js';
 export { spawnPermanent, spawnTemp, buildRoleConfig, profileValues, validateSpawnOpts, } from './spawn.js';
 export { RoleRepository } from './application/role-repository.js';
 export { FleetQueryService } from './application/fleet-query-service.js';
-export { AcpRoleSessionAdapter, TmuxRoleSessionAdapter } from './application/session-control.js';
+export { AcpRoleSessionAdapter } from './application/session-control.js';
 export { RoleCreationService } from './application/role-creation-service.js';
 export { RoleCommandService, RoleLifecycleService } from './application/role-command-service.js';
 export { StructuredLogService } from './application/log-service.js';
@@ -21,5 +20,4 @@ export { roleCapabilities } from './application/capabilities.js';
 export { FleetError, normalizeError } from './application/errors.js';
 export { doctor } from './doctor.js';
 export { runOnce, runTemp } from './runner.js';
-export { Tmux } from './tmux.js';
 export { VERSION } from './version.js';