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

package/dist/build-info.json

@@ -1,9 +1,9 @@
 {
-  "version": "0.19.0-nightly.1",
-  "buildId": "6ce6f5e5dd7d",
-  "commit": "d847df00e6f4a0146633f2533b4daf61004d9c55",
+  "version": "0.19.0-nightly.3",
+  "buildId": "c969df19c5f2",
+  "commit": "1cfdb94ec5bc493c83c72f62dd70c669c78b9e68",
   "dirty": true,
-  "builtAt": "2026-08-22T13:27:23.786Z",
+  "builtAt": "2026-08-23T10:19:42.625Z",
   "capabilities": [
     "monitor.interrupt.after_tool"
   ]

package/dist/cli.js

@@ -37,6 +37,7 @@ import { WebAccessStore, passwordAccess, validatePublicOrigin } from './web/acce
 import { FLEET_PROXY_CALLER_ENV, FLEET_PROXY_STATE_DIR_ENV, } from './fleet-proxy.js';
 import './harness/claude-code.js'; // registers the claude-code adapter
 import './harness/codex.js'; // registers the codex adapter
+import { registerTemplateCommands, registerTaskCommands, registerRoomCommands } from './rooms-tasks/cli.js';
 // sudo/su shells lack XDG_RUNTIME_DIR, breaking every systemctl/journalctl
 // --user child (supervisor commands, logs, doctor). Derive it before dispatch. (#9)
 deriveXdgRuntimeDir();
@@ -1403,6 +1404,10 @@ function configureWebAccess(opts) {
             + 'or --pairing for protection, or --no-password only for intentional unprotected access');
     return undefined;
 }
