@ours.network/fleet 1.2.0-nightly.6 → 1.2.0-nightly.61

package/dist/owner-channel/channel.js

@@ -883,8 +883,15 @@ export class OwnerChannel {
         const recovered = [];
         for (const claim of this.messageRecovery.list()) {
             const item = await this.client.getHistoryItem(claim.wireId);
-            if (!item)
-                throw new Error(`journaled owner message ${claim.wireId} is missing from persistent history`);
+            if (!item) {
+                // The daemon has definitively lost this body. Retrying the claim would
+                // block every later owner message, including after a supervisor restart.
+                // Keep transient lookup errors retryable; only an explicit absence skips.
+                this.messageRecovery.pruneHandled(wireId => wireId === claim.wireId);
+                this.options.log(`[${this.options.role}] skipped journaled owner message ${claim.wireId} `
+                    + `(seq=${claim.seq}): missing from persistent history`);
+                continue;
+            }
             recovered.push(this.historyMessage(item, claim));
         }
         const listed = await this.client.listIncomingMessages();
@@ -1391,6 +1398,7 @@ export class OwnerChannel {
                     await this.fleetOps.provisionTask(task.task_id);
                 return outcome;
             }),
+            observeTaskReadiness: taskId => new TaskRoomApplicationService(this.options.configPath).observeTaskReadiness(taskId),
             taskProvisioningOutcome: taskId => new TaskRoomApplicationService(this.options.configPath).taskProvisioningOutcome(taskId),
             listTasks: filter => new TaskRoomApplicationService(this.options.configPath).listTasks(filter),
             groupedTasks: filter => new TaskRoomApplicationService(this.options.configPath).groupedTasks(filter),
