@ours.network/fleet 0.19.0-nightly.6 → 0.19.0-nightly.8

package/dist/build-info.json

@@ -1,9 +1,9 @@
 {
-  "version": "0.19.0-nightly.6",
-  "buildId": "1165e05339e3",
-  "commit": "188e186e43324119f08d38106f9bcd7606199e5c",
+  "version": "0.19.0-nightly.8",
+  "buildId": "d22ed5b7bff3",
+  "commit": "39cad43ae0d8f08341775953baeda7b77eb3ade4",
   "dirty": true,
-  "builtAt": "2026-08-23T18:53:56.442Z",
+  "builtAt": "2026-08-23T23:06:12.416Z",
   "capabilities": [
     "monitor.interrupt.after_tool"
   ]

package/dist/rooms-tasks/cli.js

@@ -2,9 +2,10 @@ import { readFileSync } from 'node:fs';
 import { loadConfig, ConfigError } from '../config.js';
 import { provisionMembers, cleanupMembers, getBinPath } from './provision.js';
 import { resolveTemplate, listTemplates, snapshotTemplate, hashTemplate, } from './templates.js';
-import { createTask, getTask, listTasks, startTask, activateTask, blockTask, unblockTask, reviewTask, completeTask, cancelTask, updateTaskRoom, } from './task-state.js';
+import { createTask, getTask, listTasks, startTask, activateTask, blockTask, unblockTask, reviewTask, completeTask, cancelTask, updateTaskRoom, updateTaskTemplate, } from './task-state.js';
 import { createRoomRecord, getRoomRecord, listRoomRecords, closeRoom as closeRoomRecord, advanceSaga, setOwnerSeat, setSagaError, activateRoom, } from './room-state.js';
 import { createCoworkAdapter, CoworkProtocolError, CoworkUnavailableError } from './cowork-adapter.js';
+import { TASK_TERMINAL_STATES } from './types.js';
 function die(e) {
     const msg = e instanceof Error ? e.message : String(e);
     process.stderr.write(`error: ${msg}\n`);
@@ -204,7 +205,7 @@ export function registerTaskCommands(parent, cOpt) {
                 templateRef = { name: snap.name, version: snap.version, content_hash: snap.content_hash };
             }
             else if (opts.room !== false) {
-                const defaultTpl = cfg.tasks?.default_room_template ?? cfg.rooms?.defaults?.template ?? 'briefing';
+                const defaultTpl = cfg.tasks?.default_room_template ?? cfg.rooms?.defaults?.template ?? 'team';
                 const t = resolveTemplate(defaultTpl, allTemplates(cfg));
                 if (t) {
                     const snap = snapshotTemplate(t);
@@ -534,6 +535,174 @@ export function registerTaskCommands(parent, cOpt) {
             die(e);
         }
     });
+    cOpt(taskCmd.command('work <id>'))
+        .description('ensure a task has a room and agents running')
+        .option('--template <name>', 'room template')
+        .option('--json', 'JSON output')
+        .action(async (id, opts) => {
+        try {
+            const cfg = loadCfg(opts);
+            let t = getTask(id);
+            if (TASK_TERMINAL_STATES.includes(t.state))
+                die(new Error(`task ${id} is in terminal state '${t.state}'`));
+            if (t.state === 'active' && t.room_id) {
+                // An explicit --template must agree with the room the task already
+                // runs in; a conflicting override is an error, not a silent no-op.
+                if (opts.template) {
+                    const override = resolveTemplate(opts.template, allTemplates(cfg));
+                    if (!override)
+                        die(new Error(`template not found: ${opts.template}`));
+                    const overrideSnap = snapshotTemplate(override);
+                    const roomSnap = getRoomRecord(t.room_id)?.template_snapshot ?? t.template;
+                    if (roomSnap && (roomSnap.name !== overrideSnap.name || roomSnap.content_hash !== overrideSnap.content_hash))
+                        die(new Error(`template ${overrideSnap.name}@${overrideSnap.version} does not match room ${t.room_id}'s provisioned template ${roomSnap.name}@${roomSnap.version}`));
+                }
+                if (opts.json) {
+                    console.log(JSON.stringify({ schema_version: 1, task: t, status: 'already_active' }, null, 2));
+                    return;
+                }
+                console.log('Task already has an active room');
+                return;
+            }
+            // Select and validate the template snapshot before any state change or
+            // provisioning. An explicit --template re-pins the task; a stored ref
+            // must still match its snapshot (same contract as `task start`).
+            const templateName = opts.template
+                ?? t.template?.name
+                ?? cfg.tasks?.default_room_template
+                ?? cfg.rooms?.defaults?.template
+                ?? 'single';
+            const resolved = resolveTemplate(templateName, allTemplates(cfg));
+            if (!resolved)
+                die(new Error(`template not found: ${templateName}`));
+            const snap = snapshotTemplate(resolved);
+            if (!opts.template && t.template && snap.content_hash !== t.template.content_hash)
+                die(new Error(`task template snapshot no longer matches ${t.template.name}@${t.template.version}`));
+            // A provisioned room is pinned to its snapshot: never resume or re-pin
+            // an existing room under a different template.
+            if (t.room_id) {
+                const roomSnap = getRoomRecord(t.room_id)?.template_snapshot ?? t.template;
+                if (roomSnap && (roomSnap.name !== snap.name || roomSnap.content_hash !== snap.content_hash))
+                    die(new Error(`template ${snap.name}@${snap.version} does not match room ${t.room_id}'s provisioned template ${roomSnap.name}@${roomSnap.version}`));
+            }
+            let templateRef = t.template;
+            if (!templateRef || templateRef.name !== snap.name || templateRef.content_hash !== snap.content_hash) {
+                templateRef = { name: snap.name, version: snap.version, content_hash: snap.content_hash };
+                t = updateTaskTemplate(t.task_id, templateRef);
+            }
+            if (t.state === 'backlog') {
+                t = startTask(id);
+            }
+            if (!t.room_id) {
+                try {
+                    await provisionRoom(cfg, {
+                        name: t.title,
+                        goal: t.title,
+                        brief: t.brief,
+                        template: snap,
+                        taskId: t.task_id,
+                        onCreated: room => {
+                            t = updateTaskRoom(t.task_id, room.room_id, room.room_identity_cid);
+                        },
+                    });
+                    t = getTask(t.task_id);
+                }
+                catch (error) {
+                    if (error instanceof CoworkUnavailableError) {
+                        blockTask(t.task_id, 'Cowork management socket is unavailable');
+                    }
+                    throw error;
+                }
+            }
+            else if (t.state === 'provisioning') {
+                // The task already has a room mid-provisioning (e.g. seats were still
+                // pending on the last run). Resume it exactly as `task recover` does.
+                const room = getRoomRecord(t.room_id);
+                const resumable = ['create_members', 'join_role_groups', 'wait_seats', 'launch_work', 'activate'];
+                if (room && resumable.includes(room.saga.phase)) {
+                    try {
+                        await provisionMembers({
+                            cfg,
+                            cowork: coworkFor(cfg),
+                            roomId: room.room_id,
+                            taskId: t.task_id,
+                            template: snap,
+                            binPath: getBinPath(),
+                            brief: t.brief,
+                            goal: t.title,
+                        });
+                    }
+                    catch (error) {
+                        if (error instanceof CoworkUnavailableError) {
+                            blockTask(t.task_id, 'Cowork management socket is unavailable');
+                        }
+                        throw error;
+                    }
+                    t = getTask(t.task_id);
+                }
+                else {
+                    die(new Error(`task ${id} has room ${t.room_id} in a non-resumable state — run 'task recover ${id}'`));
+                }
+            }
+            if (opts.json) {
+                console.log(JSON.stringify({ schema_version: 1, task: t }, null, 2));
+                return;
+            }
+            console.log(`Task ${t.task_id} · ${t.state}`);
+            if (templateRef)
+                console.log(`Template: ${templateRef.name}@${templateRef.version}`);
+            if (t.room_id)
+                console.log(`Room: ${t.room_id}`);
+            if (t.member_roles.length) {
+                console.log('Agents:');
+                for (const m of t.member_roles)
+                    console.log(`  ${m.name} (${m.cowork_role})`);
+            }
+        }
+        catch (e) {
+            die(e);
+        }
+    });
+    cOpt(taskCmd.command('finish <id>'))
+        .description('finish a task: transition to done and close its room')
+        .option('--summary <text>', 'completion summary')
+        .option('--summary-file <path>', 'completion summary from file')
+        .option('--json', 'JSON output')
+        .action(async (id, opts) => {
+        try {
+            let summary = opts.summary;
+            if (opts.summaryFile)
+                summary = readFileSync(opts.summaryFile, 'utf8');
+            const outcome = summary ? { summary } : undefined;
+            let t = getTask(id);
+            if (TASK_TERMINAL_STATES.includes(t.state))
+                die(new Error(`task ${id} is already in terminal state '${t.state}'`));
+            if (t.state === 'active') {
+                reviewTask(id);
+            }
+            t = completeTask(id, outcome);
+            if (t.room_id) {
+                const cfg = loadCfg(opts);
+                try {
+                    await cleanupMembers({
+                        roomId: t.room_id,
+                        taskId: id,
+                        closeCoworkRoom: true,
+                        cowork: coworkFor(cfg),
+                    });
+                }
+                catch { /* room cleanup is best-effort */ }
+            }
+            if (opts.json) {
+                console.log(JSON.stringify({ schema_version: 1, task: t }, null, 2));
+                return;
+            }
+            console.log(`Task ${t.task_id} · done`);
+        }
+        catch (e) {
+            die(e);
+        }
+    });
 }
 export function registerRoomCommands(parent, cOpt) {
     const roomCmd = parent.command('room').description('room orchestration operations');

package/dist/rooms-tasks/provision.js

@@ -96,71 +96,90 @@ export async function provisionMembers(input) {
     const plan = expandMembers(template, prefix);
     const createdIdentities = [];
     const members = [];
-    // Phase 4: create_members
-    advanceSaga(roomId, 'create_members', 3);
-    try {
+    // A room that already reached wait_seats keeps its member identities, seats
+    // and accepted invitations; recreating them on a retry would collide. Resume
+    // from the persisted seats and re-check seat activity instead.
+    const existing = getRoomRecord(roomId);
+    const persistedSeats = existing?.member_seats ?? [];
+    const resuming = existing !== undefined
+        && ['wait_seats', 'launch_work', 'activate'].includes(existing.saga.phase)
+        && plan.length > 0
+        && plan.every(p => persistedSeats.some(s => s.role_name === p.name));
+    let seats;
+    if (resuming) {
         for (const planned of plan) {
-            const bio = `Fleet task member: ${planned.coworkRole} for ${taskId ?? roomId}`;
-            const { cid } = await createMemberIdentity(planned.name, bio);
-            createdIdentities.push(planned.name);
-            members.push({ ...planned, cid });
+            const seat = persistedSeats.find(s => s.role_name === planned.name);
+            members.push({ ...planned, cid: seat.identity_cid });
         }
+        seats = persistedSeats;
     }
-    catch (error) {
-        for (const name of createdIdentities)
-            await removeMemberIdentity(name);
-        setSagaError(roomId, error instanceof Error ? error.message : String(error), 'Member identity creation failed. Retry with `task recover`.', 'member_failed');
-        if (taskId)
-            failTask(taskId, error instanceof Error ? error.message : String(error));
-        throw error;
-    }
-    const seats = members.map(m => ({
-        role_name: m.name,
-        identity_cid: m.cid,
-        slot: m.slot,
-        cowork_role: m.coworkRole,
-        seat_state: 'pending',
-    }));
-    updateMemberSeats(roomId, seats);
-    if (taskId) {
-        const taskMembers = members.map(m => ({
-            name: m.name,
+    else {
+        // Phase 4: create_members
+        advanceSaga(roomId, 'create_members', 3);
+        try {
+            for (const planned of plan) {
+                const bio = `Fleet task member: ${planned.coworkRole} for ${taskId ?? roomId}`;
+                const { cid } = await createMemberIdentity(planned.name, bio);
+                createdIdentities.push(planned.name);
+                members.push({ ...planned, cid });
+            }
+        }
+        catch (error) {
+            for (const name of createdIdentities)
+                await removeMemberIdentity(name);
+            setSagaError(roomId, error instanceof Error ? error.message : String(error), 'Member identity creation failed. Retry with `task recover`.', 'member_failed');
+            if (taskId)
+                failTask(taskId, error instanceof Error ? error.message : String(error));
+            throw error;
+        }
+        seats = members.map(m => ({
+            role_name: m.name,
             identity_cid: m.cid,
             slot: m.slot,
             cowork_role: m.coworkRole,
+            seat_state: 'pending',
         }));
-        updateTaskMembers(taskId, taskMembers);
-    }
-    // Phase 5: join_role_groups — serial by Cowork role
-    advanceSaga(roomId, 'join_role_groups', 4);
-    const roleGroups = new Map();
-    for (const m of members) {
-        const group = roleGroups.get(m.coworkRole) ?? [];
-        group.push(m);
-        roleGroups.set(m.coworkRole, group);
-    }
-    try {
-        for (const [coworkRole, group] of roleGroups) {
-            const { invite } = await cowork.issueInvite(roomId, {
-                role: coworkRole,
-                min_accepts: group.length,
-            });
-            // invite is used in-memory only — NEVER persisted
-            for (const member of group) {
-                await cowork.acceptInvite(roomId, invite, {
+        updateMemberSeats(roomId, seats);
+        if (taskId) {
+            const taskMembers = members.map(m => ({
+                name: m.name,
+                identity_cid: m.cid,
+                slot: m.slot,
+                cowork_role: m.coworkRole,
+            }));
+            updateTaskMembers(taskId, taskMembers);
+        }
+        // Phase 5: join_role_groups — serial by Cowork role
+        advanceSaga(roomId, 'join_role_groups', 4);
+        const roleGroups = new Map();
+        for (const m of members) {
+            const group = roleGroups.get(m.coworkRole) ?? [];
+            group.push(m);
+            roleGroups.set(m.coworkRole, group);
+        }
+        try {
+            for (const [coworkRole, group] of roleGroups) {
+                const { invite } = await cowork.issueInvite(roomId, {
                     role: coworkRole,
-                    expected_cid: member.cid,
+                    min_accepts: group.length,
                 });
+                // invite is used in-memory only — NEVER persisted
+                for (const member of group) {
+                    await cowork.acceptInvite(roomId, invite, {
+                        role: coworkRole,
+                        expected_cid: member.cid,
+                    });
+                }
             }
         }
-    }
-    catch (error) {
-        for (const name of createdIdentities)
-            await removeMemberIdentity(name);
-        setSagaError(roomId, error instanceof Error ? error.message : String(error), 'Role-group admission failed. Retry with `task recover`.', 'member_failed');
-        if (taskId)
-            failTask(taskId, error instanceof Error ? error.message : String(error));
-        throw error;
+        catch (error) {
+            for (const name of createdIdentities)
+                await removeMemberIdentity(name);
+            setSagaError(roomId, error instanceof Error ? error.message : String(error), 'Role-group admission failed. Retry with `task recover`.', 'member_failed');
+            if (taskId)
+                failTask(taskId, error instanceof Error ? error.message : String(error));
+            throw error;
+        }
     }
     // Phase 6: wait_seats
     advanceSaga(roomId, 'wait_seats', 5);

package/dist/rooms-tasks/task-state.d.ts

@@ -28,5 +28,6 @@ export declare function completeTask(id: string, outcome?: TaskOutcome): TaskRec
 export declare function cancelTask(id: string): TaskRecord;
 export declare function failTask(id: string, error: string): TaskRecord;
 export declare function updateTaskRoom(id: string, roomId: string, roomIdentityCid: string): TaskRecord;
+export declare function updateTaskTemplate(id: string, template: TaskTemplateRef): TaskRecord;
 export declare function updateTaskMembers(id: string, members: TaskMemberRole[]): TaskRecord;
 export declare function deleteTask(id: string): void;

package/dist/rooms-tasks/task-state.js

@@ -161,6 +161,12 @@ export function updateTaskRoom(id, roomId, roomIdentityCid) {
     writeTask(t);
     return t;
 }
+export function updateTaskTemplate(id, template) {
+    const t = readTask(id);
+    t.template = template;
+    writeTask(t);
+    return t;
+}
 export function updateTaskMembers(id, members) {
     const t = readTask(id);
     t.member_roles = members;

package/dist/rooms-tasks/templates.js

@@ -1,6 +1,6 @@
 import { createHash } from 'node:crypto';
-const BRIEFING = {
-    name: 'briefing',
+const TEAM = {
+    name: 'team',
     version: 1,
     builtin: true,
     description: 'Phased task pipeline: Architect specifies, Developer implements, Tester verifies',
@@ -17,8 +17,8 @@ const BRIEFING = {
         { slot: 'tester', role: 'Tester', count: 1, role_ref: 'Tester' },
     ],
 };
-const CONSILIUM = {
-    name: 'consilium',
+const PAIR = {
+    name: 'pair',
     version: 1,
     builtin: true,
     description: 'Deliberation pair: Secretary writes code, Critic reviews — every decision deliberated together',
@@ -34,7 +34,21 @@ const CONSILIUM = {
         { slot: 'critic', role: 'Critic', count: 1, role_ref: 'Critic' },
     ],
 };
-export const BUILTIN_TEMPLATES = [BRIEFING, CONSILIUM];
+const SINGLE = {
+    name: 'single',
+    version: 1,
+    builtin: true,
+    description: 'Solo agent: one general-purpose agent works the task with owner oversight',
+    room: { quiet_membership: false, anonymous: false },
+    contract: [
+        'Agent works the task autonomously, consulting the owner when blocked.',
+        'Owner reviews and approves completion.',
+    ].join('\n'),
+    members: [
+        { slot: 'agent', role: 'Agent', count: 1, role_ref: 'Agent' },
+    ],
+};
+export const BUILTIN_TEMPLATES = [TEAM, PAIR, SINGLE];
 export function hashTemplate(t) {
     const canonical = JSON.stringify({
         name: t.name, version: t.version, description: t.description,

package/package.json

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