@ours.network/fleet 0.18.1 → 0.19.0-nightly.10

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

@@ -1,4 +1,5 @@
 import type { InterruptOutcome, SessionEvent, SessionSnapshot } from '../session/types.js';
+import type { TaskOutcome, TaskTerminalIntent } from '../rooms-tasks/types.js';
 import { type OwnerCommentsState } from './notices.js';
 /**
  * Fleet-level effects a deterministic owner command may trigger. Production
@@ -10,6 +11,10 @@ export interface OwnerFleetOps {
     restart(mode: 'keep' | 'fresh'): Promise<void>;
     /** `ours-fleet ls` output. */
     list(): Promise<string>;
+    /** Start a room-close worker outside the caller role's supervisor lifecycle. */
+    closeRoom(roomId: string): Promise<void>;
+    /** Resume a task terminal intent outside the caller role's supervisor lifecycle. */
+    settleTask(taskId: string): Promise<void>;
 }
 /**
  * The narrow capability surface a command executor sees. Everything here is
@@ -40,6 +45,10 @@ export interface OwnerCommandContext {
      */
     setComments(enabled: boolean): OwnerCommentsState;
     fleetList(): Promise<string>;
+    /** Persist acceptance, acknowledge it, then launch the external close worker. */
+    closeRoom(roomId: string): Promise<void>;
+    /** Persist terminal intent, acknowledge it, then launch the external settle worker. */
+    terminalTask(taskId: string, kind: TaskTerminalIntent['kind'], outcome?: TaskOutcome): Promise<void>;
     recentEvents(limit: number): SessionEvent[];
     readWorklogTail(maxChars: number): Promise<string | undefined>;
     reply(text: string): Promise<void>;

package/dist/owner-channel/commands.js

@@ -1,4 +1,5 @@
 import { execFile, spawn } from 'node:child_process';
