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

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;

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))
@@ -149,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;
@@ -169,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. */
@@ -232,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 });
@@ -293,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/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@ours.network/fleet",
-  "version": "1.1.0-nightly.20",
+  "version": "1.1.0-nightly.22",
   "description": "Harness-agnostic fleet of persistent, identity-bound AI agents. Declarative fleet.yaml, managed native/ACP sessions, supervision, and ours.network messaging.",
   "type": "module",
   "license": "FSL-1.1-Apache-2.0",

package/presets/fleet/agent_templates/LocalCoordinator.yaml

@@ -2,3 +2,48 @@ role: { ref: LocalCoordinator }
 brain: { ref: claude-default }
 coordinator: FleetCoordinator
 permissions: { approval: ask, filesystem: workspace, unattended: deny }
+loops:
+  continuity:
+    interval: 15m
+    prompt: |
+      Perform one bounded, observation-only continuity pass for the assigned task room. Do not modify
+      task or project state; the only permitted writes are the room action and secret-free WORKLOG
+      checkpoint defined below. Anchor the preceding interval to scheduled_at minus 15 minutes
+      through scheduled_at. A late start or missed-loop metadata describes this loop's outage, not
+      evidence that development froze.
+
+      Re-read ROUTINES.md when present and the continuity checkpoint in WORKLOG.md. Use bounded
+      `list_history` reads filtered to the assigned room CID and direction as needed. Do not drain
+      unread mail or mark unrelated mail read. Ignore unrelated contacts and private messages.
+      Use only attributable room/task evidence. Exclude loop-authored `CONTINUITY *` messages from
+      development evidence and fingerprint inputs; retain their request/report IDs separately for
+      dedupe. Lifecycle state `active`, elapsed time, silence, task difficulty, and filesystem
+      dirtiness alone do not prove development is active, meaningful progress, or a stall. Meaningful
+      progress is a concrete reported change, test result, decision, handoff, blocker delta, active
+      step, or unexpired ETA.
+
+      After a mandatory final history recheck, choose exactly one mutually exclusive branch:
+      - Terminal: if attributable evidence says the task is terminal, do nothing.
+      - Recent update: if the room already has a meaningful update in the interval, do nothing.
+      - Ongoing: if attributable development evidence is ongoing but the room has no meaningful
+        update in the interval, send at most one concise
+        `CONTINUITY ACTIVE [start..end]: <observed facts>; next=<known step or ETA>` update.
+      - Unobservable/no evidence: never invent activity. If no qualifying outstanding continuity
+        request exists, send one direct `CONTINUITY CHECK` request for status, next step, and ETA.
+        If the prior request is less than 10 minutes old or its ETA is unexpired, do nothing. If it
+        is at least 10 minutes old, no later meaningful evidence exists, and the ETA is absent or
+        elapsed, send at most one clear `CONTINUITY STALLED` report.
+      - Explicit stop: if attributable evidence says work stopped or is blocked with no active next
+        step, send at most one clear `CONTINUITY STALLED` report.
+
+      Before any send, suppress a semantic duplicate found by the final history recheck or checkpoint;
+      room history wins if they disagree. Build the stable fingerprint from classification and
+      non-loop evidence IDs/timestamps plus requested/reported state, excluding loop-authored
+      continuity messages, prose, and time-of-check so unchanged classification and evidence state
+      stay silent. Store continuity request/report IDs separately. Later meaningful progress resets
+      a prior request or stall. Append a secret-free WORKLOG checkpoint with interval, classification,
+      evidence IDs/times, fingerprint, and any separate request/report ID.
+
+      Do not edit project files, run implementation or tests, interrupt peers, spawn or manage agents,
+      invoke task/room lifecycle actions, infer from unrelated messages, or exceed LocalCoordinator
+      authority. Complete silently when no room action is required.

package/presets/fleet/room_templates/team.yaml

@@ -3,6 +3,7 @@ description: "Locally coordinated team: LocalCoordinator sequences, Developer ex
 room: { quiet_membership: false, anonymous: false }
 contract: |
   LocalCoordinator coordinates sequencing, handoffs, context, and blockers among existing members.
+  LocalCoordinator performs a bounded 15-minute continuity check without taking over implementation.
   Developer owns implementation and verification evidence.
   Critic independently reviews and withholds sign-off on material failures.
   LocalCoordinator has no Fleet lifecycle or agent-management authority.

package/presets/manifest.json

@@ -1,6 +1,6 @@
 {
   "schema_version": 1,
-  "preset_revision": 4,
+  "preset_revision": 5,
   "brain_catalog_revision": 1,
   "description": "ours-fleet standard configuration presets"
 }