@ours.network/fleet 1.0.5 → 1.1.0-nightly.10

package/dist/rooms-tasks/cli.js

@@ -1,4 +1,5 @@
 import { readFileSync } from 'node:fs';
+import { createHash } from 'node:crypto';
 import { loadConfig, ConfigError } from '../config.js';
 import { provisionMembers, getBinPath } from './provision.js';
 import { launchFleetWorker } from './external-worker.js';
@@ -9,6 +10,7 @@ import { createCoworkAdapter, CoworkProtocolError } from './cowork-adapter.js';
 import { markdownCode, markdownProse, renderMarkdownFailure, renderMarkdownList, renderMarkdownResult, roomStatus, taskStatus, } from './markdown.js';
 import { TaskRoomApplicationError, TaskRoomApplicationService } from '../application/task-room-service.js';
 import { TaskListError } from './task-lists.js';
+import { recordFleetAuditFailure, recordFleetAuditPresentation, recordFleetAuditResource, } from '../fleet-command-audit.js';
 class TaskRoomPublicError extends Error {
     code;
     fields;
@@ -41,7 +43,7 @@ function taskRoomPublicFailure(error) {
         case 'template_not_found': return {
             legacy: `template not found: ${f.template ?? 'requested-template'}`, kind: 'not_found',
             detail: `The requested template ${f.template ?? ''}`.trim() + ' was not found.',
-            action: 'Run ours-fleet template list and retry with an available template.',
+            action: 'Run ours-fleet init to seed missing file-backed presets, then run ours-fleet template list.',
         };
         case 'template_mismatch': return {
             legacy: `template ${f.requested ?? 'requested-template'} does not match room ${f.room ?? 'requested-room'}'s provisioned template ${f.provisioned ?? 'recorded-template'}`,
@@ -89,8 +91,29 @@ function die(e) {
     const msg = e instanceof TaskRoomPublicError
         ? taskRoomPublicFailure(e).legacy : e instanceof Error ? e.message : String(e);
     process.stderr.write(`error: ${msg}\n`);
+    recordFleetAuditFailure(classifyTaskRoomFailure(e));
     process.exit(1);
 }
+function classifyTaskRoomFailure(e) {
+    if (e instanceof TaskRoomApplicationError)
+        e = taskRoomPublicError(e.code, e.fields);
+    if (e instanceof TaskRoomPublicError || e instanceof TaskListError || e instanceof ConfigError)
+        return { class: 'validation', effect: 'not_started' };
+    if (e instanceof TaskStateError) {
+        const known = /^task not found: [A-Za-z0-9_-]{1,128}$/u.test(e.message)
+            || e.message === 'invalid task ID: expected the canonical 17-character lowercase ID'
+            || isKnownTaskStateMessage(e.message);
+        return known ? { class: 'validation', effect: 'not_started' }
+            : { class: 'runtime', effect: 'unknown' };
+    }
+    if (e instanceof RoomStateError) {
+        const known = /^room not found: [A-Za-z0-9_-]{1,128}$/u.test(e.message)
+            || isKnownRoomStateMessage(e.message);
+        return known ? { class: 'validation', effect: 'not_started' }
+            : { class: 'runtime', effect: 'unknown' };
+    }
+    return { class: 'runtime', effect: 'unknown' };
+}
 const TASK_STATE_WORD = '(?:backlog|provisioning|active|review|done|cancelled|failed)';
 const SAFE_ID_WORD = '[A-Za-z0-9_-]{1,128}';
 function isKnownTaskStateMessage(message) {
@@ -127,6 +150,7 @@ function dieTaskRoom(e) {
             action: failure.action,
         });
         process.stderr.write(`${output}\n`);
+        recordFleetAuditFailure({ class: 'validation', effect: 'not_started' });
         process.exit(1);
     }
     if (e instanceof TaskListError) {
@@ -142,6 +166,7 @@ function dieTaskRoom(e) {
                     : 'Use a valid NFC-normalized name of at most 64 Unicode code points.',
         });
         process.stderr.write(`${output}\n`);
+        recordFleetAuditFailure({ class: 'validation', effect: 'not_started' });
         process.exit(1);
     }
     const taskMissing = e instanceof TaskStateError
@@ -167,6 +192,7 @@ function dieTaskRoom(e) {
                     : 'Retry once; if it repeats, run ours-fleet doctor and inspect the role logs.',
     });
     process.stderr.write(`${output}\n`);
