@ours.network/fleet 1.2.0-nightly.2 → 1.2.0-nightly.21

package/dist/session/acp.d.ts

@@ -1,3 +1,4 @@
+import { type TaskNoticeBinding, type TaskCreatedNotice } from './task-notice.js';
 import * as acp from '@agentclientprotocol/sdk';
 import type { CommonPermissions } from '../config.js';
 import type { AcpMcpServer } from '../harness/types.js';
@@ -340,6 +341,8 @@ export declare class AcpSession implements AgentSession {
     private codexMessagePhase;
     /** Normalize every ACP update losslessly into the durable ledger. */
     private recordConversationUpdate;
+    taskNoticeBinding(): TaskNoticeBinding | undefined;
+    recordTaskCreated(binding: TaskNoticeBinding, notice: TaskCreatedNotice): void;
     conversationPage(request?: {
         after?: string;
         limit?: number;

package/dist/session/acp.js

@@ -1,3 +1,4 @@
+import { appendTaskCreated } from './task-notice.js';
 import { spawn } from 'node:child_process';
 import { createHash, randomUUID } from 'node:crypto';
 import { existsSync, lstatSync, readFileSync, readlinkSync, realpathSync, writeFileSync, } from 'node:fs';
@@ -760,6 +761,8 @@ export class AcpSession {
         const existing = this.conversation.receiptFor(command.commandId, bodyDigest);
         if (existing)
             return existing;
+        if (command.expectedSessionGeneration !== undefined && command.expectedSessionGeneration !== this.conversationSnapshot().sessionGeneration)
+            throw new Error('session_changed: Agent session changed. Record a new voice message.');
         const queued = await this.queuePrompt(command.text, {
             origin: { kind: 'owner-admin-console', commandId: command.commandId },
             actor: { browserSession: command.actorBrowserSession },
@@ -1805,6 +1808,10 @@ export class AcpSession {
         });
     }
     // ── conversation ledger access (AgentSession) ─────────────────────────────
+    taskNoticeBinding() {
+        return this.activeTurn && this.sessionId ? { sessionGeneration: this.sessionGeneration, acpSessionId: this.sessionId, promptId: this.activeTurn.id } : undefined;
+    }
+    recordTaskCreated(binding, notice) { appendTaskCreated(this.conversation, binding, notice); }
     conversationPage(request = {}) {
         const floor = Number(this.conversationStartCursor ?? 0);
         const requested = Number(request.after ?? 0);

package/dist/session/arbiter.d.ts

@@ -23,6 +23,7 @@ export declare class RoleTurnArbiter implements AgentSession {
     private tail;
     private unsettled;
     private stopping;
+    private retiring;
     /** Bumped by `retireStalledAdmission`; every claim carries the one it was made under. */
     private generation;
     /** Resolves the instant the CURRENT generation is retired. */
@@ -62,6 +63,8 @@ export declare class RoleTurnArbiter implements AgentSession {
     tryScheduled(text: string, origin: Extract<PromptOrigin, {
         kind: 'scheduled-loop';
     }>, beforeQueue?: () => void | Promise<void>): Promise<ScheduledAttempt>;
+    /** Retire only at the same admission boundary used by all prompt producers. */
+    retireIfIdle(expired: (snapshot: SessionSnapshot, queueDepth: number) => boolean): Promise<boolean>;
     stopScheduledAdmission(): void;
     isAlive(): boolean;
     snapshot(): SessionSnapshot;

package/dist/session/arbiter.js

@@ -29,6 +29,7 @@ export class RoleTurnArbiter {
     tail = Promise.resolve();
     unsettled = 0;
     stopping = false;
+    retiring = false;
     /** Bumped by `retireStalledAdmission`; every claim carries the one it was made under. */
     generation = 0;
     /** Resolves the instant the CURRENT generation is retired. */
@@ -89,7 +90,8 @@ export class RoleTurnArbiter {
         retired.retire();
     }
     queuePrompt(text, options = {}) {
-        return this.exclusive(async () => this.track(await this.session.queuePrompt(text, options)));
+        return this.exclusive(async () => { if (this.retiring)
+            throw new Error('Chat is closing'); return this.track(await this.session.queuePrompt(text, options)); });
     }
     async submitPrompt(text, options = {}) {
         return (await this.queuePrompt(text, options)).completion;
@@ -99,6 +101,8 @@ export class RoleTurnArbiter {
      * answers and explicit interrupts must remain able to pass immediately.
      */
     submitPromptAfterTool(text, options = {}) {
+        if (this.retiring)
+            return Promise.reject(new Error('Chat is closing'));
         return this.session.submitPromptAfterTool?.(text, options)
             ?? this.session.submitPrompt(text, { ...options, interrupt: false, steer: false });
     }
@@ -136,6 +140,19 @@ export class RoleTurnArbiter {
             throw error;
         });
     }
+    /** Retire only at the same admission boundary used by all prompt producers. */
+    retireIfIdle(expired) {
+        return this.exclusive(async () => {
+            const snapshot = this.session.snapshot();
+            const queue = this.session.conversationSnapshot?.().queueDepth ?? -1;
+            if (this.retiring || this.unsettled > 0 || snapshot.readiness !== 'idle' || !expired(snapshot, queue))
+                return false;
+            this.retiring = true;
+            this.stopping = true;
+            await this.session.close();
+            return true;
+        });
+    }
     stopScheduledAdmission() { this.stopping = true; }
     isAlive() { return this.session.isAlive(); }
     snapshot() { return this.session.snapshot(); }
@@ -157,7 +174,8 @@ export class RoleTurnArbiter {
     submitPromptBrowser(command) {
         if (!this.session.submitPromptBrowser)
             return Promise.reject(new Error('browser prompt admission is unavailable'));
-        return this.exclusive(() => this.session.submitPromptBrowser(command));
+        return this.exclusive(() => { if (this.retiring)
+            throw new Error('Chat is closing'); return this.session.submitPromptBrowser(command); });
     }
     interrupt(source = 'local-console') {
         return this.exclusive(async () => interruptOutcome(await this.session.interrupt(source)));

package/dist/session/codex-app-server-transport.js

@@ -55,7 +55,7 @@ export class CodexAppServerTransport {
             throw new Error('Codex app-server command is empty');
         const child = spawn(options.argv[0], options.argv.slice(1), {
             cwd: options.cwd,
-            env: { ...process.env, ...options.env },
+            env: { ...(options.env?.FLEET_OURS_MANAGED === '1' ? {} : process.env), ...options.env },
             stdio: ['pipe', 'pipe', 'pipe'],
         });
         // `pid` is assigned synchronously on a successful local spawn. Checking it

package/dist/session/codex-app-server.d.ts

@@ -1,3 +1,4 @@
+import { type TaskNoticeBinding, type TaskCreatedNotice } from './task-notice.js';
 import type { CommonPermissions } from '../config.js';
 import type { ConversationEventV1, ConversationSnapshot, PromptOrigin, PromptReceipt, SubmitPromptCommand } from './conversation-types.js';
 import type { CodexAppServerTransportFactory } from './codex-app-server-transport.js';
@@ -76,6 +77,8 @@ export declare class CodexAppServerSession implements AgentSession {
     setControllerAttached(attached: boolean): void;
     exitResult(): ExitRecord | null;
     close(): Promise<void>;
+    taskNoticeBinding(): TaskNoticeBinding | undefined;
+    recordTaskCreated(binding: TaskNoticeBinding, notice: TaskCreatedNotice): void;
     conversationPage(request?: {
         after?: string;
         limit?: number;

package/dist/session/codex-app-server.js

@@ -1,6 +1,8 @@
+import { appendTaskCreated } from './task-notice.js';
 import { createHash, randomUUID } from 'node:crypto';
 import { existsSync, readFileSync, writeFileSync } from 'node:fs';
 import { isAbsolute, join, resolve } from 'node:path';
+import { boundedJson } from './conversation-normalizer.js';
 import { ConversationEventStore } from './conversation-store.js';
 import { SessionEvents } from './events.js';
 import { CodexAppServerTransport } from './codex-app-server-transport.js';
@@ -228,8 +230,10 @@ export class CodexAppServerSession {
     }
     async interrupt(source = 'local-console') {
         const active = this.activeTurn;
-        if (!active || !this.threadId || !active.nativeTurnId)
+        if (!active || !this.threadId)
             return { state: 'settled' };
+        if (!active.nativeTurnId)
+            throw new SessionControlError('backend', 'The operation is still pending without a native turn ID. Cancellation is not confirmed; inspect or restart the agent if it does not progress.');
         active.cancellationSource ??= source;
         this.events.emit('state', { turnId: active.promptId, status: 'running', origin: active.origin });
         this.conversation.appendSafe({
@@ -335,6 +339,10 @@ export class CodexAppServerSession {
         this.conversation.close();
         await this.transport.close();
     }
+    taskNoticeBinding() {
+        return this.activeTurn && this.threadId ? { sessionGeneration: this.sessionGeneration, acpSessionId: this.threadId, promptId: this.activeTurn.promptId } : undefined;
+    }
+    recordTaskCreated(binding, notice) { appendTaskCreated(this.conversation, binding, notice); }
     conversationPage(request = {}) {
         const floor = Number(this.conversationStartCursor ?? 0);
         const requested = Number(request.after ?? 0);
@@ -367,6 +375,8 @@ export class CodexAppServerSession {
         const existing = this.conversation.receiptFor(command.commandId, bodyDigest);
         if (existing)
             return existing;
+        if (command.expectedSessionGeneration !== undefined && command.expectedSessionGeneration !== this.conversationSnapshot().sessionGeneration)
+            throw new Error('session_changed: Agent session changed. Record a new voice message.');
         const queued = await this.queuePrompt(command.text, {
             origin: { kind: 'owner-admin-console', commandId: command.commandId },
             actor: { browserSession: command.actorBrowserSession },
@@ -415,6 +425,10 @@ export class CodexAppServerSession {
             this.reasoningEffort = { value: effort };
         this.readiness = 'idle';
         this.events.emit('state', { status: 'idle', text: `Codex thread ${this.threadId}` });
+        this.conversation.appendSafe({
+            kind: 'capabilities.updated', sessionGeneration: this.sessionGeneration,
+            payload: { commands: [{ name: 'compact', description: textBlock('Compact session context') }] },
+        });
         this.conversation.appendSafe({
             kind: 'session.state', sessionGeneration: this.sessionGeneration,
             payload: { status: 'idle' },
@@ -486,6 +500,12 @@ export class CodexAppServerSession {
             promptId, turnId: promptId, source: sourceFor(origin).source, payload: {},
         });
         try {
+            if (text.trim() === '/compact') {
+                // The acknowledgement is not completion. Standard turn notifications
+                // settle the same queued prompt and durable browser receipt.
+                await this.transport.request('thread/compact/start', { threadId: this.threadId });
+                return await settled;
+            }
             const response = await this.transport.request('turn/start', {
                 threadId: this.threadId,
                 input: [{ type: 'text', text, text_elements: [] }],
@@ -746,6 +766,10 @@ export class CodexAppServerSession {
                 toolCallId: scheduled ? 'scheduled-loop-tool' : id, snapshot,
                 title: scheduled ? 'scheduled-loop tool' : tool.title, status: tool.status,
                 kind: string(item.type),
+                ...(!scheduled && item.arguments !== undefined ? { rawInput: boundedJson(item.arguments) } : {}),
+                ...(!scheduled && item.type === 'commandExecution' ? { rawInput: boundedJson({ command: item.command, cwd: item.cwd }), ...(item.aggregatedOutput !== undefined ? { rawOutput: boundedJson({ output: item.aggregatedOutput, exitCode: item.exitCode }) } : {}) } : {}),
+                ...(!scheduled && item.type === 'fileChange' && item.changes !== undefined ? { rawOutput: boundedJson(item.changes) } : {}),
+                ...(!scheduled && (item.result !== undefined || item.error !== undefined) ? { rawOutput: boundedJson({ result: item.result, error: item.error }) } : {}),
             },
         });
     }

package/dist/session/control.d.ts

@@ -1,3 +1,5 @@
+import type { LayoutControlRequest } from '../rooms-tasks/layout-control.js';
+import type { SupervisorCorrespondence, AgentHistoryQuery } from '../agent-ours/correspondence.js';
 import { type Socket } from 'node:net';
 import type { AgentSession, ControlFailureKind, SessionEvent, SessionSnapshot } from './types.js';
 import type { OwnerChannelHandle, OwnerChannelManagementRequest } from '../owner-channel/channel.js';
@@ -9,8 +11,11 @@ export interface ControlRequest {
     version: 1 | 2 | 3;
     id: string;
     token: string;
-    command: 'status' | 'snapshot' | 'submit_prompt' | 'respond_permission' | 'interrupt' | 'follow' | 'events_since' | 'owner_channel_manage' | 'loop_status' | 'loop_run_now' | 'loop_disable' | 'loop_enable' | 'reload_config' | 'conversation_page' | 'conversation_follow' | 'submit_prompt_v2' | 'interrupt_v2' | 'respond_permission_v2' | 'fleet_spawn' | 'fleet_audit_begin' | 'fleet_audit_present' | 'fleet_audit_finish';
+    command: 'status' | 'snapshot' | 'submit_prompt' | 'respond_permission' | 'interrupt' | 'follow' | 'events_since' | 'owner_channel_manage' | 'loop_status' | 'loop_run_now' | 'loop_disable' | 'loop_enable' | 'reload_config' | 'conversation_page' | 'conversation_follow' | 'submit_prompt_v2' | 'submit_voice_prompt' | 'interrupt_v2' | 'layout_control' | 'agent_contacts' | 'agent_history' | 'respond_permission_v2' | 'fleet_spawn' | 'fleet_audit_begin' | 'fleet_audit_present' | 'fleet_audit_finish';
+    layout?: LayoutControlRequest;
+    agentHistory?: AgentHistoryQuery;
     text?: string;
+    expectedSessionGeneration?: string;
     permissionId?: string;
     optionId?: string;
     since?: number;
@@ -112,9 +117,13 @@ export declare class RoleControlServer {
     private readonly sockets;
     /** Interrupt idempotency: same command id returns the first receipt. */
     private readonly interruptCommands;
+    private correspondence?;
+    setCorrespondence(value: SupervisorCorrespondence): void;
     private ownerChannel?;
     private loopManager?;
     private reloadConfig?;
+    private layoutControl?;
+    setLayoutControl(handler: (request: LayoutControlRequest) => Promise<unknown>): void;
     private fleetSpawner?;
     private fleetAuditor?;
     constructor(stateDir: string, session: AgentSession, log: (line: string) => void);

package/dist/session/control.js

@@ -1,3 +1,4 @@
+import { socketPath as privateSocketPath } from '../socket-path.js';
 import { randomBytes, randomUUID, timingSafeEqual } from 'node:crypto';
 import { chmodSync, existsSync, readFileSync, rmSync, writeFileSync } from 'node:fs';
 import { createConnection, createServer } from 'node:net';
@@ -8,7 +9,7 @@ import { interruptSession, queueSessionPrompt, respondSessionPermission, respond
 const MAX_LINE_BYTES = 64 * 1024;
 /** Commands that require protocol version 3. */
 const V3_COMMANDS = new Set([
-    'conversation_page', 'conversation_follow', 'submit_prompt_v2', 'interrupt_v2',
+    'conversation_page', 'conversation_follow', 'submit_prompt_v2', 'submit_voice_prompt', 'interrupt_v2',
     'respond_permission_v2',
 ]);
 /** The one retained-range projection shared by polling and live-follow admission. */
@@ -99,7 +100,7 @@ export function oversightTaxonomy(name = '<Name>') {
 export function oversightTaxonomyLines(name = '<Name>') {
     return oversightTaxonomy(name).map(r => `- **${r.result}** — ${r.meaning} → ${r.action}`);
 }
-export const controlSocketPath = (stateDir) => join(stateDir, '.control.sock');
+export const controlSocketPath = (stateDir) => privateSocketPath(join(stateDir, '.control.sock'));
 export const controlTokenPath = (stateDir) => join(stateDir, '.control-token');
 function sameToken(actual, supplied) {
     const a = Buffer.from(actual);
@@ -116,9 +117,13 @@ export class RoleControlServer {
     sockets = new Set();
     /** Interrupt idempotency: same command id returns the first receipt. */
     interruptCommands = new Map();
+    correspondence;
+    setCorrespondence(value) { this.correspondence = value; }
     ownerChannel;
     loopManager;
     reloadConfig;
+    layoutControl;
+    setLayoutControl(handler) { this.layoutControl = handler; }
     fleetSpawner;
     fleetAuditor;
     constructor(stateDir, session, log) {
@@ -235,6 +240,7 @@ export class RoleControlServer {
                             protocolVersion: this.session.conversationPage ? 3 : 2,
                             features: [
                                 'events_since', 'observer_follow', 'retained_range',
+                                ...(this.correspondence ? ['agent_correspondence'] : []),
                                 ...(this.session.conversationPage ? ['conversation_v3'] : []),
                                 ...(this.session.capabilities?.steering ? ['steering'] : []),
                                 ...(this.session.capabilities?.permissions ? ['permissions'] : []),
@@ -308,6 +314,13 @@ export class RoleControlServer {
                     });
                     return;
                 }
+                case 'layout_control': {
+                    if (request.version !== 2 || !request.layout || !this.layoutControl)
+                        throw new SessionControlError('rejected', 'layout control unavailable');
+                    const result = await this.layoutControl(request.layout);
+                    this.write(socket, { version: 1, id: request.id, ok: true, result });
+                    return;
+                }
                 case 'fleet_spawn': {
                     if (request.version !== 2 || !request.spawn || typeof request.spawn.name !== 'string')
                         throw new SessionControlError('rejected', 'version 2 and typed spawn options are required');
@@ -362,6 +375,23 @@ export class RoleControlServer {
                     this.write(socket, { version: 1, id: request.id, ok: true, result: { delivered: true } });
                     return;
                 }
+                case 'agent_contacts':
+                case 'agent_history': {
+                    if (!this.correspondence)
+                        throw new SessionControlError('rejected', 'Supervisor correspondence API is unavailable; this session needs an updated supervisor.');
+                    const query = request.agentHistory;
+                    if (request.command === 'agent_history' && (!query || !/^[a-f0-9]{64}$/i.test(query.peer_cid) || (query.limit !== undefined && (!Number.isInteger(query.limit) || query.limit < 1 || query.limit > 200)) || (query.before_seq !== undefined && (!Number.isSafeInteger(query.before_seq) || query.before_seq < 1))))
+                        throw new SessionControlError('rejected', 'Valid peer_cid, limit (1–200) and before_seq are required.');
+                    let result;
+                    try {
+                        result = request.command === 'agent_contacts' ? await this.correspondence.contacts() : await this.correspondence.history(query);
+                    }
+                    catch {
+                        throw new SessionControlError('rejected', 'Supervisor correspondence read failed; identity or transport is unavailable.');
+                    }
+                    this.write(socket, { version: 1, id: request.id, ok: true, result });
+                    return;
+                }
                 case 'owner_channel_manage': {
                     if (!request.ownerChannel || typeof request.ownerChannel.action !== 'string')
                         throw new SessionControlError('rejected', 'owner-channel management action is required');
@@ -421,7 +451,10 @@ export class RoleControlServer {
                                 socket.write(JSON.stringify({ version: 1, conversationEvent: event }) + '\n');
                         }) };
                 }
+                case 'submit_voice_prompt':
                 case 'submit_prompt_v2': {
+                    if (request.command === 'submit_voice_prompt' && !request.expectedSessionGeneration?.trim())
+                        throw new SessionControlError('rejected', 'expectedSessionGeneration is required');
                     this.requireConversation(request);
                     if (!request.commandId?.trim() || !request.text?.trim() || !request.actor?.trim()
                         || request.source !== 'owner_admin_console')
@@ -432,6 +465,7 @@ export class RoleControlServer {
                         const receipt = await this.session.submitPromptBrowser({
                             commandId: request.commandId, text: request.text,
                             source: 'owner_admin_console', actorBrowserSession: request.actor,
+                            expectedSessionGeneration: request.expectedSessionGeneration,
                         });
                         this.write(socket, { version: 1, id: request.id, ok: true, result: receipt });
                     }

package/dist/session/conversation-normalizer.d.ts

@@ -1,5 +1,5 @@
 import type * as acp from '@agentclientprotocol/sdk';
-import type { AdapterMeta, ConversationEventKind, ConversationPayload } from './conversation-types.js';
+import type { AdapterMeta, BoundedJson, ConversationEventKind, ConversationPayload } from './conversation-types.js';
 /**
  * Reduce one ACP v1 `session/update` into one conversation-domain event draft.
  *
@@ -43,4 +43,5 @@ export interface NormalizedUpdate {
     toolCallId?: string;
     adapterMeta?: AdapterMeta[];
 }
+export declare function boundedJson(value: unknown): BoundedJson;
 export declare function normalizeSessionUpdate(update: acp.SessionUpdate, options?: NormalizeOptions): NormalizedUpdate;

package/dist/session/conversation-normalizer.js

@@ -246,7 +246,7 @@ function redactSensitiveJson(value) {
     };
     return { value: visit(value, 0), redacted };
 }
-function boundedJson(value) {
+export function boundedJson(value) {
     let serialized;
     let safe;
     let redacted = false;

package/dist/session/conversation-types.d.ts

@@ -1,3 +1,4 @@
+import type { TaskCreatedNotice } from './task-notice.js';
 import type { PromptOrigin, TurnCancellationSource, TurnOutcome } from './types.js';
 /**
  * Durable conversation domain schema for managed-session consoles.
@@ -7,11 +8,11 @@ import type { PromptOrigin, TurnCancellationSource, TurnOutcome } from './types.
  * file touches the wire: transport updates are reduced into these shapes by a
  * session adapter, and the store assigns `seq`/`eventId`/timestamps.
  */
-export type ConversationEventKind = 'prompt.admitted' | 'prompt.started' | 'prompt.interrupt_requested' | 'message.chunk' | 'message.replace' | 'thought.chunk' | 'thought.replace' | 'plan.replace' | 'tool.upsert' | 'tool.content_chunk' | 'permission.requested' | 'permission.resolved' | 'monitor.delivery' | 'usage.updated' | 'turn.state' | 'turn.completed' | 'session.state' | 'session.info' | 'capabilities.updated' | 'error'
+export type ConversationEventKind = 'prompt.admitted' | 'prompt.started' | 'prompt.interrupt_requested' | 'message.chunk' | 'message.replace' | 'thought.chunk' | 'thought.replace' | 'plan.replace' | 'tool.upsert' | 'tool.content_chunk' | 'permission.requested' | 'permission.resolved' | 'fleet.task_created' | 'monitor.delivery' | 'usage.updated' | 'turn.state' | 'turn.completed' | 'session.state' | 'session.info' | 'capabilities.updated' | 'error'
 /** A well-formed transport update this version cannot represent. Bounded, never a crash. */
  | 'unsupported';
 /** Where a conversation record came from. Typed provenance, never prompt text. */
-export type ConversationSource = 'owner_admin_console' | 'owner_channel' | 'fleet_monitor' | 'scheduled_loop' | 'startup' | 'local_console' | 'agent' | 'agent_replay';
+export type ConversationSource = 'owner_admin_console' | 'owner_channel' | 'fleet_monitor' | 'scheduled_loop' | 'startup' | 'local_console' | 'agent' | 'agent_replay' | 'fleet_lifecycle';
 export interface NormalizedText {
     type: 'text';
     text: string;
@@ -227,7 +228,7 @@ export interface BoundedJson {
     digest?: string;
     redacted?: true;
 }
-export type ConversationPayload = MessageChunkPayload | ThoughtChunkPayload | PlanReplacePayload | ToolUpsertPayload | UsageUpdatedPayload | SessionStatePayload | SessionInfoPayload | CapabilitiesUpdatedPayload | UnsupportedPayload | PromptAdmittedPayload | PromptStartedPayload | PromptInterruptRequestedPayload | PermissionRequestedPayload | PermissionResolvedPayload | TurnStatePayload | TurnCompletedPayload | MonitorDeliveryPayload | SessionLifecyclePayload | ErrorPayload;
+export type ConversationPayload = MessageChunkPayload | ThoughtChunkPayload | PlanReplacePayload | ToolUpsertPayload | UsageUpdatedPayload | SessionStatePayload | SessionInfoPayload | CapabilitiesUpdatedPayload | UnsupportedPayload | PromptAdmittedPayload | PromptStartedPayload | PromptInterruptRequestedPayload | PermissionRequestedPayload | PermissionResolvedPayload | TurnStatePayload | TurnCompletedPayload | MonitorDeliveryPayload | SessionLifecyclePayload | ErrorPayload | TaskCreatedNotice;
 export interface ConversationEventV1 {
     schemaVersion: 1;
     roleId: string;
@@ -262,6 +263,7 @@ export interface ConversationEventV1 {
     adapterMeta?: AdapterMeta[];
 }
 export interface SubmitPromptCommand {
+    expectedSessionGeneration?: string;
     /** Idempotency-Key / clientRequestId. Reuse with a different body is a conflict. */
     commandId: string;
     text: string;

package/dist/session/task-notice.d.ts

@@ -0,0 +1,14 @@
+import type { ConversationEventStore } from './conversation-store.js';
+export interface TaskNoticeBinding {
+    sessionGeneration: string;
+    acpSessionId: string;
+    promptId: string;
+}
+export interface TaskCreatedNotice {
+    operationId: string;
+    taskId: string;
+    title: string;
+    state: string;
+}
+/** Only the trusted Fleet audit completion calls this, never model output. */
+export declare function appendTaskCreated(store: ConversationEventStore, binding: TaskNoticeBinding, notice: TaskCreatedNotice): void;

package/dist/session/task-notice.js

@@ -0,0 +1,13 @@
+/** Only the trusted Fleet audit completion calls this, never model output. */
+export function appendTaskCreated(store, binding, notice) {
+    let after;
+    do {
+        const page = store.page({ after, limit: 1000 });
+        if (page.events.some(e => e.kind === 'fleet.task_created' && e.payload.operationId === notice.operationId))
+            return;
+        if (!page.hasMore)
+            break;
+        after = page.nextCursor;
+    } while (after);
+    store.append({ kind: 'fleet.task_created', source: 'fleet_lifecycle', ...binding, turnId: binding.promptId, payload: notice });
+}

package/dist/session/types.d.ts

@@ -1,3 +1,4 @@
+import type { TaskCreatedNotice, TaskNoticeBinding } from './task-notice.js';
 import type { SessionBackendId } from '../config.js';
 import type { ConversationEventV1, ConversationSnapshot, PromptReceipt, SubmitPromptCommand } from './conversation-types.js';
 /**
@@ -289,6 +290,8 @@ export interface AgentSession {
     readonly capabilities?: AgentSessionCapabilities;
     isAlive(): boolean;
     snapshot(): SessionSnapshot;
+    taskNoticeBinding?(): TaskNoticeBinding | undefined;
+    recordTaskCreated?(binding: TaskNoticeBinding, notice: TaskCreatedNotice): void;
     conversationPage?(request: {
         after?: string;
         limit?: number;

package/dist/socket-path.d.ts

@@ -0,0 +1,2 @@
+/** Optional private socket directory for deeply nested, isolated Fleet homes. */
+export declare function socketPath(logicalPath: string): string;

package/dist/socket-path.js

@@ -0,0 +1,22 @@
+import { createHash } from 'node:crypto';
+import { lstatSync, mkdirSync } from 'node:fs';
+import { isAbsolute, join, resolve } from 'node:path';
+/** Optional private socket directory for deeply nested, isolated Fleet homes. */
+export function socketPath(logicalPath) {
+    const root = process.env.OURS_FLEET_SOCKET_ROOT;
+    if (!root) {
+        if (Buffer.byteLength(logicalPath) > 103)
+            throw new Error('Unix socket path is too long; configure a short private OURS_FLEET_SOCKET_ROOT');
+        return logicalPath;
+    }
+    if (!isAbsolute(root) || resolve(root) !== root)
+        throw new Error('OURS_FLEET_SOCKET_ROOT must be an absolute normalized path');
+    mkdirSync(root, { recursive: true, mode: 0o700 });
+    const stat = lstatSync(root);
+    if (!stat.isDirectory() || stat.isSymbolicLink() || stat.uid !== process.getuid?.() || (stat.mode & 0o777) !== 0o700)
+        throw new Error('OURS_FLEET_SOCKET_ROOT must be an owner-only 0700 directory');
+    const path = join(root, createHash('sha256').update(resolve(logicalPath)).digest('hex').slice(0, 24) + '.sock');
+    if (Buffer.byteLength(path) > 103)
+        throw new Error('OURS_FLEET_SOCKET_ROOT is too long');
+    return path;
+}

package/dist/spawn.js

@@ -1,3 +1,6 @@
+import { randomUUID } from 'node:crypto';
+import { storeRoomSecret, storeTemporaryLaunch, preparePermanentAssignment } from './agent-ours/service.js';
+import { ensureWorkspace } from './rooms-tasks/workspace.js';
 import { spawn as spawnChild } from 'node:child_process';
 import { closeSync, existsSync, lstatSync, mkdirSync, openSync, readFileSync, rmSync, writeFileSync } from 'node:fs';
 import { join } from 'node:path';
@@ -7,7 +10,7 @@ import { validateIsolationConfig } from './isolation/policy.js';
 import { loadConfig, findRole, splitRootFor, validateMonitorConfig, } from './config.js';
 import { applyRole, up } from './ops.js';
 import { START_STAGGER_FILE } from './runner.js';
-import { buildProvenance, daemonIdentityProvisioner, ensureIdentity, provenanceOf, withCreationTransaction, writeProvenance, writeRoleFile, } from './creation.js';
+import { buildProvenance, provenanceOf, withCreationTransaction, writeProvenance, writeRoleFile, } from './creation.js';
 import { VERSION } from './version.js';
 import { recordGeneratedAgentSource } from './generated-agent-source.js';
 import './harness/claude-code.js';
@@ -239,22 +242,12 @@ export async function spawnPermanent(o, deps, creation = {}) {
     return withCreationTransaction({ role: o.name, identity: effectiveIdentity(o) }, async (tx) => {
         assertNameFree(o);
         const cfg = loadConfig(o.configPath);
-        // Establish the identity BEFORE the service is enabled, and record
-        // what was actually guaranteed so the briefing can say something true.
+        // Pin an existing assignment without binding; the supervisor provisions
+        // a missing role identity before starting its harness.
         creation.onStage?.('checking_identity');
-        const guarantee = await ensureIdentity(effectiveIdentity(o), { bio: prepared.role.bio, persona: prepared.role.persona }, creation.identityProvisioner ?? deps.identityProvisioner ?? daemonIdentityProvisioner(), deps.log);
-        creation.onStage?.('checking_identity', {
-            result: guarantee.evidence, guarantee: guarantee.state,
-        });
-        if (guarantee.state === 'created')
-            // We minted it; a failed creation must not leave an orphan identity
-            // behind. Only ever removes an identity THIS transaction created.
-            tx.record({
-                stage: `ours identity ${effectiveIdentity(o)}`,
-                undo: async () => {
-                    await creation.identityProvisioner?.remove?.(effectiveIdentity(o));
-                },
-            });
+        const assignment = await preparePermanentAssignment(prepared.role);
+        const guarantee = { state: assignment, evidence: assignment === 'verified' ? 'verified' : 'missing' };
+        creation.onStage?.('checking_identity', { result: guarantee.evidence, guarantee: guarantee.state });
         const agentRoot = join(splitRootFor(o.configPath ?? defaultConfigPath()), 'agents');
         mkdirSync(agentRoot, { recursive: true });
         creation.onStage?.('writing_role');
@@ -329,6 +322,12 @@ export async function spawnTemp(o, binPath, launch = independentSupervisor, crea
     if (o.isolationFile)
         readIsolationFile(o.isolationFile); // fail before reserving
     const prepared = resolvedSpawn(o); // canonical validation before mutation
+    if (o.roomMemberStartup?.workspace) {
+        const workspace = o.roomMemberStartup.workspace;
+        if (prepared.role.cwd !== workspace.path)
+            throw new Error('room member cwd must equal its recorded owned workspace');
+        ensureWorkspace(workspace);
+    }
     // Retire only supervisors whose recorded owner is definitively stopped. This
     // bounded pass keeps the active roster clean without deleting old evidence.
     await reclaimStaleTempState();
@@ -354,6 +353,10 @@ async function spawnTempInner(o, preparedRole, binPath, launch, tx, onStage) {
         temporaryLoopSource: o.loopSource ?? (temporaryLoops?.length ? 'agent-template' : 'omitted'),
         roomMemberStartup: o.roomMemberStartup,
     };
+    storeTemporaryLaunch(role, o.creationActionId ?? randomUUID());
+    storeRoomSecret(role);
+    if (role.roomMemberStartup)
+        role.roomMemberStartup = { ...role.roomMemberStartup, invite: '' };
     onStage?.('writing_role');
     const dir = applyRole(role, { temp: true, identityGuarantee: 'unverified' });
     const provenance = buildProvenance({

package/dist/startup-readiness.d.ts

@@ -0,0 +1,13 @@
+import { type DaemonGenerationProbe } from './daemon-recovery.js';
+export declare const STARTUP_WAIT_MS = 240000;
+export declare const STARTUP_RETRY_MS = 5000;
+interface ReadinessDeps {
+    probe(env: NodeJS.ProcessEnv): Promise<DaemonGenerationProbe>;
+    now(): number;
+    sleep(ms: number): Promise<void>;
+    log(message: string): void;
+    env: NodeJS.ProcessEnv;
+}
+/** Read-only preflight: never binds identities, starts a harness or edits its ledger. */
+export declare function waitForRoleDaemon(name: string, configPath?: string, partial?: Partial<ReadinessDeps>): Promise<void>;
+export {};

package/dist/startup-readiness.js

@@ -0,0 +1,38 @@
+import { agentDir } from './paths.js';
+import { findRole, loadConfig } from './config.js';
+import { resolveConfigPath } from './runner.js';
+import { probeDaemonGeneration } from './daemon-recovery.js';
+export const STARTUP_WAIT_MS = 240_000;
+export const STARTUP_RETRY_MS = 5_000;
+/** Read-only preflight: never binds identities, starts a harness or edits its ledger. */
+export async function waitForRoleDaemon(name, configPath, partial = {}) {
+    const deps = {
+        probe: env => probeDaemonGeneration(((url, init) => globalThis.fetch(url, {
+            ...init, signal: AbortSignal.timeout(10_000),
+        })), env),
+        now: Date.now,
+        sleep: ms => new Promise(resolve => setTimeout(resolve, ms)),
+        log: message => process.stderr.write(message + '\n'),
+        env: process.env,
+        ...partial,
+    };
+    const path = resolveConfigPath(agentDir(name), configPath);
+    const role = findRole(loadConfig(path), name);
+    const env = { ...deps.env, ...role.env };
+    const deadline = deps.now() + STARTUP_WAIT_MS;
+    let lastReason = '';
+    while (deps.now() < deadline) {
+        const result = await deps.probe(env);
+        if (result.state === 'ready') {
+            deps.log(`[${name}] daemon ready; starting supervised agent`);
+            return;
+        }
+        // Only structured diagnostic codes, never endpoint responses or credentials.
+        const reason = /^[A-Z][A-Z0-9_]*$/.test(result.reason) ? result.reason : 'DAEMON_UNAVAILABLE';
+        if (reason !== lastReason)
+            deps.log(`[${name}] waiting for configured daemon: ${reason}`);
+        lastReason = reason;
+        await deps.sleep(Math.min(STARTUP_RETRY_MS, Math.max(0, deadline - deps.now())));
+    }
+    throw new Error(`Daemon not ready (${lastReason}); service manager will retry startup`);
+}

package/dist/supervisor/launchd.js

@@ -1,3 +1,4 @@
+import { clientConfigPath } from '../client-profile.js';
 import { existsSync, mkdirSync, writeFileSync, rmSync } from 'node:fs';
 import { join } from 'node:path';
 import { home, logsRoot } from '../paths.js';
@@ -22,7 +23,7 @@ const xml = (value) => value
     .replaceAll("'", ''');
 function plist(name, binPath) {
     const log = join(logsRoot(), `${name}.log`);
-    const config = process.env.OURS_CONFIG;
+    const config = clientConfigPath(process.env);
     return `<?xml version="1.0" encoding="UTF-8"?>
 <!DOCTYPE plist PUBLIC "-//Apple//DTD PLIST 1.0//EN" "http://www.apple.com/DTDs/PropertyList-1.0.dtd">
 <plist version="1.0">