@ours.network/fleet 1.2.0-nightly.3 → 1.2.0-nightly.4

package/dist/agent-ours/runtime.d.ts

@@ -0,0 +1,53 @@
+import type { OursClient } from '@ours.network/sdk/client';
+import { RuntimeJournal, type RuntimeState } from './state.js';
+export interface AssignedIdentity {
+    instance: string;
+    generation: number;
+    daemon: string;
+    name: string;
+    lifetime: 'permanent' | 'temporary';
+    action: string;
+    expectedCid?: string;
+    allowCreate: boolean;
+    bio: string;
+}
+export interface RoomAdmission {
+    id: string;
+    cid: string;
+    seat: string;
+    action: string;
+    /** The secret stays in trusted storage and is never returned to the child. */
+    redeem(client: OursClient): Promise<{
+        cid: string;
+    }>;
+    observe(agentCid: string): Promise<'pending' | 'established' | 'mismatch'>;
+    discardSecret(): Promise<void>;
+}
+export interface RuntimeDependencies {
+    journal: RuntimeJournal;
+    /** Client is already attached to the pinned daemon with its durable external owner. */
+    client: OursClient;
+    /** Checked before every operation; tied to the cross-process controller lock. */
+    assertFence(): void;
+    sleep(ms: number): Promise<void>;
+    now(): number;
+}
+/** A bridge never owns this object or its client; EOF never releases its lease. */
+export declare class AgentOursRuntime {
+    readonly assignment: AssignedIdentity;
+    private readonly deps;
+    private inFlight;
+    private drain?;
+    private accepting;
+    private state;
+    constructor(assignment: AssignedIdentity, deps: RuntimeDependencies);
+    get snapshot(): Readonly<RuntimeState>;
+    private transition;
+    private verify;
+    prepare(room?: RoomAdmission, timeoutMs?: number): Promise<void>;
+    /** Admission covers SDK calls, response rendering and agent filesystem callbacks. */
+    admit(): Promise<() => void>;
+    startHarness<T>(start: () => Promise<T>): Promise<T>;
+    suspend(): Promise<void>;
+    terminal(): Promise<void>;
+}

package/dist/agent-ours/runtime.js

