@ours.network/fleet 1.1.0-nightly.22 → 1.1.0-nightly.24

package/dist/application/task-room-service.js

@@ -16,6 +16,7 @@ import { acceptTaskDeletion, recordTaskDeletionError, settleTaskDeletion, } from
 import { withFileLock } from '../atomic-file.js';
 import { launchFleetWorker } from '../rooms-tasks/external-worker.js';
 import { storedRoomLaunchPolicy, TASK_CANCELLABLE_STATES, TASK_TERMINAL_STATES } from '../rooms-tasks/types.js';
+import { deriveTaskRoomName } from '../rooms-tasks/task-room-name.js';
 export class TaskRoomApplicationError extends Error {
     code;
     fields;
@@ -399,8 +400,28 @@ export class TaskRoomApplicationService {
             return {
                 kind: TASK_TERMINAL_STATES.includes(task.state) ? 'terminal' : 'no_op', task, room, issues,
             };
-        if (!room)
-            return { kind: 'provisioning_non_resumable', task, room, issues, reason: 'missing_room' };
+        if (!room) {
+            if (!task.template)
+                return {
+                    kind: 'provisioning_non_resumable', task, room, issues, reason: 'missing_room',
+                };
+            try {
+                const template = task.execution_plan?.snapshot ?? this.existingTemplate(cfg, task);
+                const roomPolicy = task.execution_plan
+                    ? storedRoomLaunchPolicy(task.execution_plan.room_policy)
+                    : resolveRoomLaunchPolicy(template, undefined);
+                await this.provisionRoom(cfg, task, template, created => {
+                    task = updateTaskRoom(task.task_id, created.room_id, created.room_identity_cid);
+                }, undefined, roomPolicy);
+                task = readTask(task.task_id);
+                room = task.room_id ? getRoomRecord(task.room_id) : undefined;
+                return { kind: 'provisioning_resumed', task, room, issues: [{ code: 'provisioning_resumed' }] };
+            }
+            catch (error) {
+                issues.push({ code: 'resume_failed', error: error instanceof Error ? error.message : String(error) });
+                return { kind: 'provisioning_resume_failed', task, room, issues };
+            }
+        }
         if (room.provisioning_detail === 'waiting_cowork')
             issues.push({ code: 'waiting_cowork' });
         if (room.provisioning_detail === 'waiting_owner_invite')
@@ -829,6 +850,7 @@ export class TaskRoomApplicationService {
                 throw new ConfigError('rooms: configuration is required before creating or querying rooms');
             return createCoworkAdapter({ configPath: cfg.rooms.cowork?.config });
         })();
+        const roomName = task.task_id ? deriveTaskRoomName(task.title, task.task_id) : task.title;
         const unlockSnapshot = template ? acquireLaunchSnapshotLock() : undefined;
         let launchTemplate;
         let room;
@@ -847,13 +869,13 @@ export class TaskRoomApplicationService {
                         throw new TaskRoomApplicationError('task_deleting', `task ${task.task_id} is pending deletion`, { task: task.task_id });
                 }
                 const created = await cowork.createRoom({
-                    room_name: task.title, goal: task.goal?.trim() || task.title,
+                    room_name: roomName, goal: task.goal?.trim() || task.title,
                     briefing: task.brief?.trim() || launchTemplate?.contract?.trim() || task.goal?.trim() || task.title,
                     quiet_membership: launchTemplate?.room?.quiet_membership,
                     anonymous: policy.anonymous,
                 });
                 const record = createRoomRecord({
-                    room_id: created.room_id, room_name: task.title, room_identity_cid: created.identity_cid,
+                    room_id: created.room_id, room_name: roomName, room_identity_cid: created.identity_cid,
                     task_id: task.task_id, template_snapshot: launchTemplate, room_policy: policy,
                 });
                 onCreated(record);

package/dist/build-info.json

@@ -1,9 +1,9 @@
 {
-  "version": "1.1.0-nightly.22",
-  "buildId": "bfb51e6ced00",
-  "commit": "5447c29d81481c7880fa9cf5bfbbcc2ff294950f",
+  "version": "1.1.0-nightly.24",
+  "buildId": "30fec1b573b6",
+  "commit": "93f6e23dd6eb3642ee12bc01cba53a2aba838ab1",
   "dirty": true,
-  "builtAt": "2026-09-01T19:41:56.761Z",
+  "builtAt": "2026-09-02T11:45:37.603Z",
   "capabilities": [
     "monitor.interrupt.after_tool"
   ]

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

@@ -225,6 +225,8 @@ export declare class OwnerChannel implements OwnerChannelHandle {
         resourceIds?: Record<string, string>;
         presentations?: FleetAuditPresentation[];
     }): Promise<FleetAuditAttempt>;
+    private flushPendingFleetCommandAudits;
+    private deliverFleetCommandOutcome;
     recover(epoch: string): Promise<void>;
     private recoveryStage;
     private writeShutdownState;

package/dist/owner-channel/channel.js

@@ -199,6 +199,7 @@ export class OwnerChannel {
         }
         this.startedOnce = true;
         this.ready = true;
+        await this.flushPendingFleetCommandAudits();
         // Do not make role startup wait for an old owner request to finish a turn.
         // watchLoop itself drains before every establishment, including this first
         // one, so there is no drain-to-tip race.
@@ -301,33 +302,50 @@ export class OwnerChannel {
                 return attempt;
             if (attempt.outcome?.delivery === 'uncertain')
                 return attempt;
-            let uncertain = false;
-            try {
-                for (const event of attempt.outcome?.presentations ?? []) {
-                    try {
-                        await this.sendProactiveMessage(renderFleetLifecycleEvent(event), `fleet-lifecycle\0${lifecycleEventDigestBasis(event)}`, 0);
-                    }
-                    catch (error) {
-                        if (error instanceof DuplicateSendError) {
-                            if (error.status !== 'delivered')
-                                uncertain = true;
-                            this.options.log(`[${this.options.role}] duplicate Fleet lifecycle event suppressed`);
-                            continue;
-                        }
-                        throw error;
-                    }
-                }
-            }
-            catch (error) {
-                uncertain = true;
-                this.logError(`fleet lifecycle delivery uncertain correlation=${attempt.correlationId}`, error);
-            }
-            attempt = this.commandAudits.outcome(attempt.correlationId, this.options.role, uncertain ? 'uncertain' : 'delivered');
-            return attempt;
+            // Before the Owner sink is attached, ordinary commands have nothing to
+            // deliver. Lifecycle presentations remain in the never-attempted
+            // `sending` state and are flushed exactly once when start() makes the
+            // authenticated sink ready. A restart converts them to `uncertain`, so
+            // effects are never replayed after an unproven delivery boundary.
+            if (!attempt.outcome?.presentations?.length)
+                return this.commandAudits.outcome(attempt.correlationId, this.options.role, 'delivered');
+            if (!this.ready)
+                return attempt;
+            return this.deliverFleetCommandOutcome(attempt);
         });
         this.managementTail = run.then(() => undefined, () => undefined);
         return run;
     }
