@ours.network/fleet 0.18.0 → 0.19.0-nightly.1

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/resolved-plan.js

@@ -18,7 +18,6 @@ export function resolvedPlan(cfg) {
         schemaVersion: RESOLVED_PLAN_SCHEMA_VERSION,
         sourceFiles: [...cfg.files],
         startStaggerMs: cfg.startStaggerMs,
-        harnesses: cfg.harnessPlugins,
         diagnostics: cfg.diagnostics.map(diagnostic => ({ ...diagnostic })),
         roles: cfg.roles.map(resolvedRolePlan),
         loops: cfg.loops.map(loop => sortedObject({

package/dist/runner.d.ts

@@ -35,15 +35,6 @@ export interface RunnerDeps {
 }
 /** Environment injected only into the managed harness process. */
 export declare function managedFleetProxyEnv(role: ResolvedRole, stateDir: string): Record<string, string>;
-/**
- * The environment a managed harness child actually receives, checked at the one
- * point where it is composed. `role.env` deliberately wins over harness prep,
- * which is exactly how a stale fleet-wide model pin used to outrank the model
- * the role was spawned with — so the model pin is verified here rather than
- * trusted, and a disagreement stops the launch instead of being reported as a
- * success (see src/model-env.ts).
- */
-export declare function harnessChildEnv(role: ResolvedRole, launchEnv: Record<string, string> | undefined, stateDir: string): Record<string, string>;
 /**
  * Record who owns wake delivery for this run. Returning true means a fleet
  * monitor is taking ownership back from a native harness and must start at the
@@ -70,23 +61,6 @@ export declare function readExitRecord(path: string): ExitRecord | null;
 export declare const RESTART_LEDGER_FILE = ".restart-ledger.json";
 /** Consecutive immediate failures tolerated before the agent is held down. */
 export declare const RESTART_FAIL_THRESHOLD = 5;
-/**
- * How the previous supervisor process ended.
- *
- * `abrupt` is the case the ledger used to miss entirely: an OOM-kill or any
- * other external signal takes the supervisor down before it can write anything,
- * the service manager restarts the unit, and every durable indicator still
- * describes the run that died. A health check reading them reported "no
- * restarts" for a role that had died and come back.
- */
-export interface TerminationRecord {
-    class: 'clean' | 'abrupt' | 'unknown';
-    detail: string;
-    /** When the SURVIVING process observed it, not when it happened. */
-    observedAt: string;
-    /** Start time of the run that ended, when it was recorded. */
-    runStartedAt?: string;
-}
 export interface RestartLedger {
     version: 1;
     consecutiveImmediateFailures: number;
@@ -98,29 +72,7 @@ export interface RestartLedger {
     updatedAt: string;
     /** When the circuit opened, for the held-down status line. */
     openedAt?: string;
-    /** How the previous supervisor process ended, including abnormal exits. */
-    lastTermination?: TerminationRecord;
-    /** Supervisor processes that died without closing their run marker. */
-    abruptTerminations?: number;
-    /** Start of the supervisor run that owns this state directory now. */
-    supervisorStartedAt?: string;
 }
-/**
- * Carried across a supervisor process's life so its successor can tell an
- * orderly exit from a kill. Present on disk == "a supervisor believed it was
- * running"; the next start finding one that is not its own is proof the
- * previous process died without getting to write anything.
- */
-export declare const RUN_MARKER_FILE = ".supervisor-run.json";
-/**
- * Claim this state directory for the current supervisor process and report how
- * the previous one ended. Runs BEFORE the first attempt, which is the whole
- * point: after an abrupt kill nothing else writes until an attempt finishes,
- * and an attempt can take minutes.
- */
-export declare function claimSupervisorRun(dir: string, startedAt: string, pid?: number): TerminationRecord;
-/** Orderly exit: the successor must not read this run as a kill. */
-export declare function releaseSupervisorRun(dir: string): void;
 /** Bounded exponential backoff for the nth consecutive immediate failure. */
 export declare function backoffFor(consecutiveFailures: number): number;
 /** Read a role's restart ledger; a missing or corrupt one starts clean. */