@@ -0,0 +1,247 @@
+/** A bridge never owns this object or its client; EOF never releases its lease. */
+export class AgentOursRuntime {
+    assignment;
+    deps;
+    inFlight = 0;
+    drain;
+    accepting = false;
+    state;
+    constructor(assignment, deps) {
+        this.assignment = assignment;
+        this.deps = deps;
+        const existing = deps.journal.read();
+        if (existing) {
+            if (existing.instance !== assignment.instance ||
+                existing.daemon !== assignment.daemon ||
+                existing.name !== assignment.name ||
+                existing.lifetime !== assignment.lifetime ||
+                existing.generation !== assignment.generation ||
+                existing.action !== assignment.action ||
+                (assignment.expectedCid !== undefined &&
+                    existing.cid !== undefined &&
+                    existing.cid !== assignment.expectedCid))
+                throw Error('RUNTIME_ASSIGNMENT_MISMATCH');
+            this.state = existing;
+        }
+        else {
+            // Deliberately serialize only the public ownership facts, never credentials.
+            const { instance, generation, daemon, name, lifetime, action } = assignment;
+            this.state = {
+                version: 1,
+                instance,
+                generation,
+                daemon,
+                name,
+                lifetime,
+                action,
+                phase: 'PREPARING',
+                revision: 0,
+                updatedAt: '',
+            };
+            deps.assertFence();
+            deps.journal.commit(this.state);
+            this.state = deps.journal.read();
+        }
+    }
+    get snapshot() {
+        return structuredClone(this.state);
+    }
+    transition(phase, patch = {}) {
+        this.deps.assertFence();
+        this.deps.journal.commit({ ...this.state, ...patch, phase }, this.state.revision);
+        this.state = this.deps.journal.read();
+    }
+    async verify() {
+        this.deps.assertFence();
+        if (this.assignment.expectedCid && this.state.cid !== this.assignment.expectedCid)
+            throw Error('PINNED_CID_MISMATCH');
+        const actual = await this.deps.client.currentIdentity();
+        if (actual.cid !== this.state.cid ||
+            actual.name !== this.state.name ||
+            actual.temporary !== (this.state.lifetime === 'temporary') ||
+            actual.isRoot)
+            throw Error('IDENTITY_PROOF_MISMATCH');
+        this.deps.assertFence();
+    }
+    async prepare(room, timeoutMs = 30_000) {
+        if (['TERMINAL_INTENT', 'CLEANUP_PENDING', 'RELEASED', 'FAILED', 'QUIESCING'].includes(this.state.phase))
+            throw Error('RUNTIME_NOT_RESUMABLE');
+        this.deps.assertFence();
+        if (!this.state.cid) {
+            // An existing PREPARING journal is an uncertain create, never evidence of absence.
+            if (this.state.phase === 'RECOVERING')
+                throw Error('UNCERTAIN_PROVISIONING');
+            const rows = await this.deps.client.listIdentities();
+            const row = rows.find((r) => r.name === this.state.name);
+            if (row) {
+                if (!('cid' in row) ||
+                    this.state.lifetime === 'temporary' ||
+                    !this.assignment.expectedCid ||
+                    row.cid !== this.assignment.expectedCid ||
+                    row.kind === 'root' ||
+                    row.temp)
+                    throw Error('IDENTITY_COLLISION');
+                this.transition('RECOVERING');
+                await this.deps.client.chooseIdentity({ name: this.state.name, force: false });
+                this.transition('OWNED', { cid: row.cid });
+            }
+            else {
+                if (!this.assignment.allowCreate || this.assignment.expectedCid)
+                    throw Error('IDENTITY_ABSENT');
+                // Persist uncertainty before the non-idempotent call. Crash recovery requires owner proof.
+                this.transition('RECOVERING');
+                const args = {
+                    name: this.state.name,
+                    bio: this.assignment.bio,
+                    exposeLocal: false,
+                    localAutoAccept: true,
+                };
+                const created = this.state.lifetime === 'temporary'
+                    ? await this.deps.client.createTemporaryIdentity(args)
+                    : await this.deps.client.createIdentity(args);
+                if (created.hierarchy !== 'role')
+                    throw Error('ROOT_PROVISIONING_FORBIDDEN');
+                this.transition('OWNED', { cid: created.info.cid });
+            }
+        }
+        await this.verify();
+        if (!room && (this.state.room || this.state.admissionIntent))
+            throw Error('ROOM_DESCRIPTOR_REQUIRED');
+        if (room) {
+            if (this.state.room &&
+                (this.state.room.id !== room.id ||
+                    this.state.room.cid !== room.cid ||
+                    this.state.room.seat !== room.seat ||
+                    this.state.room.agentCid !== this.state.cid ||
+                    this.state.room.action !== room.action))
+                throw Error('ROOM_ASSIGNMENT_MISMATCH');
+            const intent = this.state.admissionIntent;
+            if (intent &&
+                (intent.id !== room.id ||
+                    intent.cid !== room.cid ||
+                    intent.seat !== room.seat ||
+                    intent.action !== room.action ||
+                    intent.agentCid !== this.state.cid))
+                throw Error('ROOM_INTENT_MISMATCH');
+            if (!this.state.room && !intent) {
+                // A permanent identity may already occupy its seat after a clean supervisor stop.
+                const existing = await room.observe(this.state.cid);
+                if (existing === 'mismatch') {
+                    this.transition('FAILED');
+                    throw Error('WRONG_ROOM_SEAT');
+                }
+                this.transition('ROOM_PENDING', {
+                    admissionIntent: {
+                        id: room.id,
+                        cid: room.cid,
+                        seat: room.seat,
+                        action: room.action,
+                        agentCid: this.state.cid,
+                    },
+                });
+                if (existing !== 'established') {
+                    const result = await room.redeem(this.deps.client);
+                    if (result.cid !== room.cid) {
+                        this.transition('FAILED');
+                        throw Error('WRONG_ROOM_CID');
+                    }
+                }
+            }
+            const deadline = this.deps.now() + timeoutMs;
+            for (;;) {
+                this.deps.assertFence();
+                const observation = await room.observe(this.state.cid);
+                if (observation === 'mismatch') {
+                    this.transition('FAILED');
+                    throw Error('WRONG_ROOM_SEAT');
+                }
+                if (observation === 'established')
+                    break;
+                if (this.deps.now() >= deadline)
+                    throw Error('ROOM_PENDING');
+                await this.deps.sleep(Math.min(250, deadline - this.deps.now()));
+            }
+            this.transition('READY', {
+                room: {
+                    id: room.id,
+                    cid: room.cid,
+                    seat: room.seat,
+                    agentCid: this.state.cid,
+                    action: room.action,
+                },
+            });
+            await room.discardSecret();
+        }
+        else
+            this.transition('READY');
+        this.accepting = true;
+    }
+    /** Admission covers SDK calls, response rendering and agent filesystem callbacks. */
+    async admit() {
+        this.deps.assertFence();
+        if (!this.accepting || !['READY', 'SERVING'].includes(this.state.phase))
+            throw Error('RUNTIME_NOT_READY');
+        this.inFlight++;
+        let released = false;
+        const release = () => {
+            if (released)
+                return;
+            released = true;
+            if (--this.inFlight === 0)
+                this.drain?.();
+        };
+        try {
+            await this.verify();
+            if (!this.accepting)
+                throw Error('RUNTIME_QUIESCING');
+            return release;
+        }
+        catch (error) {
+            release();
+            throw error;
+        }
+    }
+    async startHarness(start) {
+        if (!this.accepting || this.state.phase !== 'READY')
+            throw Error('RUNTIME_NOT_READY');
+        await this.verify();
+        this.transition('SERVING');
+        return start();
+    }
+    async suspend() {
+        this.accepting = false;
+        if (this.inFlight)
+            await new Promise((resolve) => {
+                this.drain = resolve;
+            });
+        this.transition('RECOVERING');
+    }
+    async terminal() {
+        this.accepting = false;
+        if (this.state.phase === 'RELEASED')
+            return;
+        if (!['TERMINAL_INTENT', 'CLEANUP_PENDING'].includes(this.state.phase))
+            this.transition('QUIESCING');
+        if (this.inFlight)
+            await new Promise((resolve) => {
+                this.drain = resolve;
+            });
+        this.transition('TERMINAL_INTENT');
+        try {
+            this.deps.assertFence();
+            const ack = await this.deps.client.releaseLease();
+            if (!ack ||
+                !Array.isArray(ack.released) ||
+                !Array.isArray(ack.closed) ||
+                [...ack.released, ...ack.closed].some((name) => typeof name !== 'string') ||
+                [ack.attempted, ack.notified, ack.failed].some((n) => !Number.isSafeInteger(n) || n < 0) ||
+                ack.notified + ack.failed !== ack.attempted)
+                throw Error('INVALID_RELEASE_ACK');
+            this.transition('RELEASED', { releaseAck: ack });
+        }
+        catch (error) {
+            this.transition('CLEANUP_PENDING');
+            throw error;
+        }
+    }
+}

