@ours.network/fleet 0.17.7 → 0.18.0-nightly.2

package/dist/owner-channel/channel.js

@@ -1,5 +1,5 @@
 import { spawn } from 'node:child_process';
-import { createHash, randomUUID } from 'node:crypto';
+import { createHash } from 'node:crypto';
 import { existsSync, readFileSync } from 'node:fs';
 import { mkdir, readFile, readdir, rm } from 'node:fs/promises';
 import { createInterface } from 'node:readline';
@@ -10,11 +10,11 @@ import { resolveEndpoint } from '../monitor.js';
 import { ACP_CANCEL_DEADLINE_EXCEEDED, SessionControlError, interruptOutcome, } from '../session/types.js';
 import { VERSION } from '../version.js';
 import { dispatchOwnerCommand, fleetCliOps, isOwnerCommandText, } from './commands.js';
-import { OursMcpClient } from './mcp.js';
+import { OURS_BOUND_ELSEWHERE, OursSdkClient, oursErrorCode, } from './ours-client.js';
 import { ownerNotices, } from './notices.js';
 import { DuplicateSendError, OwnerAuthorizationState, OwnerChannelState, OwnerConversationState, } from './state.js';
 import { OwnerTaskState, ownerTaskAuditId, ownerTaskDigest, } from './tasks.js';
-import { AttachmentRecoveryState, admitAttachments, cleanupAttachmentRoot, parseIncomingAttachments, parseRetrievedAttachments, prepareAttachmentDirectory, recoveredAttachment, removeRequestDirectory, safeField, validateAttachmentSelection, validateAttachmentRelaySelection, } from './attachments.js';
+import { AttachmentRecoveryState, admitAttachments, cleanupAttachmentRoot, parseIncomingAttachments, parseRetrievedAttachments, prepareAttachmentDirectory, recoveredAttachment, removeRequestDirectory, safeField, validateAttachmentSelection, validateAttachmentRelaySelection, writeRecoveredAttachment, } from './attachments.js';
 import { acquireOwnerBinderLease, OWNER_BIND_HANDOFF_TIMEOUT_MS, } from './binder.js';
 const OWNER_UPDATE_MIN_INTERVAL_MS = 5_000;
 const OWNER_UPDATE_MAX_COUNT = 20;
