@ours.network/fleet 1.2.0-nightly.3 → 1.2.0-nightly.31

package/dist/subscriptions/store.js

@@ -0,0 +1,140 @@
+import { existsSync, mkdirSync, readFileSync, rmSync, symlinkSync } from 'node:fs';
+import { randomBytes } from 'node:crypto';
+import { join } from 'node:path';
+import { replaceFileAtomically, withFileLock } from '../atomic-file.js';
+import { FleetError } from '../application/errors.js';
+import { homedir } from 'node:os';
+import { stateRoot } from '../paths.js';
+export const SUBSCRIPTION_PROVIDERS = ['claude', 'codex'];
+export const DEFAULT_PROFILE_ID = 'default';
+export const PIN_FILE = '.subscription-pin.json';
+export const OBSERVED_USAGE_FILE = '.subscription-usage.json';
+/** Non-history configuration shared from the base home into each new profile. */
+const SHARED_CONFIG = {
+    claude: ['settings.json', 'CLAUDE.md', 'plugins', 'skills', 'agents', 'commands'],
+    codex: ['config.toml', 'AGENTS.md', 'plugins', 'skills', 'rules'],
+};
+export const PROFILE_ID_RE = /^[a-z0-9][a-z0-9-]{0,40}$/;
+export const subscriptionsRoot = () => join(stateRoot(), 'subscriptions');
+const stateFile = () => join(subscriptionsRoot(), 'state.json');
+const lockPath = () => join(subscriptionsRoot(), '.lock');
+/**
+ * The CLI's own default home, adopted as the `default` profile. This follows
+ * `$HOME` like the CLIs do, not OURS_FLEET_HOME (which may relocate Fleet state).
+ */
+export const baseHome = (provider) => join(homedir(), provider === 'claude' ? '.claude' : '.codex');
+export function isProvider(value) {
+    return value === 'claude' || value === 'codex';
+}
+export function profileHome(provider, profileId) {
+    if (profileId === DEFAULT_PROFILE_ID)
+        return baseHome(provider);
+    if (!PROFILE_ID_RE.test(profileId))
+        throw new FleetError('invalid_request', 'invalid profile id');
+    return join(subscriptionsRoot(), provider, profileId);
+}
+function initialState() {
+    const provider = () => ({
+        activeProfileId: DEFAULT_PROFILE_ID,
+        profiles: [{ id: DEFAULT_PROFILE_ID, label: 'Default (existing login)', createdAt: new Date(0).toISOString() }],
+    });
+    return { version: 1, providers: { claude: provider(), codex: provider() } };
+}
+/**
+ * Read the state. The file is only ever replaced by an atomic rename, so a
+ * reader (including a launching agent) sees either the old or the new active
+ * profile, never a torn write.
+ */
+export function readSubscriptionState() {
+    let text;
+    try {
+        text = readFileSync(stateFile(), 'utf8');
+    }
+    catch (error) {
+        if (error.code === 'ENOENT')
+            return initialState();
+        throw unreadable();
+    }
+    // Fail closed: a damaged state file must not silently move launches to another account.
+    let raw;
+    try {
+        raw = JSON.parse(text);
+    }
+    catch {
+        throw unreadable();
+    }
+    const state = initialState();
+    const providers = raw?.providers;
+    if (!providers || typeof providers !== 'object')
+        throw unreadable();
+    for (const provider of SUBSCRIPTION_PROVIDERS) {
+        const p = providers[provider];
+        if (!p || !Array.isArray(p.profiles) || typeof p.activeProfileId !== 'string')
+            throw unreadable();
+        const profiles = p.profiles;
+        if (profiles.some(x => !x || typeof x.id !== 'string' || (x.id !== DEFAULT_PROFILE_ID && !PROFILE_ID_RE.test(x.id))))
+            throw unreadable();
+        if (!profiles.some(x => x.id === DEFAULT_PROFILE_ID))
+            profiles.unshift(state.providers[provider].profiles[0]);
+        if (!profiles.some(x => x.id === p.activeProfileId))
+            throw unreadable();
+        const active = p.activeProfileId;
+        state.providers[provider] = {
+            activeProfileId: active,
+            profiles: profiles.map(x => ({ id: x.id, label: String(x.label ?? x.id).slice(0, 80), createdAt: String(x.createdAt ?? '') })),
+        };
+    }
+    return state;
+}
+const unreadable = () => new FleetError('prerequisite_unavailable', `subscription state ${stateFile()} is unreadable or invalid; fix or remove it before starting agents`);
+/** Serialised read-modify-write of the state under a cross-process lock. */
+export async function updateSubscriptionState(fn) {
+    mkdirSync(subscriptionsRoot(), { recursive: true, mode: 0o700 });
+    return withFileLock(lockPath(), () => {
+        const state = readSubscriptionState();
+        const result = fn(state);
+        replaceFileAtomically(stateFile(), `${JSON.stringify(state, null, 2)}\n`, 0o600);
+        return result;
+    });
+}
+/**
+ * Create an empty profile home (not yet registered). Shared, non-history
+ * configuration is symlinked from the base home; credentials and session
+ * history stay per profile.
+ */
+export function createProfileHome(provider) {
+    const id = `p-${randomBytes(6).toString('hex')}`;
+    const dir = profileHome(provider, id);
+    mkdirSync(dir, { recursive: true, mode: 0o700 });
+    const base = baseHome(provider);
+    for (const name of SHARED_CONFIG[provider]) {
+        const src = join(base, name);
+        if (existsSync(src)) {
+            try {
+                symlinkSync(src, join(dir, name));
+            }
+            catch { /* optional convenience */ }
+        }
+    }
+    return { id, home: dir };
+}
+/** Remove a non-default profile home. Never touches the adopted default. */
+export function removeProfileHome(provider, profileId) {
+    if (profileId === DEFAULT_PROFILE_ID)
+        return;
+    rmSync(profileHome(provider, profileId), { recursive: true, force: true });
+}
+export function readPin(stateDir, provider) {
+    try {
+        const pin = JSON.parse(readFileSync(join(stateDir, PIN_FILE), 'utf8'));
+        if (provider)
+            return pin[provider];
+        return Object.values(pin)[0];
+    }
+    catch {
+        return undefined;
+    }
+}
+export function writePin(stateDir, pin) {
+    replaceFileAtomically(join(stateDir, PIN_FILE), `${JSON.stringify({ [pin.provider]: pin })}\n`, 0o600);
+}