package/dist/agent-ours/service.d.ts

@@ -0,0 +1,23 @@
+import type { ResolvedRole } from '../config.js';
+import { AgentOursRuntime } from './runtime.js';
+export declare const privateRuntimeRoot: () => string;
+export interface ManagedAgentService {
+    runtime: AgentOursRuntime;
+    descriptor: string;
+    privatePaths: string[];
+    close(terminal: boolean): Promise<void>;
+}
+/** Only trusted launch orchestration may write this descriptor, never the child. */
+export declare function storeRoomSecret(role: ResolvedRole): void;
+export declare function storeTemporaryLaunch(role: ResolvedRole, action: string): void;
+export declare function prepareManagedAgent(role: ResolvedRole, stateDir: string, temporary: boolean): Promise<ManagedAgentService>;
+/** Explicit trusted inventory migration: read and pin existing permanent CID, never bind. */
+export declare function preparePermanentAssignment(role: ResolvedRole): Promise<'verified' | 'unverified'>;
+export declare function readRoomReadiness(roomCid: string, name: string): {
+    room: string;
+    invite: string;
+    cid: string;
+    generation: number;
+} | undefined;
+/** Explicit logical-instance termination, independent of harness/bridge transport. */
+export declare function releaseManagedAgent(role: ResolvedRole): Promise<void>;

