@ours.network/fleet 1.1.5 → 1.2.0-nightly.1

package/dist/monitor.d.ts

@@ -1,3 +1,4 @@
+import { type AttachOursClientOptions } from '@ours.network/sdk/client';
 import type { MonitorConfig, MonitorInterrupt, NotifyEventType } from './config.js';
 import { type FailureEvidence } from './model-recovery.js';
 /** A content-free arrival event as the daemon serves it over the notifications API. */
@@ -26,6 +27,28 @@ export type FetchLike = (url: string, init?: {
     headers?: Record<string, string>;
     signal?: AbortSignal;
 }) => Promise<FetchResponse>;
+export interface MonitorPageClient {
+    readNotificationPage(identity: string, options?: {
+        since?: number | 'tip';
+        signal?: AbortSignal;
+        requestTimeoutMs?: number;
+    }): Promise<{
+        cursor: number;
+        events: Array<Record<string, unknown>>;
+    }>;
+    close(): Promise<void>;
+}
+export interface IdentityProbeClient {
+    identities(): Promise<Array<string | {
+        name?: unknown;
+        temporary?: unknown;
+        stale?: unknown;
+    }>>;
+    close(): Promise<void>;
+}
+export interface IdentityProbeDeps {
+    attachClient?(options: AttachOursClientOptions): IdentityProbeClient | Promise<IdentityProbeClient>;
+}
 export interface MonitorDeps {
     fetch: FetchLike;
     isAlive(pid: number): boolean;
@@ -37,6 +60,8 @@ export interface MonitorDeps {
         set(fn: () => void, ms: number): ReturnType<typeof setTimeout>;
         clear(t: ReturnType<typeof setTimeout>): void;
     };
+    /** Test seam; production attaches through the SDK's verified selection path. */
+    attachClient?(options: AttachOursClientOptions): MonitorPageClient | Promise<MonitorPageClient>;
     /**
      * Structured prompt delivery used by agent sessions.
      * `succeeded` is the turn's TERMINAL result, not merely that the session took
@@ -101,13 +126,13 @@ export type IdentityPresence = {
     detail: string;
 };
 /** Resolve the daemon endpoint + auth header from env → config → defaults. */
-export declare function resolveEndpoint(env: NodeJS.ProcessEnv): DaemonEndpoint;
+export declare function resolveEndpoint(env: NodeJS.ProcessEnv, includeToken?: boolean): DaemonEndpoint;
 /**
  * Ask the daemon's authoritative identity index. The notifications endpoint is
  * intentionally unsuitable for lifecycle: it serves an empty 200 page for a
  * valid but missing identity, which made a closed temp identity look healthy.
  */
-export declare function probeIdentityPresence(name: string, fetch: FetchLike, env: NodeJS.ProcessEnv): Promise<IdentityPresence>;
+export declare function probeIdentityPresence(name: string, fetch: FetchLike, env: NodeJS.ProcessEnv, deps?: IdentityProbeDeps): Promise<IdentityPresence>;
 /** Actionable, secret-free description of every token source for this profile. */
 export declare function authResolutionHint(ep: DaemonEndpoint): string;
 /** Keep only the events whose type the role asked to wake on. */
@@ -171,7 +196,11 @@ export declare class Monitor {
     private readonly identity;
     private readonly cfg;
     private readonly deps;
-    private readonly ep;
+    private readonly ep?;
+    private readonly profile?;
+    private readonly profileKey;
+    private readonly monitorLeaseToken;
+    private profileClientPromise?;
     private readonly statusPath;
     private readonly cursorPath;
     private readonly statePath;
@@ -212,6 +241,8 @@ export declare class Monitor {
      * no-ops (delivery is still verified downstream).
      */
     private doFetch;
+    private profileClient;
+    private disposeProfileClient;
     private advance;
     private persistCursor;
     private readPersistedCursor;

package/dist/monitor.js

@@ -1,6 +1,9 @@
 import { existsSync, readFileSync, renameSync, writeFileSync } from 'node:fs';
+import { randomUUID } from 'node:crypto';
 import { homedir } from 'node:os';
 import { join } from 'node:path';
+import { attachOursClient } from '@ours.network/sdk/client';
+import { clientProfileKey, readClientProfile, } from './client-profile.js';
 // Code constants rather than user configuration.
 const DEFAULT_PORT = 3050;
 // The daemon normally holds for 25s, but that value is operator-configurable
@@ -92,12 +95,12 @@ export function resolveApiToken(env, file = readDaemonConfig(env)) {
     return undefined;
 }
 /** Resolve the daemon endpoint + auth header from env → config → defaults. */
-export function resolveEndpoint(env) {
+export function resolveEndpoint(env, includeToken = true) {
     const file = readDaemonConfig(env);
     const port = envInt(env, 'OURS_PORT') ?? file.port ?? DEFAULT_PORT;
     const configPath = daemonConfigPath(env);
     const stateDir = env.OURS_STATE_DIR ?? file.stateDir ?? join(homedir(), '.ours');
-    const token = resolveApiToken(env, file);
+    const token = includeToken ? resolveApiToken(env, file) : undefined;
     const origin = `http://127.0.0.1:${port}`;
     return {
         origin,
@@ -113,7 +116,29 @@ export function resolveEndpoint(env) {
  * intentionally unsuitable for lifecycle: it serves an empty 200 page for a
  * valid but missing identity, which made a closed temp identity look healthy.
  */
-export async function probeIdentityPresence(name, fetch, env) {
+export async function probeIdentityPresence(name, fetch, env, deps = {}) {
+    const profile = readClientProfile(env);
+    if (profile) {
+        let client;
+        try {
+            client = await (deps.attachClient?.({
+                endpoint: profile.endpoint, expectedInstanceId: profile.expectedInstanceId,
+                credentialPath: profile.credentialPath,
+                sessionMode: 'external', leaseToken: randomUUID(), env: {},
+            }) ?? attachOursClient({
+                endpoint: profile.endpoint, expectedInstanceId: profile.expectedInstanceId,
+                credentialPath: profile.credentialPath,
+                sessionMode: 'external', leaseToken: randomUUID(), env: {},
+            }));
+            return classifyIdentityPresence(name, await client.identities());
+        }
+        catch {
+            return { state: 'unknown', detail: 'selected identity index is unavailable' };
+        }
+        finally {
+            await client?.close().catch(() => undefined);
+        }
+    }
     const ep = resolveEndpoint(env);
     let response;
     try {
@@ -131,25 +156,36 @@ export async function probeIdentityPresence(name, fetch, env) {
         };
     try {
         const body = await response.json();
-        if (!Array.isArray(body.identities))
-            return { state: 'unknown', detail: 'identity index response is malformed' };
-        // A healthy daemon normally has at least its Human identity. During daemon
-        // restart, however, the authenticated endpoint can briefly serve a valid
-        // but empty index while state is still loading. Empty is therefore not
-        // enough authority to retire a live temporary role.
-        if (body.identities.length === 0)
-            return { state: 'unknown', detail: 'identity index is temporarily empty' };
-        const found = body.identities.find(identity => (typeof identity === 'string' ? identity : identity?.name) === name);
-        if (!found)
-            return { state: 'absent' };
-        return typeof found === 'string'
-            ? { state: 'present', temporary: false, stale: false }
-            : { state: 'present', temporary: found.temporary === true, stale: found.stale === true };
+        return classifyIdentityPresence(name, body.identities);
     }
     catch (error) {
         return { state: 'unknown', detail: `identity index response is unreadable (${msg(error)})` };
     }
 }
+function classifyIdentityPresence(name, identities) {
+    if (!Array.isArray(identities))
+        return { state: 'unknown', detail: 'identity index response is malformed' };
+    // A healthy daemon normally has at least its Human identity. During daemon
+    // restart, however, the authenticated endpoint can briefly serve a valid
+    // but empty index while state is still loading. Empty is therefore not
+    // enough authority to retire a live temporary role.
+    if (identities.length === 0)
+        return { state: 'unknown', detail: 'identity index is temporarily empty' };
+    const found = identities.find(identity => (typeof identity === 'string'
+        ? identity
+        : identity && typeof identity === 'object'
+            ? identity.name
+            : undefined) === name);
+    if (!found)
+        return { state: 'absent' };
+    return typeof found === 'string'
+        ? { state: 'present', temporary: false, stale: false }
+        : {
+            state: 'present',
+            temporary: found.temporary === true,
+            stale: found.stale === true,
+        };
+}
 /** Actionable, secret-free description of every token source for this profile. */
 export function authResolutionHint(ep) {
     const tokenPath = join(ep.stateDir, 'daemon-token');
@@ -379,6 +415,10 @@ export class Monitor {
     cfg;
     deps;
     ep;
+    profile;
+    profileKey;
+    monitorLeaseToken = `ours-fleet-monitor-${process.pid}-${randomUUID()}`;
+    profileClientPromise;
     statusPath;
     cursorPath;
     statePath;
@@ -400,7 +440,9 @@ export class Monitor {
         this.identity = o.identity ?? o.name;
         this.cfg = o.cfg;
         this.deps = o.deps;
-        this.ep = resolveEndpoint(o.deps.env);
+        this.profile = readClientProfile(o.deps.env);
+        this.ep = this.profile ? undefined : resolveEndpoint(o.deps.env);
+        this.profileKey = this.profile ? clientProfileKey(this.profile) : this.ep.origin;
         this.statusPath = join(o.agentDir, '.monitor-status');
         this.cursorPath = join(o.agentDir, '.notify-cursor');
         this.statePath = join(o.agentDir, '.monitor-state.json');
@@ -428,8 +470,14 @@ export class Monitor {
         }
         catch (e) {
             if (e instanceof AuthError) {
-                this.fatal = true;
-                this.degrade('auth', e.message, 'failed');
+                if (this.profile) {
+                    this.cursor = null;
+                    this.degrade('auth', e.message);
+                }
+                else {
+                    this.fatal = true;
+                    this.degrade('auth', e.message, 'failed');
+                }
             }
             else {
                 this.cursor = null;
@@ -439,70 +487,81 @@ export class Monitor {
     }
     /** Long-poll → filter → coalesce → inject, until the pane pid dies or stop(). */
     async run(pid) {
-        if (this.fatal)
+        if (this.fatal) {
+            await this.disposeProfileClient();
             return;
+        }
         this.bootDeadline = this.deps.now() + BOOT_GRACE_MS;
         let backoff = 0;
         const pending = [];
-        while (!this.stopped) {
-            if (!this.deps.isAlive(pid)) {
-                this.degrade('offline', 'session offline');
-                return;
-            }
-            let body;
-            try {
-                body = await this.doFetch(String(this.cursor ?? 0), LONGPOLL_STALL_MS, 'stall');
-                backoff = 0;
-                // A poll that worked proves the stream is healthy — and only that.
-                this.recover('connectivity');
-            }
-            catch (e) {
-                if (this.stopped)
-                    return;
-                if (e instanceof AuthError) {
-                    this.fatal = true;
-                    this.degrade('auth', e.message, 'failed');
+        try {
+            while (!this.stopped) {
+                if (!this.deps.isAlive(pid)) {
+                    this.degrade('offline', 'session offline');
                     return;
                 }
-                backoff = Math.min(backoff + BACKOFF_STEP_MS, BACKOFF_MAX_MS);
-                this.degrade('connectivity', `stream hiccup (${msg(e)})`);
-                await this.deps.sleep(backoff);
-                continue;
-            }
-            this.advance(body.cursor, false);
-            const batch = filterEvents(body.events ?? [], this.cfg.wake_sources);
-            appendUniqueEvents(pending, batch);
-            if (pending.length === 0) {
-                this.persistCursor();
-                continue;
-            }
-            this.pendingState = {
-                count: pending.length,
-                eventTypes: uniq(pending.map(event => event.event ?? 'unknown')),
-                attempts: (this.pendingState?.attempts ?? 0) + 1,
-            };
-            this.persistState();
-            await this.coalesce(pending);
-            // Do not durably commit this cursor until the session explicitly accepts
-            // the wake. If delivery fails or the runner crashes, the daemon replays
-            // from the last committed cursor and the wake is attempted again.
-            let accepted = false;
-            try {
-                accepted = await this.deliver(pid, pending);
-            }
-            catch (e) {
-                this.degrade('delivery', `delivery failed (${msg(e)})`);
-            }
-            if (accepted) {
-                pending.length = 0;
-                this.pendingState = null;
-                this.persistCursor();
+                let body;
+                try {
+                    body = await this.doFetch(String(this.cursor ?? 0), LONGPOLL_STALL_MS, 'stall');
+                    backoff = 0;
+                    // A poll that worked proves the stream is healthy — and only that.
+                    this.recover('connectivity', 'auth');
+                }
+                catch (e) {
+                    if (this.stopped)
+                        return;
+                    if (e instanceof AuthError && !this.profile) {
+                        this.fatal = true;
+                        this.degrade('auth', e.message, 'failed');
+                        return;
+                    }
+                    backoff = Math.min(backoff + BACKOFF_STEP_MS, BACKOFF_MAX_MS);
+                    if (e instanceof AuthError)
+                        this.degrade('auth', e.message);
+                    else
+                        this.degrade('connectivity', `stream hiccup (${msg(e)})`);
+                    await this.deps.sleep(backoff);
+                    continue;
+                }
+                this.advance(body.cursor, false);
+                const batch = filterEvents(body.events ?? [], this.cfg.wake_sources);
+                appendUniqueEvents(pending, batch);
+                if (pending.length === 0) {
+                    this.persistCursor();
+                    continue;
+                }
+                this.pendingState = {
+                    count: pending.length,
+                    eventTypes: uniq(pending.map(event => event.event ?? 'unknown')),
+                    attempts: (this.pendingState?.attempts ?? 0) + 1,
+                };
+                this.persistState();
+                await this.coalesce(pending);
+                // Do not durably commit this cursor until the session explicitly accepts
+                // the wake. If delivery fails or the runner crashes, the daemon replays
+                // from the last committed cursor and the wake is attempted again.
+                let accepted = false;
+                try {
+                    accepted = await this.deliver(pid, pending);
+                }
+                catch (e) {
+                    this.degrade('delivery', `delivery failed (${msg(e)})`);
+                }
+                if (accepted) {
+                    pending.length = 0;
+                    this.pendingState = null;
+                    this.persistCursor();
+                }
             }
         }
+        finally {
+            await this.disposeProfileClient();
+        }
     }
     stop() {
         this.stopped = true;
         this.currentAbort?.abort();
+        void this.disposeProfileClient();
     }
     // ── internals ──────────────────────────────────────────────────────────────
     /** Gather stragglers arriving within batch_ms so a burst lands as one line. */
@@ -573,11 +632,24 @@ export class Monitor {
         const timer = this.deps.timers.set(() => { timedOut = true; ctrl.abort(); }, timeoutMs);
         let resp;
         try {
+            if (this.profile) {
+                const client = await this.profileClient();
+                const page = await client.readNotificationPage(this.identity, {
+                    since: since === 'tip' ? 'tip' : Number.parseInt(since, 10),
+                    signal: ctrl.signal,
+                    requestTimeoutMs: timeoutMs,
+                });
+                return { cursor: page.cursor, events: page.events };
+            }
             resp = await this.deps.fetch(`${this.ep.url(this.identity)}?since=${since}`, { headers: this.ep.headers, signal: ctrl.signal });
         }
         catch (error) {
             if (timedOut && timeoutKind === 'stall')
                 throw new Error(`notification stream stalled for ${Math.round(timeoutMs / 1000)}s`);
+            if (this.profile && /(?:HTTP\s*401|unauthori[sz]ed|API token)/i.test(msg(error)))
+                throw new AuthError(`daemon rejected the API token (401) — verify the credential file `
+                    + `${JSON.stringify(this.profile.credentialPath)} selected by `
+                    + `${JSON.stringify(this.profile.configPath)}`);
             throw error;
         }
         finally {
@@ -590,6 +662,34 @@ export class Monitor {
             throw new Error(`daemon returned HTTP ${resp.status}`);
         return resp.json();
     }
+    profileClient() {
+        if (!this.profile)
+            throw new Error('explicit client profile is not selected');
+        if (!this.profileClientPromise) {
+            const { endpoint, expectedInstanceId, credentialPath } = this.profile;
+            const options = {
+                endpoint, expectedInstanceId, credentialPath,
+                sessionMode: 'external', leaseToken: this.monitorLeaseToken, env: {},
+            };
+            this.profileClientPromise = Promise.resolve(this.deps.attachClient?.(options) ?? attachOursClient(options)).catch(error => {
+                this.profileClientPromise = undefined;
+                throw error;
+            });
+        }
+        return this.profileClientPromise;
+    }
+    async disposeProfileClient() {
+        const pending = this.profileClientPromise;
+        this.profileClientPromise = undefined;
+        if (!pending)
+            return;
+        try {
+            await (await pending).close();
+        }
+        catch {
+            this.deps.log(`[${this.name}] monitor: failed to close daemon client`);
+        }
+    }
     advance(cursor, persist = true) {
         if (typeof cursor === 'number' && cursor !== this.cursor) {
             this.cursor = cursor;
@@ -616,7 +716,7 @@ export class Monitor {
             if (existsSync(this.statePath)) {
                 const state = JSON.parse(readFileSync(this.statePath, 'utf8'));
                 if ((state.identity !== undefined && state.identity !== this.identity)
-                    || (state.profileKey !== undefined && state.profileKey !== this.ep.origin))
+                    || (state.profileKey !== undefined && state.profileKey !== this.profileKey))
                     return null;
                 if (typeof state.deliveredCursor === 'number') {
                     this.deliveredCursor = state.deliveredCursor;
@@ -641,7 +741,7 @@ export class Monitor {
             writeFileSync(tmp, JSON.stringify({
                 version: 1,
                 identity: this.identity,
-                profileKey: this.ep.origin,
+                profileKey: this.profileKey,
                 observedCursor: this.cursor,
                 deliveredCursor: this.deliveredCursor,
                 pending: this.pendingState,

package/dist/owner-channel/channel.js

@@ -419,7 +419,9 @@ export class OwnerChannel {
             ]), deadlineAt);
             if (superseded())
                 throw new Error('owner recovery epoch superseded');
-            await this.recoveryStage('close', this.client.close(), deadlineAt);
+            // A daemon reconnect is not terminal ownership evidence. Keep the same
+            // owner ID and its temporary/permanent bindings while replacing transport.
+            await this.recoveryStage('close', this.client.close({ releaseLease: false }), deadlineAt);
             if (superseded())
                 throw new Error('owner recovery epoch superseded');
             try {
@@ -450,7 +452,7 @@ export class OwnerChannel {
                 // its disposal; the recorded quiescence debt gates the next retry.
                 if (!this.recoveryQuiescence) {
                     try {
-                        await this.recoveryStage('close_after_failure', this.client.close(), deadlineAt);
+                        await this.recoveryStage('close_after_failure', this.client.close({ releaseLease: false }), deadlineAt);
                     }
                     catch (closeError) {
                         this.logError('recovery client close failed', closeError);

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

@@ -92,8 +92,10 @@ export interface OursOps {
         filename: string;
         replyToWireId?: string;
     }): Promise<void>;
-    /** Release the daemon lease and stop. Never throws. */
-    close(): Promise<void>;
+    /** Dispose transport; terminal release is default and rejects if cleanup is incomplete. */
+    close(options?: {
+        releaseLease?: boolean;
+    }): Promise<void>;
 }
 /**
  * The typed error code of a daemon operation, or undefined when the failure was
@@ -120,14 +122,17 @@ export interface OursSdkClientDeps {
  * 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.
+ * terminal release does that deterministically. Recovery disposes only the
+ * transport and retains this owner ID and its bindings. Explicit daemon identity selects external
+ * ownership in either layout; PID-based legacy attachment remains temporary.
+ * Failed external release preserves unknown ownership until exact terminal evidence.
  */
 export declare class OursSdkClient implements OursOps {
     private readonly env;
     private readonly log;
     private readonly deps;
     private client?;
+    private terminalReleasePending;
     private readonly leaseToken;
     constructor(env?: Record<string, string>, log?: (line: string) => void, deps?: OursSdkClientDeps);
     start(): Promise<void>;
@@ -161,7 +166,9 @@ export declare class OursSdkClient implements OursOps {
         filename: string;
         replyToWireId?: string;
     }): Promise<void>;
-    close(): Promise<void>;
+    close(options?: {
+        releaseLease?: boolean;
+    }): Promise<void>;
     private ops;
 }
 export {};

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

@@ -1,6 +1,8 @@
 import { randomUUID } from 'node:crypto';
 import { readFile } from 'node:fs/promises';
-import { extname } from 'node:path';
+import { extname, join } from 'node:path';
+import { readDaemonConfig, resolveEndpoint } from '../monitor.js';
+import { readClientProfile } from '../client-profile.js';
 import { OursError, attachOursClient, } from '@ours.network/sdk/client';
 /** Any failure of a daemon operation. Never carries a message body or a token. */
 export class OursDaemonError extends Error {
@@ -106,14 +108,18 @@ export const OURS_BOUND_ELSEWHERE = 'BOUND_ELSEWHERE';
  * 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.
+ * terminal release does that deterministically. Recovery disposes only the
+ * transport and retains this owner ID and its bindings. Explicit daemon identity selects external
+ * ownership in either layout; PID-based legacy attachment remains temporary.
+ * Failed external release preserves unknown ownership until exact terminal evidence.
  */
 export class OursSdkClient {
     env;
     log;
     deps;
     client;
+    // Disposing a transport does not discharge this owner's terminal cleanup.
+    terminalReleasePending = false;
     leaseToken = `ours-fleet-owner-${process.pid}-${randomUUID()}`;
     constructor(env = {}, log = () => undefined, deps = {}) {
         this.env = env;
@@ -124,16 +130,28 @@ export class OursSdkClient {
         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 = {
+        const profile = readClientProfile(environment);
+        // Reuse existing connection configuration. Identity selection checks the
+        // daemon capability before reading the client's protected token delivery file.
+        const endpoint = !profile && environment.OURS_DAEMON_ID
+            ? resolveEndpoint(environment, false) : undefined;
+        const token = endpoint ? environment.OURS_API_TOKEN?.trim() || readDaemonConfig(environment).apiToken : undefined;
+        const options = profile ? {
+            endpoint: profile.endpoint, expectedInstanceId: profile.expectedInstanceId,
+            credentialPath: profile.credentialPath,
+            sessionMode: 'external', leaseToken: this.leaseToken, env: {},
+        } : endpoint ? {
+            endpoint: endpoint.origin, expectedInstanceId: environment.OURS_DAEMON_ID,
+            sessionMode: 'external', leaseToken: this.leaseToken,
+            ...(token ? { token } : { credentialPath: join(endpoint.stateDir, 'daemon-token') }),
+        } : {
             env: environment,
             leaseToken: this.leaseToken,
             clientPid: process.pid,
             fetch: notificationDeadlineFetch(this.deps.fetch ?? globalThis.fetch, this.deps.notificationRequestDeadlineMs ?? NOTIFICATION_REQUEST_DEADLINE_MS),
         };
         this.client = await (this.deps.attachClient?.(options) ?? attachOursClient(options));
+        this.terminalReleasePending = true;
     }
     async bindIdentity(name) {
         // force is pinned off: the owner channel never evicts another live session
@@ -162,7 +180,10 @@ export class OursSdkClient {
         return this.ops().getHistoryItem({ wire_id: wireId });
     }
     watchNotifications(identity, options) {
-        return this.ops().watchNotifications(identity, options);
+        return this.ops().watchNotifications(identity, {
+            ...options,
+            requestTimeoutMs: this.deps.notificationRequestDeadlineMs ?? NOTIFICATION_REQUEST_DEADLINE_MS,
+        });
     }
     async listIncomingFiles() {
         return this.ops().listIncomingFiles();
@@ -211,19 +232,34 @@ export class OursSdkClient {
             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() {
+    async close(options = {}) {
+        const terminal = options.releaseLease !== false;
+        // A failed recovery may have disposed its client before normal shutdown.
+        // Reattach the same owner through ordinary verified selection; no rebind is
+        // needed to release it, and a failed attach must not be reported as closed.
+        if (terminal && !this.client && this.terminalReleasePending)
+            await this.start();
         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.
+        // waiting for the supervisor to exit. External failure remains unknown;
+        // it is not permission to infer owner death or fall back to daemon PID checks.
         try {
-            await client.releaseLease();
+            if (terminal) {
+                const result = await client.releaseLease();
+                if (result.failed > 0)
+                    throw new OursDaemonError('daemon lease release incomplete');
+                this.terminalReleasePending = false;
+            }
         }
         catch (error) {
             this.log(`lease release failed: ${error?.message ?? String(error)}`);
+            throw error;
+        }
+        finally {
+            await client.close();
         }
     }
     ops() {