@ours.network/fleet 1.1.0-nightly.8 → 1.1.0

package/dist/fleet-command-audit.js

@@ -1,7 +1,11 @@
 import { existsSync, readFileSync } from 'node:fs';
 import { randomUUID } from 'node:crypto';
+import { Buffer } from 'node:buffer';
 import { replaceFileAtomically } from './atomic-file.js';
 import { isSensitiveConfigKey } from './sensitive-config.js';
+import { mandatoryConfigurationFits } from './lifecycle-summary.js';
+import { MARKDOWN_MAX_BYTES, MARKDOWN_MAX_CODE_POINTS, markdownCode, markdownProse, } from './rooms-tasks/markdown.js';
+const SESSION_BACKENDS = new Set(['acp', 'codex-app-server']);
 export class FleetCliExit extends Error {
     exitCode;
     outcomeClass;
@@ -13,15 +17,91 @@ export class FleetCliExit extends Error {
         this.effect = effect;
     }
 }
+/** Commands are Owner-silent unless they record one of these semantic lifecycle kinds. */
+export const FLEET_LIFECYCLE_EVENT_KINDS = Object.freeze([
+    'agent_started', 'task', 'room', 'lifecycle_failure',
+]);
+/** Stable semantic dedupe basis: resource kind + stable resource ID + transition/action ID. */
+export function lifecycleEventDigestBasis(value) {
+    const resourceKind = value.kind === 'lifecycle_failure' ? value.resource : value.kind;
+    return `${resourceKind}\0${value.id}\0${value.eventId}`;
+}
 let collection;
-export function beginFleetAuditCollection() { collection = { resourceIds: {} }; }
+export function beginFleetAuditCollection() { collection = { resourceIds: {}, presentations: [] }; }
+let lifecycleCheckpoint;
+export function setFleetAuditLifecycleCheckpoint(checkpoint) { lifecycleCheckpoint = checkpoint; }
+/**
+ * Deliver already-recorded lifecycle events while a managed command is still
+ * running. On a failed checkpoint the events remain in the final audit batch,
+ * so a temporary Owner-channel outage loses timing, never the notice itself.
+ */
+export async function checkpointFleetAuditPresentations() {
+    if (!collection || !lifecycleCheckpoint || !collection.presentations.length)
+        return;
+    const pending = collection.presentations.splice(0);
+    try {
+        await lifecycleCheckpoint(structuredClone(pending));
+    }
+    catch {
+        collection.presentations.unshift(...pending);
+    }
+}
 export function recordFleetAuditResource(kind, id) {
     if (id && collection)
         collection.resourceIds[kind] = id;
 }
+const PRESENTATION_LABEL_MAX_CODE_POINTS = 160;
+const PRESENTATION_LABEL_MAX_BYTES = 640;
+const PRESENTATION_LABEL_CONTROLS = /[\u0000-\u001f\u007f-\u009f]/gu;
+const PRESENTATION_LABEL_SPOOFING = /[\u200b-\u200f\u202a-\u202e\u2060-\u206f\ufeff]/gu;
+/** Immutable, single-line human label captured before mutable Task/Room state can disappear. */
+export function fleetPresentationLabel(value) {
+    const normalized = String(value ?? '')
+        .replace(/\r\n?/gu, '\n')
+        .replace(PRESENTATION_LABEL_SPOOFING, '�')
+        .replace(PRESENTATION_LABEL_CONTROLS, ' ')
+        .replace(/\s+/gu, ' ')
+        .trim();
+    if (!normalized)
+        return undefined;
+    if (Array.from(normalized).length <= PRESENTATION_LABEL_MAX_CODE_POINTS
+        && Buffer.byteLength(normalized, 'utf8') <= PRESENTATION_LABEL_MAX_BYTES)
+        return normalized;
+    let bounded = '';
+    for (const point of normalized) {
+        const candidate = `${bounded}${point}…`;
+        if (Array.from(candidate).length > PRESENTATION_LABEL_MAX_CODE_POINTS
+            || Buffer.byteLength(candidate, 'utf8') > PRESENTATION_LABEL_MAX_BYTES)
+            break;
+        bounded += point;
+    }
+    return `${bounded.replace(/\s+$/u, '')}…`;
+}
 export function recordFleetAuditPresentation(value) {
-    if (collection)
-        collection.presentation = structuredClone(value);
+    if (collection && FLEET_LIFECYCLE_EVENT_KINDS.includes(value.kind)) {
+        const basis = value.eventId ?? (value.kind === 'agent_started' ? value.actionId
+            : value.kind === 'task' || value.kind === 'room'
+                ? `${value.operation}:${value.revision ?? `${value.previousState ?? 'none'}:${value.newState}`}`
+                : `${value.category}:${value.state}`);
+        const labels = value.kind === 'task'
+            ? { title: fleetPresentationLabel(value.title), roomName: fleetPresentationLabel(value.roomName),
+                reason: fleetPresentationLabel(value.reason) }
+            : value.kind === 'room'
+                ? { name: fleetPresentationLabel(value.name) }
+                : value.kind === 'lifecycle_failure'
+                    ? { label: fleetPresentationLabel(value.label) }
+                    : {};
+        const presentation = structuredClone({ ...value, ...labels, eventId: basis });
+        const digest = lifecycleEventDigestBasis(presentation);
+        if (!collection.presentations.some(existing => lifecycleEventDigestBasis(existing) === digest))
+            collection.presentations.push(presentation);
+        if (value.kind === 'task')
+            collection.resourceIds.task = value.id;
+        if (value.kind === 'room')
+            collection.resourceIds.room = value.id;
+        if (value.kind === 'agent_started')
+            collection.resourceIds.agent = value.id;
+    }
 }
 export function recordFleetAuditFailure(failure) { if (collection)
     collection.failure = failure; }
