@ours.network/fleet 0.19.0-nightly.1 → 0.19.0-nightly.11

package/dist/doctor.js

@@ -106,6 +106,126 @@ export async function doctor(opts = {}, exec = realExec, platform = process.plat
                 ok: true,
                 detail: `warning: ${diagnostic.message}`,
             });
+    // ── Rooms/tasks checks (§5.3) ────────────────────────────────────────
+    if (loaded.ok && loaded.rooms) {
+        const rooms = loaded.rooms;
+        // Cowork socket reachability
+        const coworkConfig = rooms.cowork?.config;
+        try {
+            const { createCoworkAdapter } = await import('./rooms-tasks/cowork-adapter.js');
+            const adapter = createCoworkAdapter({ configPath: coworkConfig });
+            const reachable = await adapter.available();
+            checks.push({
+                name: 'cowork', ok: reachable,
+                detail: reachable
+                    ? 'management socket reachable'
+                    : `management socket unreachable${coworkConfig ? ` (config: ${coworkConfig})` : ''}`,
+            });
+        }
+        catch (e) {
+            checks.push({
+                name: 'cowork', ok: false,
+                detail: `management socket error${coworkConfig ? ` (config: ${coworkConfig})` : ''}: ${e?.message ?? e}`,
+            });
+        }
+        // Owner CID shape
+        const cidOk = /^[0-9a-fA-F]{64}$/.test(rooms.owner.expected_cid);
+        checks.push({
+            name: 'rooms: owner CID', ok: cidOk,
+            detail: cidOk ? 'valid 64-hex CID' : `invalid CID shape: ${rooms.owner.expected_cid.slice(0, 16)}...`,
+        });
+        // Invite presence (never content)
+        checks.push({
+            name: 'rooms: owner invite',
+            ok: !!loaded.ownerInviteFingerprint,
+            detail: loaded.ownerInviteFingerprint
+                ? `present (fingerprint: ${loaded.ownerInviteFingerprint.slice(0, 12)}...)`
+                : 'not configured — room owner attachment will use waiting_owner_invite',
+        });
+        // Template validity and referenced role validity
+        const { listTemplates, resolveTemplate } = await import('./rooms-tasks/templates.js');
+        const customs = loaded.roomTemplates ?? {};
+        const templates = listTemplates(customs);
+        const roleNames = new Set(roles.map(r => r.name));
+        for (const t of templates) {
+            const badRefs = t.members
+                .filter(m => m.role_ref && !roleNames.has(m.role_ref))
+                .map(m => m.role_ref);
+            if (badRefs.length) {
+                checks.push({
+                    name: `template: ${t.name}@${t.version}`,
+                    ok: true,
+                    detail: `warning: role_ref(s) ${badRefs.join(', ')} not found in configured roles`,
+                });
+            }
+        }
+        // Default template validity
+        const defaultTemplate = loaded.rooms.defaults?.template
+            ?? loaded.tasks?.default_room_template;
+        if (defaultTemplate) {
+            const resolved = resolveTemplate(defaultTemplate, customs);
+            checks.push({
+                name: 'rooms: default template',
+                ok: !!resolved,
+                detail: resolved
+                    ? `${resolved.name}@${resolved.version}`
+                    : `template '${defaultTemplate}' not found`,
+            });
+        }
+        // Shared-daemon selection coherence
+        if (rooms.cowork?.config) {
+            const { existsSync: exists } = await import('node:fs');
+            const configOk = exists(rooms.cowork.config);
+            checks.push({
+                name: 'rooms: cowork config', ok: configOk,
+                detail: configOk
+                    ? `cowork config at ${rooms.cowork.config}`
+                    : `cowork config not found: ${rooms.cowork.config}`,
+            });
+        }
+        // Hard prerelease capability check
+        try {
+            const { createCoworkAdapter } = await import('./rooms-tasks/cowork-adapter.js');
+            const adapter = createCoworkAdapter({ configPath: coworkConfig });
+            const roomList = await adapter.listRooms();
+            checks.push({
+                name: 'rooms: capability', ok: true,
+                detail: `cowork room management operational (${roomList.length} room(s))`,
+            });
+        }
+        catch (e) {
+            const msg = e?.message ?? String(e);
+            const isProto = msg.includes('protocol') || msg.includes('invalid');
+            checks.push({
+                name: 'rooms: capability', ok: false,
+                detail: isProto
+                    ? `cowork does not support room management protocol — upgrade ours-cowork to prerelease`
+                    : `room management check failed: ${msg}`,
+            });
+        }
+        // Stale task/room warnings
+        try {
+            const { listTasks } = await import('./rooms-tasks/task-state.js');
+            const { listRoomRecords } = await import('./rooms-tasks/room-state.js');
+            const tasks = listTasks();
+            const roomRecords = listRoomRecords();
+            const roomIds = new Set(roomRecords.map(r => r.room_id));
+            const taskIds = new Set(tasks.map(t => t.task_id));
+            const orphanedTasks = tasks.filter(t => t.room_id && !roomIds.has(t.room_id));
+            const orphanedRooms = roomRecords.filter(r => r.task_id && !taskIds.has(r.task_id));
+            if (orphanedTasks.length)
+                checks.push({
+                    name: 'rooms: stale tasks', ok: true,
+                    detail: `warning: ${orphanedTasks.length} task(s) reference missing rooms: ${orphanedTasks.map(t => t.task_id).join(', ')}`,
+                });
+            if (orphanedRooms.length)
+                checks.push({
+                    name: 'rooms: stale rooms', ok: true,
+                    detail: `warning: ${orphanedRooms.length} room(s) reference missing tasks: ${orphanedRooms.map(r => r.room_id).join(', ')}`,
+                });
+        }
+        catch { /* state dir may not exist yet */ }
+    }
     if (roles.length === 0 || roles.some(role => (role.session ?? 'tmux') === 'tmux')) {
         const tmux = await exec('tmux', ['-V']);
         checks.push({
@@ -405,7 +525,11 @@ export async function doctor(opts = {}, exec = realExec, platform = process.plat
 function loadConfigResult(configPath, yamlMode) {
     try {
         const cfg = loadConfig(configPath, { yamlMode });
-        return { ok: true, roles: cfg.roles, files: cfg.files, diagnostics: cfg.diagnostics };
+        return {
+            ok: true, roles: cfg.roles, files: cfg.files, diagnostics: cfg.diagnostics,
+            rooms: cfg.rooms, roomTemplates: cfg.roomTemplates, tasks: cfg.tasks,
+            ownerInviteFingerprint: cfg.ownerInviteFingerprint,
+        };
     }
     catch (e) {
         return { ok: false, error: e instanceof Error ? e.message : String(e) };

package/dist/harness/claude-code.js

@@ -285,6 +285,8 @@ export function makeClaudeCodeAdapter(exec = realExec) {
             currentIdentityTool: 'current_identity',
             sendTool: 'send_message',
             getMessagesTool: 'get_messages',
+            listHistoryTool: 'list_history',
+            getHistoryItemTool: 'get_history_item',
             monitorInstruction: id => {
                 const m = armMonitor(id);
                 return `${m.charAt(0).toUpperCase()}${m.slice(1)}.`;

package/dist/harness/codex.js

@@ -411,6 +411,8 @@ export function makeCodexAdapter(exec = realExec) {
             currentIdentityTool: 'current_identity',
             sendTool: 'send_message',
             getMessagesTool: 'get_messages',
+            listHistoryTool: 'list_history',
+            getHistoryItemTool: 'get_history_item',
             monitorInstruction: (id, configuredRole) => {
                 const consented = configuredRole?.harness_options?.monitor === true;
                 const consent = consented

package/dist/harness/types.d.ts

@@ -67,6 +67,8 @@ export interface BriefingVocab {
     currentIdentityTool: string;
     sendTool: string;
     getMessagesTool: string;
+    listHistoryTool: string;
+    getHistoryItemTool: string;
     monitorInstruction(identity: string, role?: ResolvedRole): string;
     /** Wake-source wording for a role whose monitor is supervisor-owned (monitor.mode=fleet). */
     supervisedWakeNote(identity: string, role?: ResolvedRole): string;

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

@@ -217,6 +217,13 @@ export declare class OwnerChannel implements OwnerChannelHandle {
      * CLI is asked to bounce this very process; neither can happen afterwards.
      */
     private restartSelf;
+    /**
+     * The caller may itself be a room member. Persist and acknowledge acceptance
+     * before an external worker starts a saga that can retire this process.
+     */
+    private closeRoomFromOwner;
+    /** Carry a task terminal request through a worker that survives this role. */
+    private terminalTaskFromOwner;
     /** Code-point-safe tail of the worklog, or undefined when there is none. */
     private readWorklogTail;
     /** Bound harness-command output to a single outbound message. */

package/dist/owner-channel/channel.js

@@ -996,6 +996,8 @@ export class OwnerChannel {
                 return this.commentsState();
             },
             fleetList: () => this.fleetOps.list(),
+            closeRoom: roomId => this.closeRoomFromOwner(sender, roomId, wireId),
+            terminalTask: (taskId, kind, outcome) => this.terminalTaskFromOwner(sender, taskId, kind, outcome, wireId),
             recentEvents: limit => this.options.session.eventsSince(0).slice(-limit),
             readWorklogTail: maxChars => this.readWorklogTail(maxChars),
             reply: async (replyText) => { await this.send(sender.id, replyText, wireId); },
@@ -1046,6 +1048,51 @@ export class OwnerChannel {
         this.options.log(`[${this.options.role}] owner requested ${command}`);
         await this.fleetOps.restart(mode);
     }
+    /**
+     * The caller may itself be a room member. Persist and acknowledge acceptance
+     * before an external worker starts a saga that can retire this process.
+     */
+    async closeRoomFromOwner(sender, roomId, wireId) {
+        const { acceptManagedRoomClose, recordManagedRoomCloseError } = await import('../rooms-tasks/close.js');
+        const accepted = await acceptManagedRoomClose(roomId);
+        if (accepted.state === 'closed') {
+            await this.send(sender.id, `🔒 Room ${roomId} is already closed`, wireId);
+            this.state.remember(wireId);
+            return;
+        }
+        await this.send(sender.id, `🔒 Room ${roomId} close accepted/pending`, wireId);
+        this.state.remember(wireId);
+        try {
+            await this.fleetOps.closeRoom(roomId);
+        }
+        catch (error) {
+            await recordManagedRoomCloseError(roomId, error instanceof Error ? error.message : String(error), `External close worker failed to start. Retry /room close ${roomId} ${roomId}.`);
+            throw error;
+        }
+    }
+    /** Carry a task terminal request through a worker that survives this role. */
+    async terminalTaskFromOwner(sender, taskId, kind, outcome, wireId) {
+        const { getTask } = await import('../rooms-tasks/task-state.js');
+        const { acceptTaskTerminalIntent, recordTaskTerminalIntentError, } = await import('../rooms-tasks/terminal.js');
+        const task = getTask(taskId);
+        const accepted = await acceptTaskTerminalIntent({
+            taskId, kind, roomId: task.room_id, outcome,
+        });
+        if (accepted.terminal_intent?.status === 'settled') {
+            await this.send(sender.id, `✅ Task ${taskId} → ${accepted.state}`, wireId);
+            this.state.remember(wireId);
+            return;
+        }
+        await this.send(sender.id, `⏳ Task ${taskId} terminal intent accepted/pending`, wireId);
+        this.state.remember(wireId);
+        try {
+            await this.fleetOps.settleTask(taskId);
+        }
+        catch (error) {
+            await recordTaskTerminalIntentError(taskId, error instanceof Error ? error.message : String(error), `External settle worker failed to start. Retry the identical task command or run task recover ${taskId}.`);
+            throw error;
+        }
+    }
     /** Code-point-safe tail of the worklog, or undefined when there is none. */
     async readWorklogTail(maxChars) {
         try {

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

@@ -1,4 +1,5 @@
 import type { InterruptOutcome, SessionEvent, SessionSnapshot } from '../session/types.js';
+import type { TaskOutcome, TaskTerminalIntent } from '../rooms-tasks/types.js';
 import { type OwnerCommentsState } from './notices.js';
 /**
  * Fleet-level effects a deterministic owner command may trigger. Production
@@ -10,6 +11,10 @@ export interface OwnerFleetOps {
     restart(mode: 'keep' | 'fresh'): Promise<void>;
     /** `ours-fleet ls` output. */
     list(): Promise<string>;
+    /** Start a room-close worker outside the caller role's supervisor lifecycle. */
+    closeRoom(roomId: string): Promise<void>;
+    /** Resume a task terminal intent outside the caller role's supervisor lifecycle. */
+    settleTask(taskId: string): Promise<void>;
 }
 /**
  * The narrow capability surface a command executor sees. Everything here is
@@ -40,6 +45,10 @@ export interface OwnerCommandContext {
      */
     setComments(enabled: boolean): OwnerCommentsState;
     fleetList(): Promise<string>;
+    /** Persist acceptance, acknowledge it, then launch the external close worker. */
+    closeRoom(roomId: string): Promise<void>;
+    /** Persist terminal intent, acknowledge it, then launch the external settle worker. */
+    terminalTask(taskId: string, kind: TaskTerminalIntent['kind'], outcome?: TaskOutcome): Promise<void>;
     recentEvents(limit: number): SessionEvent[];
     readWorklogTail(maxChars: number): Promise<string | undefined>;
     reply(text: string): Promise<void>;