+    async flushPendingFleetCommandAudits() {
+        for (const attempt of this.commandAudits.list())
+            if (attempt.outcome?.delivery === 'sending')
+                await this.deliverFleetCommandOutcome(attempt);
+    }
+    async deliverFleetCommandOutcome(attempt) {
+        let uncertain = false;
+        try {
+            for (const event of attempt.outcome?.presentations ?? []) {
+                try {
+                    await this.sendProactiveMessage(renderFleetLifecycleEvent(event), `fleet-lifecycle\0${lifecycleEventDigestBasis(event)}`, 0);
+                }
+                catch (error) {
+                    if (error instanceof DuplicateSendError) {
+                        if (error.status !== 'delivered')
+                            uncertain = true;
+                        this.options.log(`[${this.options.role}] duplicate Fleet lifecycle event suppressed`);
+                        continue;
+                    }
+                    throw error;
+                }
+            }
+        }
+        catch (error) {
+            uncertain = true;
+            this.logError(`fleet lifecycle delivery uncertain correlation=${attempt.correlationId}`, error);
+        }
+        attempt = this.commandAudits.outcome(attempt.correlationId, this.options.role, uncertain ? 'uncertain' : 'delivered');
+        return attempt;
+    }
     recover(epoch) {
         if (this.stopping)
             return Promise.reject(new Error('owner channel is stopping'));

package/dist/rooms-tasks/task-room-name.d.ts

@@ -0,0 +1,12 @@
+/**
+ * Cowork room identities are named `ours-cowork:<room name>` and both the
+ * room and identity contracts count NFC-normalized Unicode code points.
+ * Keeping the complete task ID inside that shared budget makes every derived
+ * name stable, directly correlated, and unique even when the title is empty,
+ * sanitized, or truncated.
+ */
+export declare const COWORK_ROOM_IDENTITY_PREFIX = "ours-cowork:";
+export declare const COWORK_IDENTITY_NAME_MAX_CODE_POINTS = 64;
+export declare const TASK_ROOM_NAME_MAX_CODE_POINTS: number;
+/** Canonical Cowork room name for a Fleet task; never mutates the task title. */
+export declare function deriveTaskRoomName(title: string, taskId: string): string;

package/dist/rooms-tasks/task-room-name.js

@@ -0,0 +1,61 @@
+/**
+ * Cowork room identities are named `ours-cowork:<room name>` and both the
+ * room and identity contracts count NFC-normalized Unicode code points.
+ * Keeping the complete task ID inside that shared budget makes every derived
+ * name stable, directly correlated, and unique even when the title is empty,
+ * sanitized, or truncated.
+ */
+export const COWORK_ROOM_IDENTITY_PREFIX = 'ours-cowork:';
+export const COWORK_IDENTITY_NAME_MAX_CODE_POINTS = 64;
+export const TASK_ROOM_NAME_MAX_CODE_POINTS = COWORK_IDENTITY_NAME_MAX_CODE_POINTS
+    - Array.from(COWORK_ROOM_IDENTITY_PREFIX).length;
+const TASK_ID_PATTERN = /^[0-9a-z]{9}[0-9a-f]{8}$/;
+const FORBIDDEN = /[\\/\p{Cc}\p{Cf}\p{Cs}\p{Zl}\p{Zp}]/u;
+const DASH_SEPARATOR = /\p{Pd}/u;
+const WHITESPACE = /\s/u;
+const FALLBACK_TITLE = 'Task';
+function sanitizeTitle(title) {
+    const normalized = title.normalize('NFC');
+    let result = '';
+    let pending;
+    for (const character of normalized) {
+        if (FORBIDDEN.test(character) || DASH_SEPARATOR.test(character)) {
+            pending = 'separator';
+        }
+        else if (WHITESPACE.test(character)) {
+            if (pending !== 'separator')
+                pending = 'space';
+        }
+        else {
+            if (result && pending)
+                result += pending === 'separator' ? ' - ' : ' ';
+            result += character;
+            pending = undefined;
+        }
+    }
+    return result;
+}
+/** Truncate to a code-point budget without cutting an extended grapheme. */
+function graphemeBound(value, maxCodePoints) {
+    const segmenter = new Intl.Segmenter('en', { granularity: 'grapheme' });
+    let result = '';
+    let length = 0;
+    for (const { segment } of segmenter.segment(value)) {
+        const segmentLength = Array.from(segment).length;
+        if (length + segmentLength > maxCodePoints)
+            break;
+        result += segment;
+        length += segmentLength;
+    }
+    return result.trimEnd();
+}
+/** Canonical Cowork room name for a Fleet task; never mutates the task title. */
+export function deriveTaskRoomName(title, taskId) {
+    if (!TASK_ID_PATTERN.test(taskId))
+        throw new Error(`invalid canonical task ID: ${taskId}`);
+    const suffix = ` [${taskId}]`;
+    const titleBudget = TASK_ROOM_NAME_MAX_CODE_POINTS - Array.from(suffix).length;
+    const readable = sanitizeTitle(title);
+    const bounded = graphemeBound(readable || FALLBACK_TITLE, titleBudget) || FALLBACK_TITLE;
+    return `${bounded}${suffix}`;
+}

package/dist/runner.js

@@ -26,6 +26,7 @@ import { FLEET_PROXY_CALLER_ENV, FLEET_PROXY_STATE_DIR_ENV, } from './fleet-prox
 import { effectivePermissionMode } from './permissions.js';
 import { assertModelPinReachesChild, effectiveRoleModel, repinModelEnv } from './model-env.js';
 import { archiveTempState, markTempSupervisorActive, requestedTempStopReason, } from './temp-lifecycle.js';
+import { FleetCommandAuditStore } from './fleet-command-audit.js';
 export const SUPERVISOR_RECYCLE_REQUIRED = 'OWNER_CHANNEL_SUPERVISOR_RECYCLE_REQUIRED';
 export class SupervisorRecycleRequiredError extends Error {
     code = SUPERVISOR_RECYCLE_REQUIRED;
@@ -70,6 +71,31 @@ const defaultDeps = () => ({
 });
 const MONITOR_OWNER_FILE = '.monitor-owner';
 const OBSOLETE_OURS_AUTOSTART_ENV = 'OURS_AUTOSTART';
+function localFleetAuditor(stateDir, caller, log) {
+    const store = new FleetCommandAuditStore(join(stateDir, '.fleet-command-audit.json'));
+    return {
+        async begin(requestId, argv) {
+            let attempt = store.begin(requestId, caller, argv);
+            if (attempt.invocation === 'sending') {
+                log(`[${caller}] fleet proxy command ${attempt.correlationId} `
+                    + `route=${attempt.classification.route} decision=${attempt.classification.decision}`);
+                attempt = store.invocation(attempt.correlationId, caller, 'delivered');
+            }
+            return attempt;
+        },
+        async finish(input) {
+            let attempt = store.finish(input.correlationId, caller, {
+                class: input.class, effect: input.effect,
+                ...(input.exitCode === undefined ? {} : { exitCode: input.exitCode }),
+                ...(input.resourceIds ? { resourceIds: input.resourceIds } : {}),
+                ...(input.presentations ? { presentations: input.presentations } : {}),
+            });
+            if (attempt.outcome?.delivery === 'sending')
+                attempt = store.outcome(attempt.correlationId, caller, 'delivered');
+            return attempt;
+        },
+    };
+}
 /** Environment injected only into the managed harness process. */
 export function managedFleetProxyEnv(role, stateDir) {
     const roleEnv = { ...(role.env ?? {}) };
@@ -612,11 +638,28 @@ export async function runOnce(name, opts = {}, partialDeps = {}) {
                     + `${error?.message ?? String(error)}`);
             }
         }
-        control = deps.createControlServer(dir, arbiter, deps.log);
         try {
+            if (role.owner_channel)
+                ownerChannel = deps.createOwnerChannel({
+                    role: name,
+                    harness: role.harness,
+                    config: role.owner_channel,
+                    session: arbiter,
+                    stateDir: dir,
+                    env: role.env,
+                    log: deps.log,
+                    ...(ownerBinder ? { binderLease: ownerBinder } : {}),
+                    ...(configPath ? { configPath } : {}),
+                });
+            control = deps.createControlServer(dir, arbiter, deps.log);
+            control.setFleetAuditor(ownerChannel ? {
+                begin: (requestId, argv) => ownerChannel.beginFleetCommandAudit(requestId, argv),
+                finish: input => ownerChannel.finishFleetCommandAudit(input),
+            } : localFleetAuditor(dir, name, deps.log));
             await control.start();
         }
         catch (error) {
+            await ownerChannel?.close().catch(() => undefined);
             ownerBinder?.release();
             await agentSession.close();
             unsubscribeRecovery?.();
@@ -731,18 +774,7 @@ export async function runOnce(name, opts = {}, partialDeps = {}) {
             deps.log(`[${name}] ${sessionLabel} startup prompt cancelled by ${started.cancellationSource}; `
                 + 'keeping temporary supervisor alive');
         sessionStartupComplete = true;
-        if (role.owner_channel) {
-            ownerChannel = deps.createOwnerChannel({
-                role: name,
-                harness: role.harness,
-                config: role.owner_channel,
-                session: arbiter,
-                stateDir: dir,
-                env: role.env,
-                log: deps.log,
-                ...(ownerBinder ? { binderLease: ownerBinder } : {}),
-                ...(configPath ? { configPath } : {}),
-            });
+        if (ownerChannel) {
             try {
                 await ownerChannel.start();
             }
@@ -761,10 +793,6 @@ export async function runOnce(name, opts = {}, partialDeps = {}) {
         }
         if (ownerChannel) {
             control.setOwnerChannel(ownerChannel);
-            control.setFleetAuditor({
-                begin: (requestId, argv) => ownerChannel.beginFleetCommandAudit(requestId, argv),
-                finish: input => ownerChannel.finishFleetCommandAudit(input),
-            });
         }
         reloadLoopConfig = async () => {
             const nextRole = findRole(loadConfig(configPath), name);

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@ours.network/fleet",
-  "version": "1.1.0-nightly.22",
+  "version": "1.1.0-nightly.24",
   "description": "Harness-agnostic fleet of persistent, identity-bound AI agents. Declarative fleet.yaml, managed native/ACP sessions, supervision, and ours.network messaging.",
   "type": "module",
   "license": "FSL-1.1-Apache-2.0",