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

package/dist/application/task-room-service.d.ts

@@ -1,10 +1,11 @@
 import { type FleetConfig } from '../config.js';
 import { type CoworkAdapter } from '../rooms-tasks/cowork-adapter.js';
 import { provisionMembers } from '../rooms-tasks/provision.js';
-import type { RoomOrchestrationRecord, TaskOrigin, TaskOutcome, TaskRecord, TaskState } from '../rooms-tasks/types.js';
+import { moveTaskToList } from '../rooms-tasks/task-state.js';
+import type { RoomOrchestrationRecord, TaskListRecord, TaskOrigin, TaskOutcome, TaskRecord, TaskState } from '../rooms-tasks/types.js';
 export type TaskRoomActor = {
     kind: 'local_control';
-    surface: 'cli';
+    surface: 'cli' | 'web';
 } | {
     kind: 'authenticated_owner';
     surface: 'messenger';
@@ -55,6 +56,7 @@ export interface CreateTaskRequest {
     noRoom?: boolean;
     idempotencyKey?: string;
     origin: TaskOrigin;
+    list?: string;
 }
 export interface CreateRoomRequest {
     actor: TaskRoomActor;
@@ -69,6 +71,7 @@ export interface TaskRoomServiceDeps {
     cowork?(config: FleetConfig): CoworkAdapter;
     binPath?(): string;
     provisionMembers?: typeof provisionMembers;
+    moveTaskToList?: typeof moveTaskToList;
 }
 /** Exact extraction of the previously CLI-owned task create/start behavior. */
 export declare class TaskRoomApplicationService {
@@ -84,7 +87,39 @@ export declare class TaskRoomApplicationService {
     }): Promise<TaskRecord>;
     listTasks(filter?: {
         state?: TaskState | TaskState[];
+        list?: string;
     }): TaskRecord[];
+    listTaskLists(): TaskListRecord[];
+    groupedTasks(filter?: {
+        state?: TaskState | TaskState[];
+        list?: string;
+    }): Array<{
+        list: TaskListRecord;
+        tasks: TaskRecord[];
+    }>;
+    createTaskList(input: {
+        actor: TaskRoomActor;
+        name: string;
+    }): Promise<TaskListRecord>;
+    renameTaskList(input: {
+        actor: TaskRoomActor;
+        name: string;
+        newName: string;
+    }): Promise<TaskListRecord>;
+    moveTask(input: {
+        actor: TaskRoomActor;
+        taskId: string;
+        list: string;
+    }): Promise<TaskRecord>;
+    deleteTaskList(input: {
+        actor: TaskRoomActor;
+        name: string;
+        destination?: string;
+    }): Promise<{
+        deleted: TaskListRecord;
+        moved: number;
+        destination?: TaskListRecord;
+    }>;
     getTask(taskId: string): {
         task: TaskRecord;
         orchestration: RoomOrchestrationRecord | undefined;

package/dist/application/task-room-service.js

@@ -3,7 +3,8 @@ import { ConfigError, loadConfig } from '../config.js';
 import { CoworkProtocolError, CoworkUnavailableError, createCoworkAdapter, } from '../rooms-tasks/cowork-adapter.js';
 import { getBinPath, provisionMembers } from '../rooms-tasks/provision.js';
 import { activateRoom, advanceSaga, createRoomRecord, getRoomRecord, listRoomRecords, setOwnerSeat, setSagaError, } from '../rooms-tasks/room-state.js';
-import { activateTask, blockTask as persistBlockTask, createTask as persistTask, deleteTask as persistDeleteTask, getTask as readTask, listTasks as readTasks, reviewTask as persistReviewTask, startTask as transitionTask, TaskStateError, unblockTask as persistUnblockTask, updateTaskRoom, updateTaskTemplate, } from '../rooms-tasks/task-state.js';
+import { activateTask, blockTask as persistBlockTask, createTask as persistTask, deleteTask as persistDeleteTask, getTask as readTask, listTasks as readTasks, moveTaskToList, reviewTask as persistReviewTask, startTask as transitionTask, TaskStateError, unblockTask as persistUnblockTask, updateTaskRoom, updateTaskTemplate, } from '../rooms-tasks/task-state.js';
+import { createTaskListLocked, DEFAULT_TASK_LIST_ID, deleteTaskListRecordLocked, readTaskLists, renameTaskListLocked, resolveTaskList, TaskListError, withTaskListsLock, } from '../rooms-tasks/task-lists.js';
 import { hashTemplate, listTemplates, resolveTemplate, snapshotTemplate } from '../rooms-tasks/templates.js';
 import { acceptManagedRoomClose, deleteLegacyClosedRooms, deleteManagedRoom, recordManagedRoomCloseError, } from '../rooms-tasks/close.js';
 import { acceptTaskTerminalIntent, recordTaskTerminalIntentError, settleTaskTerminalIntent, } from '../rooms-tasks/terminal.js';
@@ -34,11 +35,13 @@ export class TaskRoomApplicationService {
             name: template.name, version: template.version, content_hash: template.content_hash,
         };
         const brief = request.briefFile ? readFileSync(request.briefFile, 'utf8') : request.brief;
-        let task = persistTask({
-            title: request.title, brief, brief_file: request.briefFile, template: ref,
-            origin: request.origin, idempotency_key: request.idempotencyKey,
-            start: !request.backlog,
-            no_room: request.noRoom,
+        let task = await withTaskListsLock(() => {
+            const list = resolveTaskList(request.list ?? 'default');
+            return persistTask({
+                title: request.title, brief, brief_file: request.briefFile, template: ref,
+                origin: request.origin, idempotency_key: request.idempotencyKey,
+                start: !request.backlog, no_room: request.noRoom, listId: list.list_id,
+            });
         });
         if (!request.backlog && !request.noRoom && ref && !task.room_id) {
             try {
@@ -82,7 +85,46 @@ export class TaskRoomApplicationService {
         return task;
     }
     listTasks(filter) {
-        return readTasks(filter);
+        const listId = filter?.list === undefined ? undefined : resolveTaskList(filter.list).list_id;
+        return readTasks({ state: filter?.state, listId });
+    }
+    listTaskLists() { return readTaskLists(); }
+    groupedTasks(filter) {
+        const tasks = this.listTasks(filter);
+        const lists = filter?.list ? [resolveTaskList(filter.list)] : readTaskLists();
+        return lists.map(list => ({ list, tasks: tasks.filter(task => task.list_id === list.list_id) }));
+    }
+    async createTaskList(input) {
+        return withTaskListsLock(() => createTaskListLocked(input.name));
+    }
+    async renameTaskList(input) {
+        return withTaskListsLock(() => renameTaskListLocked(input.name, input.newName));
+    }
+    async moveTask(input) {
+        return withTaskListsLock(() => {
+            const destination = resolveTaskList(input.list);
+            return (this.deps.moveTaskToList ?? moveTaskToList)(input.taskId, destination.list_id);
+        });
+    }
+    async deleteTaskList(input) {
+        return withTaskListsLock(() => {
+            const source = resolveTaskList(input.name);
+            if (source.list_id === DEFAULT_TASK_LIST_ID)
+                throw new TaskListError('default_immutable', "the 'default' list cannot be deleted");
+            const assigned = readTasks({ listId: source.list_id });
+            let destination;
+            if (assigned.length) {
+                if (!input.destination)
+                    throw new TaskListError('destination_required', `task list '${source.name}' is not empty; destination is required`);
+                destination = resolveTaskList(input.destination);
+                if (destination.list_id === source.list_id)
+                    throw new TaskListError('same_destination', 'deletion destination must differ from the source list');
+                for (const task of assigned)
+                    (this.deps.moveTaskToList ?? moveTaskToList)(task.task_id, destination.list_id);
+            }
+            deleteTaskListRecordLocked(source.list_id);
+            return { deleted: source, moved: assigned.length, destination };
+        });
     }
     getTask(taskId) {
         const task = readTask(taskId);

package/dist/application/types.d.ts

@@ -117,7 +117,6 @@ export interface RoleCapabilities {
     };
     input: {
         text: boolean;
-        rawKeys: boolean;
         interrupt: boolean;
         steering: boolean;
     };
@@ -125,12 +124,6 @@ export interface RoleCapabilities {
         observe: boolean;
         respond: boolean;
     };
-    terminal: {
-        available: boolean;
-        reason?: 'wrong_backend' | 'pty_unavailable' | 'offline' | 'incompatible_runner';
-        multiViewer: boolean;
-        writerLease: boolean;
-    };
     lifecycle: {
         start: boolean;
         stop: boolean;

package/dist/atomic-file.d.ts

@@ -10,6 +10,8 @@
 export interface LockDeps {
     now?(): number;
     sleep?(ms: number): Promise<void>;
+    /** Test hook after a complete private claim is prepared, before atomic publication. */
+    beforePublish?(): void | Promise<void>;
 }
 /** The syscalls a replace depends on, injectable so faults can be forced deterministically. */
 export interface WriteDeps {
@@ -18,9 +20,9 @@ export interface WriteDeps {
     closeSync?(fd: number): void;
 }
 /**
- * Run `fn` holding a cross-process lock. `mkdir` is atomic on every platform we
- * support, so the directory's existence IS the lock; the timestamp inside lets a
- * crashed holder's lock be broken rather than deadlocking the fleet forever.
+ * Run `fn` holding a cross-process lock. A fully populated private claim directory
+ * is atomically renamed to the canonical path, so contenders never observe partial
+ * ownership metadata; its timestamp lets a crashed holder be reclaimed safely.
  * Same strategy as the runner's launch gate, factored out so both use one.
  *
  * The lock is always released, including when `fn` throws.

package/dist/atomic-file.js

@@ -4,9 +4,9 @@ import { randomUUID } from 'node:crypto';
 const DEFAULT_STALE_MS = 10_000;
 const POLL_MS = 25;
 /**
- * Run `fn` holding a cross-process lock. `mkdir` is atomic on every platform we
- * support, so the directory's existence IS the lock; the timestamp inside lets a
- * crashed holder's lock be broken rather than deadlocking the fleet forever.
+ * Run `fn` holding a cross-process lock. A fully populated private claim directory
+ * is atomically renamed to the canonical path, so contenders never observe partial
+ * ownership metadata; its timestamp lets a crashed holder be reclaimed safely.
  * Same strategy as the runner's launch gate, factored out so both use one.
  *
  * The lock is always released, including when `fn` throws.
@@ -15,15 +15,22 @@ export async function withFileLock(lockPath, fn, deps = {}, staleMs = DEFAULT_ST
     const now = deps.now ?? (() => Date.now());
     const sleep = deps.sleep ?? ((ms) => new Promise(r => { setTimeout(r, ms); }));
     const stampPath = join(lockPath, 'ts');
+    const ownerPath = join(lockPath, 'owner.json');
+    const token = randomUUID();
     mkdirSync(dirname(lockPath), { recursive: true });
     for (let waited = 0;;) {
+        const claimPath = `${lockPath}.claim.${process.pid}.${randomUUID()}`;
         try {
-            mkdirSync(lockPath);
-            writeFileSync(stampPath, String(now()));
+            mkdirSync(claimPath);
+            writeFileSync(join(claimPath, 'ts'), String(now()));
+            writeFileSync(join(claimPath, 'owner.json'), JSON.stringify({ token, pid: process.pid }));
+            await deps.beforePublish?.();
+            renameSync(claimPath, lockPath);
             break;
         }
         catch (e) {
-            if (e.code !== 'EEXIST')
+            rmSync(claimPath, { recursive: true, force: true });
+            if (!['EEXIST', 'ENOTEMPTY'].includes(e.code ?? ''))
                 throw e;
             let held = null;
             try {
@@ -31,7 +38,19 @@ export async function withFileLock(lockPath, fn, deps = {}, staleMs = DEFAULT_ST
                 held = Number.isFinite(n) ? n : null;
             }
             catch { /* holder died between mkdir and stamp */ }
-            if ((held !== null && now() - held > staleMs) || waited > staleMs * 2) {
+            let ownerAlive = false;
+            try {
+                const owner = JSON.parse(readFileSync(ownerPath, 'utf8'));
+                if (typeof owner.pid === 'number') {
+                    try {
+                        process.kill(owner.pid, 0);
+                        ownerAlive = true;
+                    }
+                    catch { /* dead owner */ }
+                }
+            }
+            catch { /* legacy or incomplete lock */ }
+            if (!ownerAlive && ((held !== null && now() - held > staleMs) || waited > staleMs * 2)) {
                 rmSync(lockPath, { recursive: true, force: true }); // break a dead holder's lock
                 continue;
             }
@@ -43,7 +62,12 @@ export async function withFileLock(lockPath, fn, deps = {}, staleMs = DEFAULT_ST
         return await fn();
     }
     finally {
-        rmSync(lockPath, { recursive: true, force: true });
+        try {
+            const owner = JSON.parse(readFileSync(ownerPath, 'utf8'));
+            if (owner.token === token)
+                rmSync(lockPath, { recursive: true, force: true });
+        }
+        catch { /* never remove a lock whose ownership cannot be proved */ }
     }
 }
 /**

package/dist/briefing.js

@@ -190,9 +190,6 @@ export function generateBriefing(role, v, opts) {
         L.push(`7. Await messages. When the monitor wakes you (or the owner requests a manual check),`);
         L.push(`   call **${v.getMessagesTool}**, act on them,`);
         L.push(`   and reply with ${v.sendTool}. No coordinator is configured — the owner drives you`);
-        // NOT `tmux attach -t <name>`: each role's pane lives on its own tmux
-        // socket (#32), so a bare attach finds no server. `ours-fleet attach`
-        // addresses the right one.
         L.push(`   via \`ours-fleet attach ${role.name}\` or by messaging "${id}".`);
     }
     if (role.oversee?.length) {
@@ -221,7 +218,7 @@ export function generateBriefing(role, v, opts) {
         L.push('idle or stalled from `readiness=idle` alone.');
         L.push('');
         L.push('Then judge the console content: stuck on a prompt/menu/trust dialog → answer it directly');
-        L.push('with `ours-fleet send <Name> "<text>"` (or `--key <K>` for raw keys); idle with work');
+        L.push('with `ours-fleet send <Name> "<text>"`; idle with work');
         L.push('assigned → nudge; actively working → do nothing, and do not mistake a long turn for a');
         L.push('stall. Escalate over ours messaging only when you cannot resolve it yourself.');
     }

package/dist/build-info.json

@@ -1,9 +1,9 @@
 {
-  "version": "1.0.4",
-  "buildId": "0891be00930f",
-  "commit": "4f7c7292736219d27e8949442478996191cc2b54",
-  "dirty": false,
-  "builtAt": "2026-08-26T06:30:09.239Z",
+  "version": "1.1.0-nightly.1",
+  "buildId": "bf3c406ba57c",
+  "commit": "10d6da8bfd9903d216bce80a9ef89a42c282f8d9",
+  "dirty": true,
+  "builtAt": "2026-08-30T07:44:27.551Z",
   "capabilities": [
     "monitor.interrupt.after_tool"
   ]

package/dist/cli.js

@@ -11,7 +11,6 @@ import { agentDir, agentsRoot, tmpRoot, logsRoot, deriveXdgRuntimeDir } from './
 import { findRole, loadConfig } from './config.js';
 import { formatDuration } from './duration.js';
 import { resolvedPlan } from './resolved-plan.js';
-import { Tmux, tmuxArgs } from './tmux.js';
 import { pickBackend } from './supervisor/index.js';
 import { up, down } from './ops.js';
 import { readRestartLedger, runSupervised, runTemp } from './runner.js';
@@ -74,7 +73,7 @@ const passthrough = (cmd, args) => new Promise(resolve => {
 });
 const program = new Command()
     .name('ours-fleet')
-    .description('Fleet of persistent, identity-bound AI agents — selectable harness and tmux/ACP sessions.')
+    .description('Fleet of persistent, identity-bound AI agents — selectable harnesses over ACP sessions.')
     .enablePositionalOptions()
     .version(VERSION);
 const cOpt = (cmd) => cmd.option('-c, --configuration <file>', 'config file (default: ~/fleet.yaml + ~/fleet.d/)');
@@ -369,15 +368,11 @@ cOpt(program.command('force-restart [names...]').description('re-sync + bounce F
 });
 program.command('ls').description('list running fleet sessions')
     .action(async () => {
-    // Each session has its own tmux server (#32), so there is no single server
-    // to ask: the known role names ARE the list of servers to poll.
-    const names = [];
     const acp = [];
     for (const root of [agentsRoot(), tmpRoot()]) {
         if (!existsSync(root))
             continue;
         for (const name of readdirSync(root)) {
-            names.push(name);
             const stateDir = joinPath(root, name);
             if (!existsSync(controlSocketPath(stateDir)))
                 continue;
@@ -395,14 +390,13 @@ program.command('ls').description('list running fleet sessions')
             catch { /* ignore stale sockets */ }
         }
     }
-    const tmux = await new Tmux().list(names);
-    console.log([tmux, ...acp].filter(Boolean).join('\n') || '(none)');
+    console.log(acp.join('\n') || '(none)');
 });
 program.command('attach <name>').description('open the live console (Ctrl-b d to leave)')
     .action(async (name) => {
     const stateDir = acpStateDir(name);
     if (!stateDir)
-        process.exit(await passthrough('tmux', tmuxArgs(name, ['attach', '-t', name])));
+        throw new SessionControlError('offline', 'agent session is offline');
     try {
         const { socket, send } = await followControl(stateDir, message => {
             if ('event' in message)
@@ -439,7 +433,7 @@ program.command('attach <name>').description('open the live console (Ctrl-b d to
         die(e);
     }
 });
-/** Classify a raw tmux failure: only "no such session" proves the pane is gone. */
+/** Preserve typed control failures and classify only definite missing-session errors as offline. */
 const asControlError = (e) => {
     if (e instanceof SessionControlError)
         return e;
@@ -467,23 +461,17 @@ program.command('peek <name> [lines]').description('pane snapshot without attach
             for (const event of events.slice(-(lines ? Number(lines) : 40)))
                 renderSessionEvent(event);
         }
-        else {
-            console.log(await new Tmux().capture(name, lines ? Number(lines) : 40));
-        }
+        else
+            throw new SessionControlError('offline', 'agent session is offline');
     }
     catch (e) {
         die(controlFailure(name, 'peek', e));
     }
 });
 program.command('send <name> [text...]').description("type into the agent's console")
-    .option('--key <key>', 'send a raw key instead (Escape, Up, C-c, ...)')
     .action(async (name, text, opts) => {
     const stateDir = acpStateDir(name);
-    if (stateDir && opts.key)
-        die('--key is available only for tmux sessions');
-    if (!stateDir && !opts.key && !text?.length)
-        die('nothing to send: give text or --key');
-    if (stateDir && !text?.length)
+    if (!text?.length)
         die('nothing to send: give text');
     try {
         if (stateDir) {
@@ -496,10 +484,8 @@ program.command('send <name> [text...]').description("type into the agent's cons
                 ? `queued for ${name} behind ${queued.queuedBehind} running turn(s)`
                 : `queued for ${name}`);
         }
-        else if (opts.key)
-            await new Tmux().sendKey(name, opts.key);
         else
-            await new Tmux().sendText(name, text.join(' '));
+            throw new SessionControlError('offline', 'agent session is offline');
     }
     catch (e) {
         die(controlFailure(name, 'send', e, asControlError(e).kind === 'timeout'
@@ -1126,7 +1112,7 @@ cOpt(program.command('spawn [name]').description('spawn a new agent (permanent b
     .option('--role <name>', 'role name (alternative to the positional name)')
     .option('--temp', 'temporary: independent transient supervisor, archived on retirement, gone on reboot')
     .option('--harness <id>', 'harness adapter (default: defaults.harness)')
-    .option('--session <backend>', 'session backend: tmux|acp (default: defaults.session or tmux)')
+    .option('--session <backend>', 'session backend: acp (default: acp)')
     .option('--mission <text>', 'one-line mission')
     .option('--mission-file <path>', 'UTF-8 mission text (mutually exclusive with --mission)')
     .option('--identity <name>', 'ours identity to bind (default: role name)')

package/dist/config.d.ts

@@ -25,7 +25,7 @@ export declare const NOTIFY_EVENT_TYPES: readonly ["message_received", "file_rec
 export type NotifyEventType = (typeof NOTIFY_EVENT_TYPES)[number];
 export type InjectMode = 'notification' | 'full';
 export type MonitorMode = 'fleet' | 'native';
-export type SessionBackendId = 'tmux' | 'acp';
+export type SessionBackendId = 'acp';
 /** Public, harness-neutral permission policy. */
 export type FleetPermissionMode = 'ask' | 'auto' | 'allow';
 /** `deny` is a deprecated, fail-closed compatibility alias retained for old fleet files. */
@@ -44,9 +44,6 @@ export interface SessionOptions {
         /** ACP agent command and arguments. Defaults are supplied by the harness adapter. */
         command?: string | string[];
     };
-    tmux?: {
-        boot_grace_ms?: number;
-    };
 }
 /** Resolved per-role supervisor-monitor config. */
 export interface MonitorConfig {
@@ -93,12 +90,14 @@ export interface OwnerAttachmentConfig {
     max_file_bytes: number;
     max_request_bytes: number;
     retention_ms: number;
-    allowed_mime: string[];
 }
+type OwnerAttachmentConfigInput = Partial<OwnerAttachmentConfig> & {
+    /** @deprecated Accepted only so existing configs keep loading; ignored. */
+    allowed_mime?: unknown;
+};
 export type OwnerChannelConfigInput = Omit<Partial<OwnerChannelConfig>, 'attachments'> & {
-    attachments?: Partial<OwnerAttachmentConfig>;
+    attachments?: OwnerAttachmentConfigInput;
 };
-export declare const DEFAULT_OWNER_ATTACHMENT_MIME: readonly ["application/pdf", "application/json", "text/plain", "image/png", "image/jpeg", "image/gif", "image/webp", "audio/ogg", "audio/mpeg", "audio/wav", "audio/x-wav", "audio/mp4", "audio/webm", "application/msword", "application/vnd.ms-excel", "application/vnd.ms-powerpoint", "application/vnd.openxmlformats-officedocument.wordprocessingml.document", "application/vnd.openxmlformats-officedocument.spreadsheetml.sheet", "application/vnd.openxmlformats-officedocument.presentationml.presentation"];
 /** Default wake sources when a role does not list its own. */
 export declare const DEFAULT_WAKE_SOURCES: NotifyEventType[];
 /**
@@ -236,3 +235,4 @@ export declare function resolveMonitorConfig(defMonitor: unknown, roleMonitor?:
     name?: string;
 }): MonitorConfig;
 export declare function findRole(cfg: FleetConfig, name: string): ResolvedRole;
+export {};

package/dist/config.js

@@ -21,15 +21,6 @@ export const NOTIFY_EVENT_TYPES = [
     'message_received', 'file_received', 'sibling_contact_added', 'local_contact_request',
     'pending_message', 'contact_restored', 'inbound_error', 'state_import_failed',
 ];
-export const DEFAULT_OWNER_ATTACHMENT_MIME = [
-    'application/pdf', 'application/json', 'text/plain',
-    'image/png', 'image/jpeg', 'image/gif', 'image/webp',
-    'audio/ogg', 'audio/mpeg', 'audio/wav', 'audio/x-wav', 'audio/mp4', 'audio/webm',
-    'application/msword', 'application/vnd.ms-excel', 'application/vnd.ms-powerpoint',
-    'application/vnd.openxmlformats-officedocument.wordprocessingml.document',
-    'application/vnd.openxmlformats-officedocument.spreadsheetml.sheet',
-    'application/vnd.openxmlformats-officedocument.presentationml.presentation',
-];
 /** Default wake sources when a role does not list its own. */
 export const DEFAULT_WAKE_SOURCES = ['message_received', 'file_received', 'local_contact_request', 'pending_message'];
 const MONITOR_KEYS = [
@@ -410,13 +401,6 @@ export function resolveOwnerChannelConfig(defaults, role, session, file = 'confi
     const maxRequestBytes = attachments.max_request_bytes ?? 20 * 1024 * 1024;
     if (maxRequestBytes < maxFileBytes)
         throw new ConfigError(`${file}: role '${name}' owner_channel.attachments.max_request_bytes must be at least max_file_bytes`);
-    const allowedMime = attachments.allowed_mime ?? [...DEFAULT_OWNER_ATTACHMENT_MIME];
-    if (!Array.isArray(allowedMime) || allowedMime.length < 1 || allowedMime.length > 64
-        || allowedMime.some(mime => typeof mime !== 'string'
-            || !/^[a-z0-9][a-z0-9!#$&^_.+-]*\/[a-z0-9][a-z0-9!#$&^_.+-]*$/.test(mime)))
-        throw new ConfigError(`${file}: role '${name}' owner_channel.attachments.allowed_mime must contain 1-64 lowercase MIME types`);
-    if (new Set(allowedMime).size !== allowedMime.length)
-        throw new ConfigError(`${file}: role '${name}' owner_channel.attachments.allowed_mime must not contain duplicates`);
     if (session !== 'acp')
         throw new ConfigError(`${file}: role '${name}' owner_channel requires session: acp for correlated final replies`);
     return {
@@ -434,7 +418,6 @@ export function resolveOwnerChannelConfig(defaults, role, session, file = 'confi
             max_file_bytes: maxFileBytes,
             max_request_bytes: maxRequestBytes,
             retention_ms: attachments.retention_ms ?? 24 * 60 * 60 * 1_000,
-            allowed_mime: [...allowedMime],
         },
     };
 }
@@ -541,9 +524,12 @@ export function resolveWorklogPolicy(defaults, role, file = 'config', name = 'ro
     return merged;
 }
 function resolveSession(raw, file, name) {
-    const value = raw ?? 'tmux';
-    if (value !== 'tmux' && value !== 'acp')
-        throw new ConfigError(`${file}: role '${name}' session: must be one of: tmux, acp`);
+    const value = raw ?? 'acp';
+    if (value === 'tmux')
+        throw new ConfigError(`${file}: role '${name}' session: tmux is no longer supported; use session: acp `
+            + 'with the Codex or Claude Code adapter');
+    if (value !== 'acp')
+        throw new ConfigError(`${file}: role '${name}' session: must be: acp`);
     return value;
 }
 function resolveSessionOptions(defaults, role, session, file, name) {
@@ -558,33 +544,26 @@ function resolveSessionOptions(defaults, role, session, file, name) {
             ...((defaults?.acp) ?? {}),
             ...(role?.acp ?? {}),
         },
-        tmux: {
-            ...((defaults?.tmux) ?? {}),
-            ...(role?.tmux ?? {}),
-        },
     };
-    const bad = Object.keys(merged).filter(k => k !== 'acp' && k !== 'tmux');
+    if (defaults?.tmux !== undefined
+        || role?.tmux !== undefined)
+        throw new ConfigError(`${file}: role '${name}' session_options.tmux is no longer supported; `
+            + 'use session: acp with session_options.acp');
+    const bad = Object.keys(merged).filter(k => k !== 'acp');
     if (bad.length)
         throw new ConfigError(`${file}: role '${name}' session_options: unknown key(s) ${bad.join(', ')}`);
-    if (!isPlainObject(merged.acp) || !isPlainObject(merged.tmux))
+    if (!isPlainObject(merged.acp))
         throw new ConfigError(`${file}: role '${name}' session_options.${session} must be a map`);
     const acpBad = Object.keys(merged.acp).filter(k => k !== 'command');
-    const tmuxBad = Object.keys(merged.tmux).filter(k => k !== 'boot_grace_ms');
     if (acpBad.length)
         throw new ConfigError(`${file}: role '${name}' session_options.acp: unknown key(s) ${acpBad.join(', ')}`);
-    if (tmuxBad.length)
-        throw new ConfigError(`${file}: role '${name}' session_options.tmux: unknown key(s) ${tmuxBad.join(', ')}`);
     const command = merged.acp.command;
     if (command !== undefined
         && !(typeof command === 'string' && command.trim())
         && !(Array.isArray(command) && command.length > 0
             && command.every(v => typeof v === 'string' && v.length > 0)))
         throw new ConfigError(`${file}: role '${name}' session_options.acp.command must be a non-empty string or string list`);
-    const grace = merged.tmux.boot_grace_ms;
-    if (grace !== undefined
-        && (typeof grace !== 'number' || !Number.isFinite(grace) || grace < 0))
-        throw new ConfigError(`${file}: role '${name}' session_options.tmux.boot_grace_ms must be a non-negative number`);
-    return Object.keys(merged.acp).length || Object.keys(merged.tmux).length ? merged : undefined;
+    return Object.keys(merged.acp).length ? merged : undefined;
 }
 export function resolvePermissions(defaults, role, file = 'config', name = 'role') {
     if (defaults !== undefined && !isPlainObject(defaults))