@ours.network/fleet 1.1.0-nightly.12 → 1.1.0-nightly.13

package/dist/fleet-command-audit.d.ts

@@ -1,3 +1,4 @@
+import { type AgentLaunchConfiguration } from './lifecycle-summary.js';
 export type FleetCommandDecision = 'allow' | 'deny' | 'unsupported';
 export type FleetCommandOutcomeClass = 'success' | 'validation' | 'denied' | 'runtime' | 'timeout' | 'proxy' | 'delivery';
 export declare class FleetCliExit extends Error {
@@ -21,6 +22,7 @@ export type FleetAuditPresentation = {
     parent: string;
     actionId: string;
     inherited: string[];
+    configuration?: AgentLaunchConfiguration;
 } | {
     kind: 'task';
     operation: 'create' | 'start' | 'work' | 'block' | 'unblock' | 'review' | 'done' | 'cancel' | 'finish' | 'delete' | 'settling';
@@ -38,6 +40,7 @@ export type FleetAuditPresentation = {
         brain?: string;
         role: string;
         permissions?: string;
+        configuration?: AgentLaunchConfiguration;
     }>;
 } | {
     kind: 'room';
@@ -56,6 +59,7 @@ export type FleetAuditPresentation = {
         brain?: string;
         role: string;
         permissions?: string;
+        configuration?: AgentLaunchConfiguration;
     }>;
 } | {
     kind: 'lifecycle_failure';

package/dist/fleet-command-audit.js

@@ -1,7 +1,10 @@
 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, renderAgentConfiguration, } from './lifecycle-summary.js';
+import { MARKDOWN_MAX_BYTES, MARKDOWN_MAX_CODE_POINTS, markdownCode, markdownProse, } from './rooms-tasks/markdown.js';
 export class FleetCliExit extends Error {
     exitCode;
     outcomeClass;
@@ -330,10 +333,71 @@ export function validateFleetAuditFinish(value) {
             || 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'])
+        && c.version === 1 && origin(c.role) && origin(c.brain)
+        && text(c.harness, 64) && c.session === 'acp'
+        && (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)))
+        // 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);
@@ -342,11 +406,11 @@ function validPresentation(value) {
         && allowed[p.operation]?.includes(`${String(p.previousState ?? 'none')}→${p.newState}`);
     if (p.kind === 'agent_started')
         return exact(p, ['kind', 'eventId', 'id', 'name', 'lifetime', 'brain', 'role',
-            'harness', 'session', 'model', 'permissions', 'parent', 'actionId', 'inherited'])
+            '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) && p.session === 'acp' && 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 exact(p, ['kind', 'operation', 'eventId', 'id', 'title', 'previousState',
             'newState', 'template', 'roomId', 'revision', 'list', 'agents'])
@@ -358,18 +422,24 @@ function validPresentation(value) {
                 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: ['done→deleted'], settling: ['active→active', 'review→review', 'backlog→backlog',
+                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 || text(p.title)) && (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'
-                && exact(a, ['name', 'brain', 'role', 'permissions'])
+                && exact(a, ['name', 'brain', 'role', 'permissions', 'configuration'])
                 && safe(a.name)
                 && text(a.role)
                 && (a.brain === undefined || text(a.brain))
-                && (a.permissions === undefined || text(a.permissions)));
+                && (a.permissions === undefined || text(a.permissions))
+                && configured(a));
     if (p.kind === 'room')
         return exact(p, ['kind', 'operation', 'eventId', 'id', 'previousState', 'newState',
             'revision', 'name', 'template', 'taskId', 'participants'])
@@ -383,12 +453,13 @@ function validPresentation(value) {
             && (p.taskId === undefined || safe(p.taskId)) && (p.revision === undefined || text(p.revision))
             && Array.isArray(p.participants) && p.participants.length <= 64
             && p.participants.every(a => a && typeof a === 'object'
-                && exact(a, ['name', 'id', 'brain', 'role', 'permissions'])
+                && 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)));
+                && (a.permissions === undefined || text(a.permissions))
+                && configured(a));
     if (p.kind === 'lifecycle_failure')
         return exact(p, ['kind', 'eventId', 'resource', 'id', 'state', 'category'])
             && ['Agent', 'Task', 'Room'].includes(String(p.resource))