+import { launchFleetWorker } from '../rooms-tasks/external-worker.js';
 import { OWNER_COMMENT_LABEL, ownerNotices } from './notices.js';
 /** A malformed invocation; the dispatcher answers it with annotated help. */
 class OwnerCommandUsageError extends Error {
@@ -142,6 +143,396 @@ export const ownerCommands = [
         name: 'version', summary: 'report the fleet version',
         execute: noArgs('/version', async (ctx) => ctx.reply(`ℹ️ ours-fleet ${ctx.version}`)),
     },
+    {
+        name: 'tasks', usage: '/tasks [state]',
+        summary: 'list tasks (optionally filter by state)',
+        execute: async (ctx, args) => {
+            const { listTasks } = await import('../rooms-tasks/task-state.js');
+            const stateFilter = args?.trim() || undefined;
+            const tasks = listTasks(stateFilter && stateFilter !== 'all' ? { state: stateFilter } : undefined);
+            if (!tasks.length)
+                return ctx.reply('📋 No tasks.');
+            const lines = tasks.map(t => {
+                const blocked = t.blocked ? ` [BLOCKED: ${t.blocked.reason}]` : '';
+                return `${t.task_id}  ${t.state}${blocked}  ${t.title}`;
+            });
+            await ctx.reply(tail(`📋 Tasks:\n${lines.join('\n')}`, REPLY_MAX_CHARS));
+        },
+    },
+    {
+        name: 'task',
+        usage: '/task <create|list|show|start|block|unblock|review|done|cancel|recover> ...',
+        summary: 'task lifecycle subcommands',
+        execute: async (ctx, args) => {
+            if (!args)
+                throw new OwnerCommandUsageError('usage: /task <subcommand> <id>');
+            const argLines = args.trim().split('\n');
+            const firstLineTokens = argLines[0].trim().split(/\s+/);
+            const sub = firstLineTokens[0];
+            const rest = firstLineTokens.slice(1);
+            const trailingLines = argLines.slice(1).join('\n').trim() || undefined;
+            const showTask = async (id) => {
+                const { getTask } = await import('../rooms-tasks/task-state.js');
+                const t = getTask(id);
+                const lines = [
+                    `📋 Task: ${t.task_id}`,
+                    `Title: ${t.title}`,
+                    `State: ${t.state}${t.blocked ? ` [BLOCKED: ${t.blocked.reason}]` : ''}`,
+                    ...(t.template ? [`Template: ${t.template.name}@${t.template.version}`] : []),
+                    ...(t.room_id ? [`Room: ${t.room_id}`] : []),
+                    `Origin: ${t.origin.type}`,
+                    `Created: ${t.created_at}`,
+                ];
+                await ctx.reply(lines.join('\n'));
+            };
+            try {
+                switch (sub) {
+                    case 'create': {
+                        if (!rest[0])
+                            throw new OwnerCommandUsageError('usage: /task create [--backlog] [--template=<name>|--no-room] <title>');
+                        const backlog = rest.includes('--backlog');
+                        const tplFlag = rest.find(r => r.startsWith('--template='));
+                        const template = tplFlag ? tplFlag.slice('--template='.length) : undefined;
+                        const noRoom = rest.includes('--no-room');
+                        const titleParts = rest.filter(r => r !== '--backlog' && !r.startsWith('--template=') && r !== '--no-room');
+                        if (!titleParts.length)
+                            throw new OwnerCommandUsageError('usage: /task create [--backlog] [--template=<name>|--no-room] <title>');
+                        const { createTask } = await import('../rooms-tasks/task-state.js');
+                        const t = createTask({
+                            title: titleParts.join(' '),
+                            origin: { type: 'owner_channel' },
+                            start: !backlog,
+                            ...(template ? { template: { name: template, version: 1, content_hash: '' } } : {}),
+                            ...(noRoom ? { no_room: true } : {}),
+                            ...(trailingLines ? { brief: trailingLines } : {}),
+                        });
+                        const lines = [`Task ${t.task_id} created · ${t.state}`];
+                        if (template)
+                            lines.push(`Template: ${template}`);
+                        if (noRoom)
+                            lines.push('No room requested');
+                        await ctx.reply(lines.join('\n'));
+                        break;
+                    }
+                    case 'list': {
+                        const { listTasks } = await import('../rooms-tasks/task-state.js');
+                        const filter = rest[0];
+                        const stateMap = {
+                            backlog: 'backlog', active: 'active', blocked: 'active',
+                            done: 'done', all: ['backlog', 'provisioning', 'active', 'review', 'done', 'cancelled', 'failed'],
+                        };
+                        const stateFilter = filter && stateMap[filter]
+                            ? { state: stateMap[filter] }
+                            : undefined;
+                        const tasks = listTasks(stateFilter);
+                        if (filter === 'blocked') {
+                            const blocked = tasks.filter(t => t.blocked);
+                            if (!blocked.length) {
+                                await ctx.reply('📋 No blocked tasks.');
+                                break;
+                            }
+                            const lines = blocked.map(t => `${t.task_id}  ${t.state}  ${t.title}  [BLOCKED: ${t.blocked.reason}]`);
+                            await ctx.reply(tail(`📋 Blocked tasks:\n${lines.join('\n')}`, REPLY_MAX_CHARS));
+                            break;
+                        }
+                        if (!tasks.length) {
+                            await ctx.reply('📋 No tasks.');
+                            break;
+                        }
+                        const lines = tasks.map(t => `${t.task_id}  ${t.state}  ${t.title}${t.blocked ? ` [BLOCKED]` : ''}`);
+                        await ctx.reply(tail(`📋 Tasks:\n${lines.join('\n')}`, REPLY_MAX_CHARS));
+                        break;
+                    }
+                    case 'show': {
+                        if (!rest[0])
+                            throw new OwnerCommandUsageError('usage: /task show <id>');
+                        await showTask(rest[0]);
+                        break;
+                    }
+                    case 'start': {
+                        if (!rest[0])
+                            throw new OwnerCommandUsageError('usage: /task start <id>');
+                        const { startTask } = await import('../rooms-tasks/task-state.js');
+                        const t = startTask(rest[0]);
+                        await ctx.reply(`✅ Task ${t.task_id} → provisioning`);
+                        break;
+                    }
+                    case 'block': {
+                        if (!rest[0] || !rest[1])
+                            throw new OwnerCommandUsageError('usage: /task block <id> <reason>');
+                        const { blockTask } = await import('../rooms-tasks/task-state.js');
+                        const reason = rest.slice(1).join(' ');
+                        const t = blockTask(rest[0], reason);
+                        await ctx.reply(`🚧 Task ${t.task_id} blocked: ${reason}`);
+                        break;
+                    }
+                    case 'unblock': {
+                        if (!rest[0])
+                            throw new OwnerCommandUsageError('usage: /task unblock <id>');
+                        const { unblockTask } = await import('../rooms-tasks/task-state.js');
+                        const t = unblockTask(rest[0]);
+                        await ctx.reply(`✅ Task ${t.task_id} unblocked`);
+                        break;
+                    }
+                    case 'review': {
+                        if (!rest[0])
+                            throw new OwnerCommandUsageError('usage: /task review <id>');
+                        const { reviewTask } = await import('../rooms-tasks/task-state.js');
+                        const t = reviewTask(rest[0]);
+                        await ctx.reply(`📝 Task ${t.task_id} → review`);
+                        break;
+                    }
+                    case 'done': {
+                        if (!rest[0])
+                            throw new OwnerCommandUsageError('usage: /task done <id> [summary]');
+                        const summary = rest.slice(1).join(' ') || undefined;
+                        await ctx.terminalTask(rest[0], 'done', summary ? { summary } : undefined);
+                        break;
+                    }
+                    case 'cancel': {
+                        if (rest.length < 2 || rest[0] !== rest[1])
+                            throw new OwnerCommandUsageError('destructive: /task cancel <id> <id> — provide the task ID twice');
+                        await ctx.terminalTask(rest[0], 'cancelled');
+                        break;
+                    }
+                    case 'recover': {
+                        if (!rest[0])
+                            throw new OwnerCommandUsageError('usage: /task recover <id>');
+                        const { getTask } = await import('../rooms-tasks/task-state.js');
+                        const { getRoomRecord } = await import('../rooms-tasks/room-state.js');
+                        const t = getTask(rest[0]);
+                        if (t.terminal_intent?.status === 'pending') {
+                            await ctx.terminalTask(t.task_id, t.terminal_intent.kind, t.terminal_intent.outcome);
+                            break;
+                        }
+                        const room = t.room_id ? getRoomRecord(t.room_id) : undefined;
+                        const hints = [];
+                        if (t.state === 'provisioning' && room) {
+                            if (room.provisioning_detail === 'waiting_cowork')
+                                hints.push('Cowork socket unreachable');
+                            if (room.provisioning_detail === 'waiting_owner_invite')
+                                hints.push('Owner invite missing or invalid');
+                            if (room.provisioning_detail === 'owner_cid_mismatch')
+                                hints.push('Owner CID mismatch');
+                            if (room.provisioning_detail === 'member_failed')
+                                hints.push(`Member failed at step ${room.saga.step_index}`);
+                        }
+                        const lines = [`Task ${t.task_id} · ${t.state}`];
+                        if (room)
+                            lines.push(`Room ${room.room_id} · ${room.state} · saga: ${room.saga.phase}`);
+                        if (hints.length)
+                            lines.push(`Hints: ${hints.join('; ')}`);
+                        else
+                            lines.push('No automated recovery actions available.');
+                        await ctx.reply(lines.join('\n'));
+                        break;
+                    }
+                    default:
+                        // bare /task <id> → show
+                        await showTask(sub);
+                }
+            }
+            catch (e) {
+                if (e instanceof OwnerCommandUsageError)
+                    throw e;
+                await ctx.reply(`⚠️ ${e instanceof Error ? e.message : String(e)}`);
+            }
+        },
+    },
+    {
+        name: 'rooms', summary: 'list rooms',
+        execute: noArgs('/rooms', async (ctx) => {
+            const { listRoomRecords } = await import('../rooms-tasks/room-state.js');
+            const rooms = listRoomRecords();
+            if (!rooms.length)
+                return ctx.reply('🏠 No rooms.');
+            const lines = rooms.map(r => `${r.room_id}  ${r.state}  ${r.room_name}${r.task_id ? ` (task: ${r.task_id})` : ''}`);
+            await ctx.reply(tail(`🏠 Rooms:\n${lines.join('\n')}`, REPLY_MAX_CHARS));
+        }),
+    },
+    {
+        name: 'room',
+        usage: '/room <create|list|show|close|recover> ...',
+        summary: 'room lifecycle subcommands',
+        execute: async (ctx, args) => {
+            if (!args)
+                throw new OwnerCommandUsageError('usage: /room <subcommand> <id>');
+            const argLines = args.trim().split('\n');
+            const firstLineTokens = argLines[0].trim().split(/\s+/);
+            const sub = firstLineTokens[0];
+            const rest = firstLineTokens.slice(1);
+            const roomTrailingLines = argLines.slice(1).join('\n').trim() || undefined;
+            const showRoom = async (id) => {
+                const { getRoomRecord } = await import('../rooms-tasks/room-state.js');
+                const r = getRoomRecord(id);
+                if (!r)
+                    return ctx.reply(`⚠️ room not found: ${id}`);
+                const lines = [
+                    `🏠 Room: ${r.room_id}`,
+                    `Name: ${r.room_name}`,
+                    `State: ${r.state}`,
+                    `Saga: ${r.saga.phase} (step ${r.saga.step_index})`,
+                    ...(r.task_id ? [`Task: ${r.task_id}`] : []),
+                    ...(r.provisioning_detail ? [`Detail: ${r.provisioning_detail}`] : []),
+                    ...(r.saga.error ? [`Error: ${r.saga.error}`] : []),
+                    `Created: ${r.created_at}`,
+                ];
+                await ctx.reply(lines.join('\n'));
+            };
+            try {
+                switch (sub) {
+                    case 'create': {
+                        const tplFlag = rest.find(r => r.startsWith('--template='));
+                        const templateName = tplFlag?.slice('--template='.length);
+                        const nameParts = rest.filter(r => !r.startsWith('--'));
+                        if (!nameParts.length)
+                            throw new OwnerCommandUsageError('usage: /room create --template=<name> <room name>');
+                        const { randomUUID } = await import('node:crypto');
+                        const { createRoomRecord } = await import('../rooms-tasks/room-state.js');
+                        const { resolveTemplate, snapshotTemplate } = await import('../rooms-tasks/templates.js');
+                        let templateSnapshot;
+                        if (templateName) {
+                            const tpl = resolveTemplate(templateName, {});
+                            if (!tpl)
+                                throw new OwnerCommandUsageError(`unknown template: ${templateName}`);
+                            templateSnapshot = snapshotTemplate(tpl);
+                        }
+                        const r = createRoomRecord({
+                            room_id: randomUUID().replace(/-/g, '').slice(0, 16),
+                            room_name: nameParts.join(' '),
+                            ...(templateSnapshot ? { template_snapshot: templateSnapshot } : {}),
+                            ...(roomTrailingLines ? { goal: roomTrailingLines } : {}),
+                        });
+                        const lines = [`🏠 Room ${r.room_id} created · ${r.state}`];
+                        if (templateName)
+                            lines.push(`Template: ${templateName}`);
+                        await ctx.reply(lines.join('\n'));
+                        break;
+                    }
+                    case 'list': {
+                        const { listRoomRecords } = await import('../rooms-tasks/room-state.js');
+                        const filter = rest[0];
+                        let rooms = listRoomRecords();
+                        if (filter === 'active')
+                            rooms = rooms.filter(r => r.state === 'active');
+                        if (!rooms.length) {
+                            await ctx.reply('🏠 No rooms.');
+                            break;
+                        }
+                        const lines = rooms.map(r => `${r.room_id}  ${r.state}  ${r.room_name}${r.task_id ? ` (task: ${r.task_id})` : ''}`);
+                        await ctx.reply(tail(`🏠 Rooms:\n${lines.join('\n')}`, REPLY_MAX_CHARS));
+                        break;
+                    }
+                    case 'show': {
+                        if (!rest[0])
+                            throw new OwnerCommandUsageError('usage: /room show <id>');
+                        await showRoom(rest[0]);
+                        break;
+                    }
+                    case 'close': {
+                        if (rest.length < 2 || rest[0] !== rest[1])
+                            throw new OwnerCommandUsageError('destructive: /room close <id> <id> — provide the room ID twice');
+                        await ctx.closeRoom(rest[0]);
+                        break;
+                    }
+                    case 'recover': {
+                        if (!rest[0])
+                            throw new OwnerCommandUsageError('usage: /room recover <id>');
+                        const { getRoomRecord } = await import('../rooms-tasks/room-state.js');
+                        const r = getRoomRecord(rest[0]);
+                        if (!r) {
+                            await ctx.reply(`⚠️ room not found: ${rest[0]}`);
+                            break;
+                        }
+                        if (r.state === 'closing') {
+                            await ctx.closeRoom(r.room_id);
+                            break;
+                        }
+                        const lines = [`🏠 Room ${r.room_id} · ${r.state} · saga: ${r.saga.phase}`];
+                        if (r.saga.error)
+                            lines.push(`Error: ${r.saga.error}`);
+                        if (r.provisioning_detail)
+                            lines.push(`Detail: ${r.provisioning_detail}`);
+                        lines.push(r.saga.error ? 'Run `ours-fleet room recover` from CLI for full recovery.' : 'No recovery needed.');
+                        await ctx.reply(lines.join('\n'));
+                        break;
+                    }
+                    default:
+                        // bare /room <id> → show
+                        await showRoom(sub);
+                }
+            }
+            catch (e) {
+                if (e instanceof OwnerCommandUsageError)
+                    throw e;
+                await ctx.reply(`⚠️ ${e instanceof Error ? e.message : String(e)}`);
+            }
+        },
+    },
+    {
+        name: 'templates', aliases: ['template-list'],
+        summary: 'list available room templates',
+        execute: noArgs('/templates', async (ctx) => {
+            const { listTemplates } = await import('../rooms-tasks/templates.js');
+            const templates = listTemplates({});
+            if (!templates.length)
+                return ctx.reply('📐 No templates.');
+            const lines = templates.map(t => {
+                const tag = t.builtin ? ' (built-in)' : '';
+                return `${t.name}@${t.version}${tag}  ${t.description}`;
+            });
+            await ctx.reply(`📐 Templates:\n${lines.join('\n')}`);
+        }),
+    },
+    {
+        name: 'template',
+        usage: '/template <show|list> <name[@version]>',
+        summary: 'template subcommands (show, list)',
+        execute: async (ctx, args) => {
+            if (!args)
+                throw new OwnerCommandUsageError('usage: /template show <name[@version]>');
+            const parts = args.trim().split(/\s+/);
+            const sub = parts[0];
+            const showTemplate = async (nameStr) => {
+                const { resolveTemplate } = await import('../rooms-tasks/templates.js');
+                const t = resolveTemplate(nameStr, {});
+                if (!t)
+                    return ctx.reply(`⚠️ template not found: ${nameStr}`);
+                const lines = [
+                    `📐 Template: ${t.name}@${t.version}`,
+                    `Description: ${t.description}`,
+                    ...(t.builtin ? ['Source: built-in'] : []),
+                    ...(t.contract ? [`Contract: ${t.contract}`] : []),
+                    'Members:',
+                    ...t.members.map(m => `  ${m.slot} (${m.role}) ×${m.count} → role_ref: ${m.role_ref}`),
+                ];
+                await ctx.reply(lines.join('\n'));
+            };
+            switch (sub) {
+                case 'show': {
+                    if (!parts[1])
+                        throw new OwnerCommandUsageError('usage: /template show <name[@version]>');
+                    await showTemplate(parts[1]);
+                    break;
+                }
+                case 'list': {
+                    const { listTemplates } = await import('../rooms-tasks/templates.js');
+                    const templates = listTemplates({});
+                    if (!templates.length)
+                        return ctx.reply('📐 No templates.');
+                    const lines = templates.map(t => {
+                        const tag = t.builtin ? ' (built-in)' : '';
+                        return `${t.name}@${t.version}${tag}  ${t.description}`;
+                    });
+                    await ctx.reply(`📐 Templates:\n${lines.join('\n')}`);
+                    break;
+                }
+                default:
+                    // bare /template <name> → show
+                    await showTemplate(sub);
+            }
+        },
+    },
 ];
 /** Trimmed slash-prefixed text is a command attempt and is never forwarded. */
 export const isOwnerCommandText = (text) => text.trim().startsWith('/');
