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

package/README.md

@@ -8,8 +8,8 @@ harnesses — from one declarative file.**
 An AI coding agent in a terminal dies when you close the laptop. `ours-fleet`
 turns such sessions into **roles**: long-lived agents that
 
-- **run through a selectable session backend** — existing detached tmux consoles
-  or structured ACP sessions — which you can attach to, peek at, or prompt,
+- **run through structured ACP sessions** behind a shared Codex/Claude Code
+  agent-session interface, which you can inspect or prompt,
 - are **supervised** — systemd (Linux) or launchd (macOS) restarts them on crash
   and brings them back after a reboot,
 - **resume their context** across restarts (when the harness supports it),
@@ -44,8 +44,7 @@ roles:
 ~/fleet.yaml + ~/fleet.d/*.yaml           your declaration
         │  ours-fleet up
         ▼
-briefing.md per role  ──►  tmux session  ──►  harness CLI (claude …)
-                       └─►  ACP client   ──►  ACP agent (codex-acp …)
+briefing.md per role  ──►  agent session adapter  ──►  ACP client/session  ──►  ACP agent
         ▲                        │
  systemd --user / launchd ───────┘   restart on crash, start at boot/login
 ```
@@ -78,7 +77,6 @@ The state dir contract:
 | What | Why | Install |
 |---|---|---|
 | Node ≥ 20 | runs `ours-fleet` itself | nodejs.org, `apt`, or `brew` |
-| tmux | roles using `session: tmux` (the default) | `apt install tmux` / `brew install tmux` |
 | Node ≥ 22 | Claude roles using `session: acp` | required by the maintained Claude ACP adapter |
 | a harness CLI, logged in | the agent itself | e.g. Claude Code (`claude`) or Codex CLI (`codex`) |
 | `ours` CLI + shared daemon | identity + agent-to-agent messaging | `npm i -g @ours.network/cli && ours daemon start` |
@@ -98,8 +96,8 @@ ours-fleet doctor    # verifies everything above, with actionable messages
 The maintained Codex and Claude ACP adapters install as optional dependencies of
 `ours-fleet` and are resolved internally; users do not install adapter commands
 or add them to `PATH`. An explicit `session_options.acp.command` remains
-available for custom adapters. On Node 20–21, tmux and Codex ACP remain
-available, while maintained Claude ACP requires upgrading to Node 22.
+available for custom adapters. On Node 20–21, Codex ACP remains available,
+while maintained Claude ACP requires upgrading to Node 22.
 
 Each OS user manages their own fleet — to host roles under a sandboxed account,
 become that account and repeat.
@@ -139,8 +137,8 @@ fleet monitor policy, and same-harness model inherit from the caller. Explicit
 flags win; changing harness without a model lets the selected harness/fleet
 defaults choose one. After creation succeeds, fleet can deterministically notify
 the caller's owner channel with the caller and spawned-role details. This is an
-honest-actor convenience and attribution path, not a security boundary; tmux,
-host shells, and deliberately bypassed absolute binaries retain direct behavior.
+honest-actor convenience and attribution path, not a security boundary; host
+shells and deliberately bypassed absolute binaries retain direct behavior.
 
 ## Local web console
 
@@ -209,8 +207,8 @@ offline shell and no stale fleet state.
 
 The console provides evidence-separated inventory and status, ACP activity and
 permission controls, redacted logs, typed text send, confirmed lifecycle
-actions, transactional permanent/temporary creation, and a shared tmux browser
-terminal. Identity is fixed to the role name. Creation uses the authenticated
+actions, and transactional permanent/temporary creation. Identity is fixed to
+the role name. Creation uses the authenticated
 daemon inventory and reports verified, missing, or unknown evidence. A missing
 permanent role identity is created deterministically before launch with local
 discovery and auto-accept enabled, then the provisioning lease is released so
@@ -243,19 +241,16 @@ never force-adopts or deletes identity state. Permanent roles are
 provisioned by fleet before launch and never delegate normal identity creation
 to the harness.
 
-`node-pty` is optional: if its native module cannot load, ACP and all
-non-terminal features remain available and tmux Terminal is disabled with a
-diagnostic.
+The web console uses structured ACP activity rather than exposing a raw agent terminal.
 
 Security boundaries:
 
 - configured `Host` and `Origin`, CSRF, one-time WebSocket tickets, and explicit
   bind/origin policy are enforced server-side;
 - cwd values must resolve beneath configured local roots;
-- terminal bytes are intentionally unredacted and are never copied into audit
-  records; normal logs are bounded and redacted;
-- tests use temporary fleet homes, fake supervisors/identity providers, and
-  isolated tmux sockets—never active role state.
+- normal logs are bounded and redacted;
+- tests use temporary fleet homes and fake supervisors/identity providers—never
+  active role state.
 
 Permanent spawns are written to `~/fleet.d/<Name>.yaml`; the CLI never edits your
 hand-written `~/fleet.yaml`. `ours-fleet rm <Name>` unspawns.
@@ -292,7 +287,6 @@ them and unsticks them:
 
 ```sh
 ours-fleet peek Worker          # what is it doing?
-ours-fleet send Worker --key 1  # answer the menu it's stuck on
 ours-fleet send Worker "continue with the tests, then report"
 ```
 
@@ -315,7 +309,7 @@ ours-fleet docs | man                 AI-friendly complete reference
 ours-fleet up|down|restart|force-restart [-c FILE] [Name...]
 ours-fleet config [-c FILE]         validate + print merged plan
 ours-fleet ls | attach | peek | logs [-f] | status <Name>
-ours-fleet send <Name> "text" | --key <K>
+ours-fleet send <Name> "text"
 ours-fleet spawn [--temp] [<Name> | --role <Name>] [--harness --session --mission --model --approval ...]
 ours-fleet loops validate|list|status
 ours-fleet loops reload <Role>
@@ -355,7 +349,7 @@ vars: { work_root: /home/me/work }      # ${var} substitution anywhere below
 start_stagger_ms: 0                     # delay between agent LAUNCHES (host-wide, ms); 0 = no stagger
 defaults:
   harness: claude-code                  # for roles that don't set one
-  session: tmux                         # tmux (default) | acp
+  session: acp                          # supported Fleet↔agent session path
   permissions:                         # common intent, translated by each harness/backend
     approval: ask                       # ask | auto | allow (`deny` is a deprecated alias)
     filesystem: workspace               # read-only | workspace | unrestricted
@@ -371,7 +365,7 @@ defaults:
 roles:
   Name:                                 # [A-Za-z0-9_-]+
     harness: claude-code
-    session: acp                         # one flag selects ACP; omit for tmux
+    session: acp                         # optional; ACP is the only supported session
     session_options:
       acp:
         command: claude-agent-acp        # optional advanced override
@@ -400,7 +394,6 @@ roles:
         max_file_bytes: 10485760         # 10 MiB
         max_request_bytes: 20971520      # 20 MiB total, and >= max_file_bytes
         retention_ms: 86400000           # stale crash cleanup; 1 minute..30 days
-        allowed_mime: [application/pdf, text/plain, image/png, audio/ogg]
     model: claude-fable-5               # launch on a specific model (pass-through id; default: launcher default)
     mission: one line
     persona: |                          # operating contract (published as persona)
@@ -447,15 +440,14 @@ loops:                                    # trusted local scheduled ACP turns
 
 Merge order: `fleet.yaml` ← `fleet.d/*.yaml`; a duplicate role name is a hard
 error naming both files. Identities and roles are decoupled — removing a role
-never deletes an identity. `session` is independent of `harness`, so changing a
-role from tmux to ACP does not change its identity, mission, monitor, or permission
-contract. `defaults.harness_options` is shallow-merged with each
+never deletes an identity. `session` is ACP-backed for both supported harnesses.
+`defaults.harness_options` is shallow-merged with each
 role's `harness_options`, so a fleet can set common Codex permission/profile defaults
 and override individual keys per role. `monitor` merges the same way — a role block
 overrides `defaults.monitor` key-by-key.
 
 Every supervised role is a client of the operator-configured ours daemon. Fleet strips the
-obsolete, presence-sensitive `OURS_AUTOSTART` variable from both tmux and ACP harness
+obsolete, presence-sensitive `OURS_AUTOSTART` variable from ACP harness
 processes. `ours-mcp proxy` is client-only and never starts a daemon; operators and explicit
 installer/setup flows remain responsible for starting it.
 
@@ -598,9 +590,7 @@ since a human can still attach a console and answer.
 `auto` selects Codex ACP `agent` (`on-request` + `workspace-write`) / Claude
 `acceptEdits`. `allow` selects Codex ACP's fully non-interactive yolo mode,
 reported by the adapter as `agent-full-access` (`never` +
-`danger-full-access`); Claude uses `bypassPermissions`. For Codex tmux, where the
-approval and sandbox flags remain independent, `auto` is `on-request` and
-`allow` is `never` while `filesystem` still chooses the sandbox.
+`danger-full-access`); Claude uses `bypassPermissions`.
 `dontAsk` suppresses only the *prompt*, not the denial, which is why an
 `allow` role previously ran unable to do its job. Legacy `deny` is accepted
 only for compatibility and retains its conservative Codex `on-request` /
@@ -690,8 +680,8 @@ their boots ~4 s apart instead of firing all seven at once.
 With `monitor.mode: fleet` (the default), the **ours-fleet supervisor** delivers
 a role's mail wakes: the per-role runner long-polls the ours daemon's notification API and
 submits a single `[fleet-monitor] N new messages from … — run get_messages` prompt
-through the selected backend. ACP uses live steering when its adapter supports it
-and falls back to structured `session/prompt`; tmux uses verified console input.
+through the shared agent session. ACP uses live steering when its adapter supports it
+and falls back to structured `session/prompt`.
 Set `monitor.interrupt: true` on roles where every configured wake should cancel
 the active turn before the notification is delivered. This is intentionally
 content-blind: the supervisor cannot inspect encrypted message bodies, so all
@@ -701,8 +691,7 @@ tool result or pending permission. Fleet waits for terminal ACP tool/update
 evidence, then steers the wake without calling `session.cancel`. If the tool is
 still active after 120 seconds, or the adapter cannot expose authenticated tool
 boundaries/steering, fleet visibly degrades to non-cancelling steering or queued
-delivery. Tmux never receives `C-c` for `after_tool`. Explicit human and control
-interrupts remain immediate.
+delivery. Explicit human and control interrupts remain immediate.
 The default is `false`: a role that must begin a post-readiness mission
 immediately, including second-and-later mail received while it is working, must
 set `monitor.mode: fleet` and `monitor.interrupt: true` explicitly. Readiness and
@@ -795,8 +784,8 @@ invites, message bodies, credentials, or keys. A corrupt overlay fails closed
 (no effective owners and no mutation), and the last effective owner cannot be
 revoked.
 
-These commands require a running ACP role with `owner_channel` enabled. Missing,
-stopped, tmux, disabled, draining, and unavailable-MCP targets fail without
+These commands require a running role with `owner_channel` enabled. Missing,
+stopped, disabled, draining, and unavailable-MCP targets fail without
 starting a second client, binding an identity, or opening a network listener.
 
 The managed agent can use its ordinary ours `send_message` or `send_file` tool to
@@ -967,20 +956,25 @@ message plaintext in fleet state.
 Inbound owner attachments use the same authenticated-CID and exact-wire routing
 boundary. Fleet first calls the metadata-only `listIncomingFiles`, groups a
 file-only wake or a same-sender reply-linked text caption, and checks the enabled,
-count, declared MIME, per-file size, and total-size policy before retrieving any
-bytes. It then calls selective `getFiles` only for the admitted wire IDs. An
+count, per-file size, and total-size policy before retrieving any bytes. MIME values,
+extensions, file categories, and declared-versus-detected mismatches are metadata,
+never rejection criteria. It then calls selective `getFiles` only for the admitted wire IDs. An
 unauthorized sender is ignored without retrieval or reply. A rejected authorized
 request receives a bounded reason correlated to its file wire.
 
 Retrieved files must be regular, non-symlink paths whose byte count and SHA-256
-match typed SDK metadata. Fleet additionally checks content signatures against the
-declared MIME, sanitizes traversal/control characters from names, and copies each
+match typed SDK metadata. Fleet detects recognizable content only to report metadata,
+sanitizes traversal/control characters from names, and copies each
 file into a random request-scoped directory at mode 0700 with files at mode 0600.
 The `[fleet-owner]` turn receives only bounded metadata, the private local paths,
 and an explicit daemon transcription result for voice messages. Successful
 transcripts are included; `failed` and `unavailable` states are stated plainly so
 the agent must use the audio path rather than inventing text.
 
+The legacy `attachments.allowed_mime` key is accepted and ignored so existing
+configurations continue to load. It is omitted from resolved configuration and
+cannot affect attachment admission.
+
 Request files are removed after final delivery and stale directories are removed
 after `retention_ms`. A bounded mode-0600 recovery journal stores only owner CID
 and wire routing metadata—never filenames, paths, captions, transcripts, or file
@@ -1002,20 +996,17 @@ Managed-agent file egress is a separate trust direction. It retains the same
 metadata provenance checks, count/per-file/request byte caps, regular-file and
 no-symlink reads, actual byte-count/SHA-256 verification, filename sanitization,
 private staging, fixed owner routing, and bounded body-free recovery metadata.
-It deliberately does not consult `attachments.enabled` or `allowed_mime`; MIME is
+It deliberately does not consult `attachments.enabled`; MIME is
 still detected during byte validation, but a declared-versus-detected mismatch is
-not an egress deny gate. Markdown, HTML, octet-stream, unknown extensions, and normal
-binaries are therefore routable only from the exact configured `agent` CID.
-Owner-to-agent admission above remains byte-for-byte strict. Each outbound file
+not a deny gate in either direction. Markdown, HTML, octet-stream, unknown extensions,
+and normal binaries are therefore routable only across their authenticated direction.
+Each outbound file
 gets a durable pre-send marker: a failed/ambiguous send becomes `uncertain` and is
 not blindly retried, while files not yet attempted remain recoverable after restart.
 Logs contain counts and byte totals, never filenames or raw bytes.
 
-Owner channels currently require `session: acp`. Fleet needs structured,
-turn-correlated assistant output for automatic replies; scraping a tmux pane
-cannot reliably distinguish the final answer from thoughts, tool output, or
-unrelated concurrent work. The config rejects tmux instead of silently offering
-weaker semantics.
+Owner channels use the structured agent-session interface for turn-correlated
+assistant output and reliable automatic replies.
 
 ## Codex roles
 
@@ -1079,7 +1070,7 @@ role-specific ours daemon, or configure the host default in `~/.ours/config.json
 
 Each role can be sandboxed at the environment level via an `isolation:` block —
 **fully additive: a role with no block behaves exactly as before.** The agent's
-tmux-pane process is wrapped in [bubblewrap](https://github.com/containers/bubblewrap)
+agent process is wrapped in [bubblewrap](https://github.com/containers/bubblewrap)
 (rootless, no setuid), resource-limited by `systemd-run --user --scope`.
 
 An empty `isolation: {}` gives a sensible default posture: filesystem-confined to

package/dist/application/capabilities.d.ts

@@ -1,6 +1,5 @@
 import type { RoleRecord, RoleCapabilities, RoleStatus } from './types.js';
 export interface CapabilityContext {
-    terminalPtyAvailable?: boolean;
     controlProtocolVersion?: number;
 }
 export declare function roleCapabilities(role: RoleRecord, status: RoleStatus, context?: CapabilityContext): RoleCapabilities;

package/dist/application/capabilities.js

@@ -1,30 +1,20 @@
 export function roleCapabilities(role, status, context = {}) {
-    const backend = role.configuredBackend ?? (role.detectedBackend === 'acp' || role.detectedBackend === 'tmux' ? role.detectedBackend : undefined);
+    const backend = role.configuredBackend ?? (role.detectedBackend === 'acp' ? 'acp' : undefined);
     const online = status.session.reachability === 'online';
     const acp = backend === 'acp';
-    const tmux = backend === 'tmux';
     const protocolVersion = context.controlProtocolVersion ?? 1;
     const inactive = status.overall === 'offline'
         || (!online && status.supervisor.liveness === 'stopped');
-    const terminalAvailable = tmux && online && context.terminalPtyAvailable === true;
-    const terminalReason = terminalAvailable ? undefined
-        : !tmux ? 'wrong_backend'
-            : !online ? 'offline'
-                : 'pty_unavailable';
     return {
         protocolVersion,
         inventory: true,
         status: true,
         output: {
-            recent: acp || tmux, stream: (acp && protocolVersion >= 2) || terminalAvailable,
+            recent: acp, stream: acp && protocolVersion >= 2,
             structured: acp, replayCursor: acp && protocolVersion >= 2,
         },
-        input: { text: online && (acp || tmux), rawKeys: terminalAvailable, interrupt: online && acp, steering: false },
+        input: { text: online && acp, interrupt: online && acp, steering: false },
         permissions: { observe: acp, respond: acp && online },
-        terminal: {
-            available: terminalAvailable, reason: terminalReason,
-            multiViewer: terminalAvailable, writerLease: terminalAvailable,
-        },
         lifecycle: {
             start: role.lifetime === 'permanent' && status.supervisor.liveness !== 'running',
             stop: role.lifetime === 'permanent' && !inactive && status.supervisor.liveness !== 'stopped',

package/dist/application/errors.d.ts

@@ -1,4 +1,4 @@
-export type FleetErrorCode = 'role_not_found' | 'capability_unavailable' | 'invalid_request' | 'offline' | 'control_unavailable' | 'timeout' | 'rejected' | 'backend_failure' | 'conflict' | 'stale_state' | 'prerequisite_unavailable' | 'idempotency_conflict' | 'rollback_incomplete' | 'launched_unconfirmed' | 'unauthorized' | 'forbidden' | 'rate_limited' | 'incompatible_version' | 'internal';
+export type FleetErrorCode = 'role_not_found' | 'resource_not_found' | 'capability_unavailable' | 'invalid_request' | 'offline' | 'control_unavailable' | 'timeout' | 'rejected' | 'backend_failure' | 'conflict' | 'stale_state' | 'prerequisite_unavailable' | 'idempotency_conflict' | 'rollback_incomplete' | 'launched_unconfirmed' | 'unauthorized' | 'forbidden' | 'rate_limited' | 'incompatible_version' | 'internal';
 export interface FleetErrorShape {
     code: FleetErrorCode;
     message: string;

package/dist/application/fleet-query-service.d.ts

@@ -1,13 +1,11 @@
 import type { SupervisorBackend } from '../supervisor/types.js';
 import { controlRequest } from '../session/control.js';
-import { Tmux } from '../tmux.js';
 import { type CapabilityContext } from './capabilities.js';
 import { RoleRepository } from './role-repository.js';
 import type { RoleCapabilities, RoleRecord, RoleStatus } from './types.js';
 export interface FleetQueryOptions {
     repository: RoleRepository;
     supervisor: SupervisorBackend;
-    tmux?: Tmux;
     control?: typeof controlRequest;
     capabilityContext?: CapabilityContext;
     /**
@@ -24,7 +22,6 @@ export interface FleetQueryOptions {
 }
 export declare class FleetQueryService {
     private readonly options;
-    private readonly tmux;
     private readonly control;
     constructor(options: FleetQueryOptions);
     list(): Promise<Array<{

package/dist/application/fleet-query-service.js

@@ -4,7 +4,6 @@ import { classifyActivity } from '../session/activity.js';
 import { controlRequest } from '../session/control.js';
 import { SessionControlError } from '../session/types.js';
 import { readExitRecord, readRestartLedger } from '../runner.js';
-import { Tmux } from '../tmux.js';
 import { roleCapabilities } from './capabilities.js';
 import { FleetError } from './errors.js';
 const clean = (value, max = 512) => value.replace(/[\0-\x08\x0b\x0c\x0e-\x1f\x7f]/g, '').trim().slice(0, max);
@@ -50,7 +49,7 @@ function sessionOverall(supervisor, session, restart, monitor, isolation, proble
         || problems.some(problem => problem.severity === 'error' || problem.source === 'watchdog')
         || session.readiness === 'failed')
         return 'attention';
-    // A reachable ACP/tmux session is the user's live interaction surface. Its
+    // A reachable agent session is the user's live interaction surface. Its
     // evidence remains authoritative even when a service manager no longer owns
     // the process (for example, a detached ACP session with an inactive unit).
     if (session.reachability === 'online'
@@ -69,11 +68,9 @@ function sessionOverall(supervisor, session, restart, monitor, isolation, proble
 }
 export class FleetQueryService {
     options;
-    tmux;
     control;
     constructor(options) {
         this.options = options;
-        this.tmux = options.tmux ?? new Tmux();
         this.control = options.control ?? controlRequest;
     }
     async list() {
@@ -174,26 +171,6 @@ export class FleetQueryService {
                 };
             }
         }
-        if (intended === 'tmux' || role.detectedBackend === 'tmux') {
-            try {
-                const has = await this.tmux.has(role.id);
-                return {
-                    backend: 'tmux', reachability: has ? 'online' : supervisor === 'stopped' ? 'offline' : 'unknown',
-                    readiness: has ? 'idle' : supervisor === 'running' ? 'starting' : 'failed',
-                    evidence: 'inferred',
-                    // tmux exposes no agent-side evidence at all, and `readiness: idle`
-                    // here is a pane-liveness inference, not an activity claim.
-                    activity: { state: 'unobservable' },
-                };
-            }
-            catch (error) {
-                return {
-                    backend: 'tmux', reachability: 'unknown', readiness: 'unknown',
-                    evidence: 'inferred', lastError: clean(error.message),
-                    activity: { state: 'unobservable' },
-                };
-            }
-        }
         return {
             backend: 'unknown', reachability: supervisor === 'stopped' ? 'offline' : 'unknown',
             readiness: supervisor === 'stopped' ? 'failed' : 'unknown', evidence: 'inferred',

package/dist/application/role-creation-service.d.ts

@@ -12,7 +12,7 @@ export interface CreateRoleSessionRequest {
     /** null means the selected harness's own default; web blank fields send null. */
     model?: string | null;
     reasoningEffort?: string | null;
