@ours.network/fleet 1.0.3 → 1.0.5

package/dist/rooms-tasks/task-state.js

@@ -1,11 +1,66 @@
-import { existsSync, mkdirSync, readdirSync, readFileSync, unlinkSync } from 'node:fs';
+import { existsSync, mkdirSync, readdirSync, readFileSync, unlinkSync, writeFileSync, rmSync, renameSync } from 'node:fs';
 import { join } from 'node:path';
 import { randomUUID } from 'node:crypto';
 import { replaceFileAtomically } from '../atomic-file.js';
 import { stateRoot } from '../paths.js';
 import { TASK_TERMINAL_STATES, TASK_CANCELLABLE_STATES } from './types.js';
+import { DEFAULT_TASK_LIST_ID, readTaskLists } from './task-lists.js';
 export const tasksDir = () => join(stateRoot(), 'tasks');
 function taskPath(id) { return join(tasksDir(), `${id}.json`); }
+function taskLockPath(id) { return join(tasksDir(), '.locks', id); }
+const localTaskLocks = new Set();
+function withTaskLock(id, fn) {
+    if (localTaskLocks.has(id))
+        return fn();
+    const path = taskLockPath(id);
+    const ownerPath = join(path, 'owner.json');
+    const token = randomUUID();
+    mkdirSync(join(tasksDir(), '.locks'), { recursive: true });
+    for (;;) {
+        const claimPath = `${path}.claim.${process.pid}.${randomUUID()}`;
+        try {
+            mkdirSync(claimPath);
+            writeFileSync(join(claimPath, 'owner.json'), JSON.stringify({ token, pid: process.pid }));
+            renameSync(claimPath, path);
+            break;
+        }
+        catch (error) {
+            rmSync(claimPath, { recursive: true, force: true });
+            if (!['EEXIST', 'ENOTEMPTY'].includes(error.code ?? ''))
+                throw error;
+            let alive = false;
+            try {
+                const owner = JSON.parse(readFileSync(ownerPath, 'utf8'));
+                if (typeof owner.pid === 'number') {
+                    try {
+                        process.kill(owner.pid, 0);
+                        alive = true;
+                    }
+                    catch { /* dead */ }
+                }
+            }
+            catch { /* corrupt legacy lock */ }
+            if (!alive) {
+                rmSync(path, { recursive: true, force: true });
+                continue;
+            }
+            Atomics.wait(new Int32Array(new SharedArrayBuffer(4)), 0, 0, 10);
+        }
+    }
+    localTaskLocks.add(id);
+    try {
+        return fn();
+    }
+    finally {
+        localTaskLocks.delete(id);
+        try {
+            const owner = JSON.parse(readFileSync(ownerPath, 'utf8'));
+            if (owner.token === token)
+                rmSync(path, { recursive: true, force: true });
+        }
+        catch { /* ownership cannot be proved */ }
+    }
+}
 function generateTaskId() {
     const ts = Date.now().toString(36).padStart(9, '0');
     const rand = randomUUID().replace(/-/g, '').slice(0, 8);
@@ -27,11 +82,20 @@ function readTask(id) {
     const p = taskPath(id);
     if (!existsSync(p))
         throw new TaskStateError(`task not found: ${id}`);
-    return JSON.parse(readFileSync(p, 'utf8'));
+    return presentTask(JSON.parse(readFileSync(p, 'utf8')));
 }
 function writeTask(record) {
     mkdirSync(tasksDir(), { recursive: true });
-    replaceFileAtomically(taskPath(record.task_id), JSON.stringify(record, null, 2) + '\n');
+    const persisted = { ...record };
+    delete persisted.list_name;
+    replaceFileAtomically(taskPath(record.task_id), JSON.stringify(persisted, null, 2) + '\n');
+}
+function presentTask(record) {
+    const listId = record.list_id ?? DEFAULT_TASK_LIST_ID;
+    const list = readTaskLists().find(item => item.list_id === listId);
+    if (!list)
+        throw new TaskStateError(`task ${record.task_id} references missing list ${listId}`);
+    return { ...record, list_id: listId, list_name: list.name };
 }
 // ── Lifecycle transitions ───────────────────────────────────────────────
 const VALID_TRANSITIONS = {
@@ -60,6 +124,7 @@ export function createTask(input) {
     const state = input.start === false ? 'backlog' : 'provisioning';
     const record = {
         task_id: generateTaskId(),
+        list_id: input.listId ?? DEFAULT_TASK_LIST_ID,
         title: input.title,
         brief: input.brief,
         brief_file: input.brief_file,
@@ -74,9 +139,9 @@ export function createTask(input) {
         started_at: state === 'provisioning' ? new Date().toISOString() : undefined,
     };
     writeTask(record);
-    return record;
+    return readTask(record.task_id);
 }
-export function getTask(id) { return readTask(id); }
+export function getTask(id) { return withTaskLock(id, () => readTask(id)); }
 export function listTasks(filter) {
     const dir = tasksDir();
     if (!existsSync(dir))
@@ -87,222 +152,263 @@ export function listTasks(filter) {
     const tasks = [];
     for (const f of readdirSync(dir).filter(f => f.endsWith('.json'))) {
         try {
-            const t = JSON.parse(readFileSync(join(dir, f), 'utf8'));
-            if (!states || states.includes(t.state))
+            const id = f.slice(0, -5);
+            const t = withTaskLock(id, () => presentTask(JSON.parse(readFileSync(join(dir, f), 'utf8'))));
+            if ((!states || states.includes(t.state)) && (!filter?.listId || t.list_id === filter.listId))
                 tasks.push(t);
         }
         catch { /* corrupt file, skip */ }
     }
-    return tasks.sort((a, b) => a.created_at.localeCompare(b.created_at));
+    const order = new Map(readTaskLists().map((item, index) => [item.list_id, index]));
+    return tasks.sort((a, b) => (order.get(a.list_id) - order.get(b.list_id))
+        || a.created_at.localeCompare(b.created_at) || a.task_id.localeCompare(b.task_id));
+}
+export function moveTaskToList(id, listId) {
+    return withTaskLock(id, () => {
+        const task = readTask(id);
+        task.list_id = listId;
+        writeTask(task);
+        return readTask(id);
+    });
 }
 export function findByIdempotencyKey(key) {
     return listTasks().find(t => t.idempotency_key === key);
 }
 export function startTask(id) {
-    const t = readTask(id);
-    assertNoPendingTerminalIntent(t);
-    assertTransition(t.state, 'provisioning');
-    t.state = 'provisioning';
-    t.started_at = new Date().toISOString();
-    writeTask(t);
-    return t;
+    return withTaskLock(id, () => {
+        const t = readTask(id);
+        assertNoPendingTerminalIntent(t);
+        assertTransition(t.state, 'provisioning');
+        t.state = 'provisioning';
+        t.started_at = new Date().toISOString();
+        writeTask(t);
+        return t;
+    });
 }
 export function activateTask(id) {
-    const t = readTask(id);
-    assertNoPendingTerminalIntent(t);
-    assertTransition(t.state, 'active');
-    t.state = 'active';
-    delete t.blocked;
-    writeTask(t);
-    return t;
+    return withTaskLock(id, () => {
+        const t = readTask(id);
+        assertNoPendingTerminalIntent(t);
+        assertTransition(t.state, 'active');
+        t.state = 'active';
+        delete t.blocked;
+        writeTask(t);
+        return t;
+    });
 }
 export function blockTask(id, reason) {
-    const t = readTask(id);
-    assertNoPendingTerminalIntent(t);
-    if (TASK_TERMINAL_STATES.includes(t.state))
-        throw new TaskStateError(`cannot block a '${t.state}' task`);
-    t.blocked = { reason, at: new Date().toISOString() };
-    writeTask(t);
-    return t;
+    return withTaskLock(id, () => {
+        const t = readTask(id);
+        assertNoPendingTerminalIntent(t);
+        if (TASK_TERMINAL_STATES.includes(t.state))
+            throw new TaskStateError(`cannot block a '${t.state}' task`);
+        t.blocked = { reason, at: new Date().toISOString() };
+        writeTask(t);
+        return t;
+    });
 }
 export function unblockTask(id) {
-    const t = readTask(id);
-    assertNoPendingTerminalIntent(t);
-    if (!t.blocked)
-        throw new TaskStateError('task is not blocked');
-    delete t.blocked;
-    writeTask(t);
-    return t;
+    return withTaskLock(id, () => {
+        const t = readTask(id);
+        assertNoPendingTerminalIntent(t);
+        if (!t.blocked)
+            throw new TaskStateError('task is not blocked');
+        delete t.blocked;
+        writeTask(t);
+        return t;
+    });
 }
 export function reviewTask(id) {
-    const t = readTask(id);
-    assertNoPendingTerminalIntent(t);
-    assertTransition(t.state, 'review');
-    t.state = 'review';
-    delete t.blocked;
-    writeTask(t);
-    return t;
+    return withTaskLock(id, () => {
+        const t = readTask(id);
+        assertNoPendingTerminalIntent(t);
+        assertTransition(t.state, 'review');
+        t.state = 'review';
+        delete t.blocked;
+        writeTask(t);
+        return t;
+    });
 }
 export function completeTask(id, outcome) {
-    const t = readTask(id);
-    assertNoPendingTerminalIntent(t);
-    assertTransition(t.state, 'done');
-    t.state = 'done';
-    t.ended_at = new Date().toISOString();
-    delete t.blocked;
-    if (outcome)
-        t.outcome = outcome;
-    writeTask(t);
-    return t;
+    return withTaskLock(id, () => {
+        const t = readTask(id);
+        assertNoPendingTerminalIntent(t);
+        assertTransition(t.state, 'done');
+        t.state = 'done';
+        t.ended_at = new Date().toISOString();
+        delete t.blocked;
+        if (outcome)
+            t.outcome = outcome;
+        writeTask(t);
+        return t;
+    });
 }
 export function cancelTask(id) {
-    const t = readTask(id);
-    assertNoPendingTerminalIntent(t);
-    if (!TASK_CANCELLABLE_STATES.includes(t.state))
-        throw new TaskStateError(`cannot cancel a '${t.state}' task`);
-    t.state = 'cancelled';
-    t.ended_at = new Date().toISOString();
-    delete t.blocked;
-    writeTask(t);
-    return t;
+    return withTaskLock(id, () => {
+        const t = readTask(id);
+        assertNoPendingTerminalIntent(t);
+        if (!TASK_CANCELLABLE_STATES.includes(t.state))
+            throw new TaskStateError(`cannot cancel a '${t.state}' task`);
+        t.state = 'cancelled';
+        t.ended_at = new Date().toISOString();
+        delete t.blocked;
+        writeTask(t);
+        return t;
+    });
 }
 function sameOutcome(left, right) {
     return JSON.stringify(left) === JSON.stringify(right);
 }
 /** Persist the first terminal request. Callers serialize this with the task-operation lock. */
 export function beginTaskTerminalIntent(id, input) {
-    const t = readTask(id);
-    const existing = t.terminal_intent;
-    if (existing) {
-        if (existing.kind !== input.kind || existing.room_id !== input.roomId
-            || !sameOutcome(existing.outcome, input.outcome)) {
-            throw new TaskStateError(`task ${id} already has a conflicting '${existing.kind}' terminal intent`);
+    return withTaskLock(id, () => {
+        const t = readTask(id);
+        const existing = t.terminal_intent;
+        if (existing) {
+            if (existing.kind !== input.kind || existing.room_id !== input.roomId
+                || !sameOutcome(existing.outcome, input.outcome)) {
+                throw new TaskStateError(`task ${id} already has a conflicting '${existing.kind}' terminal intent`);
+            }
+            return t;
+        }
+        if (TASK_TERMINAL_STATES.includes(t.state)) {
+            throw new TaskStateError(`task ${id} is already in terminal state '${t.state}'`);
         }
+        if (input.kind === 'done' && t.state !== 'review') {
+            throw new TaskStateError(`cannot transition from '${t.state}' to 'done'`);
+        }
+        if (input.kind === 'cancelled' && !TASK_CANCELLABLE_STATES.includes(t.state)) {
+            throw new TaskStateError(`cannot cancel a '${t.state}' task`);
+        }
+        if (input.roomId !== undefined && t.room_id !== input.roomId) {
+            throw new TaskStateError(`task ${id} is not tied to room ${input.roomId}`);
+        }
+        t.terminal_intent = {
+            kind: input.kind,
+            status: 'pending',
+            room_id: input.roomId,
+            outcome: input.outcome,
+            accepted_at: new Date().toISOString(),
+        };
+        writeTask(t);
         return t;
-    }
-    if (TASK_TERMINAL_STATES.includes(t.state)) {
-        throw new TaskStateError(`task ${id} is already in terminal state '${t.state}'`);
-    }
-    if (input.kind === 'done' && t.state !== 'review') {
-        throw new TaskStateError(`cannot transition from '${t.state}' to 'done'`);
-    }
-    if (input.kind === 'cancelled' && !TASK_CANCELLABLE_STATES.includes(t.state)) {
-        throw new TaskStateError(`cannot cancel a '${t.state}' task`);
-    }
-    if (input.roomId !== undefined && t.room_id !== input.roomId) {
-        throw new TaskStateError(`task ${id} is not tied to room ${input.roomId}`);
-    }
-    t.terminal_intent = {
-        kind: input.kind,
-        status: 'pending',
-        room_id: input.roomId,
-        outcome: input.outcome,
-        accepted_at: new Date().toISOString(),
-    };
-    writeTask(t);
-    return t;
+    });
 }
 /** Record an actionable failure without claiming the requested terminal state. */
 export function setTaskTerminalIntentError(id, error, recoveryHint) {
-    const t = readTask(id);
-    if (!t.terminal_intent)
-        throw new TaskStateError(`task ${id} has no terminal intent`);
-    if (t.terminal_intent.status === 'settled')
+    return withTaskLock(id, () => {
+        const t = readTask(id);
+        if (!t.terminal_intent)
+            throw new TaskStateError(`task ${id} has no terminal intent`);
+        if (t.terminal_intent.status === 'settled')
+            return t;
+        t.terminal_intent.first_failure ??= error;
+        t.terminal_intent.first_recovery_hint ??= recoveryHint;
+        t.terminal_intent.error = error;
+        const previousErrorAt = Date.parse(t.terminal_intent.error_at ?? '');
+        t.terminal_intent.error_at = new Date(Math.max(Date.now(), Number.isFinite(previousErrorAt) ? previousErrorAt + 1 : 0)).toISOString();
+        t.terminal_intent.recovery_hint = recoveryHint;
+        writeTask(t);
         return t;
-    t.terminal_intent.first_failure ??= error;
-    t.terminal_intent.first_recovery_hint ??= recoveryHint;
-    t.terminal_intent.error = error;
-    const previousErrorAt = Date.parse(t.terminal_intent.error_at ?? '');
-    t.terminal_intent.error_at = new Date(Math.max(Date.now(), Number.isFinite(previousErrorAt) ? previousErrorAt + 1 : 0)).toISOString();
-    t.terminal_intent.recovery_hint = recoveryHint;
-    writeTask(t);
-    return t;
+    });
 }
 /** Atomically publish the task terminal state and settled audit cursor. */
 export function finishTaskTerminalIntent(id) {
-    const t = readTask(id);
-    const intent = t.terminal_intent;
-    if (!intent)
-        throw new TaskStateError(`task ${id} has no terminal intent`);
-    if (intent.status === 'settled')
+    return withTaskLock(id, () => {
+        const t = readTask(id);
+        const intent = t.terminal_intent;
+        if (!intent)
+            throw new TaskStateError(`task ${id} has no terminal intent`);
+        if (intent.status === 'settled')
+            return t;
+        if (TASK_TERMINAL_STATES.includes(t.state)) {
+            throw new TaskStateError(`task ${id} reached terminal state '${t.state}' outside its intent`);
+        }
+        if (intent.kind === 'done')
+            assertTransition(t.state, 'done');
+        else if (!TASK_CANCELLABLE_STATES.includes(t.state)) {
+            throw new TaskStateError(`cannot cancel a '${t.state}' task`);
+        }
+        t.state = intent.kind;
+        t.ended_at = new Date().toISOString();
+        delete t.blocked;
+        if (intent.outcome)
+            t.outcome = intent.outcome;
+        intent.status = 'settled';
+        intent.settled_at = t.ended_at;
+        delete intent.error;
+        delete intent.error_at;
+        delete intent.recovery_hint;
+        writeTask(t);
         return t;
-    if (TASK_TERMINAL_STATES.includes(t.state)) {
-        throw new TaskStateError(`task ${id} reached terminal state '${t.state}' outside its intent`);
-    }
-    if (intent.kind === 'done')
-        assertTransition(t.state, 'done');
-    else if (!TASK_CANCELLABLE_STATES.includes(t.state)) {
-        throw new TaskStateError(`cannot cancel a '${t.state}' task`);
-    }
-    t.state = intent.kind;
-    t.ended_at = new Date().toISOString();
-    delete t.blocked;
-    if (intent.outcome)
-        t.outcome = intent.outcome;
-    intent.status = 'settled';
-    intent.settled_at = t.ended_at;
-    delete intent.error;
-    delete intent.error_at;
-    delete intent.recovery_hint;
-    writeTask(t);
-    return t;
+    });
 }
 export function failTask(id, error) {
-    const t = readTask(id);
-    assertNoPendingTerminalIntent(t);
-    assertTransition(t.state, 'failed');
-    t.state = 'failed';
-    t.ended_at = new Date().toISOString();
-    t.outcome = { summary: error };
-    delete t.blocked;
-    writeTask(t);
-    return t;
+    return withTaskLock(id, () => {
+        const t = readTask(id);
+        assertNoPendingTerminalIntent(t);
+        assertTransition(t.state, 'failed');
+        t.state = 'failed';
+        t.ended_at = new Date().toISOString();
+        t.outcome = { summary: error };
+        delete t.blocked;
+        writeTask(t);
+        return t;
+    });
 }
 export function updateTaskRoom(id, roomId, roomIdentityCid) {
-    const t = readTask(id);
-    assertNoPendingTerminalIntent(t);
-    t.room_id = roomId;
-    t.room_identity_cid = roomIdentityCid;
-    writeTask(t);
-    return t;
+    return withTaskLock(id, () => {
+        const t = readTask(id);
+        assertNoPendingTerminalIntent(t);
+        t.room_id = roomId;
+        t.room_identity_cid = roomIdentityCid;
+        writeTask(t);
+        return t;
+    });
 }
 export function updateTaskTemplate(id, template) {
-    const t = readTask(id);
-    assertNoPendingTerminalIntent(t);
-    t.template = template;
-    writeTask(t);
-    return t;
+    return withTaskLock(id, () => {
+        const t = readTask(id);
+        assertNoPendingTerminalIntent(t);
+        t.template = template;
+        writeTask(t);
+        return t;
+    });
 }
 export function updateTaskMembers(id, members) {
-    const t = readTask(id);
-    assertNoPendingTerminalIntent(t);
-    t.member_roles = members;
-    writeTask(t);
-    return t;
+    return withTaskLock(id, () => {
+        const t = readTask(id);
+        assertNoPendingTerminalIntent(t);
+        t.member_roles = members;
+        writeTask(t);
+        return t;
+    });
 }
 /** Remove a completed task from Fleet's backlog. Missing tasks are an idempotent no-op. */
 export function deleteTask(id) {
-    assertCanonicalTaskId(id);
-    const p = taskPath(id);
-    let task;
-    try {
-        task = JSON.parse(readFileSync(p, 'utf8'));
-    }
-    catch (error) {
-        if (isNotFoundError(error))
-            return false;
-        throw error;
-    }
-    if (task.state !== 'done') {
-        throw new TaskStateError(`cannot delete a '${task.state}' task; only 'done' tasks can be deleted`);
-    }
-    try {
-        unlinkSync(p);
-    }
-    catch (error) {
-        if (isNotFoundError(error))
-            return false;
-        throw error;
-    }
-    return true;
+    return withTaskLock(id, () => {
+        assertCanonicalTaskId(id);
+        const p = taskPath(id);
+        let task;
+        try {
+            task = JSON.parse(readFileSync(p, 'utf8'));
+        }
+        catch (error) {
+            if (isNotFoundError(error))
+                return false;
+            throw error;
+        }
+        if (task.state !== 'done') {
+            throw new TaskStateError(`cannot delete a '${task.state}' task; only 'done' tasks can be deleted`);
+        }
+        try {
+            unlinkSync(p);
+        }
+        catch (error) {
+            if (isNotFoundError(error))
+                return false;
+            throw error;
+        }
+        return true;
+    });
 }

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

@@ -24,7 +24,7 @@ export interface TaskMemberRole {
     cowork_role: string;
 }
 export interface TaskOrigin {
-    type: 'cli' | 'owner_channel';
+    type: 'cli' | 'owner_channel' | 'web';
     owner_cid?: string;
 }
 export interface TaskOutcome {
@@ -46,6 +46,10 @@ export interface TaskTerminalIntent {
 }
 export interface TaskRecord {
     task_id: string;
+    /** Stable organizational list identifier. Missing legacy values mean `default`. */
+    list_id: string;
+    /** Derived presentation field; repositories must never persist it. */
+    list_name: string;
     title: string;
     brief?: string;
     brief_file?: string;
@@ -64,6 +68,12 @@ export interface TaskRecord {
     outcome?: TaskOutcome;
     terminal_intent?: TaskTerminalIntent;
 }
+export interface TaskListRecord {
+    list_id: string;
+    name: string;
+    built_in: boolean;
+    created_at: string;
+}
 export type RoomOrchestrationState = 'provisioning' | 'active' | 'closing' | 'closed';
 export type SagaPhase = 'persist_intent' | 'create_room' | 'attach_owner' | 'create_members' | 'join_role_groups' | 'wait_seats' | 'launch_work' | 'activate' | 'completed' | 'failed';
 export interface SagaCursor {

package/dist/runner.js

@@ -23,7 +23,7 @@ import { OwnerChannel } from './owner-channel/channel.js';
 import { acquireOwnerBinderLease, OwnerBinderHandoffTimeoutError, } from './owner-channel/binder.js';
 import { RoleTurnArbiter } from './session/arbiter.js';
 import { ScheduledLoopManager, } from './loops/manager.js';
-import { FLEET_PROXY_CALLER_ENV, FLEET_PROXY_STATE_DIR_ENV, inheritCallerSpawnDefaults, } from './fleet-proxy.js';
+import { FLEET_PROXY_CALLER_ENV, FLEET_PROXY_STATE_DIR_ENV, } from './fleet-proxy.js';
 import { effectivePermissionMode } from './permissions.js';
 import { assertModelPinReachesChild, effectiveRoleModel, repinModelEnv } from './model-env.js';
 import { archiveTempState, markTempSupervisorActive, requestedTempStopReason, } from './temp-lifecycle.js';
@@ -92,11 +92,6 @@ export function harnessChildEnv(role, launchEnv, stateDir) {
  * avoid a runner↔spawn initialization cycle (spawn imports runner constants).
  */
 async function executeManagedSpawn(caller, configPath, requested, log) {
-    const { options, inherited } = inheritCallerSpawnDefaults(caller, requested, configPath);
-    const creationActionId = randomUUID();
-    options.creationActionId = creationActionId;
-    const spawnModule = await import('./spawn.js');
-    const preview = spawnModule.spawnDryRun(options).resolvedRole;
     const runtimeBinPath = (() => {
         try {
             return realpathSync(process.argv[1]);
@@ -105,33 +100,15 @@ async function executeManagedSpawn(caller, configPath, requested, log) {
             return process.argv[1];
         }
     })();
-    let statePath;
-    if (options.temp) {
-        statePath = await spawnModule.spawnTemp(options, runtimeBinPath);
-    }
-    else {
-        const { pickBackend } = await import('./supervisor/index.js');
-        const { WatchdogServiceManager } = await import('./watchdog/service.js');
-        statePath = await spawnModule.spawnPermanent(options, {
-            backend: pickBackend(), binPath: runtimeBinPath, log,
-            watchdogService: new WatchdogServiceManager(),
-        });
-    }
-    const result = {
-        caller: caller.name,
-        role: options.name,
-        lifetime: options.temp ? 'temporary' : 'permanent',
-        statePath,
-        harness: preview.harness,
-        session: preview.session,
-        // Read back from the resolved environment, not from the request: the banner
-        // must name the model the child will run, not the one that was asked for.
-        ...(effectiveRoleModel(preview) ? { model: effectiveRoleModel(preview) } : {}),
-        monitor: { mode: preview.monitor.mode, interrupt: preview.monitor.interrupt },
-        permissionMode: effectivePermissionMode(preview),
-        inherited,
-        creationActionId,
-    };
+    const [{ RoleCreationService }, { pickBackend }, { WatchdogServiceManager }] = await Promise.all([
+        import('./application/role-creation-service.js'), import('./supervisor/index.js'),
+        import('./watchdog/service.js'),
+    ]);
+    const service = new RoleCreationService({ configPath,
+        ops: { backend: pickBackend(), binPath: runtimeBinPath, log,
+            watchdogService: new WatchdogServiceManager() },
+        binPath: runtimeBinPath, journal: false });
+    const result = await service.createManaged(caller, requested);
     log(`[${caller.name}] managed fleet proxy spawned ${result.lifetime} role ${result.role} `
         + `harness=${result.harness} session=${result.session} `
         + `model=${result.model ?? '(harness default)'} `

package/dist/session/control.d.ts

@@ -1,5 +1,5 @@
 import { type Socket } from 'node:net';
-import type { ControlFailureKind, SessionHandle } from './types.js';
+import type { ControlFailureKind, SessionEvent, SessionHandle, SessionSnapshot } from './types.js';
 import type { OwnerChannelHandle, OwnerChannelManagementRequest } from '../owner-channel/channel.js';
 import type { ScheduledLoopManagerHandle } from '../loops/manager.js';
 import type { SpawnOpts } from '../spawn.js';
@@ -40,6 +40,15 @@ export interface ControlResponse {
     /** Why it failed, so the caller does not have to guess from the text. */
     kind?: ControlFailureKind;
 }
+export interface RetainedEventPage {
+    events: SessionEvent[];
+    snapshot: SessionSnapshot;
+    firstSeq: number;
+    lastSeq: number;
+    truncated: boolean;
+}
+/** The one retained-range projection shared by polling and live-follow admission. */
+export declare function retainedEventPage(session: SessionHandle, since: number): RetainedEventPage;
 /**
  * One line saying what a control failure does — and does not — prove about the
  * agent. Only `offline` is evidence that it is gone; every other kind used to