+    recordFleetAuditFailure(classifyTaskRoomFailure(e));
     process.exit(1);
 }
 const taskListMarkdown = (tasks, title = 'Tasks') => renderMarkdownList({
@@ -175,23 +201,107 @@ const taskListMarkdown = (tasks, title = 'Tasks') => renderMarkdownList({
         + ` — List ${markdownCode(t.list_name ?? 'default')}`
         + (t.blocked ? ` — 🚧 Blocked: ${markdownProse(t.blocked.reason)}` : '')),
 });
-const taskActionMarkdown = (title, task, fields = []) => renderMarkdownResult({
-    icon: '📋', title,
-    fields: [
-        { label: 'ID', value: task.task_id, kind: 'code' },
-        { label: 'Status', value: taskStatus(task.state), kind: 'markdown' },
-        { label: 'List', value: task.list_name ?? 'default', kind: 'code' },
-        ...fields,
-    ],
-});
-const roomActionMarkdown = (title, room, fields = []) => renderMarkdownResult({
-    icon: '🏠', title,
-    fields: [
-        { label: 'ID', value: room.room_id, kind: 'code' },
-        { label: 'Status', value: roomStatus(room.state), kind: 'markdown' },
-        ...fields,
-    ],
-});
+const taskActionMarkdown = (title, task, fields = []) => {
+    recordFleetAuditResource('task', task.task_id);
+    if (task.room_id)
+        recordFleetAuditResource('room', task.room_id);
+    return renderMarkdownResult({
+        icon: '📋', title,
+        fields: [
+            { label: 'ID', value: task.task_id, kind: 'code' },
+            { label: 'Status', value: taskStatus(task.state), kind: 'markdown' },
+            { label: 'List', value: task.list_name ?? 'default', kind: 'code' },
+            ...fields,
+        ],
+    });
+};
+function safeSelectionSummary(definition, kind) {
+    const selected = definition?.[kind];
+    if (!selected || typeof selected !== 'object' || Array.isArray(selected))
+        return 'unresolved';
+    const selection = selected;
+    if (selection.kind === 'ref' && typeof selection.id === 'string')
+        return `ref:${selection.id} (reference)`;
+    if (selection.kind === 'inline' && typeof selection.fingerprint === 'string')
+        return `inline:${selection.fingerprint} (inline)`;
+    if (typeof selection.ref === 'string')
+        return `ref:${selection.ref}`;
+    if (!Object.hasOwn(selection, 'inline'))
+        return 'unresolved';
+    const canonical = (value) => Array.isArray(value)
+        ? `[${value.map(canonical).join(',')}]`
+        : value && typeof value === 'object'
+            ? `{${Object.entries(value).sort(([a], [b]) => a.localeCompare(b))
+                .map(([key, child]) => `${JSON.stringify(key)}:${canonical(child)}`).join(',')}}`
+            : JSON.stringify(value);
+    const fingerprint = createHash('sha256').update(canonical(selection.inline)).digest('hex').slice(0, 16);
+    return `inline:sha256:${fingerprint}`;
+}
+function safePermissionsSummary(definition) {
+    const permissions = definition?.permissions;
+    if (!permissions || typeof permissions !== 'object' || Array.isArray(permissions))
+        return undefined;
+    const policy = permissions;
+    const fields = ['approval', 'filesystem', 'unattended'].flatMap(key => typeof policy[key] === 'string' ? [`${key}=${policy[key]}`] : []);
+    return fields.length ? fields.join(',') : undefined;
+}
+function auditTask(operation, task, previousState, newState = task.state, revision) {
+    const materialSameState = operation === 'block' || operation === 'unblock' || operation === 'settling';
+    if (previousState === newState && !materialSameState)
+        return;
+    recordFleetAuditResource('task', task.task_id);
+    if (task.room_id)
+        recordFleetAuditResource('room', task.room_id);
+    const room = task.room_id ? getRoomRecord(task.room_id) : undefined;
+    const definitions = new Map(room?.member_seats.map(seat => [seat.role_name, seat.launch?.agent_definition]) ?? []);
+    const semanticOperation = operation === 'recover'
+        ? newState === 'active' ? 'work' : newState === 'done' ? 'done'
+            : newState === 'cancelled' ? 'cancel' : undefined
+        : operation;
+    if (!semanticOperation)
+        return;
+    recordFleetAuditPresentation({ kind: 'task', operation: semanticOperation, id: task.task_id, title: task.title,
+        previousState, newState,
+        revision: revision ?? task.blocked?.at ?? task.ended_at ?? task.started_at ?? task.created_at,
+        list: task.list_name ?? 'default',
+        template: task.template ? `${task.template.name}@${task.template.version}` : undefined,
+        roomId: task.room_id, agents: [...task.member_roles].sort((a, b) => a.name.localeCompare(b.name)).map(member => ({ name: member.name,
+            brain: safeSelectionSummary(definitions.get(member.name), 'brain'),
+            role: safeSelectionSummary(definitions.get(member.name), 'role') === 'unresolved'
+                ? member.cowork_role : safeSelectionSummary(definitions.get(member.name), 'role'),
+            permissions: safePermissionsSummary(definitions.get(member.name)) })) });
+}
+function auditRoom(operation, room, previousState, newState = room.state) {
+    if (previousState === newState)
+        return;
+    recordFleetAuditResource('room', room.room_id);
+    const semanticOperation = operation === 'recover'
+        ? newState === 'active' ? 'activate' : newState === 'deleted' ? 'delete'
+            : newState === 'closing' ? 'close' : undefined
+        : operation;
+    if (!semanticOperation)
+        return;
+    recordFleetAuditPresentation({ kind: 'room', operation: semanticOperation, id: room.room_id, previousState, newState,
+        revision: room.closed_at ?? room.activated_at ?? room.close?.accepted_at ?? room.created_at,
+        name: room.room_name, taskId: room.task_id,
+        template: room.template_snapshot ? `${room.template_snapshot.name}@${room.template_snapshot.version}` : undefined,
+        participants: [...room.member_seats].sort((a, b) => a.role_name.localeCompare(b.role_name)).map(member => ({ name: member.role_name, id: member.identity_cid,
+            brain: safeSelectionSummary(member.launch?.agent_definition, 'brain'),
+            role: safeSelectionSummary(member.launch?.agent_definition, 'role') === 'unresolved'
+                ? member.cowork_role : safeSelectionSummary(member.launch?.agent_definition, 'role'),
+            permissions: safePermissionsSummary(member.launch?.agent_definition) })) });
+}
+const roomActionMarkdown = (title, room, fields = []) => {
+    recordFleetAuditResource('room', room.room_id);
+    return renderMarkdownResult({
+        icon: '🏠', title,
+        fields: [
+            { label: 'ID', value: room.room_id, kind: 'code' },
+            { label: 'Status', value: roomStatus(room.state), kind: 'markdown' },
+            ...fields,
+        ],
+    });
+};
 const PUBLIC_SETTLE_WAIT_MS = 60_000;
 const PUBLIC_SETTLE_POLL_MS = 100;
 const sleep = (ms) => new Promise(resolve => { setTimeout(resolve, ms); });
@@ -208,6 +318,10 @@ async function launchTaskSettleWorker(taskId, configPath) {
             actor: { kind: 'local_control', surface: 'cli' }, taskId, error: errorText(error),
             recoveryHint: `External settle worker failed to start. Retry task recover ${taskId}.`,
         });
