@ours.network/fleet 1.0.5 → 1.1.0-nightly.10

package/dist/rooms-tasks/provision.js

@@ -1,10 +1,10 @@
-import { randomUUID } from 'node:crypto';
-import { existsSync, readFileSync, realpathSync } from 'node:fs';
+import { createHash, randomUUID } from 'node:crypto';
+import { existsSync, readFileSync, realpathSync, statSync } from 'node:fs';
 import { parse } from 'yaml';
 import { advanceSaga, setSagaError, updateMemberSeats, updateMemberStartup, activateRoom, getRoomRecord, } from './room-state.js';
 import { activateTask, updateTaskMembers, blockTask, unblockTask, getTask, } from './task-state.js';
 import { spawnTemp } from '../spawn.js';
-import { findRole } from '../config.js';
+import { findRole, loadConfig } from '../config.js';
 import { FLEET_PROXY_CALLER_ENV, FLEET_PROXY_STATE_DIR_ENV, } from '../fleet-proxy.js';
 import { controlRequest } from '../session/control.js';
 import { SessionControlError } from '../session/types.js';
@@ -13,6 +13,7 @@ import { buildRoomMemberTask, sha256Text } from './member-startup.js';
 import { agentDir } from '../paths.js';
 import { readProvenance } from '../creation.js';
 import { readTempSupervisor, secureStoppedTempArchive, tempArchiveForCreationAction, tempSupervisorLiveness, } from '../temp-lifecycle.js';
