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

package/dist/runner.js

@@ -5,16 +5,13 @@ import { parse } from 'yaml';
 import { agentDir, stateRoot } from './paths.js';
 import { loadConfig, findRole, isolationContextFor, resolveMonitorConfig, resolvePermissions, } from './config.js';
 import { getAdapter } from './harness/registry.js';
-import { Tmux } from './tmux.js';
 import { createMonitor, probeIdentityPresence, } from './monitor.js';
-import { realExec, shq } from './exec.js';
+import { realExec } from './exec.js';
 import { resolveIsolation } from './isolation/policy.js';
 import { selectIsolationBackend } from './isolation/registry.js';
 import { resourceArgs, cpuControllerDelegated } from './isolation/resources.js';
 import { resolveLaunchRuntime } from './isolation/runtime.js';
-import { AcpSession } from './session/acp.js';
 import { controlRequest, RoleControlServer } from './session/control.js';
-import { TmuxSession } from './session/tmux.js';
 import { ACP_CANCEL_DEADLINE_EXCEEDED, classifyShellStatus } from './session/types.js';
 import { effectiveModelForRole, modelRecoveryHeld, reconcileModelRecovery, recordModelFailure, classifyFailureText, } from './model-recovery.js';
 import { rotateWorklog } from './worklog.js';