-    session: 'acp' | 'tmux';
+    session: 'acp';
     cwd?: string;
     lifetime: 'permanent' | 'temporary';
     mission?: string;
@@ -41,7 +41,7 @@ export interface CreationCapabilities {
     harnesses: Array<{
         id: 'codex' | 'claude-code';
         available: boolean;
-        sessions: Array<'acp' | 'tmux'>;
+        sessions: Array<'acp'>;
         defaultModel?: string;
         models: string[];
         modelOptions: HarnessModelOption[];
@@ -71,7 +71,7 @@ export interface CreationPreview {
         name: string;
         identity: string;
         harness: string;
-        session: 'acp' | 'tmux';
+        session: 'acp';
         model?: string;
         reasoningEffort?: string;
         cwd?: string;
@@ -95,7 +95,7 @@ export interface CreationAction {
     actionId: string;
     requestHash: string;
     roleId: string;
-    session: 'acp' | 'tmux';
+    session: 'acp';
     lifetime: 'permanent' | 'temporary';
     state: CreationStage;
     stages: Array<{
@@ -121,7 +121,7 @@ export interface RoleCreationServiceOptions {
     tempLauncher?: SupervisorLauncher;
     allowedCwdRoots?: string[];
     journalDir?: string;
-    probeReady?: (name: string, session: 'acp' | 'tmux') => Promise<'ready' | 'attention' | 'unknown'>;
+    probeReady?: (name: string, session: 'acp') => Promise<'ready' | 'attention' | 'unknown'>;
     onProgress?: (action: CreationAction) => void;
     modelCatalogs?: Partial<Record<'codex' | 'claude-code', () => HarnessModelCatalog>>;
     /** Direct/managed callers must not create or restore the web action journal. */

package/dist/application/role-creation-service.js

@@ -109,13 +109,13 @@ export class RoleCreationService {
             reasons,
             harnesses: [
                 {
-                    id: 'codex', available: true, sessions: ['acp', 'tmux'],
+                    id: 'codex', available: true, sessions: ['acp'],
                     defaultModel: resolveRoleModel(undefined, 'codex', defaults),
                     ...codexModels, catalogSource: 'codex-runtime-catalog', customModelAllowed: true,
                     warnings: codexCatalog.warnings,
                 },
                 {
-                    id: 'claude-code', available: true, sessions: ['acp', 'tmux'],
+                    id: 'claude-code', available: true, sessions: ['acp'],
                     defaultModel: resolveRoleModel(undefined, 'claude-code', defaults),
                     ...claudeModels, catalogSource: 'claude-adapter-2.1', customModelAllowed: true,
                     warnings: claudeCatalog.warnings,
@@ -149,7 +149,7 @@ export class RoleCreationService {
         const effective = {
             name: request.name, identity: request.name,
             harness: request.harness ?? defaults.harness ?? 'claude-code',
-            session: request.session ?? defaults.session ?? 'tmux',
+            session: request.session ?? defaults.session ?? 'acp',
             model: resolveRoleModel(request.model, request.harness, defaults),
             reasoningEffort: request.reasoningEffort ?? undefined,
             cwd, lifetime: request.lifetime,
@@ -264,9 +264,7 @@ export class RoleCreationService {
             this.stage(action, 'waiting_for_session');
             const ready = await this.waitForReady(action.roleId, action.session);
             if (ready === 'ready') {
-                action.openPath = action.session === 'acp'
-                    ? `/roles/${encodeURIComponent(action.roleId)}/activity`
-                    : `/roles/${encodeURIComponent(action.roleId)}/terminal`;
+                action.openPath = `/roles/${encodeURIComponent(action.roleId)}/activity`;
                 this.stage(action, 'session_reachable', 'session is reachable; identity binding has no structured evidence in this version');
             }
             else if (ready === 'attention') {
@@ -311,7 +309,7 @@ export class RoleCreationService {
             throw new FleetError('invalid_request', 'invalid role name');
         if (!['codex', 'claude-code'].includes(input.harness))
             throw new FleetError('invalid_request', 'unsupported harness');
-        if (!['acp', 'tmux'].includes(input.session))
+        if (input.session !== 'acp')
             throw new FleetError('invalid_request', 'unsupported session backend');
         if (!['permanent', 'temporary'].includes(input.lifetime))
             throw new FleetError('invalid_request', 'unsupported lifetime');

package/dist/application/role-repository.d.ts

@@ -3,9 +3,8 @@ export interface RoleRepositoryOptions {
     configPath?: string;
     permanentRoot?: string;
     temporaryRoot?: string;
-    probeBackend?: (name: string, intended?: 'acp' | 'tmux') => Promise<{
+    probeBackend?: (name: string, intended?: 'acp') => Promise<{
         acp: boolean;
-        tmux: boolean;
     }>;
     concurrency?: number;
     timeoutMs?: number;

package/dist/application/role-repository.js

@@ -42,7 +42,11 @@ function snapshot(path, name) {
         const raw = parse(readFileSync(path, 'utf8'));
         if (!raw || typeof raw !== 'object')
             throw new Error('snapshot must be a mapping');
-        const session = raw.session === 'acp' || raw.session === 'tmux' ? raw.session : 'tmux';
+        if (raw.session === 'tmux')
+            throw new Error('session: tmux is no longer supported; use session: acp with the Codex or Claude Code adapter');
+        if (raw.session !== undefined && raw.session !== 'acp')
+            throw new Error(`unsupported session '${String(raw.session)}'; expected session: acp`);
+        const session = 'acp';
         return {
             role: {
                 ...raw, name, harness: typeof raw.harness === 'string' ? raw.harness : 'claude-code',
@@ -167,14 +171,10 @@ export class RoleRepository {
         const timeoutMs = this.options.timeoutMs ?? 2_000;
         const result = await Promise.race([
             this.options.probeBackend(name, intended),
-            new Promise(resolve => setTimeout(() => resolve({ acp: false, tmux: false }), timeoutMs)),
-        ]).catch(() => ({ acp: false, tmux: false }));
-        if (result.acp && result.tmux)
-            return 'ambiguous';
+            new Promise(resolve => setTimeout(() => resolve({ acp: false }), timeoutMs)),
+        ]).catch(() => ({ acp: false }));
         if (result.acp)
             return 'acp';
-        if (result.tmux)
-            return 'tmux';
         return 'none';
     }
 }

package/dist/application/session-control.d.ts

@@ -1,7 +1,6 @@
 import { controlRequest } from '../session/control.js';
 import type { ConversationEventV1, ConversationSnapshot, PromptReceipt } from '../session/conversation-types.js';
 import type { SessionSnapshot } from '../session/types.js';
-import { Tmux } from '../tmux.js';
 import type { OutputPage, SendReceipt, SessionDescriptor } from './types.js';
 export interface ConversationPageView {
     events: ConversationEventV1[];
@@ -120,14 +119,3 @@ export declare class AcpRoleSessionAdapter implements RoleSessionControl {
     }>;
     private call;
 }
-export declare class TmuxRoleSessionAdapter implements RoleSessionControl {
-    private readonly roleId;
-    private readonly tmux;
-    constructor(roleId: string, tmux?: Tmux);
-    describe(): Promise<SessionDescriptor>;
-    snapshot(): Promise<SessionSnapshot>;
-    recentOutput(request?: {
-        limit?: number;
-    }): Promise<OutputPage>;
-    sendText(text: string): Promise<SendReceipt>;
-}

package/dist/application/session-control.js

@@ -1,6 +1,4 @@
-import { randomUUID } from 'node:crypto';
 import { controlRequest, followConversation } from '../session/control.js';
-import { Tmux } from '../tmux.js';
 import { FleetError, normalizeError } from './errors.js';
 const visibleEvents = (events) => events.filter(event => event.kind !== 'thought');
 export class AcpRoleSessionAdapter {
@@ -149,43 +147,3 @@ export class AcpRoleSessionAdapter {
         }
     }
 }
-export class TmuxRoleSessionAdapter {
-    roleId;
-    tmux;
-    constructor(roleId, tmux = new Tmux()) {
-        this.roleId = roleId;
-        this.tmux = tmux;
-    }
-    async describe() {
-        return { backend: 'tmux', protocolVersion: 1, features: ['text', 'capture'] };
-    }
-    async snapshot() {
-        const alive = await this.tmux.has(this.roleId);
-        return { backend: 'tmux', alive, readiness: alive ? 'idle' : 'failed' };
-    }
-    async recentOutput(request = {}) {
-        try {
-            const text = await this.tmux.capture(this.roleId, Math.min(request.limit ?? 100, 500));
-            return { events: [], text, truncated: false };
-        }
-        catch (error) {
-            throw normalizeError(error);
-        }
-    }
-    async sendText(text) {
-        if (!text.trim())
-            throw new FleetError('invalid_request', 'text is required');
-        if (Buffer.byteLength(text) > 32 * 1024)
-            throw new FleetError('invalid_request', 'text exceeds 32 KiB');
-        try {
-            await this.tmux.sendText(this.roleId, text);
-        }
-        catch (error) {
-            throw normalizeError(error);
-        }
-        return {
-            accepted: true, promptId: randomUUID(), queuedBehind: 0, terminalOutcomeKnown: false,
-            detail: 'literal text and Enter sent; terminal outcome is unknown',
-        };
-    }
-}

package/dist/application/session-mutations.d.ts

@@ -1,7 +1,7 @@
-import type { InterruptOutcome, QueuedPrompt, SessionHandle, SubmitPromptOptions, TurnCancellationSource } from '../session/types.js';
+import type { AgentSession, InterruptOutcome, QueuedPrompt, SubmitPromptOptions, TurnCancellationSource } from '../session/types.js';
 /** Thin in-process session mutation kernel. Callers retain every policy decision. */
-export declare const queueSessionPrompt: (session: SessionHandle, text: string, options?: SubmitPromptOptions) => Promise<QueuedPrompt>;
-export declare const interruptSession: (session: SessionHandle, source: TurnCancellationSource) => Promise<InterruptOutcome>;
-export declare const respondSessionPermission: (session: SessionHandle, permissionId: string, optionId: string) => boolean;
+export declare const queueSessionPrompt: (session: AgentSession, text: string, options?: SubmitPromptOptions) => Promise<QueuedPrompt>;
+export declare const interruptSession: (session: AgentSession, source: TurnCancellationSource) => Promise<InterruptOutcome>;
+export declare const respondSessionPermission: (session: AgentSession, permissionId: string, optionId: string) => boolean;
 export type GenerationPermissionResult = 'accepted' | 'stale' | 'unavailable';
-export declare const respondSessionPermissionV2: (session: SessionHandle, permissionId: string, optionId: string, sessionGeneration: string) => GenerationPermissionResult;
+export declare const respondSessionPermissionV2: (session: AgentSession, permissionId: string, optionId: string, sessionGeneration: string) => GenerationPermissionResult;