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

package/dist/owner-channel/commands.js

@@ -142,6 +142,95 @@ 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 <id>',
+        summary: 'show task details',
+        execute: async (ctx, args) => {
+            if (!args)
+                throw new OwnerCommandUsageError('usage: /task <id>');
+            const { getTask } = await import('../rooms-tasks/task-state.js');
+            try {
+                const t = getTask(args.trim());
+                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'));
+            }
+            catch (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 <id>',
+        summary: 'show room details',
+        execute: async (ctx, args) => {
+            if (!args)
+                throw new OwnerCommandUsageError('usage: /room <id>');
+            const { getRoomRecord } = await import('../rooms-tasks/room-state.js');
+            const r = getRoomRecord(args.trim());
+            if (!r)
+                return ctx.reply(`⚠️ room not found: ${args.trim()}`);
+            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'));
+        },
+    },
+    {
+        name: 'templates', 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')}`);
+        }),
+    },
 ];
 /** Trimmed slash-prefixed text is a command attempt and is never forwarded. */
 export const isOwnerCommandText = (text) => text.trim().startsWith('/');

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. */

package/dist/owner-channel/ours-client.d.ts

@@ -0,0 +1,148 @@
+import { OursClient, type AttachOursClientOptions, type NotificationEvent } from '@ours.network/sdk/client';
+/** Any failure of a daemon operation. Never carries a message body or a token. */
+export declare class OursDaemonError extends Error {
+}
+/**
+ * The daemon accepted the call and answered "not sent". The MCP surface reported
+ * exactly these verdicts as tool errors, so they must keep throwing here: the
+ * owner channel books a resolved send as delivered, and a silently-swallowed
+ * refusal would be recorded as a delivered message that never left the host.
+ */
+export declare class OursSendRefusedError extends OursDaemonError {
+}
+type Res<M extends keyof OursClient> = OursClient[M] extends (...args: never[]) => infer R ? Awaited<R> : never;
+export type OursContactsView = Res<'listContacts'>;
+export type OursInviteResult = Res<'generateInvite'>;
+export type OursAddContactResult = Res<'addContact'>;
+export type OursIncomingMessage = Res<'listIncomingMessages'>[number];
+export type OursMessagesPayload = Res<'getMessages'>;
+export type OursInboundMessage = OursMessagesPayload['messages'][number];
+export type OursHistoryMessage = NonNullable<Res<'getHistoryItem'>>;
+export type OursIncomingFile = Res<'listIncomingFiles'>[number];
+export type OursRetrievedFiles = Res<'getFiles'>;
+export type OursRetrievedFile = OursRetrievedFiles['files'][number];
+export type OursHistoryFile = NonNullable<Res<'getFileInfo'>>;
+export type OursNotificationEvent = NotificationEvent;
+export declare class OursWatchDeadlineError extends OursDaemonError {
+}
+/**
+ * The daemon operations the owner channel needs, one typed method each.
+ *
+ * This interface deliberately has no generic `callTool(name, args): unknown`
+ * escape hatch. The legacy MCP connector answered every
+ * tool with `{content:[{type:'text',...}]}` and no `structuredContent`, the
+ * transport fell back to returning the daemon's English sentence — which the
+ * channel then pattern-matched (an invite blob sliced out of a prose sentence,
+ * a bind conflict detected with /currently bound to another live session/i).
+ * With no untyped result there is nothing left to pattern-match.
+ */
+export interface OursOps {
+    /** Prepare the transport. Must be called before any operation. */
+    start(): Promise<void>;
+    /** Bind this session's identity. Throws `BOUND_ELSEWHERE` when it is held live. */
+    bindIdentity(name: string): Promise<void>;
+    listContacts(): Promise<OursContactsView>;
+    generateInvite(name?: string): Promise<OursInviteResult>;
+    addContact(a: {
+        invite: string;
+        name?: string;
+    }): Promise<OursAddContactResult>;
+    listIncomingMessages(): Promise<OursIncomingMessage[]>;
+    getMessages(limit: number): Promise<OursMessagesPayload>;
+    getHistoryItem(wireId: string): Promise<OursHistoryMessage | null>;
+    watchNotifications(identity: string, options?: {
+        since?: number | 'tip';
+        signal?: AbortSignal;
+    }): AsyncGenerator<OursNotificationEvent, void, undefined>;
+    listIncomingFiles(): Promise<OursIncomingFile[]>;
+    getFileInfo(wireId: string): Promise<OursHistoryFile | null>;
+    getFiles(wireIds: string[]): Promise<OursRetrievedFiles>;
+    /**
+     * The bytes of an already-retrieved file. Transport only — the caller owns
+     * where they land, so path safety stays with the attachment code that already
+     * enforces it (`writeRecoveredAttachment`).
+     */
+    fetchFile(wireId: string): Promise<Uint8Array>;
+    sendMessage(a: {
+        contact: string;
+        text: string;
+        replyToWireId?: string;
+    }): Promise<void>;
+    sendFile(a: {
+        contact: string;
+        path: string;
+        filename: string;
+        replyToWireId?: string;
+    }): Promise<void>;
+    /** Release the daemon lease and stop. Never throws. */
+    close(): Promise<void>;
+}
+/**
+ * The typed error code of a daemon operation, or undefined when the failure was
+ * not one (transport, abort, programming error). `instanceof` is checked first;
+ * the structural fallback keeps a duplicated SDK copy in a consumer's tree from
+ * silently demoting a real daemon verdict to "unknown transport failure".
+ */
+export declare function oursErrorCode(error: unknown): string | undefined;
+/** The identity is bound by another live session; a predecessor may still be releasing it. */
+export declare const OURS_BOUND_ELSEWHERE = "BOUND_ELSEWHERE";
+export interface OursSdkClientDeps {
+    /** Test seam; production uses the SDK's coherence-checking application attach path. */
+    attachClient?(options: AttachOursClientOptions): OursClient | Promise<OursClient>;
+    /** Underlying transport and deadline seams for deterministic half-open tests. */
+    fetch?: typeof globalThis.fetch;
+    notificationRequestDeadlineMs?: number;
+    readFile?(path: string): Promise<Uint8Array>;
+}
+/**
+ * The owner-channel's daemon client: one `OursClient` over the local ours HTTP
+ * API, owning exactly one identity binding.
+ *
+ * Lease lifetime. The lease token IS the session, so each channel instance mints
+ * its own and hands it back in `close()`. That replaces the connector proxy's
+ * shell-PID fence, which existed because a supervised attempt had to make its
+ * lease reclaimable while the supervisor itself stayed alive: an explicit
+ * release does that deterministically, and `clientPid` still covers the case
+ * where the whole supervisor dies without unwinding.
+ */
+export declare class OursSdkClient implements OursOps {
+    private readonly env;
+    private readonly log;
+    private readonly deps;
+    private client?;
+    private readonly leaseToken;
+    constructor(env?: Record<string, string>, log?: (line: string) => void, deps?: OursSdkClientDeps);
+    start(): Promise<void>;
+    bindIdentity(name: string): Promise<void>;
+    listContacts(): Promise<OursContactsView>;
+    generateInvite(name?: string): Promise<OursInviteResult>;
+    addContact(a: {
+        invite: string;
+        name?: string;
+    }): Promise<OursAddContactResult>;
+    listIncomingMessages(): Promise<OursIncomingMessage[]>;
+    getMessages(limit: number): Promise<OursMessagesPayload>;
+    getHistoryItem(wireId: string): Promise<OursHistoryMessage | null>;
+    watchNotifications(identity: string, options?: {
+        since?: number | 'tip';
+        signal?: AbortSignal;
+    }): AsyncGenerator<OursNotificationEvent, void, undefined>;
+    listIncomingFiles(): Promise<OursIncomingFile[]>;
+    getFileInfo(wireId: string): Promise<OursHistoryFile | null>;
+    getFiles(wireIds: string[]): Promise<OursRetrievedFiles>;
+    fetchFile(wireId: string): Promise<Uint8Array>;
+    sendMessage(a: {
+        contact: string;
+        text: string;
+        replyToWireId?: string;
+    }): Promise<void>;
+    sendFile(a: {
+        contact: string;
+        path: string;
+        filename: string;
+        replyToWireId?: string;
+    }): Promise<void>;
+    close(): Promise<void>;
+    private ops;
+}
+export {};

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

