@ours.network/fleet 1.1.0-nightly.2 → 1.1.0-nightly.21

package/dist/rooms-tasks/cli.js

@@ -1,14 +1,52 @@
 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';
-import { resolveTemplate, snapshotTemplate, } from './templates.js';
-import { getTask, activateTask, TaskStateError, } from './task-state.js';
+import { resolveTemplate, sealTemplateSnapshot, snapshotTemplate, } from './templates.js';
+import { acquireLaunchSnapshotLock, releaseLaunchSnapshot } from './launch-snapshot.js';
+import { parseGroupedMemberArgs, readMembersFile } from './member-overrides.js';
+const MEMBER_ARG_FLAGS = new Set([
+    '--member', '--agent-template', '--brain', '--role', '--approval', '--filesystem', '--unattended',
+    '--cwd', '--model', '--effort', '--loops-file', '--no-loops',
+]);
+export function cliMemberOverrides(membersFile, argv = process.argv.slice(2)) {
+    const grouped = [];
+    for (let i = 0; i < argv.length; i++)
+        if (MEMBER_ARG_FLAGS.has(argv[i])) {
+            grouped.push(argv[i]);
+            if (argv[i] !== '--no-loops') {
+                grouped.push(argv[i + 1]);
+                i += 1;
+            }
+        }
+    if (membersFile && grouped.length)
+        throw new Error('--members-file cannot be combined with grouped --member options');
+    if (membersFile)
+        return readMembersFile(membersFile);
+    return grouped.length ? parseGroupedMemberArgs(grouped) : undefined;
+}
+function commandArgv(command) {
+    let root = command;
+    while (root.parent)
+        root = root.parent;
+    return root.rawArgs ?? process.argv.slice(2);
+}
+function cliAnonymousOverride(argv) {
+    const enabled = argv.includes('--anonymous');
+    const disabled = argv.includes('--no-anonymous');
+    if (enabled && disabled)
+        throw new Error('--anonymous and --no-anonymous are mutually exclusive');
+    return enabled ? true : disabled ? false : undefined;
+}
+import { getTask, getDeletingTask, activateTask, TaskStateError, } from './task-state.js';
 import { createRoomRecord, getRoomRecord, advanceSaga, setOwnerSeat, setSagaError, activateRoom, RoomStateError, } from './room-state.js';
 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';