+        const task = getTask(taskId);
+        recordFleetAuditPresentation({ kind: 'lifecycle_failure', resource: 'Task', id: taskId,
+            state: task.state, category: 'settlement_failed',
+            eventId: task.terminal_intent?.error_at ?? task.terminal_intent?.accepted_at ?? task.created_at });
         throw error;
     }
     const deadline = Date.now() + PUBLIC_SETTLE_WAIT_MS;
@@ -220,7 +334,11 @@ async function launchTaskSettleWorker(taskId, configPath) {
         }
         await sleep(PUBLIC_SETTLE_POLL_MS);
     }
-    return { task: getTask(taskId), timedOut: true };
+    const task = getTask(taskId);
+    recordFleetAuditPresentation({ kind: 'lifecycle_failure', resource: 'Task', id: taskId,
+        state: task.state, category: 'settlement_pending',
+        eventId: task.terminal_intent?.accepted_at ?? task.created_at });
+    return { task, timedOut: true };
 }
 async function launchRoomDeleteWorker(roomId, configPath) {
     const previousErrorAt = getRoomRecord(roomId)?.close?.error_at;
@@ -232,6 +350,11 @@ async function launchRoomDeleteWorker(roomId, configPath) {
             actor: { kind: 'local_control', surface: 'cli' }, roomId, error: errorText(error),
             recoveryHint: `External delete worker failed to start. Retry room delete ${roomId} ${roomId}.`,
         });