@@ -195,5 +586,7 @@ export function fleetCliOps(role, configPath) {
         list: () => new Promise((resolve, reject) => {
             execFile(process.execPath, [process.argv[1], 'ls'], { timeout: 15_000, maxBuffer: 256 * 1024 }, (error, stdout) => error ? reject(error) : resolve(String(stdout).trim()));
         }),
+        closeRoom: roomId => launchFleetWorker(['room', '_close', roomId], `room-close-${roomId}`, configPath),
+        settleTask: taskId => launchFleetWorker(['task', '_settle', taskId], `task-settle-${taskId}`, configPath),
     };
 }

package/dist/owner-channel/message-recovery.d.ts

@@ -0,0 +1,25 @@
+export interface PendingMessageClaim {
+    wireId: string;
+    seq: number;
+    claimedAt: number;
+}
+/**
+ * Body-free crash journal for the SQLite getMessages read boundary.
+ *
+ * A claim lands before getMessages marks its exact oldest-first batch read.
+ * After a crash, getHistoryItem can therefore recover the body by wire ID
+ * without fleet ever duplicating message plaintext in its own state.
+ */
+export declare class MessageRecoveryState {
+    private readonly path;
+    private readonly limit;
+    private pending;
+    private corrupt;
+    constructor(path: string, limit?: number);
+    integrity(): boolean;
+    list(): PendingMessageClaim[];
+    claim(items: PendingMessageClaim[]): void;
+    pruneHandled(handled: (wireId: string) => boolean): number;
+    private assertHealthy;
+    private persist;
+}

