@ours.network/fleet 1.0.4 → 1.1.0-nightly.1

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,32 @@ 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({
+            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 +329,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 +345,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 +449,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,18 @@
+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 {
+    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);
+    prepareLaunch(role: ResolvedRole, prep: SessionPrep): PreparedAgentSessionLaunch;
+    start(options: AgentSessionStartOptions): Promise<import("../index.js").AgentSession>;
+}

package/dist/harness/codex-session.js

@@ -0,0 +1,28 @@
+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;
+    }
+    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,23 @@ function hasInstalledOursPlugin(output) {
         return false;
     }
 }
-export function makeCodexAdapter(exec = realExec) {
+export function makeCodexAdapter(exec = realExec, transport) {
     return {
         id: 'codex',
+        agentSession: new CodexAgentSessionAdapter({
+            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 +347,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 +498,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/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';

package/dist/isolation/resources.d.ts

@@ -4,13 +4,9 @@ export interface ResourceArgs {
     warnings: string[];
 }
 /**
- * Build the `systemd-run --user --scope -p … --` prefix that caps the pane's
- * cgroup-v2 scope. Composed OUTSIDE the sandbox wrap: a tmux pane is
- * a child of a tmux SERVER rather than of the role's own runner process, so the
- * only reliable per-agent limit is a transient scope at the pane itself. (Since
- * #32 that server is per role rather than fleet-wide, which is what keeps one
- * role's `stop` off every other role's pane — the limit still belongs on the
- * pane.)
+ * Build the `systemd-run --user --scope -p … --` prefix that caps the agent
+ * process's cgroup-v2 scope. It composes outside the sandbox wrapper so both
+ * the adapter and its sandboxed child remain inside the transient scope.
  *
  * mem/pids are always enforced (their controllers are delegated to `--user` by
  * default). cpu degrades to a warning when the cpu controller is not delegated.

package/dist/isolation/resources.js

@@ -1,12 +1,8 @@
 import { readFileSync } from 'node:fs';
 /**
- * Build the `systemd-run --user --scope -p … --` prefix that caps the pane's
- * cgroup-v2 scope. Composed OUTSIDE the sandbox wrap: a tmux pane is
- * a child of a tmux SERVER rather than of the role's own runner process, so the
- * only reliable per-agent limit is a transient scope at the pane itself. (Since
- * #32 that server is per role rather than fleet-wide, which is what keeps one
- * role's `stop` off every other role's pane — the limit still belongs on the
- * pane.)
+ * Build the `systemd-run --user --scope -p … --` prefix that caps the agent
+ * process's cgroup-v2 scope. It composes outside the sandbox wrapper so both
+ * the adapter and its sandboxed child remain inside the transient scope.
  *
  * mem/pids are always enforced (their controllers are delegated to `--user` by
  * default). cpu degrades to a warning when the cpu controller is not delegated.

package/dist/model-env.d.ts

@@ -3,9 +3,8 @@ import type { ResolvedRole } from './config.js';
  * Which environment variable a harness reads to pin the model it RUNS.
  *
  * This is not a convenience: for `claude-code` it is the only channel that
- * reaches the ACP backend at all. `buildLaunch` (tmux) passes `--model`, but
- * `buildAcpLaunch` launches the ACP adapter with no model argument, and that
- * adapter resolves its model in this order — ANTHROPIC_MODEL, then
+ * reaches the Claude Code ACP adapter. The adapter resolves its model in this
+ * order — ANTHROPIC_MODEL, then
  * `settings.model`, then a resumed session's live model, then its first
  * catalogue entry. A role's declared model was therefore invisible to every
  * ACP role, and a fleet-wide `defaults.env.ANTHROPIC_MODEL` silently outranked

package/dist/model-env.js

@@ -2,9 +2,8 @@
  * Which environment variable a harness reads to pin the model it RUNS.
  *
  * This is not a convenience: for `claude-code` it is the only channel that
- * reaches the ACP backend at all. `buildLaunch` (tmux) passes `--model`, but
- * `buildAcpLaunch` launches the ACP adapter with no model argument, and that
- * adapter resolves its model in this order — ANTHROPIC_MODEL, then
+ * reaches the Claude Code ACP adapter. The adapter resolves its model in this
+ * order — ANTHROPIC_MODEL, then
  * `settings.model`, then a resumed session's live model, then its first
  * catalogue entry. A role's declared model was therefore invisible to every
  * ACP role, and a fleet-wide `defaults.env.ANTHROPIC_MODEL` silently outranked

package/dist/monitor.d.ts

@@ -26,15 +26,8 @@ export type FetchLike = (url: string, init?: {
     headers?: Record<string, string>;
     signal?: AbortSignal;
 }) => Promise<FetchResponse>;
-export interface MonitorTmux {
-    has(name: string): Promise<boolean>;
-    capture(name: string, lines?: number): Promise<string>;
-    sendText(name: string, text: string): Promise<void>;
-    sendKey(name: string, key: string): Promise<void>;
-}
 export interface MonitorDeps {
     fetch: FetchLike;
-    tmux: MonitorTmux;
     isAlive(pid: number): boolean;
     sleep(ms: number): Promise<void>;
     now(): number;
@@ -45,7 +38,7 @@ export interface MonitorDeps {
         clear(t: ReturnType<typeof setTimeout>): void;
     };
     /**
-     * Structured prompt delivery used by ACP sessions. Tmux remains the fallback.
+     * Structured prompt delivery used by agent sessions.
      * `succeeded` is the turn's TERMINAL result, not merely that the session took
      * the prompt: a refused or cancelled wake was seen and not acted on, and must
      * not commit the cursor.
@@ -208,14 +201,6 @@ export declare class Monitor {
     /** Gather stragglers arriving within batch_ms so a burst lands as one line. */
     private coalesce;
     private deliver;
-    /**
-     * Watch the pane until the just-triggered turn settles, then fold its outcome
-     * into the API-error streak and republish `.monitor-status`. A completed turn
-     * (or an inconclusive give-up) resets/keeps the streak; an `API Error:` tail
-     * grows it. Once the streak reaches the threshold the status degrades; a later
-     * completed turn flips it back to armed. Detection only — no remediation (#19).
-     */
-    private observeTurnOutcome;
     /** Update the consecutive-API-error streak and derive `.monitor-status` from it. */
     private recordTurn;
     /**
@@ -226,14 +211,6 @@ export declare class Monitor {
      * the composer is cleared by hand. Best-effort: a dead pane just makes the keys
      * no-ops (delivery is still verified downstream).
      */
-    private clearComposer;
-    /**
-     * Block until the console can accept input; classify offline/stopped/ready, or
-     * `modal` when the pane still looks modal after `MODAL_GIVE_UP_MS`. The bound is
-     * what keeps a modal from wedging delivery silently: we still never `Enter` into
-     * the dialog, but the give-up is reported instead of retried forever.
-     */
-    private awaitInjectable;
     private doFetch;
     private advance;
     private persistCursor;