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

package/dist/docs.js

@@ -31,6 +31,12 @@ selects one inline/ref Role and Brain and carries its operational fields.
 Agent Templates under \`~/fleet/agent_templates\` are inert reusable launch definitions;
 only explicit files under \`~/fleet/agents\` are persistent lifecycle instances.
 Room members use \`agent_template\` and receive immutable content-addressed snapshots.
+An Agent Template may declare up to 64 temporary-only named \`loops\`; persistent Agent
+instances reject them. Each loop requires \`interval\` (1m..30d) and bounded
+nonblank \`prompt\`, with optional \`enabled\` (default true), \`initial_delay\`
+(default interval, 0s..30d), and \`jitter\` (default 0s, < interval, <=1h).
+Execution is fixed skip-if-busy with no ordinary missed-tick backlog/replay;
+restart recovery may preserve at most one recent late occurrence.
 Legacy top-level \`roles:\` and \`fleet.d\` are rejected. Validate the complete
 trusted source set with \`config\` and \`doctor\` before starting or restarting.
 
@@ -318,8 +324,23 @@ ours-fleet template show team [-c FILE]
 ours-fleet task create --title "Solo task" --template single [-c FILE]
 ours-fleet task create --title "Reviewed change" --template pair [-c FILE]
 ours-fleet task create --title "Phased delivery" --template team [-c FILE]
+ours-fleet spawn --temp Scout --role SELECTION --brain SELECTION --loops-file PRIVATE.yaml
+ours-fleet task start TASK --member developer --loops-file PRIVATE.yaml
+ours-fleet task start TASK --member critic --no-loops
 \`\`\`
 
+\`--loops-file\` must be an owner-only, non-symlink regular file <=1 MB containing
+exactly one top-level non-empty \`loops:\` mapping. \`--no-loops\` explicitly
+disables loops. They are mutually exclusive and rejected for permanent spawn.
+For a grouped room member the whole CLI block overrides its Agent Template;
+the template overrides omission. Omission preserves historical no-loop behavior
+and never inherits manifest wildcard loops. Fleet validates before side effects,
+seals normalized timings plus exact private prompts, and reuses that snapshot for
+idempotent start, retry, recovery, and replacement. Trusted authoring and the
+private sealed runtime retain exact prompts; resolved launch, task, room,
+provenance, and audit presentations show source, policy, timing, prompt bytes,
+and prompt SHA-256 instead of prompt text.
+
 An alternate manifest \`-c /path/custom.yaml\` uses \`/path/custom/\` as its split
 root. Repeated init only fills missing files and never adopts a newer default.
 Revision-3 packaged-bootstrap and generated role defaults have an exact-semantic,

package/dist/fleet-command-audit.js

@@ -131,7 +131,7 @@ export function classifyFleetArgv(argv) {
 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',
@@ -364,7 +364,7 @@ function validConfiguration(value) {
     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'])
+        '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))
@@ -389,6 +389,18 @@ function validConfiguration(value) {
             && (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.

package/dist/lifecycle-summary.d.ts

@@ -47,6 +47,22 @@ export interface AgentLaunchConfiguration {
         read_mounts?: number;
         write_mounts?: number;
     };
+    /** Present only for temporary agents; prompt bodies are never presented. */
+    loops?: {
+        source: 'agent-template' | 'cli' | 'omitted';
+        policy: 'skip-if-busy';
+        entries: Array<{
+            name: string;
+            enabled: boolean;
+            intervalMs: number;
+            initialDelayMs: number;
+            jitterMs: number;
+            prompt: {
+                bytes: number;
+                sha256: string;
+            };
+        }>;
+    };
 }
 /** Where a Brain/Role selection came from; labels are human, hashes secondary. */
 export type SelectionOrigin = {

package/dist/lifecycle-summary.js

@@ -58,6 +58,15 @@ export function summarizeResolvedLaunch(role, origins) {
                 ...(fs?.read?.length ? { read_mounts: fs.read.length } : {}),
                 ...(fs?.write?.length ? { write_mounts: fs.write.length } : {}),
             } } : {}),
+        ...(role.temporaryLoopSource ? { loops: {
+                source: role.temporaryLoopSource,
+                policy: 'skip-if-busy',
+                entries: (role.temporaryLoops ?? role.loops ?? []).map(loop => ({
+                    name: loop.name, enabled: loop.enabled, intervalMs: loop.intervalMs,
+                    initialDelayMs: loop.initialDelayMs, jitterMs: loop.jitterMs,
+                    prompt: { bytes: loop.promptBytes, sha256: loop.promptHash },
+                })),
+            } } : {}),
     };
     // A configuration whose complete mandatory rendering cannot fit must never
     // be produced; real resolved values sit far below the budget, so this is a
@@ -114,6 +123,15 @@ function optionalComponents(configuration) {
                 + `${configuration.isolation.read_mounts || configuration.isolation.write_mounts
                     ? `, mounts +${configuration.isolation.read_mounts ?? 0}ro/+${configuration.isolation.write_mounts ?? 0}rw` : ''}`
             : undefined,
+        configuration.loops
+            ? configuration.loops.source === 'omitted'
+                ? 'temporary loops omitted (legacy behavior)'
+                : configuration.loops.entries.length === 0
+                    ? `temporary loops disabled (source ${configuration.loops.source})`
+                    : `temporary loops ${configuration.loops.entries.map(loop => `${loop.name}:${loop.enabled ? 'enabled' : 'disabled'}`
+                        + ` interval=${loop.intervalMs}ms delay=${loop.initialDelayMs}ms jitter=${loop.jitterMs}ms`
+                        + ` prompt=${loop.prompt.bytes}B/${loop.prompt.sha256.slice(0, 12)}`).join(', ')}; policy skip-if-busy; source ${configuration.loops.source}`
+            : undefined,
     ].filter((part) => Boolean(part));
 }
 /**

package/dist/loops/config.d.ts

@@ -7,6 +7,9 @@ export interface LoopConfig {
     initial_delay?: string;
     jitter?: string;
 }
+/** Agent Template-local loops are implicitly scoped to the temporary agent. */
+export type AgentLoopConfig = Omit<LoopConfig, 'roles'>;
+export type AgentLoopsConfig = Record<string, AgentLoopConfig>;
 export interface ResolvedLoop {
     name: string;
     selectors: string[];
@@ -24,7 +27,13 @@ export interface ResolvedRoleLoop extends Omit<ResolvedLoop, 'selectors' | 'role
     role: string;
     definitionHash: string;
 }
-export declare function resolveLoops(block: unknown, baseFile: string, roles: ResolvedRole[], vars: Record<string, string>): {
+export declare function resolveLoops(block: unknown, baseFile: string, roles: ResolvedRole[], vars: Record<string, string>, options?: {
+    assertTrustedSource?: boolean;
+}): {
     loops: ResolvedLoop[];
     byRole: Map<string, ResolvedRoleLoop[]>;
 };
+/** Resolve the canonical Agent Template schema without inventing a second loop language. */
+export declare function resolveAgentLoops(block: unknown, role: ResolvedRole, sourceFile?: string): ResolvedRoleLoop[];
+/** Fully explicit private snapshot form; prompt text is retained for deterministic recovery. */
+export declare function canonicalAgentLoops(loops: ResolvedRoleLoop[]): AgentLoopsConfig;

package/dist/loops/config.js

@@ -2,13 +2,14 @@ import { createHash } from 'node:crypto';
 import { lstatSync } from 'node:fs';
 import { ConfigError, ROLE_NAME_RE } from '../config.js';
 import { sessionBackendCapabilities } from '../session/types.js';
-import { parseDuration } from '../duration.js';
+import { formatDuration, parseDuration } from '../duration.js';
 const LOOP_KEYS = ['roles', 'interval', 'prompt', 'enabled', 'initial_delay', 'jitter'];
 const MIN_INTERVAL_MS = 60_000;
 const MAX_DURATION_MS = 30 * 24 * 60 * 60 * 1_000;
 const MAX_JITTER_MS = 60 * 60 * 1_000;
 const MAX_PROMPT_BYTES = 16 * 1024;
 const MAX_PROMPT_SCALARS = 12_000;
+const MAX_AGENT_LOOPS = 64;
 function substitute(value, vars) {
     if (typeof value === 'string')
         return value.replace(/\$\{(\w+)\}/g, (match, key) => key in vars ? String(vars[key]) : match);
@@ -48,7 +49,7 @@ function normalizePrompt(raw, where) {
 function digest(value) {
     return createHash('sha256').update(JSON.stringify(value)).digest('hex');
 }
-export function resolveLoops(block, baseFile, roles, vars) {
+export function resolveLoops(block, baseFile, roles, vars, options = {}) {
     const byRole = new Map(roles.map(role => [role.name, []]));
     if (block === undefined || block === null)
         return { loops: [], byRole };
@@ -114,10 +115,41 @@ export function resolveLoops(block, baseFile, roles, vars) {
     for (const values of byRole.values())
         values.sort((a, b) => a.name.localeCompare(b.name));
     out.sort((a, b) => a.name.localeCompare(b.name));
-    if (out.some(loop => loop.enabled))
+    if (out.some(loop => loop.enabled) && options.assertTrustedSource !== false)
         assertSafeLoopConfig(baseFile);
     return { loops: out, byRole };
 }
+/** Resolve the canonical Agent Template schema without inventing a second loop language. */
+export function resolveAgentLoops(block, role, sourceFile = '(temporary Agent loop)') {
+    if (block === undefined)
+        return [];
+    if (!block || typeof block !== 'object' || Array.isArray(block))
+        throw new ConfigError(`${sourceFile}: Agent loops must be a non-empty map`);
+    if (!Object.keys(block).length)
+        throw new ConfigError(`${sourceFile}: Agent loops must be non-empty; use an explicit no-loops override to disable template loops`);
+    if (Object.keys(block).length > MAX_AGENT_LOOPS)
+        throw new ConfigError(`${sourceFile}: Agent loops may contain at most ${MAX_AGENT_LOOPS} entries`);
+    const scoped = Object.fromEntries(Object.entries(block).map(([name, raw]) => {
+        if (!raw || typeof raw !== 'object' || Array.isArray(raw))
+            return [name, raw];
+        const value = raw;
+        if (Object.hasOwn(value, 'roles'))
+            throw new ConfigError(`${sourceFile}: Agent loop '${name}' has unknown key roles; Agent loops are implicitly scoped`);
+        return [name, { ...value, roles: [role.name] }];
+    }));
+    return resolveLoops(scoped, sourceFile, [role], {}, { assertTrustedSource: false })
+        .byRole.get(role.name) ?? [];
+}
+/** Fully explicit private snapshot form; prompt text is retained for deterministic recovery. */
+export function canonicalAgentLoops(loops) {
+    return Object.fromEntries(loops.map(loop => [loop.name, {
+            enabled: loop.enabled,
+            interval: formatDuration(loop.intervalMs),
+            initial_delay: formatDuration(loop.initialDelayMs),
+            jitter: formatDuration(loop.jitterMs),
+            prompt: loop.prompt,
+        }]));
+}
 function assertSafeLoopConfig(path) {
     let stat;
     try {

package/dist/resolved-plan.js

@@ -1,9 +1,15 @@
 import { analyzeRolePermissions } from './permissions.js';
 import { dirname, relative } from 'node:path';
+import { createHash } from 'node:crypto';
 import { isSensitiveConfigKey } from './sensitive-config.js';
 export const RESOLVED_PLAN_SCHEMA_VERSION = 2;
 const sortedObject = (value) => Object.fromEntries(Object.entries(value).sort(([a], [b]) => a.localeCompare(b)));
 export const redactSensitive = (value, key = '') => {
+    if (key === 'prompt' && typeof value === 'string')
+        return {
+            bytes: Buffer.byteLength(value, 'utf8'),
+            sha256: createHash('sha256').update(value).digest('hex'),
+        };
     if (isSensitiveConfigKey(key))
         return '<redacted>';
     if (Array.isArray(value))
@@ -48,6 +54,7 @@ export function resolvedPlan(cfg) {
 }
 export function resolvedRolePlan(role, manifestDir = dirname(role.sourceFile)) {
     const analysis = analyzeRolePermissions(role);
+    const effectiveLoops = role.temporaryLoopSource ? (role.temporaryLoops ?? []) : (role.loops ?? []);
     return {
         name: role.name,
         sourceFile: role.sourceFile,
@@ -87,7 +94,8 @@ export function resolvedRolePlan(role, manifestDir = dirname(role.sourceFile)) {
         },
         monitor: role.monitor,
         ownerChannel: role.owner_channel ?? null,
-        loops: (role.loops ?? []).map(loop => ({
+        temporaryLoopSource: role.temporaryLoopSource ?? null,
+        loops: effectiveLoops.map(loop => ({
             name: loop.name, enabled: loop.enabled, intervalMs: loop.intervalMs,
             initialDelayMs: loop.initialDelayMs, jitterMs: loop.jitterMs,
             definitionHash: loop.definitionHash, prompt: { bytes: loop.promptBytes, sha256: loop.promptHash },

package/dist/rooms-tasks/cli.js

@@ -8,14 +8,17 @@ import { acquireLaunchSnapshotLock, releaseLaunchSnapshot } from './launch-snaps
 import { parseGroupedMemberArgs, readMembersFile } from './member-overrides.js';
 const MEMBER_ARG_FLAGS = new Set([
     '--member', '--agent-template', '--brain', '--role', '--approval', '--filesystem', '--unattended',
-    '--cwd', '--model', '--effort',
+    '--cwd', '--model', '--effort', '--loops-file', '--no-loops',
 ]);
 export function cliMemberOverrides(membersFile, argv = process.argv.slice(2)) {
     const grouped = [];
     for (let i = 0; i < argv.length; i++)
         if (MEMBER_ARG_FLAGS.has(argv[i])) {
-            grouped.push(argv[i], argv[i + 1]);
-            i += 1;
+            grouped.push(argv[i]);
+            if (argv[i] !== '--no-loops') {
+                grouped.push(argv[i + 1]);
+                i += 1;
+            }
         }
     if (membersFile && grouped.length)
         throw new Error('--members-file cannot be combined with grouped --member options');
@@ -712,6 +715,8 @@ export function registerTaskCommands(parent, cOpt) {
         .option('--cwd <path>', 'working directory for the current member block')
         .option('--model <id>', 'model for the current member block')
         .option('--effort <level>', 'reasoning effort for the current member block')
+        .option('--loops-file <path>', 'owner-only loops: YAML for the current temporary member')
+        .option('--no-loops', 'disable loops for the current temporary member')
         .option('--json', 'JSON output')
         .action(async (opts, command) => {
         try {
@@ -926,6 +931,8 @@ export function registerTaskCommands(parent, cOpt) {
         .option('--cwd <path>', 'working directory for current member')
         .option('--model <id>', 'model for current member')
         .option('--effort <level>', 'reasoning effort for current member')
+        .option('--loops-file <path>', 'owner-only loops: YAML for current member')
+        .option('--no-loops', 'disable loops for current member')
         .option('--json', 'JSON output')
         .action(async (id, opts, command) => {
         try {
@@ -1336,6 +1343,8 @@ export function registerTaskCommands(parent, cOpt) {
         .option('--cwd <path>', 'working directory for current member')
         .option('--model <id>', 'model for current member')
         .option('--effort <level>', 'reasoning effort for current member')
+        .option('--loops-file <path>', 'owner-only loops: YAML for current member')
+        .option('--no-loops', 'disable loops for current member')
         .option('--json', 'JSON output')
         .action(async (id, opts, command) => {
         try {
@@ -1446,6 +1455,8 @@ export function registerRoomCommands(parent, cOpt) {
         .option('--cwd <path>', 'working directory for current member')
         .option('--model <id>', 'model for current member')
         .option('--effort <level>', 'reasoning effort for current member')
+        .option('--loops-file <path>', 'owner-only loops: YAML for current member')
+        .option('--no-loops', 'disable loops for current member')
         .option('--json', 'JSON output')
         .action(async (opts, command) => {
         try {

package/dist/rooms-tasks/launch-snapshot.js

@@ -99,6 +99,11 @@ function sweepUnreferencedSnapshotsLocked() {
     }
 }
 export function redactLaunchDefinition(value, key = '') {
+    if (key === 'prompt' && typeof value === 'string')
+        return {
+            bytes: Buffer.byteLength(value, 'utf8'),
+            sha256: createHash('sha256').update(value).digest('hex'),
+        };
     if (['env', 'harness_options', 'session_options', 'owner_channel', 'auth_proxy'].includes(key))
         return '<redacted>';
     if (Array.isArray(value))

package/dist/rooms-tasks/member-overrides.d.ts

@@ -1,5 +1,6 @@
 import { type AgentDefinition, type AgentTemplateDefinition, type FleetConfig } from '../config.js';
 import type { TemplateDefinition, TemplateSnapshot } from './types.js';
+import type { AgentLoopsConfig } from '../loops/config.js';
 export interface MemberOverride {
     agent_template?: string;
     brain?: string;
@@ -10,6 +11,8 @@ export interface MemberOverride {
     cwd?: string;
     model?: string;
     effort?: string;
+    /** Whole-block override; false is the explicit no-loops policy. */
+    loops?: AgentLoopsConfig | false;
     overrides?: Partial<AgentDefinition>;
 }
 export type MemberOverrides = Record<string, MemberOverride>;

package/dist/rooms-tasks/member-overrides.js

@@ -6,6 +6,8 @@ import { analyzeRolePermissions } from '../permissions.js';
 import { canonicalJson } from '../canonical-json.js';
 import { redactLaunchDefinition } from './launch-snapshot.js';
 import { snapshotTemplate } from './templates.js';
+import { readLoopsFile } from '../spawn.js';
+import { canonicalAgentLoops, resolveAgentLoops } from '../loops/config.js';
 export function hashMemberOverrides(overrides) {
     return createHash('sha256').update(canonicalJson(overrides)).digest('hex');
 }
@@ -16,20 +18,37 @@ const OPTION_FIELDS = {
 };
 /** Parse only the ordered member-option subsequence supplied by the CLI action. */
 export function parseGroupedMemberArgs(argv) {
-    if (argv.length % 2)
-        throw new Error(`${argv.at(-1)}: value required`);
     const result = {};
     let current;
-    for (let index = 0; index < argv.length; index += 2) {
+    for (let index = 0; index < argv.length;) {
         const flag = argv[index];
+        if (flag === '--no-loops') {
+            if (!current)
+                throw new Error(`${flag} must follow --member <slot>`);
+            if (result[current].loops !== undefined)
+                throw new Error(`duplicate loop override for member '${current}'`);
+            result[current].loops = false;
+            index += 1;
+            continue;
+        }
         const value = argv[index + 1];
-        if (!value)
+        if (!value || value.startsWith('--'))
             throw new Error(`${flag}: value required`);
         if (flag === '--member') {
             if (result[value])
                 throw new Error(`duplicate member slot '${value}'`);
             current = value;
             result[current] = {};
+            index += 2;
+            continue;
+        }
+        if (flag === '--loops-file') {
+            if (!current)
+                throw new Error(`${flag} must follow --member <slot>`);
+            if (result[current].loops !== undefined)
+                throw new Error(`duplicate loop override for member '${current}'`);
+            result[current].loops = readLoopsFile(value);
+            index += 2;
             continue;
         }
         const field = OPTION_FIELDS[flag];
@@ -40,6 +59,7 @@ export function parseGroupedMemberArgs(argv) {
         if (result[current][field] !== undefined)
             throw new Error(`duplicate ${flag} for member '${current}'`);
         result[current][field] = value;
+        index += 2;
     }
     for (const [slot, value] of Object.entries(result))
         validateMemberOverride(value, `member '${slot}'`);
@@ -60,7 +80,7 @@ export function readMembersFile(path) {
         validateMemberOverride(value, `${path}: member '${slot}'`);
     return members;
 }
-const MEMBER_KEYS = new Set(['agent_template', 'brain', 'role', 'approval', 'filesystem', 'unattended', 'cwd', 'model', 'effort', 'overrides']);
+const MEMBER_KEYS = new Set(['agent_template', 'brain', 'role', 'approval', 'filesystem', 'unattended', 'cwd', 'model', 'effort', 'overrides', 'loops']);
 function validateMemberOverride(value, where) {
     if (!value || typeof value !== 'object' || Array.isArray(value))
         throw new Error(`${where}: must be a mapping`);
@@ -81,6 +101,11 @@ function validateMemberOverride(value, where) {
             throw new Error(`${where}: ${key} must be a non-blank string`);
     if (item.overrides !== undefined && (!item.overrides || typeof item.overrides !== 'object' || Array.isArray(item.overrides)))
         throw new Error(`${where}: overrides must be a mapping`);
+    if (item.overrides && Object.hasOwn(item.overrides, 'loops'))
+        throw new Error(`${where}: overrides.loops is unsupported; use the top-level loops member override`);
+    if (item.loops !== undefined && item.loops !== false
+        && (!item.loops || typeof item.loops !== 'object' || Array.isArray(item.loops)))
+        throw new Error(`${where}: loops must be a mapping or false`);
 }
 const MAPS = new Set(['permissions', 'env', 'isolation', 'monitor', 'owner_channel', 'worklog', 'auth_proxy']);
 function merge(base, overlay) {
@@ -95,6 +120,8 @@ function merge(base, overlay) {
     return out;
 }
 export function prepareExecutionPlan(template, cfg, overrides = {}) {
+    for (const [slot, value] of Object.entries(overrides))
+        validateMemberOverride(value, `member '${slot}'`);
     const slots = new Set(template.members.map(member => member.slot));
     for (const slot of Object.keys(overrides))
         if (!slots.has(slot))
@@ -108,6 +135,10 @@ export function prepareExecutionPlan(template, cfg, overrides = {}) {
         if (!base)
             throw new Error(`Agent Template '${source}' not found`);
         let definition = merge(base, (input.overrides ?? {}));
+        if (input.loops === false)
+            delete definition.loops;
+        else if (input.loops !== undefined)
+            definition.loops = structuredClone(input.loops);
         const rolePreset = input.role ? cfg.rolePresets?.[input.role] : undefined;
         if (input.role && !rolePreset)
             throw new Error(`Role '${input.role}' not found`);
@@ -144,6 +175,8 @@ export function prepareExecutionPlan(template, cfg, overrides = {}) {
             const role = cfg.resolveAgentDefinition(`RoomMember_${member.slot}`, {
                 ...definition, identity: `RoomMember_${member.slot}`,
             });
+            if (definition.loops !== undefined)
+                definition.loops = canonicalAgentLoops(resolveAgentLoops(definition.loops, role, `(member '${member.slot}' resolved loops)`));
             const analysis = analyzeRolePermissions(role);
             if (analysis.conflicts?.length)
                 throw new Error(`member '${member.slot}' has native permission conflicts: ${analysis.conflicts.map(item => item.warning).join('; ')}`);
@@ -154,6 +187,7 @@ export function prepareExecutionPlan(template, cfg, overrides = {}) {
         launchDefinitions[id] = definition;
         const hash = createHash('sha256').update(canonicalJson(definition)).digest('hex');
         return { ...member, agent_template: source, launch_definition_id: id,
+            loop_source: input.loops !== undefined ? 'cli' : base.loops !== undefined ? 'agent-template' : 'omitted',
             agent_template_hash: hash,
             ...(input.role ? { role_preset: { id: input.role, hash: createHash('sha256').update(canonicalJson(rolePreset)).digest('hex') } } : {}),
             ...(input.brain ? { brain_preset: { id: input.brain, hash: createHash('sha256').update(canonicalJson(brainPreset)).digest('hex') } } : {}),

package/dist/rooms-tasks/provision.js

@@ -100,6 +100,7 @@ function expandMembers(template, prefix) {
                 agentTemplate: slot.agent_template,
                 launchDefinitionId: slot.launch_definition_id ?? slot.agent_template,
                 agentTemplateHash: slot.agent_template_hash,
+                loopSource: slot.loop_source ?? 'omitted',
             });
         }
     }
@@ -121,6 +122,7 @@ function settingsFor(member, cfg, sealed) {
         template: member.agentTemplate,
         templateHash: member.agentTemplateHash
             ?? createHash('sha256').update(canonicalJson(definition)).digest('hex'),
+        loopSource: member.loopSource,
     };
 }
 function roomTask(input, member, settings, members, roomIdentityCid, ownerSeatCid) {
@@ -286,6 +288,9 @@ async function launchMemberUnlocked(input) {
             temp: true,
             identity: member.name,
             agentDefinition: settings.definition,
+            ...(settings.loopSource === 'cli' && settings.definition.loops === undefined
+                ? { noLoops: true } : {}),
+            loopSource: settings.loopSource,
             surface: 'agent',
             creationActionId: actionId,
             roomMemberStartup: startup,

package/dist/rooms-tasks/types.d.ts

@@ -276,6 +276,8 @@ export interface TemplateDefinition {
     members: TemplateMemberSlot[];
 }
 export interface TemplateSnapshotMember extends TemplateMemberSlot {
+    /** Source of the effective temporary-loop policy, independent of its sealed value. */
+    loop_source?: 'agent-template' | 'cli' | 'omitted';
     /** Secret-safe public projection; launch material lives in the sealed snapshot. */
     agent_projection?: Record<string, unknown>;
     agent_template_hash?: string;

package/dist/runner.d.ts

@@ -7,6 +7,7 @@ import type { AgentSession, ExitRecord, TurnResult } from './session/types.js';
 import type { AgentSessionAdapter, AgentSessionStartOptions } from './harness/agent-session.js';
 import { type OwnerChannelHandle, type OwnerChannelOptions } from './owner-channel/channel.js';
 import { type OwnerBinderLease } from './owner-channel/binder.js';
+import { ScheduledLoopManager, type ScheduledLoopManagerHandle } from './loops/manager.js';
 export interface RunnerDeps {
     exec: Exec;
     cpuDelegated(): boolean;
@@ -26,6 +27,8 @@ export interface RunnerDeps {
     startAgentSession(adapter: AgentSessionAdapter, options: AgentSessionStartOptions): Promise<AgentSession>;
     /** Construct the authenticated role control route (injectable where sockets are unavailable). */
     createControlServer(stateDir: string, session: AgentSession, log: (line: string) => void): Pick<RoleControlServer, 'start' | 'close' | 'setFleetSpawner' | 'setFleetAuditor' | 'setOwnerChannel' | 'setConfigReloader' | 'setLoopManager'>;
+    /** Construct scheduled-loop execution (injectable for fail-closed startup tests). */
+    createLoopManager(...args: ConstructorParameters<typeof ScheduledLoopManager>): ScheduledLoopManagerHandle;
     /** Acquire the cross-process owner-channel binder lease before replacing the control socket. */
     acquireOwnerBinder(stateDir: string, role: string, identity: string): Promise<OwnerBinderLease>;
     /** Ask the still-authenticated predecessor to emit the fixed recovery notice. */

package/dist/runner.js

@@ -53,6 +53,7 @@ const defaultDeps = () => ({
     createOwnerChannel: opts => new OwnerChannel(opts),
     startAgentSession: (adapter, options) => adapter.start(options),
     createControlServer: (stateDir, session, log) => new RoleControlServer(stateDir, session, log),
+    createLoopManager: (...args) => new ScheduledLoopManager(...args),
     acquireOwnerBinder: (stateDir, role, identity) => acquireOwnerBinderLease(stateDir, role, identity),
     reportOwnerStartupFailure: async (stateDir) => {
         const response = await controlRequest(stateDir, {
@@ -774,7 +775,7 @@ export async function runOnce(name, opts = {}, partialDeps = {}) {
             if (generation === loopGeneration && (loopManager || !definitions.length))
                 return { changed: false, loops: definitions.length };
             if (!loopManager && definitions.length) {
-                loopManager = new ScheduledLoopManager(name, definitions, dir, arbiter, {
+                loopManager = deps.createLoopManager(name, definitions, dir, arbiter, {
                     now: deps.now,
                     setTimer: (callback, ms) => setTimeout(callback, ms),
                     clearTimer: timer => clearTimeout(timer),
@@ -790,10 +791,12 @@ export async function runOnce(name, opts = {}, partialDeps = {}) {
             deps.log(`[${name}] scheduled loops reloaded (${definitions.length} definitions)`);
             return { changed: true, loops: definitions.length };
         };
-        control.setConfigReloader(reloadLoopConfig);
+        // Temporary agents are immutable launch snapshots: never re-resolve mutable Fleet YAML.
+        if (!temp)
+            control.setConfigReloader(reloadLoopConfig);
         if (role.loops?.length) {
             try {
-                loopManager = new ScheduledLoopManager(name, role.loops, dir, arbiter, {
+                loopManager = deps.createLoopManager(name, role.loops, dir, arbiter, {
                     now: deps.now,
                     setTimer: (callback, ms) => setTimeout(callback, ms),
                     clearTimer: timer => clearTimeout(timer),
@@ -803,6 +806,17 @@ export async function runOnce(name, opts = {}, partialDeps = {}) {
                 loopManager.start();
             }
             catch (error) {
+                if (temp) {
+                    monitor?.stop();
+                    if (monitorLoop)
+                        await monitorLoop;
+                    await control.close();
+                    ownerBinder?.release();
+                    await agentSession.close();
+                    unsubscribeRecovery?.();
+                    throw new Error(`[${name}] configured temporary loop manager failed to start: `
+                        + `${error?.message ?? String(error)}`);
+                }
                 deps.log(`[${name}] scheduled loop manager unavailable: ${error?.name ?? 'Error'}`);
             }
         }

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;