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

package/dist/session/control.d.ts

@@ -9,7 +9,7 @@ export interface ControlRequest {
     version: 1 | 2 | 3;
     id: string;
     token: string;
-    command: 'status' | 'snapshot' | 'submit_prompt' | 'respond_permission' | 'interrupt' | 'follow' | 'events_since' | 'owner_channel_manage' | 'loop_status' | 'loop_run_now' | 'loop_disable' | 'loop_enable' | 'reload_config' | 'conversation_page' | 'conversation_follow' | 'submit_prompt_v2' | 'interrupt_v2' | 'respond_permission_v2' | 'fleet_spawn' | 'fleet_audit_begin' | 'fleet_audit_finish';
+    command: 'status' | 'snapshot' | 'submit_prompt' | 'respond_permission' | 'interrupt' | 'follow' | 'events_since' | 'owner_channel_manage' | 'loop_status' | 'loop_run_now' | 'loop_disable' | 'loop_enable' | 'reload_config' | 'conversation_page' | 'conversation_follow' | 'submit_prompt_v2' | 'interrupt_v2' | 'respond_permission_v2' | 'fleet_spawn' | 'fleet_audit_begin' | 'fleet_audit_present' | 'fleet_audit_finish';
     text?: string;
     permissionId?: string;
     optionId?: string;

package/dist/session/control.js

@@ -3,7 +3,7 @@ import { chmodSync, existsSync, readFileSync, rmSync, writeFileSync } from 'node
 import { createConnection, createServer } from 'node:net';
 import { join } from 'node:path';
 import { SessionControlError } from './types.js';
-import { validateFleetAuditBegin, validateFleetAuditFinish, } from '../fleet-command-audit.js';
+import { validateFleetAuditBegin, validateFleetAuditFinish, validateFleetAuditPresentations, } from '../fleet-command-audit.js';
 import { interruptSession, queueSessionPrompt, respondSessionPermission, respondSessionPermissionV2, } from '../application/session-mutations.js';
 const MAX_LINE_BYTES = 64 * 1024;
 /** Commands that require protocol version 3. */
@@ -236,6 +236,9 @@ export class RoleControlServer {
                             features: [
                                 'events_since', 'observer_follow', 'retained_range',
                                 ...(this.session.conversationPage ? ['conversation_v3'] : []),
+                                ...(this.session.capabilities?.steering ? ['steering'] : []),
+                                ...(this.session.capabilities?.permissions ? ['permissions'] : []),
+                                ...(this.session.capabilities?.messagePhases ? ['message_phases'] : []),
                             ],
                         },
                     });
@@ -346,6 +349,19 @@ export class RoleControlServer {
                     this.write(socket, { version: 1, id: request.id, ok: true, result });
                     return;
                 }