@@ -28,7 +25,6 @@ import { effectivePermissionMode } from './permissions.js';
 import { assertModelPinReachesChild, effectiveRoleModel, repinModelEnv } from './model-env.js';
 import { archiveTempState, markTempSupervisorActive, requestedTempStopReason, } from './temp-lifecycle.js';
 const defaultDeps = () => ({
-    tmux: new Tmux(),
     exec: realExec,
     cpuDelegated: () => cpuControllerDelegated(),
     isAlive: pid => { try {
@@ -44,7 +40,7 @@ const defaultDeps = () => ({
     fetch: (url, init) => globalThis.fetch(url, init),
     createMonitor: opts => createMonitor(opts),
     createOwnerChannel: opts => new OwnerChannel(opts),
-    startAcpSession: opts => AcpSession.start(opts),
+    startAgentSession: (adapter, options) => adapter.start(options),
     createControlServer: (stateDir, session, log) => new RoleControlServer(stateDir, session, log),
     acquireOwnerBinder: (stateDir, role, identity) => acquireOwnerBinderLease(stateDir, role, identity),
     reportOwnerStartupFailure: async (stateDir) => {
@@ -133,38 +129,10 @@ export function recordMonitorOwner(dir, owner) {
     catch { /* ownership diagnostics must never take the role down */ }
     return owner === 'fleet' && previous === 'native';
 }
-/**
- * Compose the tmux pane shell command: env prefix + argv + exit-status capture.
- * `paneArgv` defaults to `launch.argv`; when isolation is active the caller passes
- * the sandbox-wrapped argv (e.g. `bwrap … -- claude …`). The `env` prefix and the
- * `echo $? > exitfile` capture stay host-side, outside the sandbox, so the runner
- * still sees the real exit code.
- */
-export function buildPaneCommand(launch, roleEnv, exitStatusPath, paneArgv = launch.argv) {
-    const env = {
-        PATH: process.env.PATH ?? '', COLORTERM: 'truecolor', ...launch.env, ...(roleEnv ?? {}),
-    };
-    delete env[OBSOLETE_OURS_AUTOSTART_ENV];
-    // Interactive panes should advertise colour even when the supervisor itself
-    // was launched with NO_COLOR. A role may still deliberately opt back in to
-    // NO_COLOR (or replace COLORTERM) through its explicit env block.
-    const unsetNoColor = Object.prototype.hasOwnProperty.call(roleEnv ?? {}, 'NO_COLOR')
-        ? '' : '-u NO_COLOR ';
-    const envPfx = 'env -u OURS_AUTOSTART ' + unsetNoColor
-        + Object.entries(env).map(([k, v]) => `${k}=${shq(v)}`).join(' ');
-    const cmd = paneArgv.map(shq).join(' ');
-    // Write a structured record, not a bare number: the wait status alone cannot
-    // say whether the file is missing because the program never exited or because
-    // nothing ever wrote it. `printf` is POSIX; no shell branching is needed
-    // because classification happens in one place, in TypeScript.
-    const record = `'{"version":1,"backend":"tmux","status":'"$__ofs"'}'`;
-    return `${envPfx} ${cmd}; __ofs=$?; printf %s ${record} > ${shq(exitStatusPath)}`;
-}
 /** Adapt runner deps and the role's daemon-profile overrides for the monitor. */
 function monitorDeps(deps, roleEnv) {
     return {
         fetch: deps.fetch,
-        tmux: deps.tmux,
         isAlive: deps.isAlive,
         sleep: deps.sleep,
         now: deps.now,
@@ -484,16 +452,9 @@ export async function runOnce(name, opts = {}, partialDeps = {}) {
     writeFileSync(bootedFile, `${new Date(deps.now()).toISOString()} ${mode}\n`);
     const runCwd = role.cwd && existsSync(role.cwd) ? role.cwd : dir;
     const prep = await adapter.prepareSession(role, { stateDir: dir, runCwd });
-    const sessionBackend = role.session ?? 'tmux';
-    let launch = sessionBackend === 'acp'
-        ? (() => {
-            if (!adapter.buildAcpLaunch)
-                throw new Error(`harness '${role.harness}' does not support the ACP session backend`);
-            return adapter.buildAcpLaunch(role, prep);
-        })()
-        : adapter.buildLaunch(role, mode, { sessionId }, prep);
-    // Isolation is additive: only roles that declare `isolation:` are wrapped. The
-    // env prefix + exit capture in buildPaneCommand stay host-side.
+    const sessionBackend = role.session ?? 'acp';
+    let launch = adapter.agentSession.prepareLaunch(role, prep);
+    // Isolation is additive: only roles that declare `isolation:` are wrapped.
     let wrappedArgv = launch.argv;
     if (role.isolation) {
         // Start with the same durable context that config validation and doctor judged,
@@ -530,7 +491,7 @@ export async function runOnce(name, opts = {}, partialDeps = {}) {
     // user unit concurrently on boot; `ours-fleet up`/restart-all bulk-start) does not
     // hit the harness/API rate limit at once. Time-based via a shared launch gate, so
     // a lone start or a solo crash-restart waits zero. Applied right before the harness
-    // launch (tmux.newSession); the cheap monitor prime still runs immediately after.
+    // agent-session start; the cheap monitor prime still runs immediately after.
     if (staggerMs > 0) {
         const slot = await reserveLaunchSlot(stateRoot(), staggerMs, deps);
         const wait = slot - deps.now();
@@ -575,7 +536,7 @@ export async function runOnce(name, opts = {}, partialDeps = {}) {
         await monitor.prime({ resetCursor: resetMonitorCursor });
     rmSync(exitFile, { force: true });
     let pid;
-    let acpSession;
+    let agentSession;
     let control;
     let unsubscribeRecovery;
     let monitorLoop;
@@ -590,7 +551,7 @@ export async function runOnce(name, opts = {}, partialDeps = {}) {
     let loopGeneration = JSON.stringify((role.loops ?? []).map(loop => [
         loop.name, loop.definitionHash, loop.promptHash,
     ]));
-    if (sessionBackend === 'acp') {
+    {
         const perms = role.permissions ?? resolvePermissions(undefined, undefined);
         // Say once, at startup, that this role will decide permission requests by
         // itself. Without it the only trace of an auto-denied tool call is a turn
@@ -598,34 +559,16 @@ export async function runOnce(name, opts = {}, partialDeps = {}) {
         if (perms.unattended === 'deny')
             deps.log(`[${name}] permission policy: unattended=deny — with no console attached, ` +
                 `permission requests are automatically denied once each (reject_once) and the turn continues`);
-        acpSession = await deps.startAcpSession({
-            name,
-            argv: wrappedArgv,
-            cwd: runCwd,
-            env: harnessChildEnv(role, launch.env, dir),
-            stateDir: dir,
-            mode,
-            permissions: perms,
-            modeId: adapter.acpPermissionModeId?.(role),
-            // The role's declared MCP servers, and the bundled agent's `_meta`
-            // vocabulary for the options it takes no flag for. Both come from the
-            // ADAPTER and from `prep`: the ACP launch cannot carry `prep.argv`, so this
-            // is the route by which harness_options that used to be silently dropped
-            // for an ACP role actually reach the session.
-            mcpServers: adapter.acpMcpServers?.(role),
-            sessionMeta: adapter.acpSessionMeta?.(role, prep),
-            permissionMode: effectivePermissionMode(role),
-            // Provenance travels with the exact ACP launch. Keeping it out of a
-            // role-only adapter hook prevents a PATH fallback or resolver skew from
-            // claiming metadata trust for an argv it did not authenticate.
-            permissionMetadataSource: launch.permissionMetadataSource,
-            scrubObsoleteOursAutostart: true,
-            log: deps.log,
+        agentSession = await deps.startAgentSession(adapter.agentSession, {
+            role, prep,
+            launch: { ...launch, argv: wrappedArgv, env: harnessChildEnv(role, launch.env, dir) },
+            cwd: runCwd, stateDir: dir, mode, permissions: perms,
+            permissionMode: effectivePermissionMode(role), log: deps.log,
         });
-        pid = acpSession.pid;
-        arbiter = new RoleTurnArbiter(acpSession);
+        pid = agentSession.pid;
+        arbiter = new RoleTurnArbiter(agentSession);
         sessionHandle = arbiter;
-        unsubscribeRecovery = acpSession.subscribe(event => {
+        unsubscribeRecovery = agentSession.subscribe(event => {
             if (event.kind !== 'error' || !event.text)
                 return;
             const evidence = classifyFailureText(event.text, 'acp', new Date(deps.now()).toISOString());
@@ -647,7 +590,7 @@ export async function runOnce(name, opts = {}, partialDeps = {}) {
                             + `${notifyError?.message ?? String(notifyError)}`);
                     }
                 }
-                await acpSession.close();
+                await agentSession.close();
                 unsubscribeRecovery?.();
                 throw new Error(`[${name}] owner channel failed to start: `
                     + `${error?.message ?? String(error)}`);
@@ -659,7 +602,7 @@ export async function runOnce(name, opts = {}, partialDeps = {}) {
         }
         catch (error) {
             ownerBinder?.release();
-            await acpSession.close();
+            await agentSession.close();
             unsubscribeRecovery?.();
             throw error;
         }
@@ -740,7 +683,7 @@ export async function runOnce(name, opts = {}, partialDeps = {}) {
         const started = await starting;
         // A temporary role's first turn can be the active turn when an ours wake
         // needs immediate attention. A typed console/monitor cancellation ends
-        // only that turn: the already-live ACP session and any queued wake remain
+        // only that turn: the already-live agent session and any queued wake remain
         // valid. Keep every unproven cancellation, refusal, shutdown, and genuine
         // failure terminal so a role that never accepted its briefing is not
         // silently reported as healthy.
@@ -749,7 +692,7 @@ export async function runOnce(name, opts = {}, partialDeps = {}) {
             monitor?.stop();
             await control.close();
             ownerBinder?.release();
-            await acpSession.close();
+            await agentSession.close();
             unsubscribeRecovery?.();
             if (modelRecovery) {
                 if (monitorLoop)
@@ -795,7 +738,7 @@ export async function runOnce(name, opts = {}, partialDeps = {}) {
                 await ownerChannel.close().catch(() => undefined);
                 await control.close();
                 ownerBinder?.release();
-                await acpSession.close();
+                await agentSession.close();
                 unsubscribeRecovery?.();
                 throw new Error(`[${name}] owner channel failed to start: `
                     + `${error?.message ?? String(error)}`);
@@ -854,20 +797,6 @@ export async function runOnce(name, opts = {}, partialDeps = {}) {
             }
         }
     }
-    else {
-        await deps.tmux.kill(name);
-        await deps.tmux.newSession(name, runCwd, buildPaneCommand(launch, role.env, exitFile, wrappedArgv));
-        let panePid = null;
-        for (let i = 0; i < 40 && panePid === null; i++) {
-            panePid = await deps.tmux.panePid(name);
-            if (panePid === null)
-                await deps.sleep(250);
-        }
-        if (panePid === null)
-            throw new Error(`[${name}] could not resolve tmux pane pid`);
-        pid = panePid;
-        sessionHandle = new TmuxSession(name, pid, deps.tmux, deps.isAlive);
-    }
     deps.log(`[${name}] up; pid=${pid} cwd=${runCwd} harness=${role.harness} session=${sessionBackend} mode=${mode}`);
     // The monitor loop lives exactly as long as the session: it starts once the
     // pane pid is known and is stopped when that pid dies (task dies with runner).
@@ -899,7 +828,7 @@ export async function runOnce(name, opts = {}, partialDeps = {}) {
             else if (presence.state === 'absent' && identityObserved) {
                 identityAbsentSince ??= now;
                 // Require a continuous, time-bounded run of authoritative absence.
-                // The first positive observation is the readiness gate: cold tmux
+                // The first positive observation is the readiness gate: cold harness
                 // starts may spend minutes loading the harness and briefing before the
                 // agent creates/binds its identity, and absence before then is not a
                 // close event. After readiness, debounce a real disappearance.
@@ -948,19 +877,14 @@ export async function runOnce(name, opts = {}, partialDeps = {}) {
         await monitorLoop;
     }
     unsubscribeRecovery?.();
-    if (acpSession && !sessionClosed)
-        await acpSession.close();
+    if (agentSession && !sessionClosed)
+        await agentSession.close();
     const elapsed = (deps.now() - start) / 1000;
     // Establish what actually happened before deciding anything. Absence of a
     // record is `unknown` — except when the console itself is gone, which is a
     // different event with a different consequence.
-    const exitRecord = acpSession
-        ? acpSession.exitResult()
-            ?? { version: 1, class: 'unknown', detail: 'the ACP agent stopped without reporting an exit' }
-        : readExitRecord(exitFile)
-            ?? (await deps.tmux.has(name)
-                ? { version: 1, class: 'unknown', detail: 'the pane process ended without writing an exit record' }
-                : { version: 1, class: 'session-destroyed', detail: `the tmux session '${name}' no longer exists` });
+    const exitRecord = agentSession.exitResult()
+        ?? { version: 1, class: 'unknown', detail: 'the agent session stopped without reporting an exit' };
     writeFileSync(exitFile, JSON.stringify({
         ...exitRecord, at: new Date(deps.now()).toISOString(), elapsedSecs: Number(elapsed.toFixed(1)),
     }) + '\n');

package/dist/session/acp.d.ts

@@ -3,7 +3,7 @@ import type { CommonPermissions } from '../config.js';
 import type { AcpMcpServer } from '../harness/types.js';
 import { ConversationEventStore } from './conversation-store.js';
 import type { ConversationSnapshot, PromptOrigin, PromptReceipt, SubmitPromptCommand } from './conversation-types.js';
-import type { ConversationHandlePage, ExitRecord, InterruptOutcome, QueuedPrompt, SessionEvent, RuntimeSelectorMetadata, SessionHandle, SessionSnapshot, SubmitPromptOptions, TurnCancellationSource, TurnOutcome, TurnResult } from './types.js';
+import type { ConversationHandlePage, ExitRecord, InterruptOutcome, QueuedPrompt, SessionEvent, AgentSession, RuntimeSelectorMetadata, SessionSnapshot, SubmitPromptOptions, TurnCancellationSource, TurnOutcome, TurnResult } from './types.js';
 /** Bound safe-boundary waiting without turning a hung tool into cancellation. */
 export declare const AFTER_TOOL_BOUNDARY_TIMEOUT_MS = 120000;
 /**
@@ -81,7 +81,7 @@ export declare function classifyStopReason(stopReason: string | undefined): Turn
  * Persistent ACP v1 client. It is the sole owner of the agent's stdio; all
  * human/automation attachment happens through the fleet role-control protocol.
  */
-export declare class AcpSession implements SessionHandle {
+export declare class AcpSession implements AgentSession {
     private readonly options;
     readonly backend: "acp";
     readonly pid: number;

package/dist/session/acp.js

@@ -281,8 +281,7 @@ export class AcpSession {
                 clearTimeout(this.cancelForceKill);
             this.cancelForceKill = undefined;
             this.releaseSteeringOccupancy('adapter exited');
-            // Record the child's real exit code/signal. The tmux path can only see a
-            // shell's `$?`; here the truth is available, so keep it.
+            // Record the child's real exit code/signal while the truth is available.
             const classified = classifyChildExit(code, signal);
             this.exit = this.cancelRecoveryReason
                 ? { ...classified, detail: `${this.cancelRecoveryReason}; ${classified.detail}` }
@@ -1476,7 +1475,7 @@ export class AcpSession {
             ...(normalized.adapterMeta ? { adapterMeta: normalized.adapterMeta } : {}),
         });
     }
-    // ── conversation ledger access (SessionHandle) ─────────────────────────────
+    // ── conversation ledger access (AgentSession) ─────────────────────────────
     conversationPage(request = {}) {
         const floor = Number(this.conversationStartCursor ?? 0);
         const requested = Number(request.after ?? 0);

package/dist/session/activity.d.ts

@@ -18,9 +18,8 @@ export interface ObservedActivity {
     lastUpdateAt?: string;
 }
 /**
- * Classify agent-side activity. `unobservable` is NOT `quiet`: a backend that
- * cannot see the agent (tmux) has no evidence, and no evidence must never be
- * reported as "doing nothing".
+ * Classify agent-side activity. `unobservable` is NOT `quiet`: absent evidence
+ * must never be reported as "doing nothing".
  */
 export declare function classifyActivity(activity: SessionActivity | undefined, now?: number): ObservedActivity;
 /**

package/dist/session/activity.js

@@ -11,9 +11,8 @@
  */
 export const ACTIVITY_WINDOW_MS = 60_000;
 /**
- * Classify agent-side activity. `unobservable` is NOT `quiet`: a backend that
- * cannot see the agent (tmux) has no evidence, and no evidence must never be
- * reported as "doing nothing".
+ * Classify agent-side activity. `unobservable` is NOT `quiet`: absent evidence
+ * must never be reported as "doing nothing".
  */
 export function classifyActivity(activity, now = Date.now()) {
     if (!activity)

package/dist/session/arbiter.d.ts

@@ -1,4 +1,4 @@
-import type { ConversationHandlePage, ExitRecord, InterruptOutcome, PromptOrigin, QueuedPrompt, SessionEvent, SessionHandle, SessionSnapshot, SubmitPromptOptions, TurnCancellationSource, TurnResult } from './types.js';
+import type { ConversationHandlePage, ExitRecord, InterruptOutcome, PromptOrigin, QueuedPrompt, SessionEvent, AgentSession, SessionSnapshot, SubmitPromptOptions, TurnCancellationSource, TurnResult } from './types.js';
 import type { ConversationEventV1, ConversationSnapshot, PromptReceipt, SubmitPromptCommand } from './conversation-types.js';
 export type ScheduledAttempt = {
     state: 'started';
@@ -15,9 +15,9 @@ export type ScheduledAttempt = {
  * producers retain ACP queue semantics while making their unsettled claim
  * visible before another producer can inspect idle state.
  */
-export declare class RoleTurnArbiter implements SessionHandle {
+export declare class RoleTurnArbiter implements AgentSession {
     private readonly session;
-    readonly backend: import("../config.js").SessionBackendId;
+    readonly backend: "acp";
     readonly pid: number;
     private tail;
     private unsettled;
@@ -26,7 +26,7 @@ export declare class RoleTurnArbiter implements SessionHandle {
     private generation;
     /** Resolves the instant the CURRENT generation is retired. */
     private retirement;
-    constructor(session: SessionHandle);
+    constructor(session: AgentSession);
     /**
      * Waiters race the tail against their own generation's retirement, so a
      * single operation that never settles cannot own the boundary forever. A

package/dist/session/control.d.ts

@@ -1,5 +1,5 @@
 import { type Socket } from 'node:net';
-import type { ControlFailureKind, SessionEvent, SessionHandle, SessionSnapshot } from './types.js';
+import type { AgentSession, ControlFailureKind, SessionEvent, SessionSnapshot } from './types.js';
 import type { OwnerChannelHandle, OwnerChannelManagementRequest } from '../owner-channel/channel.js';
 import type { ScheduledLoopManagerHandle } from '../loops/manager.js';
 import type { SpawnOpts } from '../spawn.js';
@@ -48,7 +48,7 @@ export interface RetainedEventPage {
     truncated: boolean;
 }
 /** The one retained-range projection shared by polling and live-follow admission. */
-export declare function retainedEventPage(session: SessionHandle, since: number): RetainedEventPage;
+export declare function retainedEventPage(session: AgentSession, since: number): RetainedEventPage;
 /**
  * One line saying what a control failure does — and does not — prove about the
  * agent. Only `offline` is evidence that it is gone; every other kind used to
@@ -105,7 +105,7 @@ export declare class RoleControlServer {
     private loopManager?;
     private reloadConfig?;
     private fleetSpawner?;
-    constructor(stateDir: string, session: SessionHandle, log: (line: string) => void);
+    constructor(stateDir: string, session: AgentSession, log: (line: string) => void);
     start(): Promise<void>;
     close(): Promise<void>;
     /** Attach only the already-started supervisor-owned channel client. */

package/dist/session/types.d.ts

@@ -96,7 +96,7 @@ export interface InterruptOutcome {
     reasonCode?: string;
 }
 /**
- * What a `SessionHandle.interrupt` implementation may resolve. Before 0.17.1 the
+ * What an `AgentSession.interrupt` implementation may resolve. Before 0.17.1 the
  * contract was `Promise<void>`, and resolving at all meant the cancellation had
  * taken effect cooperatively — so an implementation written against that
  * contract stays valid and keeps its exact meaning. Only in-tree consumers read
@@ -146,7 +146,7 @@ export interface ExitRecord {
     code?: number;
     /** Signal that killed it, when one did. */
     signal?: string;
-    /** Raw wait status as the pane shell saw it (tmux only). */
+    /** Raw wait status retained when migrating a legacy shell-exit record. */
     status?: number;
     at?: string;
     /** One line an operator can read. */
@@ -194,8 +194,7 @@ export interface SessionSnapshot {
     };
     /**
      * Observed agent activity, independent of turn occupancy: the evidence a
-     * human-facing surface needs before calling a role idle. Absent on backends
-     * that cannot observe the agent at all (tmux), which is itself honest — no
+     * human-facing surface needs before calling a role idle. When absent, no
      * evidence is not evidence of inactivity.
      */
     activity?: SessionActivity;
@@ -259,7 +258,12 @@ export interface ConversationHandlePage {
     hasMore: boolean;
     snapshot: ConversationSnapshot;
 }
-export interface SessionHandle {
+/**
+ * The live, harness-neutral contract between Fleet and one agent session.
+ * Harness adapters construct this handle; orchestration code must not depend
+ * on the ACP transport which currently implements it.
+ */
+export interface AgentSession {
     readonly backend: SessionBackendId;
     readonly pid: number;
     isAlive(): boolean;
@@ -301,3 +305,5 @@ export interface SessionHandle {
     exitResult(): ExitRecord | null;
     close(): Promise<void>;
 }
+/** @deprecated Public compatibility name; use AgentSession. */
+export type SessionHandle = AgentSession;

package/dist/spawn.js

@@ -123,8 +123,10 @@ export function readIsolationFile(path) {
 export function validateSpawnOpts(o) {
     if (o.mission !== undefined && o.missionFile)
         throw new Error('--mission and --mission-file are mutually exclusive');
-    if (o.session && !['tmux', 'acp'].includes(o.session))
-        throw new Error(`invalid --session '${o.session}'; allowed: tmux, acp`);
+    if (o.session === 'tmux')
+        throw new Error("invalid --session 'tmux'; tmux is no longer supported; use --session acp");
+    if (o.session && o.session !== 'acp')
+        throw new Error(`invalid --session '${o.session}'; allowed: acp`);
     if (o.approval && !['ask', 'auto', 'allow', 'deny'].includes(o.approval))
         throw new Error(`invalid --approval '${o.approval}'; allowed: ask, auto, allow (deprecated alias: deny)`);
     if (o.filesystem && !['read-only', 'workspace', 'unrestricted'].includes(o.filesystem))
@@ -203,7 +205,7 @@ export function spawnDryRun(o) {
         ...(authProxy ? { authProxyBaseUrl: authProxy.base_url } : {}),
     });
     const model = modelEnv.model;
-    const session = raw.session ?? cfg.defaults.session ?? 'tmux';
+    const session = raw.session ?? cfg.defaults.session ?? 'acp';
     const resolvedRole = {
         ...raw,
         name: o.name,
@@ -255,7 +257,7 @@ function provenanceSettings(o, defaults) {
     const inheritedModel = resolveRoleModel(undefined, o.harness, defaults);
     return {
         harness: tagged('harness', provenanceOf(o.harness, defaults.harness, 'claude-code')),
-        session: tagged('session', provenanceOf(o.session, defaults.session, 'tmux')),
+        session: tagged('session', provenanceOf(o.session, defaults.session, 'acp')),
         identity: o.identity
             ? { value: o.identity, source: 'cli' }
             : { value: o.name, source: 'built-in' }, // defaults to the role name
@@ -417,7 +419,7 @@ async function spawnTempInner(o, binPath, launch, tx, onStage) {
         ...(tempAuthProxy ? { authProxyBaseUrl: tempAuthProxy.base_url } : {}),
     });
     const model = modelEnv.model;
-    const session = o.session ?? cfg.defaults.session ?? 'tmux';
+    const session = o.session ?? cfg.defaults.session ?? 'acp';
     const role = {
         ...fromOpts, // includes `isolation` when --isolation-file was given
         name: o.name,
@@ -467,10 +469,7 @@ async function spawnTempInner(o, binPath, launch, tx, onStage) {
     if (cfg.startStaggerMs > 0)
         writeFileSync(join(dir, START_STAGGER_FILE), String(cfg.startStaggerMs));
     prepareTempSupervisor(dir, o.name);
-    // Run the supervisor independently — NOT inside a tmux session named <name>.
-    // `_run-temp` -> runOnce() creates AND kills the tmux session <name> for the
-    // agent itself; a supervisor sharing that session name would SIGHUP its own
-    // process before the agent ever launches. On a service-managed host the temp
+    // Run the supervisor independently. On a service-managed host the temp
     // runner gets its own transient unit/job, so stopping the coordinator's unit
     // cannot kill a live worker in the coordinator's cgroup.
     onStage?.('starting_temp');

package/dist/supervisor/none.d.ts

@@ -1,7 +1,7 @@
 import { type Exec } from '../exec.js';
 import type { SupervisorBackend } from './types.js';
 /**
- * No supervision: sessions are plain tmux, nothing survives a reboot and
+ * No service supervision: tmux contains the direct runner process, nothing survives a reboot and
  * nothing restarts on crash. Used for temp agents and CI tests
  * (OURS_FLEET_SUPERVISOR=none).
  */

package/dist/supervisor/none.js

@@ -1,7 +1,7 @@
 import { Tmux, tmuxArgs } from '../tmux.js';
 import { realExec, shq } from '../exec.js';
 /**
- * No supervision: sessions are plain tmux, nothing survives a reboot and
+ * No service supervision: tmux contains the direct runner process, nothing survives a reboot and
  * nothing restarts on crash. Used for temp agents and CI tests
  * (OURS_FLEET_SUPERVISOR=none).
  */
@@ -9,7 +9,7 @@ export function makeNoneBackend(exec = realExec) {
     const tmux = new Tmux(exec);
     return {
         id: 'none',
-        async init() { return ['no supervisor: sessions are plain tmux (no reboot survival)']; },
+        async init() { return ['no service supervisor: direct runner containment only (no reboot survival)']; },
         async install(name, binPath) {
             const existed = await tmux.kill(name); // true when a session was there
             await tmux.newSession(name, process.cwd(), `${shq(binPath)} _run ${shq(name)}`);

package/dist/tmux.d.ts

@@ -20,7 +20,7 @@ export declare const tmuxSocket: (session: string) => string;
  * the shared default server and re-creates #32.
  */
 export declare const tmuxArgs: (session: string, args: string[]) => string[];
-/** Thin tmux wrapper; all session handling in the core goes through this. */
+/** Thin tmux wrapper retained only for supervisor=none process containment. */
 export declare class Tmux {
     private exec;
     constructor(exec?: Exec);
@@ -32,17 +32,4 @@ export declare class Tmux {
      * program inside it exited on its own".
      */
     kill(name: string): Promise<boolean>;
-    capture(name: string, lines?: number): Promise<string>;
-    /** Bounded ANSI/history seed for the browser terminal projection. */
-    captureHistory(name: string, lines?: number): Promise<string>;
-    panePid(name: string): Promise<number | null>;
-    /**
-     * List the live sessions among `names`, asking each server in turn.
-     * There is no fleet-wide `tmux ls` any more: a session per server means the
-     * caller says which sessions to ask about. A server that is not running
-     * answers non-zero and contributes nothing.
-     */
-    list(names: readonly string[]): Promise<string>;
-    sendText(name: string, text: string): Promise<void>;
-    sendKey(name: string, key: string): Promise<void>;
 }

package/dist/tmux.js

@@ -20,7 +20,7 @@ export const tmuxSocket = (session) => `${TMUX_SOCKET_PREFIX}${session}`;
  * the shared default server and re-creates #32.
  */
 export const tmuxArgs = (session, args) => ['-L', tmuxSocket(session), ...args];
-/** Thin tmux wrapper; all session handling in the core goes through this. */
+/** Thin tmux wrapper retained only for supervisor=none process containment. */
 export class Tmux {
     exec;
     constructor(exec = realExec) {
@@ -42,54 +42,4 @@ export class Tmux {
     async kill(name) {
         return (await this.exec('tmux', tmuxArgs(name, ['kill-session', '-t', name]))).code === 0;
     }
-    async capture(name, lines = 40) {
-        const r = await this.exec('tmux', tmuxArgs(name, ['capture-pane', '-t', name, '-p']));
-        if (r.code !== 0)
-            throw new Error(`tmux capture-pane '${name}' failed: ${r.stderr.trim()}`);
-        const all = r.stdout.replace(/\n+$/, '').split('\n');
-        return all.slice(-lines).join('\n');
-    }
-    /** Bounded ANSI/history seed for the browser terminal projection. */
-    async captureHistory(name, lines = 5_000) {
-        const bounded = Math.min(Math.max(Math.trunc(lines), 1), 20_000);
-        const r = await this.exec('tmux', tmuxArgs(name, ['capture-pane', '-t', name, '-p', '-e', '-J', '-S', `-${bounded}`]));
-        if (r.code !== 0)
-            throw new Error(`tmux capture-pane '${name}' failed: ${r.stderr.trim()}`);
-        return Buffer.from(r.stdout).subarray(0, 4 * 1024 * 1024).toString();
-    }
-    async panePid(name) {
-        const r = await this.exec('tmux', tmuxArgs(name, ['list-panes', '-t', name, '-F', '#{pane_pid}']));
-        if (r.code !== 0)
-            return null;
-        const pid = parseInt(r.stdout.trim().split('\n')[0], 10);
-        return Number.isFinite(pid) ? pid : null;
-    }
-    /**
-     * List the live sessions among `names`, asking each server in turn.
-     * There is no fleet-wide `tmux ls` any more: a session per server means the
-     * caller says which sessions to ask about. A server that is not running
-     * answers non-zero and contributes nothing.
-     */
-    async list(names) {
-        const lines = [];
-        for (const name of names) {
-            const r = await this.exec('tmux', tmuxArgs(name, ['ls']));
-            if (r.code === 0 && r.stdout.trim())
-                lines.push(r.stdout.trimEnd());
-        }
-        return lines.join('\n');
-    }
-    async sendText(name, text) {
-        let r = await this.exec('tmux', tmuxArgs(name, ['send-keys', '-t', name, '-l', text]));
-        if (r.code !== 0)
-            throw new Error(`tmux send-keys '${name}' failed: ${r.stderr.trim()}`);
-        r = await this.exec('tmux', tmuxArgs(name, ['send-keys', '-t', name, 'Enter']));
-        if (r.code !== 0)
-            throw new Error(`tmux send-keys Enter '${name}' failed: ${r.stderr.trim()}`);
-    }
-    async sendKey(name, key) {
-        const r = await this.exec('tmux', tmuxArgs(name, ['send-keys', '-t', name, key]));
-        if (r.code !== 0)
-            throw new Error(`tmux send-keys '${name}' failed: ${r.stderr.trim()}`);
-    }
 }

package/dist/watchdog/config.js

@@ -31,7 +31,7 @@ export function resolveWatchdogs(baseDoc, baseFile, roles, vars, defaults) {
     const roleIdentities = new Set(roles.map(r => r.identity));
     // Tracks identity -> owning watchdog name across entries:
     // two watchdogs declaring the same identity would otherwise share a temp
-    // dir, tmux session, and run lock with no error until they collide at
+    // dir, agent session, and run lock with no error until they collide at
     // runtime.
     const watchdogIdentities = new Map();
     const out = [];
@@ -61,9 +61,11 @@ export function resolveWatchdogs(baseDoc, baseFile, roles, vars, defaults) {
             throw new ConfigError(`${where}: identity '${identity}' collides with watchdog '${collidingWatchdog}'`);
         watchdogIdentities.set(identity, name);
         const harness = w.harness ?? defaults.harness ?? 'claude-code';
-        const sessionRaw = w.session ?? defaults.session ?? 'tmux';
-        if (sessionRaw !== 'tmux' && sessionRaw !== 'acp')
-            throw new ConfigError(`${where}: session must be 'tmux' or 'acp'`);
+        const sessionRaw = w.session ?? defaults.session ?? 'acp';
+        if (sessionRaw === 'tmux')
+            throw new ConfigError(`${where}: session 'tmux' is no longer supported; use session: acp`);
+        if (sessionRaw !== 'acp')
+            throw new ConfigError(`${where}: session must be 'acp'`);
         if (w.prompt_file !== undefined) {
             if (typeof w.prompt_file !== 'string' || !isAbsolute(w.prompt_file))
                 throw new ConfigError(`${where}: prompt_file must be an absolute path`);