+        const room = getRoomRecord(roomId);
+        if (room)
+            recordFleetAuditPresentation({ kind: 'lifecycle_failure', resource: 'Room', id: roomId,
+                state: room.state, category: 'cleanup_failed',
+                eventId: room.close?.error_at ?? room.close?.accepted_at ?? room.created_at });
         throw error;
     }
     const deadline = Date.now() + PUBLIC_SETTLE_WAIT_MS;
@@ -244,7 +367,12 @@ async function launchRoomDeleteWorker(roomId, configPath) {
         }
         await sleep(PUBLIC_SETTLE_POLL_MS);
     }
-    return { deleted: getRoomRecord(roomId) === undefined, timedOut: true };
+    const remaining = getRoomRecord(roomId);
+    if (remaining)
+        recordFleetAuditPresentation({ kind: 'lifecycle_failure', resource: 'Room', id: roomId,
+            state: remaining.state, category: 'cleanup_pending',
+            eventId: remaining.close?.accepted_at ?? remaining.created_at });
+    return { deleted: remaining === undefined, timedOut: true };
 }
 function loadCfg(opts) {
     return loadConfig(opts.configuration);
@@ -346,21 +474,36 @@ async function provisionRoom(cfg, input) {
             setSagaError(record.room_id, error instanceof Error ? error.message : String(error), mismatch
                 ? 'Verify rooms.owner.expected_cid and rotate the configured invite if necessary.'
                 : 'Rotate rooms.owner.public_invite or public_invite_file, then run room recover.', mismatch ? 'owner_cid_mismatch' : 'waiting_owner_invite');
+            const failed = getRoomRecord(record.room_id);
+            if (failed)
+                recordFleetAuditPresentation({ kind: 'lifecycle_failure', resource: 'Room',
+                    id: failed.room_id, state: failed.state, category: 'provision_failed',
+                    eventId: `${failed.created_at}:${failed.saga.phase}:${failed.saga.step_index}` });
             throw error;
         }
     }
     record = advanceSaga(record.room_id, 'create_members', 3);
     if (input.template && input.template.members.length > 0) {
-        record = await provisionMembers({
-            cfg,
-            cowork,
-            roomId: record.room_id,
-            taskId: input.taskId,
-            template: input.template,
-            binPath: getBinPath(),
-            brief: input.brief,
-            goal: input.goal,
-        });
+        try {
+            record = await provisionMembers({
+                cfg,
+                cowork,
+                roomId: record.room_id,
+                taskId: input.taskId,
+                template: input.template,
+                binPath: getBinPath(),
+                brief: input.brief,
+                goal: input.goal,
+            });
+        }
+        catch (error) {
+            const failed = getRoomRecord(record.room_id);
+            if (failed)
+                recordFleetAuditPresentation({ kind: 'lifecycle_failure', resource: 'Room',
+                    id: failed.room_id, state: failed.state, category: 'provision_failed',
+                    eventId: `${failed.created_at}:${failed.saga.phase}:${failed.saga.step_index}` });
+            throw error;
+        }
     }
     else {
         record = activateRoom(record.room_id);
@@ -382,12 +525,11 @@ export function registerTemplateCommands(parent, cOpt) {
                 return;
             }
             if (!templates.length) {
-                console.log('No templates configured.');
+                console.log('No templates configured. Run ours-fleet init to seed missing file-backed presets.');
                 return;
             }
             for (const t of templates) {
-                const tag = t.builtin ? ' (built-in)' : '';
-                console.log(`${t.name}@${t.version}${tag}  ${t.description}`);
+                console.log(`${t.name}@${t.version}  ${t.description}  [file: ${t.sourceFile ?? 'manifest'}]`);
             }
         }
         catch (e) {
@@ -405,11 +547,13 @@ export function registerTemplateCommands(parent, cOpt) {
                 return;
             }
             console.log(`${t.name}@${t.version}  ${t.description}`);
+            console.log(`Source: ${t.sourceFile ?? 'manifest'}`);
             if (t.contract)
                 console.log(`\nContract:\n${t.contract}`);
             console.log(`\nMembers:`);
             for (const m of t.members)
-                console.log(`  ${m.slot}: ${m.count}× ${m.role} (ref: ${m.role_ref})`);
+                console.log(`  ${m.slot}: ${m.count}× ${m.role} (`
+                    + `${'ref' in m.agent ? `agent ref: ${m.agent.ref}` : 'inline Agent'})`);
             console.log(`\nContent hash: ${t.content_hash}`);
         }
         catch (e) {
@@ -487,7 +631,7 @@ export function registerTaskCommands(parent, cOpt) {
         .option('--list <name>', 'filter by task list')
         .option('--group-by-list', 'group deterministic results by list (JSON)')
         .option('--json', 'JSON output')
-        .action((opts) => {
+        .action(async (opts) => {
         try {
             let stateFilter;
             if (opts.state && opts.state !== 'all') {
@@ -513,9 +657,10 @@ export function registerTaskCommands(parent, cOpt) {
     taskCmd.command('lists')
         .description('list named task lists')
         .option('--json', 'JSON output')
-        .action((opts) => {
+        .action(async (opts) => {
         try {
-            const lists = taskRoomService().listTaskLists();
+            const service = taskRoomService(opts.configuration);
+            const lists = service.listTaskLists();
             if (opts.json) {
                 console.log(JSON.stringify({ schema_version: 1, lists }, null, 2));
                 return;
@@ -606,9 +751,10 @@ export function registerTaskCommands(parent, cOpt) {
     taskCmd.command('show <id>')
         .description('show task details')
         .option('--json', 'JSON output')
-        .action((id, opts) => {
+        .action(async (id, opts) => {
         try {
-            const { task: t, orchestration: room } = taskRoomService().getTask(id);
+            const service = taskRoomService();
+            const { task: t, orchestration: room } = service.getTask(id);
             if (opts.json) {
                 console.log(JSON.stringify({
                     schema_version: 1, task: t, orchestration: room ?? null,
@@ -676,9 +822,11 @@ export function registerTaskCommands(parent, cOpt) {
         .option('--json', 'JSON output')
         .action((id, opts) => {
         try {
+            const previous = getTask(id).state;
             const t = taskRoomService().blockTask({
                 actor: { kind: 'local_control', surface: 'cli' }, taskId: id, reason: opts.reason,
             });
+            auditTask('block', t, previous);
             if (opts.json) {
                 console.log(JSON.stringify({ schema_version: 1, task: t }, null, 2));
                 return;
@@ -696,9 +844,12 @@ export function registerTaskCommands(parent, cOpt) {
         .option('--json', 'JSON output')
         .action((id, opts) => {
         try {
+            const prior = getTask(id);
+            const previous = prior.state;
             const t = taskRoomService().unblockTask({
                 actor: { kind: 'local_control', surface: 'cli' }, taskId: id,
             });
+            auditTask('unblock', t, previous, t.state, prior.blocked?.at);
             if (opts.json) {
                 console.log(JSON.stringify({ schema_version: 1, task: t }, null, 2));
                 return;
@@ -716,9 +867,11 @@ export function registerTaskCommands(parent, cOpt) {
         .option('--json', 'JSON output')
         .action((id, opts) => {
         try {
+            const previous = getTask(id).state;
             const t = taskRoomService().reviewTask({
                 actor: { kind: 'local_control', surface: 'cli' }, taskId: id,
             });
+            auditTask('review', t, previous);
             if (opts.json) {
                 console.log(JSON.stringify({ schema_version: 1, task: t }, null, 2));
                 return;
@@ -738,6 +891,7 @@ export function registerTaskCommands(parent, cOpt) {
         .option('--json', 'JSON output')
         .action(async (id, opts) => {
         try {
+            const previous = getTask(id).state;
             let summary = opts.summary;
             if (opts.summaryFile)
                 summary = readFileSync(opts.summaryFile, 'utf8');
@@ -745,10 +899,13 @@ export function registerTaskCommands(parent, cOpt) {
             const plan = await taskRoomService(opts.configuration).completeTask({
                 actor: { kind: 'local_control', surface: 'cli' }, taskId: id, outcome,
             });
+            if (plan.task.terminal_intent?.status === 'pending')
+                auditTask('settling', plan.task, previous, previous, plan.task.terminal_intent.accepted_at);
             const settled = plan.settlementRequired
                 ? await launchTaskSettleWorker(id, opts.configuration)
                 : { task: plan.task, timedOut: false };
             const t = settled.task;
+            auditTask('done', t, previous);
             if (opts.json) {
                 console.log(JSON.stringify({ schema_version: 1, task: t }, null, 2));
                 return;
@@ -776,13 +933,17 @@ export function registerTaskCommands(parent, cOpt) {
         try {
             if (id !== confirmId)
                 throw taskRoomPublicError('task_confirmation_mismatch');
+            const previous = getTask(id).state;
             const plan = await taskRoomService(opts.configuration).cancelTask({
                 actor: { kind: 'local_control', surface: 'cli' }, taskId: id,
             });
+            if (plan.task.terminal_intent?.status === 'pending')
+                auditTask('settling', plan.task, previous, previous, plan.task.terminal_intent.accepted_at);
             const settled = plan.settlementRequired
                 ? await launchTaskSettleWorker(id, opts.configuration)
                 : { task: plan.task, timedOut: false };
             const t = settled.task;
+            auditTask('cancel', t, previous);
             if (opts.json) {
                 console.log(JSON.stringify({ schema_version: 1, task: t }, null, 2));
                 return;
@@ -810,9 +971,16 @@ export function registerTaskCommands(parent, cOpt) {
         try {
             if (id !== confirmId)
                 throw taskRoomPublicError('task_confirmation_mismatch');
+            let prior;
+            try {
+                prior = getTask(id);
+            }
+            catch { /* idempotent already-absent delete */ }
             const deleted = taskRoomService().deleteTask({
                 actor: { kind: 'local_control', surface: 'cli' }, taskId: id,
             });
+            if (prior)
+                auditTask('delete', prior, prior.state, 'deleted');
             if (opts.json) {
                 console.log(JSON.stringify({ schema_version: 1, task_id: id, deleted }, null, 2));
                 return;
@@ -833,6 +1001,7 @@ export function registerTaskCommands(parent, cOpt) {
         .option('--json', 'JSON output')
         .action(async (id, opts) => {
         try {
+            const previous = getTask(id).state;
             const app = taskRoomService(opts.configuration);
             const actor = { kind: 'local_control', surface: 'cli' };
             const begin = await app.beginTaskRecovery({ actor, taskId: id });
@@ -843,6 +1012,7 @@ export function registerTaskCommands(parent, cOpt) {
                 })()
                 : begin.result;
             const t = recovered.task;
+            auditTask('recover', t, previous);
             const room = recovered.room;
             const recoveryActions = recovered.issues.map(issue => {
                 if (issue.code === 'terminal_pending')
@@ -992,6 +1162,7 @@ export function registerTaskCommands(parent, cOpt) {
         .option('--json', 'JSON output')
         .action(async (id, opts) => {
         try {
+            const previous = getTask(id).state;
             let summary = opts.summary;
             if (opts.summaryFile)
                 summary = readFileSync(opts.summaryFile, 'utf8');
@@ -999,10 +1170,13 @@ export function registerTaskCommands(parent, cOpt) {
             const plan = await taskRoomService(opts.configuration).finishTask({
                 actor: { kind: 'local_control', surface: 'cli' }, taskId: id, outcome,
             });
+            if (plan.task.terminal_intent?.status === 'pending')
+                auditTask('settling', plan.task, previous, previous, plan.task.terminal_intent.accepted_at);
             const settled = plan.settlementRequired
                 ? await launchTaskSettleWorker(id, opts.configuration)
                 : { task: plan.task, timedOut: false };
             const t = settled.task;
+            auditTask('finish', t, previous);
             if (opts.json) {
                 console.log(JSON.stringify({ schema_version: 1, task: t }, null, 2));
                 return;
@@ -1126,7 +1300,7 @@ export function registerRoomCommands(parent, cOpt) {
         .option('--json', 'JSON output')
         .action(async (id, opts) => {
         try {
-            const { room } = await taskRoomService(opts.configuration).getRoomDetail(id);
+            const { room, orchestration } = await taskRoomService(opts.configuration).getRoomDetail(id);
             const url = `http://localhost:4460/room/${id}`;
             if (opts.json) {
                 console.log(JSON.stringify({ schema_version: 1, room_id: id, url, room_name: room.room_name }, null, 2));
@@ -1186,10 +1360,16 @@ export function registerRoomCommands(parent, cOpt) {
         try {
             if (id !== confirmId)
                 throw taskRoomPublicError('room_confirmation_mismatch');
+            const previous = getRoomRecord(id);
             await taskRoomService(opts.configuration).requestRoomDeletion({
                 actor: { kind: 'local_control', surface: 'cli' }, roomId: id,
             });
+            const closing = getRoomRecord(id);
+            if (previous && closing && previous.state !== closing.state)
+                auditRoom('close', closing, previous.state, closing.state);
             const settled = await launchRoomDeleteWorker(id, opts.configuration);
+            if (closing)
+                auditRoom('delete', closing, closing.state, settled.deleted ? 'deleted' : 'closing');
             if (opts.json) {
                 console.log(JSON.stringify({ schema_version: 1, room_id: id, deleted: settled.deleted }, null, 2));
                 return;
@@ -1226,11 +1406,14 @@ export function registerRoomCommands(parent, cOpt) {
         .option('--json', 'JSON output')
         .action(async (id, opts) => {
         try {
+            const previous = getRoomRecord(id);
             const recovered = await taskRoomService(opts.configuration).recoverRoom({
                 actor: { kind: 'local_control', surface: 'cli' }, roomId: id,
             });
             if (recovered.kind === 'deletion_worker_required') {
                 const settled = await launchRoomDeleteWorker(id, opts.configuration);
+                if (previous)
+                    auditRoom('recover', previous, previous.state, settled.deleted ? 'deleted' : 'closing');
                 if (opts.json) {
                     console.log(JSON.stringify({
                         schema_version: 1, room: null, orchestration: null,
@@ -1251,6 +1434,8 @@ export function registerRoomCommands(parent, cOpt) {
                 return;
             }
             const { room: cowork, orchestration: r, issues: actions } = recovered;
+            if (r)
+                auditRoom('recover', r, previous?.state ?? 'unresolved', r.state);
             if (opts.json) {
                 console.log(JSON.stringify({ schema_version: 1, room: cowork, orchestration: r ?? null, recovery_actions: actions }, null, 2));
                 return;

package/dist/rooms-tasks/config.js

@@ -1,7 +1,7 @@
 import { existsSync, readFileSync } from 'node:fs';
 import { createHash } from 'node:crypto';
-import { ROOMS_KEYS as RK, ROOMS_OWNER_KEYS as ROK, ROOMS_COWORK_KEYS as RCK, ROOMS_DEFAULTS_KEYS as RDK, TASKS_KEYS as TK, TEMPLATE_KEYS as TPK, TEMPLATE_MEMBER_KEYS as TMK, TEMPLATE_OVERRIDE_KEYS as TOK, } from './types.js';
-import { BUILTIN_TEMPLATES } from './templates.js';
+import { ROOMS_KEYS as RK, ROOMS_OWNER_KEYS as ROK, ROOMS_COWORK_KEYS as RCK, ROOMS_DEFAULTS_KEYS as RDK, TASKS_KEYS as TK, TEMPLATE_KEYS as TPK, TEMPLATE_MEMBER_KEYS as TMK, } from './types.js';
+import { isSensitiveConfigKey } from '../sensitive-config.js';
 const isPlainObject = (v) => v !== null && typeof v === 'object' && !Array.isArray(v);
 const CID_RE = /^[0-9a-fA-F]{64}$/;
 export class RoomsTasksConfigError extends Error {
@@ -116,9 +116,6 @@ export function validateRoomTemplatesConfig(raw, path) {
         if (!isPlainObject(tplRaw))
             throw new RoomsTasksConfigError(path, `room_templates.${name}: must be a mapping`);
         rejectUnknown(tplRaw, [...TPK, 'name'], path, `room_templates.${name}`);
-        const isBuiltinOverride = BUILTIN_TEMPLATES.some(b => b.name === name);
-        if (isBuiltinOverride && !tplRaw.override_builtin)
-            throw new RoomsTasksConfigError(path, `room_templates.${name}: overrides built-in template; set override_builtin: true and bump version`);
         const version = tplRaw.version;
         if (version === undefined || !Number.isInteger(version) || version < 1)
             throw new RoomsTasksConfigError(path, `room_templates.${name}.version: required positive integer`);
@@ -136,19 +133,33 @@ export function validateRoomTemplatesConfig(raw, path) {
                 throw new RoomsTasksConfigError(path, `room_templates.${name}.members[${i}].role: required string`);
             if (!Number.isInteger(m.count) || m.count < 1)
                 throw new RoomsTasksConfigError(path, `room_templates.${name}.members[${i}].count: required positive integer`);
-            if (!m.role_ref || typeof m.role_ref !== 'string')
-                throw new RoomsTasksConfigError(path, `room_templates.${name}.members[${i}].role_ref: required string`);
-            if (m.overrides !== undefined) {
-                if (!isPlainObject(m.overrides))
-                    throw new RoomsTasksConfigError(path, `room_templates.${name}.members[${i}].overrides: must be a mapping`);
-                rejectUnknown(m.overrides, TOK, path, `room_templates.${name}.members[${i}].overrides`);
+            if (!isPlainObject(m.agent))
+                throw new RoomsTasksConfigError(path, `room_templates.${name}.members[${i}].agent: required mapping`);
+            const agentKeys = Object.keys(m.agent);
+            const isRef = agentKeys.length === 1 && typeof m.agent.ref === 'string';
+            const isDefinition = agentKeys.includes('role') && agentKeys.includes('brain');
+            if (!isRef && !isDefinition)
+                throw new RoomsTasksConfigError(path, `room_templates.${name}.members[${i}].agent: must be {ref} or canonical {role, brain, ...}`);
+            const containsSensitive = (value) => Array.isArray(value)
+                ? value.some(containsSensitive)
+                : Boolean(value && typeof value === 'object' && Object.entries(value)
+                    .some(([key, child]) => isSensitiveConfigKey(key) || containsSensitive(child)));
+            if (isDefinition && containsSensitive(m.agent))
+                throw new RoomsTasksConfigError(path, `room_templates.${name}.members[${i}].agent: inline sensitive configuration cannot be persisted; use references`);
+            if (isDefinition) {
+                const definition = m.agent;
+                const brain = isPlainObject(definition.brain) && isPlainObject(definition.brain.inline)
+                    ? definition.brain.inline : undefined;
+                if (definition.env !== undefined || definition.owner_channel !== undefined
+                    || definition.auth_proxy !== undefined || brain?.harness_options !== undefined
+                    || brain?.session_options !== undefined)
+                    throw new RoomsTasksConfigError(path, `room_templates.${name}.members[${i}].agent: secret-capable inline fields cannot be persisted; use references`);
             }
             return {
                 slot: m.slot,
                 role: m.role,
                 count: m.count,
-                role_ref: m.role_ref,
-                overrides: m.overrides,
+                agent: structuredClone(m.agent),
             };
         });
         let room;

package/dist/rooms-tasks/external-worker.d.ts

@@ -1,2 +1,3 @@
+export declare function fleetWorkerEnv(source?: NodeJS.ProcessEnv): Record<string, string>;
 /** Launch a Fleet CLI operation outside the caller's supervisor/session lifecycle. */
 export declare function launchFleetWorker(args: string[], operation: string, configPath?: string): Promise<void>;

package/dist/rooms-tasks/external-worker.js

@@ -1,14 +1,23 @@
 import { execFile, spawn } from 'node:child_process';
 import { randomUUID } from 'node:crypto';
-/** Launch a Fleet CLI operation outside the caller's supervisor/session lifecycle. */
-export function launchFleetWorker(args, operation, configPath) {
-    const cli = [process.argv[1], ...args, ...(configPath ? ['-c', configPath] : [])];
+import { FLEET_PROXY_CALLER_ENV, FLEET_PROXY_STATE_DIR_ENV } from '../fleet-proxy.js';
+export function fleetWorkerEnv(source = process.env) {
     const inheritedKeys = [
         'HOME', 'PATH', 'XDG_RUNTIME_DIR', 'OURS_FLEET_HOME', 'OURS_CONFIG',
         'OURS_PORT', 'OURS_STATE_DIR', 'OURS_API_TOKEN', 'OURS_COWORK_CONFIG',
     ];
-    const inherited = inheritedKeys
-        .flatMap(key => process.env[key] === undefined ? [] : [`${key}=${process.env[key]}`]);
+    const env = Object.fromEntries(inheritedKeys.flatMap(key => source[key] === undefined ? [] : [[key, source[key]]]));
+    // Explicit defense: trusted settle/recover/delete/close workers are effects
+    // nested inside the outer audited command, never fresh agent attempts.
+    delete env[FLEET_PROXY_STATE_DIR_ENV];
+    delete env[FLEET_PROXY_CALLER_ENV];
+    return env;
+}
+/** Launch a Fleet CLI operation outside the caller's supervisor/session lifecycle. */
+export function launchFleetWorker(args, operation, configPath) {
+    const cli = [process.argv[1], ...args, ...(configPath ? ['-c', configPath] : [])];
+    const env = fleetWorkerEnv();
+    const inherited = Object.entries(env).map(([key, value]) => `${key}=${value}`);
     const suffix = randomUUID().slice(0, 8);
     const safeOperation = operation.replace(/[^A-Za-z0-9_.-]/g, '-');
     return new Promise((resolve, reject) => {
@@ -29,10 +38,6 @@ export function launchFleetWorker(args, operation, configPath) {
             ], { timeout: 15_000 }, error => error ? reject(error) : resolve());
             return;
         }
-        const env = Object.fromEntries(inherited.map(value => {
-            const split = value.indexOf('=');
-            return [value.slice(0, split), value.slice(split + 1)];
-        }));
         const child = spawn(process.execPath, cli, { detached: true, stdio: 'ignore', env });
         child.once('error', reject);
         child.once('spawn', () => { child.unref(); resolve(); });