@@ -30,7 +110,7 @@ export function consumeFleetAuditCollection() {
     collection = undefined;
     return {
         ...(current && Object.keys(current.resourceIds).length ? { resourceIds: current.resourceIds } : {}),
-        ...(current?.presentation ? { presentation: current.presentation } : {}),
+        ...(current?.presentations.length ? { presentations: current.presentations } : {}),
         ...(current?.failure ? { failure: current.failure } : {}),
     };
 }
@@ -39,16 +119,19 @@ const AGENT_SURFACES = {
     spawn: new Set(['<none>']),
     template: new Set(['list', 'show', 'validate']),
     task: new Set(['create', 'list', 'lists', 'list-create', 'list-rename', 'list-delete', 'move',
-        'show', 'start', 'block', 'unblock', 'review', 'done', 'cancel', 'delete', 'recover', 'work', 'finish']),
-    room: new Set(['create', 'list', 'show', 'open', 'members', 'delete', 'close', 'recover']),
+        'show', 'start', 'block', 'unblock', 'review', 'done', 'cancel', 'delete', 'work', 'finish']),
+    room: new Set(['create', 'list', 'show', 'open', 'members', 'delete', 'close']),
 };
 export const fleetProxyCommandInventory = Object.freeze(Object.fromEntries(Object.entries(AGENT_SURFACES).map(([surface, commands]) => [surface, [...commands]])));
 const DENIED = new Set([
     'up', 'down', 'restart', 'force-restart', 'attach', 'send', 'loops', 'owner-channel',
-    'watchdog-run', 'watchdog-report', 'rm', 'init', 'web',
+    'watchdog-run', 'watchdog-report', 'rm', 'init', 'migrate-agent-templates', 'migrate-role-defaults', 'web',
 ]);
 export const fleetProxyTopLevelInventory = Object.freeze({
-    safeRead: [...SAFE_READ], agent: Object.keys(AGENT_SURFACES), denied: [...DENIED],
+    safeRead: [...SAFE_READ], agent: Object.keys(AGENT_SURFACES), public: [
+        'up', 'down', 'restart', 'force-restart', 'attach', 'send', 'loops', 'owner-channel',
+        'watchdog-run', 'watchdog-report', 'rm', 'init', 'web',
+    ], denied: [...DENIED],
     hidden: ['_run', '_run-temp', '_run-watchdog', '_run-watchdogs'], aliases: ['man'],
 });
 const globalValueOptions = new Set(['-c', '--configuration']);
@@ -92,18 +175,19 @@ export function classifyFleetArgv(argv) {
         if (sub.startsWith('_'))
             return { command: `${command} ${sub}`, route: 'supervisor-proxy/internal', decision: 'deny' };
         if (command !== 'spawn' && !AGENT_SURFACES[command].has(sub))
-            return { command: `${command} ${sub}`, route: 'supervisor-proxy/unsupported', decision: 'unsupported' };
+            return { command: `${command} ${sub}`, route: `supervisor-proxy/${command}`, decision: 'allow' };
         return { command: sub.startsWith('-') ? command : `${command} ${sub}`,
             route: `supervisor-proxy/${command}`, decision: 'allow' };
     }
