@ours.network/fleet 1.2.0-nightly.9 → 2.0.1

package/dist/application/room-layout-definitions.js

@@ -0,0 +1,130 @@
+/** Web authoring of `fleet/room_layouts/<name>.yaml`.
+ * Writes are revision-guarded (sha256 of the file bytes) and validated with the
+ * same parser the CLI uses. Retained layout runs keep their own snapshots, so
+ * editing or deleting a definition never changes an existing run.
+ */
+import { createHash } from 'node:crypto';
+import { existsSync, mkdirSync, readFileSync, readdirSync, unlinkSync } from 'node:fs';
+import { basename, extname, join } from 'node:path';
+import { stringify } from 'yaml';
+import { replaceFileAtomically, withFileLock } from '../atomic-file.js';
+import { parseFleetDocument } from '../config-yaml.js';
+import { defaultConfigPath } from '../paths.js';
+import { loadConfig, splitRootFor } from '../config.js';
+import { assertLayoutFile, validLayoutKey, validateRoomLayout } from '../rooms-tasks/layout-config.js';
+import { FleetError } from './errors.js';
+import { layoutDefinitionHash } from './task-layouts.js';
+export const ABSENT_REVISION = 'absent';
+const revisionOf = (bytes) => createHash('sha256').update(bytes).digest('hex');
+export class RoomLayoutDefinitions {
+    configPath;
+    deps;
+    constructor(configPath, deps = {}) {
+        this.configPath = configPath;
+        this.deps = deps;
+    }
+    root() { return join(splitRootFor(this.configPath ?? defaultConfigPath()), 'room_layouts'); }
+    pathFor(name) {
+        if (!validLayoutKey(name))
+            throw new FleetError('invalid_request', 'layout name must start with a letter and use letters, digits, - or _');
+        return join(this.root(), `${name}.yaml`);
+    }
+    currentRevision(path) {
+        if (!existsSync(path))
+            return ABSENT_REVISION;
+        assertLayoutFile(path);
+        return revisionOf(readFileSync(path));
+    }
+    /** Agent-template references that do not resolve in the current Fleet configuration. */
+    templateIssues(definition) {
+        let templates = {};
+        try {
+            templates = (this.deps.loadConfiguration ?? loadConfig)(this.configPath).agentTemplates ?? {};
+        }
+        catch (error) {
+            return [`fleet configuration unavailable: ${error.message}`];
+        }
+        return Object.entries(definition.participants).flatMap(([key, participant]) => participant.agent_template && !Object.hasOwn(templates, participant.agent_template)
+            ? [`participant ${key}: agent template not found: ${participant.agent_template}`] : []);
+    }
+    /** The configured default (`rooms.defaults.template`, else `tasks.default_room_template`) when it names a usable layout. */
+    defaultLayout(entries = this.list()) {
+        let name;
+        try {
+            const config = (this.deps.loadConfiguration ?? loadConfig)(this.configPath);
+            name = config.rooms?.defaults?.template ?? config.tasks?.default_room_template;
+        }
+        catch {
+            return undefined;
+        }
+        const entry = entries.find(e => e.name === name);
+        return entry && !('error' in entry) && !entry.issues.length ? entry.name : undefined;
+    }
+    list() {
+        const root = this.root();
+        if (!existsSync(root))
+            return [];
+        assertLayoutFile(root, true);
+        return readdirSync(root).filter(file => /\.ya?ml$/.test(file)).sort().map(file => {
+            const name = basename(file, extname(file)), path = join(root, file);
+            try {
+                if (!validLayoutKey(name))
+                    throw Error(`invalid room layout id: ${name}`);
+                assertLayoutFile(path);
+                const bytes = readFileSync(path);
+                const definition = validateRoomLayout(parseFleetDocument(path, bytes.toString('utf8'), 'strict').value, file);
+                return { name, file, revision: revisionOf(bytes), definition, issues: this.templateIssues(definition), definition_hash: layoutDefinitionHash(definition) };
+            }
+            catch (error) {
+                // Only a trusted regular file may be read to offer an overwrite revision.
+                let revision = ABSENT_REVISION;
+                try {
+                    assertLayoutFile(path);
+                    revision = revisionOf(readFileSync(path));
+                }
+                catch { /* not trusted: never read */ }
+                return { name, file, revision, error: error.message };
+            }
+        });
+    }
+    validate(raw) {
+        let definition;
+        try {
+            definition = validateRoomLayout(raw, 'room layout');
+        }
+        catch (error) {
+            return { issues: [error.message] };
+        }
+        return { definition, issues: this.templateIssues(definition) };
+    }
+    async save(name, expectedRevision, raw) {
+        const path = this.pathFor(name);
+        const { definition, issues } = this.validate(raw);
+        if (!definition || issues.length)
+            throw new FleetError('invalid_request', issues.join('; '));
+        const root = this.root();
+        mkdirSync(root, { recursive: true, mode: 0o700 });
+        assertLayoutFile(root, true);
+        return withFileLock(`${path}.lock`, async () => {
+            const current = this.currentRevision(path);
+            if (current !== expectedRevision)
+                throw new FleetError('stale_state', 'room layout changed since it was loaded; reload before saving');
+            const { description, participants, rooms } = definition;
+            const text = stringify({ version: 1, ...(description ? { description } : {}), participants, rooms });
+            replaceFileAtomically(path, text, 0o600);
+            return { name, revision: revisionOf(text), definition };
+        });
+    }
+    async remove(name, expectedRevision) {
+        const path = this.pathFor(name);
+        return withFileLock(`${path}.lock`, async () => {
+            const current = this.currentRevision(path);
+            if (current === ABSENT_REVISION)
+                return { name, deleted: false };
+            if (current !== expectedRevision)
+                throw new FleetError('stale_state', 'room layout changed since it was loaded; reload before deleting');
+            unlinkSync(path);
+            return { name, deleted: true };
+        });
+    }
+}