@@ -84,7 +84,7 @@ export class OwnerChannel {
     fleetOps;
     constructor(options) {
         this.options = options;
-        this.client = options.client ?? new OursMcpClient(options.command, options.env, line => options.log(`[${options.role}] owner channel ${line}`));
+        this.client = options.client ?? new OursSdkClient(options.env, line => options.log(`[${options.role}] owner channel ${line}`));
         this.fleetOps = options.fleet ?? fleetCliOps(options.role, options.configPath);
         this.state = new OwnerChannelState(join(options.stateDir, '.owner-channel-state.json'));
         this.authorizations = new OwnerAuthorizationState(join(options.stateDir, '.owner-channel-owners.json'), options.config.owners);
@@ -123,12 +123,16 @@ export class OwnerChannel {
             const bindStartedAt = now();
             for (;;) {
                 try {
-                    await this.client.callTool('choose_identity', { name: this.options.config.identity });
+                    await this.client.bindIdentity(this.options.config.identity);
                     break;
                 }
                 catch (error) {
-                    const message = error?.message ?? String(error);
-                    const liveConflict = /currently bound to another live session/i.test(message);
+                    // The predecessor's lease may still be in flight. Only the daemon's
+                    // own typed verdict may extend the handoff window: matching the
+                    // wording of an error message would let any other failure whose text
+                    // happens to say "bound to another live session" — including one
+                    // relayed from a peer — spin here for the whole timeout.
+                    const liveConflict = oursErrorCode(error) === OURS_BOUND_ELSEWHERE;
                     if (!this.binder.inherited || !liveConflict
                         || now() - bindStartedAt >= OWNER_BIND_HANDOFF_TIMEOUT_MS)
                         throw error;
@@ -201,13 +205,10 @@ export class OwnerChannel {
                 ? ' with interruption'
                 : event.monitor.interrupt === 'after_tool' ? ' with after-tool steering' : '';
             const monitor = `${event.monitor.mode} monitor${monitorPolicy}`;
-            const permission = event.permissionMode
-                ? `; permission ${event.permissionMode.fleetMode}, native ${event.permissionMode.nativeMode}`
-                : '';
             const inherited = event.inherited.length
                 ? ` Supervisor inherited omitted defaults: ${event.inherited.join(', ')}.` : '';
             await this.sendProactiveMessage(`🧑‍💻 ${event.caller} spawned ${event.lifetime} agent ${event.role} `
-                + `(${event.harness}/${event.session}${model}; ${monitor}${permission}).${inherited}`, `fleet-spawn\0${event.creationActionId}`, 0);
+                + `(${event.harness}/${event.session}${model}; ${monitor}).${inherited}`, `fleet-spawn\0${event.creationActionId}`, 0);
         });
         this.managementTail = run.then(() => undefined, () => undefined);
         return run;
@@ -220,11 +221,14 @@ export class OwnerChannel {
                 return { action: request.action, contacts: await this.contacts() };
             case 'contact_invite': {
                 this.assertLabel(request.name);
-                const raw = await this.client.callTool('generate_invite', request.name ? { name: request.name } : {});
-                const invite = typeof raw === 'string' ? raw : String(raw?.invite ?? '');
-                if (!invite)
-                    throw new Error('ours-mcp returned no invite');
-                return { action: request.action, invite };
+                // The invite is the blob field, not a sentence containing it. The MCP
+                // surface answered with "One-time invite for X created (invite_id …).
+                // Share this blob out-of-band …:\n<blob>" and the whole sentence was
+                // handed out as the invite, so any rewording changed the payload.
+                const { blob } = await this.client.generateInvite(request.name);
+                if (typeof blob !== 'string' || !blob)
+                    throw new Error('the ours daemon returned no invite blob');
+                return { action: request.action, invite: blob };
             }
             case 'contact_add': {
                 if (typeof request.invite !== 'string' || !request.invite)
@@ -232,18 +236,19 @@ export class OwnerChannel {
                 if (Buffer.byteLength(request.invite) > 48 * 1024)
                     throw new Error('invite exceeds 49152 bytes');
                 this.assertLabel(request.name);
-                let raw;
+                let added;
                 try {
-                    raw = await this.client.callTool('add_contact', {
+                    added = await this.client.addContact({
                         invite: request.invite, ...(request.name ? { name: request.name } : {}),
                     });
                 }
                 catch {
                     // Daemon errors are not allowed to reflect invite material through
                     // the control response, CLI stderr, or supervisor logs.
-                    throw new Error('ours-mcp could not accept the contact invite');
+                    throw new Error('the ours daemon could not accept the contact invite');
                 }
-                return { action: request.action, status: 'pending', contact: this.contact(raw) };
+                const contact = this.contact(added.cid, added.display, 'pending');
+                return { action: request.action, status: 'pending', ...(contact ? { contact } : {}) };
             }
             case 'owner_list':
                 return {
@@ -317,33 +322,36 @@ export class OwnerChannel {
                 throw new Error('unknown owner-channel management action');
         }
     }
+    /**
+     * The daemon reports established contacts and pending introductions as two
+     * separate collections, so the status is structural rather than a word parsed
+     * out of a rendered line. Nothing here can be spoofed by a contact's own
+     * display name.
+     */
     async contacts() {
-        const raw = await this.client.callTool('list_contacts');
-        const values = Array.isArray(raw) ? raw : raw?.contacts;
-        if (!Array.isArray(values))
-            return [];
-        return values.map(value => this.contact(value)).filter((v) => Boolean(v))
+        const view = await this.client.listContacts();
+        const rows = [
+            ...(Array.isArray(view?.contacts) ? view.contacts : [])
+                .map(row => this.contact(row?.container_id, row?.name, 'established', view)),
+            ...(Array.isArray(view?.pending) ? view.pending : [])
+                .map(row => this.contact(row?.container_id, row?.name, 'pending', view)),
+        ];
+        return rows.filter((row) => Boolean(row))
             .sort((a, b) => a.cid.localeCompare(b.cid));
     }
-    contact(raw) {
-        if (!raw || typeof raw !== 'object')
-            return undefined;
-        const value = raw;
-        const cid = String(value.cid ?? value.id ?? value.container_id ?? value.containerId ?? '');
+    contact(cidValue, nameValue, status, view) {
+        const cid = String(cidValue ?? '');
         if (!/^[A-Fa-f0-9]{64}$/.test(cid))
             return undefined;
-        const humanRaw = value.human ?? value.root;
-        const human = humanRaw && typeof humanRaw === 'object' ? humanRaw : undefined;
+        const root = view?.roots?.[cid];
+        const rootCid = String(root?.root_cid ?? '');
         return {
             cid,
-            name: this.safeMetadata(value.name ?? value.display_name ?? cid),
-            status: this.safeMetadata(value.status ?? 'established'),
-            ...(typeof value.kind === 'string' ? { kind: this.safeMetadata(value.kind) } : {}),
-            ...(human ? { human: {
-                    ...(typeof (human.cid ?? human.id) === 'string'
-                        && /^[A-Fa-f0-9]{64}$/.test(String(human.cid ?? human.id))
-                        ? { cid: String(human.cid ?? human.id) } : {}),
-                    ...(human.name ? { name: this.safeMetadata(human.name) } : {}),
+            name: this.safeMetadata(nameValue ?? cid),
+            status,
+            ...(root ? { human: {
+                    ...(/^[A-Fa-f0-9]{64}$/.test(rootCid) ? { cid: rootCid } : {}),
+                    ...(root.root_name ? { name: this.safeMetadata(root.root_name) } : {}),
                 } } : {}),
         };
     }
@@ -528,16 +536,16 @@ export class OwnerChannel {
         // A finite cap protects the supervisor if a broken daemon repeats unread
         // messages forever. A watch notification will resume draining later.
         for (let pass = 0; pass < 100 && !this.stopping; pass++) {
-            const [raw, fileResult] = await Promise.all([
-                this.client.callTool('get_messages'),
-                this.client.callTool('list_incoming_files')
+            const [payload, fileResult] = await Promise.all([
+                this.client.getMessages(),
+                this.client.listIncomingFiles()
                     .catch(error => {
                     this.logError('attachment metadata inspection unavailable', error);
                     return undefined;
                 }),
             ]);
-            const messages = Array.isArray(raw?.messages)
-                ? raw.messages.filter(message => message && typeof message === 'object')
+            const messages = Array.isArray(payload?.messages)
+                ? payload.messages.filter(message => message && typeof message === 'object')
                 : [];
             let files = [];
             try {
@@ -561,7 +569,7 @@ export class OwnerChannel {
                     && Number.isInteger(message.msg_id);
             }).map(message => message.msg_id);
             if (deferred.length)
-                await this.client.callTool('defer_messages', { msg_ids: deferred });
+                await this.client.deferMessages(deferred);
             let advanced = false;
             const consumedMessages = new Set();
             const groups = this.attachmentGroups(files, messages, pending, consumedMessages);
@@ -692,15 +700,12 @@ export class OwnerChannel {
             const unread = group.files.filter(file => file.status === 'unread');
             const processed = group.files.filter(file => file.status !== 'unread');
             const retrieved = unread.length
-                ? parseRetrievedAttachments(await this.client.callTool('get_files', {
-                    wire_ids: unread.map(file => file.wireId),
-                }), unread)
+                ? parseRetrievedAttachments(await this.client.getFiles(unread.map(file => file.wireId)), unread)
                 : [];
             for (const file of processed) {
                 if (!group.recovery)
                     throw new Error('unexpected processed attachment without recovery route');
-                const recoveryPath = join(requestDir, `.recovered-${file.wireId}-${randomUUID()}`);
-                await this.client.callTool('save_file', { wire_id: file.wireId, dest_path: recoveryPath });
+                const recoveryPath = await writeRecoveredAttachment(requestDir, file.wireId, await this.client.fetchFile(file.wireId));
                 retrieved.push(await recoveredAttachment(file, recoveryPath));
             }
             const order = new Map(group.files.map((file, index) => [file.wireId, index]));
@@ -797,12 +802,12 @@ export class OwnerChannel {
                     // the authenticated agent once so the wait is never silent.
                     this.options.log(`[${this.options.role}] owner channel managed-agent relay has no owner `
                         + `route yet; message stays queued: ${this.errorText(error)}`);
-                    await this.nackManagedAgent(sender.id, message, wireId, ownerNotices.relayQueued());
+                    await this.nackManagedAgent(sender.id, message.wire_id ? wireId : undefined, wireId, ownerNotices.relayQueued());
                     return false;
                 }
                 else {
                     this.logError('managed-agent message relay refused', error);
-                    await this.nackManagedAgent(sender.id, message, wireId, ownerNotices.relayRefused(this.errorText(error)));
+                    await this.nackManagedAgent(sender.id, message.wire_id ? wireId : undefined, wireId, ownerNotices.relayRefused(this.errorText(error)));
                 }
             }
             this.state.remember(wireId);
@@ -1047,7 +1052,9 @@ export class OwnerChannel {
     async handleManagedAgentAttachmentGroup(group, handledWireIds, agent) {
         const captionWire = group.caption ? this.wireId(group.caption) : undefined;
         const nackWire = captionWire ?? group.files[0].wireId;
-        const nackMessage = group.caption ?? { wire_id: nackWire };
+        // A caption whose own wire id is synthetic (msg_id only) must not be echoed
+        // back as a reply reference; a file wire always is a real one.
+        const nackReplyTo = (group.caption ? group.caption.wire_id : nackWire) ? nackWire : undefined;
         let requestDir;
         let recovery;
         try {
@@ -1083,15 +1090,12 @@ export class OwnerChannel {
             const unread = group.files.filter(file => file.status === 'unread');
             const processed = group.files.filter(file => file.status !== 'unread');
             const retrieved = unread.length
-                ? parseRetrievedAttachments(await this.client.callTool('get_files', {
-                    wire_ids: unread.map(file => file.wireId),
-                }), unread)
+                ? parseRetrievedAttachments(await this.client.getFiles(unread.map(file => file.wireId)), unread)
                 : [];
             for (const file of processed) {
                 if (!group.recovery)
                     throw new Error('unexpected processed attachment without recovery route');
-                const recoveryPath = join(requestDir, `.recovered-${file.wireId}-${randomUUID()}`);
-                await this.client.callTool('save_file', { wire_id: file.wireId, dest_path: recoveryPath });
+                const recoveryPath = await writeRecoveredAttachment(requestDir, file.wireId, await this.client.fetchFile(file.wireId));
                 retrieved.push(await recoveredAttachment(file, recoveryPath));
             }
             const order = new Map(group.files.map((file, index) => [file.wireId, index]));
@@ -1103,9 +1107,9 @@ export class OwnerChannel {
                 if (caption)
                     await this.send(contact, caption, replyTo);
                 for (const file of admitted) {
-                    await this.client.callTool('send_file', {
+                    await this.client.sendFile({
                         contact, path: file.path, filename: file.filename,
-                        ...(replyTo ? { reply_to_wire_id: replyTo } : {}),
+                        ...(replyTo ? { replyToWireId: replyTo } : {}),
                     });
                 }
             }
@@ -1142,11 +1146,11 @@ export class OwnerChannel {
             if (error instanceof RelayUnroutableError) {
                 this.options.log(`[${this.options.role}] managed-agent attachment has no owner route; `
                     + `transaction stays queued: ${this.errorText(error)}`);
-                await this.nackManagedAgent(agent, nackMessage, nackWire, ownerNotices.relayQueued());
+                await this.nackManagedAgent(agent, nackReplyTo, nackWire, ownerNotices.relayQueued());
                 return false;
             }
             this.logError('managed-agent caption/file relay refused', error);
-            await this.nackManagedAgent(agent, nackMessage, nackWire, ownerNotices.relayRefused(this.errorText(error)));
+            await this.nackManagedAgent(agent, nackReplyTo, nackWire, ownerNotices.relayRefused(this.errorText(error)));
             // Rejection/admission failure and uncertain transport are terminal and
             // visible. Consuming every correlated wire prevents a later partial replay.
             for (const wire of handledWireIds)
@@ -1185,14 +1189,14 @@ export class OwnerChannel {
      * to the authenticated agent, while its deferred replays stay quiet. NACK
      * delivery is best-effort — it must never make the failure worse.
      */
-    async nackManagedAgent(contact, message, wireId, notice) {
+    async nackManagedAgent(contact, replyTo, wireId, notice) {
         if (this.relayNacks.has(wireId))
             return;
         this.relayNacks.add(wireId);
         if (this.relayNacks.size > RELAY_NACK_MEMORY)
             this.relayNacks.delete(this.relayNacks.values().next().value);
         try {
-            await this.send(contact, notice, message.wire_id ? wireId : undefined);
+            await this.send(contact, notice, replyTo);
         }
         catch (error) {
             this.logError('managed-agent relay NACK delivery failed', error);
@@ -1510,8 +1514,8 @@ export class OwnerChannel {
         return createHash('sha256').update(wireId).digest('hex');
     }
     send(contact, text, replyTo) {
-        return this.client.callTool('send_message', {
-            contact, text, ...(replyTo ? { reply_to_wire_id: replyTo } : {}),
+        return this.client.sendMessage({
+            contact, text, ...(replyTo ? { replyToWireId: replyTo } : {}),
         });
     }
     async sendAttachments(contact, outbox, replyTo) {
@@ -1519,11 +1523,11 @@ export class OwnerChannel {
             .filter(entry => entry.isFile())
             .sort((a, b) => a.name.localeCompare(b.name));
         for (const entry of entries) {
-            await this.client.callTool('send_file', {
+            await this.client.sendFile({
                 contact,
                 path: join(outbox, entry.name),
                 filename: entry.name,
-                reply_to_wire_id: replyTo,
+                replyToWireId: replyTo,
             });
         }
         await rm(outbox, { recursive: true, force: true });
@@ -1546,11 +1550,11 @@ export class OwnerChannel {
         return Number.isInteger(message.msg_id) ? `msg:${message.msg_id}` : '';
     }
     sender(message) {
-        const source = message.from ?? message.sender;
-        if (typeof source === 'string')
-            return { id: source, name: source };
-        const id = String(source?.id ?? message.sender_id ?? '');
-        return { id, name: String(source?.name ?? message.sender_name ?? id) };
+        // Authenticated routing data, straight from the daemon's typed envelope.
+        // The id still goes through the CID checks in acceptedSender/isEffectiveOwner.
+        const source = message.from;
+        const id = String(source?.id ?? '');
+        return { id, name: String(source?.name ?? id) };
     }
     latestEventSeq(events) {
         return events.reduce((latest, event) => Math.max(latest, event.seq), 0);

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

@@ -0,0 +1,126 @@
+import { OursClient, type OursClientOptions } 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 OursMessagesPayload = Res<'getMessages'>;
+export type OursInboundMessage = OursMessagesPayload['messages'][number];
+export type OursIncomingFile = Res<'listIncomingFiles'>[number];
+export type OursRetrievedFiles = Res<'getFiles'>;
+export type OursRetrievedFile = OursRetrievedFiles['files'][number];
+/**
+ * The daemon operations the owner channel needs, one typed method each.
+ *
+ * This interface deliberately has no generic `callTool(name, args): unknown`
+ * escape hatch. The MCP surface had one, and because ours-mcp answers 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>;
+    getMessages(): Promise<OursMessagesPayload>;
+    deferMessages(msgIds: number[]): Promise<void>;
+    listIncomingFiles(): Promise<OursIncomingFile[]>;
+    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 builds an `OursClient` from the resolved endpoint. */
+    createClient?(options: OursClientOptions): OursClient;
+}
+/**
+ * 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 `ours-mcp proxy`
+ * 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>;
+    getMessages(): Promise<OursMessagesPayload>;
+    deferMessages(msgIds: number[]): Promise<void>;
+    listIncomingFiles(): Promise<OursIncomingFile[]>;
+    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,148 @@
+import { randomUUID } from 'node:crypto';
+import { OursClient, OursError } from '@ours.network/sdk/client';
+import { resolveApiToken, resolveEndpoint } from '../monitor.js';
+/** 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 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 `ours-mcp proxy`
+ * 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 };
+        // Reuse fleet's own daemon resolution so this client and the notification
+        // watch loop can never disagree about which daemon they are talking to.
+        const endpoint = resolveEndpoint(environment);
+        const apiToken = resolveApiToken(environment);
+        const options = {
+            url: endpoint.origin,
+            leaseToken: this.leaseToken,
+            clientPid: process.pid,
+            ...(apiToken ? { apiToken } : {}),
+        };
+        this.client = this.deps.createClient?.(options) ?? new OursClient(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 getMessages() {
+        return this.ops().getMessages();
+    }
+    async deferMessages(msgIds) {
+        await this.ops().deferMessages({ msg_ids: msgIds });
+    }
+    async listIncomingFiles() {
+        return this.ops().listIncomingFiles();
+    }
+    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 } : {}),
+        });
+        // Parity with ours-mcp 0.16.0: 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) {
+        const verdict = await this.ops().sendFile({
+            contact: a.contact, path: a.path, filename: a.filename,
+            ...(a.replyToWireId ? { reply_to_wire_id: a.replyToWireId } : {}),
+        });
+        // Parity with ours-mcp 0.16.0, which 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;
+    }
+}