package/dist/owner-channel/message-recovery.js

@@ -0,0 +1,114 @@
+import { chmodSync, existsSync, readFileSync } from 'node:fs';
+import { replaceFileAtomically } from '../atomic-file.js';
+const MAX_PENDING_MESSAGES = 5_000;
+const MAX_WIRE_ID_CHARS = 1_024;
+/**
+ * Body-free crash journal for the SQLite getMessages read boundary.
+ *
+ * A claim lands before getMessages marks its exact oldest-first batch read.
+ * After a crash, getHistoryItem can therefore recover the body by wire ID
+ * without fleet ever duplicating message plaintext in its own state.
+ */
+export class MessageRecoveryState {
+    path;
+    limit;
+    pending = [];
+    corrupt = false;
+    constructor(path, limit = MAX_PENDING_MESSAGES) {
+        this.path = path;
+        this.limit = limit;
+        if (!existsSync(path))
+            return;
+        try {
+            const raw = JSON.parse(readFileSync(path, 'utf8'));
+            if (raw.version !== 1 || !Array.isArray(raw.pending)
+                || raw.pending.length > limit || !raw.pending.every(validClaim)
+                || new Set(raw.pending.map(item => item.wireId)).size !== raw.pending.length)
+                throw new Error('invalid message recovery state');
+            this.pending = raw.pending.map(item => ({ ...item }));
+            chmodSync(path, 0o600);
+        }
+        catch {
+            this.corrupt = true;
+            this.pending = [];
+            try {
+                chmodSync(path, 0o600);
+            }
+            catch { /* retain the evidence */ }
+        }
+    }
+    integrity() { return !this.corrupt; }
+    list() {
+        this.assertHealthy();
+        return this.pending.map(item => ({ ...item }));
+    }
+    claim(items) {
+        this.assertHealthy();
+        if (!items.length)
+            return;
+        if (!items.every(validClaim))
+            throw new Error('invalid message recovery claim');
+        const next = this.pending.map(item => ({ ...item }));
+        const byWire = new Map(next.map(item => [item.wireId, item]));
+        for (const item of items) {
+            const existing = byWire.get(item.wireId);
+            if (existing) {
+                if (existing.seq !== item.seq)
+                    throw new Error('message recovery wire ID changed sequence');
+                continue;
+            }
+            if (next.length >= this.limit)
+                throw new Error('too many pending message recoveries');
+            const copy = { ...item };
+            next.push(copy);
+            byWire.set(copy.wireId, copy);
+        }
+        if (next.length === this.pending.length)
+            return;
+        const previous = this.pending;
+        this.pending = next;
+        try {
+            this.persist();
+        }
+        catch (error) {
+            this.pending = previous;
+            throw error;
+        }
+    }
+    pruneHandled(handled) {
+        this.assertHealthy();
+        const next = this.pending.filter(item => !handled(item.wireId));
+        const removed = this.pending.length - next.length;
+        if (!removed)
+            return 0;
+        const previous = this.pending;
+        this.pending = next;
+        try {
+            this.persist();
+        }
+        catch (error) {
+            this.pending = previous;
+            throw error;
+        }
+        return removed;
+    }
+    assertHealthy() {
+        if (this.corrupt)
+            throw new Error('message recovery state is corrupt');
+    }
+    persist() {
+        replaceFileAtomically(this.path, JSON.stringify({
+            version: 1, pending: this.pending,
+        }) + '\n', 0o600);
+        chmodSync(this.path, 0o600);
+    }
+}
+function validClaim(value) {
+    if (!value || typeof value !== 'object')
+        return false;
+    const item = value;
+    return typeof item.wireId === 'string' && item.wireId.length >= 1
+        && Array.from(item.wireId).length <= MAX_WIRE_ID_CHARS
+        && Number.isSafeInteger(item.seq) && item.seq >= 1
+        && Number.isSafeInteger(item.claimedAt) && item.claimedAt >= 0;
+}

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