@@ -0,0 +1,231 @@
+import { randomUUID } from 'node:crypto';
+import { readFile } from 'node:fs/promises';
+import { extname } from 'node:path';
+import { OursError, attachOursClient, } from '@ours.network/sdk/client';
+/** Any failure of a daemon operation. Never carries a message body or a token. */
+export class OursDaemonError extends Error {
+}
+/**
+ * The daemon accepted the call and answered "not sent". The MCP surface reported
+ * exactly these verdicts as tool errors, so they must keep throwing here: the
+ * owner channel books a resolved send as delivered, and a silently-swallowed
+ * refusal would be recorded as a delivered message that never left the host.
+ */
+export class OursSendRefusedError extends OursDaemonError {
+}
+// The daemon normally returns a quiet long-poll within 25 seconds. Keep the
+// client-side fence comfortably above it so ordinary quiet periods do not
+// recycle a healthy stream, while a half-open socket still heals on its own.
+const NOTIFICATION_REQUEST_DEADLINE_MS = 120_000;
+// SDK sendFile({path}) inferred these common types before reading the path in
+// the daemon process. Staged uploads move that read into fleet, so preserve the
+// same advertised MIME rather than silently turning every attachment into an
+// octet stream. Importing the SDK root just for its helper would also pull the
+// daemon runtime into this client-only process.
+const FILE_MIME_BY_EXTENSION = {
+    '.png': 'image/png', '.jpg': 'image/jpeg', '.jpeg': 'image/jpeg', '.gif': 'image/gif',
+    '.webp': 'image/webp', '.svg': 'image/svg+xml', '.bmp': 'image/bmp', '.ico': 'image/x-icon',
+    '.pdf': 'application/pdf', '.txt': 'text/plain', '.md': 'text/markdown',
+    '.json': 'application/json', '.csv': 'text/csv', '.html': 'text/html',
+    '.xml': 'application/xml', '.zip': 'application/zip', '.gz': 'application/gzip',
+    '.tar': 'application/x-tar', '.mp3': 'audio/mpeg', '.wav': 'audio/wav',
+    '.mp4': 'video/mp4', '.mov': 'video/quicktime',
+};
+function mimeFromFilename(filename) {
+    return FILE_MIME_BY_EXTENSION[extname(filename).toLowerCase()] ?? 'application/octet-stream';
+}
+export class OursWatchDeadlineError extends OursDaemonError {
+}
+function notificationRequest(input) {
+    const url = typeof input === 'string' || input instanceof URL ? String(input) : input.url;
+    return /\/identities\/[^/]+\/notifications(?:\?|$)/.test(url);
+}
+function notificationDeadlineFetch(fetchImpl, deadlineMs) {
+    return async (input, init) => {
+        if (!notificationRequest(input))
+            return fetchImpl(input, init);
+        const ctrl = new AbortController();
+        const upstream = init?.signal;
+        let rejectFence;
+        const fence = new Promise((_resolve, reject) => { rejectFence = reject; });
+        const abortUpstream = () => {
+            const reason = upstream?.reason
+                ?? new DOMException('ours notification request aborted', 'AbortError');
+            ctrl.abort(reason);
+            // Shutdown must not wait for the deadline when a custom fetch ignores
+            // AbortSignal either.
+            rejectFence(reason);
+        };
+        if (upstream?.aborted)
+            abortUpstream();
+        else
+            upstream?.addEventListener('abort', abortUpstream, { once: true });
+        const timer = setTimeout(() => {
+            const error = new OursWatchDeadlineError('ours notification request deadline exceeded');
+            ctrl.abort(error);
+            // Do not rely on a custom or half-open fetch implementation to honor
+            // AbortSignal: the fence itself must always settle the request.
+            rejectFence(error);
+        }, deadlineMs);
+        timer.unref?.();
+        try {
+            return await Promise.race([
+                fetchImpl(input, { ...init, signal: ctrl.signal }),
+                fence,
+            ]);
+        }
+        finally {
+            clearTimeout(timer);
+            upstream?.removeEventListener('abort', abortUpstream);
+        }
+    };
+}
+/**
+ * The typed error code of a daemon operation, or undefined when the failure was
+ * not one (transport, abort, programming error). `instanceof` is checked first;
+ * the structural fallback keeps a duplicated SDK copy in a consumer's tree from
+ * silently demoting a real daemon verdict to "unknown transport failure".
+ */
+export function oursErrorCode(error) {
+    if (error instanceof OursError)
+        return error.code;
+    if (error instanceof Error && error.name === 'OursError') {
+        const code = error.code;
+        if (typeof code === 'string')
+            return code;
+    }
+    return undefined;
+}
+/** The identity is bound by another live session; a predecessor may still be releasing it. */
+export const OURS_BOUND_ELSEWHERE = 'BOUND_ELSEWHERE';
+/**
+ * The owner-channel's daemon client: one `OursClient` over the local ours HTTP
+ * API, owning exactly one identity binding.
+ *
+ * Lease lifetime. The lease token IS the session, so each channel instance mints
+ * its own and hands it back in `close()`. That replaces the connector proxy's
+ * shell-PID fence, which existed because a supervised attempt had to make its
+ * lease reclaimable while the supervisor itself stayed alive: an explicit
+ * release does that deterministically, and `clientPid` still covers the case
+ * where the whole supervisor dies without unwinding.
+ */
+export class OursSdkClient {
+    env;
+    log;
+    deps;
+    client;
+    leaseToken = `ours-fleet-owner-${process.pid}-${randomUUID()}`;
+    constructor(env = {}, log = () => undefined, deps = {}) {
+        this.env = env;
+        this.log = log;
+        this.deps = deps;
+    }
+    async start() {
+        if (this.client)
+            return;
+        const environment = { ...process.env, ...this.env };
+        // SDK 2's supported application path resolves endpoint, state root, and
+        // token as one coherent selection, proves the daemon's state root before
+        // sending credentials, and only then constructs the client.
+        const options = {
+            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));
+    }
+    async bindIdentity(name) {
+        // force is pinned off: the owner channel never evicts another live session
+        // from an identity, it waits for the bounded handoff window and then fails.
+        await this.ops().chooseIdentity({ name, force: false });
+    }
+    async listContacts() {
+        return this.ops().listContacts();
+    }
+    async generateInvite(name) {
+        return this.ops().generateInvite(name ? { name } : {});
+    }
+    async addContact(a) {
+        return this.ops().addContact({ invite: a.invite, ...(a.name ? { name: a.name } : {}) });
+    }
+    async listIncomingMessages() {
+        return this.ops().listIncomingMessages();
+    }
+    async getMessages(limit) {
+        return this.ops().getMessages({ limit });
+    }
+    async getHistoryItem(wireId) {
+        return this.ops().getHistoryItem({ wire_id: wireId });
+    }
+    watchNotifications(identity, options) {
+        return this.ops().watchNotifications(identity, options);
+    }
+    async listIncomingFiles() {
+        return this.ops().listIncomingFiles();
+    }
+    async getFileInfo(wireId) {
+        return this.ops().getFileInfo({ wire_id: wireId });
+    }
+    async getFiles(wireIds) {
+        return this.ops().getFiles({ wire_ids: wireIds });
+    }
+    async fetchFile(wireId) {
+        // save_file has no SDK operation on purpose: that daemon route only reports
+        // that a too-old connector reached it. The bytes of a retrieved file are
+        // already on disk, so read them back and let the caller write them as this
+        // process's own OS user.
+        return this.ops().fetchFile(wireId);
+    }
+    async sendMessage(a) {
+        const verdict = await this.ops().sendMessage({
+            contact: a.contact, text: a.text,
+            ...(a.replyToWireId ? { reply_to_wire_id: a.replyToWireId } : {}),
+        });
+        // Legacy parity: only `refused` was a tool error. `migrating`,
+        // `deferred` and `e2e` are accepted-and-queued outcomes that it reported as
+        // success, so they must not become failures here.
+        if (verdict.kind === 'refused')
+            throw new OursSendRefusedError('the daemon refused the message: the contact\'s end-to-end session must be '
+                + 're-established after an upgrade; it was not sent and not downgraded');
+    }
+    async sendFile(a) {
+        // The shared daemon may be owned by a different OS process/user and must
+        // never be expected to open fleet-private outbox paths. SDK 2 stages bytes
+        // read by THIS process, then sends only the opaque upload receipt.
+        const bytes = await (this.deps.readFile?.(a.path) ?? readFile(a.path));
+        const staged = await this.ops().uploadFile(bytes, {
+            filename: a.filename, mime: mimeFromFilename(a.filename),
+        });
+        const verdict = await this.ops().sendFile({
+            contact: a.contact, upload_id: staged.upload_id, filename: a.filename,
+            ...(a.replyToWireId ? { reply_to_wire_id: a.replyToWireId } : {}),
+        });
+        // Legacy parity treated `migrating` as an error for
+        // files and as success for messages: files are not auto-queued behind a
+        // migration, so "queued" would be a false delivery claim.
+        if (verdict.kind === 'refused' || verdict.kind === 'migrating')
+            throw new OursSendRefusedError(`the daemon did not send the file (${verdict.kind}): the contact's end-to-end `
+                + 'session must be re-established after an upgrade; files are not queued');
+    }
+    async close() {
+        const client = this.client;
+        this.client = undefined;
+        if (!client)
+            return;
+        // Handing the lease back is what lets a successor bind this identity without
+        // waiting for the supervisor to exit. A failure here is not fatal — the
+        // daemon still reclaims the lease when this process dies.
+        try {
+            await client.releaseLease();
+        }
+        catch (error) {
+            this.log(`lease release failed: ${error?.message ?? String(error)}`);
+        }
+    }
+    ops() {
+        if (!this.client)
+            throw new OursDaemonError('ours daemon client is not started');
+        return this.client;
+    }
+}

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

@@ -0,0 +1,4 @@
+import type { Command } from 'commander';
+export declare function registerTemplateCommands(parent: Command, cOpt: (cmd: Command) => Command): void;
+export declare function registerTaskCommands(parent: Command, cOpt: (cmd: Command) => Command): void;
+export declare function registerRoomCommands(parent: Command, cOpt: (cmd: Command) => Command): void;