+                case 'fleet_audit_present': {
+                    if (!this.fleetAuditor)
+                        throw new SessionControlError('rejected', 'fleet auditing is unavailable');
+                    try {
+                        validateFleetAuditPresentations(request.audit?.presentations);
+                    }
+                    catch {
+                        throw new SessionControlError('rejected', 'valid Fleet lifecycle presentations are required');
+                    }
+                    await this.fleetAuditor.present(request.audit.presentations);
+                    this.write(socket, { version: 1, id: request.id, ok: true, result: { delivered: true } });
+                    return;
+                }
                 case 'owner_channel_manage': {
                     if (!request.ownerChannel || typeof request.ownerChannel.action !== 'string')
                         throw new SessionControlError('rejected', 'owner-channel management action is required');

package/dist/session/conversation-types.d.ts

@@ -1,14 +1,14 @@
 import type { PromptOrigin, TurnCancellationSource, TurnOutcome } from './types.js';
 /**
- * Durable conversation domain schema for the ACP web console.
+ * Durable conversation domain schema for managed-session consoles.
  *
  * `SessionEvent` in ./types.js remains the compact diagnostic projection; the
  * types here describe the durable per-role conversation ledger. Nothing in this
- * file touches the wire: ACP updates are reduced into these shapes by the
- * normalizer, and the store assigns `seq`/`eventId`/timestamps.
+ * file touches the wire: transport updates are reduced into these shapes by a
+ * session adapter, and the store assigns `seq`/`eventId`/timestamps.
  */
 export type ConversationEventKind = 'prompt.admitted' | 'prompt.started' | 'prompt.interrupt_requested' | 'message.chunk' | 'message.replace' | 'thought.chunk' | 'thought.replace' | 'plan.replace' | 'tool.upsert' | 'tool.content_chunk' | 'permission.requested' | 'permission.resolved' | 'monitor.delivery' | 'usage.updated' | 'turn.state' | 'turn.completed' | 'session.state' | 'session.info' | 'capabilities.updated' | 'error'
-/** A well-formed ACP update this version cannot represent. Bounded, never a crash. */
+/** A well-formed transport update this version cannot represent. Bounded, never a crash. */
  | 'unsupported';
 /** Where a conversation record came from. Typed provenance, never prompt text. */
 export type ConversationSource = 'owner_admin_console' | 'owner_channel' | 'fleet_monitor' | 'scheduled_loop' | 'startup' | 'local_console' | 'agent' | 'agent_replay';

package/dist/session/types.d.ts

@@ -33,7 +33,7 @@ export type PromptOrigin = {
     commandId: string;
 };
 export interface RuntimeSelectorMetadata {
-    /** Exact provider/model identifier reported by the live ACP session. */
+    /** Exact provider/model identifier reported by the live managed session. */
     value: string;
     /** Complete provider-supplied label for that exact value, when available. */
     label?: string;
@@ -75,6 +75,8 @@ export interface TurnResult {
 export type ControlFailureKind = 'offline' | 'control-unavailable' | 'timeout' | 'rejected' | 'backend';
 /** Stable body-free reason shared by ACP recovery and durable ingress. */
 export declare const ACP_CANCEL_DEADLINE_EXCEEDED = "ACP_CANCEL_DEADLINE_EXCEEDED";
+/** Native Codex equivalent; kept distinct so diagnostics name the failing transport. */
+export declare const CODEX_APP_SERVER_CANCEL_DEADLINE_EXCEEDED = "CODEX_APP_SERVER_CANCEL_DEADLINE_EXCEEDED";
 export declare class SessionControlError extends Error {
     readonly kind: ControlFailureKind;
     /** Stable body-free machine reason for recovery/audit decisions. */
@@ -170,7 +172,7 @@ export interface SubmitPromptOptions {
     interruptSource?: TurnCancellationSource;
     /** Typed in-process provenance. Text markers never grant this origin. */
     origin?: PromptOrigin;
-    /** Use the ACP steering extension when available; ignored by other backends. */
+    /** Inject into active work when the selected backend supports steering. */
     steer?: boolean;
     /** Audit-grade actor detail persisted with the conversation admission record. */
     actor?: {
@@ -200,11 +202,25 @@ export interface SessionSnapshot {
     activity?: SessionActivity;
 }
 export interface SessionActivity {
-    /** ACP tool calls currently reserved (lifecycle open or permission pending). */
+    /** Tool calls currently reserved (lifecycle open or permission pending). */
     activeToolCalls: number;
     /** When the agent last sent ANY session update, replay excluded. */
     lastUpdateAt?: string;
 }
+/** Provider-neutral behavior exposed by a session transport. */
+export interface AgentSessionCapabilities {
+    streaming: boolean;
+    durableConversation: boolean;
+    promptInput: boolean;
+    interrupt: boolean;
+    steering: boolean;
+    permissions: boolean;
+    toolBoundaryDelivery: boolean;
+    messagePhases: boolean;
+    resume: boolean;
+}
+/** Conservative static capabilities used before a live session is reachable. */
+export declare function sessionBackendCapabilities(backend: SessionBackendId, harness?: string): AgentSessionCapabilities;
 export type SessionEventKind = 'state' | 'agent_text' | 'thought' | 'tool_call' | 'tool_update' | 'permission' | 'monitor_delivery' | 'turn_stop' | 'error';
 /** What a settled permission request resolved to. */
 export type PermissionDecision = 'allowed' | 'denied' | 'cancelled';
@@ -219,7 +235,7 @@ export interface SessionEvent {
     text?: string;
     /**
      * Adapter-authenticated presentation phase for assistant text. Only the
-     * exact Codex ACP marker is promoted; absence/unknown values stay unset.
+     * exact Codex phase marker is promoted; absence/unknown values stay unset.
      */
     messagePhase?: 'commentary' | 'final_answer';
     /** Stable adapter message/item id when supplied. */
@@ -261,11 +277,13 @@ export interface ConversationHandlePage {
 /**
  * The live, harness-neutral contract between Fleet and one agent session.
  * Harness adapters construct this handle; orchestration code must not depend
- * on the ACP transport which currently implements it.
+ * on any concrete transport which implements it.
  */
 export interface AgentSession {
     readonly backend: SessionBackendId;
     readonly pid: number;
+    /** Live capabilities; optional only for source compatibility with external adapters. */
+    readonly capabilities?: AgentSessionCapabilities;
     isAlive(): boolean;
     snapshot(): SessionSnapshot;
     conversationPage?(request: {
@@ -283,7 +301,7 @@ export interface AgentSession {
     queuePrompt(text: string, options?: SubmitPromptOptions): Promise<QueuedPrompt>;
     /** Queue a prompt and wait for its terminal result. */
     submitPrompt(text: string, options?: SubmitPromptOptions): Promise<TurnResult>;
-    /** Monitor-only ACP safe-boundary delivery. Never implies human/control cancellation. */
+    /** Monitor-only safe-boundary delivery. Never implies human/control cancellation. */
     submitPromptAfterTool?(text: string, options?: SubmitPromptOptions): Promise<TurnResult>;
     /**
      * Cancel the active turn. Resolves when the cancellation has taken effect —

package/dist/session/types.js

@@ -1,5 +1,7 @@
 /** Stable body-free reason shared by ACP recovery and durable ingress. */
 export const ACP_CANCEL_DEADLINE_EXCEEDED = 'ACP_CANCEL_DEADLINE_EXCEEDED';
+/** Native Codex equivalent; kept distinct so diagnostics name the failing transport. */
+export const CODEX_APP_SERVER_CANCEL_DEADLINE_EXCEEDED = 'CODEX_APP_SERVER_CANCEL_DEADLINE_EXCEEDED';
 export class SessionControlError extends Error {
     kind;
     reasonCode;
@@ -53,3 +55,29 @@ export function turnResult(accepted, outcome, detail, output, cancellationSource
         ...(outcome === 'cancelled' && cancellationSource ? { cancellationSource } : {}),
     };
 }
+/** Conservative static capabilities used before a live session is reachable. */
+export function sessionBackendCapabilities(backend, harness) {
+    if (backend === 'codex-app-server')
+        return {
+            streaming: true,
+            durableConversation: true,
+            promptInput: true,
+            interrupt: true,
+            steering: true,
+            permissions: true,
+            toolBoundaryDelivery: false,
+            messagePhases: true,
+            resume: true,
+        };
+    return {
+        streaming: true,
+        durableConversation: true,
+        promptInput: true,
+        interrupt: true,
+        steering: false,
+        permissions: true,
+        toolBoundaryDelivery: true,
+        messagePhases: harness === 'codex',
+        resume: true,
+    };
+}

package/dist/spawn.d.ts

@@ -1,4 +1,5 @@
 import type { IsolationConfig } from './isolation/types.js';
+import type { AgentLoopsConfig } from './loops/config.js';
 import { type ApprovalMode, type FilesystemMode, type ResolvedRole, type MonitorConfig, type UnattendedMode, type RoomMemberStartup, type AgentDefinition, type AgentSelection } from './config.js';
 import { type OpsDeps } from './ops.js';
 import { type CreationDeps, type CreationProvenance } from './creation.js';
@@ -40,6 +41,12 @@ export interface SpawnOpts {
      * input in this release.
      */
     isolationFile?: string;
+    /** Trusted YAML containing exactly a top-level `loops:` map. Temporary launches only. */
+    loopsFile?: string;
+    /** Explicitly override any selected Agent Template loops with none. */
+    noLoops?: boolean;
+    /** Internal source label retained after room-member plan resolution. */
+    loopSource?: 'agent-template' | 'cli' | 'omitted';
     overseeInterval?: string;
     configPath?: string;
     dryRun?: boolean;
@@ -56,6 +63,8 @@ export declare function agentDefinitionFromSpawn(o: SpawnOpts): AgentDefinition;
  * must fail before any artifact exists.
  */
 export declare function readIsolationFile(path: string): IsolationConfig;
+/** Read a private canonical temporary-loop override before any creation side effect. */
+export declare function readLoopsFile(path: string): AgentLoopsConfig;
 export declare function validateSpawnOpts(o: SpawnOpts): void;
 /** The ours identity a spawn will bind: explicit, else the role name. */
 export declare const effectiveIdentity: (o: SpawnOpts) => string;

package/dist/spawn.js

@@ -1,5 +1,5 @@
 import { spawn as spawnChild } from 'node:child_process';
-import { closeSync, existsSync, mkdirSync, openSync, readFileSync, rmSync, writeFileSync } from 'node:fs';
+import { closeSync, existsSync, lstatSync, mkdirSync, openSync, readFileSync, rmSync, writeFileSync } from 'node:fs';
 import { join } from 'node:path';
 import { parse, stringify } from 'yaml';
 import { agentDir, defaultConfigPath } from './paths.js';
@@ -22,9 +22,12 @@ export function agentDefinitionFromSpawn(o) {
     if (o.agentDefinition) {
         if (o.brain !== undefined || o.role !== undefined || o.cwd !== undefined
             || o.coordinator !== undefined || o.approval !== undefined || o.filesystem !== undefined
-            || o.unattended !== undefined || o.isolationFile !== undefined || o.monitorConfig !== undefined)
+            || o.unattended !== undefined || o.isolationFile !== undefined || o.monitorConfig !== undefined
+            || o.loopsFile !== undefined)
             throw new Error('canonical agentDefinition conflicts with separate Agent fields');
         const definition = structuredClone(o.agentDefinition);
+        if (o.noLoops === true && definition.loops !== undefined)
+            throw new Error('canonical agentDefinition loops conflict with explicit no-loops policy');
         if (o.identity)
             definition.identity = o.identity;
         return definition;
@@ -46,12 +49,21 @@ export function agentDefinitionFromSpawn(o) {
         ...(permissions ? { permissions } : {}),
         ...(o.isolationFile ? { isolation: readIsolationFile(o.isolationFile) } : {}),
         ...(o.monitorConfig ? { monitor: structuredClone(o.monitorConfig) } : {}),
+        ...(o.loopsFile ? { loops: readLoopsFile(o.loopsFile) } : {}),
     };
 }
 function resolvedSpawn(o) {
     const definition = agentDefinitionFromSpawn(o);
-    const cfg = loadConfig(o.configPath, { additionalAgent: { id: o.name, definition } });
-    return { definition, role: findRole(cfg, o.name) };
+    const cfg = loadConfig(o.configPath, {
+        additionalAgent: { id: o.name, definition, temporary: o.temp === true },
+    });
+    const role = findRole(cfg, o.name);
+    if (o.temp)
+        role.temporaryLoopSource = o.loopSource
+            ?? (role.temporaryLoops?.length ? 'agent-template' : 'omitted');
+    if (o.noLoops === true)
+        role.temporaryLoops = [];
+    return { definition, role };
 }
 /**
  * Read and validate an `--isolation-file`. The file is the existing
@@ -78,7 +90,37 @@ export function readIsolationFile(path) {
         throw new Error(`--isolation-file ${path}: ${problems.join('; ')}`);
     return cfg;
 }
+/** Read a private canonical temporary-loop override before any creation side effect. */
+export function readLoopsFile(path) {
+    const stat = lstatSync(path);
+    const uid = process.getuid?.();
+    if (!stat.isFile() || stat.isSymbolicLink() || stat.size > 1_000_000
+        || (uid !== undefined && stat.uid !== uid) || (stat.mode & 0o777) !== 0o600)
+        throw new Error(`${path}: loops file must be an owner-only regular file no larger than 1 MB`);
+    let raw;
+    try {
+        raw = parse(readFileSync(path, 'utf8'));
+    }
+    catch (error) {
+        throw new Error(`--loops-file ${path}: ${error.message}`);
+    }
+    if (!raw || typeof raw !== 'object' || Array.isArray(raw)
+        || !Object.hasOwn(raw, 'loops')
+        || Object.keys(raw).some(key => key !== 'loops'))
+        throw new Error(`${path}: expected exactly a top-level loops: mapping`);
+    const loops = raw.loops;
+    if (!loops || typeof loops !== 'object' || Array.isArray(loops)
+        || !Object.keys(loops).length)
+        throw new Error(`${path}: loops must be a non-empty mapping; use --no-loops to disable loops`);
+    return structuredClone(loops);
+}
 export function validateSpawnOpts(o) {
+    if (o.loopsFile && o.noLoops === true)
+        throw new Error('--loops-file and --no-loops are mutually exclusive');
+    if ((o.loopsFile || o.noLoops === true || o.agentDefinition?.loops !== undefined) && !o.temp)
+        throw new Error('temporary Agent loops require --temp');
+    if (o.loopsFile)
+        readLoopsFile(o.loopsFile);
     if (o.approval && !['ask', 'auto', 'allow', 'deny'].includes(o.approval))
         throw new Error(`invalid --approval '${o.approval}'; allowed: ask, auto, allow (deprecated alias: deny)`);
     if (o.filesystem && !['read-only', 'workspace', 'unrestricted'].includes(o.filesystem))
@@ -102,7 +144,15 @@ export function validateSpawnOpts(o) {
  * by the reservation rather than by this function.
  */
 function assertNameFree(o) {
-    const cfg = loadConfig(o.configPath);
+    let cfg;
+    try {
+        cfg = loadConfig(o.configPath);
+    }
+    catch (error) {
+        if (error instanceof Error && error.message.includes(`resolve to duplicate identity '${effectiveIdentity(o)}'`))
+            throw new Error(`ours identity '${effectiveIdentity(o)}' is already taken or being created right now`);
+        throw error;
+    }
     if (cfg.roles.some(r => r.name === o.name))
         throw new Error(`role '${o.name}' already exists (${cfg.roles.find(r => r.name === o.name).sourceFile})`);
     if (existsSync(agentDir(o.name)) || existsSync(agentDir(o.name, true)))
@@ -141,7 +191,7 @@ export function spawnDryRun(o) {
  * `env`, `bio`, `persona` and `harness_options` are deliberately absent: the
  * record exists to be read, and must not become a place credentials collect.
  */
-function provenanceSettings(o, defaults) {
+function provenanceSettings(o, defaults, resolvedLoops = []) {
     const perms = (defaults.permissions ?? {});
     const callerDefaults = new Set(o.inheritedFromCaller ?? []);
     const tagged = (key, entry) => callerDefaults.has(key) ? { ...entry, source: 'caller-role' } : entry;
@@ -161,6 +211,16 @@ function provenanceSettings(o, defaults) {
             ? { value: 'declared via --isolation-file', source: 'cli' }
             : { value: defaults.isolation ? 'from fleet defaults' : undefined, source: defaults.isolation ? 'fleet-default' : 'built-in' },
         monitor: tagged('monitorConfig', provenanceOf(o.monitorConfig, defaults.monitor, { mode: 'fleet' })),
+        loops: {
+            value: o.noLoops ? { enabled: false, loops: [] }
+                : resolvedLoops.length ? resolvedLoops.map(loop => ({
+                    name: loop.name, enabled: loop.enabled, intervalMs: loop.intervalMs,
+                    initialDelayMs: loop.initialDelayMs, jitterMs: loop.jitterMs,
+                    prompt: { bytes: loop.promptBytes, sha256: loop.promptHash },
+                })) : 'omitted (legacy no temporary loops)',
+            source: o.loopSource === 'agent-template' ? 'agent-template'
+                : o.loopsFile || o.noLoops || o.loopSource === 'cli' ? 'cli' : 'built-in',
+        },
     };
 }
 /** Permanent spawn: persist one bare Agent document under the selected v2 root. */
@@ -168,6 +228,9 @@ export async function spawnPermanent(o, deps, creation = {}) {
     validateSpawnOpts(o);
     if (o.isolationFile)
         readIsolationFile(o.isolationFile); // fail before reserving
+    // Preserve the detailed owner/source diagnostic for an existing identity.
+    // The check is repeated inside the reservation boundary to close races.
+    assertNameFree(o);
     const prepared = resolvedSpawn(o); // canonical validation before mutation
     // Reserve name and identity together before anything is written or started.
     // A loser of the race creates no config, state, or service.
@@ -221,7 +284,7 @@ export async function spawnPermanent(o, deps, creation = {}) {
         // launch still records how it was asked for.
         const provenance = buildProvenance({
             role: o.name, lifetime: 'permanent', fleetVersion: VERSION,
-            settings: provenanceSettings(o, cfg.defaults),
+            settings: provenanceSettings(o, cfg.defaults, prepared.role.temporaryLoops),
             surface: o.surface, creationActionId: o.creationActionId, callerRole: o.callerRole,
         });
         mkdirSync(agentDir(o.name), { recursive: true });
@@ -282,14 +345,19 @@ export async function spawnTemp(o, binPath, launch = independentSupervisor, crea
 }
 async function spawnTempInner(o, preparedRole, binPath, launch, tx, onStage) {
     const cfg = loadConfig(o.configPath);
+    const { temporaryLoops, ...launchRole } = preparedRole;
     const role = {
-        ...preparedRole, sourceFile: '(temp)', loops: undefined, roomMemberStartup: o.roomMemberStartup,
+        ...launchRole, sourceFile: '(temp)',
+        ...(o.noLoops === true ? { loops: [] }
+            : temporaryLoops?.length ? { loops: temporaryLoops } : { loops: undefined }),
+        temporaryLoopSource: o.loopSource ?? (temporaryLoops?.length ? 'agent-template' : 'omitted'),
+        roomMemberStartup: o.roomMemberStartup,
     };
     onStage?.('writing_role');
     const dir = applyRole(role, { temp: true, identityGuarantee: 'unverified' });
     const provenance = buildProvenance({
         role: o.name, lifetime: 'temporary', fleetVersion: VERSION,
-        settings: provenanceSettings(o, cfg.defaults),
+        settings: provenanceSettings(o, cfg.defaults, preparedRole.temporaryLoops),
         surface: o.surface, creationActionId: o.creationActionId, callerRole: o.callerRole,
     });
     writeProvenance(dir, provenance);

package/dist/web/fleet-config-service.d.ts

@@ -3,6 +3,7 @@ export declare const REDACTED_ENV_VALUE = "__OURS_FLEET_SECRET_REDACTED__";
 export interface EditableFleetModel {
     manifest: Record<string, unknown>;
     agents: Record<string, Record<string, unknown>>;
+    agent_templates: Record<string, Record<string, unknown>>;
 }
 export interface ConfigReadResult {
     path: string;

package/dist/web/fleet-config-service.js

@@ -12,7 +12,7 @@ import { isSensitiveConfigKey } from '../sensitive-config.js';
 export const REDACTED_ENV_VALUE = '__OURS_FLEET_SECRET_REDACTED__';
 const MAX_CONFIG_BYTES = 256 * 1024;
 const DIFF_CONTEXT_LINES = 3;
-const KINDS = ['agents', 'roles', 'brains', 'room_templates'];
+const KINDS = ['agents', 'agent_templates', 'roles', 'brains', 'room_templates'];
 const emptyReport = () => ({ ok: true, checks: [] });
 export class FleetConfigService {
     path;
@@ -176,7 +176,7 @@ function readSources(manifest) {
         }
         trustedDirectory(dir);
         for (const name of readdirSync(dir).sort()) {
-            if ((kind === 'agents' || kind === 'room_templates')
+            if ((kind === 'agents' || kind === 'agent_templates' || kind === 'room_templates')
                 && !['.yaml', '.yml'].includes(extname(name).toLowerCase()))
                 continue;
             documents.set(join(kind, name), trustedFile(join(dir, name)));
@@ -188,20 +188,26 @@ function modelFrom(sources) {
     const manifestKey = basename(sources.manifest);
     const manifest = parseFleetDocument(sources.manifest, sources.documents.get(manifestKey), 'strict').value;
     const agents = {};
+    const agent_templates = {};
     for (const [rel, source] of sources.documents)
         if (rel.startsWith(`agents/`)) {
             const id = basename(rel, extname(rel));
             agents[id] = parseFleetDocument(absoluteFor(sources.manifest, rel), source, 'strict').value;
         }
-    return { manifest, agents };
+    for (const [rel, source] of sources.documents)
+        if (rel.startsWith(`agent_templates/`)) {
+            const id = basename(rel, extname(rel));
+            agent_templates[id] = parseFleetDocument(absoluteFor(sources.manifest, rel), source, 'strict').value;
+        }
+    return { manifest, agents, agent_templates };
 }
 function assertModel(value) {
     if (!value || typeof value !== 'object' || Array.isArray(value))
         throw new FleetError('invalid_request', 'model must be an object');
     const input = value;
-    if (Object.keys(input).sort().join(',') !== 'agents,manifest')
-        throw new FleetError('invalid_request', 'model allows exactly manifest and agents');
-    for (const key of ['manifest', 'agents'])
+    if (Object.keys(input).sort().join(',') !== 'agent_templates,agents,manifest')
+        throw new FleetError('invalid_request', 'model allows exactly manifest, agents, and agent_templates');
+    for (const key of ['manifest', 'agents', 'agent_templates'])
         if (!input[key] || typeof input[key] !== 'object' || Array.isArray(input[key]))
             throw new FleetError('invalid_request', `${key} must be an object`);
     for (const [id, doc] of Object.entries(input.agents)) {
@@ -210,6 +216,12 @@ function assertModel(value) {
         if (!doc || typeof doc !== 'object' || Array.isArray(doc))
             throw new FleetError('invalid_request', `Agent '${id}' must be an object`);
     }
+    for (const [id, doc] of Object.entries(input.agent_templates)) {
+        if (!ROLE_NAME_RE.test(id))
+            throw new FleetError('invalid_request', `invalid Agent Template ID '${id}'`);
+        if (!doc || typeof doc !== 'object' || Array.isArray(doc))
+            throw new FleetError('invalid_request', `Agent Template '${id}' must be an object`);
+    }
     return structuredClone(input);
 }
 function renderProposal(current, model) {
@@ -222,6 +234,12 @@ function renderProposal(current, model) {
         next.set(oldRel ?? join('agents', `${id}.yaml`), oldRel
             ? render(current.documents.get(oldRel), doc) : stringify(doc));
     }
+    for (const [id, doc] of Object.entries(model.agent_templates).sort(([a], [b]) => a.localeCompare(b))) {
+        const oldRel = [...current.documents.keys()].find(rel => rel.startsWith('agent_templates/')
+            && basename(rel, extname(rel)) === id);
+        next.set(oldRel ?? join('agent_templates', `${id}.yaml`), oldRel
+            ? render(current.documents.get(oldRel), doc) : stringify(doc));
+    }
     for (const [rel, source] of current.documents)
         if (rel.startsWith('roles/') || rel.startsWith('brains/') || rel.startsWith('room_templates/'))
             next.set(rel, source);
@@ -425,7 +443,7 @@ function sourceSensitiveValues(sources) {
             continue;
         try {
             const parsed = parse(source);
-            values.push(...sensitiveValues({ manifest: {}, agents: { source: parsed } }));
+            values.push(...sensitiveValues({ manifest: {}, agents: { source: parsed }, agent_templates: {} }));
         }
         catch { /* the authoritative parser reports malformed YAML */ }
     }

package/dist/web/runtime.js

@@ -4,7 +4,7 @@ import { resolve } from 'node:path';
 import { loadConfig } from '../config.js';
 import { RoleRepository } from '../application/role-repository.js';
 import { FleetQueryService } from '../application/fleet-query-service.js';
-import { AcpRoleSessionAdapter } from '../application/session-control.js';
+import { RoleSessionControlAdapter } from '../application/session-control.js';
 import { StructuredLogService } from '../application/log-service.js';
 import { RoleCommandService } from '../application/role-command-service.js';
 import { RoleCreationService } from '../application/role-creation-service.js';
@@ -64,18 +64,22 @@ export async function startWebConsole(options) {
     const repository = new RoleRepository({
         configPath: options.configPath,
         probeBackend: async (name) => {
-            let acp = false;
+            let backend;
             const permanent = resolve(home(), '.ours-fleet', 'agents', name);
             const temporary = resolve(home(), '.ours-fleet', 'tmp', name);
             for (const dir of [permanent, temporary]) {
                 if (!existsSync(controlSocketPath(dir)))
                     continue;
                 try {
-                    acp = (await controlRequest(dir, { command: 'snapshot' }, 500)).ok;
+                    const response = await controlRequest(dir, { command: 'snapshot' }, 500);
+                    const snapshot = response.result;
+                    if (response.ok && (snapshot?.backend === 'acp'
+                        || snapshot?.backend === 'codex-app-server'))
+                        backend = snapshot.backend;
                 }
                 catch { /* stale socket is evidence, not reachability */ }
             }
-            return { acp };
+            return { backend };
         },
     });
     const events = new FleetEventBus();
@@ -161,11 +165,12 @@ export async function startWebConsole(options) {
                 const role = await repository.get(roleId);
                 if (!role)
                     throw new FleetError('role_not_found', `no such role '${roleId}'`);
-                if (role.configuredBackend === 'acp') {
+                if (role.configuredBackend === 'acp'
+                    || role.configuredBackend === 'codex-app-server') {
                     const dir = repository.stateDir(role);
                     if (!dir)
                         throw new FleetError('control_unavailable', 'role state directory is unavailable');
-                    return new AcpRoleSessionAdapter(dir);
+                    return new RoleSessionControlAdapter(dir);
                 }
                 throw new FleetError('capability_unavailable', 'role session backend is unavailable');
             },

package/dist/web/server.js

@@ -183,12 +183,39 @@ export async function buildWebServer(services, boundary, options = {}) {
             throw new FleetError('invalid_request', 'invalid task state filter');
         if (query.groupByList !== undefined && !['true', 'false'].includes(query.groupByList))
             throw new FleetError('invalid_request', 'groupByList must be true or false');
+        if (query.includeDeleting !== undefined && !['true', 'false'].includes(query.includeDeleting))
+            throw new FleetError('invalid_request', 'includeDeleting must be true or false');
         const state = query.state && query.state !== 'all' ? query.state : undefined;
-        const filter = { ...(state ? { state } : {}), ...(query.list ? { list: query.list } : {}) };
+        const filter = { ...(state ? { state } : {}), ...(query.list ? { list: query.list } : {}),
+            ...(query.includeDeleting === 'true' ? { includeDeleting: true } : {}) };
         return taskApi(() => query.groupByList === 'true'
             ? { groups: requireTaskRooms().groupedTasks(filter) }
             : { tasks: requireTaskRooms().listTasks(filter) });
     });
+    app.delete('/api/v1/tasks/:id', async (request, reply) => {
+        auth.authenticate(request, true);
+        const taskId = request.params.id;
+        const confirm = request.query.confirm;
+        // Exact-ID-twice confirmation is validated before existence or idempotency.
+        if (confirm !== taskId)
+            throw new FleetError('invalid_request', 'confirm must exactly repeat the task id');
+        const accepted = await taskApi(() => requireTaskRooms().requestTaskDeletion({
+            actor: { kind: 'local_control', surface: 'web' }, taskId,
+        }));
+        if (accepted.status === 'already_absent')
+            return { task_id: taskId, deleted: false, already_absent: true };
+        // Cleanup runs in an external worker outside the request lifecycle; the
+        // request waits boundedly and reports pending — never fabricated success.
+        const outcome = await requireTaskRooms().launchTaskDeletionWorker({ taskId, waitMs: 5_000 });
+        if (outcome.deleted)
+            return { task_id: taskId, deleted: true };
+        reply.code(202);
+        return {
+            task_id: taskId, accepted: true, deletion: 'pending',
+            ...(outcome.error ? { error: outcome.error } : {}),
+            recovery: `Repeat DELETE /api/v1/tasks/${taskId}?confirm=${taskId}.`,
+        };
+    });
     app.post('/api/v1/tasks', async (request, reply) => {
         auth.authenticate(request, true);
         const body = request.body;