@@ -22,13 +22,6 @@ export declare const ownerNotices: {
     receivedStarted: () => string;
     receivedQueued: (queuedBehind: number) => string;
     receivedInterrupting: () => string;
-    /**
-     * The honest answer when the agent is mid-task and pre-empting it would have
-     * corrupted the conversation. Says "not started yet" rather than borrowing
-     * `receivedInterrupting`'s claim that something was cancelled for this
-     * request.
-     */
-    receivedDeferred: () => string;
     status: (role: string, snapshot: SessionSnapshot) => string;
     interrupted: (role: string) => string;
     /** The turn IS cancelled — say how, without implying the owner must retry. */

package/dist/owner-channel/notices.js

@@ -26,15 +26,6 @@ export const ownerNotices = {
     receivedInterrupting: () => "ℹ️ Message received. The agent's previous task was interrupted to prioritize "
         + 'this request, and it is now working on a response. '
         + 'The response will arrive in this channel when ready.',
-    /**
-     * The honest answer when the agent is mid-task and pre-empting it would have
-     * corrupted the conversation. Says "not started yet" rather than borrowing
-     * `receivedInterrupting`'s claim that something was cancelled for this
-     * request.
-     */
-    receivedDeferred: () => 'ℹ️ Message received and held. The agent is in the middle of a task that '
-        + 'cannot be interrupted safely; this request starts as soon as that work '
-        + 'reaches a stopping point. The response will arrive in this channel when ready.',
     status: (role, snapshot) => `📊 ${role} status: ${snapshot.readiness}; session is ${snapshot.alive ? 'online' : 'offline'}.`,
     interrupted: (role) => `🛑 Interrupt sent to ${role}'s active turn.`,
     /** The turn IS cancelled — say how, without implying the owner must retry. */