+// ── rooms & tasks ──────────────────────────────────────────────────────────
+registerTemplateCommands(program, cOpt);
+registerTaskCommands(program, cOpt);
+registerRoomCommands(program, cOpt);
 program.command('_run <name>', { hidden: true }).description('internal: supervisor entrypoint')
     .option('-c, --configuration <file>')
     .action(async (name, opts) => {

package/dist/config.d.ts

@@ -165,6 +165,17 @@ export interface FleetConfig {
     diagnostics: ConfigDiagnostic[];
     watchdogs: ResolvedWatchdog[];
     loops: ResolvedLoop[];
+    rooms?: import('./rooms-tasks/types.js').RoomsConfig;
+    roomTemplates?: import('./rooms-tasks/types.js').RoomTemplatesConfig;
+    tasks?: import('./rooms-tasks/types.js').TasksConfig;
+    /** SHA-256 fingerprint of the resolved owner invite (never the invite itself). */
+    ownerInviteFingerprint?: string;
+    /**
+     * Resolved owner invite for immediate private-IPC use only. This property is
+     * deliberately non-enumerable so config dumps and JSON output cannot expose
+     * the bearer credential.
+     */
+    ownerInvite?: string;
 }
 export declare class ConfigError extends Error {
 }

package/dist/config.js

@@ -6,6 +6,7 @@ import { harnessRuntimeDir, resolveIsolation, validateIsolationConfig, } from '.
 import { getAdapter } from './harness/registry.js';
 import { resolveWatchdogs } from './watchdog/config.js';
 import { resolveLoops } from './loops/config.js';
+import { validateRoomsConfig, validateTasksConfig, validateRoomTemplatesConfig, } from './rooms-tasks/config.js';
 import { CAPABILITIES, CAP_MONITOR_INTERRUPT_AFTER_TOOL } from './capabilities.js';
 import { runningLabel } from './provenance.js';
 /** The 8 content-free event types the ours daemon appends to notifications.log. */
@@ -164,9 +165,10 @@ export function loadConfig(configPath, options = {}) {
             const parsed = parseFleetDocument(p, readFileSync(p, 'utf8'), options.yamlMode);
             const doc = parsed.value;
             diagnostics.push(...parsed.diagnostics);
-            const extra = Object.keys(doc).filter(k => k !== 'roles');
+            const FLEET_D_ALLOWED = ['roles', 'rooms', 'room_templates', 'tasks'];
+            const extra = Object.keys(doc).filter(k => !FLEET_D_ALLOWED.includes(k));
             if (extra.length)
-                throw new ConfigError(`${p}: fleet.d files may only define roles: (found: ${extra.join(', ')})`);
+                throw new ConfigError(`${p}: fleet.d files may only define ${FLEET_D_ALLOWED.join(', ')}: (found: ${extra.join(', ')})`);
             docs.push({ file: p, doc });
             files.push(p);
         }
@@ -268,10 +270,49 @@ export function loadConfig(configPath, options = {}) {
     const resolvedLoops = resolveLoops(baseDoc.loops, base, roles, vars);
     for (const role of roles)
         role.loops = resolvedLoops.byRole.get(role.name) ?? [];
-    return {
+    // ── Rooms, room_templates, tasks (split-config merge) ──────────────
+    // These sections may appear in the base fleet.yaml and/or in fleet.d files.
+    // Base provides defaults; fleet.d extends. Only one source may define rooms/tasks
+    // top-level (room_templates merge by name, last writer wins).
+    let rooms;
+    let ownerInviteFingerprint;
+    let ownerInvite;
+    let roomTemplates;
+    let tasks;
+    for (const { file, doc } of docs) {
+        if (doc.rooms !== undefined) {
+            if (rooms)
+                throw new ConfigError(`rooms: defined in multiple files; last: ${file}`);
+            const validated = validateRoomsConfig(deepSub(doc.rooms, vars), vars, file);
+            ownerInviteFingerprint = validated._invite?.fingerprint;
+            ownerInvite = validated._invite?.value;
+            const { _invite: _, ...clean } = validated;
+            rooms = clean;
+        }
+        if (doc.room_templates !== undefined) {
+            const validated = validateRoomTemplatesConfig(deepSub(doc.room_templates, vars), file);
+            roomTemplates = { ...(roomTemplates ?? {}), ...validated };
+        }
+        if (doc.tasks !== undefined) {
+            if (tasks)
+                throw new ConfigError(`tasks: defined in multiple files; last: ${file}`);
+            tasks = validateTasksConfig(deepSub(doc.tasks, vars), file);
+        }
+    }
+    const result = {
         roles, vars, defaults, files, startStaggerMs, diagnostics, watchdogs,
         loops: resolvedLoops.loops,
+        rooms, roomTemplates, tasks, ownerInviteFingerprint,
     };
+    if (ownerInvite !== undefined) {
+        Object.defineProperty(result, 'ownerInvite', {
+            value: ownerInvite,
+            enumerable: false,
+            writable: false,
+            configurable: false,
+        });
+    }
+    return result;
 }
 /**
  * Canonical form of a 64-hex container ID for authorization decisions. Hex

package/dist/owner-channel/commands.js

@@ -142,6 +142,95 @@ export const ownerCommands = [
         name: 'version', summary: 'report the fleet version',
         execute: noArgs('/version', async (ctx) => ctx.reply(`ℹ️ ours-fleet ${ctx.version}`)),
     },
+    {
+        name: 'tasks', usage: '/tasks [state]',
+        summary: 'list tasks (optionally filter by state)',
+        execute: async (ctx, args) => {
+            const { listTasks } = await import('../rooms-tasks/task-state.js');
+            const stateFilter = args?.trim() || undefined;
+            const tasks = listTasks(stateFilter && stateFilter !== 'all' ? { state: stateFilter } : undefined);
+            if (!tasks.length)
+                return ctx.reply('📋 No tasks.');
+            const lines = tasks.map(t => {
+                const blocked = t.blocked ? ` [BLOCKED: ${t.blocked.reason}]` : '';
+                return `${t.task_id}  ${t.state}${blocked}  ${t.title}`;
+            });
+            await ctx.reply(tail(`📋 Tasks:\n${lines.join('\n')}`, REPLY_MAX_CHARS));
+        },
+    },
+    {
+        name: 'task', usage: '/task <id>',
+        summary: 'show task details',
+        execute: async (ctx, args) => {
+            if (!args)
+                throw new OwnerCommandUsageError('usage: /task <id>');
+            const { getTask } = await import('../rooms-tasks/task-state.js');
+            try {
+                const t = getTask(args.trim());
+                const lines = [
+                    `📋 Task: ${t.task_id}`,
+                    `Title: ${t.title}`,
+                    `State: ${t.state}${t.blocked ? ` [BLOCKED: ${t.blocked.reason}]` : ''}`,
+                    ...(t.template ? [`Template: ${t.template.name}@${t.template.version}`] : []),
+                    ...(t.room_id ? [`Room: ${t.room_id}`] : []),
+                    `Origin: ${t.origin.type}`,
+                    `Created: ${t.created_at}`,
+                ];
+                await ctx.reply(lines.join('\n'));
+            }
+            catch (e) {
+                await ctx.reply(`⚠️ ${e instanceof Error ? e.message : String(e)}`);
+            }
+        },
+    },
+    {
+        name: 'rooms', summary: 'list rooms',
+        execute: noArgs('/rooms', async (ctx) => {
+            const { listRoomRecords } = await import('../rooms-tasks/room-state.js');
+            const rooms = listRoomRecords();
+            if (!rooms.length)
+                return ctx.reply('🏠 No rooms.');
+            const lines = rooms.map(r => `${r.room_id}  ${r.state}  ${r.room_name}${r.task_id ? ` (task: ${r.task_id})` : ''}`);
+            await ctx.reply(tail(`🏠 Rooms:\n${lines.join('\n')}`, REPLY_MAX_CHARS));
+        }),
+    },
+    {
+        name: 'room', usage: '/room <id>',
+        summary: 'show room details',
+        execute: async (ctx, args) => {
+            if (!args)
+                throw new OwnerCommandUsageError('usage: /room <id>');
+            const { getRoomRecord } = await import('../rooms-tasks/room-state.js');
+            const r = getRoomRecord(args.trim());
+            if (!r)
+                return ctx.reply(`⚠️ room not found: ${args.trim()}`);
+            const lines = [
+                `🏠 Room: ${r.room_id}`,
+                `Name: ${r.room_name}`,
+                `State: ${r.state}`,
+                `Saga: ${r.saga.phase} (step ${r.saga.step_index})`,
+                ...(r.task_id ? [`Task: ${r.task_id}`] : []),
+                ...(r.provisioning_detail ? [`Detail: ${r.provisioning_detail}`] : []),
+                ...(r.saga.error ? [`Error: ${r.saga.error}`] : []),
+                `Created: ${r.created_at}`,
+            ];
+            await ctx.reply(lines.join('\n'));
+        },
+    },
+    {
+        name: 'templates', summary: 'list available room templates',
+        execute: noArgs('/templates', async (ctx) => {
+            const { listTemplates } = await import('../rooms-tasks/templates.js');
+            const templates = listTemplates({});
+            if (!templates.length)
+                return ctx.reply('📐 No templates.');
+            const lines = templates.map(t => {
+                const tag = t.builtin ? ' (built-in)' : '';
+                return `${t.name}@${t.version}${tag}  ${t.description}`;
+            });
+            await ctx.reply(`📐 Templates:\n${lines.join('\n')}`);
+        }),
+    },
 ];
 /** Trimmed slash-prefixed text is a command attempt and is never forwarded. */
 export const isOwnerCommandText = (text) => text.trim().startsWith('/');

package/dist/rooms-tasks/cli.d.ts

@@ -0,0 +1,4 @@
+import type { Command } from 'commander';
+export declare function registerTemplateCommands(parent: Command, cOpt: (cmd: Command) => Command): void;
+export declare function registerTaskCommands(parent: Command, cOpt: (cmd: Command) => Command): void;
+export declare function registerRoomCommands(parent: Command, cOpt: (cmd: Command) => Command): void;