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

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/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,7 @@ 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 { readDaemonRecoveryStatus } from '../daemon-recovery.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);
@@ -47,10 +47,11 @@ function readIsolation(dir) {
 function sessionOverall(supervisor, session, restart, monitor, isolation, problems) {
     if (restart.circuit === 'open' || monitor.health === 'failed' || monitor.health === 'degraded'
         || isolation.degraded
-        || problems.some(problem => problem.severity === 'error' || problem.source === 'watchdog')
+        || problems.some(problem => problem.severity === 'error'
+            || problem.source === 'watchdog' || problem.source === 'daemon-recovery')
         || 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 +70,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() {
@@ -106,6 +105,16 @@ export class FleetQueryService {
         const lastExit = dir ? readExitRecord(join(dir, '.exit-status')) ?? undefined : undefined;
         const session = await this.session(role, dir, live.state);
         const problems = [...role.problems];
+        const recovery = dir ? readDaemonRecoveryStatus(dir) : undefined;
+        if (recovery && recovery.state !== 'recovered') {
+            const paths = ['agent', 'owner']
+                .filter(name => recovery.paths[name].state !== 'recovered')
+                .map(name => `${name}:${recovery.paths[name].state}`);
+            problems.push({
+                code: 'daemon_recovery', severity: 'warning', source: 'daemon-recovery',
+                detail: `${recovery.state}; ${paths.join(', ') || 'no degraded path'}; epoch ${recovery.epoch || 'unavailable'}`,
+            });
+        }
         if (live.state === 'running' && session.reachability !== 'online')
             problems.push({
                 code: 'supervisor_session_disagreement', severity: 'warning',
@@ -174,26 +183,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

@@ -5,21 +5,14 @@ import type { OpsDeps } from '../ops.js';
 import type { ResolvedRole } from '../config.js';
 import { FleetError } from './errors.js';
 import { type ManagedFleetSpawnResult } from '../fleet-proxy.js';
-import { type HarnessModelCatalog, type HarnessModelOption } from './model-catalog.js';
 export interface CreateRoleSessionRequest {
     name: string;
-    harness: 'codex' | 'claude-code';
-    /** null means the selected harness's own default; web blank fields send null. */
-    model?: string | null;
-    reasoningEffort?: string | null;
-    session: 'acp' | 'tmux';
+    brain: import('../config.js').AgentSelection;
+    role: import('../config.js').AgentSelection;
     cwd?: string;
     lifetime: 'permanent' | 'temporary';
-    mission?: string;
     coordinator?: string;
     permissions: CommonPermissions;
-    bio?: string;
-    persona?: string;
     monitor?: WebCreationMonitor;
     openAfterCreate: boolean;
     highRiskAcknowledged?: boolean;
@@ -38,17 +31,6 @@ export type WebCreationMonitor = {
 export interface CreationCapabilities {
     available: boolean;
     reasons: string[];
-    harnesses: Array<{
-        id: 'codex' | 'claude-code';
-        available: boolean;
-        sessions: Array<'acp' | 'tmux'>;
-        defaultModel?: string;
-        models: string[];
-        modelOptions: HarnessModelOption[];
-        catalogSource: string;
-        customModelAllowed: true;
-        warnings: string[];
-    }>;
     lifetimes: Array<'permanent' | 'temporary'>;
     identityBootstrap: {
         mode: 'current-fleet-first-boot';
@@ -71,7 +53,7 @@ export interface CreationPreview {
         name: string;
         identity: string;
         harness: string;
-        session: 'acp' | 'tmux';
+        session: 'acp';
         model?: string;
         reasoningEffort?: string;
         cwd?: string;
@@ -95,7 +77,7 @@ export interface CreationAction {
     actionId: string;
     requestHash: string;
     roleId: string;
-    session: 'acp' | 'tmux';
+    session: 'acp';
     lifetime: 'permanent' | 'temporary';
     state: CreationStage;
     stages: Array<{
@@ -121,9 +103,8 @@ 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. */
     journal?: boolean;
 }

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

@@ -1,16 +1,15 @@
 import { createHash, randomUUID } from 'node:crypto';
 import { mkdirSync, readFileSync, readdirSync, realpathSync, statSync } from 'node:fs';
 import { isAbsolute, relative } from 'node:path';
-import { loadConfig, NOTIFY_EVENT_TYPES, resolveMonitorConfig, resolveRoleModel, resolvePermissions, ROLE_NAME_RE, validateMonitorConfig, } from '../config.js';
+import { loadConfig, NOTIFY_EVENT_TYPES, resolveMonitorConfig, resolvePermissions, ROLE_NAME_RE, validateMonitorConfig, } from '../config.js';
 import { daemonIdentityProvisioner, } from '../creation.js';
 import { replaceFileAtomically } from '../atomic-file.js';
 import { stateRoot } from '../paths.js';
-import { buildRoleConfig, spawnDryRun, spawnPermanent, spawnTemp, validateSpawnOpts, } from '../spawn.js';
+import { spawnDryRun, spawnPermanent, spawnTemp, validateSpawnOpts, } from '../spawn.js';
 import { FleetError, normalizeError } from './errors.js';
 import { inheritCallerSpawnDefaults } from '../fleet-proxy.js';
 import { effectivePermissionMode } from '../permissions.js';
 import { effectiveRoleModel } from '../model-env.js';
-import { claudeModelCatalog, codexModelCatalog, } from './model-catalog.js';
 const canonical = (value) => {
     if (Array.isArray(value))
         return `[${value.map(canonical).join(',')}]`;
@@ -62,6 +61,16 @@ export class RoleCreationService {
         const creationActionId = randomUUID();
         plan.options.creationActionId = creationActionId;
         const statePath = await this.launchSync(plan.options);
+        const selectionSummary = (kind) => {
+            const value = plan.options[kind];
+            const provenance = plan.inherited.includes(kind) ? 'inherited' : 'explicit';
+            if (!value)
+                return `unresolved (${provenance})`;
+            if ('ref' in value)
+                return `ref:${value.ref} (${provenance})`;
+            const fingerprint = hash(value.inline).slice(0, 16);
+            return `inline:sha256:${fingerprint} (${provenance})`;
+        };
         return {
             caller: plan.caller, role: plan.options.name,
             lifetime: plan.options.temp ? 'temporary' : 'permanent', statePath,
@@ -70,6 +79,7 @@ export class RoleCreationService {
             monitor: { mode: plan.preview.resolvedRole.monitor.mode, interrupt: plan.preview.resolvedRole.monitor.interrupt },
             permissionMode: effectivePermissionMode(plan.preview.resolvedRole), inherited: plan.inherited,
             creationActionId,
+            brainSummary: selectionSummary('brain'), roleSummary: selectionSummary('role'),
         };
     }
     launchSync(options, creation) {
@@ -80,47 +90,16 @@ export class RoleCreationService {
     async capabilities() {
         const reasons = [];
         let defaults = {};
-        let roles = [];
         try {
             const config = loadConfig(this.options.configPath);
             defaults = config.defaults;
-            roles = config.roles;
         }
         catch (error) {
             reasons.push(`configuration is invalid: ${error.message}`);
         }
-        const modelsFor = (harness, catalog) => {
-            const configured = roles.filter(role => role.harness === harness)
-                .flatMap(role => [role.model, ...(role.model_chain ?? [])])
-                .filter((model) => Boolean(model));
-            const inherited = resolveRoleModel(undefined, harness, defaults);
-            const configuredOptions = [...new Set([...(inherited ? [inherited] : []), ...configured])]
-                .filter(id => !catalog.models.some(model => model.id === id))
-                .map(id => ({ id, label: `${id} (configured)`, reasoningEfforts: [], source: 'fleet-config' }));
-            const modelOptions = [...configuredOptions, ...catalog.models];
-            return { modelOptions, models: modelOptions.map(model => model.id) };
-        };
-        const codexCatalog = this.options.modelCatalogs?.codex?.() ?? codexModelCatalog();
-        const claudeCatalog = this.options.modelCatalogs?.['claude-code']?.() ?? claudeModelCatalog();
-        const codexModels = modelsFor('codex', codexCatalog);
-        const claudeModels = modelsFor('claude-code', claudeCatalog);
         return {
             available: reasons.length === 0,
             reasons,
-            harnesses: [
-                {
-                    id: 'codex', available: true, sessions: ['acp', 'tmux'],
-                    defaultModel: resolveRoleModel(undefined, 'codex', defaults),
-                    ...codexModels, catalogSource: 'codex-runtime-catalog', customModelAllowed: true,
-                    warnings: codexCatalog.warnings,
-                },
-                {
-                    id: 'claude-code', available: true, sessions: ['acp', 'tmux'],
-                    defaultModel: resolveRoleModel(undefined, 'claude-code', defaults),
-                    ...claudeModels, catalogSource: 'claude-adapter-2.1', customModelAllowed: true,
-                    warnings: claudeCatalog.warnings,
-                },
-            ],
             lifetimes: ['permanent', 'temporary'],
             identityBootstrap: {
                 mode: 'current-fleet-first-boot',
@@ -144,14 +123,12 @@ export class RoleCreationService {
         const defaults = cfg.defaults;
         const opts = this.spawnOptions(request);
         validateSpawnOpts(opts);
-        buildRoleConfig(opts, defaults.harness);
+        const resolved = spawnDryRun(opts).resolvedRole;
         const cwd = request.cwd ? this.resolveCwd(request.cwd) : undefined;
         const effective = {
             name: request.name, identity: request.name,
-            harness: request.harness ?? defaults.harness ?? 'claude-code',
-            session: request.session ?? defaults.session ?? 'tmux',
-            model: resolveRoleModel(request.model, request.harness, defaults),
-            reasoningEffort: request.reasoningEffort ?? undefined,
+            harness: resolved.harness, session: resolved.session, model: resolved.model,
+            reasoningEffort: resolved.effort,
             cwd, lifetime: request.lifetime,
             permissions: resolvePermissions(defaults.permissions, request.permissions),
             monitor: resolveMonitorConfig(defaults.monitor, request.monitor),
@@ -183,9 +160,7 @@ export class RoleCreationService {
         if (existingIdentity === 'unknown' && !request.unverifiedIdentityAcknowledged)
             prerequisites.push('confirm creation with an unverified identity preflight');
         const provenance = {
-            harness: 'request', session: 'request', identity: 'built-in',
-            model: request.model !== undefined ? 'request'
-                : resolveRoleModel(undefined, request.harness, defaults) ? 'fleet-default' : 'built-in',
+            brain: 'request', role: 'request', identity: 'built-in',
             cwd: request.cwd ? 'request' : 'built-in', permissions: 'request',
             monitor: request.monitor ? 'request' : defaults.monitor ? 'fleet-default' : 'built-in',
         };
@@ -264,9 +239,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') {
@@ -298,8 +271,8 @@ export class RoleCreationService {
     }
     validate(input) {
         const allowed = new Set([
-            'name', 'harness', 'model', 'reasoningEffort', 'session', 'cwd', 'lifetime', 'mission',
-            'coordinator', 'permissions', 'bio', 'persona', 'monitor', 'openAfterCreate',
+            'name', 'brain', 'role', 'cwd', 'lifetime',
+            'coordinator', 'permissions', 'monitor', 'openAfterCreate',
             'highRiskAcknowledged', 'reuseExistingIdentityAcknowledged',
             'unverifiedIdentityAcknowledged',
         ]);
@@ -309,20 +282,11 @@ export class RoleCreationService {
             throw new FleetError('invalid_request', `unsupported web creation field: ${unsupported[0]}`);
         if (!ROLE_NAME_RE.test(input.name))
             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))
-            throw new FleetError('invalid_request', 'unsupported session backend');
+        if (!input.brain || !input.role)
+            throw new FleetError('invalid_request', 'brain and role selections are required');
         if (!['permanent', 'temporary'].includes(input.lifetime))
             throw new FleetError('invalid_request', 'unsupported lifetime');
-        bounded(input.model ?? undefined, 'model', 128);
-        bounded(input.reasoningEffort ?? undefined, 'reasoning effort', 16);
-        if (input.reasoningEffort != null && !['low', 'medium', 'high', 'xhigh', 'max', 'ultra'].includes(input.reasoningEffort))
-            throw new FleetError('invalid_request', 'unsupported reasoning effort');
-        bounded(input.mission, 'mission', 4_096);
         bounded(input.coordinator, 'coordinator', 128);
-        bounded(input.bio, 'bio', 8_192);
-        bounded(input.persona, 'persona', 16_384);
         resolvePermissions(undefined, input.permissions);
         if (input.monitor) {
             const problems = validateMonitorConfig(input.monitor);
@@ -332,10 +296,8 @@ export class RoleCreationService {
                 throw new FleetError('invalid_request', 'web creation supports monitor.inject=notification only');
         }
         return {
-            ...input, model: input.model === null ? null : input.model?.trim() || undefined,
-            reasoningEffort: input.reasoningEffort === null ? null : input.reasoningEffort?.trim() || undefined,
-            mission: input.mission?.trim() || undefined, coordinator: input.coordinator?.trim() || undefined,
-            bio: input.bio?.trim() || undefined, persona: input.persona?.trim() || undefined,
+            ...input, brain: structuredClone(input.brain), role: structuredClone(input.role),
+            coordinator: input.coordinator?.trim() || undefined,
             monitor: input.monitor ? structuredClone(input.monitor) : undefined,
         };
     }
@@ -362,12 +324,10 @@ export class RoleCreationService {
     spawnOptions(request, creationActionId) {
         return {
             name: request.name, temp: request.lifetime === 'temporary',
-            identity: request.name, harness: request.harness,
-            model: request.model, session: request.session, cwd: request.cwd,
-            reasoningEffort: request.reasoningEffort,
-            mission: request.mission, coordinator: request.coordinator,
+            identity: request.name, brain: request.brain, role: request.role, cwd: request.cwd,
+            coordinator: request.coordinator,
             approval: request.permissions.approval, filesystem: request.permissions.filesystem,
-            unattended: request.permissions.unattended, bio: request.bio, persona: request.persona,
+            unattended: request.permissions.unattended,
             monitorConfig: request.monitor,
             configPath: this.options.configPath,
             surface: creationActionId ? 'web' : undefined, creationActionId,

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

@@ -4,6 +4,7 @@ import { loadConfig, ROLE_NAME_RE } from '../config.js';
 import { agentDir, stateRoot } from '../paths.js';
 import { rmRole } from '../ops.js';
 import { FleetError } from './errors.js';
+import { provesGeneratedAgentSource } from '../generated-agent-source.js';
 export class RoleRemovalService {
     options;
     constructor(options) {
@@ -45,8 +46,9 @@ export class RoleRemovalService {
             `Stop and uninstall the exact backend registration for '${requested}'.`,
             `Archive then remove ${lifetime === 'temporary' ? temporaryState : permanentState}.`,
         ];
-        if (role?.sourceFile.includes('/fleet.d/'))
-            effects.push(`Remove spawned configuration ${role.sourceFile}.`);
+        const generatedSource = role && provesGeneratedAgentSource(agentDir(requested), cfg.files[0], role.sourceFile);
+        if (generatedSource)
+            effects.push(`Remove generated Agent configuration ${role.sourceFile}.`);
         else if (role)
             effects.push(`Keep hand-written configuration ${role.sourceFile}; the role can be recreated from it.`);
         else
@@ -76,7 +78,8 @@ export class RoleRemovalService {
         mkdirSync(recoveryPath, { recursive: true, mode: 0o700 });
         if (existsSync(sourceState))
             cpSync(sourceState, join(recoveryPath, 'state'), { recursive: true });
-        if (role?.sourceFile.includes('/fleet.d/') && existsSync(role.sourceFile))
+        if (role && provesGeneratedAgentSource(agentDir(preview.role), cfg.files[0], role.sourceFile)
+            && existsSync(role.sourceFile))
             cpSync(role.sourceFile, join(recoveryPath, basename(role.sourceFile)));
         if (role || preview.lifetime === 'temporary')
             await rmRole(cfg, preview.role, this.options.ops);

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;

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

@@ -179,7 +179,7 @@ export declare class TaskRoomApplicationService {
         name: string;
         version: number;
         description: string;
-        builtin?: boolean;
+        sourceFile?: string;
         room?: import("../rooms-tasks/types.js").TemplateRoomConfig;
         contract?: string;
         members: import("../rooms-tasks/types.js").TemplateMemberSlot[];