@ours.network/fleet 1.1.0-nightly.2 → 1.1.0-nightly.21

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

@@ -4,6 +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 { 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);
@@ -46,7 +47,8 @@ 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 agent session is the user's live interaction surface. Its
@@ -74,7 +76,8 @@ export class FleetQueryService {
         this.control = options.control ?? controlRequest;
     }
     async list() {
-        const roles = await this.options.repository.list();
+        const roles = (await this.options.repository.list())
+            .filter(role => role.configured && role.lifetime === 'permanent');
         return Promise.all(roles.map(async (role) => {
             const status = await this.status(role);
             return { role, status, capabilities: roleCapabilities(role, status, this.options.capabilityContext) };
@@ -103,6 +106,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',
@@ -141,14 +154,16 @@ export class FleetQueryService {
     }
     async session(role, dir, supervisor) {
         const intended = role.configuredBackend;
-        if (intended === 'acp' && dir) {
+        if (intended && dir) {
             try {
                 const response = await this.control(dir, { command: 'snapshot' }, 2_000);
                 if (!response.ok)
                     throw new SessionControlError(response.kind ?? 'backend', response.error ?? 'snapshot failed');
                 const snapshot = response.result;
+                if (snapshot.backend !== intended)
+                    throw new SessionControlError('backend', `live session reports backend '${String(snapshot.backend)}', expected '${intended}'`);
                 return {
-                    backend: 'acp', reachability: snapshot.alive ? 'online' : 'offline',
+                    backend: intended, reachability: snapshot.alive ? 'online' : 'offline',
                     readiness: snapshot.readiness, evidence: 'authoritative',
                     sessionId: snapshot.sessionId, lastError: snapshot.lastError,
                     pendingPermissionId: snapshot.pendingPermissionId,
@@ -162,7 +177,7 @@ export class FleetQueryService {
                 const failure = error instanceof SessionControlError ? error.kind : 'backend';
                 const offline = failure === 'offline';
                 return {
-                    backend: 'acp',
+                    backend: intended,
                     reachability: offline ? 'offline'
                         : failure === 'control-unavailable' ? 'unavailable' : 'unknown',
                     readiness: offline ? 'failed' : 'unknown',

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

@@ -12,6 +12,10 @@ export class RoleLifecycleService {
         const config = input.config ?? loadConfig(this.options.configPath);
         const selected = input.roleIds.length ? input.roleIds : config.roles.map(role => role.name);
         for (const roleId of selected) {
+            if (config.agentTemplates?.[roleId] && !config.roles.some(role => role.name === roleId))
+                throw new FleetError('capability_unavailable', `'${roleId}' is an inert Agent Template; lifecycle commands target only persistent fleet/agents instances`);
+            if (!config.roles.some(role => role.name === roleId))
+                throw new FleetError('role_not_found', `no such role '${roleId}'`);
             const role = await this.options.repository.get(roleId);
             if (!role)
                 throw new FleetError('role_not_found', `no such role '${roleId}'`);
@@ -51,6 +55,11 @@ export class RoleCommandService {
                 throw new FleetError('idempotency_conflict', 'action ID already belongs to another operation');
             return prior;
         }
+        const config = loadConfig(this.options.configPath);
+        if (config.agentTemplates?.[input.roleId] && !config.roles.some(role => role.name === input.roleId))
+            throw new FleetError('capability_unavailable', `'${input.roleId}' is an inert Agent Template; lifecycle commands target only persistent fleet/agents instances`);
+        if (!config.roles.some(role => role.name === input.roleId))
+            throw new FleetError('role_not_found', `no such role '${input.roleId}'`);
         const role = await this.options.repository.get(input.roleId);
         if (!role)
             throw new FleetError('role_not_found', `no such role '${input.roleId}'`);

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

@@ -1,25 +1,18 @@
-import { type CommonPermissions, type MonitorConfig, type MonitorInterrupt, type NotifyEventType } from '../config.js';
+import { type CommonPermissions, type MonitorConfig, type MonitorInterrupt, type NotifyEventType, type SessionBackendId } from '../config.js';
 import { type IdentityProvisioner } from '../creation.js';
 import { spawnDryRun, type SpawnOpts, type SupervisorLauncher } from '../spawn.js';
 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';
+    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'>;
-        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';
+        session: SessionBackendId;
         model?: string;
         reasoningEffort?: string;
         cwd?: string;
@@ -95,7 +77,7 @@ export interface CreationAction {
     actionId: string;
     requestHash: string;
     roleId: string;
-    session: 'acp';
+    session: SessionBackendId;
     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') => Promise<'ready' | 'attention' | 'unknown'>;
+    probeReady?: (name: string, session: SessionBackendId) => 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,17 +1,16 @@
 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 { getAdapter } from '../harness/registry.js';
-import { claudeModelCatalog, codexModelCatalog, } from './model-catalog.js';
+import { selectionOrigin, summarizeResolvedLaunch } from '../lifecycle-summary.js';
 const canonical = (value) => {
     if (Array.isArray(value))
         return `[${value.map(canonical).join(',')}]`;
@@ -63,14 +62,31 @@ 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})`;
+        };
+        const permissionMode = effectivePermissionMode(plan.preview.resolvedRole);
         return {
             caller: plan.caller, role: plan.options.name,
             lifetime: plan.options.temp ? 'temporary' : 'permanent', statePath,
             harness: plan.preview.resolvedRole.harness, session: plan.preview.resolvedRole.session,
             ...(effectiveRoleModel(plan.preview.resolvedRole) ? { model: effectiveRoleModel(plan.preview.resolvedRole) } : {}),
             monitor: { mode: plan.preview.resolvedRole.monitor.mode, interrupt: plan.preview.resolvedRole.monitor.interrupt },
-            permissionMode: effectivePermissionMode(plan.preview.resolvedRole), inherited: plan.inherited,
+            permissionMode, inherited: plan.inherited,
             creationActionId,
+            brainSummary: selectionSummary('brain'), roleSummary: selectionSummary('role'),
+            configuration: summarizeResolvedLaunch(plan.preview.resolvedRole, {
+                role: selectionOrigin(plan.options.role ?? plan.options.agentDefinition?.role),
+                brain: selectionOrigin(plan.options.brain ?? plan.options.agentDefinition?.brain),
+                permissionMode,
+            }),
         };
     }
     launchSync(options, creation) {
@@ -81,47 +97,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'],
-                    defaultModel: resolveRoleModel(undefined, 'codex', defaults),
-                    ...codexModels, catalogSource: 'codex-runtime-catalog', customModelAllowed: true,
-                    warnings: codexCatalog.warnings,
-                },
-                {
-                    id: 'claude-code', available: true, sessions: ['acp'],
-                    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',
@@ -145,14 +130,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 ?? 'acp',
-            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),
@@ -184,9 +167,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',
         };
@@ -297,8 +278,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',
         ]);
@@ -308,26 +289,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 (input.session !== 'acp')
-            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) {
-            try {
-                getAdapter(input.harness).agentSession.resolveBrain({ effort: input.reasoningEffort });
-            }
-            catch (error) {
-                throw new FleetError('invalid_request', error.message);
-            }
-        }
-        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);
@@ -337,10 +303,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,
         };
     }
@@ -367,12 +331,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-repository.d.ts

@@ -1,10 +1,12 @@
+import { type SessionBackendId } from '../config.js';
 import type { RoleRecord } from './types.js';
 export interface RoleRepositoryOptions {
     configPath?: string;
     permanentRoot?: string;
     temporaryRoot?: string;
-    probeBackend?: (name: string, intended?: 'acp') => Promise<{
-        acp: boolean;
+    probeBackend?: (name: string, intended?: SessionBackendId) => Promise<{
+        acp?: boolean;
+        backend?: SessionBackendId;
     }>;
     concurrency?: number;
     timeoutMs?: number;

package/dist/application/role-repository.js

@@ -44,9 +44,10 @@ function snapshot(path, name) {
             throw new Error('snapshot must be a mapping');
         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';
+        if (raw.session !== undefined && raw.session !== 'acp'
+            && raw.session !== 'codex-app-server')
+            throw new Error(`unsupported session '${String(raw.session)}'; expected session: acp or codex-app-server`);
+        const session = raw.session ?? 'acp';
         return {
             role: {
                 ...raw, name, harness: typeof raw.harness === 'string' ? raw.harness : 'claude-code',
@@ -173,6 +174,8 @@ export class RoleRepository {
             this.options.probeBackend(name, intended),
             new Promise(resolve => setTimeout(() => resolve({ acp: false }), timeoutMs)),
         ]).catch(() => ({ acp: false }));
+        if (result.backend)
+            return result.backend;
         if (result.acp)
             return 'acp';
         return 'none';

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

@@ -71,7 +71,7 @@ export interface RoleSessionControl {
         onClose(reason?: string): void;
     }): Promise<ConversationFollowHandle>;
 }
-export declare class AcpRoleSessionAdapter implements RoleSessionControl {
+export declare class RoleSessionControlAdapter implements RoleSessionControl {
     private readonly stateDir;
     private readonly request;
     constructor(stateDir: string, request?: typeof controlRequest);
@@ -119,3 +119,5 @@ export declare class AcpRoleSessionAdapter implements RoleSessionControl {
     }>;
     private call;
 }
+/** @deprecated Compatibility name; control is provider-neutral. */
+export { RoleSessionControlAdapter as AcpRoleSessionAdapter };

package/dist/application/session-control.js

@@ -1,7 +1,7 @@
 import { controlRequest, followConversation } from '../session/control.js';
 import { FleetError, normalizeError } from './errors.js';
 const visibleEvents = (events) => events.filter(event => event.kind !== 'thought');
-export class AcpRoleSessionAdapter {
+export class RoleSessionControlAdapter {
     stateDir;
     request;
     constructor(stateDir, request = controlRequest) {
@@ -12,7 +12,7 @@ export class AcpRoleSessionAdapter {
         const response = await this.call('snapshot');
         const result = response;
         return {
-            backend: 'acp', protocolVersion: result.protocolVersion ?? 1,
+            backend: result.backend, protocolVersion: result.protocolVersion ?? 1,
             features: result.features ?? [], snapshot: result,
         };
     }
@@ -147,3 +147,5 @@ export class AcpRoleSessionAdapter {
         }
     }
 }
+/** @deprecated Compatibility name; control is provider-neutral. */
+export { RoleSessionControlAdapter as AcpRoleSessionAdapter };

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

@@ -2,7 +2,10 @@ import { type FleetConfig } from '../config.js';
 import { type CoworkAdapter } from '../rooms-tasks/cowork-adapter.js';
 import { provisionMembers } from '../rooms-tasks/provision.js';
 import { moveTaskToList } from '../rooms-tasks/task-state.js';
-import type { RoomOrchestrationRecord, TaskListRecord, TaskOrigin, TaskOutcome, TaskRecord, TaskState } from '../rooms-tasks/types.js';
+import { type MemberOverrides } from '../rooms-tasks/member-overrides.js';
+import { type TaskDeletionSettleResult } from '../rooms-tasks/deletion.js';
+import type { RoomLaunchPolicy, RoomOrchestrationRecord, TaskListRecord, TaskOrigin, TaskOutcome, TaskRecord, TaskState, TemplateSnapshot } from '../rooms-tasks/types.js';
+import type { TaskDeletionAcceptance } from '../rooms-tasks/task-state.js';
 export type TaskRoomActor = {
     kind: 'local_control';
     surface: 'cli' | 'web';
@@ -37,14 +40,17 @@ export interface TaskRecoveryResult {
 export type TaskRecoveryBegin = {
     kind: 'terminal_worker_required';
     taskId: string;
+} | {
+    kind: 'deletion_worker_required';
+    taskId: string;
 } | {
     kind: 'final';
     result: TaskRecoveryResult;
 };
 export declare class TaskRoomApplicationError extends Error {
-    readonly code: 'template_not_found' | 'task_template_drift' | 'template_mismatch' | 'task_terminal' | 'task_terminal_already' | 'task_non_resumable' | 'room_not_found' | 'room_record_not_found';
+    readonly code: 'template_not_found' | 'task_template_drift' | 'template_mismatch' | 'task_terminal' | 'task_terminal_already' | 'task_non_resumable' | 'task_deleting' | 'room_not_found' | 'room_record_not_found';
     readonly fields: Readonly<Record<string, string>>;
-    constructor(code: 'template_not_found' | 'task_template_drift' | 'template_mismatch' | 'task_terminal' | 'task_terminal_already' | 'task_non_resumable' | 'room_not_found' | 'room_record_not_found', message: string, fields?: Readonly<Record<string, string>>);
+    constructor(code: 'template_not_found' | 'task_template_drift' | 'template_mismatch' | 'task_terminal' | 'task_terminal_already' | 'task_non_resumable' | 'task_deleting' | 'room_not_found' | 'room_record_not_found', message: string, fields?: Readonly<Record<string, string>>);
 }
 export interface CreateTaskRequest {
     actor: TaskRoomActor;
@@ -57,6 +63,8 @@ export interface CreateTaskRequest {
     idempotencyKey?: string;
     origin: TaskOrigin;
     list?: string;
+    members?: MemberOverrides;
+    anonymous?: boolean;
 }
 export interface CreateRoomRequest {
     actor: TaskRoomActor;
@@ -65,13 +73,19 @@ export interface CreateRoomRequest {
     goal?: string;
     brief?: string;
     briefFile?: string;
+    members?: MemberOverrides;
+    anonymous?: boolean;
 }
+export declare function resolveRoomLaunchPolicy(template: TemplateSnapshot | undefined, override: boolean | undefined): RoomLaunchPolicy;
 export interface TaskRoomServiceDeps {
     loadConfiguration?(path?: string): FleetConfig;
     cowork?(config: FleetConfig): CoworkAdapter;
     binPath?(): string;
     provisionMembers?: typeof provisionMembers;
     moveTaskToList?: typeof moveTaskToList;
+    launchDeletionWorker?(taskId: string): Promise<void>;
+    sleep?(ms: number): Promise<void>;
+    now?(): number;
 }
 /** Exact extraction of the previously CLI-owned task create/start behavior. */
 export declare class TaskRoomApplicationService {
@@ -84,15 +98,20 @@ export declare class TaskRoomApplicationService {
     startTask(input: {
         actor: TaskRoomActor;
         taskId: string;
+        template?: string;
+        members?: MemberOverrides;
+        anonymous?: boolean;
     }): Promise<TaskRecord>;
     listTasks(filter?: {
         state?: TaskState | TaskState[];
         list?: string;
+        includeDeleting?: boolean;
     }): TaskRecord[];
     listTaskLists(): TaskListRecord[];
     groupedTasks(filter?: {
         state?: TaskState | TaskState[];
         list?: string;
+        includeDeleting?: boolean;
     }): Array<{
         list: TaskListRecord;
         tasks: TaskRecord[];
@@ -137,10 +156,40 @@ export declare class TaskRoomApplicationService {
         actor: TaskRoomActor;
         taskId: string;
     }): TaskRecord;
-    deleteTask(input: {
+    private deletionActor;
+    /** Accept a permanent deletion in any lifecycle state; audit at acceptance. */
+    requestTaskDeletion(input: {
+        actor: TaskRoomActor;
+        taskId: string;
+    }): Promise<TaskDeletionAcceptance>;
+    /** Worker entry: converge an accepted deletion; Cowork is resolved lazily. */
+    settleTaskDeletion(input: {
+        actor: {
+            kind: 'internal_worker';
+            surface: 'cli';
+        };
+        taskId: string;
+    }): Promise<TaskDeletionSettleResult>;
+    /**
+     * Launch the external deletion worker outside the caller's lifecycle and
+     * wait boundedly for physical absence. Timeouts and launch failures report
+     * a pending, recoverable state — never success. A concurrent worker that
+     * already removed the record reads as settled.
+     */
+    launchTaskDeletionWorker(input: {
+        taskId: string;
+        waitMs?: number;
+    }): Promise<{
+        deleted: boolean;
+        pending: boolean;
+        error?: string;
+    }>;
+    recordDeletionError(input: {
         actor: TaskRoomActor;
         taskId: string;
-    }): boolean;
+        error: string;
+        recoveryHint: string;
+    }): Promise<TaskRecord>;
     completeTask(input: {
         actor: TaskRoomActor;
         taskId: string;
@@ -179,7 +228,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[];
@@ -197,6 +246,7 @@ export declare class TaskRoomApplicationService {
         identity_cid: string;
         room_name: string;
         state: "provisioning" | "active" | "closing" | "closed";
+        anonymous: boolean;
         seats: import("../rooms-tasks/cowork-adapter.js").CoworkSeatInfo[];
         goal?: string;
         briefing?: string;
@@ -252,6 +302,8 @@ export declare class TaskRoomApplicationService {
         actor: TaskRoomActor;
         taskId: string;
         template?: string;
+        members?: MemberOverrides;
+        anonymous?: boolean;
     }): Promise<{
         task: TaskRecord;
         status: 'ready' | 'already_active';