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

package/README.md

@@ -365,8 +365,41 @@ Agent Template document (\`~/fleet/agent_templates/Worker.yaml\`) is inert and r
 role: { ref: developer }
 brain: { ref: claude-default }
 permissions: { approval: ask, filesystem: workspace, unattended: deny }
+loops:                                   # optional; temporary launches only
+  progress:
+    interval: 10m                        # required; 1m..30d
+    initial_delay: 10m                   # default: interval; 0s..30d
+    jitter: 30s                          # default: 0s; < interval and <=1h
+    enabled: true                        # default true
+    prompt: Continue the assigned work and report only material progress.
 ```
 
+Agent Template-local `loops` are limited to 64 entries, implicitly scoped to the temporary agent, and
+reuse Fleet's scheduled-turn semantics: a busy occurrence is skipped, ordinary
+missed occurrences are not backlogged or replayed, and restart recovery may
+preserve at most one recent late occurrence. The trusted authoring file and
+private sealed role snapshot retain exact prompt text; resolved launch, task,
+room, provenance, and audit presentation surfaces show only bytes and SHA-256.
+
+Direct temporary spawn can set the same whole block from an owner-only regular
+file containing exactly a top-level `loops:` mapping, or explicitly disable it:
+
+```sh
+ours-fleet spawn --temp Scout --role 'inline:{mission: inspect}' --brain 'inline:{harness: codex}' --loops-file ./scout-loops.yaml
+ours-fleet spawn --temp Scout --role 'inline:{mission: inspect}' --brain 'inline:{harness: codex}' --no-loops
+ours-fleet task start TASK --member developer --loops-file ./developer-loops.yaml
+ours-fleet task start TASK --member critic --no-loops
+```
+
+`--loops-file` and `--no-loops` are mutually exclusive and temporary-only.
+For room members they override the selected Agent Template as a whole; the
+Agent Template overrides legacy omission. Omission preserves the historical
+no-loop temporary behavior and never inherits manifest `roles: ["*"]` loops.
+The file must be owned by the current user, mode 0600, non-symlink, no larger
+than 1 MB, and contain a non-empty map. Validation completes before identity,
+Cowork, snapshot, or supervisor side effects. Recovery and replacement reuse
+the private sealed normalized definition even if mutable templates later change.
+
 Persistent Agent instance (\`~/fleet/agents/Name.yaml\`) either remains a canonical
 Role/Brain composition or explicitly reuses a template:
 
@@ -484,6 +517,15 @@ ours-fleet task create --title "Reviewed change" --template pair
 ours-fleet task create --title "Phased delivery" --template team
 ```
 
+The default `team` gives only its LocalCoordinator Agent Template a 15-minute
+continuity loop. Each idle-only pass uses authenticated assigned-room evidence,
+posts at most one missing interval update or status request, and reports `STALLED`
+only after concrete stopped/blocked evidence or the role's documented request/ETA
+window. Stable history/checkpoint fingerprints suppress duplicates; `single` and
+`pair` remain loop-free. This preset does not widen permissions: task planning and
+launch still fail closed when the selected harness cannot supply the configured
+unattended messaging and checkpoint capabilities.
+
 `ours-fleet init -c /path/custom.yaml` reviews the literal resolved manifest and
 `/path/custom/` split directory before doing anything. It requires a TTY and two
 default-No confirmations. You select Codex, Claude, or both; then either one explicit
@@ -514,11 +556,12 @@ task-local `LocalCoordinator`, `Developer`, and `Critic`. The persistent
 `FleetCoordinator` uses the separate packaged `Coordinator` contract and coordination
 model.
 
-Revision-3 role defaults have an explicit fail-closed adoption command: first run
+Revision-3 role defaults and exact revision-4 LocalCoordinator/team defaults have an
+explicit fail-closed adoption command: first run
 `ours-fleet migrate-role-defaults -c FILE` for a zero-write plan, review every removal,
 replacement, addition, preserved custom file, staging path, and recovery path, then rerun
 with `--write`. Only exact semantic matches for packaged-bootstrap and generated
-revision-3 forms are changed; same-named customized files remain byte-identical, and a
+revision-3/4 forms are changed; same-named customized files remain byte-identical, and a
 dangling custom reference refuses publication. Rerunning the migration is a no-op.
 
 For manual adoption of a single newer packaged file, copy the reported source beside the
@@ -582,8 +625,9 @@ optional `rooms.owner.provider` setting is separate and defaults to
 ### Scheduled agent loops
 
 Top-level `loops` schedule literal prompts from trusted local YAML. Enabled targets
-must use a managed session (`acp` or `codex-app-server`); temporary roles never inherit loops, including `roles:
-["*"]`. Fleet rejects an enabled loop when its explicitly selected base config is
+must use a managed session (`acp` or `codex-app-server`); temporary roles never
+inherit these manifest loops, including `roles: ["*"]`. Only their sealed Agent
+Template/CLI-local `loops` apply. Fleet rejects an enabled loop when its explicitly selected base config is
 a symlink, is owned by another user, or is group/world writable. Prompts are
 bounded and normalized at validation time, but only their size and SHA-256 appear
 in `config`, `list`, logs, or durable state.

package/dist/application/task-room-service.js

@@ -625,15 +625,24 @@ export class TaskRoomApplicationService {
             throw new TaskRoomApplicationError('template_mismatch', 'anonymous override does not match the existing Room launch policy', { room: task.room_id });
         if (TASK_TERMINAL_STATES.includes(task.state))
             throw new TaskRoomApplicationError('task_terminal', 'task terminal', { task: input.taskId, state: task.state });
+        const durableTemplate = task.room_id
+            ? getRoomRecord(task.room_id)?.template_snapshot ?? task.execution_plan?.snapshot
+            : task.execution_plan?.snapshot;
+        const templateRequestMatches = !input.template || (durableTemplate !== undefined
+            && (input.template === durableTemplate.name
+                || input.template === `${durableTemplate.name}@${durableTemplate.version}`));
+        const memberRequestMatches = input.members === undefined || (task.execution_plan !== undefined
+            && task.execution_plan.overrides_hash === hashMemberOverrides(input.members));
+        const durableRequestMatches = durableTemplate !== undefined
+            && templateRequestMatches && memberRequestMatches;
         if (task.state === 'active' && task.room_id) {
             if (input.template || input.members) {
-                const pinned = getRoomRecord(task.room_id)?.template_snapshot ?? task.execution_plan?.snapshot;
+                const pinned = durableTemplate;
                 if (!pinned)
                     throw new TaskRoomApplicationError('template_mismatch', 'active task has no durable execution plan', { room: task.room_id });
-                const templateName = input.template ?? pinned.name;
-                if ((!input.template || input.template === pinned.name) && input.members
-                    && task.execution_plan?.overrides_hash === hashMemberOverrides(input.members))
+                if (durableRequestMatches)
                     return { task, status: 'already_active' };
+                const templateName = input.template ?? pinned.name;
                 const definition = resolveTemplate(templateName, cfg.roomTemplates ?? {});
                 if (!definition)
                     throw new TaskRoomApplicationError('template_not_found', 'template not found', { template: templateName });
@@ -654,11 +663,10 @@ export class TaskRoomApplicationService {
             throw new Error(`task ${task.task_id} template reference does not match its durable execution snapshot`);
         const templateName = input.template ?? durable?.name ?? task.template?.name
             ?? cfg.tasks?.default_room_template ?? cfg.rooms?.defaults?.template ?? 'single';
-        const storedOverridesMatch = !!(durable && input.members && task.execution_plan?.overrides_hash
-            === hashMemberOverrides(input.members));
-        const definition = durable && !input.template && (!input.members || storedOverridesMatch) ? undefined
+        const storedOverridesMatch = !!(durable && memberRequestMatches);
+        const definition = durable && durableRequestMatches ? undefined
             : resolveTemplate(templateName, cfg.roomTemplates ?? {});
-        if (input.template && !definition)
+        if (input.template && !definition && !durableRequestMatches)
             throw new TaskRoomApplicationError('template_not_found', 'template not found', { template: templateName });
         if (!durable && !definition)
             throw new TaskRoomApplicationError('template_not_found', 'template not found', { template: templateName });

package/dist/build-info.json

@@ -1,9 +1,9 @@
 {
-  "version": "1.1.0-nightly.20",
-  "buildId": "1e57994b7fe2",
-  "commit": "4921e26d6cae40636146ace372eb9aa73dffb799",
+  "version": "1.1.0-nightly.22",
+  "buildId": "bfb51e6ced00",
+  "commit": "5447c29d81481c7880fa9cf5bfbbcc2ff294950f",
   "dirty": true,
-  "builtAt": "2026-09-01T14:06:50.386Z",
+  "builtAt": "2026-09-01T19:41:56.761Z",
   "capabilities": [
     "monitor.interrupt.after_tool"
   ]

package/dist/cli.js

@@ -14,7 +14,7 @@ import { analyzeInstalls, buildInfo, buildLabel, discoverInstalls, runningLabel,
 import { agentDir, agentsRoot, tmpRoot, logsRoot, deriveXdgRuntimeDir, defaultConfigPath } from './paths.js';
 import { findRole, loadConfig, ROLE_NAME_RE } from './config.js';
 import { formatDuration } from './duration.js';
-import { redactSensitive, resolvedPlan } from './resolved-plan.js';
+import { redactSensitive, resolvedPlan, resolvedRolePlan } from './resolved-plan.js';
 import { pickBackend } from './supervisor/index.js';
 import { up, down } from './ops.js';
 import { readRestartLedger, runSupervised, runTemp } from './runner.js';
@@ -26,11 +26,11 @@ import { acquireRunLock, latestReport, listRuns, readReport, releaseRunLock, rep
 import { watchdogAddressable } from './watchdog/query.js';
 import { lastProvenance } from './spawn.js';
 import { stringify } from 'yaml';
-import { resolvedRolePlan } from './resolved-plan.js';
 import { creationBuildNote, formatProvenance, readProvenance } from './creation.js';
 import { doctor } from './doctor.js';
 import { allWarnings, analyzeFleetPermissions, effectivePermissionMode, formatNative, } from './permissions.js';
 import { AI_DOCS } from './docs.js';
+import { renderAgentConfiguration, selectionOrigin, summarizeResolvedLaunch } from './lifecycle-summary.js';
 import { classifyActivity, describeSessionState } from './session/activity.js';
 import { controlRequest, controlSocketPath, followControl, livenessNote, } from './session/control.js';
 import { SessionControlError } from './session/types.js';
@@ -1147,6 +1147,8 @@ cOpt(program.command('spawn [name]').description('spawn a new agent (permanent b
     .option('--filesystem <mode>', 'common filesystem intent: read-only|workspace|unrestricted')
     .option('--unattended <mode>', 'permission behavior without a console: deny|wait')
     .option('--isolation-file <path>', 'file holding an isolation: mapping (same schema as fleet.yaml)')
+    .option('--loops-file <path>', 'owner-only YAML containing exactly loops: for this temporary agent')
+    .option('--no-loops', 'explicitly disable temporary-agent loops')
     .option('--dry-run', 'validate and print without reserving or creating anything')
     .option('--json', 'with --dry-run, emit a stable secret-safe JSON result')
     .action(async (name, opts) => {
@@ -1163,6 +1165,8 @@ cOpt(program.command('spawn [name]').description('spawn a new agent (permanent b
             approval: opts.approval,
             filesystem: opts.filesystem, unattended: opts.unattended,
             isolationFile: opts.isolationFile, configPath: opts.configuration,
+            loopsFile: opts.loopsFile, noLoops: opts.loops === false,
+            loopSource: opts.loopsFile || opts.loops === false ? 'cli' : 'omitted',
             dryRun: opts.dryRun, json: opts.json,
         };
         if (o.json && !o.dryRun)
@@ -1176,7 +1180,7 @@ cOpt(program.command('spawn [name]').description('spawn a new agent (permanent b
                 process.stdout.write(`${JSON.stringify({
                     schemaVersion: result.schemaVersion,
                     warning: result.warning,
-                    roleDocument: result.roleDocument,
+                    roleDocument: redactSensitive(result.roleDocument),
                     resolvedRole: resolvedRolePlan(result.resolvedRole),
                 }, null, 2)}\n`);
             }
@@ -1190,7 +1194,7 @@ cOpt(program.command('spawn [name]').description('spawn a new agent (permanent b
         if (proxyStateDir) {
             // Paths entered in the agent shell belong to that shell's cwd, not the
             // supervisor process. Normalize before crossing the control boundary.
-            for (const key of ['isolationFile']) {
+            for (const key of ['isolationFile', 'loopsFile']) {
                 if (o[key])
                     o[key] = resolvePath(o[key]);
             }
@@ -1211,6 +1215,8 @@ cOpt(program.command('spawn [name]').description('spawn a new agent (permanent b
                 + `monitor=${result.monitor.mode} interrupt=${result.monitor.interrupt}`);
             if (result.inherited.length)
                 console.log(`  inherited omitted defaults from ${result.caller}: ${result.inherited.join(', ')}`);
+            if (result.configuration)
+                console.log(`  ${renderAgentConfiguration(result.configuration)}`);
             console.log(`→ watch it: ours-fleet peek ${result.role}   |   attach: ours-fleet attach ${result.role}`);
             return;
         }
@@ -1235,6 +1241,11 @@ cOpt(program.command('spawn [name]').description('spawn a new agent (permanent b
         }
         console.log(`  permission=${plannedPermissionMode.fleetMode} `
             + `native=${plannedPermissionMode.nativeMode}`);
+        console.log(`  ${renderAgentConfiguration(summarizeResolvedLaunch(created.plan.preview.resolvedRole, {
+            role: selectionOrigin(o.role ?? o.agentDefinition?.role),
+            brain: selectionOrigin(o.brain ?? o.agentDefinition?.brain),
+            permissionMode: plannedPermissionMode,
+        }))}`);
         console.log(`→ watch it: ours-fleet peek ${roleName}   |   attach: ours-fleet attach ${roleName}`);
     }
     catch (e) {

package/dist/config.d.ts

@@ -1,7 +1,7 @@
 import { type ConfigDiagnostic, type YamlMode } from './config-yaml.js';
 import type { IsolationConfig, WrapContext } from './isolation/types.js';
 import type { ResolvedWatchdog } from './watchdog/config.js';
-import type { ResolvedLoop, ResolvedRoleLoop } from './loops/config.js';
+import type { AgentLoopsConfig, ResolvedLoop, ResolvedRoleLoop } from './loops/config.js';
 export interface OverseeEntry {
     agent: string;
     interval: string;
@@ -162,6 +162,8 @@ export interface AgentDefinition {
     owner_channel?: OwnerChannelConfigInput;
     worklog?: WorklogPolicyInput;
     auth_proxy?: Partial<AuthProxyConfig>;
+    /** Scheduled turns scoped only to temporary launches; persistent Agents reject this field. */
+    loops?: AgentLoopsConfig;
 }
 /** Inert, reusable launch definition. It never owns an identity or runtime state. */
 export type AgentTemplateDefinition = Omit<AgentDefinition, 'identity'>;
@@ -202,6 +204,10 @@ export interface ResolvedRole extends Omit<RoleConfig, 'model' | 'owner_channel'
     worklog?: WorklogPolicy;
     auth_proxy?: AuthProxyConfig;
     loops?: ResolvedRoleLoop[];
+    /** Agent Template-local loops, kept separate from manifest loops until a temp launch. */
+    temporaryLoops?: ResolvedRoleLoop[];
+    /** Durable source of the temporary loop policy; internal and never user-authored. */
+    temporaryLoopSource?: 'agent-template' | 'cli' | 'omitted';
     provenance?: Record<string, FieldProvenance>;
     /** Internal/transient: never accepted as a user-authored RoleConfig key. */
     roomMemberStartup?: RoomMemberStartup;
@@ -294,6 +300,7 @@ export declare function loadConfig(configPath?: string, options?: {
     additionalAgent?: {
         id: string;
         definition: AgentDefinition;
+        temporary?: boolean;
     };
     skipWatchdogs?: boolean;
 }): FleetConfig;

package/dist/config.js

@@ -6,7 +6,7 @@ import { harnessRuntimeDir, resolveIsolation, validateIsolationConfig, } from '.
 import { getAdapter } from './harness/registry.js';
 import { resolveRoleModelEnv } from './model-env.js';
 import { resolveWatchdogs } from './watchdog/config.js';
-import { resolveLoops } from './loops/config.js';
+import { resolveAgentLoops, resolveLoops } from './loops/config.js';
 import { validateRoomsConfig, validateTasksConfig, validateRoomTemplatesConfig, } from './rooms-tasks/config.js';
 import { CAPABILITIES, CAP_MONITOR_INTERRUPT_AFTER_TOOL } from './capabilities.js';
 import { runningLabel } from './provenance.js';
@@ -142,12 +142,12 @@ export const BRAIN_PRESET_KEYS = [
 ];
 export const AGENT_KEYS = [
     'role', 'brain', 'permissions', 'identity', 'cwd', 'coordinator', 'env', 'oversee',
-    'isolation', 'monitor', 'owner_channel', 'worklog', 'auth_proxy',
+    'isolation', 'monitor', 'owner_channel', 'worklog', 'auth_proxy', 'loops',
 ];
 const AGENT_INSTANCE_KEYS = ['template', 'overrides'];
 const TEMPLATE_FORBIDDEN_KEYS = ['identity'];
 const MERGED_MAP_FIELDS = new Set([
-    'permissions', 'env', 'isolation', 'monitor', 'owner_channel', 'worklog', 'auth_proxy',
+    'permissions', 'env', 'isolation', 'monitor', 'owner_channel', 'worklog', 'auth_proxy', 'loops',
 ]);
 const V2_API_VERSION = 'ours.network/fleet/v2';
 const utf8Bytes = (value) => Buffer.byteLength(value, 'utf8');
@@ -221,6 +221,10 @@ export function validateEffectiveAgentTemplate(definition, id = 'room-member') {
     return value;
 }
 function validateAgentScalars(value, file, id) {
+    if (value.loops !== undefined)
+        resolveAgentLoops(value.loops, {
+            name: id, harness: 'codex', session: 'acp', permissions: {},
+        }, file);
     for (const key of ['identity', 'cwd']) {
         const current = value[key];
         if (current !== undefined && (typeof current !== 'string' || !current.trim()))
@@ -471,6 +475,8 @@ function composeSplitRoles(base, baseDoc, yamlMode, diagnostics, files, addition
         }
         if (!('role' in a) || !('brain' in a))
             throw new ConfigError(`${agent.file}: agent '${id}' requires role and brain`);
+        if (Object.hasOwn(a, 'loops') && !(additionalAgent?.temporary && additionalAgent.id === id))
+            schemaError(agent.file, `/agents/${id}/loops`, 'is supported only for temporary Agent launches and inert Agent Templates');
         const role = selection(a.role, 'role', agent.file, roles, ROLE_PRESET_KEYS);
         const brain = selection(a.brain, 'brain', agent.file, brains, BRAIN_PRESET_KEYS);
         const operational = deepSubStrict(Object.fromEntries(Object.entries(a).filter(([key]) => key !== 'role' && key !== 'brain')), vars, agent.file, `/agents/${id}`);
@@ -545,8 +551,9 @@ function composeSplitRoles(base, baseDoc, yamlMode, diagnostics, files, addition
             brain: deepSubStrict(a.brain, vars, agent.file, `/agents/${id}/brain`),
             ...operational,
         };
+        const { loops: _temporaryLoops, ...runtimeOperational } = operational;
         documents.push({ file: agent.file,
-            doc: { roles: { [id]: { ...brainValue, ...roleValue, ...operational } } }, provenance,
+            doc: { roles: { [id]: { ...brainValue, ...roleValue, ...runtimeOperational } } }, provenance,
             agentSelections: structuredClone({ role: canonicalDefinition.role, brain: canonicalDefinition.brain }),
             agentDefinition: canonicalDefinition,
             ...(agentTemplate ? { agentTemplate } : {}) });
@@ -677,7 +684,7 @@ export function loadConfig(configPath, options = {}) {
             defaulted('identity', r.identity !== undefined, r.identity === undefined);
             defaulted('permissions', defaults.permissions !== undefined, defaults.permissions === undefined);
             defaulted('monitor', defaults.monitor !== undefined, defaults.monitor === undefined);
-            roles.push({
+            const resolvedRole = {
                 ...r,
                 name,
                 sourceFile: file,
@@ -701,7 +708,10 @@ export function loadConfig(configPath, options = {}) {
                 loops: [],
                 ...(agentSelections ? { agentSelections } : {}),
                 ...(agentTemplate ? { agentTemplate } : {}),
-            });
+            };
+            if (agentDefinition?.loops !== undefined)
+                resolvedRole.temporaryLoops = resolveAgentLoops(agentDefinition.loops, resolvedRole, file);
+            roles.push(resolvedRole);
             // Forbidden-path enforcement: a mount that would breach the policy
             // is a configuration error, caught by `config` rather than at launch.
             if (isolation !== undefined) {
@@ -806,7 +816,7 @@ export function loadConfig(configPath, options = {}) {
 /** Full read-only Agent resolution used by launch dry-runs and room plan validation. */
 export function resolveAgentDefinitionDryRun(configPath, id, definition) {
     return findRole(loadConfig(configPath, {
-        additionalAgent: { id, definition }, skipWatchdogs: true,
+        additionalAgent: { id, definition, temporary: true }, skipWatchdogs: true,
     }), id);
 }
 /**

package/dist/creation.d.ts

@@ -156,7 +156,7 @@ export declare function daemonIdentityInventoryProvisioner(env?: NodeJS.ProcessE
 /** Atomically write a bare Agent file, journalling it for rollback. */
 export declare function writeRoleFile(tx: CreationTransaction, file: string, contents: string): void;
 /** Where a setting's effective value came from. */
-export type ProvenanceSource = 'cli' | 'fleet-default' | 'caller-role' | 'built-in';
+export type ProvenanceSource = 'cli' | 'agent-template' | 'fleet-default' | 'caller-role' | 'built-in';
 export interface ProvenanceEntry {
     value: unknown;
     source: ProvenanceSource;

package/dist/creation.js

@@ -374,11 +374,12 @@ export function creationBuildNote(p) {
 export function formatProvenance(p) {
     const mark = {
         cli: 'explicit', 'fleet-default': 'fleet default', 'caller-role': 'caller role',
-        'built-in': 'built-in',
+        'agent-template': 'Agent Template', 'built-in': 'built-in',
     };
     return Object.entries(p.settings)
         .filter(([, e]) => e.value !== undefined)
-        .map(([k, e]) => `    ${k.padEnd(12)} ${String(e.value)}  (${mark[e.source]})`);
+        .map(([k, e]) => `    ${k.padEnd(12)} ${e.value && typeof e.value === 'object'
+        ? JSON.stringify(e.value) : String(e.value)}  (${mark[e.source]})`);
 }
 /** Classify one setting: an explicit CLI value, a fleet default, or built-in. */
 export function provenanceOf(cliValue, fleetDefault, builtIn) {