-    if (DENIED.has(command))
-        return { command, route: 'supervisor-proxy/permission-denied', decision: 'deny' };
-    return { command, route: 'supervisor-proxy/unsupported', decision: 'unsupported' };
+    // The proxy is attribution and routing, not a product permission boundary.
+    // Commander validates every public command. Hidden process entry points above
+    // remain guarded because recursively invoking them breaks the supervisor protocol.
+    return { command, route: 'supervisor-proxy/public', decision: 'allow' };
 }
 const marker = (value) => value === '' ? '[REDACTED:empty]' : '[REDACTED:value]';
 const sensitiveValueFlags = new Set([
     '--identity', '--invite', '--token', '--api-token', '--password', '--password-file',
-    '--env', '--brief', '--brief-file', '--bio-file', '--persona-file', '--isolation-file',
+    '--env', '--brief', '--brief-file', '--bio-file', '--persona-file', '--isolation-file', '--loops-file',
     '--configuration', '-c', '--public-invite', '--public-invite-file', '--invite-file',
     '--summary-file', '--text', '--message', '--summary', '--reason', '--goal', '--cwd',
     '--identity-cid', '--owner-cid', '--contact-cid', '--codex-config', '--add-dir',
@@ -251,7 +335,7 @@ export class FleetCommandAuditStore {
             const prior = { class: attempt.outcome.class, effect: attempt.outcome.effect,
                 ...(attempt.outcome.exitCode === undefined ? {} : { exitCode: attempt.outcome.exitCode }),
                 ...(attempt.outcome.resourceIds ? { resourceIds: attempt.outcome.resourceIds } : {}),
-                ...(attempt.outcome.presentation ? { presentation: attempt.outcome.presentation } : {}) };
+                ...(attempt.outcome.presentations ? { presentations: attempt.outcome.presentations } : {}) };
             if (JSON.stringify(prior) !== JSON.stringify(outcome))
                 throw new Error('conflicting fleet command outcome for existing correlation');
         }
@@ -293,7 +377,7 @@ export function validateFleetAuditBegin(value) {
 }
 export function validateFleetAuditFinish(value) {
     const input = value;
-    const allowed = ['correlationId', 'class', 'exitCode', 'effect', 'resourceIds', 'presentation'];
+    const allowed = ['correlationId', 'class', 'exitCode', 'effect', 'resourceIds', 'presentations'];
     const resources = input?.resourceIds;
     if (!input || Object.keys(input).some(key => !allowed.includes(key))
         || typeof input.correlationId !== 'string' || !UUID.test(input.correlationId)
@@ -302,74 +386,353 @@ export function validateFleetAuditFinish(value) {
         || (resources !== undefined && (!resources || typeof resources !== 'object' || Array.isArray(resources)
             || Object.entries(resources).some(([key, id]) => !['agent', 'task', 'room'].includes(key)
                 || typeof id !== 'string' || !SAFE_RESOURCE_ID.test(id))))
-        || (input.presentation !== undefined && !validPresentation(input.presentation)))
+        || (input.presentations !== undefined && (!Array.isArray(input.presentations)
+            || input.presentations.length > 128 || !input.presentations.every(validPresentation))))
         throw new Error('invalid fleet audit finish fields');
 }
+const APPROVAL_MODES = new Set(['ask', 'auto', 'allow', 'deny']);
+const FILESYSTEM_MODES = new Set(['read-only', 'workspace', 'unrestricted']);
+const UNATTENDED_MODES = new Set(['deny', 'wait']);
+const FLEET_PERMISSION_MODES = new Set(['ask', 'auto', 'allow']);
+const PRESENTATION_TEXT = /[\u0000-\u001f\u007f-\u009f\u202a-\u202e\u2066-\u2069]/u;
+/**
+ * Exact-key validation of a current-version launch configuration. A partial
+ * v1 configuration is rejected; a legacy presentation simply omits the field.
+ */
+function validConfiguration(value) {
+    if (!value || typeof value !== 'object' || Array.isArray(value))
+        return false;
+    const c = value;
+    const text = (v, max = 256) => typeof v === 'string' && v.length <= max
+        && !PRESENTATION_TEXT.test(v);
+    const exact = (record, keys) => Object.keys(record).every(key => keys.includes(key));
+    const record = (v) => !!v && typeof v === 'object' && !Array.isArray(v);
+    const origin = (v) => {
+        if (!record(v))
+            return false;
+        if (v.kind === 'named')
+            return exact(v, ['kind', 'ref']) && text(v.ref, 160);
+        if (v.kind === 'inline')
+            return exact(v, ['kind', 'fingerprint'])
+                && (v.fingerprint === undefined || (typeof v.fingerprint === 'string' && /^[a-f0-9]{12}$/.test(v.fingerprint)));
+        return v.kind === 'unknown' && exact(v, ['kind']);
+    };
+    const count = (v) => v === undefined
+        || (Number.isSafeInteger(v) && Number(v) >= 0 && Number(v) <= 4_096);
+    return exact(c, ['version', 'template', 'role', 'brain', 'harness', 'session', 'model',
+        'effort', 'mission', 'approval', 'filesystem', 'unattended', 'permissionMode', 'monitor', 'isolation', 'loops'])
+        && c.version === 1 && origin(c.role) && origin(c.brain)
+        && text(c.harness, 64) && SESSION_BACKENDS.has(c.session)
+        && (c.model === null || text(c.model, 160))
+        && (c.template === undefined || text(c.template, 160))
+        && (c.effort === undefined || text(c.effort, 32))
+        // The builder caps the mission label at 80 code points; enforce the same
+        // invariant here so the per-line budget proof holds for wire input too.
+        && (c.mission === undefined || (text(c.mission) && Array.from(String(c.mission)).length <= 80))
+        && APPROVAL_MODES.has(String(c.approval))
+        && FILESYSTEM_MODES.has(String(c.filesystem))
+        && UNATTENDED_MODES.has(String(c.unattended))
+        && record(c.permissionMode)
+        && exact(c.permissionMode, ['fleetMode', 'nativeMode'])
+        && FLEET_PERMISSION_MODES.has(String(c.permissionMode.fleetMode))
+        && text(c.permissionMode.nativeMode, 160)
+        && record(c.monitor) && exact(c.monitor, ['mode', 'interrupt'])
+        && ['fleet', 'native'].includes(String(c.monitor.mode))
+        && (typeof c.monitor.interrupt === 'boolean' || c.monitor.interrupt === 'after_tool')
+        && (c.isolation === undefined || (record(c.isolation)
+            && exact(c.isolation, ['requested', 'on_unavailable', 'network', 'read_mounts', 'write_mounts'])
+            && ['auto', 'bubblewrap', 'podman', 'none'].includes(String(c.isolation.requested))
+            && (c.isolation.on_unavailable === undefined || ['warn', 'strict'].includes(String(c.isolation.on_unavailable)))
+            && (c.isolation.network === undefined || ['broker', 'deny', 'allow', 'allowlist'].includes(String(c.isolation.network)))
+            && count(c.isolation.read_mounts) && count(c.isolation.write_mounts)))
+        && (c.loops === undefined || (record(c.loops)
+            && exact(c.loops, ['source', 'policy', 'entries'])
+            && ['agent-template', 'cli', 'omitted'].includes(String(c.loops.source))
+            && c.loops.policy === 'skip-if-busy'
+            && Array.isArray(c.loops.entries) && c.loops.entries.length <= 64
+            && c.loops.entries.every(entry => record(entry)
+                && exact(entry, ['name', 'enabled', 'intervalMs', 'initialDelayMs', 'jitterMs', 'prompt'])
+                && text(entry.name, 64) && typeof entry.enabled === 'boolean'
+                && [entry.intervalMs, entry.initialDelayMs, entry.jitterMs].every(Number.isSafeInteger)
+                && record(entry.prompt) && exact(entry.prompt, ['bytes', 'sha256'])
+                && Number.isSafeInteger(entry.prompt.bytes) && Number(entry.prompt.bytes) >= 0
+                && typeof entry.prompt.sha256 === 'string' && /^[a-f0-9]{64}$/.test(entry.prompt.sha256))))
+        // Escaping and code-fence growth can push a per-field-valid configuration
+        // past the line budget; a v1 configuration whose complete mandatory
+        // rendering cannot fit is invalid, never silently trimmed.
+        && mandatoryConfigurationFits(c);
+}
 function validPresentation(value) {
     if (!value || typeof value !== 'object' || Array.isArray(value))
         return false;
     const p = value;
+    const configured = (record) => record.configuration === undefined || validConfiguration(record.configuration);
     const safe = (v) => typeof v === 'string' && SAFE_RESOURCE_ID.test(v);
     const text = (v) => typeof v === 'string' && v.length <= 256
         && !/[\u0000-\u001f\u007f-\u009f\u202a-\u202e\u2066-\u2069]/u.test(v);
+    const presentationLabel = (v) => typeof v === 'string'
+        && fleetPresentationLabel(v) === v;
+    const exact = (record, keys) => Object.keys(record).every(key => keys.includes(key));
+    const transition = (allowed) => typeof p.operation === 'string' && typeof p.newState === 'string'
+        && allowed[p.operation]?.includes(`${String(p.previousState ?? 'none')}→${p.newState}`);
     if (p.kind === 'agent_started')
-        return safe(p.name) && ['permanent', 'temporary'].includes(String(p.lifetime))
-            && text(p.brain) && text(p.role) && safe(p.harness) && p.session === 'acp' && safe(p.parent) && safe(p.actionId)
+        return exact(p, ['kind', 'eventId', 'id', 'name', 'lifetime', 'brain', 'role',
+            'harness', 'session', 'model', 'permissions', 'parent', 'actionId', 'inherited', 'configuration'])
+            && safe(p.eventId) && safe(p.id) && safe(p.name) && ['permanent', 'temporary'].includes(String(p.lifetime))
+            && text(p.brain) && text(p.role) && safe(p.harness)
+            && SESSION_BACKENDS.has(p.session) && safe(p.parent) && safe(p.actionId)
             && (p.model === undefined || text(p.model)) && (p.permissions === undefined || text(p.permissions))
-            && Array.isArray(p.inherited) && p.inherited.every(text);
+            && Array.isArray(p.inherited) && p.inherited.every(text) && configured(p);
     if (p.kind === 'task')
-        return safe(p.operation) && safe(p.id) && safe(p.newState)
-            && (p.title === undefined || text(p.title)) && (p.previousState === undefined || safe(p.previousState))
+        return exact(p, ['kind', 'operation', 'eventId', 'id', 'title', 'previousState',
+            'newState', 'template', 'roomId', 'roomName', 'reason', 'revision', 'list', 'agents'])
+            && ['create', 'start', 'work', 'block', 'unblock', 'review', 'done',
+                'cancel', 'finish', 'delete', 'settling'].includes(String(p.operation)) && safe(p.eventId) && safe(p.id) && safe(p.newState)
+            && transition({ create: ['none→backlog', 'none→provisioning', 'none→active'],
+                start: ['backlog→provisioning'], work: ['provisioning→active'],
+                block: ['backlog→backlog', 'provisioning→provisioning', 'active→active', 'review→review'],
+                unblock: ['backlog→backlog', 'provisioning→provisioning', 'active→active', 'review→review'],
+                review: ['active→review'], done: ['review→done'], finish: ['active→done', 'review→done'],
+                cancel: ['backlog→cancelled', 'provisioning→cancelled', 'active→cancelled', 'review→cancelled'],
+                delete: [
+                    'backlog→deleting', 'provisioning→deleting', 'active→deleting', 'review→deleting',
+                    'done→deleting', 'cancelled→deleting', 'failed→deleting',
+                    'backlog→deleted', 'provisioning→deleted', 'active→deleted', 'review→deleted',
+                    'done→deleted', 'cancelled→deleted', 'failed→deleted',
+                ], settling: ['active→active', 'review→review', 'backlog→backlog',
+                    'provisioning→provisioning'] })
+            && (p.title === undefined || presentationLabel(p.title))
+            && (p.roomName === undefined || presentationLabel(p.roomName))
+            && (p.reason === undefined || presentationLabel(p.reason))
+            && (p.previousState === undefined || safe(p.previousState))
             && (p.template === undefined || text(p.template)) && (p.roomId === undefined || safe(p.roomId))
+            && (p.list === undefined || text(p.list)) && (p.revision === undefined || text(p.revision))
             && Array.isArray(p.agents) && p.agents.length <= 64
-            && p.agents.every(a => a && typeof a === 'object' && safe(a.name)
+            && p.agents.every(a => a && typeof a === 'object'
+                && exact(a, ['name', 'brain', 'role', 'permissions', 'configuration'])
+                && safe(a.name)
                 && text(a.role)
-                && (a.brain === undefined || text(a.brain)));
+                && (a.brain === undefined || text(a.brain))
+                && (a.permissions === undefined || text(a.permissions))
+                && configured(a));
     if (p.kind === 'room')
-        return safe(p.operation) && safe(p.id) && safe(p.newState)
+        return exact(p, ['kind', 'operation', 'eventId', 'id', 'previousState', 'newState',
+            'revision', 'name', 'template', 'taskId', 'anonymous', 'memberCount', 'ownerAttached', 'participants'])
+            && ['create', 'activate', 'close', 'delete'].includes(String(p.operation))
+            && safe(p.eventId) && safe(p.id) && safe(p.newState)
+            && transition({ create: ['none→provisioning'], activate: ['provisioning→active'],
+                close: ['active→closing', 'provisioning→closing'],
+                delete: ['closing→deleted'] })
             && (p.previousState === undefined || safe(p.previousState))
-            && (p.template === undefined || text(p.template))
+            && (p.name === undefined || presentationLabel(p.name)) && (p.template === undefined || text(p.template))
+            && (p.taskId === undefined || safe(p.taskId)) && (p.revision === undefined || text(p.revision))
+            && (p.anonymous === undefined || typeof p.anonymous === 'boolean')
+            && (p.ownerAttached === undefined || typeof p.ownerAttached === 'boolean')
+            && (p.memberCount === undefined || (Number.isSafeInteger(p.memberCount)
+                && Number(p.memberCount) >= 0 && Number(p.memberCount) <= 64))
             && Array.isArray(p.participants) && p.participants.length <= 64
-            && p.participants.every(a => a && typeof a === 'object' && safe(a.name)
-                && text(a.role));
+            && p.participants.every(a => a && typeof a === 'object'
+                && exact(a, ['name', 'id', 'brain', 'role', 'permissions', 'configuration'])
+                && safe(a.name)
+                && text(a.role)
+                && (a.id === undefined || safe(a.id))
+                && (a.brain === undefined || text(a.brain))
+                && (a.permissions === undefined || text(a.permissions))
+                && configured(a));
+    if (p.kind === 'lifecycle_failure')
+        return exact(p, ['kind', 'eventId', 'resource', 'id', 'label', 'state', 'category'])
+            && ['Agent', 'Task', 'Room'].includes(String(p.resource))
+            && safe(p.eventId) && safe(p.id) && safe(p.state)
+            && (p.label === undefined || presentationLabel(p.label))
+            && ['provision_failed', 'provision_pending', 'readiness_failed', 'settlement_failed',
+                'settlement_pending', 'cleanup_failed', 'cleanup_pending'].includes(String(p.category));
     return false;
 }
-export function renderFleetAuditInvocation(attempt) {
-    return ['🧾 Fleet command invoked', `Correlation: ${attempt.correlationId}`, `Agent: ${attempt.caller}`,
-        `Route: ${attempt.classification.route}`, `Fleet action: ${attempt.classification.command}`,
-        `Decision: ${attempt.classification.decision}`, `Invoked: ${attempt.invokedAt}`,
-        `Raw argv (redacted): ${JSON.stringify(attempt.argv)}`].join('\n');
+export function validateFleetAuditPresentations(value) {
+    if (!Array.isArray(value) || value.length < 1 || value.length > 128
+        || !value.every(validPresentation))
+        throw new Error('invalid Fleet lifecycle presentations');
+}
+const messageCodePoints = (value) => Array.from(value).length;
+const messageBytes = (value) => Buffer.byteLength(value, 'utf8');
+const withinMessageBounds = (value) => messageCodePoints(value) <= MARKDOWN_MAX_CODE_POINTS && messageBytes(value) <= MARKDOWN_MAX_BYTES;
+function titleCase(value) {
+    return value ? `${value[0].toUpperCase()}${value.slice(1)}` : value;
+}
+function commaInteger(value) {
+    return String(value).replace(/\B(?=(\d{3})+(?!\d))/g, ',');
+}
+function renderStructuredMessage(headline, fields, action) {
+    return `${headline}`
+        + fields.map(([label, value]) => `\n- **${label}:** ${value}`).join('')
+        + (action ? `\n\n${action}` : '');
+}
+function structuredMessage(headline, fields, action) {
+    const visible = fields.filter((field) => field[1] !== undefined);
+    const render = (selected) => renderStructuredMessage(headline, selected, action);
+    const complete = render(visible);
+    if (withinMessageBounds(complete))
+        return complete;
+    const marker = ['Details omitted', 'Additional lifecycle details'];
+    const selected = [];
+    for (const field of visible) {
+        if (!withinMessageBounds(render([...selected, field, marker])))
+            break;
+        selected.push(field);
+    }
+    const bounded = render([...selected, marker]);
+    if (!withinMessageBounds(bounded))
+        throw new Error('mandatory lifecycle presentation exceeds message bounds');
+    return bounded;
+}
+function originFields(label, origin) {
+    if (origin.kind === 'named')
+        return [[label, `Preset ${markdownCode(origin.ref)}`]];
+    if (origin.kind === 'inline')
+        return [
+            [label, 'Inline definition'],
+            ...(origin.fingerprint ? [[`${label} fingerprint`, markdownCode(origin.fingerprint)]] : []),
+        ];
+    return [[label, 'Unknown']];
 }
-export function renderFleetAuditOutcome(attempt) {
-    if (!attempt.outcome)
-        throw new Error('fleet command audit outcome is absent');
-    return ['🧾 Fleet command outcome', `Correlation: ${attempt.correlationId}`, `Agent: ${attempt.caller}`,
-        `Route: ${attempt.classification.route}`, `Fleet action: ${attempt.classification.command}`,
-        `Result: ${attempt.outcome.class}`, `Effect: ${attempt.outcome.effect}`,
-        ...(attempt.outcome.exitCode === undefined ? [] : [`Exit: ${attempt.outcome.exitCode}`]),
-        ...Object.entries(attempt.outcome.resourceIds ?? {}).sort(([a], [b]) => a.localeCompare(b))
-            .map(([kind, id]) => `${kind[0]?.toUpperCase()}${kind.slice(1)} ID: ${id}`),
-        `Completed: ${attempt.outcome.completedAt}`, `Raw argv (redacted): ${JSON.stringify(attempt.argv)}`,
-        ...renderPresentation(attempt.outcome.presentation)].join('\n');
+function interruptSummary(value) {
+    return value === false ? 'off' : value === true ? 'on' : markdownProse(value);
 }
-function renderPresentation(value) {
-    if (!value)
-        return [];
-    if (value.kind === 'agent_started')
-        return ['Structured result: Agent started', `Agent: ${value.name}`,
-            `Brain: ${value.brain}`, `Role: ${value.role}`,
-            `Runtime: ${value.harness}/${value.session}${value.model ? ` model=${value.model}` : ''}`,
-            ...(value.permissions ? [`Permissions: ${value.permissions}`] : []), `Parent: ${value.parent}`,
-            `Agent action ID: ${value.actionId}`,
-            `Inheritance: ${value.inherited.length ? value.inherited.join(', ') : 'none'}`];
-    if (value.kind === 'task')
-        return ['Structured result: Task', `Operation: ${value.operation}`,
-            `Task: ${value.title ? `${value.title} (` : ''}${value.id}${value.title ? ')' : ''}`,
-            `Status: ${value.previousState ?? 'unresolved'} -> ${value.newState}`,
-            ...(value.template ? [`Template: ${value.template}`] : []), ...(value.roomId ? [`Room: ${value.roomId}`] : []),
-            `Responsible Agents: ${value.agents.length ? value.agents.map(a => `${a.name} [Brain ${a.brain ?? 'unresolved'}; Role ${a.role}]`).join('; ') : 'none'}`];
-    return ['Structured result: Room', `Operation: ${value.operation}`, `Room: ${value.id}`,
-        `Status: ${value.previousState ?? 'unresolved'} -> ${value.newState}`,
-        ...(value.template ? [`Template: ${value.template}`] : []),
-        `Participants: ${value.participants.length ? value.participants.map(a => `${a.name} [Role ${a.role}]`).join('; ') : 'none'}`];
+function agentConfigurationFieldGroups(configuration) {
+    const optional = [
+        [['Monitor mode', markdownProse(configuration.monitor.mode)],
+            ['Interrupt', interruptSummary(configuration.monitor.interrupt)]],
+    ];
+    if (configuration.isolation)
+        optional.push([
+            ['Isolation', markdownProse(configuration.isolation.requested)],
+            ['Network', configuration.isolation.network ? markdownProse(configuration.isolation.network) : undefined],
+            ['If unavailable', configuration.isolation.on_unavailable
+                    ? configuration.isolation.on_unavailable === 'strict' ? 'Fail' : 'Warn' : undefined],
+            ['Read-only mounts', String(configuration.isolation.read_mounts ?? 0)],
+            ['Read-write mounts', String(configuration.isolation.write_mounts ?? 0)],
+        ]);
+    for (const entry of configuration.loops?.entries ?? [])
+        optional.push([
+            ['Loop', markdownCode(entry.name)],
+            ['Loop status', entry.enabled ? 'Enabled' : 'Disabled'],
+            ['Loop interval', `${commaInteger(entry.intervalMs)} ms`],
+            ['Loop delay', `${commaInteger(entry.initialDelayMs)} ms`],
+            ['Loop jitter', `${commaInteger(entry.jitterMs)} ms`],
+            ['Loop prompt size', `${entry.prompt.bytes} B`],
+            ['Loop prompt hash', markdownCode(entry.prompt.sha256.slice(0, 12))],
+        ]);
+    return { mandatory: [
+            ['Template', configuration.template ? markdownCode(configuration.template) : undefined],
+            ...originFields('Role', configuration.role),
+            ['Mission', configuration.mission ? `“${markdownProse(configuration.mission)}”` : undefined],
+            ...originFields('Brain', configuration.brain),
+            ['Harness', markdownCode(configuration.harness)],
+            ['Model', configuration.model === null ? 'Harness default' : markdownCode(configuration.model)],
+            ['Effort', configuration.effort ? markdownProse(configuration.effort) : undefined],
+            ['Approval', markdownProse(configuration.approval)],
+            ['Filesystem', markdownProse(configuration.filesystem)],
+            ['Wait', markdownProse(configuration.unattended)],
+            ['Fleet mode', markdownProse(configuration.permissionMode.fleetMode)],
+            ['Native mode', markdownProse(configuration.permissionMode.nativeMode)],
+        ], optional, tail: [
+            ['Loop policy', configuration.loops ? 'Skip if busy' : undefined],
+            ['Loop source', configuration.loops
+                    ? markdownProse(configuration.loops.source.replace(/-/g, ' ')) : undefined],
+        ] };
+}
+function boundedAgentMessage(headline, prefix, optionalGroups, suffix, action) {
+    const visible = (fields) => fields.filter((field) => field[1] !== undefined);
+    const requiredPrefix = visible(prefix);
+    const requiredSuffix = visible(suffix);
+    const groups = optionalGroups.map(visible).filter(group => group.length > 0);
+    const marker = ['Details omitted', 'Additional optional Agent configuration'];
+    const render = (optional, omitted) => renderStructuredMessage(headline, [...requiredPrefix, ...optional, ...(omitted ? [marker] : []), ...requiredSuffix], action);
+    const all = groups.flat();
+    const complete = render(all, false);
+    if (withinMessageBounds(complete))
+        return complete;
+    const included = [];
+    for (const group of groups) {
+        const candidate = render([...included, ...group], true);
+        if (!withinMessageBounds(candidate))
+            break;
+        included.push(...group);
+    }
+    const bounded = render(included, true);
+    if (!withinMessageBounds(bounded))
+        throw new Error('mandatory Agent presentation exceeds message bounds');
+    return bounded;
+}
+/** Compact Owner presentation. It intentionally has no command, argv, environment, or correlation data. */
+export function renderFleetLifecycleEvent(value) {
+    if (value.kind === 'lifecycle_failure') {
+        const label = markdownProse(value.label ?? value.id);
+        if (value.category === 'provision_failed')
+            return structuredMessage(`⚠️ Couldn’t prepare ${value.resource} “${label}”`, [['Status', 'Provisioning failed'], ['Resource', value.resource], [`${value.resource} ID`, markdownCode(value.id)]], `**Next:** Check the Fleet service logs, correct the configuration, then run the same ${value.resource === 'Room' ? 'create' : 'start'} command again.`);
+        if (value.category === 'provision_pending')
+            return structuredMessage(`⏳ ${value.resource} “${label}” is still getting ready`, [['Status', 'Waiting for Agents'], ['Resource', value.resource], [`${value.resource} ID`, markdownCode(value.id)]], value.resource === 'Task'
+                ? `**Next:** Check member readiness, then run ${markdownCode(`task start ${value.id}`)}.`
+                : '**Next:** Check member readiness, then repeat the same Room command.');
+        if (value.category === 'readiness_failed')
+            return structuredMessage(`⚠️ Agent didn’t become ready: ${label}`, [['Status', 'Readiness failed'], ['Agent ID', markdownCode(value.id)]], '**Next:** Check the Agent log, correct its configuration, then create it again.');
+        if (value.resource === 'Task')
+            return structuredMessage(`⚠️ Task cleanup is incomplete: ${label}`, [['Status', 'Finish pending'], ['Task ID', markdownCode(value.id)]], '**Next:** Check the Fleet service logs, then repeat the same `done`, `finish`, or `cancel` command.');
+        return structuredMessage(`⚠️ Room cleanup is incomplete: ${label}`, [['Status', 'Deletion pending'], ['Room ID', markdownCode(value.id)]], '**Next:** Check the Fleet service logs, then repeat the same confirmed Room delete command.');
+    }
+    if (value.kind === 'agent_started') {
+        const prefix = [
+            ['Started by', markdownProse(value.parent)],
+            ['Lifetime', titleCase(value.lifetime)],
+        ];
+        if (value.configuration) {
+            const configuration = agentConfigurationFieldGroups(value.configuration);
+            return boundedAgentMessage(`🚀 Agent launched: ${markdownProse(value.name)}`, [...prefix, ...configuration.mandatory], configuration.optional, [...configuration.tail, ['Agent ID', markdownCode(value.id)]], 'Launch was accepted; harness and room-seat readiness converge separately.');
+        }
+        return structuredMessage(`🚀 Agent launched: ${markdownProse(value.name)}`, [...prefix,
+            ['Resolved details', 'Unavailable'],
+            ['Role', markdownProse(value.role)],
+            ['Brain', markdownProse(value.brain)],
+            ...(value.permissions ? [['Permissions', markdownProse(value.permissions)]] : []),
+            ['Agent ID', markdownCode(value.id)]], 'Launch was accepted; harness and room-seat readiness converge separately.');
+    }
+    if (value.kind === 'task') {
+        const title = markdownProse(value.title ?? value.id);
+        const id = markdownCode(value.id);
+        const list = value.list ? markdownProse(value.list) : undefined;
+        if (value.operation === 'create' && value.newState === 'backlog')
+            return structuredMessage('✅ Task added to Backlog', [['Task', `“${title}”`], ['Task ID', id], ['List', list],
+                ['Template', value.template ? markdownCode(value.template) : undefined]]);
+        if (value.operation === 'create' || value.operation === 'start' || value.operation === 'work')
+            return structuredMessage(`🚀 Task started: ${title}`, [['Status', 'Active'], ['List', list], ['Room', value.roomId
+                        ? markdownProse(value.roomName ?? value.roomId) : undefined],
+                ['Room ID', value.roomId ? markdownCode(value.roomId) : undefined],
+                ['Team', `${value.agents.length} Agent${value.agents.length === 1 ? '' : 's'} ready`], ['Task ID', id]], 'The task room and its Agents are ready to work.');
+        if (value.operation === 'block')
+            return structuredMessage(`⛔ Task blocked: ${title}`, [['Status', titleCase(value.newState)], ['Blocked', 'Yes'],
+                ['Reason', value.reason ? markdownProse(value.reason) : undefined], ['Task ID', id]]);
+        if (value.operation === 'unblock')
+            return structuredMessage(`✅ Task unblocked: ${title}`, [['Status', titleCase(value.newState)], ['Task ID', id]]);
+        if (value.operation === 'review')
+            return structuredMessage(`🔎 Task ready for review: ${title}`, [['List', list], ['Task ID', id]]);
+        if (value.operation === 'done' || value.operation === 'finish')
+            return structuredMessage(`🎉 Task completed: ${title}`, [['Status', 'Done'], ['List', list], ['Task ID', id]], 'The task room and temporary Agents have been cleaned up.');
+        if (value.operation === 'cancel')
+            return structuredMessage(`🚫 Task cancelled: ${title}`, [['Status', 'Cancelled'], ['List', list], ['Task ID', id]], 'The task room and temporary Agents have been cleaned up.');
+        if (value.operation === 'delete' && value.newState === 'deleting')
+            return structuredMessage(`🗑️ Task deletion started: ${title}`, [['Current status', 'Deleting'], ['Task ID', id]], 'Fleet is removing the linked room and temporary Agents in the background.');
+        if (value.operation === 'delete')
+            return structuredMessage(`🗑️ Task deleted: ${title}`, [['Task ID', id]], 'Temporary Agents were cleaned up.');
+        return structuredMessage(`⚠️ Task cleanup is incomplete: ${title}`, [['Status', 'Finish pending'], ['Task ID', id]], '**Next:** Check the Fleet service logs, then repeat the same `done`, `finish`, or `cancel` command.');
+    }
+    const name = markdownProse(value.name ?? value.id);
+    if (value.operation === 'activate')
+        return structuredMessage(`🏠 Room ready: ${name}`, [['Status', 'Active'], ['Template', value.template ? markdownCode(value.template) : undefined],
+            ['Team', `${value.memberCount ?? value.participants.length} Agent${(value.memberCount ?? value.participants.length) === 1 ? '' : 's'} ready`],
+            ['Room ID', markdownCode(value.id)]]);
+    if (value.operation === 'delete')
+        return structuredMessage(`🗑️ Room deleted: ${name}`, [['Room ID', markdownCode(value.id)]], 'Temporary Agents were cleaned up.');
+    if (value.operation === 'close')
+        return structuredMessage(`🗑️ Room deletion started: ${name}`, [['Current status', 'Deleting'], ['Room ID', markdownCode(value.id)]]);
+    return structuredMessage(`⏳ Room “${name}” is still getting ready`, [['Status', 'Waiting for Agents'], ['Resource', 'Room'], ['Room ID', markdownCode(value.id)]], '**Next:** Check member readiness, then repeat the same Room command.');
 }

package/dist/fleet-proxy.d.ts

@@ -1,4 +1,5 @@
-import type { MonitorConfig, ResolvedRole } from './config.js';
+import type { MonitorConfig, ResolvedRole, SessionBackendId } from './config.js';
+import type { AgentLaunchConfiguration } from './lifecycle-summary.js';
 import type { SpawnOpts } from './spawn.js';
 /** Present only inside a managed role process. The CLI treats it as a routing hint, not authority. */
 export declare const FLEET_PROXY_STATE_DIR_ENV = "OURS_FLEET_PROXY_STATE_DIR";
@@ -9,7 +10,7 @@ export interface ManagedFleetSpawnResult {
     lifetime: 'permanent' | 'temporary';
     statePath: string;
     harness: string;
-    session: 'acp';
+    session: SessionBackendId;
     model?: string;
     monitor: Pick<MonitorConfig, 'mode' | 'interrupt'>;
     /** Adapter-resolved portable policy and exact native runtime mode. */
@@ -21,6 +22,8 @@ export interface ManagedFleetSpawnResult {
     creationActionId: string;
     brainSummary: string;
     roleSummary: string;
+    /** Launch configuration captured from the exact resolved role; absent only from pre-upgrade daemons. */
+    configuration?: AgentLaunchConfiguration;
 }
 /**
  * Fill only omitted spawn settings from the live caller. Explicit agent choices

package/dist/harness/claude-code-session.js

@@ -21,7 +21,8 @@ export class ClaudeCodeAgentSessionAdapter {
     start(options) {
         const { role, prep, launch } = options;
         return this.transport({
-            name: role.name, argv: launch.argv, cwd: options.cwd, env: launch.env,
+            name: role.name, harness: role.harness,
+            argv: launch.argv, cwd: options.cwd, env: launch.env,
             stateDir: options.stateDir, mode: options.mode, permissions: options.permissions,
             modeId: this.strategy.permissionModeId(role),
             mcpServers: this.strategy.mcpServers(role),