@ours.network/fleet 1.1.0-nightly.3 → 1.1.0-nightly.30

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,4 +1,4 @@
-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';
@@ -53,7 +53,7 @@ export interface CreationPreview {
         name: string;
         identity: string;
         harness: string;
-        session: 'acp';
+        session: SessionBackendId;
         model?: string;
         reasoningEffort?: string;
         cwd?: string;
@@ -77,7 +77,7 @@ export interface CreationAction {
     actionId: string;
     requestHash: string;
     roleId: string;
-    session: 'acp';
+    session: SessionBackendId;
     lifetime: 'permanent' | 'temporary';
     state: CreationStage;
     stages: Array<{
@@ -103,7 +103,7 @@ 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;
     /** Direct/managed callers must not create or restore the web action journal. */
     journal?: boolean;

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

@@ -10,6 +10,7 @@ import { FleetError, normalizeError } from './errors.js';
 import { inheritCallerSpawnDefaults } from '../fleet-proxy.js';
 import { effectivePermissionMode } from '../permissions.js';
 import { effectiveRoleModel } from '../model-env.js';
+import { selectionOrigin, summarizeResolvedLaunch } from '../lifecycle-summary.js';
 const canonical = (value) => {
     if (Array.isArray(value))
         return `[${value.map(canonical).join(',')}]`;
@@ -61,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) {

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';
@@ -18,8 +21,8 @@ export interface TaskSettlementPlan {
     task: TaskRecord;
     settlementRequired: boolean;
 }
-export type TaskRecoveryIssue = {
-    code: 'terminal_pending' | 'waiting_cowork' | 'waiting_owner_invite' | 'owner_cid_mismatch' | 'waiting_seats' | 'provisioning_resumed';
+export type TaskProvisioningContinuationIssue = {
+    code: 'waiting_cowork' | 'waiting_owner_authorization' | 'waiting_owner_invite' | 'owner_cid_mismatch' | 'waiting_seats' | 'provisioning_resumed';
 } | {
     code: 'member_failed';
     stepIndex: number;
@@ -27,24 +30,36 @@ export type TaskRecoveryIssue = {
     code: 'resume_failed';
     error: string;
 };
-export interface TaskRecoveryResult {
-    kind: 'provisioning_resumed' | 'provisioning_resume_failed' | 'provisioning_non_resumable' | 'terminal' | 'no_op';
+export interface TaskProvisioningContinuationResult {
+    kind: 'provisioning_resumed' | 'provisioning_resume_failed' | 'provisioning_non_resumable' | 'no_op';
     task: TaskRecord;
     room: RoomOrchestrationRecord | undefined;
-    issues: TaskRecoveryIssue[];
+    issues: TaskProvisioningContinuationIssue[];
     reason?: 'missing_room' | 'missing_durable_template' | 'non_resumable_phase';
 }
-export type TaskRecoveryBegin = {
-    kind: 'terminal_worker_required';
-    taskId: string;
-} | {
-    kind: 'final';
-    result: TaskRecoveryResult;
-};
+export interface TaskProvisioningOutcome {
+    kind: 'ready' | 'in_progress' | 'failed';
+    task: TaskRecord;
+    room?: RoomOrchestrationRecord;
+    launch: {
+        template?: string;
+        anonymous: boolean;
+        owner_attached: boolean;
+    };
+    members: {
+        expected: number;
+        active: number;
+        launched: number;
+    };
+    blocker?: string;
+    next_action?: string;
+}
+/** Repairable terminal observation derived entirely from durable Task/Room state. */
+export declare function recordTaskProvisioningOutcome(outcome: TaskProvisioningOutcome): void;
 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 +72,8 @@ export interface CreateTaskRequest {
     idempotencyKey?: string;
     origin: TaskOrigin;
     list?: string;
+    members?: MemberOverrides;
+    anonymous?: boolean;
 }
 export interface CreateRoomRequest {
     actor: TaskRoomActor;
@@ -65,34 +82,44 @@ 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 {
     private readonly configurationPath?;
     private readonly deps;
-    private recovery?;
     constructor(configurationPath?: string | undefined, deps?: TaskRoomServiceDeps);
     createTask(request: CreateTaskRequest): Promise<TaskRecord>;
     createRoom(request: CreateRoomRequest): Promise<RoomOrchestrationRecord>;
     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[];
@@ -124,6 +151,12 @@ export declare class TaskRoomApplicationService {
         task: TaskRecord;
         orchestration: RoomOrchestrationRecord | undefined;
     };
+    taskProvisioningOutcome(taskId: string): TaskProvisioningOutcome;
+    awaitTaskProvisioning(input: {
+        actor: TaskRoomActor;
+        taskId: string;
+        waitMs?: number;
+    }): Promise<TaskProvisioningOutcome>;
     blockTask(input: {
         actor: TaskRoomActor;
         taskId: string;
@@ -137,10 +170,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;
-    }): boolean;
+    }): 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;
+        error: string;
+        recoveryHint: string;
+    }): Promise<TaskRecord>;
     completeTask(input: {
         actor: TaskRoomActor;
         taskId: string;
@@ -163,15 +226,14 @@ export declare class TaskRoomApplicationService {
         error: string;
         recoveryHint: string;
     }): Promise<TaskRecord>;
-    beginTaskRecovery(input: {
-        actor: TaskRoomActor;
-        taskId: string;
-    }): Promise<TaskRecoveryBegin>;
-    continueTaskRecovery(input: {
-        actor: TaskRoomActor;
+    continueTaskProvisioning(input: {
+        actor: {
+            kind: 'internal_worker';
+            surface: 'cli';
+        };
         taskId: string;
-        terminalTimedOut: boolean;
-    }): Promise<TaskRecoveryResult>;
+    }): Promise<TaskProvisioningContinuationResult>;
+    private reconcileProvisioningOwner;
     private acceptTerminal;
     listTemplates(): import("../rooms-tasks/types.js").TemplateDefinition[];
     getTemplate(name: string): {
@@ -179,7 +241,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 +259,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;
@@ -231,18 +294,6 @@ export declare class TaskRoomApplicationService {
         error: string;
         recoveryHint: string;
     }): Promise<RoomOrchestrationRecord>;
-    recoverRoom(input: {
-        actor: TaskRoomActor;
-        roomId: string;
-    }): Promise<{
-        kind: 'deletion_worker_required';
-        roomId: string;
-    } | {
-        kind: 'recovered' | 'provisioning_resumed' | 'provisioning_resume_failed';
-        room: Awaited<ReturnType<CoworkAdapter['recoverRoom']>>;
-        orchestration: RoomOrchestrationRecord | undefined;
-        issues: string[];
-    }>;
     finishTask(input: {
         actor: TaskRoomActor;
         taskId: string;
@@ -252,9 +303,11 @@ export declare class TaskRoomApplicationService {
         actor: TaskRoomActor;
         taskId: string;
         template?: string;
+        members?: MemberOverrides;
+        anonymous?: boolean;
     }): Promise<{
         task: TaskRecord;
-        status: 'ready' | 'already_active';
+        status: 'ready' | 'already_active' | 'in_progress';
     }>;
     private createTemplate;
     private existingTemplate;