@ours.network/fleet 1.2.0-nightly.10 → 1.2.0-nightly.12

package/README.md

@@ -1752,3 +1752,18 @@ or message delivery. File tools resolve paths in the invoking CLI process or
 Fleet web server's filesystem context, with that process's access permissions.
 
 Task workspace ownership, retention, safe deletion and legacy migration are documented in [Task workspaces](docs/task-workspaces.md).
+
+### Active task readiness after interruption
+
+Task and room list states, and `taskProvisioningOutcome`, describe durable lifecycle
+and provisioning progress; they are not live health checks. Retrying `task start`
+or `task work` on an active task checks the current Cowork room identity and seats,
+member launch ownership, supervisor liveness, and authenticated session status
+before reporting success. Waiting for provisioning completion also checks live
+readiness. This is a point-in-time observation, not proof of an agent-authored reply.
+
+A `task_not_ready` result distinguishes confirmed degradation from unknown health
+(for example, an unavailable control socket). Ask Fleet Coordinator to inspect room
+and member status and choose supported recovery. These checks do not restart agents,
+recreate identities, redeem invites, or rewrite lifecycle state. Temporary room agents
+remain transient across host reboot; retained launch records do not restore them.

package/dist/application/task-room-service.d.ts

@@ -1,3 +1,4 @@
+import { type LiveReadinessDeps } from '../rooms-tasks/live-readiness.js';
 import { type FleetConfig } from '../config.js';
 import { type CoworkAdapter } from '../rooms-tasks/cowork-adapter.js';
 import { provisionMembers } from '../rooms-tasks/provision.js';