+import { recordFleetAuditPresentation } from '../fleet-command-audit.js';
 export function getBinPath() {
     try {
         return realpathSync(process.argv[1]);
@@ -21,6 +22,45 @@ export function getBinPath() {
         return process.argv[1];
     }
 }
+function canonicalJson(value) {
+    if (Array.isArray(value))
+        return `[${value.map(canonicalJson).join(',')}]`;
+    if (value && typeof value === 'object')
+        return `{${Object.entries(value)
+            .sort(([a], [b]) => a.localeCompare(b))
+            .map(([key, item]) => `${JSON.stringify(key)}:${canonicalJson(item)}`).join(',')}}`;
+    return JSON.stringify(value);
+}
+function selectionSummary(selection) {
+    if ('ref' in selection)
+        return `ref:${selection.ref} (reference)`;
+    return `inline:sha256:${createHash('sha256').update(canonicalJson(selection.inline)).digest('hex').slice(0, 16)} (inline)`;
+}
+function permissionSummary(definition) {
+    const permissions = definition.permissions;
+    if (!permissions)
+        return undefined;
+    return `approval=${permissions.approval},filesystem=${permissions.filesystem},unattended=${permissions.unattended}`;
+}
+function launchDefinition(definition) {
+    const selectionEvidence = (selection) => 'ref' in selection ? { kind: 'ref', id: selection.ref } : {
+        kind: 'inline', fingerprint: `sha256:${createHash('sha256')
+            .update(canonicalJson(selection.inline)).digest('hex').slice(0, 16)}`,
+    };
+    return {
+        projection: {
+            brain: selectionEvidence(definition.brain), role: selectionEvidence(definition.role),
+            ...(definition.permissions ? { permissions: {
+                    approval: definition.permissions.approval,
+                    filesystem: definition.permissions.filesystem,
+                    unattended: definition.permissions.unattended,
+                } } : {}),
+            operationalFields: Object.keys(definition)
+                .filter(key => key !== 'brain' && key !== 'role').sort(),
+        },
+        fingerprint: createHash('sha256').update(canonicalJson(definition)).digest('hex'),
+    };
+}
 async function spawnRoomMember(options, binPath) {
     const stateDir = process.env[FLEET_PROXY_STATE_DIR_ENV];
     if (!stateDir)
@@ -52,28 +92,31 @@ function expandMembers(template, prefix) {
                 name: `${prefix}-${slot.slot}-${i}`,
                 slot: slot.slot,
                 coworkRole: slot.role,
-                roleRef: slot.role_ref,
-                overrides: slot.overrides,
+                agent: structuredClone(slot.agent),
             });
         }
     }
     return result;
 }
 function settingsFor(member, cfg) {
-    let refRole;
-    try {
-        refRole = findRole(cfg, member.roleRef);
+    if (!('ref' in member.agent)) {
+        const role = member.agent.role;
+        if (cfg.files[0] && existsSync(cfg.files[0]) && statSync(cfg.files[0]).isFile())
+            loadConfig(cfg.files[0], { additionalAgent: {
+                    id: `RoomPreflight${member.name.replace(/[^A-Za-z0-9_-]/g, '')}`.slice(0, 64),
+                    definition: member.agent,
+                } });
+        return { definition: structuredClone(member.agent),
+            ...('inline' in role && typeof role.inline.persona === 'string'
+                ? { persona: role.inline.persona } : {}) };
     }
-    catch { /* no ref role */ }
-    const permissions = member.overrides?.permissions;
+    const refRole = findRole(cfg, member.agent.ref);
+    const definition = cfg.agentDefinitions?.[member.agent.ref];
+    if (!definition)
+        throw new Error(`Agent '${member.agent.ref}' has no canonical definition`);
     return {
-        model: member.overrides?.model ?? refRole?.model,
-        harness: member.overrides?.harness ?? refRole?.harness,
-        cwd: member.overrides?.cwd ?? refRole?.cwd,
-        persona: member.overrides?.persona ?? refRole?.persona,
-        approval: permissions?.approval,
-        filesystem: permissions?.filesystem,
-        unattended: permissions?.unattended,
+        definition: structuredClone(definition),
+        persona: refRole.persona,
     };
 }
 function roomTask(input, member, settings, members, roomIdentityCid, ownerSeatCid) {
@@ -104,13 +147,11 @@ function launchMatches(dir, member, actionId, taskSha, roomId, roomIdentityCid,
         const role = parse(readFileSync(`${dir}/role.yaml`, 'utf8'));
         const startup = role.roomMemberStartup;
         return role.identity === member.name
-            && typeof role.mission === 'string'
-            && sha256Text(role.mission) === taskSha
             && startup?.room_id === roomId
             && startup.room_identity_cid === roomIdentityCid
             && startup.identity_name === member.name
             && startup.role === member.coworkRole
-            && startup.task === role.mission
+            && sha256Text(startup.task ?? '') === taskSha
             && (expectedInviteId === undefined || startup.invite_id === expectedInviteId)
             && typeof startup.invite === 'string'
             && startup.invite.length > 0;
@@ -199,10 +240,13 @@ async function launchMember(input) {
     let effectiveActionId = actionId;
     const attempt = (seat.launch?.attempt ?? 0) + 1;
     const taskSha = sha256Text(startup.task);
+    const effectiveAgentDefinition = structuredClone(settings.definition);
+    const { projection: agentDefinition, fingerprint: agentFingerprint } = launchDefinition(effectiveAgentDefinition);
     const proxyCaller = process.env[FLEET_PROXY_STATE_DIR_ENV]
         ? process.env[FLEET_PROXY_CALLER_ENV] : undefined;
     updateMemberStartup(provision.roomId, member.name, { launch: {
             state: 'intent', attempt, action_id: actionId, mission_sha256: taskSha,
+            agent_definition: agentDefinition, agent_fingerprint: agentFingerprint,
             ...(proxyCaller ? { caller_role: proxyCaller } : {}),
             updated_at: new Date().toISOString(),
         } });
@@ -211,13 +255,7 @@ async function launchMember(input) {
             name: member.name,
             temp: true,
             identity: member.name,
-            mission: startup.task,
-            model: settings.model,
-            harness: settings.harness,
-            cwd: settings.cwd,
-            approval: settings.approval,
-            filesystem: settings.filesystem,
-            unattended: settings.unattended,
+            agentDefinition: settings.definition,
             surface: 'agent',
             creationActionId: actionId,
             roomMemberStartup: startup,
@@ -227,7 +265,8 @@ async function launchMember(input) {
         if (launched.creationActionId !== actionId) {
             updateMemberStartup(provision.roomId, member.name, { launch: {
                     state: 'intent', attempt, action_id: launched.creationActionId,
-                    mission_sha256: taskSha, updated_at: new Date().toISOString(),
+                    mission_sha256: taskSha, agent_definition: agentDefinition,
+                    agent_fingerprint: agentFingerprint, updated_at: new Date().toISOString(),
                     ...(launched.callerRole ? { caller_role: launched.callerRole } : {}),
                 } });
         }
@@ -237,17 +276,26 @@ async function launchMember(input) {
         }
         updateMemberStartup(provision.roomId, member.name, { launch: {
                 state: 'launched', attempt, action_id: launched.creationActionId, mission_sha256: taskSha,
+                agent_definition: agentDefinition, agent_fingerprint: agentFingerprint,
                 ...(launched.callerRole ? { caller_role: launched.callerRole } : {}),
                 launch_id: supervisor.launchId, updated_at: new Date().toISOString(),
             } });
+        recordFleetAuditPresentation({ kind: 'agent_started', id: member.name, name: member.name,
+            lifetime: 'temporary', brain: selectionSummary(settings.definition.brain),
+            role: selectionSummary(settings.definition.role), harness: 'resolved', session: 'acp',
+            permissions: permissionSummary(settings.definition), parent: provision.roomId,
+            actionId: launched.creationActionId, inherited: [] });
     }
     catch (error) {
         updateMemberStartup(provision.roomId, member.name, { launch: {
                 state: 'failed', attempt, action_id: effectiveActionId, mission_sha256: taskSha,
+                agent_definition: agentDefinition, agent_fingerprint: agentFingerprint,
                 ...(proxyCaller ? { caller_role: proxyCaller } : {}),
                 updated_at: new Date().toISOString(),
                 error: error instanceof Error ? error.message : String(error),
             } });
+        recordFleetAuditPresentation({ kind: 'lifecycle_failure', resource: 'Agent', id: member.name,
+            state: 'failed', category: 'readiness_failed', eventId: effectiveActionId });
         throw error;
     }
 }
@@ -289,6 +337,8 @@ export async function provisionMembers(input) {
     const { cfg, cowork, roomId, taskId, template } = input;
     const prefix = taskId ? shortId(taskId) : `room-${shortId(roomId)}`;
     const members = expandMembers(template, prefix);
+    // Resolve every Agent before persisting launch intent or touching Cowork membership.
+    const settings = new Map(members.map(member => [member.name, settingsFor(member, cfg)]));
     const existing = getRoomRecord(roomId);
     if (!existing?.room_identity_cid)
         throw new Error(`room ${roomId} has no pinned room identity CID`);
@@ -299,15 +349,27 @@ export async function provisionMembers(input) {
         && members.every(member => persistedNames.has(member.name));
     if (!resuming) {
         advanceSaga(roomId, 'create_members', 3);
-        updateMemberSeats(roomId, members.map(member => ({
-            role_name: member.name,
-            slot: member.slot,
-            cowork_role: member.coworkRole,
-            seat_state: 'pending',
-            launch: { state: 'pending', attempt: 0, updated_at: new Date().toISOString() },
-        })));
+        updateMemberSeats(roomId, members.map(member => {
+            const evidence = launchDefinition(settings.get(member.name).definition);
+            return ({
+                role_name: member.name,
+                slot: member.slot,
+                cowork_role: member.coworkRole,
+                seat_state: 'pending',
+                launch: { state: 'pending', attempt: 0,
+                    agent_definition: evidence.projection, agent_fingerprint: evidence.fingerprint,
+                    updated_at: new Date().toISOString() },
+            });
+        }));
+    }
+    else {
+        for (const member of members) {
+            const seat = existing.member_seats.find(candidate => candidate.role_name === member.name);
+            const evidence = launchDefinition(settings.get(member.name).definition);
+            if (!seat.launch?.agent_fingerprint || seat.launch.agent_fingerprint !== evidence.fingerprint)
+                throw new Error(`Agent definition drift for ${member.name}; durable launch intent does not match current configuration`);
+        }
     }
-    const settings = new Map(members.map(member => [member.name, settingsFor(member, cfg)]));
     const tasks = new Map(members.map(member => [member.name, roomTask(input, member, settings.get(member.name), members, roomIdentityCid, ownerSeatCid)]));
     const policy = {
         timeoutMs: input.startupWait?.timeoutMs ?? 60_000,

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

@@ -1,5 +1,4 @@
 import type { TemplateDefinition, TemplateSnapshot } from './types.js';
-export declare const BUILTIN_TEMPLATES: readonly TemplateDefinition[];
 export declare function hashTemplate(t: TemplateDefinition): string;
 export declare function snapshotTemplate(t: TemplateDefinition): TemplateSnapshot;
 export declare function resolveTemplate(name: string, customTemplates: Record<string, TemplateDefinition>): TemplateDefinition | undefined;

package/dist/rooms-tasks/templates.js

@@ -1,54 +1,4 @@
 import { createHash } from 'node:crypto';
-const TEAM = {
-    name: 'team',
-    version: 1,
-    builtin: true,
-    description: 'Phased task pipeline: Architect specifies, Developer implements, Tester verifies',
-    room: { quiet_membership: false, anonymous: false },
-    contract: [
-        'Architect produces a spec and posts it to the room. Work pauses for owner approval.',
-        'Developer implements per approved spec.',
-        'Tester verifies spec conformance and test coverage.',
-        'Completion requires tester sign-off.',
-    ].join('\n'),
-    members: [
-        { slot: 'architect', role: 'Architect', count: 1, role_ref: 'Architect' },
-        { slot: 'developer', role: 'Developer', count: 1, role_ref: 'Developer' },
-        { slot: 'tester', role: 'Tester', count: 1, role_ref: 'Tester' },
-    ],
-};
-const PAIR = {
-    name: 'pair',
-    version: 1,
-    builtin: true,
-    description: 'Deliberation pair: Secretary writes code, Critic reviews — every decision deliberated together',
-    room: { quiet_membership: false, anonymous: false },
-    contract: [
-        'Secretary and Critic deliberate every decision together before acting.',
-        'Secretary writes code; Critic reviews and challenges.',
-        'No material change lands without both agreeing.',
-        'Completion requires joint sign-off.',
-    ].join('\n'),
-    members: [
-        { slot: 'secretary', role: 'Secretary', count: 1, role_ref: 'Secretary' },
-        { slot: 'critic', role: 'Critic', count: 1, role_ref: 'Critic' },
-    ],
-};
-const SINGLE = {
-    name: 'single',
-    version: 1,
-    builtin: true,
-    description: 'Solo agent: one general-purpose agent works the task with owner oversight',
-    room: { quiet_membership: false, anonymous: false },
-    contract: [
-        'Agent works the task autonomously, consulting the owner when blocked.',
-        'Owner reviews and approves completion.',
-    ].join('\n'),
-    members: [
-        { slot: 'agent', role: 'Agent', count: 1, role_ref: 'Agent' },
-    ],
-};
-export const BUILTIN_TEMPLATES = [TEAM, PAIR, SINGLE];
 export function hashTemplate(t) {
     const canonical = JSON.stringify({
         name: t.name, version: t.version, description: t.description,
@@ -57,38 +7,21 @@ export function hashTemplate(t) {
     return createHash('sha256').update(canonical).digest('hex');
 }
 export function snapshotTemplate(t) {
-    return { ...t, content_hash: hashTemplate(t) };
+    const { sourceFile: _, ...semantic } = t;
+    return { ...semantic, content_hash: hashTemplate(t) };
 }
 export function resolveTemplate(name, customTemplates) {
     const atIdx = name.lastIndexOf('@');
     const baseName = atIdx > 0 ? name.slice(0, atIdx) : name;
     const versionStr = atIdx > 0 ? name.slice(atIdx + 1) : undefined;
     const version = versionStr ? parseInt(versionStr, 10) : undefined;
-    const custom = customTemplates[baseName];
-    if (custom) {
-        if (version !== undefined && custom.version !== version)
-            return undefined;
-        return custom;
-    }
-    const builtin = BUILTIN_TEMPLATES.find(b => b.name === baseName);
-    if (builtin) {
-        if (version !== undefined && builtin.version !== version)
-            return undefined;
-        return builtin;
-    }
-    return undefined;
+    const template = customTemplates[baseName];
+    if (!template || (version !== undefined && template.version !== version))
+        return undefined;
+    return template;
 }
 export function listTemplates(customTemplates) {
-    const result = [];
-    const overridden = new Set();
-    for (const [name, t] of Object.entries(customTemplates)) {
-        result.push({ ...t, name });
-        if (BUILTIN_TEMPLATES.some(b => b.name === name))
-            overridden.add(name);
-    }
-    for (const b of BUILTIN_TEMPLATES) {
-        if (!overridden.has(b.name))
-            result.push(b);
-    }
-    return result.sort((a, b) => a.name.localeCompare(b.name));
+    return Object.entries(customTemplates)
+        .map(([name, template]) => ({ ...template, name }))
+        .sort((a, b) => a.name.localeCompare(b.name));
 }

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

@@ -100,6 +100,9 @@ export interface RoomMemberLaunchState {
     /** Expected authenticated proxy caller while adopting a post-spawn crash. */
     caller_role?: string;
     mission_sha256?: string;
+    /** Redacted, deterministic effective Agent launch definition retained for retry inspection. */
+    agent_definition?: Record<string, unknown>;
+    agent_fingerprint?: string;
     launch_id?: string;
     updated_at: string;
     error?: string;
@@ -189,19 +192,10 @@ export interface TemplateMemberSlot {
     slot: string;
     role: string;
     count: number;
-    role_ref: string;
-    overrides?: TemplateRoleOverrides;
-}
-export interface TemplateRoleOverrides {
-    harness?: string;
-    model?: string;
-    model_chain?: string[];
-    permissions?: Record<string, unknown>;
-    isolation?: Record<string, unknown>;
-    cwd?: string;
-    env?: Record<string, string>;
-    persona?: string;
-    mission?: string;
+    /** Canonical Agent definition, or stable reference to a declared Agent. */
+    agent: import('../config.js').AgentDefinition | {
+        ref: string;
+    };
 }
 export interface TemplateRoomConfig {
     quiet_membership?: boolean;
@@ -211,7 +205,8 @@ export interface TemplateDefinition {
     name: string;
     version: number;
     description: string;
-    builtin?: boolean;
+    /** Authoring provenance only; excluded from snapshots and semantic hashes. */
+    sourceFile?: string;
     room?: TemplateRoomConfig;
     contract?: string;
     members: TemplateMemberSlot[];
@@ -252,5 +247,4 @@ export declare const ROOMS_COWORK_KEYS: readonly ["config"];
 export declare const ROOMS_DEFAULTS_KEYS: readonly ["template", "attach_owner", "close_when_task_done"];
 export declare const TASKS_KEYS: readonly ["default_room_template", "create_mode", "close_room_on_done", "retain_completed_for"];
 export declare const TEMPLATE_KEYS: readonly ["version", "description", "room", "contract", "members", "override_builtin"];
-export declare const TEMPLATE_MEMBER_KEYS: readonly ["slot", "role", "count", "role_ref", "overrides"];
-export declare const TEMPLATE_OVERRIDE_KEYS: readonly ["harness", "model", "model_chain", "permissions", "isolation", "cwd", "env", "persona", "mission"];
+export declare const TEMPLATE_MEMBER_KEYS: readonly ["slot", "role", "count", "agent"];

package/dist/rooms-tasks/types.js

@@ -14,7 +14,4 @@ export const ROOMS_COWORK_KEYS = ['config'];
 export const ROOMS_DEFAULTS_KEYS = ['template', 'attach_owner', 'close_when_task_done'];
 export const TASKS_KEYS = ['default_room_template', 'create_mode', 'close_room_on_done', 'retain_completed_for'];
 export const TEMPLATE_KEYS = ['version', 'description', 'room', 'contract', 'members', 'override_builtin'];
-export const TEMPLATE_MEMBER_KEYS = ['slot', 'role', 'count', 'role_ref', 'overrides'];
-export const TEMPLATE_OVERRIDE_KEYS = [
-    'harness', 'model', 'model_chain', 'permissions', 'isolation', 'cwd', 'env', 'persona', 'mission',
-];
+export const TEMPLATE_MEMBER_KEYS = ['slot', 'role', 'count', 'agent'];

package/dist/runner.d.ts

@@ -1,15 +1,13 @@
 import { type ResolvedRole } from './config.js';
-import type { Launch } from './harness/types.js';
-import { Tmux } from './tmux.js';
 import { type MonitorHandle, type MonitorOpts, type FetchLike } from './monitor.js';
+import { type DaemonGenerationProbe } from './daemon-recovery.js';
 import { type Exec } from './exec.js';
-import { type AcpSessionOptions } from './session/acp.js';
 import { RoleControlServer } from './session/control.js';
-import type { ExitRecord, SessionHandle, TurnResult } from './session/types.js';
+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';
 export interface RunnerDeps {
-    tmux: Tmux;
     exec: Exec;
     cpuDelegated(): boolean;
     isAlive(pid: number): boolean;
@@ -18,14 +16,16 @@ export interface RunnerDeps {
     log(line: string): void;
     /** HTTP transport for the monitor's daemon long-poll (injectable for tests). */
     fetch: FetchLike;
+    probeGeneration(env: NodeJS.ProcessEnv): Promise<DaemonGenerationProbe>;
     /** Construct the supervisor mail monitor (injectable so tests stub it out). */
     createMonitor(opts: MonitorOpts): MonitorHandle;
     /** Construct trusted owner ingress (injectable for lifecycle tests). */
     createOwnerChannel(opts: OwnerChannelOptions): OwnerChannelHandle;
     /** Start the ACP transport (injectable for deterministic runner lifecycle tests). */
-    startAcpSession(opts: AcpSessionOptions): Promise<SessionHandle>;
+    /** Neutral construction seam for deterministic runner lifecycle tests. */
+    startAgentSession(adapter: AgentSessionAdapter, options: AgentSessionStartOptions): Promise<AgentSession>;
     /** Construct the authenticated role control route (injectable where sockets are unavailable). */
-    createControlServer(stateDir: string, session: SessionHandle, log: (line: string) => void): Pick<RoleControlServer, 'start' | 'close' | 'setFleetSpawner' | 'setOwnerChannel' | 'setConfigReloader' | 'setLoopManager'>;
+    createControlServer(stateDir: string, session: AgentSession, log: (line: string) => void): Pick<RoleControlServer, 'start' | 'close' | 'setFleetSpawner' | 'setFleetAuditor' | 'setOwnerChannel' | 'setConfigReloader' | 'setLoopManager'>;
     /** 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. */
@@ -33,6 +33,11 @@ export interface RunnerDeps {
     /** Lets a test (or a shutdown path) end the supervised restart loop. */
     shouldStop?(): boolean;
 }
+export declare const SUPERVISOR_RECYCLE_REQUIRED = "OWNER_CHANNEL_SUPERVISOR_RECYCLE_REQUIRED";
+export declare class SupervisorRecycleRequiredError extends Error {
+    readonly code = "OWNER_CHANNEL_SUPERVISOR_RECYCLE_REQUIRED";
+    constructor();
+}
 /** Environment injected only into the managed harness process. */
 export declare function managedFleetProxyEnv(role: ResolvedRole, stateDir: string): Record<string, string>;
 /**
@@ -51,14 +56,6 @@ export declare function harnessChildEnv(role: ResolvedRole, launchEnv: Record<st
  * responsible for.
  */
 export declare function recordMonitorOwner(dir: string, owner: 'fleet' | 'native'): boolean;
-/**
- * Compose the tmux pane shell command: env prefix + argv + exit-status capture.
- * `paneArgv` defaults to `launch.argv`; when isolation is active the caller passes
- * the sandbox-wrapped argv (e.g. `bwrap … -- claude …`). The `env` prefix and the
- * `echo $? > exitfile` capture stay host-side, outside the sandbox, so the runner
- * still sees the real exit code.
- */
-export declare function buildPaneCommand(launch: Launch, roleEnv: Record<string, string> | undefined, exitStatusPath: string, paneArgv?: string[]): string;
 /**
  * Read the pane's `.exit-status`. Three shapes are accepted: the structured
  * record written above, a bare number left by a pre-upgrade pane (so an
@@ -186,4 +183,4 @@ export declare function runSupervised(name: string, opts?: {
     allowResumeRotation?: boolean;
 }, d: Partial<RunnerDeps>) => Promise<AttemptResult>): Promise<RestartLedger>;
 /** Temp-agent entrypoint: run once, journal why it ended, then archive its evidence. */
-export declare function runTemp(name: string, deps?: Partial<RunnerDeps>): Promise<void>;
+export declare function runTemp(name: string, deps?: Partial<RunnerDeps>, attempt?: typeof runOnce): Promise<void>;