+import { renderAgentConfiguration } from '../lifecycle-summary.js';
 class TaskRoomPublicError extends Error {
     code;
     fields;
@@ -41,7 +79,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 interactive ours-fleet init to review and create a complete default setup, 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 +127,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) {
@@ -104,7 +163,7 @@ function isKnownTaskStateMessage(message) {
         new RegExp(`^task ${SAFE_ID_WORD} is not tied to room ${SAFE_ID_WORD}$`, 'u'),
         new RegExp(`^task ${SAFE_ID_WORD} has no terminal intent$`, 'u'),
         new RegExp(`^task ${SAFE_ID_WORD} reached terminal state '${TASK_STATE_WORD}' outside its intent$`, 'u'),
-        new RegExp(`^cannot delete a '${TASK_STATE_WORD}' task; only 'done' tasks can be deleted$`, 'u'),
+        new RegExp(`^task ${SAFE_ID_WORD} is pending deletion; run 'ours-fleet task delete ${SAFE_ID_WORD} ${SAFE_ID_WORD}' to retry cleanup$`, 'u'),
     ].some(pattern => pattern.test(message));
 }
 function isKnownRoomStateMessage(message) {
@@ -127,6 +186,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 +202,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 +228,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 +237,118 @@ 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,
+        ],
+    });
+};
+/**
+ * Shared launch-configuration line for CLI member listings. Pre-upgrade seats
+ * without a captured presentation keep the minimal listing rather than
+ * claiming resolved facts. Output is already escaped (markdownItems boundary).
+ */
+function seatConfigurationSuffix(presentation) {
+    return presentation ? ` — ${renderAgentConfiguration(presentation)}` : '';
+}
+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 presentations = new Map(room?.member_seats.map(seat => [seat.role_name, seat.launch?.presentation]) ?? []);
+    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)),
+            configuration: presentations.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),
+            configuration: member.launch?.presentation })) });
+}
+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 +365,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 +381,54 @@ 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 };
+}
+/** Launch the deletion settle worker and wait boundedly for physical absence. */
+async function launchTaskDeleteWorker(taskId, configPath) {
+    const readDeletion = () => {
+        try {
+            const task = getDeletingTask(taskId);
+            return { present: true, errorAt: task.deletion?.error_at, error: task.deletion?.error };
+        }
+        catch (error) {
+            // Only proven physical absence counts as deleted; anything else propagates.
+            if (error instanceof TaskStateError && /task not found/.test(error.message))
+                return { present: false };
+            throw error;
+        }
+    };
+    const before = readDeletion();
+    if (!before.present)
+        return { deleted: true, timedOut: false };
+    try {
+        await launchFleetWorker(['task', '_settle_delete', taskId], `task-delete-${taskId}`, configPath);
+    }
+    catch (error) {
+        await taskRoomService(configPath).recordDeletionError({
+            actor: { kind: 'local_control', surface: 'cli' }, taskId, error: errorText(error),
+            recoveryHint: `External delete worker failed to start. Retry task delete ${taskId} ${taskId}.`,
+        }).catch(() => { });
+        recordFleetAuditPresentation({ kind: 'lifecycle_failure', resource: 'Task', id: taskId,
+            state: 'deleting', category: 'settlement_failed', eventId: new Date().toISOString() });
+        throw error;
+    }
+    const deadline = Date.now() + PUBLIC_SETTLE_WAIT_MS;
+    while (Date.now() < deadline) {
+        const current = readDeletion();
+        if (!current.present)
+            return { deleted: true, timedOut: false };
+        if (current.errorAt !== before.errorAt && current.error) {
+            throw new TaskStateError(current.error);
+        }
+        await sleep(PUBLIC_SETTLE_POLL_MS);
+    }
+    recordFleetAuditPresentation({ kind: 'lifecycle_failure', resource: 'Task', id: taskId,
+        state: 'deleting', category: 'settlement_pending', eventId: new Date().toISOString() });
+    return { deleted: false, timedOut: true };
 }
 async function launchRoomDeleteWorker(roomId, configPath) {
     const previousErrorAt = getRoomRecord(roomId)?.close?.error_at;
@@ -232,6 +440,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 +457,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);
@@ -271,7 +489,7 @@ function resolveRoomTemplate(cfg, name) {
     const template = resolveTemplate(name, allTemplates(cfg));
     if (!template)
         throw new Error(`template not found: ${name}`);
-    return snapshotTemplate(template);
+    return snapshotTemplate(template, cfg.agentTemplates);
 }
 function durableTaskRoomTemplate(task, room) {
     const snapshot = room.template_snapshot;
@@ -315,22 +533,36 @@ async function provisionRoom(cfg, input) {
         throw new ConfigError('rooms.owner: public_invite or public_invite_file is required when attach_owner is enabled');
     const cowork = coworkFor(cfg);
     const goal = input.goal?.trim() || input.name;
-    const briefing = input.brief?.trim() || input.template?.contract?.trim() || goal;
-    const created = await cowork.createRoom({
-        room_name: input.name,
-        goal,
-        briefing,
-        quiet_membership: input.template?.room?.quiet_membership,
-        anonymous: input.template?.room?.anonymous,
-    });
-    let record = createRoomRecord({
-        room_id: created.room_id,
-        room_name: input.name,
-        room_identity_cid: created.identity_cid,
-        task_id: input.taskId,
-        template_snapshot: input.template,
-    });
-    input.onCreated?.(record);
+    const unlockSnapshot = input.template ? acquireLaunchSnapshotLock() : undefined;
+    let launchTemplate;
+    let record;
+    try {
+        launchTemplate = input.template
+            ? sealTemplateSnapshot(input.template, cfg.agentTemplates ?? {}) : undefined;
+        const briefing = input.brief?.trim() || launchTemplate?.contract?.trim() || goal;
+        const created = await cowork.createRoom({
+            room_name: input.name,
+            goal,
+            briefing,
+            quiet_membership: launchTemplate?.room?.quiet_membership,
+            anonymous: launchTemplate?.room?.anonymous,
+        });
+        record = createRoomRecord({
+            room_id: created.room_id,
+            room_name: input.name,
+            room_identity_cid: created.identity_cid,
+            task_id: input.taskId,
+            template_snapshot: launchTemplate,
+        });
+        input.onCreated?.(record);
+    }
+    catch (error) {
+        unlockSnapshot?.();
+        if (launchTemplate?.launch_snapshot_hash)
+            releaseLaunchSnapshot(launchTemplate.launch_snapshot_hash);
+        throw error;
+    }
+    unlockSnapshot?.();
     record = advanceSaga(record.room_id, 'create_room', 1);
     if (attachOwner) {
         try {
@@ -346,21 +578,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,
-        });
+    if (launchTemplate && launchTemplate.members.length > 0) {
+        try {
+            record = await provisionMembers({
+                cfg,
+                cowork,
+                roomId: record.room_id,
+                taskId: input.taskId,
+                template: launchTemplate,
+                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 +629,11 @@ export function registerTemplateCommands(parent, cOpt) {
                 return;
             }
             if (!templates.length) {
-                console.log('No templates configured.');
+                console.log('No templates configured. Run interactive ours-fleet init to review and create a complete default setup.');
                 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 +651,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} (`
+                    + `agent template: ${m.agent_template})`);
             console.log(`\nContent hash: ${t.content_hash}`);
         }
         catch (e) {
@@ -452,17 +700,35 @@ export function registerTaskCommands(parent, cOpt) {
         .option('--brief-file <path>', 'task brief from file')
         .option('--backlog', 'create in backlog (do not start immediately)')
         .option('--no-room', 'create task without a room')
+        .option('--anonymous', 'create an anonymous Cowork room')
+        .option('--no-anonymous', 'explicitly disable template anonymous mode')
         .option('--idempotency-key <key>', 'idempotency key')
         .option('--list <name>', 'task list (default: default)')
+        .option('--members-file <path>', 'typed YAML member overrides')
+        .option('--member <slot>', 'begin a typed member override block')
+        .option('--agent-template <id>', 'Agent Template for the current member block')
+        .option('--brain <id>', 'Brain preset for the current member block')
+        .option('--role <id>', 'Role preset for the current member block')
+        .option('--approval <mode>', 'approval for the current member block')
+        .option('--filesystem <mode>', 'filesystem for the current member block')
+        .option('--unattended <mode>', 'unattended policy for the current member block')
+        .option('--cwd <path>', 'working directory for the current member block')
+        .option('--model <id>', 'model for the current member block')
+        .option('--effort <level>', 'reasoning effort for the current member block')
+        .option('--loops-file <path>', 'owner-only loops: YAML for the current temporary member')
+        .option('--no-loops', 'disable loops for the current temporary member')
         .option('--json', 'JSON output')
-        .action(async (opts) => {
+        .action(async (opts, command) => {
         try {
+            const members = cliMemberOverrides(opts.membersFile, commandArgv(command));
             const record = await taskRoomService(opts.configuration).createTask({
                 actor: { kind: 'local_control', surface: 'cli' }, title: opts.title,
                 brief: opts.brief, briefFile: opts.briefFile, template: opts.template,
                 backlog: opts.backlog, noRoom: opts.room === false,
+                anonymous: cliAnonymousOverride(commandArgv(command)),
                 idempotencyKey: opts.idempotencyKey, origin: { type: 'cli' },
                 list: opts.list,
+                members,
             });
             if (opts.json) {
                 console.log(JSON.stringify({ schema_version: 1, task: record }, null, 2));
@@ -487,7 +753,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 +779,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 +873,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,
@@ -633,7 +901,9 @@ export function registerTaskCommands(parent, cOpt) {
                 ],
                 sections: [
                     ...(t.member_roles.length ? [{
-                            heading: 'Members', markdownItems: t.member_roles.map(m => `${markdownCode(m.name)} — ${markdownProse(m.cowork_role)} — ${markdownCode(m.identity_cid)}`),
+                            heading: 'Members', markdownItems: t.member_roles.map(m => `${markdownCode(m.name)} — ${markdownProse(m.cowork_role)} — ${markdownCode(m.identity_cid)}`
+                                + seatConfigurationSuffix(room?.member_seats
+                                    .find(seat => seat.role_name === m.name)?.launch?.presentation)),
                         }] : []),
                     ...(room ? roomStartupSections(room) : []),
                 ],
@@ -646,12 +916,30 @@ export function registerTaskCommands(parent, cOpt) {
         }
     });
     cOpt(taskCmd.command('start <id>'))
-        .description('start a backlog task')
+        .description('idempotently select a plan, provision, and start a task')
+        .option('--template <name>', 'room template')
+        .option('--anonymous', 'create an anonymous Cowork room')
+        .option('--no-anonymous', 'explicitly disable template anonymous mode')
+        .option('--members-file <path>', 'typed YAML member overrides')
+        .option('--member <slot>', 'begin a typed member override block')
+        .option('--agent-template <id>', 'Agent Template for current member')
+        .option('--brain <id>', 'Brain preset for current member')
+        .option('--role <id>', 'Role preset for current member')
+        .option('--approval <mode>', 'approval for current member')
+        .option('--filesystem <mode>', 'filesystem for current member')
+        .option('--unattended <mode>', 'unattended policy for current member')
+        .option('--cwd <path>', 'working directory for current member')
+        .option('--model <id>', 'model for current member')
+        .option('--effort <level>', 'reasoning effort for current member')
+        .option('--loops-file <path>', 'owner-only loops: YAML for current member')
+        .option('--no-loops', 'disable loops for current member')
         .option('--json', 'JSON output')
-        .action(async (id, opts) => {
+        .action(async (id, opts, command) => {
         try {
             const t = await taskRoomService(opts.configuration).startTask({
                 actor: { kind: 'local_control', surface: 'cli' }, taskId: id,
+                template: opts.template, members: cliMemberOverrides(opts.membersFile, commandArgv(command)),
+                anonymous: cliAnonymousOverride(commandArgv(command)),
             });
             if (opts.json) {
                 console.log(JSON.stringify({ schema_version: 1, task: t }, null, 2));
@@ -676,9 +964,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 +986,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 +1009,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 +1033,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 +1041,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 +1075,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;
@@ -804,21 +1107,46 @@ export function registerTaskCommands(parent, cOpt) {
         }
     });
     cOpt(taskCmd.command('delete <id> <confirm-id>'))
-        .description('delete a done task from the backlog (requires ID twice for confirmation)')
+        .description('permanently delete a task in any lifecycle state (requires ID twice for confirmation)')
         .option('--json', 'JSON output')
-        .action((id, confirmId, opts) => {
+        .action(async (id, confirmId, opts) => {
         try {
             if (id !== confirmId)
                 throw taskRoomPublicError('task_confirmation_mismatch');
-            const deleted = taskRoomService().deleteTask({
+            const accepted = await taskRoomService(opts.configuration).requestTaskDeletion({
                 actor: { kind: 'local_control', surface: 'cli' }, taskId: id,
             });
+            if (accepted.status === 'already_absent') {
+                if (opts.json) {
+                    console.log(JSON.stringify({
+                        schema_version: 1, task_id: id, deleted: false, already_absent: true,
+                    }, null, 2));
+                    return;
+                }
+                console.log(renderMarkdownResult({
+                    icon: '🗑️', title: 'Task already absent',
+                    fields: [{ label: 'ID', value: id, kind: 'code' }],
+                }));
+                return;
+            }
+            const settled = await launchTaskDeleteWorker(id, opts.configuration);
             if (opts.json) {
-                console.log(JSON.stringify({ schema_version: 1, task_id: id, deleted }, null, 2));
+                console.log(JSON.stringify({
+                    schema_version: 1, task_id: id, accepted: true,
+                    deleted: settled.deleted, pending: settled.timedOut,
+                }, null, 2));
+                return;
+            }
+            if (!settled.deleted) {
+                console.log(renderMarkdownFailure({
+                    kind: 'pending', subject: `task delete ${id} ${id}`,
+                    detail: 'The deletion was accepted and cleanup is still settling.',
+                    action: `Re-run ours-fleet task delete ${id} ${id} or ours-fleet task recover ${id}.`,
+                }));
                 return;
             }
             console.log(renderMarkdownResult({
-                icon: '🗑️', title: deleted ? 'Task deleted' : 'Task already absent',
+                icon: '🗑️', title: 'Task deleted',
                 fields: [{ label: 'ID', value: id, kind: 'code' }],
             }));
         }
@@ -833,9 +1161,29 @@ 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 });
+            if (begin.kind === 'deletion_worker_required') {
+                const settled = await launchTaskDeleteWorker(id, opts.configuration);
+                const payload = { schema_version: 1, task_id: id, deleted: settled.deleted };
+                if (opts.json) {
+                    console.log(JSON.stringify(payload, null, 2));
+                    return;
+                }
+                console.log(settled.deleted
+                    ? renderMarkdownResult({
+                        icon: '🗑️', title: 'Task deletion completed by recovery',
+                        fields: [{ label: 'ID', value: id, kind: 'code' }],
+                    })
+                    : renderMarkdownFailure({
+                        kind: 'pending', subject: `task recover ${id}`,
+                        detail: 'The task is pending deletion and cleanup is still settling.',
+                        action: `Run ours-fleet task delete ${id} ${id} to retry.`,
+                    }));
+                return;
+            }
             const recovered = begin.kind === 'terminal_worker_required'
                 ? await (async () => {
                     const settled = await launchTaskSettleWorker(id, opts.configuration);
@@ -843,6 +1191,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')
@@ -913,6 +1262,35 @@ export function registerTaskCommands(parent, cOpt) {
             dieTaskRoom(e);
         }
     });
+    cOpt(taskCmd.command('_settle_delete <id>', { hidden: true }))
+        .description('internal: settle a previously accepted task deletion')
+        .option('--json', 'JSON output')
+        .action(async (id, opts) => {
+        try {
+            const app = taskRoomService(opts.configuration);
+            const result = await app.settleTaskDeletion({
+                actor: { kind: 'internal_worker', surface: 'cli' }, taskId: id,
+            });
+            if (opts.json) {
+                console.log(JSON.stringify({ schema_version: 1, ...result }, null, 2));
+                return;
+            }
+            console.log(renderMarkdownResult({
+                icon: '🗑️', title: result.deleted ? 'Task deletion settled' : 'Task already absent',
+                fields: [{ label: 'ID', value: id, kind: 'code' }],
+            }));
+        }
+        catch (e) {
+            await taskRoomService(opts.configuration).recordDeletionError({
+                actor: { kind: 'internal_worker', surface: 'cli' }, taskId: id,
+                error: errorText(e),
+                recoveryHint: `External delete worker failed. Retry task delete ${id} ${id}.`,
+            }).catch(() => { });
+            if (opts.json)
+                die(e);
+            dieTaskRoom(e);
+        }
+    });
     cOpt(taskCmd.command('_recover <id>', { hidden: true }))
         .description('internal: settle and continue task recovery')
         .option('--json', 'JSON output')
@@ -921,6 +1299,11 @@ export function registerTaskCommands(parent, cOpt) {
         const actor = { kind: 'internal_worker', surface: 'cli' };
         try {
             const begin = await app.beginTaskRecovery({ actor, taskId: id });
+            if (begin.kind === 'deletion_worker_required') {
+                const settled = await app.settleTaskDeletion({ actor, taskId: id });
+                console.log(JSON.stringify({ schema_version: 1, deletion: settled }, null, 2));
+                return;
+            }
             const result = begin.kind === 'terminal_worker_required'
                 ? await (async () => {
                     try {
@@ -945,15 +1328,35 @@ export function registerTaskCommands(parent, cOpt) {
         }
     });
     cOpt(taskCmd.command('work <id>'))
-        .description('ensure a task has a room and agents running')
+        .description('deprecated alias for task start')
         .option('--template <name>', 'room template')
+        .option('--anonymous', 'create an anonymous Cowork room')
+        .option('--no-anonymous', 'explicitly disable template anonymous mode')
+        .option('--members-file <path>', 'typed YAML member overrides')
+        .option('--member <slot>', 'begin a typed member override block')
+        .option('--agent-template <id>', 'Agent Template for current member')
+        .option('--brain <id>', 'Brain preset for current member')
+        .option('--role <id>', 'Role preset for current member')
+        .option('--approval <mode>', 'approval for current member')
+        .option('--filesystem <mode>', 'filesystem for current member')
+        .option('--unattended <mode>', 'unattended policy for current member')
+        .option('--cwd <path>', 'working directory for current member')
+        .option('--model <id>', 'model for current member')
+        .option('--effort <level>', 'reasoning effort for current member')
+        .option('--loops-file <path>', 'owner-only loops: YAML for current member')
+        .option('--no-loops', 'disable loops for current member')
         .option('--json', 'JSON output')
-        .action(async (id, opts) => {
+        .action(async (id, opts, command) => {
         try {
+            const previous = getTask(id).state;
+            console.error('warning: `fleet task work` is deprecated; use `fleet task start`');
             const result = await taskRoomService(opts.configuration).ensureTaskWork({
                 actor: { kind: 'local_control', surface: 'cli' }, taskId: id, template: opts.template,
+                members: cliMemberOverrides(opts.membersFile, commandArgv(command)),
+                anonymous: cliAnonymousOverride(commandArgv(command)),
             });
             const t = result.task;
+            auditTask('work', t, previous);
             if (result.status === 'already_active') {
                 if (opts.json) {
                     console.log(JSON.stringify({ schema_version: 1, task: t, status: 'already_active' }, null, 2));
@@ -992,6 +1395,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 +1403,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;
@@ -1032,15 +1439,32 @@ export function registerRoomCommands(parent, cOpt) {
         .description('create a standalone room')
         .requiredOption('--name <name>', 'room name')
         .option('--template <name>', 'room template')
+        .option('--anonymous', 'create an anonymous Cowork room')
+        .option('--no-anonymous', 'explicitly disable template anonymous mode')
         .option('--goal <text>', 'room goal')
         .option('--brief <text>', 'room briefing')
         .option('--brief-file <path>', 'room briefing from file')
+        .option('--members-file <path>', 'typed YAML member overrides')
+        .option('--member <slot>', 'begin a typed member override block')
+        .option('--agent-template <id>', 'Agent Template for current member')
+        .option('--brain <id>', 'Brain preset for current member')
+        .option('--role <id>', 'Role preset for current member')
+        .option('--approval <mode>', 'approval for current member')
+        .option('--filesystem <mode>', 'filesystem for current member')
+        .option('--unattended <mode>', 'unattended policy for current member')
+        .option('--cwd <path>', 'working directory for current member')
+        .option('--model <id>', 'model for current member')
+        .option('--effort <level>', 'reasoning effort for current member')
+        .option('--loops-file <path>', 'owner-only loops: YAML for current member')
+        .option('--no-loops', 'disable loops for current member')
         .option('--json', 'JSON output')
-        .action(async (opts) => {
+        .action(async (opts, command) => {
         try {
             const record = await taskRoomService(opts.configuration).createRoom({
                 actor: { kind: 'local_control', surface: 'cli' }, name: opts.name,
                 template: opts.template, goal: opts.goal, brief: opts.brief, briefFile: opts.briefFile,
+                members: cliMemberOverrides(opts.membersFile, commandArgv(command)),
+                anonymous: cliAnonymousOverride(commandArgv(command)),
             });
             if (opts.json) {
                 console.log(JSON.stringify({ schema_version: 1, room: record }, null, 2));
@@ -1109,7 +1533,9 @@ export function registerRoomCommands(parent, cOpt) {
                 ],
                 sections: [
                     ...(cowork.seats.length ? [{
-                            heading: 'Members', markdownItems: cowork.seats.map(s => `${markdownCode(s.identity_cid)} — ${markdownProse(s.role)} — ${markdownProse(s.seat_state)}`),
+                            heading: 'Members', markdownItems: cowork.seats.map(s => `${markdownCode(s.identity_cid)} — ${markdownProse(s.role)} — ${markdownProse(s.seat_state)}`
+                                + seatConfigurationSuffix(r?.member_seats
+                                    .find(seat => seat.identity_cid === s.identity_cid)?.launch?.presentation)),
                         }] : []),
                     ...(r ? roomStartupSections(r) : []),
                 ],
@@ -1126,7 +1552,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));
@@ -1171,7 +1597,9 @@ export function registerRoomCommands(parent, cOpt) {
                 ],
                 sections: [{
                         heading: 'Members',
-                        ...(members.length ? { markdownItems: members.map(s => `${markdownCode(s.identity_cid)} — ${markdownProse(s.role)} — ${markdownProse(s.seat_state)}`) }
+                        ...(members.length ? { markdownItems: members.map(s => `${markdownCode(s.identity_cid)} — ${markdownProse(s.role)} — ${markdownProse(s.seat_state)}`
+                                + seatConfigurationSuffix(r?.member_seats
+                                    .find(seat => seat.identity_cid === s.identity_cid)?.launch?.presentation)) }
                             : { items: ['No members found.'] }),
                     }],
             }));
@@ -1186,10 +1614,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 +1660,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 +1688,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;