@@ -57,9 +58,9 @@ export interface TaskProvisioningOutcome {
 /** Repairable terminal observation derived entirely from durable Task/Room state. */
 export declare function recordTaskProvisioningOutcome(outcome: TaskProvisioningOutcome): void;
 export declare class TaskRoomApplicationError extends Error {
-    readonly code: 'template_not_found' | 'task_template_drift' | 'template_mismatch' | 'task_terminal' | 'task_terminal_already' | 'task_non_resumable' | 'task_deleting' | 'room_not_found' | 'room_record_not_found';
+    readonly code: 'template_not_found' | 'task_template_drift' | 'template_mismatch' | 'task_terminal' | 'task_terminal_already' | 'task_non_resumable' | 'task_deleting' | 'room_not_found' | 'room_record_not_found' | 'task_not_ready';
     readonly fields: Readonly<Record<string, string>>;
-    constructor(code: 'template_not_found' | 'task_template_drift' | 'template_mismatch' | 'task_terminal' | 'task_terminal_already' | 'task_non_resumable' | 'task_deleting' | 'room_not_found' | 'room_record_not_found', message: string, fields?: Readonly<Record<string, string>>);
+    constructor(code: 'template_not_found' | 'task_template_drift' | 'template_mismatch' | 'task_terminal' | 'task_terminal_already' | 'task_non_resumable' | 'task_deleting' | 'room_not_found' | 'room_record_not_found' | 'task_not_ready', message: string, fields?: Readonly<Record<string, string>>);
 }
 export interface CreateTaskRequest {
     actor: TaskRoomActor;
@@ -87,6 +88,7 @@ export interface CreateRoomRequest {
 }
 export declare function resolveRoomLaunchPolicy(template: TemplateSnapshot | undefined, override: boolean | undefined): RoomLaunchPolicy;
 export interface TaskRoomServiceDeps {
+    liveReadiness?: LiveReadinessDeps;
     loadConfiguration?(path?: string): FleetConfig;
     cowork?(config: FleetConfig): CoworkAdapter;
     binPath?(): string;
@@ -151,6 +153,7 @@ export declare class TaskRoomApplicationService {
         task: TaskRecord;
         orchestration: RoomOrchestrationRecord | undefined;
     };
+    /** Durable provisioning progress only; use active task start/work for a live readiness check. */
     taskProvisioningOutcome(taskId: string): TaskProvisioningOutcome;
     awaitTaskProvisioning(input: {
         actor: TaskRoomActor;
@@ -300,6 +303,7 @@ export declare class TaskRoomApplicationService {
         taskId: string;
         outcome?: TaskOutcome;
     }): Promise<TaskSettlementPlan>;
+    private assertTaskLiveReadiness;
     ensureTaskWork(input: {
         actor: TaskRoomActor;
         taskId: string;

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

@@ -1,4 +1,5 @@
 import { readFileSync } from 'node:fs';
+import { taskLiveReadiness } from '../rooms-tasks/live-readiness.js';
 import { ConfigError, loadConfig } from '../config.js';
 import { CoworkProtocolError, CoworkUnavailableError, createCoworkAdapter, } from '../rooms-tasks/cowork-adapter.js';
 import { getBinPath, provisionMembers } from '../rooms-tasks/provision.js';
@@ -223,6 +224,7 @@ export class TaskRoomApplicationService {
         const task = readTask(taskId);
         return { task, orchestration: task.room_id ? getRoomRecord(task.room_id) : undefined };
     }
+    /** Durable provisioning progress only; use active task start/work for a live readiness check. */
     taskProvisioningOutcome(taskId) {
         const task = readTask(taskId);
         const room = task.room_id ? getRoomRecord(task.room_id) : undefined;
@@ -271,6 +273,10 @@ export class TaskRoomApplicationService {
         const deadline = now() + (input.waitMs ?? 60_000);
         for (;;) {
             const outcome = this.taskProvisioningOutcome(input.taskId);
+            if (outcome.kind === 'ready') {
+                const cfg = (this.deps.loadConfiguration ?? loadConfig)(this.configurationPath);
+                await this.assertTaskLiveReadiness(outcome.task, outcome.room, cfg);
+            }
             if (outcome.kind !== 'in_progress' || now() >= deadline) {
                 recordTaskProvisioningOutcome(outcome);
                 return outcome;
@@ -657,6 +663,14 @@ export class TaskRoomApplicationService {
             (this.deps.loadConfiguration ?? loadConfig)(this.configurationPath);
         return this.acceptTerminal(task.task_id, 'done', task.room_id, input.outcome);
     }
+    async assertTaskLiveReadiness(task, room, cfg) {
+        const cowork = this.deps.cowork ? this.deps.cowork(cfg)
+            : createCoworkAdapter({ configPath: cfg.rooms?.cowork?.config });
+        const issue = await taskLiveReadiness(task, room, cowork, this.deps.liveReadiness);
+        if (issue)
+            throw new TaskRoomApplicationError('task_not_ready', `Task readiness is ${issue.state}: ${issue.reason}. Ask Fleet Coordinator to inspect the room and member status and choose supported recovery; do not blindly relaunch or reuse invites.`, { task: task.task_id, room: task.room_id ?? 'missing', readiness: issue.state,
+                reason: issue.reason, ...(issue.member ? { member: issue.member } : {}) });
+    }
     async ensureTaskWork(input) {
         const cfg = (this.deps.loadConfiguration ?? loadConfig)(this.configurationPath);
         let task = readTask(input.taskId);
@@ -681,8 +695,10 @@ export class TaskRoomApplicationService {
                 const pinned = durableTemplate;
                 if (!pinned)
                     throw new TaskRoomApplicationError('template_mismatch', 'active task has no durable execution plan', { room: task.room_id });
-                if (durableRequestMatches)
+                if (durableRequestMatches) {
+                    await this.assertTaskLiveReadiness(task, recordedRoom, cfg);
                     return { task, status: 'already_active' };
+                }
                 const templateName = input.template ?? pinned.name;
                 const definition = resolveTemplate(templateName, cfg.roomTemplates ?? {});
                 if (!definition)
@@ -695,6 +711,7 @@ export class TaskRoomApplicationService {
                         provisioned: `${pinned.name}@${pinned.version}`
                     });
             }
+            await this.assertTaskLiveReadiness(task, recordedRoom, cfg);
             return { task, status: 'already_active' };
         }
         let room = task.room_id ? getRoomRecord(task.room_id) : undefined;
@@ -833,7 +850,11 @@ export class TaskRoomApplicationService {
             }
         }
         const resultingRoom = getRoomRecord(task.room_id);
-        return { task, status: task.state === 'active' && resultingRoom?.state === 'active' ? 'ready' : 'in_progress' };
+        if (task.state === 'active' && resultingRoom?.state === 'active') {
+            await this.assertTaskLiveReadiness(task, resultingRoom, cfg);
+            return { task, status: 'ready' };
+        }
+        return { task, status: 'in_progress' };
     }
     createTemplate(cfg, requested, noRoom) {
         if (noRoom)

package/dist/build-info.json

@@ -1,9 +1,9 @@
 {
-  "version": "1.2.0-nightly.10",
-  "buildId": "cb4ba2817213",
-  "commit": "cb2c392932a631dcb0a073bef469e50d7114d93e",
+  "version": "1.2.0-nightly.12",
+  "buildId": "6f07096c9a0c",
+  "commit": "7e323845714c5b638db197673b84f28fe00a2f75",
   "dirty": true,
-  "builtAt": "2026-09-24T09:16:57.652Z",
+  "builtAt": "2026-09-24T13:14:00.219Z",
   "capabilities": [
     "cowork.http-management-v1",
     "monitor.interrupt.after_tool"

package/dist/owner-channel/channel.js

@@ -883,8 +883,15 @@ export class OwnerChannel {
         const recovered = [];
         for (const claim of this.messageRecovery.list()) {
             const item = await this.client.getHistoryItem(claim.wireId);
-            if (!item)
-                throw new Error(`journaled owner message ${claim.wireId} is missing from persistent history`);
+            if (!item) {
+                // The daemon has definitively lost this body. Retrying the claim would
+                // block every later owner message, including after a supervisor restart.
+                // Keep transient lookup errors retryable; only an explicit absence skips.
+                this.messageRecovery.pruneHandled(wireId => wireId === claim.wireId);
+                this.options.log(`[${this.options.role}] skipped journaled owner message ${claim.wireId} `
+                    + `(seq=${claim.seq}): missing from persistent history`);
+                continue;
+            }
             recovered.push(this.historyMessage(item, claim));
         }
         const listed = await this.client.listIncomingMessages();

package/dist/owner-channel/commands.js

@@ -47,6 +47,11 @@ function isKnownOwnerRoomState(message) {
     ].some(pattern => pattern.test(message));
 }
 function ownerTaskFailure(error) {
+    if (error instanceof TaskRoomApplicationError && error.code === 'task_not_ready')
+        return {
+            kind: 'state', detail: error.message,
+            action: 'Ask Fleet Coordinator to inspect room and member status and choose supported recovery.',
+        };
     if (error instanceof TaskListError)
         return {
             kind: error.code === 'list_not_found' ? 'not_found'

package/dist/rooms-tasks/cli.js

@@ -75,6 +75,11 @@ async function presentDetachedProvisioningOutcome(outcome) {
 function taskRoomPublicFailure(error) {
     const f = error.fields;
     switch (error.code) {
+        case 'task_not_ready': return {
+            legacy: `task readiness ${f.readiness}: ${f.reason}`, kind: 'state',
+            detail: `Task ${f.task} readiness is ${f.readiness}: ${f.reason}${f.member ? ` (${f.member})` : ''}.`,
+            action: 'Ask Fleet Coordinator to inspect room and member status and choose supported recovery. Do not blindly relaunch agents or reuse invites.',
+        };
         case 'task_confirmation_mismatch': return {
             legacy: 'confirmation ID must match task ID', kind: 'usage',
             detail: 'The two task IDs must match.', action: 'Repeat the same task ID twice.',

package/dist/rooms-tasks/live-readiness.d.ts

@@ -0,0 +1,18 @@
+import { readRoomReadiness } from '../agent-ours/service.js';
+import { controlRequest } from '../session/control.js';
+import { readTempSupervisor, tempSupervisorLiveness } from '../temp-lifecycle.js';
+import type { CoworkAdapter } from './cowork-adapter.js';
+import type { RoomOrchestrationRecord, TaskRecord } from './types.js';
+export type TaskReadinessIssue = {
+    state: 'degraded' | 'unknown';
+    reason: string;
+    member?: string;
+};
+export interface LiveReadinessDeps {
+    supervisor?: typeof readTempSupervisor;
+    liveness?: typeof tempSupervisorLiveness;
+    readiness?: typeof readRoomReadiness;
+    control?: typeof controlRequest;
+}
+/** Read-only observation. A failed probe never grants authority to replace a seat. */
+export declare function taskLiveReadiness(task: TaskRecord, room: RoomOrchestrationRecord | undefined, cowork: Pick<CoworkAdapter, 'getRoom'>, deps?: LiveReadinessDeps): Promise<TaskReadinessIssue | undefined>;

package/dist/rooms-tasks/live-readiness.js

@@ -0,0 +1,75 @@
+import { realExec } from '../exec.js';
+import { agentDir } from '../paths.js';
+import { readRoomReadiness } from '../agent-ours/service.js';
+import { controlRequest } from '../session/control.js';
+import { readTempSupervisor, tempSupervisorLiveness } from '../temp-lifecycle.js';
+/** Read-only observation. A failed probe never grants authority to replace a seat. */
+export async function taskLiveReadiness(task, room, cowork, deps = {}) {
+    const degraded = (reason, member) => ({ state: 'degraded', reason, member });
+    const unknown = (reason, member) => ({ state: 'unknown', reason, member });
+    if (!room || task.state !== 'active' || task.room_id !== room.room_id || room.state !== 'active' || room.close || task.terminal_intent
+        || room.task_id !== task.task_id || !room.room_identity_cid
+        || task.room_identity_cid !== room.room_identity_cid)
+        return degraded('room_record_mismatch');
+    const expected = room.template_snapshot?.members.reduce((n, member) => n + member.count, 0);
+    if (expected === undefined || room.member_seats.length !== expected
+        || new Set(room.member_seats.map(seat => seat.role_name)).size !== expected)
+        return degraded('member_roster_mismatch');
+    let remote;
+    try {
+        remote = await cowork.getRoom(room.room_id);
+    }
+    catch {
+        return unknown('room_probe_unavailable');
+    }
+    if (!remote || remote.room_id !== room.room_id || remote.identity_cid !== room.room_identity_cid
+        || remote.state !== 'active')
+        return degraded('room_identity_or_state_mismatch');
+    if (room.owner_seat_cid && !remote.seats.some(seat => seat.identity_cid === room.owner_seat_cid && seat.seat_state === 'active'))
+        return degraded('owner_seat_missing');
+    for (const seat of room.member_seats) {
+        const member = seat.role_name;
+        if (seat.seat_state !== 'active' || !seat.identity_cid || !seat.invite_id
+            || seat.launch?.state !== 'launched' || !seat.launch.launch_id || seat.retirement)
+            return degraded('member_record_incomplete', member);
+        const matches = remote.seats.filter(item => item.display_name === member && item.seat_state !== 'removed');
+        if (matches.length !== 1 || matches[0].identity_cid !== seat.identity_cid
+            || matches[0].invite_id !== seat.invite_id || matches[0].role !== seat.cowork_role
+            || matches[0].seat_state !== 'active')
+            return degraded('member_seat_mismatch', member);
+        const dir = agentDir(member, true);
+        try {
+            const supervisor = (deps.supervisor ?? readTempSupervisor)(dir);
+            if (!supervisor)
+                return unknown('supervisor_record_missing', member);
+            if (supervisor.role !== member || supervisor.launchId !== seat.launch.launch_id)
+                return degraded('supervisor_launch_mismatch', member);
+            const live = await (deps.liveness ?? tempSupervisorLiveness)(dir, {
+                exec: (cmd, args, opts) => realExec(cmd, args, { ...opts, timeout: 2_000 }),
+            });
+            if (live === 'stopped')
+                return degraded('supervisor_stopped', member);
+            if (live !== 'running')
+                return unknown('supervisor_liveness_unknown', member);
+            const ready = (deps.readiness ?? readRoomReadiness)(room.room_identity_cid, member);
+            if (!ready || ready.room !== room.room_id || ready.invite !== seat.invite_id || ready.cid !== seat.identity_cid)
+                return degraded('member_readiness_mismatch', member);
+        }
+        catch {
+            return unknown('supervisor_probe_unavailable', member);
+        }
+        try {
+            const response = await (deps.control ?? controlRequest)(dir, { command: 'status' }, 2_000);
+            if (!response.ok)
+                return unknown('control_unavailable', member);
+            const status = response.result;
+            if (status?.alive === false || status?.readiness === 'failed')
+                return degraded('agent_not_ready', member);
+            if (status?.alive !== true || !['idle', 'running', 'awaiting_permission'].includes(status.readiness ?? ''))
+                return unknown('agent_readiness_unknown', member);
+        }
+        catch {
+            return unknown('control_unavailable', member);
+        }
+    }
+}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@ours.network/fleet",
-  "version": "1.2.0-nightly.10",
+  "version": "1.2.0-nightly.12",
   "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",