@@ -1977,6 +1985,9 @@ export class OwnerChannel {
         const progressMs = this.options.config.progress_interval_ms;
         let lastSeq = activityCursor;
         let startedAt;
+        // When one turn delivers several waiting prompts, its events carry the turn's
+        // id, not this request's: follow the turn that actually carries this request.
+        const inTurn = (turnId) => turnId === (this.options.session.sharedTurnId?.(queued.promptId) ?? queued.promptId);
         let phase = 'starting request';
         let timer;
         const flushCommentary = () => {
@@ -2033,7 +2044,7 @@ export class OwnerChannel {
         };
         const acceptCommentary = (event) => {
             if (!this.commentsEnabled
-                || active.commentaryDisabled || active.finalizing || event.turnId !== queued.promptId
+                || active.commentaryDisabled || active.finalizing || !inTurn(event.turnId)
                 || event.kind !== 'agent_text' || event.messagePhase !== 'commentary'
                 || event.replayed || event.origin?.kind !== 'owner'
                 || event.origin.requestId !== active.requestId
@@ -2074,7 +2085,7 @@ export class OwnerChannel {
         const reportProgress = () => {
             const events = this.options.session.eventsSince(lastSeq);
             lastSeq = Math.max(lastSeq, this.latestEventSeq(events));
-            const activity = events.filter(event => event.turnId === queued.promptId);
+            const activity = events.filter(event => inTurn(event.turnId));
             if (!activity.length)
                 return;
             startedAt ??= Date.parse(activity[0].at) || Date.now();
@@ -2099,10 +2110,10 @@ export class OwnerChannel {
         const startProgress = (event) => {
             if (timer || progressMs <= 0)
                 return;
-            if (event && event.turnId !== queued.promptId)
+            if (event && !inTurn(event.turnId))
                 return;
             const observed = event ? [event] : this.options.session.eventsSince(activityCursor)
-                .filter(item => item.turnId === queued.promptId);
+                .filter(item => inTurn(item.turnId));
             if (!observed.length)
                 return;
             startedAt = Date.parse(observed[0].at) || Date.now();

package/dist/owner-channel/commands.d.ts

@@ -1,3 +1,4 @@
+import type { TaskReadinessIssue } from '../rooms-tasks/live-readiness.js';
 import type { InterruptOutcome, SessionEvent, SessionSnapshot } from '../session/types.js';
 import type { RoomOrchestrationRecord, TaskOutcome, TaskRecord, TaskTerminalIntent, TaskListRecord } from '../rooms-tasks/types.js';
 import { type OwnerCommentsState } from './notices.js';
@@ -58,6 +59,9 @@ export interface OwnerCommandContext {
     terminalTask(taskId: string, kind: TaskTerminalIntent['kind'], outcome?: TaskOutcome): Promise<void>;
     createTask(input: Omit<CreateTaskRequest, 'actor'>): Promise<TaskRecord>;
     startTask(taskId: string): Promise<TaskProvisioningOutcome | TaskRecord>;
+    observeTaskReadiness?(taskId: string): Promise<{
+        state: 'ready';
+    } | TaskReadinessIssue>;
     taskProvisioningOutcome?(taskId: string): TaskProvisioningOutcome;
     listTasks(filter?: {
         state?: TaskState | TaskState[];

package/dist/owner-channel/commands.js

@@ -47,6 +47,11 @@ function isKnownOwnerRoomState(message) {
     ].some(pattern => pattern.test(message));
 }
 function ownerTaskFailure(error) {
+    if (error instanceof TaskRoomApplicationError && error.code === 'task_not_ready')
+        return {
+            kind: 'state', detail: error.message,
+            action: 'Ask Fleet Coordinator to inspect room and member status and choose supported recovery.',
+        };
     if (error instanceof TaskListError)
         return {
             kind: error.code === 'list_not_found' ? 'not_found'
@@ -301,6 +306,7 @@ export const ownerCommands = [
             const trailingLines = argLines.slice(1).join('\n').trim() || undefined;
             const showTask = async (id) => {
                 const { task: t } = ctx.getTask(id);
+                const readiness = t.state === 'active' ? await ctx.observeTaskReadiness?.(id) : undefined;
                 await ctx.reply(renderMarkdownResult({
                     icon: '📋', title: 'Task details',
                     fields: [
@@ -308,6 +314,8 @@ export const ownerCommands = [
                         { label: 'Title', value: t.title },
                         { label: 'Status', value: taskStatus(t.state), kind: 'markdown' },
                         { label: 'List', value: t.list_name ?? 'default', kind: 'code' },
+                        ...(readiness ? [{ label: 'Readiness', value: readiness.state },
+                            ...('reason' in readiness ? [{ label: 'Reason', value: readiness.reason }] : [])] : []),
                         ...(t.blocked ? [{ label: 'Blocked', value: t.blocked.reason }] : []),
                         ...(t.template ? [{ label: 'Template', value: `${t.template.name}@${t.template.version}`, kind: 'code' }] : []),
                         ...(t.room_id ? [{ label: 'Room', value: t.room_id, kind: 'code' }] : []),

package/dist/owner-channel/lifecycle-outbox.js

@@ -1,6 +1,6 @@
+import { redactErasedContent, writePrivacyFilteredLedger } from '../erased-resources.js';
 import { createHash } from 'node:crypto';
 import { chmodSync, existsSync, readFileSync } from 'node:fs';
-import { replaceFileAtomically } from '../atomic-file.js';
 import { lifecycleEventDigestBasis, validateFleetAuditPresentations, } from '../fleet-command-audit.js';
 const DIGEST = /^[a-f0-9]{64}$/u;
 const LIMIT = 5_000;
@@ -63,7 +63,7 @@ export class FleetLifecycleOutbox {
     }
     pending() {
         this.assertHealthy();
-        return this.entries.filter(entry => entry.delivery === 'pending').map(entry => structuredClone(entry));
+        return redactErasedContent(this.entries).filter(entry => entry.delivery === 'pending').map(entry => structuredClone(entry));
     }
     finish(digest, delivery) {
         this.assertHealthy();
@@ -82,6 +82,7 @@ export class FleetLifecycleOutbox {
             throw new Error(this.corruptReason);
     }
     persist() {
-        replaceFileAtomically(this.path, `${JSON.stringify({ version: 1, entries: this.entries })}\n`, 0o600);
+        this.entries = redactErasedContent(this.entries);
+        writePrivacyFilteredLedger(this.path, { version: 1, entries: this.entries });
     }
 }

package/dist/owner-channel/ours-client.js

@@ -1,7 +1,6 @@
 import { randomUUID } from 'node:crypto';
 import { readFile } from 'node:fs/promises';
-import { extname, join } from 'node:path';
-import { readDaemonConfig, resolveEndpoint } from '../monitor.js';
+import { extname } from 'node:path';
 import { readClientProfile } from '../client-profile.js';
 import { OursError, attachOursClient, } from '@ours.network/sdk/client';
 /** Any failure of a daemon operation. Never carries a message body or a token. */
@@ -131,24 +130,10 @@ export class OursSdkClient {
             return;
         const environment = { ...process.env, ...this.env };
         const profile = readClientProfile(environment);
-        // Reuse existing connection configuration. Identity selection checks the
-        // daemon capability before reading the client's protected token delivery file.
-        const endpoint = !profile && environment.OURS_DAEMON_ID
-            ? resolveEndpoint(environment, false) : undefined;
-        const token = endpoint ? environment.OURS_API_TOKEN?.trim() || readDaemonConfig(environment).apiToken : undefined;
-        const options = profile ? {
+        const options = {
             endpoint: profile.endpoint, expectedInstanceId: profile.expectedInstanceId,
             credentialPath: profile.credentialPath,
             sessionMode: 'external', leaseToken: this.leaseToken, env: {},
-        } : endpoint ? {
-            endpoint: endpoint.origin, expectedInstanceId: environment.OURS_DAEMON_ID,
-            sessionMode: 'external', leaseToken: this.leaseToken,
-            ...(token ? { token } : { credentialPath: join(endpoint.stateDir, 'daemon-token') }),
-        } : {
-            env: environment,
-            leaseToken: this.leaseToken,
-            clientPid: process.pid,
-            fetch: notificationDeadlineFetch(this.deps.fetch ?? globalThis.fetch, this.deps.notificationRequestDeadlineMs ?? NOTIFICATION_REQUEST_DEADLINE_MS),
         };
         this.client = await (this.deps.attachClient?.(options) ?? attachOursClient(options));
         this.terminalReleasePending = true;

package/dist/paths.d.ts

@@ -11,6 +11,8 @@ export declare const home: () => string;
  */
 export declare function deriveXdgRuntimeDir(env?: NodeJS.ProcessEnv, uid?: number | undefined, exists?: (p: string) => boolean): string | undefined;
 export declare const stateRoot: () => string;
+/** The Owner invitation file that tunnel setup writes itself after enrollment. */
+export declare const workspaceOwnerInvite: () => string;
 export declare const agentsRoot: () => string;
 export declare const tmpRoot: () => string;
 export declare const logsRoot: () => string;

package/dist/paths.js

@@ -21,6 +21,8 @@ export function deriveXdgRuntimeDir(env = process.env, uid = process.getuid?.(),
     return env.XDG_RUNTIME_DIR;
 }
 export const stateRoot = () => join(home(), '.ours-fleet');
+/** The Owner invitation file that tunnel setup writes itself after enrollment. */
+export const workspaceOwnerInvite = () => join(stateRoot(), 'workspace', 'owner.invite');
 export const agentsRoot = () => join(stateRoot(), 'agents');
 export const tmpRoot = () => join(stateRoot(), 'tmp');
 export const logsRoot = () => join(stateRoot(), 'logs');

package/dist/preset-migration.js

@@ -67,10 +67,21 @@ const V5_GENERATED_ROLE_DEFAULT_FINGERPRINTS = Object.freeze({
     'agent_templates/Developer.yaml': 'fdd953aab72d042e62780dd273598745aae59521b39edf4876d7676bb7189c83',
     'agent_templates/Critic.yaml': '3e98a28f17876061cfadf984351aa59fdbe19629e514eff52c74546545c64a91',
 });
+// The packaged Coordinator role of revisions 8 and 9 addressed a named owner channel that a
+// fresh installation does not have. Untouched copies adopt the current role; edited ones stay.
+const OWNER_CHANNEL_COORDINATOR_FINGERPRINTS = Object.freeze({
+    'roles/Coordinator.yaml': [
+        '8c8ad28d9bb9ddf9dba8c5c9c7859f25edd8fa10ebf833e2340124a6e49583ec',
+        'f0d8b169ad0a18051b57e5280b93cf01e05faa5c12f4e12bdf89973edf2ef58a',
+    ],
+});
 const CURRENT_ROLE_DEFAULTS = new Set([
     'roles/Coordinator.yaml', 'roles/LocalCoordinator.yaml', 'roles/Developer.yaml', 'roles/Critic.yaml',
+    'roles/Engineer.yaml',
     'agent_templates/LocalCoordinator.yaml', 'agent_templates/Developer.yaml', 'agent_templates/Critic.yaml',
+    'agent_templates/Engineer.yaml',
     'room_templates/single.yaml', 'room_templates/pair.yaml', 'room_templates/team.yaml',
+    'room_templates/engineering.yaml',
     'agents/FleetCoordinator.yaml',
 ]);
 export const legacyStarterMigrationManifest = Object.freeze({
@@ -193,6 +204,7 @@ export function migratePackagedRoleDefaults(configuration, options = {}, hooks =
             ...Object.keys(V3_ROLE_DEFAULT_FINGERPRINTS),
             ...Object.keys(V4_ROLE_DEFAULT_FINGERPRINTS),
             ...Object.keys(V5_ROLE_DEFAULT_FINGERPRINTS),
+            ...Object.keys(OWNER_CHANNEL_COORDINATOR_FINGERPRINTS),
         ]);
         for (const relative of known) {
             const path = join(root, relative);
@@ -206,6 +218,7 @@ export function migratePackagedRoleDefaults(configuration, options = {}, hooks =
                 V4_GENERATED_ROLE_DEFAULT_FINGERPRINTS[relative],
                 V5_ROLE_DEFAULT_FINGERPRINTS[relative],
                 V5_GENERATED_ROLE_DEFAULT_FINGERPRINTS[relative],
+                ...(OWNER_CHANNEL_COORDINATOR_FINGERPRINTS[relative] ?? []),
             ].some(expected => expected !== undefined && actual === expected);
             if (recognized)
                 (CURRENT_ROLE_DEFAULTS.has(relative) ? replacements : removals).push(path);
@@ -258,6 +271,18 @@ export function migratePackagedRoleDefaults(configuration, options = {}, hooks =
                 unlinkSync(target);
             copyFileSync(join(source, relative), target, constants.COPYFILE_EXCL);
             chmodSync(target, 0o600);
+            // New Engineer seats use the existing Developer's selected brain. This
+            // preserves wizard/custom provider choices without copying permissions.
+            if (relative === 'agent_templates/Engineer.yaml' && classified.additions.includes(path)) {
+                const developer = join(root, 'agent_templates/Developer.yaml');
+                if (existsSync(developer)) {
+                    const value = parseFleetDocument(developer, readFileSync(developer, 'utf8'), 'strict').value;
+                    if (value.brain !== undefined && JSON.stringify(value.brain) !== JSON.stringify({ ref: 'claude-default' })) {
+                        const bytes = readFileSync(target, 'utf8').replace('brain: { ref: claude-default }', () => `brain: ${JSON.stringify(value.brain)}`);
+                        writeFileSync(target, bytes, { mode: 0o600 });
+                    }
+                }
+            }
             fsyncPath(target);
         }
         for (const kind of ['roles', 'agent_templates', 'room_templates', 'agents'])

package/dist/resolved-plan.js

@@ -103,6 +103,7 @@ export function resolvedRolePlan(role, manifestDir = dirname(role.sourceFile)) {
         isolation: role.isolation ?? null,
         worklog: role.worklog ?? null,
         authProxy: role.auth_proxy ?? null,
+        managedCli: role.managed_cli ?? [],
         oversee: role.oversee ?? [],
         harnessOptions: redactSensitive(role.harness_options ?? null),
         env: {

package/dist/rooms-tasks/add-member.d.ts

@@ -0,0 +1,48 @@
+import type { FleetConfig } from '../config.js';
+import { TaskStateError } from './task-state.js';
+import { provisionMembers } from './provision.js';
+import type { CoworkAdapter } from './cowork-adapter.js';
+export declare class MemberAdditionRejected extends TaskStateError {
+    readonly accepted = false;
+}
+export interface AddMemberRequest {
+    requestId: string;
+    slot: string;
+    role: string;
+    brain: string;
+    agentTemplate: string;
+}
+export declare function memberAddition(taskId: string, requestId: string): {
+    requestId: string;
+    taskId: string;
+    roleId: string;
+    state: "running" | "succeeded" | "attention" | "failed";
+    error?: string;
+} | {
+    state: string;
+    error: string;
+    requestId: string;
+    taskId: string;
+    roleId: string;
+};
+export declare function requestMemberAddition(input: {
+    taskId: string;
+    request: AddMemberRequest;
+    cfg: FleetConfig;
+    cowork: CoworkAdapter;
+    configPath?: string;
+    binPath: string;
+    provision?: typeof provisionMembers;
+}): Promise<{
+    requestId: string;
+    taskId: string;
+    roleId: string;
+    state: "running" | "succeeded" | "attention" | "failed";
+    error?: string;
+} | {
+    state: string;
+    error: string;
+    requestId: string;
+    taskId: string;
+    roleId: string;
+}>;

package/dist/rooms-tasks/add-member.js

@@ -0,0 +1,83 @@
+import { createHash } from 'node:crypto';
+import { existsSync, mkdirSync, readFileSync } from 'node:fs';
+import { join } from 'node:path';
+import { replaceFileAtomically, withFileLock } from '../atomic-file.js';
+import { canonicalJson } from '../canonical-json.js';
+import { stateRoot } from '../paths.js';
+import { getTask, TaskStateError } from './task-state.js';
+import { getRoomRecord } from './room-state.js';
+import { prepareExecutionPlan } from './member-overrides.js';
+import { sealTemplateSnapshot } from './templates.js';
+import { provisionMembers } from './provision.js';
+export class MemberAdditionRejected extends TaskStateError {
+    accepted = false;
+}
+const running = new Set();
+function pathFor(taskId, requestId) {
+    if (!/^[a-z0-9]{10,40}$/.test(taskId) || !/^[a-zA-Z0-9_-]{8,80}$/.test(requestId))
+        throw new TaskStateError('Invalid task or request ID');
+    return join(stateRoot(), 'member-additions', taskId, requestId + '.json');
+}
+export function memberAddition(taskId, requestId) {
+    getTask(taskId);
+    const path = pathFor(taskId, requestId);
+    if (!existsSync(path))
+        throw new TaskStateError('Member request not found');
+    const receipt = JSON.parse(readFileSync(path, 'utf8'));
+    const { hash, ...view } = receipt;
+    return receipt.state === 'running' && !running.has(path) ? { ...view, state: 'attention', error: 'The server stopped observing this launch. Inspect the existing agent before any recovery.' } : view;
+}
+export async function requestMemberAddition(input) {
+    const { request: r, taskId } = input;
+    if (!r || typeof r.slot !== 'string' || !/^[A-Za-z][A-Za-z0-9_-]{0,31}$/.test(r.slot)
+        || ![r.role, r.brain, r.agentTemplate].every(v => typeof v === 'string' && v.length > 0 && v.length <= 128))
+        // No receipt lookup has happened yet: this request ID may already be accepted.
+        throw new TaskStateError('Slot, Role, Brain and Agent Template are required');
+    const path = pathFor(taskId, r.requestId);
+    const hash = createHash('sha256').update(canonicalJson(r)).digest('hex');
+    mkdirSync(join(stateRoot(), 'member-additions', taskId), { recursive: true, mode: 0o700 });
+    return withFileLock(path + '.lock', async () => {
+        if (existsSync(path)) {
+            const old = JSON.parse(readFileSync(path, 'utf8'));
+            if (old.hash !== hash)
+                throw new TaskStateError('Request ID was already used with different settings');
+            return memberAddition(taskId, r.requestId);
+        }
+        const task = getTask(taskId);
+        const room = task.room_id && getRoomRecord(task.room_id);
+        if (!room || !['active', 'review'].includes(task.state) || task.terminal_intent || room.state !== 'active'
+            || room.task_id !== taskId || room.room_identity_cid !== task.room_identity_cid)
+            throw new MemberAdditionRejected('Adding an agent requires an active task room');
+        const roleId = `${taskId.slice(0, 8)}-${r.slot}-1`;
+        if (room.member_seats.some(s => s.role_name === roleId))
+            throw new MemberAdditionRejected('This member slot already exists');
+        const plan = (() => {
+            try {
+                return prepareExecutionPlan({ name: 'additional-member', version: 1, description: 'Additional task participant',
+                    contract: room.template_snapshot?.contract, members: [{ slot: r.slot, role: r.role, count: 1, agent_template: r.agentTemplate }] }, input.cfg, { [r.slot]: { role: r.role, brain: r.brain } });
+            }
+            catch (error) {
+                throw new MemberAdditionRejected(error instanceof Error ? error.message : 'Invalid member configuration');
+            }
+        })();
+        const template = sealTemplateSnapshot(plan.snapshot, input.cfg.agentTemplates ?? {}, plan.launchDefinitions);
+        const receipt = { taskId, requestId: r.requestId, roleId, hash, state: 'running' };
+        const save = () => replaceFileAtomically(path, JSON.stringify(receipt) + '\n', 0o600);
+        save();
+        running.add(path);
+        void (input.provision ?? provisionMembers)({ cfg: input.cfg, cowork: input.cowork, configPath: input.configPath, binPath: input.binPath,
+            taskId, roomId: room.room_id, template, goal: task.title, brief: task.brief, append: true }).then(result => {
+            const seat = result.member_seats.find(s => s.role_name === roleId);
+            receipt.state = seat?.seat_state === 'active' && getTask(taskId).member_roles.some(m => m.name === roleId) ? 'succeeded' : 'attention';
+            if (receipt.state === 'attention')
+                receipt.error = 'Admission is not confirmed. Inspect the existing launch; no automatic retry was made.';
+        }).catch(() => { receipt.state = 'failed'; receipt.error = 'Member launch failed. Inspect the task and agent logs before recovery.'; })
+            .finally(() => { try {
+            save();
+        }
+        finally {
+            running.delete(path);
+        } }).catch(() => { running.delete(path); });
+        return memberAddition(taskId, r.requestId);
+    });
+}

package/dist/rooms-tasks/archived-absence.d.ts

@@ -0,0 +1,8 @@
+import type { ArchivedMemberAbsence, RoomMemberSeat } from './types.js';
+/** Revalidate live facts; a persisted timestamp is never cleanup authority. */
+export declare function verifyArchivedAbsence(proof: ArchivedMemberAbsence): Promise<void>;
+/** After the verified archive has been consumed by explicit workspace deletion,
+ * still fence replacement live state and a recreated daemon identity on every retry.
+ */
+export declare function verifyArchivedMemberStillAbsent(proof: ArchivedMemberAbsence): Promise<void>;
+export declare function proveArchivedAbsence(seat: RoomMemberSeat): Promise<ArchivedMemberAbsence>;

package/dist/rooms-tasks/archived-absence.js

@@ -0,0 +1,48 @@
+import { existsSync, readFileSync } from 'node:fs';
+import { join } from 'node:path';
+import { agentDir } from '../paths.js';
+import { tempArchiveForLaunch, tempArchiveForCreationAction, tempSupervisorLiveness } from '../temp-lifecycle.js';
+import { assertMemberIdentityAbsent } from './close.js';
+/** Revalidate live facts; a persisted timestamp is never cleanup authority. */
+export async function verifyArchivedAbsence(proof) {
+    const absent = () => {
+        if (existsSync(agentDir(proof.name, true)))
+            throw new Error('Archived member has replacement live state');
+    };
+    absent();
+    const archive = tempArchiveForLaunch(proof.name, proof.launch_id);
+    const action = tempArchiveForCreationAction(proof.name, proof.action_id);
+    if (!archive || archive !== proof.archive_path || action?.path !== archive
+        || action.launchId !== proof.launch_id
+        || readFileSync(join(archive, '.identity'), 'utf8').trim() !== proof.name)
+        throw new Error('Archived member absence ownership proof mismatch');
+    if (await tempSupervisorLiveness(archive) !== 'stopped')
+        throw new Error('Archived member supervisor absence is not proven');
+    await verifyArchivedMemberStillAbsent(proof);
+}
+/** After the verified archive has been consumed by explicit workspace deletion,
+ * still fence replacement live state and a recreated daemon identity on every retry.
+ */
+export async function verifyArchivedMemberStillAbsent(proof) {
+    const absent = () => {
+        if (existsSync(agentDir(proof.name, true)))
+            throw new Error('Archived member has replacement live state');
+    };
+    absent();
+    await assertMemberIdentityAbsent({
+        role_name: proof.name, slot: 'archived', cowork_role: 'archived', seat_state: 'removed',
+    });
+    absent();
+}
+export async function proveArchivedAbsence(seat) {
+    if (seat.identity_cid || seat.retirement?.phase !== 'identity_absent'
+        || !seat.launch?.launch_id || !seat.launch.action_id
+        || seat.launch.launch_id !== seat.retirement.launch_id || !seat.retirement.archive_path)
+        throw new Error('Missing exact archived member absence evidence');
+    const proof = {
+        name: seat.role_name, launch_id: seat.launch.launch_id, action_id: seat.launch.action_id,
+        archive_path: seat.retirement.archive_path, checked_at: new Date().toISOString(),
+    };
+    await verifyArchivedAbsence(proof);
+    return proof;
+}

package/dist/rooms-tasks/cli.js

@@ -75,6 +75,11 @@ async function presentDetachedProvisioningOutcome(outcome) {
 function taskRoomPublicFailure(error) {
     const f = error.fields;
     switch (error.code) {
+        case 'task_not_ready': return {
+            legacy: `task readiness ${f.readiness}: ${f.reason}`, kind: 'state',
+            detail: `Task ${f.task} readiness is ${f.readiness}: ${f.reason}${f.member ? ` (${f.member})` : ''}.`,
+            action: 'Ask Fleet Coordinator to inspect room and member status and choose supported recovery. Do not blindly relaunch agents or reuse invites.',
+        };
         case 'task_confirmation_mismatch': return {
             legacy: 'confirmation ID must match task ID', kind: 'usage',
             detail: 'The two task IDs must match.', action: 'Repeat the same task ID twice.',
@@ -242,6 +247,8 @@ const taskListMarkdown = (tasks, title = 'Tasks') => renderMarkdownList({
     icon: '📋', title, empty: 'No tasks found.',
     records: tasks.map(t => `${taskStatus(t.state)} ${markdownCode(t.task_id)} — ${markdownProse(t.title)}`
         + ` — List ${markdownCode(t.list_name ?? 'default')}`
+        + (t.deletion?.status === 'pending' ? ' — Deletion pending'
+            + (t.deletion.error ? `: ${markdownProse(t.deletion.error)}` : '') : '')
         + (t.blocked ? ` — 🚧 Blocked: ${markdownProse(t.blocked.reason)}` : '')),
 });
 const taskActionMarkdown = (title, task, fields = []) => {
@@ -515,10 +522,10 @@ function taskRoomService(configuration) {
 function allTemplates(cfg) {
     return cfg.roomTemplates ?? {};
 }
-function coworkFor(cfg) {
+function coworkFor(cfg, options) {
     if (!cfg.rooms)
         throw new ConfigError('rooms: configuration is required before creating or querying rooms');
-    return createCoworkAdapter({ configPath: cfg.rooms.cowork?.config });
+    return createCoworkAdapter({ configPath: cfg.rooms.cowork?.config, ...options });
 }
 function resolveRoomTemplate(cfg, name) {
     if (!name)
@@ -709,6 +716,7 @@ export function registerTaskCommands(parent, cOpt) {
         .option('--state <state>', 'filter by state (backlog|active|provisioning|review|done|cancelled|failed|all)')
         .option('--list <name>', 'filter by task list')
         .option('--group-by-list', 'group deterministic results by list (JSON)')
+        .option('--include-deleting', 'include tasks whose accepted deletion is still pending')
         .option('--json', 'JSON output')
         .action(async (opts) => {
         try {
@@ -717,7 +725,8 @@ export function registerTaskCommands(parent, cOpt) {
                 stateFilter = opts.state;
             }
             const service = taskRoomService(opts.configuration);
-            const filter = { ...(stateFilter ? { state: stateFilter } : {}), ...(opts.list ? { list: opts.list } : {}) };
+            const filter = { ...(stateFilter ? { state: stateFilter } : {}), ...(opts.list ? { list: opts.list } : {}),
+                ...(opts.includeDeleting ? { includeDeleting: true } : {}) };
             const tasks = service.listTasks(filter);
             if (opts.json) {
                 console.log(JSON.stringify(opts.groupByList
@@ -827,16 +836,19 @@ export function registerTaskCommands(parent, cOpt) {
             dieTaskRoom(e);
         }
     });
-    taskCmd.command('show <id>')
+    cOpt(taskCmd.command('show <id>'))
         .description('show task details')
         .option('--json', 'JSON output')
         .action(async (id, opts) => {
         try {
-            const service = taskRoomService();
+            const service = taskRoomService(opts.configuration);
             const { task: t, orchestration: room } = service.getTask(id);
+            const readiness = t.state === 'active' && t.deletion?.status !== 'pending'
+                ? await service.observeTaskReadiness(id) : undefined;
             if (opts.json) {
                 console.log(JSON.stringify({
                     schema_version: 1, task: t, orchestration: room ?? null,
+                    ...(readiness ? { readiness } : {}),
                 }, null, 2));
                 return;
             }
@@ -846,6 +858,13 @@ export function registerTaskCommands(parent, cOpt) {
                     { label: 'ID', value: t.task_id, kind: 'code' },
                     { label: 'Title', value: t.title },
                     { label: 'Status', value: taskStatus(t.state), kind: 'markdown' },
+                    ...(t.deletion?.status === 'pending' ? [
+                        { label: 'Deletion', value: 'Pending — cleanup is not complete' },
+                        ...(t.deletion.error ? [{ label: 'Cleanup error', value: t.deletion.error }] : []),
+                        { label: 'Retry', value: `ours-fleet task delete ${t.task_id} ${t.task_id}`, kind: 'code' },
+                    ] : []),
+                    ...(readiness ? [{ label: 'Readiness', value: readiness.state },
+                        ...('reason' in readiness ? [{ label: 'Reason', value: readiness.reason }] : [])] : []),
                     ...(t.blocked ? [{ label: 'Blocked', value: t.blocked.reason }] : []),
                     ...(t.template ? [{ label: 'Template', value: `${t.template.name}@${t.template.version}`, kind: 'code' }] : []),
                     ...(t.room_id ? [{ label: 'Room', value: t.room_id, kind: 'code' }] : []),
@@ -872,6 +891,27 @@ export function registerTaskCommands(parent, cOpt) {
             dieTaskRoom(e);
         }
     });
+    cOpt(taskCmd.command('recover-members <id>'))
+        .description('resume proven stopped task members in-place; never create identities or replay invites')
+        .option('--json', 'JSON output')
+        .action(async (id, opts) => {
+        try {
+            const { recoverTaskMembers } = await import('./recovery.js');
+            const task = getTask(id), cfg = loadConfig(opts.configuration);
+            const members = await recoverTaskMembers({ taskId: id, binPath: getBinPath(),
+                cowork: task.layout ? undefined : createCoworkAdapter({ configPath: cfg.rooms?.cowork?.config }) });
+            if (opts.json)
+                console.log(JSON.stringify({ schema_version: 1, task_id: id, members }, null, 2));
+            else
+                for (const member of members)
+                    console.log(`${member.name}: ${member.status}`);
+        }
+        catch (e) {
+            if (opts.json)
+                die(e);
+            dieTaskRoom(e);
+        }
+    });
     cOpt(taskCmd.command('start <id>'))
         .description('idempotently select a plan, provision, and start a task')
         .option('--template <name>', 'room template')
@@ -1176,6 +1216,26 @@ export function registerTaskCommands(parent, cOpt) {
             dieTaskRoom(e);
         }
     });
+    cOpt(taskCmd.command('_layout <id> <operation> [room]', { hidden: true }))
+        .description('internal: run an accepted layout room operation (open, close-room, close)')
+        .option('--json', 'JSON output')
+        .option('--operation-id <id>', 'accepted operation ID; status updates apply only while it is current')
+        .action(async (id, operation, room, opts) => {
+        try {
+            if (!['open', 'close-room', 'close'].includes(operation))
+                throw new Error(`unknown layout operation: ${operation}`);
+            const view = await taskRoomService(opts.configuration).runTaskLayoutOperation({
+                actor: { kind: 'internal_worker', surface: 'cli' }, taskId: id,
+                operation: operation, room, operationId: opts.operationId,
+            });
+            console.log(JSON.stringify({ schema_version: 1, layout: view }, null, 2));
+        }
+        catch (e) {
+            if (opts.json)
+                die(e);
+            dieTaskRoom(e);
+        }
+    });
     cOpt(taskCmd.command('_settle_delete <id>', { hidden: true }))
         .description('internal: settle a previously accepted task deletion')
         .option('--json', 'JSON output')

package/dist/rooms-tasks/close.d.ts

@@ -1,9 +1,12 @@
+import { retireTaskMemberService } from './task-service-retirement.js';
 import { withFileLock } from '../atomic-file.js';
 import { type TempLifecycleDeps } from '../temp-lifecycle.js';
 import { type CoworkAdapter } from './cowork-adapter.js';
 import type { RoomMemberSeat, RoomOrchestrationRecord } from './types.js';
+export declare const CLOSE_LOCK_STALE_MS: number;
 export declare function roomCloseLockPath(roomId: string): string;
 export interface RoomCloseDeps {
+    retireTaskService?: typeof retireTaskMemberService;
     inspectMember?(seat: RoomMemberSeat): Promise<{
         launchId: string;
     }>;
@@ -20,12 +23,13 @@ export declare function waitForLivenessAbsent(role: string, launchId: string, li
 /** Report whether any daemon identity — under any name — carries this exact CID. */
 export declare function identityCidPresent(cid: string): Promise<boolean>;
 export declare function removeExactMemberIdentity(seat: RoomMemberSeat): Promise<void>;
+export declare function assertMemberIdentityAbsent(seat: RoomMemberSeat): Promise<void>;
 /** One forward-only room close saga shared by every Fleet entry point. */
 export declare function acceptManagedRoomClose(roomId: string): Promise<RoomOrchestrationRecord>;
 export declare function recordManagedRoomCloseError(roomId: string, error: string, recoveryHint: string): Promise<RoomOrchestrationRecord>;
 export declare function closeManagedRoom(input: {
     roomId: string;
-    cowork: Pick<CoworkAdapter, 'closeRoom'>;
+    cowork: Pick<CoworkAdapter, 'closeRoom'> & Partial<Pick<CoworkAdapter, 'getRoom'>>;
     deps?: RoomCloseDeps;
 }): Promise<RoomOrchestrationRecord>;
 export interface ManagedRoomDeleteResult {
@@ -39,6 +43,6 @@ export declare function deleteLegacyClosedRooms(input: {
 /** Retire live resources through the existing cursor, then delete retained state. */
 export declare function deleteManagedRoom(input: {
     roomId: string;
-    cowork: Pick<CoworkAdapter, 'closeRoom' | 'deleteRoom'>;
+    cowork: Pick<CoworkAdapter, 'closeRoom' | 'deleteRoom'> & Partial<Pick<CoworkAdapter, 'getRoom'>>;
     deps?: RoomCloseDeps;
 }): Promise<ManagedRoomDeleteResult>;