@@ -396,6 +467,35 @@ function validPresentation(value) {
             'settlement_pending', 'cleanup_failed', 'cleanup_pending'].includes(String(p.category));
     return false;
 }
+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;
+/**
+ * Append per-agent lines to a bounded message. Lines are admitted whole, in
+ * the given (deterministic) order; once the shared Markdown bounds would be
+ * exceeded the remaining agents collapse into an accurate omission note. The
+ * first line is admitted whenever it fits the absolute bounds so an oversized
+ * roster still shows at least one complete agent summary.
+ */
+function appendAgentLines(header, heading, lines) {
+    if (!lines.length)
+        return header;
+    let message = `${header}\n${heading}:`;
+    const note = (count) => `\n…and ${count} more agent${count === 1 ? '' : 's'} omitted.`;
+    for (const [index, line] of lines.entries()) {
+        const candidate = `${message}\n- ${line}`;
+        const remaining = lines.length - index - 1;
+        // A candidate is admitted only when it fits together with the note for
+        // every agent still pending, so each stop-return below re-states a bound
+        // that was verified when the current message was admitted.
+        if (!withinMessageBounds(remaining ? `${candidate}${note(remaining)}` : candidate)) {
+            const stopped = `${message}${note(lines.length - index)}`;
+            return withinMessageBounds(stopped) ? stopped : `${header}${note(lines.length)}`;
+        }
+        message = candidate;
+    }
+    return message;
+}
 /** Compact Owner presentation. It intentionally has no command, argv, environment, or correlation data. */
 export function renderFleetLifecycleEvent(value) {
     if (value.kind === 'lifecycle_failure') {
@@ -413,25 +513,29 @@ export function renderFleetLifecycleEvent(value) {
             + `state ${value.state}. Action: ${actions[value.category]}`;
     }
     if (value.kind === 'agent_started') {
-        const permission = value.permissions ? `; permissions ${value.permissions}` : '';
+        const summary = renderAgentConfiguration(value.configuration, {
+            role: value.role, brain: value.brain, permissions: value.permissions,
+        });
         return `🧑‍💻 ${value.parent} spawned ${value.lifetime} Agent ${value.name} (${value.id}) — ready. `
-            + `Brain ${value.brain ?? 'unresolved'}; Role ${value.role ?? 'unresolved'}${permission}.`;
+            + `${summary}.`;
     }
     if (value.kind === 'task') {
-        const title = value.title ? ` “${value.title}”` : '';
-        const context = [value.list ? `List ${value.list}` : undefined,
-            value.template ? `template ${value.template}` : undefined,
+        const title = value.title ? ` “${markdownProse(value.title)}”` : '';
+        const context = [value.list ? `List ${markdownCode(value.list)}` : undefined,
+            value.template ? `template ${markdownCode(value.template)}` : undefined,
             value.roomId ? `Room ${value.roomId}` : undefined].filter(Boolean).join('; ');
-        const agents = value.agents.length ? ` Agents: ${value.agents.map(agent => `${agent.name} [Brain ${agent.brain ?? 'unresolved'}; Role ${agent.role}`
-            + `${agent.permissions ? `; permissions ${agent.permissions}` : ''}]`).join('; ')}.` : '';
-        return `📋 Task${title} (${value.id}) ${value.operation}: `
-            + `${value.previousState ?? 'none'} → ${value.newState}.${context ? ` ${context}.` : ''}${agents}`;
+        const header = `📋 Task${title} (${value.id}) ${value.operation}: `
+            + `${value.previousState ?? 'none'} → ${value.newState}.${context ? ` ${context}.` : ''}`;
+        return appendAgentLines(header, 'Agents', value.agents.map(agent => `${markdownCode(agent.name)}: ${renderAgentConfiguration(agent.configuration, {
+            role: agent.role, brain: agent.brain, permissions: agent.permissions,
+        })}`));
     }
-    const context = [value.template ? `template ${value.template}` : undefined,
+    const context = [value.template ? `template ${markdownCode(value.template)}` : undefined,
         value.taskId ? `Task ${value.taskId}` : undefined].filter(Boolean).join('; ');
-    const participants = value.participants.length ? ` Participants: ${value.participants.map(participant => `${participant.name}${participant.id ? ` (${participant.id})` : ''} [Role ${participant.role}`
-        + `${participant.brain ? `; Brain ${participant.brain}` : ''}`
-        + `${participant.permissions ? `; permissions ${participant.permissions}` : ''}]`).join('; ')}.` : '';
-    return `🏠 Room${value.name ? ` “${value.name}”` : ''} (${value.id}) ${value.operation}: `
-        + `${value.previousState ?? 'none'} → ${value.newState}.${context ? ` ${context}.` : ''}${participants}`;
+    const header = `🏠 Room${value.name ? ` “${markdownProse(value.name)}”` : ''} (${value.id}) ${value.operation}: `
+        + `${value.previousState ?? 'none'} → ${value.newState}.${context ? ` ${context}.` : ''}`;
+    return appendAgentLines(header, 'Participants', value.participants.map(participant => `${markdownCode(participant.name)}${participant.id ? ` (${participant.id})` : ''}: `
+        + renderAgentConfiguration(participant.configuration, {
+            role: participant.role, brain: participant.brain, permissions: participant.permissions,
+        })));
 }

package/dist/fleet-proxy.d.ts

@@ -1,4 +1,5 @@
 import type { MonitorConfig, ResolvedRole } 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";
@@ -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/lifecycle-summary.d.ts

@@ -0,0 +1,118 @@
+import type { AgentSelection, ApprovalMode, FilesystemMode, FleetPermissionMode, MonitorInterrupt, MonitorMode, ResolvedRole, SessionBackendId, UnattendedMode } from './config.js';
+import type { IsolationBackendId, NetworkMode, OnUnavailable } from './isolation/types.js';
+/**
+ * Operator-facing launch configuration captured at the launch boundary from
+ * the exact ResolvedRole that was spawned. It is the single source for every
+ * Fleet lifecycle/report surface (CLI and owner-channel/Messenger).
+ *
+ * Security boundary: this object is a strict whitelist. It must never carry
+ * env, cwd or any local path, harness_options, session_options, owner_channel,
+ * or auth_proxy content. Hashes are secondary provenance only, never the
+ * primary description.
+ */
+export interface AgentLaunchConfiguration {
+    version: 1;
+    /** Agent template / launch definition label when one was selected. */
+    template?: string;
+    role: SelectionOrigin;
+    brain: SelectionOrigin;
+    harness: string;
+    session: SessionBackendId;
+    /**
+     * Model observed effective at launch. `null` reports runtime behavior — the
+     * harness ran its own default — not whether the author wrote `model: null`
+     * or omitted the field; effectiveRoleModel cannot distinguish those.
+     */
+    model: string | null;
+    effort?: string;
+    /** Concise first-line mission label (or Cowork-role fallback), never the full mission. */
+    mission?: string;
+    approval: ApprovalMode;
+    filesystem: FilesystemMode;
+    unattended: UnattendedMode;
+    /** Portable policy plus the exact native runtime mode after harness_options. */
+    permissionMode: {
+        fleetMode: FleetPermissionMode;
+        nativeMode: string;
+    };
+    monitor: {
+        mode: MonitorMode;
+        interrupt: MonitorInterrupt;
+    };
+    /** Requested isolation policy only — never resolved runtime facts or host paths. */
+    isolation?: {
+        requested: IsolationBackendId;
+        on_unavailable?: OnUnavailable;
+        network?: NetworkMode;
+        read_mounts?: number;
+        write_mounts?: number;
+    };
+}
+/** Where a Brain/Role selection came from; labels are human, hashes secondary. */
+export type SelectionOrigin = {
+    kind: 'named';
+    ref: string;
+} | {
+    kind: 'inline';
+    fingerprint?: string;
+} | {
+    kind: 'unknown';
+};
+export declare const MISSION_LABEL_MAX = 80;
+/**
+ * The inline fingerprint is always computed here from the canonical inline
+ * body; provenance can never be an arbitrary caller string.
+ */
+export declare function selectionOrigin(selection: AgentSelection | undefined): SelectionOrigin;
+export declare function missionLabel(mission: string | undefined): string | undefined;
+/**
+ * Build the presentation from the exact resolved launch state. `origins`
+ * carries the authoring-time selections and template label because a merged
+ * ResolvedRole no longer distinguishes preset references from inline bodies.
+ * `permissionMode` is required at capture time: every supported harness
+ * adapter reports it, and the managed-spawn receiver gets it over the wire
+ * and must never re-resolve mutable configuration.
+ */
+export declare function summarizeResolvedLaunch(role: ResolvedRole, origins: {
+    role: SelectionOrigin;
+    brain: SelectionOrigin;
+    template?: string;
+    permissionMode: {
+        fleetMode: FleetPermissionMode;
+        nativeMode: string;
+    };
+    /** Shown when the resolved role has no mission text (e.g. Cowork role name). */
+    missionFallback?: string;
+}): AgentLaunchConfiguration;
+/**
+ * Component budget for one rendered agent line. The complete mandatory
+ * rendering must always fit — that is a validity condition of a current-v1
+ * configuration, enforced by mandatoryConfigurationFits at the builder AND
+ * the wire boundary — while optional components (monitor, isolation) are
+ * dropped whole with a visible `…` marker past this budget.
+ */
+export declare const AGENT_LINE_MAX_CODE_POINTS = 1500;
+export declare const AGENT_LINE_MAX_BYTES = 5000;
+/**
+ * Validity condition of a current-v1 configuration: its complete mandatory
+ * rendering fits the per-line budget with the optional-omission suffix
+ * reserved. Escaping and code-fence growth (a value made of backticks can
+ * more than triple its code span) make this depend on rendered size, not raw
+ * field lengths, so both summarizeResolvedLaunch and the wire validator call
+ * this instead of trusting per-field caps.
+ */
+export declare function mandatoryConfigurationFits(configuration: AgentLaunchConfiguration): boolean;
+/**
+ * Render one agent's configuration as a single escaped Markdown line segment.
+ * This is the only escaping boundary: callers pass raw values and must not
+ * escape the result again (it is safe as a markdownItems entry and inside
+ * owner-channel lifecycle messages). Every mandatory component always
+ * renders — mandatoryConfigurationFits guarantees the fit for every produced
+ * or wire-accepted configuration; only optional components may be dropped,
+ * whole (never splitting a Markdown span), with a visible `…`.
+ */
+export declare function renderAgentConfiguration(configuration: AgentLaunchConfiguration | undefined, fallback?: {
+    role?: string;
+    brain?: string;
+    permissions?: string;
+}): string;

package/dist/lifecycle-summary.js

@@ -0,0 +1,161 @@
+import { createHash } from 'node:crypto';
+import { Buffer } from 'node:buffer';
+import { canonicalJson } from './canonical-json.js';
+import { effectiveRoleModel } from './model-env.js';
+import { markdownCode, markdownProse } from './rooms-tasks/markdown.js';
+const FINGERPRINT_HEX = 12;
+export const MISSION_LABEL_MAX = 80;
+/**
+ * The inline fingerprint is always computed here from the canonical inline
+ * body; provenance can never be an arbitrary caller string.
+ */
+export function selectionOrigin(selection) {
+    if (!selection)
+        return { kind: 'unknown' };
+    if ('ref' in selection)
+        return { kind: 'named', ref: selection.ref };
+    const fingerprint = createHash('sha256').update(canonicalJson(selection.inline)).digest('hex');
+    return { kind: 'inline', fingerprint: fingerprint.slice(0, FINGERPRINT_HEX) };
+}
+export function missionLabel(mission) {
+    const line = mission?.trim().split('\n', 1)[0]?.trim();
+    if (!line)
+        return undefined;
+    const points = Array.from(line);
+    return points.length > MISSION_LABEL_MAX
+        ? `${points.slice(0, MISSION_LABEL_MAX - 1).join('')}…` : line;
+}
+/**
+ * Build the presentation from the exact resolved launch state. `origins`
+ * carries the authoring-time selections and template label because a merged
+ * ResolvedRole no longer distinguishes preset references from inline bodies.
+ * `permissionMode` is required at capture time: every supported harness
+ * adapter reports it, and the managed-spawn receiver gets it over the wire
+ * and must never re-resolve mutable configuration.
+ */
+export function summarizeResolvedLaunch(role, origins) {
+    const mission = missionLabel(role.mission) ?? missionLabel(origins.missionFallback);
+    const fs = role.isolation?.fs;
+    const configuration = {
+        version: 1,
+        ...(origins.template ? { template: origins.template } : {}),
+        role: origins.role,
+        brain: origins.brain,
+        harness: role.harness,
+        session: role.session,
+        model: effectiveRoleModel(role) ?? null,
+        ...(role.effort ? { effort: role.effort } : {}),
+        ...(mission ? { mission } : {}),
+        approval: role.permissions.approval,
+        filesystem: role.permissions.filesystem,
+        unattended: role.permissions.unattended,
+        permissionMode: origins.permissionMode,
+        monitor: { mode: role.monitor.mode, interrupt: role.monitor.interrupt },
+        ...(role.isolation?.backend ? { isolation: {
+                requested: role.isolation.backend,
+                ...(role.isolation.on_unavailable ? { on_unavailable: role.isolation.on_unavailable } : {}),
+                ...(role.isolation.network ? { network: role.isolation.network } : {}),
+                ...(fs?.read?.length ? { read_mounts: fs.read.length } : {}),
+                ...(fs?.write?.length ? { write_mounts: fs.write.length } : {}),
+            } } : {}),
+    };
+    // A configuration whose complete mandatory rendering cannot fit must never
+    // be produced; real resolved values sit far below the budget, so this is a
+    // capture defect, not an expected path.
+    if (!mandatoryConfigurationFits(configuration))
+        throw new Error('agent launch presentation exceeds the mandatory rendering budget');
+    return configuration;
+}
+/**
+ * Component budget for one rendered agent line. The complete mandatory
+ * rendering must always fit — that is a validity condition of a current-v1
+ * configuration, enforced by mandatoryConfigurationFits at the builder AND
+ * the wire boundary — while optional components (monitor, isolation) are
+ * dropped whole with a visible `…` marker past this budget.
+ */
+export const AGENT_LINE_MAX_CODE_POINTS = 1_500;
+export const AGENT_LINE_MAX_BYTES = 5_000;
+const codePoints = (value) => Array.from(value).length;
+const utf8 = (value) => Buffer.byteLength(value, 'utf8');
+const OPTIONAL_OMISSION_SUFFIX = '; …';
+function selectionComponent(kind, value) {
+    if (value.kind === 'named')
+        return `${kind} preset ${markdownCode(value.ref)}`;
+    if (value.kind === 'inline')
+        return `inline ${kind}${value.fingerprint ? ` (def ${markdownCode(value.fingerprint)})` : ''}`;
+    return `${kind} unknown`;
+}
+/**
+ * The complete mandatory rendering: template, origins, mission, harness,
+ * model, effort, portable policy triple, and fleet/native permission mode.
+ * These must never be omitted from an operator-facing line.
+ */
+function mandatoryComponents(configuration) {
+    return [
+        configuration.template ? `template ${markdownCode(configuration.template)}` : undefined,
+        selectionComponent('Role', configuration.role),
+        configuration.mission ? `mission “${markdownProse(configuration.mission)}”` : undefined,
+        selectionComponent('Brain', configuration.brain),
+        `harness ${markdownCode(configuration.harness)}`,
+        `model ${configuration.model === null ? 'harness-default' : markdownCode(configuration.model)}`,
+        configuration.effort ? `effort ${markdownProse(configuration.effort)}` : undefined,
+        `approval=${configuration.approval}, filesystem=${configuration.filesystem}, `
+            + `unattended=${configuration.unattended}`,
+        `mode ${configuration.permissionMode.fleetMode}/${markdownProse(configuration.permissionMode.nativeMode)}`,
+    ].filter((part) => Boolean(part));
+}
+function optionalComponents(configuration) {
+    return [
+        `monitor ${configuration.monitor.mode}/${String(configuration.monitor.interrupt)}`,
+        configuration.isolation
+            ? `isolation requested ${configuration.isolation.requested}`
+                + `${configuration.isolation.network ? `, net ${configuration.isolation.network}` : ''}`
+                + `${configuration.isolation.on_unavailable ? `, on-unavailable ${configuration.isolation.on_unavailable}` : ''}`
+                + `${configuration.isolation.read_mounts || configuration.isolation.write_mounts
+                    ? `, mounts +${configuration.isolation.read_mounts ?? 0}ro/+${configuration.isolation.write_mounts ?? 0}rw` : ''}`
+            : undefined,
+    ].filter((part) => Boolean(part));
+}
+/**
+ * Validity condition of a current-v1 configuration: its complete mandatory
+ * rendering fits the per-line budget with the optional-omission suffix
+ * reserved. Escaping and code-fence growth (a value made of backticks can
+ * more than triple its code span) make this depend on rendered size, not raw
+ * field lengths, so both summarizeResolvedLaunch and the wire validator call
+ * this instead of trusting per-field caps.
+ */
+export function mandatoryConfigurationFits(configuration) {
+    const reserved = `${mandatoryComponents(configuration).join('; ')}${OPTIONAL_OMISSION_SUFFIX}`;
+    return codePoints(reserved) <= AGENT_LINE_MAX_CODE_POINTS && utf8(reserved) <= AGENT_LINE_MAX_BYTES;
+}
+/**
+ * Render one agent's configuration as a single escaped Markdown line segment.
+ * This is the only escaping boundary: callers pass raw values and must not
+ * escape the result again (it is safe as a markdownItems entry and inside
+ * owner-channel lifecycle messages). Every mandatory component always
+ * renders — mandatoryConfigurationFits guarantees the fit for every produced
+ * or wire-accepted configuration; only optional components may be dropped,
+ * whole (never splitting a Markdown span), with a visible `…`.
+ */
+export function renderAgentConfiguration(configuration, fallback) {
+    if (!configuration) {
+        const labels = [
+            fallback?.role ? `Role ${markdownProse(fallback.role)}` : undefined,
+            fallback?.brain ? `Brain ${markdownProse(fallback.brain)}` : undefined,
+            fallback?.permissions ? `permissions ${markdownProse(fallback.permissions)}` : undefined,
+        ].filter(Boolean).join('; ');
+        return `legacy launch; resolved details unavailable${labels ? ` (${labels})` : ''}`;
+    }
+    let line = mandatoryComponents(configuration).join('; ');
+    let omitted = false;
+    for (const part of optionalComponents(configuration)) {
+        const next = `${line}; ${part}`;
+        if (codePoints(`${next}${OPTIONAL_OMISSION_SUFFIX}`) > AGENT_LINE_MAX_CODE_POINTS
+            || utf8(`${next}${OPTIONAL_OMISSION_SUFFIX}`) > AGENT_LINE_MAX_BYTES) {
+            omitted = true;
+            continue;
+        }
+        line = next;
+    }
+    return omitted ? `${line}${OPTIONAL_OMISSION_SUFFIX}` : line;
+}

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

@@ -284,6 +284,8 @@ export declare class OwnerChannel implements OwnerChannelHandle {
     private recoverRoomFromOwner;
     /** Carry a task terminal request through a worker that survives this role. */
     private recoverTaskFromOwner;
+    /** Accept a permanent any-state deletion, acknowledge it, then hand cleanup to a durable worker. */
+    private deleteTaskFromOwner;
     private terminalTaskFromOwner;
     /** Code-point-safe tail of the worklog, or undefined when there is none. */
     private readWorklogTail;

package/dist/owner-channel/channel.js

@@ -270,7 +270,8 @@ export class OwnerChannel {
                 lifetime: event.lifetime, brain: event.brainSummary, role: event.roleSummary,
                 harness: event.harness, session: event.session, model: event.model,
                 permissions: permission, parent: event.caller, actionId: event.creationActionId,
-                inherited: event.inherited }), `fleet-spawn\0${event.creationActionId}`, 0);
+                inherited: event.inherited,
+                ...(event.configuration ? { configuration: event.configuration } : {}) }), `fleet-spawn\0${event.creationActionId}`, 0);
         });
     }
     beginFleetCommandAudit(requestId, argv) {
@@ -1269,9 +1270,7 @@ export class OwnerChannel {
             reviewTask: taskId => new TaskRoomApplicationService(this.options.configPath).reviewTask({
                 actor: { kind: 'authenticated_owner', surface: 'messenger', cid: sender.id }, taskId,
             }),
-            deleteTask: taskId => new TaskRoomApplicationService(this.options.configPath).deleteTask({
-                actor: { kind: 'authenticated_owner', surface: 'messenger', cid: sender.id }, taskId,
-            }),
+            deleteTask: taskId => this.deleteTaskFromOwner(sender, taskId, wireId),
             listRoomQueries: filter => new TaskRoomApplicationService(this.options.configPath).listRooms(filter),
             getRoomQuery: id => new TaskRoomApplicationService(this.options.configPath).getRoomDetail(id),
             listTemplateQueries: () => new TaskRoomApplicationService(this.options.configPath).listTemplates(),
@@ -1401,10 +1400,13 @@ export class OwnerChannel {
         const app = new TaskRoomApplicationService(this.options.configPath);
         const actor = { kind: 'authenticated_owner', surface: 'messenger', cid: sender.id };
         const begin = await app.beginTaskRecovery({ actor, taskId });
-        if (begin.kind === 'terminal_worker_required') {
+        if (begin.kind !== 'final') {
+            const deleting = begin.kind === 'deletion_worker_required';
             await this.send(sender.id, renderMarkdownFailure({
                 kind: 'pending', subject: `/task recover ${taskId}`,
-                detail: 'The recovery request was accepted and is still being settled.',
+                detail: deleting
+                    ? 'The task is pending deletion; recovery continues its cleanup.'
+                    : 'The recovery request was accepted and is still being settled.',
                 action: `Run /task recover ${taskId} if it remains pending.`,
             }), wireId);
             this.state.remember(wireId);
@@ -1412,9 +1414,13 @@ export class OwnerChannel {
                 await this.fleetOps.recoverTask(taskId);
             }
             catch (error) {
-                await app.recordSettlementError({ actor, taskId,
-                    error: error instanceof Error ? error.message : String(error),
-                    recoveryHint: `External settle worker failed to start. Retry /task recover ${taskId}.` });
+                const failure = {
+                    actor, taskId, error: error instanceof Error ? error.message : String(error),
+                    recoveryHint: deleting
+                        ? `External delete worker failed to start. Retry /task delete ${taskId} ${taskId}.`
+                        : `External settle worker failed to start. Retry /task recover ${taskId}.`,
+                };
+                await (deleting ? app.recordDeletionError(failure) : app.recordSettlementError(failure));
                 throw error;
             }
             return;
@@ -1439,6 +1445,36 @@ export class OwnerChannel {
         }), wireId);
         this.state.remember(wireId);
     }
+    /** Accept a permanent any-state deletion, acknowledge it, then hand cleanup to a durable worker. */
+    async deleteTaskFromOwner(sender, taskId, wireId) {
+        const app = new TaskRoomApplicationService(this.options.configPath);
+        const actor = { kind: 'authenticated_owner', surface: 'messenger', cid: sender.id };
+        const accepted = await app.requestTaskDeletion({ actor, taskId });
+        if (accepted.status === 'already_absent') {
+            await this.send(sender.id, renderMarkdownResult({
+                icon: '🗑️', title: 'Task already absent',
+                fields: [{ label: 'ID', value: taskId, kind: 'code' }],
+            }), wireId);
+            this.state.remember(wireId);
+            return;
+        }
+        await this.send(sender.id, renderMarkdownFailure({
+            kind: 'pending', subject: `/task delete ${taskId} ${taskId}`,
+            detail: 'The deletion was accepted; cleanup is settling in the background.',
+            action: `Run /task recover ${taskId} or repeat /task delete ${taskId} ${taskId} if it remains pending.`,
+        }), wireId);
+        this.state.remember(wireId);
+        try {
+            await this.fleetOps.settleTaskDeletion(taskId);
+        }
+        catch (error) {
+            await app.recordDeletionError({
+                actor, taskId, error: error instanceof Error ? error.message : String(error),
+                recoveryHint: `External delete worker failed to start. Retry /task delete ${taskId} ${taskId}.`,
+            });
+            throw error;
+        }
+    }
     async terminalTaskFromOwner(sender, taskId, kind, outcome, wireId) {
         const app = new TaskRoomApplicationService(this.options.configPath);
         const actor = { kind: 'authenticated_owner', surface: 'messenger', cid: sender.id };