package/dist/supervisor/launchd.js

@@ -1,3 +1,4 @@
+import { clientConfigPath } from '../client-profile.js';
 import { existsSync, mkdirSync, writeFileSync, rmSync } from 'node:fs';
 import { join } from 'node:path';
 import { home, logsRoot } from '../paths.js';
@@ -22,7 +23,7 @@ const xml = (value) => value
     .replaceAll("'", ''');
 function plist(name, binPath) {
     const log = join(logsRoot(), `${name}.log`);
-    const config = process.env.OURS_CONFIG;
+    const config = clientConfigPath(process.env);
     return `<?xml version="1.0" encoding="UTF-8"?>
 <!DOCTYPE plist PUBLIC "-//Apple//DTD PLIST 1.0//EN" "http://www.apple.com/DTDs/PropertyList-1.0.dtd">
 <plist version="1.0">

package/dist/supervisor/systemd.js

@@ -1,3 +1,4 @@
+import { clientConfigPath } from '../client-profile.js';
 import { mkdirSync, writeFileSync } from 'node:fs';
 import { delimiter, dirname, join } from 'node:path';
 import { userInfo } from 'node:os';
@@ -69,30 +70,10 @@ export function makeSystemdBackend(exec = realExec) {
                     dirname(process.execPath),
                     ...(process.env.PATH ?? '').split(delimiter),
                 ].filter(Boolean))].join(delimiter);
-            // Same reason as PATH, for the other thing a lingering unit cannot inherit:
-            // WHICH ours daemon this fleet was set up against.
-            //
-            // ours-fleet resolves its daemon from OURS_CONFIG / OURS_PORT / OURS_STATE_DIR
-            // and otherwise falls back to ~/.ours and port 3050 (src/monitor.ts). A host
-            // set up against a non-default daemon — the installer's multi-daemon profiles
-            // do exactly this — passes that selection to `ours-fleet init` in the
-            // environment, and it died there: nothing persisted it, so every runner
-            // systemd started at boot resolved the default daemon again, and on a host
-            // where only the non-default daemon exists that is a daemon that is not there.
-            //
-            // ONLY OURS_CONFIG is baked, deliberately. It names which daemon, and leaves
-            // that daemon's own config file authoritative for port and state directory, so
-            // a later edit to it still wins. Baking OURS_PORT/OURS_STATE_DIR would freeze
-            // those into a unit file that outranks the config for ever after — the failure
-            // mode @ours.network/cli avoids for the same reason (packages/cli/src/
-            // service.ts: "The port is deliberately NOT baked").
-            //
-            // Absent from init's environment ⇒ no line, and the unit is byte-for-byte what
-            // it has always been. This teaches fleet nothing about installer profiles; it
-            // persists the selection fleet was initialised with.
+            // Persist one profile path, never a URL or service port. Profile updates
+            // are picked up by every fresh process, including lingering user services.
             const unitEnv = ['PATH=' + servicePath];
-            if (process.env.OURS_CONFIG)
-                unitEnv.push('OURS_CONFIG=' + process.env.OURS_CONFIG);
+            unitEnv.push('OURS_CONFIG=' + clientConfigPath(process.env));
             const environmentLines = unitEnv
                 .map(value => `Environment="${value.replace(/\\/g, '\\\\').replace(/"/g, '\\"').replace(/%/g, '%%')}"`)
                 .join('\n');
@@ -100,10 +81,15 @@ export function makeSystemdBackend(exec = realExec) {
             writeFileSync(join(unitDir, UNIT_TEMPLATE), `[Unit]
 Description=ours-fleet agent %i
 After=default.target
+StartLimitIntervalSec=0
 
 [Service]
 Type=simple
 ${environmentLines}
+# Wait outside the runner so boot-time daemon unavailability cannot consume
+# the agent crash budget. Selection comes from the same role and profile.
+ExecStartPre=${unitArg(process.execPath)} ${unitArg(binPath)} _wait-daemon %i
+TimeoutStartSec=270
 ExecStart=${unitArg(process.execPath)} ${unitArg(binPath)} _run %i
 # The RUNNER owns the child-session restart loop, with a counted, backed-off
 # circuit breaker. systemd must only recover the runner PROCESS crashing —

package/dist/temp-idle.d.ts

@@ -0,0 +1,17 @@
+import type { SessionSnapshot } from './session/types.js';
+export declare const TEMP_CHAT_IDLE_MS: number;
+export type ChatIdlePolicy = {
+    version: 1;
+    timeoutMs: number;
+    lastActivityAt: number;
+};
+export declare function readChatIdle(dir: string): ChatIdlePolicy | undefined;
+/** Only a standalone temporary supervisor owns this clock; browser reads never touch it. */
+export declare class TemporaryChatIdle {
+    private dir;
+    private value;
+    private busy;
+    constructor(dir: string, now: number);
+    private save;
+    observe(snapshot: SessionSnapshot, queueDepth: number, now: number): boolean;
+}

package/dist/temp-idle.js

@@ -0,0 +1,42 @@
+import { existsSync, readFileSync } from 'node:fs';
+import { join } from 'node:path';
+import { replaceFileAtomically } from './atomic-file.js';
+export const TEMP_CHAT_IDLE_MS = 24 * 60 * 60_000;
+const FILE = 'chat-idle.json';
+export function readChatIdle(dir) {
+    if (!existsSync(join(dir, FILE)))
+        return undefined;
+    const value = JSON.parse(readFileSync(join(dir, FILE), 'utf8'));
+    if (value.version !== 1 || !Number.isSafeInteger(value.lastActivityAt) || value.timeoutMs !== TEMP_CHAT_IDLE_MS)
+        throw new Error('Invalid persisted chat idle policy');
+    return value;
+}
+/** Only a standalone temporary supervisor owns this clock; browser reads never touch it. */
+export class TemporaryChatIdle {
+    dir;
+    value;
+    busy = false;
+    constructor(dir, now) {
+        this.dir = dir;
+        this.value = readChatIdle(dir) ?? { version: 1, timeoutMs: TEMP_CHAT_IDLE_MS, lastActivityAt: now };
+        this.save();
+    }
+    save() { replaceFileAtomically(join(this.dir, FILE), JSON.stringify(this.value) + '\n', 0o600); }
+    observe(snapshot, queueDepth, now) {
+        // Unknown activity evidence never grants permission to retire a session.
+        const idle = snapshot.alive && snapshot.readiness === 'idle' && !snapshot.pendingPermissionId && queueDepth === 0 && snapshot.activity?.activeToolCalls === 0;
+        const update = Date.parse(snapshot.activity?.lastUpdateAt ?? '');
+        let next = this.value.lastActivityAt;
+        if (Number.isFinite(update) && update <= now)
+            next = Math.max(next, update);
+        if (!idle || this.busy)
+            next = Math.max(next, now);
+        this.busy = !idle;
+        // Active work checkpoints at most once a minute, with an immediate idle boundary write.
+        if (next > this.value.lastActivityAt && (idle || next - this.value.lastActivityAt >= 60_000)) {
+            this.value.lastActivityAt = next;
+            this.save();
+        }
+        return idle && now >= this.value.lastActivityAt && now - this.value.lastActivityAt >= this.value.timeoutMs;
+    }
+}

package/dist/temp-lifecycle.d.ts

@@ -5,7 +5,7 @@ export declare const TEMP_STOP_REQUEST_FILE = ".temp-stop-request.json";
 export declare const TEMP_RECLAIM_BATCH = 32;
 export declare const TEMP_LAUNCH_GRACE_MS = 60000;
 export type TempSupervisorKind = 'systemd-transient' | 'launchd-transient' | 'detached';
-export type TempTerminationReason = 'identity-closed' | 'session-ended' | 'operator-stop' | 'supervisor-signal' | 'supervisor-recycle' | 'startup-failure' | 'stale-supervisor';
+export type TempTerminationReason = 'idle-timeout' | 'identity-closed' | 'session-ended' | 'operator-stop' | 'supervisor-signal' | 'supervisor-recycle' | 'startup-failure' | 'stale-supervisor';
 export interface TempSupervisorRecord {
     version: 1;
     role: string;
@@ -44,6 +44,11 @@ export declare function makeTempSupervisorLauncher(options?: {
 }): SupervisorLauncher;
 export declare function markTempSupervisorActive(dir: string, pid?: number): Promise<void>;
 export declare function requestedTempStopReason(dir: string): 'operator-stop' | undefined;
+/** Explicit erasure removes only exact retired role/launch events. */
+export declare function eraseTerminationEvents(launches: ReadonlyArray<{
+    role: string;
+    launchId: string;
+}>): void;
 /** Move retired state out of the live roster without deleting any evidence. */
 export declare function archiveTempState(role: string, reason: TempTerminationReason, outcome: TempTerminationRecord['outcome'], detail: string, now?: Date): string | undefined;
 /** Resolve only an exact role+launch archive; names and timestamps are never proof. */

package/dist/temp-lifecycle.js

@@ -1,7 +1,7 @@
 import { appendFileSync, existsSync, mkdirSync, readFileSync, readdirSync, renameSync, statSync, } from 'node:fs';
 import { randomUUID } from 'node:crypto';
 import { basename, join } from 'node:path';
-import { replaceFileAtomically, withFileLock } from './atomic-file.js';
+import { replaceFileAtomically, withFileLock, withSynchronousFileLock } from './atomic-file.js';
 import { realExec } from './exec.js';
 import { stateRoot, tmpRoot } from './paths.js';
 export const TEMP_SUPERVISOR_FILE = '.temp-supervisor.json';
@@ -59,7 +59,7 @@ export function makeTempSupervisorLauncher(options = {}) {
     const supervisor = options.supervisor ?? process.env.OURS_FLEET_SUPERVISOR;
     return async (binPath, args, dir) => {
         const inherited = [
-            'HOME', 'PATH', 'XDG_RUNTIME_DIR', 'OURS_FLEET_HOME', 'CODEX_HOME',
+            'HOME', 'PATH', 'XDG_RUNTIME_DIR', 'OURS_FLEET_HOME', 'OURS_FLEET_SOCKET_ROOT', 'CODEX_HOME',
             // Preserve runtime selection across the service-manager boundary, including
             // an explicit empty value which selects the bundle over manager defaults.
             'CODEX_PATH',
@@ -133,18 +133,34 @@ function appendTermination(dir, record) {
     replaceFileAtomically(join(dir, TEMP_GLOBAL_TERMINATION_MARKER), line);
 }
 function appendGlobalTermination(line, checkExisting = false) {
-    mkdirSync(archiveRoot(), { recursive: true, mode: 0o700 });
-    const path = join(archiveRoot(), 'terminations.jsonl');
-    // Recovery may revisit a .retiring directory after a crash between the
-    // global append and final rename. Avoid duplicating that exact event.
-    if (checkExisting) {
-        try {
-            if (readFileSync(path, 'utf8').split('\n').includes(line.trimEnd()))
-                return;
+    withSynchronousFileLock(join(stateRoot(), 'locks', 'termination-journal'), () => {
+        mkdirSync(archiveRoot(), { recursive: true, mode: 0o700 });
+        const path = join(archiveRoot(), 'terminations.jsonl');
+        // Recovery may revisit a .retiring directory after a crash between the
+        // global append and final rename. Avoid duplicating that exact event.
+        if (checkExisting) {
+            try {
+                if (readFileSync(path, 'utf8').split('\n').includes(line.trimEnd()))
+                    return;
+            }
+            catch { /* the journal does not exist yet */ }
         }
-        catch { /* the journal does not exist yet */ }
-    }
-    appendFileSync(path, line, { mode: 0o600 });
+        appendFileSync(path, line, { mode: 0o600 });
+    });
+}
+/** Explicit erasure removes only exact retired role/launch events. */
+export function eraseTerminationEvents(launches) {
+    withSynchronousFileLock(join(stateRoot(), 'locks', 'termination-journal'), () => {
+        const path = join(archiveRoot(), 'terminations.jsonl');
+        if (!existsSync(path))
+            return;
+        const lines = readFileSync(path, 'utf8').split('\n').filter(Boolean);
+        const kept = lines.filter(line => {
+            const row = JSON.parse(line);
+            return !launches.some(launch => launch.role === row.role && launch.launchId === row.launchId);
+        });
+        replaceFileAtomically(path, kept.length ? kept.join('\n') + '\n' : '');
+    });
 }
 /** Pick a sibling path without overwriting evidence from an earlier attempt. */
 function collisionSafeArchivePaths(targetBase, retiringBase) {

package/dist/temp-supervisor-recovery.d.ts

@@ -0,0 +1,3 @@
+export declare const TEMP_RECYCLE_EXIT = 75;
+/** Keep the service's main process alive while replacing a PID-scoped worker. */
+export declare function runTempSupervisor(name: string, entrypoint: string, initial?: () => Promise<void>): Promise<void>;

package/dist/temp-supervisor-recovery.js

@@ -0,0 +1,46 @@
+import { spawn } from 'node:child_process';
+import { runTemp, SupervisorRecycleRequiredError } from './runner.js';
+export const TEMP_RECYCLE_EXIT = 75;
+/** Keep the service's main process alive while replacing a PID-scoped worker. */
+export async function runTempSupervisor(name, entrypoint, initial = () => runTemp(name)) {
+    try {
+        await initial();
+        return;
+    }
+    catch (error) {
+        if (!(error instanceof SupervisorRecycleRequiredError))
+            throw error;
+    }
+    for (let attempt = 0; attempt < 3; attempt++) {
+        const child = spawn(process.execPath, [entrypoint, '_run-temp-worker', name], {
+            stdio: 'inherit',
+            env: process.env,
+        });
+        let stopping = false;
+        const term = () => {
+            stopping = true;
+            child.kill('SIGTERM');
+        }, interrupt = () => {
+            stopping = true;
+            child.kill('SIGINT');
+        };
+        process.on('SIGTERM', term);
+        process.on('SIGINT', interrupt);
+        let code;
+        try {
+            code = await new Promise((resolve, reject) => {
+                child.once('error', reject);
+                child.once('exit', resolve);
+            });
+        }
+        finally {
+            process.off('SIGTERM', term);
+            process.off('SIGINT', interrupt);
+        }
+        if (code === 0 || stopping)
+            return;
+        if (code !== TEMP_RECYCLE_EXIT)
+            throw Error(`Temporary supervisor replacement exited with ${code}`);
+    }
+    throw Error('Temporary supervisor recycle limit reached; identity retained for explicit recovery');
+}

package/dist/watchdog/briefing.js

@@ -5,22 +5,9 @@ import { formatDuration } from '../duration.js';
  * wasn't verified when configured, fall back to createTool on first run.
  */
 function bindSection(heading, wd, v, guarantee) {
-    const L = ['', heading];
-    L.push(`Call the **${v.bindTool}** tool with name "${wd.identity}" force=true (search the`);
-    L.push('deferred tool registry first if needed).');
-    if (guarantee === 'unverified') {
-        L.push(`- This identity was NOT verified when this watchdog was configured, so it may not`);
-        L.push(`  exist yet. If binding reports no such identity, call **${v.createTool}** name`);
-        L.push(`  "${wd.identity}" once to mint it on this first run, then you are bound. Re-binding`);
-        L.push('  your OWN identity is always allowed.');
-    }
-    else {
-        L.push(`- It was ${guarantee === 'created' ? 'created' : 'verified to exist'} when this`);
-        L.push('  watchdog was configured, so binding should succeed. If it unexpectedly reports no');
-        L.push(`  such identity, call **${v.createTool}** name "${wd.identity}" once and report the`);
-        L.push('  discrepancy — something removed it since.');
-    }
-    return L;
+    return ['', '## Assigned identity',
+        `Your supervisor has bound your identity **${wd.identity}**. The ours tools are ready.`,
+        'No identity setup or skill reading is required.'];
 }
 /**
  * Render a watchdog run's fixed contract (briefing.md-equivalent for a one-shot clean-context

package/dist/watchdog/run.js

@@ -1,3 +1,4 @@
+import { preparePermanentAssignment, releaseManagedAgent } from '../agent-ours/service.js';
 import { closeSync, existsSync, openSync, readFileSync, readdirSync, rmSync, statSync, writeFileSync, } from 'node:fs';
 import { spawn as spawnChild } from 'node:child_process';
 import { join } from 'node:path';
@@ -7,8 +8,7 @@ import { acquireRunLock, formatRunId, pruneReports, releaseRunLock, writeReport
 import { generateNotifierBriefing, generateWatchdogBriefing } from './briefing.js';
 import { computeDigest, reconcileLedger, readLedger, writeLedger } from './alerts.js';
 import { applyRole } from '../ops.js';
-import { daemonIdentityInventoryProvisioner, ensureIdentity, } from '../creation.js';
-import { runOnce, START_STAGGER_FILE } from '../runner.js';
+import { runOnce, loadTempRole, START_STAGGER_FILE } from '../runner.js';
 import { agentDir, tmpRoot } from '../paths.js';
 import { loadConfig, ROLE_NAME_RE, } from '../config.js';
 import { getAdapter } from '../harness/registry.js';
@@ -53,6 +53,7 @@ async function killIfNeeded(reason, child, roleName, sleep) {
         if (reason === 'stable')
             await sleep(HARVEST_GRACE_MS);
         child.kill();
+        await child.exited;
     }
 }
 function defaultLaunchChild(binPath, roleName, runDir) {
@@ -139,7 +140,7 @@ export async function executeWatchdogRun(wd, deps) {
         rmSync(runDir, { recursive: true, force: true });
     let report;
     try {
-        const guarantee = await ensureIdentity(wd.identity, {}, deps.identityProvisioner ?? daemonIdentityInventoryProvisioner(), deps.log);
+        const guarantee = { state: 'unverified' }; // The child supervisor provisions before its harness starts.
         const cfg = deps.cfg ?? loadConfig();
         const discovered = wd.watchExplicit
             ? []
@@ -272,7 +273,7 @@ export async function executeNotifierRun(wd, text, deps) {
         // A crashed previous run can leave the temp dir behind; start clean.
         if (existsSync(runDir))
             rmSync(runDir, { recursive: true, force: true });
-        const guarantee = await ensureIdentity(wd.identity, {}, deps.identityProvisioner ?? daemonIdentityInventoryProvisioner(), deps.log);
+        const guarantee = { state: 'unverified' }; // The child supervisor provisions before its harness starts.
         const cfg = deps.cfg ?? loadConfig();
         const role = buildWatchdogRole(wd, cfg);
         const dir = applyRole(role, { temp: true, identityGuarantee: guarantee.state });
@@ -317,5 +318,18 @@ export async function executeNotifierRun(wd, text, deps) {
 }
 /** What `_run-watchdog` calls: one supervised session, no cleanup — the parent harvests. */
 export async function runWatchdogAgent(name) {
-    await runOnce(name, { temp: true });
+    const role = loadTempRole(name);
+    await preparePermanentAssignment(role);
+    let stopping = false;
+    const stop = () => { stopping = true; };
+    process.on('SIGTERM', stop);
+    process.on('SIGINT', stop);
+    try {
+        await runOnce(name, { temp: true, identityLifetime: 'permanent' }, { shouldStop: () => stopping });
+    }
+    finally {
+        process.off('SIGTERM', stop);
+        process.off('SIGINT', stop);
+        await releaseManagedAgent(role);
+    }
 }

package/dist/web/agent-attachments.d.ts

@@ -0,0 +1,29 @@
+export declare const MAX_ATTACHMENT_BYTES: number;
+export declare const MAX_ATTACHMENT_BODY: number;
+export interface AgentAttachment {
+    id: string;
+    name: string;
+    mimeType: string;
+    size: number;
+    sha256: string;
+    generation: string;
+}
+export declare function storeAgentAttachment(stateDir: string, generation: string, input: unknown): AgentAttachment;
+export declare function attachmentPrompt(stateDir: string, generation: string, ids: unknown, text: string): string;
+export declare function readAgentAttachment(stateDir: string, id: string): {
+    record: AgentAttachment;
+    bytes: Buffer;
+};
+interface AttachmentPresentation {
+    generation: string;
+    commandId: string;
+    text: string;
+    transportDigest: string;
+    ids: string[];
+}
+/** Written before admission so a lost HTTP response cannot lose the visible message. */
+export declare function storeAttachmentPresentation(stateDir: string, value: AttachmentPresentation): void;
+export declare function prepareAttachmentPresentation(stateDir: string, generation: string, commandId: string, ids: string[], text: string, transport: string): void;
+/** Never infer attachments by stripping user text or interpreting a marker. */
+export declare function presentAttachmentEvent<T>(stateDir: string | undefined, roleId: string, event: T): T;
+export {};