@ours.network/fleet 1.2.0-nightly.8 → 1.2.0-nightly.80

package/dist/reminders/tools.d.ts

@@ -0,0 +1,20 @@
+import type { McpServer } from '@modelcontextprotocol/sdk/server/mcp.js';
+import { type ReminderStore } from './store.js';
+/**
+ * What the agent's managed MCP endpoint needs from its runner. Absent until
+ * the runner has bound the store to this exact runtime instance and identity.
+ */
+export interface ReminderToolBackend {
+    store: ReminderStore;
+    /** Re-arm the dispatcher after a schedule change. */
+    changed(): void;
+}
+export declare const REMINDER_TOOL_NAMES: readonly ["fleet_reminder_create", "fleet_reminder_list", "fleet_reminder_update", "fleet_reminder_cancel", "fleet_reminder_inspect", "fleet_reminder_ack"];
+/**
+ * Register the self-reminder tools on the agent's own fixed-identity MCP
+ * server. No argument names an agent, identity or recipient: the server is the
+ * caller's own supervisor, so every operation is implicitly self-scoped.
+ */
+export declare function registerReminderTools(server: McpServer, backend: () => ReminderToolBackend | undefined, 
+/** The endpoint's runtime admission; nothing is read or changed unless it admits. */
+admit: () => Promise<() => void>): void;

package/dist/reminders/tools.js