package/dist/agent-ours/service.js

@@ -0,0 +1,352 @@
+import { randomBytes, randomUUID } from 'node:crypto';
+import { existsSync, mkdirSync, readFileSync, unlinkSync, writeFileSync } from 'node:fs';
+import { join } from 'node:path';
+import { attachOursClient } from '@ours.network/sdk/client';
+import { ApplicationIdentityStore } from '@ours.network/mcp/application-identities';
+import { readClientProfile } from '../client-profile.js';
+import { stateRoot } from '../paths.js';
+import { createCoworkAdapter } from '../rooms-tasks/cowork-adapter.js';
+import { RuntimeController } from './controller.js';
+import { atomicPrivateWrite, binderKey } from './state.js';
+import { AgentOursRuntime } from './runtime.js';
+import { startMcpEndpoint } from './mcp-endpoint.js';
+export const privateRuntimeRoot = () => join(stateRoot(), 'private-ours');
+/** Only trusted launch orchestration may write this descriptor, never the child. */
+export function storeRoomSecret(role) {
+    const startup = role.roomMemberStartup;
+    if (!startup?.invite)
+        return;
+    const root = join(privateRuntimeRoot(), 'room-inputs');
+    mkdirSync(root, { recursive: true, mode: 0o700 });
+    const path = join(root, binderKey(startup.room_identity_cid, role.name) + '.json');
+    if (existsSync(path)) {
+        const old = JSON.parse(readFileSync(path, 'utf8'));
+        if (old.room_id !== startup.room_id ||
+            old.invite_id !== startup.invite_id ||
+            old.identity_name !== startup.identity_name)
+            throw Error('ROOM_SECRET_COLLISION');
+        return;
+    }
+    atomicPrivateWrite(path, startup);
+}
+export function storeTemporaryLaunch(role, action) {
+    const root = join(privateRuntimeRoot(), 'launches');
+    mkdirSync(root, { recursive: true, mode: 0o700 });
+    atomicPrivateWrite(join(root, binderKey('temporary', role.name) + '.json'), {
+        role: role.name,
+        identity: role.identity,
+        action,
+    });
+}
+export async function prepareManagedAgent(role, stateDir, temporary) {
+    if (role.owner_channel?.identity === role.identity)
+        throw Error('OWNER_AGENT_IDENTITY_COLLISION');
+    const profile = readClientProfile({ ...process.env, ...role.env });
+    if (!profile)
+        throw Error('MANAGED_OURS_REQUIRES_EXPLICIT_DAEMON_PROFILE');
+    const root = privateRuntimeRoot(), key = binderKey(profile.expectedInstanceId, role.identity), dir = join(root, key);
+    mkdirSync(dir, { recursive: true, mode: 0o700 });
+    const instancePath = join(dir, 'instance.json');
+    const launch = temporary
+        ? JSON.parse(readFileSync(join(root, 'launches', binderKey('temporary', role.name) + '.json'), 'utf8'))
+        : undefined;
+    if (launch &&
+        (launch.role !== role.name ||
+            launch.identity !== role.identity ||
+            typeof launch.action !== 'string'))
+        throw Error('INVALID_TEMP_LAUNCH');
+    let instance;
+    if (existsSync(instancePath)) {
+        const old = JSON.parse(readFileSync(instancePath, 'utf8'));
+        if (old.role !== role.name || old.temporary !== temporary)
+            throw Error('IDENTITY_ASSIGNED_TO_OTHER_ROLE');
+        instance = old.instance;
+    }
+    else {
+        instance = randomUUID();
+        try {
+            writeFileSync(instancePath, JSON.stringify({ instance, role: role.name, temporary }), {
+                flag: 'wx',
+                mode: 0o600,
+            });
+        }
+        catch (error) {
+            if (error.code !== 'EEXIST')
+                throw error;
+            const old = JSON.parse(readFileSync(instancePath, 'utf8'));
+            if (old.role !== role.name || old.temporary !== temporary)
+                throw Error('IDENTITY_ASSIGNED_TO_OTHER_ROLE');
+            instance = old.instance;
+        }
+    }
+    const controller = await RuntimeController.acquire(root, profile.expectedInstanceId, role.identity, instance);
+    let closeClient;
+    let partialEndpoint;
+    try {
+        let prior = controller.journal.read();
+        if (prior?.phase === 'RELEASED') {
+            if (temporary && launch.action === prior.action)
+                throw Error('TERMINAL_TEMP_REQUIRES_NEW_LAUNCH');
+            instance = controller.successor();
+            atomicPrivateWrite(instancePath, { instance, role: role.name, temporary });
+            if (temporary && existsSync(join(dir, 'identity-pin.json')))
+                unlinkSync(join(dir, 'identity-pin.json'));
+            prior = undefined;
+        }
+        const generation = prior ? controller.resumeGeneration() : 1;
+        const tokenPath = join(dir, 'owner.json');
+        let token;
+        if (existsSync(tokenPath)) {
+            const owner = JSON.parse(readFileSync(tokenPath, 'utf8'));
+            if (owner.instance !== instance || typeof owner.token !== 'string')
+                throw Error('OWNER_RECORD_MISMATCH');
+            token = owner.token;
+        }
+        else {
+            if (prior)
+                throw Error('OWNER_RECORD_MISSING');
+            token = randomBytes(32).toString('hex');
+            atomicPrivateWrite(tokenPath, { instance, token });
+        }
+        const client = await attachOursClient({
+            endpoint: profile.endpoint,
+            expectedInstanceId: profile.expectedInstanceId,
+            credentialPath: profile.credentialPath,
+            sessionMode: 'external',
+            leaseToken: token,
+            requiredCapabilities: ['external-sessions-v1', 'root-first-identities-v1'],
+        });
+        closeClient = () => client.close();
+        const pinPath = join(dir, 'identity-pin.json');
+        const pin = existsSync(pinPath) ? JSON.parse(readFileSync(pinPath, 'utf8')) : undefined;
+        if (pin &&
+            (pin.daemon !== profile.expectedInstanceId ||
+                pin.name !== role.identity ||
+                typeof pin.cid !== 'string'))
+            throw Error('INVALID_IDENTITY_PIN');
+        const runtime = new AgentOursRuntime({
+            instance,
+            generation,
+            daemon: profile.expectedInstanceId,
+            name: role.identity,
+            lifetime: temporary ? 'temporary' : 'permanent',
+            action: launch?.action ?? prior?.action ?? randomUUID(),
+            expectedCid: pin?.cid,
+            allowCreate: true,
+            bio: role.bio ?? '',
+        }, {
+            client,
+            journal: controller.journal,
+            assertFence: controller.assertFence,
+            now: Date.now,
+            sleep: (ms) => new Promise((resolve) => setTimeout(resolve, ms)),
+        });
+        let room;
+        if (role.roomMemberStartup) {
+            const startup = role.roomMemberStartup;
+            const path = join(root, 'room-inputs', binderKey(startup.room_identity_cid, role.name) + '.json');
+            const cowork = createCoworkAdapter();
+            room = {
+                id: startup.room_id,
+                cid: startup.room_identity_cid,
+                seat: startup.invite_id,
+                action: startup.invite_id,
+                redeem: async (attached) => {
+                    const secret = JSON.parse(readFileSync(path, 'utf8'));
+                    if (secret.room_id !== startup.room_id ||
+                        secret.invite_id !== startup.invite_id ||
+                        secret.identity_name !== role.identity)
+                        throw Error('ROOM_SECRET_MISMATCH');
+                    return attached.addContact({ invite: secret.invite });
+                },
+                observe: async (agentCid) => {
+                    const [contacts, observed] = await Promise.all([
+                        client.listContacts(),
+                        cowork.getRoom(startup.room_id),
+                    ]);
+                    if (!observed || observed.identity_cid !== startup.room_identity_cid)
+                        return 'mismatch';
+                    const seat = observed.seats.find((s) => s.invite_id === startup.invite_id);
+                    if (seat && (seat.identity_cid !== agentCid || seat.role !== startup.role))
+                        return 'mismatch';
+                    return seat?.seat_state === 'active' &&
+                        contacts.contacts.some((c) => c.container_id === startup.room_identity_cid)
+                        ? 'established'
+                        : 'pending';
+                },
+                discardSecret: async () => {
+                    if (existsSync(path))
+                        unlinkSync(path);
+                },
+            };
+        }
+        await runtime.prepare(room);
+        if (role.roomMemberStartup) {
+            const startup = role.roomMemberStartup;
+            atomicPrivateWrite(join(root, 'room-inputs', binderKey(startup.room_identity_cid, role.name) + '.ready.json'), { room: startup.room_id, invite: startup.invite_id, cid: runtime.snapshot.cid, generation });
+        }
+        if (!pin)
+            atomicPrivateWrite(pinPath, {
+                daemon: profile.expectedInstanceId,
+                name: role.identity,
+                cid: runtime.snapshot.cid,
+            });
+        const identities = new ApplicationIdentityStore({ instanceId: profile.expectedInstanceId }, { path: join(dir, 'application.json') });
+        await identities.add(role.identity);
+        const bridgeDir = join(stateDir, '.ours-bridge');
+        mkdirSync(bridgeDir, { recursive: true, mode: 0o700 });
+        const capability = randomBytes(32).toString('hex'), socket = join(bridgeDir, `g${generation}.sock`);
+        const endpoint = await startMcpEndpoint({
+            socket,
+            capability,
+            generation,
+            runtime,
+            client,
+            identities,
+            remoteDaemonFiles: true,
+        });
+        partialEndpoint = endpoint;
+        const descriptor = join(bridgeDir, 'descriptor.json');
+        atomicPrivateWrite(descriptor, { socket, capability, generation });
+        return {
+            runtime,
+            descriptor,
+            privatePaths: [root, profile.configPath, profile.credentialPath],
+            close: async (terminal) => {
+                try {
+                    await endpoint.close();
+                    if (terminal)
+                        await runtime.terminal();
+                    else
+                        await runtime.suspend();
+                }
+                finally {
+                    try {
+                        await client.close();
+                    }
+                    finally {
+                        controller.unlock();
+                    }
+                }
+            },
+        };
+    }
+    catch (error) {
+        try {
+            await partialEndpoint?.close();
+        }
+        finally {
+            try {
+                await closeClient?.();
+            }
+            finally {
+                controller.unlock();
+            }
+        }
+        throw error;
+    }
+}
+/** Explicit trusted inventory migration: read and pin existing permanent CID, never bind. */
+export async function preparePermanentAssignment(role) {
+    const profile = readClientProfile({ ...process.env, ...role.env });
+    if (!profile)
+        throw Error('MANAGED_OURS_REQUIRES_EXPLICIT_DAEMON_PROFILE');
+    const client = await attachOursClient({
+        endpoint: profile.endpoint,
+        expectedInstanceId: profile.expectedInstanceId,
+        credentialPath: profile.credentialPath,
+        sessionMode: 'local',
+        requiredCapabilities: ['local-pid-v1', 'root-first-identities-v1'],
+    });
+    try {
+        const rows = await client.listIdentities(), row = rows.find((r) => r.name === role.identity);
+        if (!row)
+            return 'unverified';
+        if (!('cid' in row) || row.kind !== 'role' || row.temp)
+            throw Error('PERMANENT_ASSIGNMENT_NOT_A_ROLE');
+        const dir = join(privateRuntimeRoot(), binderKey(profile.expectedInstanceId, role.identity));
+        mkdirSync(dir, { recursive: true, mode: 0o700 });
+        const path = join(dir, 'identity-pin.json');
+        if (existsSync(path)) {
+            const old = JSON.parse(readFileSync(path, 'utf8'));
+            if (old.cid !== row.cid ||
+                old.daemon !== profile.expectedInstanceId ||
+                old.name !== role.identity)
+                throw Error('PERMANENT_ASSIGNMENT_PIN_MISMATCH');
+        }
+        else
+            atomicPrivateWrite(path, {
+                daemon: profile.expectedInstanceId,
+                name: role.identity,
+                cid: row.cid,
+            });
+        return 'verified';
+    }
+    finally {
+        await client.close();
+    }
+}
+export function readRoomReadiness(roomCid, name) {
+    try {
+        return JSON.parse(readFileSync(join(privateRuntimeRoot(), 'room-inputs', binderKey(roomCid, name) + '.ready.json'), 'utf8'));
+    }
+    catch (error) {
+        if (error.code === 'ENOENT')
+            return;
+        throw error;
+    }
+}
+/** Explicit logical-instance termination, independent of harness/bridge transport. */
+export async function releaseManagedAgent(role) {
+    const profile = readClientProfile({ ...process.env, ...role.env });
+    if (!profile)
+        throw Error('MANAGED_OURS_REQUIRES_EXPLICIT_DAEMON_PROFILE');
+    const root = privateRuntimeRoot(), dir = join(root, binderKey(profile.expectedInstanceId, role.identity));
+    if (!existsSync(join(dir, 'instance.json')))
+        return;
+    const instance = JSON.parse(readFileSync(join(dir, 'instance.json'), 'utf8'));
+    if (instance.role !== role.name)
+        throw Error('IDENTITY_ASSIGNED_TO_OTHER_ROLE');
+    const controller = await RuntimeController.acquire(root, profile.expectedInstanceId, role.identity, instance.instance);
+    try {
+        const state = controller.journal.read();
+        if (!state || state.phase === 'RELEASED')
+            return;
+        const owner = JSON.parse(readFileSync(join(dir, 'owner.json'), 'utf8'));
+        if (owner.instance !== state.instance)
+            throw Error('OWNER_RECORD_MISMATCH');
+        const client = await attachOursClient({
+            endpoint: profile.endpoint,
+            expectedInstanceId: profile.expectedInstanceId,
+            credentialPath: profile.credentialPath,
+            sessionMode: 'external',
+            leaseToken: owner.token,
+            requiredCapabilities: ['external-sessions-v1', 'root-first-identities-v1'],
+        });
+        try {
+            const runtime = new AgentOursRuntime({
+                instance: state.instance,
+                generation: state.generation,
+                daemon: state.daemon,
+                name: state.name,
+                lifetime: state.lifetime,
+                action: state.action,
+                allowCreate: false,
+                bio: '',
+            }, {
+                client,
+                journal: controller.journal,
+                assertFence: controller.assertFence,
+                now: Date.now,
+                sleep: (ms) => new Promise((resolve) => setTimeout(resolve, ms)),
+            });
+            await runtime.terminal();
+        }
+        finally {
+            await client.close();
+        }
+    }
+    finally {
+        controller.unlock();
+    }
+}