package/dist/application/session-control.d.ts

@@ -1,6 +1,10 @@
-import { controlRequest } from '../session/control.js';
-import type { ConversationEventV1, ConversationSnapshot, PromptReceipt } from '../session/conversation-types.js';
+import type { ConversationRoleObservation, ConversationRoleState, ObserveConversationRole } from './conversation-role-observer.js';
+import { type ConversationTailPage } from './conversation-history.js';
+import type { AgentHistoryQuery } from '../agent-ours/correspondence.js';
+import { controlRequest, followConversation } from '../session/control.js';
+import type { ConversationEventV1, ConversationSnapshot, ConversationObservationState, PromptReceipt } from '../session/conversation-types.js';
 import type { SessionSnapshot } from '../session/types.js';
+import type { PassiveConversationFollowRequest, ConversationReplayPage, ConversationReplayReady } from '../session/conversation-replay.js';
 import type { OutputPage, SendReceipt, SessionDescriptor } from './types.js';
 export interface ConversationPageView {
     events: ConversationEventV1[];
@@ -12,6 +16,23 @@ export interface ConversationPageView {
 export interface ConversationFollowHandle {
     close(): void;
 }
+export interface LegacyConversationFollowRequest {
+    after?: string;
+    onPage(page: ConversationPageView): void;
+    onEvent(event: ConversationEventV1): void;
+    onClose(reason?: string): void;
+}
+export interface PassiveConversationFollow extends PassiveConversationFollowRequest {
+    /** Reports role updates from the owned or borrowed observer; never attaches a controller. */
+    onRole?(state: ConversationRoleState): void;
+    /** Application-only borrowed owner; never sent over the private wire. */
+    roleObservation?: ConversationRoleObservation;
+    onReplay(page: ConversationReplayPage): void;
+    onReady(ready: ConversationReplayReady): void;
+    onEvent(event: ConversationEventV1): void;
+    onState(state: ConversationObservationState): void;
+    onClose(reason?: string): void;
+}
 /**
  * An interrupt that reached the session. `state` says whether the turn stopped
  * cooperatively or through bounded forced recovery — both are accepted, so no
@@ -23,7 +44,11 @@ export interface InterruptReceipt {
     reasonCode?: string;
 }
 export interface RoleSessionControl {
-    describe(): Promise<SessionDescriptor>;
+    /** Standalone owner for role-only observation; dispose with that connection. */
+    observeRole?: ObserveConversationRole;
+    agentContacts?(): Promise<unknown>;
+    agentHistory?(request: AgentHistoryQuery): Promise<unknown>;
+    describe(roleObservation?: ConversationRoleObservation): Promise<SessionDescriptor>;
     snapshot(): Promise<SessionSnapshot>;
     recentOutput(request?: {
         since?: number;
@@ -41,12 +66,25 @@ export interface RoleSessionControl {
         after?: string;
         limit?: number;
     }): Promise<ConversationPageView>;
+    /** The newest visible events (or those before `before`), read backwards from the ledger. */
+    conversationTail?(request: {
+        before?: string;
+        limit?: number;
+        signal?: AbortSignal;
+    }): Promise<ConversationTailPage>;
     submitPromptV2?(request: {
         commandId: string;
         text: string;
         actorBrowserSession: string;
+        expectedSessionGeneration?: string;
+        requireIdle?: boolean;
         source: 'owner_admin_console';
     }): Promise<PromptReceipt>;
+    interruptPromptV2?(request: {
+        commandId: string;
+        expectedSessionGeneration: string;
+        promptId: string;
+    }): Promise<InterruptReceipt>;
     interruptV2?(commandId: string): Promise<InterruptReceipt & {
         commandId: string;
     }>;
@@ -64,18 +102,19 @@ export interface RoleSessionControl {
      * replay page; `onEvent` every subsequent durable event; `onClose` fires
      * exactly once when the underlying control stream ends.
      */
-    followConversation?(request: {
-        after?: string;
-        onPage(page: ConversationPageView): void;
-        onEvent(event: ConversationEventV1): void;
-        onClose(reason?: string): void;
-    }): Promise<ConversationFollowHandle>;
+    followConversation?(request: LegacyConversationFollowRequest | PassiveConversationFollow): Promise<ConversationFollowHandle>;
 }
 export declare class RoleSessionControlAdapter implements RoleSessionControl {
     private readonly stateDir;
     private readonly request;
-    constructor(stateDir: string, request?: typeof controlRequest);
-    describe(): Promise<SessionDescriptor>;
+    private readonly openFollow;
+    readonly observeRole?: ObserveConversationRole | undefined;
+    private controlHealthy;
+    constructor(stateDir: string, request?: typeof controlRequest, openFollow?: typeof followConversation, observeRole?: ObserveConversationRole | undefined);
+    agentContacts(): Promise<unknown>;
+    agentHistory(request: AgentHistoryQuery): Promise<unknown>;
+    private requireCorrespondence;
+    describe(roleObservation?: ConversationRoleObservation): Promise<SessionDescriptor>;
     snapshot(): Promise<SessionSnapshot>;
     recentOutput(request?: {
         since?: number;
@@ -87,12 +126,24 @@ export declare class RoleSessionControlAdapter implements RoleSessionControl {
         after?: string;
         limit?: number;
     }): Promise<ConversationPageView>;
+    conversationTail(request?: {
+        before?: string;
+        limit?: number;
+        signal?: AbortSignal;
+    }): Promise<ConversationTailPage>;
     submitPromptV2(request: {
         commandId: string;
         text: string;
         actorBrowserSession: string;
+        expectedSessionGeneration?: string;
+        requireIdle?: boolean;
         source: 'owner_admin_console';
     }): Promise<PromptReceipt>;
+    interruptPromptV2(request: {
+        commandId: string;
+        expectedSessionGeneration: string;
+        promptId: string;
+    }): Promise<InterruptReceipt>;
     interruptV2(commandId: string): Promise<InterruptReceipt & {
         commandId: string;
     }>;
@@ -105,12 +156,7 @@ export declare class RoleSessionControlAdapter implements RoleSessionControl {
         accepted: true;
         commandId: string;
     }>;
-    followConversation(request: {
-        after?: string;
-        onPage(page: ConversationPageView): void;
-        onEvent(event: ConversationEventV1): void;
-        onClose(reason?: string): void;
-    }): Promise<ConversationFollowHandle>;
+    followConversation(request: LegacyConversationFollowRequest | PassiveConversationFollow): Promise<ConversationFollowHandle>;
     respondPermission(request: {
         permissionId: string;
         optionId: string;

package/dist/application/session-control.js

@@ -1,20 +1,42 @@
+import { readFile } from 'node:fs/promises';
+import { join } from 'node:path';
+import { conversationTailPage, resumedConversationPage } from './conversation-history.js';
 import { controlRequest, followConversation } from '../session/control.js';
 import { FleetError, normalizeError } from './errors.js';
 const visibleEvents = (events) => events.filter(event => event.kind !== 'thought');
 export class RoleSessionControlAdapter {
     stateDir;
     request;
-    constructor(stateDir, request = controlRequest) {
+    openFollow;
+    observeRole;
+    controlHealthy = true;
+    constructor(stateDir, request = controlRequest, openFollow = followConversation, observeRole) {
         this.stateDir = stateDir;
         this.request = request;
+        this.openFollow = openFollow;
+        this.observeRole = observeRole;
     }
-    async describe() {
-        const response = await this.call('snapshot');
-        const result = response;
-        return {
-            backend: result.backend, protocolVersion: result.protocolVersion ?? 1,
-            features: result.features ?? [], snapshot: result,
-        };
+    async agentContacts() { await this.requireCorrespondence(); return this.call('agent_contacts'); }
+    async agentHistory(request) { await this.requireCorrespondence(); return this.call('agent_history', { agentHistory: request }); }
+    async requireCorrespondence() { if (!(await this.describe()).features.includes('agent_correspondence'))
+        throw new FleetError('capability_unavailable', 'This session needs an updated supervisor to show contacts and history.'); }
+    async describe(roleObservation) {
+        // A describe probe owns and always disposes its temporary watcher. Follow uses
+        // a separate connection-owned observer and publishes updates via onRole.
+        const role = roleObservation ?? this.observeRole?.(() => { });
+        try {
+            const response = await this.call('snapshot');
+            const result = response;
+            const features = (result.features ?? []).filter(feature => feature !== 'conversation_live_complete');
+            if (this.controlHealthy && role?.snapshot().health === 'healthy' && role.snapshot().availability === 'available'
+                && features.includes('conversation_observation') && features.includes('control_heartbeat'))
+                features.push('conversation_live_complete');
+            return { backend: result.backend, protocolVersion: result.protocolVersion ?? 1, features, snapshot: result };
+        }
+        finally {
+            if (!roleObservation)
+                role?.dispose();
+        }
     }
     async snapshot() {
         return await this.call('snapshot');
@@ -58,28 +80,103 @@ export class RoleSessionControlAdapter {
         };
     }
     async conversationPage(request = {}) {
-        return await this.call('conversation_page', {
+        const live = await this.call('conversation_page', {
             after: request.after, limit: request.limit,
         });
+        const snapshot = await this.snapshot();
+        if (snapshot.backend !== 'acp' || !snapshot.sessionId)
+            return live;
+        try {
+            const history = await resumedConversationPage(this.stateDir, request, live, snapshot.sessionId);
+            const check = await this.call('conversation_page', { limit: 1 });
+            return check.snapshot.sessionGeneration === live.snapshot.sessionGeneration ? history : await this.call('conversation_page', request);
+        }
+        catch {
+            return live;
+        }
+    }
+    async conversationTail(request = {}) {
+        // A replacement while reading disk invalidates both the tail and its snapshot.
+        for (let attempt = 0; attempt < 3; attempt++) {
+            request.signal?.throwIfAborted();
+            const live = await this.call('conversation_page', { limit: 1 });
+            request.signal?.throwIfAborted();
+            const snapshot = await this.snapshot();
+            let resumed;
+            if (snapshot.backend === 'acp' && snapshot.sessionId) {
+                try {
+                    if ((await readFile(join(this.stateDir, '.acp-session-id'), 'utf8')).trim() === snapshot.sessionId)
+                        resumed = snapshot.sessionId;
+                }
+                catch { /* no resumed history: live generation only */ }
+            }
+            let page;
+            try {
+                page = await conversationTailPage(this.stateDir, request, live.snapshot, resumed, request.signal);
+            }
+            catch (error) {
+                request.signal?.throwIfAborted();
+                throw new FleetError('invalid_request', error.message);
+            }
+            request.signal?.throwIfAborted();
+            const check = await this.call('conversation_page', { limit: 1 });
+            request.signal?.throwIfAborted();
+            if (check.snapshot.sessionGeneration === live.snapshot.sessionGeneration)
+                return page;
+        }
+        throw new FleetError('stale_state', 'Session generation changed during conversation baseline; explicit recovery required.');
     }
     async submitPromptV2(request) {
         if (!request.text.trim())
             throw new FleetError('invalid_request', 'text is required');
         if (Buffer.byteLength(request.text) > 32 * 1024)
             throw new FleetError('invalid_request', 'text exceeds 32 KiB');
+        // A prompt bound to a session generation (voice or attachments) is checked atomically by supervisors that
+        // support it. Older supervisors do not know that command and never answer, so check the generation here
+        // and submit an ordinary prompt; its command id keeps retries idempotent either way.
+        const features = request.requireIdle ? (await this.describe()).features : undefined;
+        if (request.requireIdle && (!request.expectedSessionGeneration || !features?.includes('idle_bound_prompts')))
+            throw new FleetError('capability_unavailable', 'Live voice requires an updated supervisor.');
+        let command = 'submit_prompt_v2';
+        if (request.expectedSessionGeneration) {
+            if ((await this.describe()).features.includes('generation_bound_prompts'))
+                command = 'submit_voice_prompt';
+            else {
+                const live = await this.call('conversation_page', { limit: 1 });
+                if (live.snapshot?.sessionGeneration !== request.expectedSessionGeneration)
+                    throw new FleetError('stale_state', 'Agent session changed. Record a new voice message.');
+            }
+        }
         try {
-            return await this.call('submit_prompt_v2', {
+            return await this.call(command, {
                 commandId: request.commandId, text: request.text, actor: request.actorBrowserSession,
-                source: request.source,
+                source: request.source, expectedSessionGeneration: request.expectedSessionGeneration, requireIdle: request.requireIdle,
             });
         }
         catch (error) {
             const fleetError = normalizeError(error);
+            if (fleetError.message.includes('session_changed:'))
+                throw new FleetError('stale_state', 'Agent session changed. Record a new voice message.');
+            if (fleetError.message.includes('voice_busy:'))
+                throw new FleetError('conflict', 'Agent is already working. Wait for the current turn.');
             if (fleetError.message.includes('idempotency_conflict'))
                 throw new FleetError('idempotency_conflict', 'this command id was already used with a different prompt body');
             throw fleetError;
         }
     }
+    async interruptPromptV2(request) {
+        if (!(await this.describe()).features.includes('targeted_voice_interrupt'))
+            throw new FleetError('capability_unavailable', 'Live voice requires an updated supervisor.');
+        try {
+            return await this.call('interrupt_voice_v2', request);
+        }
+        catch (error) {
+            const failure = normalizeError(error);
+            if (failure.message.includes('session_changed:'))
+                throw new FleetError('stale_state', 'Agent session changed.');
+            throw failure;
+        }
+    }
     async interruptV2(commandId) {
         const receipt = await this.call('interrupt_v2', { commandId });
         return {
@@ -101,32 +198,133 @@ export class RoleSessionControlAdapter {
         }
     }
     async followConversation(request) {
+        const passive = 'controller' in request ? request : undefined;
         let sawPage = false;
         let closed = false;
+        let role;
+        let unsubscribeRole;
+        let lifetime;
+        let roleRevision = -1;
+        let silence;
+        let lastControlHeartbeat = Date.now();
+        const armSilence = () => {
+            if (silence)
+                clearTimeout(silence);
+            silence = setTimeout(() => {
+                // Liveness only: no role/session snapshots, regardless of web traffic.
+                if (Date.now() - lastControlHeartbeat >= 45_000) {
+                    this.controlHealthy = false;
+                    finish('control-silent');
+                }
+                else
+                    armSilence();
+            }, Math.max(1, 45_000 - (Date.now() - lastControlHeartbeat)));
+            silence.unref?.();
+        };
+        let follow;
         const finish = (reason) => {
             if (closed)
                 return;
             closed = true;
+            passive?.signal?.removeEventListener('abort', aborted);
+            if (silence)
+                clearTimeout(silence);
+            unsubscribeRole?.();
+            if (!passive?.roleObservation)
+                role?.dispose();
+            follow?.close();
             request.onClose(reason);
         };
-        const follow = await followConversation(this.stateDir, request.after, message => {
-            if (message.conversationEvent) {
-                request.onEvent(message.conversationEvent);
-                return;
+        const aborted = () => finish('conversation follow aborted');
+        passive?.signal?.addEventListener('abort', aborted, { once: true });
+        if (passive?.signal?.aborted)
+            aborted();
+        if (closed)
+            return { close: () => { } };
+        try {
+            if (passive) {
+                const changed = (state) => {
+                    if (closed || state.roleRevision <= roleRevision)
+                        return;
+                    roleRevision = state.roleRevision;
+                    passive.onRole?.(state);
+                    if (state.health !== 'healthy') {
+                        this.controlHealthy = false;
+                        finish(state.failure ?? 'role-observation-unavailable');
+                    }
+                    else if (lifetime !== undefined && (state.roleLifetime !== lifetime || state.availability !== 'available' || state.stateDir !== this.stateDir))
+                        finish('role-replaced');
+                    lifetime = state.roleLifetime;
+                };
+                role = passive.roleObservation ?? this.observeRole?.(() => { });
+                if (role) {
+                    const registration = role.subscribe(changed);
+                    unsubscribeRole = registration.unsubscribe;
+                    const initial = registration.snapshot;
+                    changed(initial);
+                    if (initial.availability !== 'available' || initial.stateDir !== this.stateDir)
+                        finish('role-unavailable');
+                    if (closed)
+                        return { close: () => { } };
+                }
+                armSilence();
             }
-            if (!sawPage) {
-                sawPage = true;
+            follow = await this.openFollow(this.stateDir, passive ? { controller: false, expectedGeneration: passive.expectedGeneration, after: passive.after, signal: passive.signal } : request.after, message => {
+                if (closed)
+                    return;
+                if (passive) {
+                    // A delayed callback must not revive an already elapsed source deadline.
+                    if (Date.now() - lastControlHeartbeat >= 45_000) {
+                        this.controlHealthy = false;
+                        finish('control-silent');
+                        return;
+                    }
+                    if (message.controlHeartbeat === true || message.conversationReplay || message.conversationReady || message.conversationEvent || message.conversationState) {
+                        lastControlHeartbeat = Date.now();
+                        this.controlHealthy = true;
+                        armSilence();
+                    }
+                    if (message.controlHeartbeat === true)
+                        return;
+                }
                 if (message.ok === false) {
                     finish(String(message.error ?? 'conversation follow refused'));
-                    follow.close();
                     return;
                 }
-                request.onPage(message.result);
+                if (message.conversationEvent) {
+                    request.onEvent(message.conversationEvent);
+                    return;
+                }
+                if (passive) {
+                    if (message.conversationReplay)
+                        passive.onReplay(message.conversationReplay);
+                    else if (message.conversationReady)
+                        passive.onReady(message.conversationReady);
+                    else if (message.conversationState)
+                        passive.onState(message.conversationState);
+                }
+                else if (!sawPage) {
+                    sawPage = true;
+                    request.onPage(message.result);
+                }
+            });
+            // Abort may win while the connector is still creating its handle.
+            if (closed || passive?.signal?.aborted) {
+                follow.close();
+                finish('conversation follow aborted');
             }
-        });
-        follow.socket.once('close', () => finish());
-        follow.socket.once('error', error => finish(error.message));
-        return { close: () => { follow.close(); finish(); } };
+            else {
+                follow.socket.once('close', () => finish());
+                follow.socket.once('error', error => finish(error.message));
+                if (follow.socket.destroyed)
+                    finish();
+            }
+            return { close: () => finish() };
+        }
+        catch (error) {
+            finish(error.message);
+            throw error;
+        }
     }
     async respondPermission(request) {
         await this.call('respond_permission', request);

package/dist/application/supervisor-ours-tools.js

@@ -1,3 +1,4 @@
+import { socketPath } from '../socket-path.js';
 import { createHash } from 'node:crypto';
 import { existsSync, readFileSync } from 'node:fs';
 import { join } from 'node:path';
@@ -35,7 +36,8 @@ export class SupervisorOursTools {
         const identity = legacy
             ? legacySupervisorIdentity(role, identityName, selected.temporary, descriptor.generation)
             : { name: identityName, cid: descriptor.cid, generation: descriptor.generation };
-        if (legacy && descriptor.socket !== join(selected.dir, '.ours-bridge', `g${descriptor.generation}.sock`))
+        const legacySocket = join(selected.dir, '.ours-bridge', `g${descriptor.generation}.sock`);
+        if (legacy && descriptor.socket !== legacySocket && descriptor.socket !== socketPath(legacySocket))
             throw new FleetError('capability_unavailable', 'legacy supervisor socket does not match the selected agent');
         if ((!legacy && (descriptor.role !== role || descriptor.identity !== identityName))
             || !/^[a-f0-9]{64}$/i.test(identity.cid ?? '') || !Number.isSafeInteger(descriptor.generation) || descriptor.generation < 1)
@@ -71,16 +73,8 @@ export class SupervisorOursTools {
                     verifySelection();
                     return;
                 }
-                const actual = await client.callTool({ name: 'current_identity', arguments: {} });
-                const blocks = actual.content;
-                const lines = blocks?.length === 1 && blocks[0].type === 'text' ? blocks[0].text?.split('\n') : undefined;
-                const prefix = `Bound to "${identity.name}" (${identity.cid})`;
-                const suffix = lines?.[0].startsWith(prefix) ? lines[0].slice(prefix.length) : undefined;
-                const roleSuffix = typeof suffix === 'string' && /^ — role "[^"\r\n]+" under root "[^"\r\n]+"\.$/.test(suffix);
-                const temporaryLine = 'TEMPORARY identity owned by the Fleet supervisor for this logical agent instance. Bridge or harness disconnect retains it; terminal supervisor release deletes local state with best-effort peer notices.';
-                if (actual.isError || !(roleSuffix || (selected.temporary && suffix === '.'))
-                    || (selected.temporary ? lines?.[1] !== temporaryLine : lines?.[1]?.startsWith('TEMPORARY')))
-                    throw new FleetError('capability_unavailable', 'connected supervisor identity does not match legacy ownership proof');
+                // The supervisor owns the binding. The authenticated bridge and pinned local
+                // assignment are authoritative; current_identity is display text, not a protocol.
                 const fresh = legacySupervisorIdentity(role, identityName, selected.temporary, descriptor.generation);
                 if (!('proof' in identity) || fresh.proof !== identity.proof)
                     throw new FleetError('capability_unavailable', 'legacy supervisor identity changed');