@@ -0,0 +1,114 @@
+import { z } from 'zod';
+import { ReminderError } from './store.js';
+export const REMINDER_TOOL_NAMES = Object.freeze([
+    'fleet_reminder_create', 'fleet_reminder_list', 'fleet_reminder_update',
+    'fleet_reminder_cancel', 'fleet_reminder_inspect', 'fleet_reminder_ack',
+]);
+const schedule = {
+    local_time: z.string().describe('Calendar date and wall-clock time WITHOUT an offset, e.g. "2027-01-20T16:00". Always a real date: resolve "tomorrow" yourself.'),
+    time_zone: z.string().describe('IANA zone the time is meant in, e.g. "Europe/London", "America/New_York" or "UTC". Use the zone of the person or task, not a guess.'),
+    fold: z.union([z.literal(0), z.literal(1)]).optional().describe('Only for a wall time that occurs twice when clocks go back: 0 = first occurrence, 1 = second.'),
+    late_window_seconds: z.number().int().optional().describe('How late the wake may still be delivered if this agent or the host was offline or busy at the due time (60..604800, default 3600). After it the reminder expires without a wake.'),
+    interrupt: z.boolean().optional().describe('Default false: the wake waits until you are idle. true only for a return that is genuinely time-bound: '
+        + 'when due and you are busy with interruptible work, Fleet asks your current turn to stop (session and context are kept) and wakes you with this reminder instead of waiting. '
+        + 'At most one interruption per reminder revision. It never pre-empts owner requests, the owner console, startup, a pending permission, queued work or another reminder; '
+        + 'then it waits like an ordinary reminder. Not a hard real-time alarm: no wake while the host or agent is down, and model start-up still takes time.'),
+};
+function result(value) {
+    return {
+        content: [{ type: 'text', text: JSON.stringify(value, null, 2) }],
+        structuredContent: value,
+        isError: false,
+    };
+}
+function failure(code, message) {
+    const value = { error: code, message };
+    return { content: [{ type: 'text', text: JSON.stringify(value) }], isError: true };
+}
+/**
+ * Register the self-reminder tools on the agent's own fixed-identity MCP
+ * server. No argument names an agent, identity or recipient: the server is the
+ * caller's own supervisor, so every operation is implicitly self-scoped.
+ */
+export function registerReminderTools(server, backend, 
+/** The endpoint's runtime admission; nothing is read or changed unless it admits. */
+admit) {
+    const run = async (operation, mutates) => {
+        let release;
+        try {
+            release = await admit();
+        }
+        catch {
+            return failure('runtime_not_ready', 'the managed runtime is not admitting tool calls right now; nothing was read or changed');
+        }
+        try {
+            const target = backend();
+            if (!target)
+                return failure('reminders_unavailable', 'self-reminders are not available in this session (the supervisor has not bound them, or this session cannot take scheduled prompts)');
+            try {
+                const value = operation(target);
+                if (mutates)
+                    target.changed();
+                return result(value);
+            }
+            catch (error) {
+                if (error instanceof ReminderError)
+                    return failure(error.code, error.message);
+                return failure('reminder_store_failed', 'the reminder could not be recorded; nothing was changed');
+            }
+        }
+        finally {
+            release();
+        }
+    };
+    server.registerTool('fleet_reminder_create', {
+        description: 'Schedule a one-time reminder that wakes YOU (this agent) at a future date and time. '
+            + 'It sends nothing to anyone: when due, Fleet starts a turn for you with the reminder, and you decide what to do. '
+            + 'Use it to come back to something later instead of polling or waiting. Repeating a call with the same request_key '
+            + 'and input returns the existing reminder instead of creating another.',
+        inputSchema: {
+            request_key: z.string().describe('Stable key for this scheduling decision, so a retried call cannot create a duplicate (e.g. "release-check-2027-01-20").'),
+            title: z.string().describe('Short label shown in the wake (max 200 characters).'),
+            note: z.string().optional().describe('Private context for your future self: what to check and why (max 4000 characters). Returned by inspect, not in the wake text.'),
+            ...schedule,
+        },
+    }, async (args) => run(({ store }) => store.create(args.request_key, args), true));
+    server.registerTool('fleet_reminder_list', {
+        description: 'List your own reminders. state: "open" (default: scheduled or delivered but not acknowledged), "closed", or "all". '
+            + 'Pages with limit (1..100, default 50) and after (the id from the previous page).',
+        inputSchema: {
+            state: z.enum(['open', 'closed', 'all']).optional(),
+            limit: z.number().int().optional(),
+            after: z.string().optional(),
+        },
+    }, async (args) => run(({ store }) => store.list(args), false));
+    server.registerTool('fleet_reminder_update', {
+        description: 'Change one of your reminders, e.g. to postpone it. Pass the id and the revision you last saw '
+            + '(expected_revision) plus only the fields to change. Any wake already issued for the old revision becomes void.',
+        inputSchema: {
+            id: z.string(),
+            expected_revision: z.number().int(),
+            title: z.string().optional(),
+            note: z.string().optional(),
+            local_time: schedule.local_time.optional(),
+            time_zone: schedule.time_zone.optional(),
+            fold: schedule.fold,
+            late_window_seconds: schedule.late_window_seconds,
+            interrupt: schedule.interrupt,
+        },
+    }, async ({ id, expected_revision, ...changes }) => run(({ store }) => store.update(id, expected_revision, changes), true));
+    server.registerTool('fleet_reminder_cancel', {
+        description: 'Cancel one of your reminders (id + expected_revision). A wake already waiting for it will not be delivered.',
+        inputSchema: { id: z.string(), expected_revision: z.number().int() },
+    }, async ({ id, expected_revision }) => run(({ store }) => store.cancel(id, expected_revision), true));
+    server.registerTool('fleet_reminder_inspect', {
+        description: 'Read the reminder behind a [fleet-reminder] wake, including its note, whether the wake is still current and eligible, '
+            + 'and for an urgent reminder what its interruption request did (interrupt.state).',
+        inputSchema: { event_id: z.string() },
+    }, async ({ event_id }) => run(({ store }) => store.inspect(event_id), false));
+    server.registerTool('fleet_reminder_ack', {
+        description: 'Record that you handled a [fleet-reminder] wake (event_id + revision from the wake). '
+            + 'It closes the reminder and sends nothing; it does not claim any external action happened. Safe to repeat.',
+        inputSchema: { event_id: z.string(), expected_revision: z.number().int() },
+    }, async ({ event_id, expected_revision }) => run(({ store }) => store.ack(event_id, expected_revision), true));
+}

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,84 @@
+import { publishFleetResourceCommit } from '../application/resource-observer.js';
+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); publishFleetResourceCommit(path); };
+        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

@@ -1,4 +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

@@ -18,6 +18,17 @@ export async function verifyArchivedAbsence(proof) {
         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',
     });

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;
     }>;
@@ -26,7 +29,7 @@ export declare function acceptManagedRoomClose(roomId: string): Promise<RoomOrch
 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 {
@@ -40,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>;