@ours.network/fleet 1.2.0-nightly.7 → 1.2.0-nightly.70

package/dist/spawn.js

@@ -1,5 +1,7 @@
+import { taskSupervisorMayRun } from './task-supervision.js';
 import { randomUUID } from 'node:crypto';
 import { storeRoomSecret, storeTemporaryLaunch, preparePermanentAssignment } from './agent-ours/service.js';
+import { ensureWorkspace } from './rooms-tasks/workspace.js';
 import { spawn as spawnChild } from 'node:child_process';
 import { closeSync, existsSync, lstatSync, mkdirSync, openSync, readFileSync, rmSync, writeFileSync } from 'node:fs';
 import { join } from 'node:path';
@@ -15,7 +17,8 @@ import { recordGeneratedAgentSource } from './generated-agent-source.js';
 import './harness/claude-code.js';
 import './harness/codex.js';
 import './harness/hermes.js';
-import { archiveTempState, makeTempSupervisorLauncher, prepareTempSupervisor, reclaimStaleTempState, } from './temp-lifecycle.js';
+import { getAdapter } from './harness/registry.js';
+import { archiveTempState, makeTempSupervisorLauncher, prepareTempSupervisor, reclaimStaleTempState, stopTempSupervisor, secureStoppedTempArchive, readTempSupervisor, requestedTempStopReason, } from './temp-lifecycle.js';
 /**
  * The provenance record written by the most recent spawn in this process, so
  * the CLI can print the same summary it persisted rather than rebuilding it.
@@ -321,6 +324,14 @@ export async function spawnTemp(o, binPath, launch = independentSupervisor, crea
     if (o.isolationFile)
         readIsolationFile(o.isolationFile); // fail before reserving
     const prepared = resolvedSpawn(o); // canonical validation before mutation
+    if ((o.taskOwner || o.roomMemberStartup?.task_id) && !getAdapter(prepared.role.harness).supportsResume)
+        throw Error('TASK_HARNESS_RESUME_UNSUPPORTED: task agents require a resumable harness');
+    if (o.roomMemberStartup?.workspace) {
+        const workspace = o.roomMemberStartup.workspace;
+        if (prepared.role.cwd !== workspace.path)
+            throw new Error('room member cwd must equal its recorded owned workspace');
+        ensureWorkspace(workspace);
+    }
     // Retire only supervisors whose recorded owner is definitively stopped. This
     // bounded pass keeps the active roster clean without deleting old evidence.
     await reclaimStaleTempState();
@@ -351,7 +362,7 @@ async function spawnTempInner(o, preparedRole, binPath, launch, tx, onStage) {
     if (role.roomMemberStartup)
         role.roomMemberStartup = { ...role.roomMemberStartup, invite: '' };
     onStage?.('writing_role');
-    const dir = applyRole(role, { temp: true, identityGuarantee: 'unverified' });
+    const dir = applyRole(role, { temp: true, identityGuarantee: 'unverified', configPath: o.configPath });
     const provenance = buildProvenance({
         role: o.name, lifetime: 'temporary', fleetVersion: VERSION,
         settings: provenanceSettings(o, cfg.defaults, preparedRole.temporaryLoops),
@@ -361,7 +372,14 @@ async function spawnTempInner(o, preparedRole, binPath, launch, tx, onStage) {
     lastProvenance = provenance;
     tx.record({
         stage: `temp state dir ${dir}`,
-        undo: () => {
+        undo: async () => {
+            if (o.taskOwner || role.roomMemberStartup?.task_id) {
+                await stopTempSupervisor(o.name);
+                const supervisor = readTempSupervisor(dir);
+                if (supervisor)
+                    await secureStoppedTempArchive(o.name, supervisor.launchId);
+                return;
+            }
             // A failed launch is still lifecycle evidence: briefing, provenance,
             // metadata and supervisor output explain what happened. Remove it from
             // the live roster by atomic archive, never recursive deletion.
@@ -374,7 +392,14 @@ async function spawnTempInner(o, preparedRole, binPath, launch, tx, onStage) {
     // out; a lone temp spawn still waits zero (time-based gate).
     if (cfg.startStaggerMs > 0)
         writeFileSync(join(dir, START_STAGGER_FILE), String(cfg.startStaggerMs));
-    prepareTempSupervisor(dir, o.name);
+    prepareTempSupervisor(dir, o.name, o.taskOwner ?? (o.roomMemberStartup?.task_id ? {
+        taskId: o.roomMemberStartup.task_id,
+        roomId: o.roomMemberStartup.room_id,
+        roomIdentityCid: o.roomMemberStartup.room_identity_cid,
+        creationActionId: o.creationActionId,
+    } : undefined));
+    if (o.taskOwner || o.roomMemberStartup?.task_id)
+        taskSupervisorMayRun(o.name);
     // Run the supervisor independently. On a service-managed host the temp
     // runner gets its own transient unit/job, so stopping the coordinator's unit
     // cannot kill a live worker in the coordinator's cgroup.
@@ -382,3 +407,14 @@ async function spawnTempInner(o, preparedRole, binPath, launch, tx, onStage) {
     await launch(binPath, ['_run-temp', o.name], dir);
     return dir;
 }
+/** Resume the exact durable task launch; no creation, invite issuance or state rotation. */
+export async function resumeTaskSupervisor(name, binPath) {
+    if (!taskSupervisorMayRun(name))
+        throw Error('TASK_SUPERVISOR_RETIRED');
+    const dir = agentDir(name, true);
+    if (requestedTempStopReason(dir))
+        throw Error('TASK_SUPERVISOR_STOP_REQUESTED');
+    const launcher = readTempSupervisor(dir)?.kind === 'detached'
+        ? makeTempSupervisorLauncher({ spawnDetached, supervisor: 'none' }) : independentSupervisor;
+    await launcher(binPath, ['_run-temp', name], dir);
+}

package/dist/startup-prompt.d.ts

@@ -0,0 +1,15 @@
+/**
+ * True when the active worklog records anything. A restart that left no entry
+ * has no continuity to restore, so it must not turn into a worklog read.
+ */
+export declare function worklogRecordsPriorWork(stateDir: string): boolean;
+/**
+ * Readiness is a separate turn after identity/profile and room admission succeed.
+ *
+ * `fresh` starts a new model conversation, which reads the briefing exactly once;
+ * `resume` restores a conversation that already holds it. `hasPriorWork` says the
+ * worklog records earlier work — the only case where it is continuity input.
+ */
+export declare function managedStartupPrompt(stateDir: string, mode: 'fresh' | 'resume', hasPriorWork?: boolean): string;
+/** Configured work/continuity runs after readiness, never inside the fast turn. */
+export declare function managedTaskPrompt(stateDir: string, mode: 'fresh' | 'resume', hasPriorWork?: boolean): string;

package/dist/startup-prompt.js

@@ -0,0 +1,71 @@
+import { existsSync, readFileSync } from 'node:fs';
+import { join } from 'node:path';
+/**
+ * True when the active worklog records anything. A restart that left no entry
+ * has no continuity to restore, so it must not turn into a worklog read.
+ */
+export function worklogRecordsPriorWork(stateDir) {
+    const worklog = join(stateDir, 'WORKLOG.md');
+    try {
+        return existsSync(worklog) && readFileSync(worklog, 'utf8').trim().length > 0;
+    }
+    catch {
+        return false;
+    }
+}
+/**
+ * Readiness is a separate turn after identity/profile and room admission succeed.
+ *
+ * `fresh` starts a new model conversation, which reads the briefing exactly once;
+ * `resume` restores a conversation that already holds it. `hasPriorWork` says the
+ * worklog records earlier work — the only case where it is continuity input.
+ */
+export function managedStartupPrompt(stateDir, mode, hasPriorWork = false) {
+    const briefing = join(stateDir, 'briefing.md');
+    const worklog = join(stateDir, 'WORKLOG.md');
+    const context = mode === 'resume'
+        ? `This restored conversation already holds ${briefing}; do not read it again unless its content is `
+            + 'genuinely missing from your context. '
+            + (hasPriorWork ? `Consult ${worklog} only as needed to recover your next action. ` : '')
+        : `After this readiness turn, read ${briefing} once for this session: in the supervisor's task turn, `
+            + 'or on your first concrete task or wake when no task turn is delivered. Reuse it on every later turn, '
+            + 'task and mail wake without reading it again. '
+            + (hasPriorWork ? `In that same first turn, read ${worklog} once for continuity. ` : '');
+    return 'Fleet readiness check. The supervisor has verified your assigned identity, configured Role profile, '
+        + 'and any required room admission. Reply with a short final console acknowledgement that you are ready, '
+        + 'then end this turn. Announce readiness before any tool calls or file reads. '
+        + 'Do not read briefing, routines, worklog, inbox, history, help or config during this readiness turn; '
+        + 'do not perform identity/profile setup or broad tool discovery. Do not claim task work has been done. '
+        + 'The supervisor delivers configured work separately; otherwise wait for a concrete task or supervisor wake. '
+        + context
+        + 'Read routines only for concrete work; an idle launch needs no detail reads. '
+        + 'The supervisor delivers initial unread mail and later arrivals as wakes; do not poll the inbox at startup.';
+}
+/** Configured work/continuity runs after readiness, never inside the fast turn. */
+export function managedTaskPrompt(stateDir, mode, hasPriorWork = false) {
+    const briefing = join(stateDir, 'briefing.md');
+    const worklog = join(stateDir, 'WORKLOG.md');
+    const opening = mode === 'resume'
+        ? `Your conversation was restored and already holds ${briefing}: follow it for the assigned work `
+            + 'without reading it again. Only if its content is genuinely missing from your context, read it once now. '
+        : `Read and follow ${briefing} for the assigned work. This is the one briefing read of this session; `
+            + 'reuse it on later turns, tasks and mail wakes without reading it again. ';
+    const continuity = !hasPriorWork
+        ? 'No previous work is recorded, so do not read a worklog for initialization. '
+        : mode === 'resume'
+            ? `Continue unfinished work from the restored conversation; consult ${worklog} only as needed to `
+                + 'recover your next action. '
+            : `Previous work is recorded: read ${worklog} once for continuity. Do not read it again later in `
+                + 'this session, including after you append to it. ';
+    return opening
+        + 'Readiness has already been announced; this is a separate task turn, so do not repeat the readiness '
+        + 'acknowledgement. ' + continuity
+        + 'Identify the concrete assignment in the briefing or unfinished work in the continuation log. '
+        + 'A role charter or public bio alone is not a new task. If there is no concrete work, end this turn '
+        + 'and await a task without reading routines, inbox, history, or unrelated files. '
+        + 'For concrete work, read any existing routines once for this session, '
+        + 'acknowledge the actual task and next action through its assigned reply route, and proceed. '
+        + 'Use inbox/history only when a mail wake, unread pagination, or the actual task needs them. '
+        + 'The supervisor delivers initial unread mail; no model-owned startup poll is needed. '
+        + 'Identity/profile setup, help/config exploration and broad tool discovery are not startup rituals.';
+}

package/dist/startup-readiness.d.ts

@@ -0,0 +1,32 @@
+import { type DaemonGenerationProbe } from './daemon-recovery.js';
+export declare const STARTUP_WAIT_MS = 240000;
+export declare const STARTUP_RETRY_MS = 5000;
+/** Upper bound for one read-only Cowork room probe during the startup wait. */
+export declare const ROOM_PROBE_TIMEOUT_MS = 10000;
+interface ReadinessDeps {
+    probe(env: NodeJS.ProcessEnv): Promise<DaemonGenerationProbe>;
+    now(): number;
+    sleep(ms: number): Promise<void>;
+    log(message: string): void;
+    env: NodeJS.ProcessEnv;
+}
+/** Read-only preflight: never binds identities, starts a harness or edits its ledger. */
+export declare function waitForRoleDaemon(name: string, configPath?: string, partial?: Partial<ReadinessDeps>, temp?: boolean): Promise<void>;
+interface RoomManagementDeps {
+    /** Read-only room observation; production uses Cowork `room.show`. */
+    showRoom(roomId: string, env: NodeJS.ProcessEnv, timeoutMs: number): Promise<unknown>;
+    now(): number;
+    sleep(ms: number): Promise<void>;
+    log(message: string): void;
+    env: NodeJS.ProcessEnv;
+    shouldStop(): boolean;
+}
+/**
+ * Read-only preflight for a room member: wait while Cowork management is still
+ * starting behind the gateway. Only a retryable `CoworkUnavailableError` waits;
+ * success, any other error and the deadline all return so the real attempt
+ * decides, fails closed and counts. Never redeems invites, binds identities or
+ * judges room/seat identity — that remains the attempt's admission check.
+ */
+export declare function waitForTaskRoomManagement(name: string, partial?: Partial<RoomManagementDeps>): Promise<'ready' | 'not-required' | 'unavailable' | 'deferred'>;
+export {};

package/dist/startup-readiness.js

@@ -0,0 +1,101 @@
+import { agentDir } from './paths.js';
+import { findRole, loadConfig } from './config.js';
+import { resolveConfigPath, loadTempRole } from './runner.js';
+import { probeDaemonGeneration } from './daemon-recovery.js';
+export const STARTUP_WAIT_MS = 240_000;
+export const STARTUP_RETRY_MS = 5_000;
+/** Upper bound for one read-only Cowork room probe during the startup wait. */
+export const ROOM_PROBE_TIMEOUT_MS = 10_000;
+/** Read-only preflight: never binds identities, starts a harness or edits its ledger. */
+export async function waitForRoleDaemon(name, configPath, partial = {}, temp = false) {
+    const deps = {
+        probe: env => probeDaemonGeneration(((url, init) => globalThis.fetch(url, {
+            ...init, signal: AbortSignal.timeout(10_000),
+        })), env),
+        now: Date.now,
+        sleep: ms => new Promise(resolve => setTimeout(resolve, ms)),
+        log: message => process.stderr.write(message + '\n'),
+        env: process.env,
+        ...partial,
+    };
+    const path = resolveConfigPath(agentDir(name), configPath);
+    const role = temp ? loadTempRole(name) : findRole(loadConfig(path), name);
+    const env = { ...deps.env, ...role.env };
+    const deadline = deps.now() + STARTUP_WAIT_MS;
+    let lastReason = '';
+    while (deps.now() < deadline) {
+        const result = await deps.probe(env);
+        if (result.state === 'ready') {
+            deps.log(`[${name}] daemon ready; starting supervised agent`);
+            return;
+        }
+        // Only structured diagnostic codes, never endpoint responses or credentials.
+        const reason = /^[A-Z][A-Z0-9_]*$/.test(result.reason) ? result.reason : 'DAEMON_UNAVAILABLE';
+        if (reason !== lastReason)
+            deps.log(`[${name}] waiting for configured daemon: ${reason}`);
+        lastReason = reason;
+        await deps.sleep(Math.min(STARTUP_RETRY_MS, Math.max(0, deadline - deps.now())));
+    }
+    throw new Error(`Daemon not ready (${lastReason}); service manager will retry startup`);
+}
+/**
+ * Read-only preflight for a room member: wait while Cowork management is still
+ * starting behind the gateway. Only a retryable `CoworkUnavailableError` waits;
+ * success, any other error and the deadline all return so the real attempt
+ * decides, fails closed and counts. Never redeems invites, binds identities or
+ * judges room/seat identity — that remains the attempt's admission check.
+ */
+export async function waitForTaskRoomManagement(name, partial = {}) {
+    let role;
+    // An unreadable snapshot is the attempt's failure to report, not this wait's.
+    try {
+        role = loadTempRole(name);
+    }
+    catch {
+        return 'deferred';
+    }
+    const startup = role.roomMemberStartup;
+    if (!startup)
+        return 'not-required';
+    const { createCoworkAdapter, CoworkUnavailableError } = await import('./rooms-tasks/cowork-adapter.js');
+    const deps = {
+        showRoom: (roomId, env, timeoutMs) => createCoworkAdapter({ env, timeoutMs }).getRoom(roomId),
+        now: Date.now,
+        sleep: ms => new Promise(resolve => setTimeout(resolve, ms)),
+        log: message => process.stderr.write(message + '\n'),
+        env: process.env,
+        shouldStop: () => false,
+        ...partial,
+    };
+    const env = { ...deps.env, ...role.env };
+    const started = deps.now();
+    const deadline = started + STARTUP_WAIT_MS;
+    let waited = false;
+    for (;;) {
+        // Each probe fits in what is left of the wait, so the wait itself is bounded.
+        const timeoutMs = Math.min(ROOM_PROBE_TIMEOUT_MS, Math.max(1, deadline - deps.now()));
+        try {
+            await deps.showRoom(startup.room_id, env, timeoutMs);
+            if (waited)
+                deps.log(`[${name}] cowork room management ready after ${deps.now() - started}ms`);
+            return 'ready';
+        }
+        catch (error) {
+            if (!(error instanceof CoworkUnavailableError) || !error.retryable)
+                return 'deferred';
+            if (!waited)
+                deps.log(`[${name}] waiting for cowork room management: ${error.message}`);
+            waited = true;
+            if (deps.shouldStop())
+                return 'unavailable';
+            if (deps.now() + STARTUP_RETRY_MS >= deadline) {
+                deps.log(`[${name}] cowork room management still unavailable after ${STARTUP_WAIT_MS}ms: `
+                    + `${error.message}; starting the attempt so the restart budget applies`);
+                return 'unavailable';
+            }
+            await deps.sleep(STARTUP_RETRY_MS);
+            if (deps.shouldStop())
+                return 'unavailable';
+        }
+    }
+}

package/dist/startup-telemetry.d.ts

@@ -0,0 +1,16 @@
+import type { ConversationEventV1 } from './session/conversation-types.js';
+/** Body-free startup diagnostics. First output is an observation, not proof of useful work. */
+export declare class StartupTelemetry {
+    private readonly now;
+    private readonly log;
+    private readonly started;
+    private promptAt?;
+    private promptId?;
+    private firstOutput;
+    private completed;
+    private readonly tools;
+    constructor(now: () => number, log: (line: string) => void);
+    mark(stage: 'supervisor_started' | 'identity_prepare_started' | 'identity_ready' | 'harness_starting' | 'harness_ready' | 'startup_submitted' | 'readiness_turn_completed'): void;
+    observe(event: ConversationEventV1): void;
+    finish(): void;
+}

package/dist/startup-telemetry.js

@@ -0,0 +1,46 @@
+/** Body-free startup diagnostics. First output is an observation, not proof of useful work. */
+export class StartupTelemetry {
+    now;
+    log;
+    started;
+    promptAt;
+    promptId;
+    firstOutput = false;
+    completed = false;
+    tools = new Set();
+    constructor(now, log) {
+        this.now = now;
+        this.log = log;
+        this.started = now();
+    }
+    mark(stage) {
+        const at = this.now();
+        if (stage === 'startup_submitted')
+            this.promptAt = at;
+        this.log(`startup stage=${stage} elapsed_ms=${Math.max(0, at - this.started)}`);
+    }
+    observe(event) {
+        if (this.promptAt === undefined || this.completed || event.source === 'agent_replay')
+            return;
+        if (event.kind === 'prompt.started' && event.source === 'startup')
+            this.promptId = event.promptId;
+        if (this.promptId && event.promptId && event.promptId !== this.promptId)
+            return;
+        if (event.kind === 'tool.upsert' && 'toolCallId' in event.payload && event.payload.toolCallId)
+            this.tools.add(event.payload.toolCallId);
+        if (!this.firstOutput && ['message.chunk', 'message.replace'].includes(event.kind)
+            && 'role' in event.payload && event.payload.role === 'assistant'
+            && 'content' in event.payload && event.payload.content.type === 'text'
+            && event.payload.content.text.trim()) {
+            this.firstOutput = true;
+            const at = this.now();
+            this.log(`startup stage=first_assistant_output elapsed_ms=${Math.max(0, at - this.started)} model_and_tools_ms=${Math.max(0, at - this.promptAt)} tools=${this.tools.size}`);
+        }
+    }
+    finish() {
+        if (this.completed)
+            return;
+        this.completed = true;
+        this.log(`startup stage=turn_settled elapsed_ms=${Math.max(0, this.now() - this.started)} tools=${this.tools.size} first_output=${this.firstOutput}`);
+    }
+}

package/dist/subscriptions/cli.d.ts

@@ -0,0 +1,91 @@
+/**
+ * Thin adapters over the official CLIs. Nothing here reads or returns a token
+ * value: credentials stay in files the CLIs own, and secrets typed by the user
+ * (a Claude paste code) travel only over a child's stdin, never argv or logs.
+ */
+export interface SubscriptionBinaries {
+    claude: string;
+    codex: string;
+    /** `script(1)`, used to give `claude auth login` the terminal it expects. */
+    script: string;
+}
+export declare const defaultBinaries: () => SubscriptionBinaries;
+/**
+ * Child env for a profile helper: explicit home for added profiles, the CLI
+ * default otherwise. Every credential selector either CLI honours is removed,
+ * so a helper can only ever see the profile's own login.
+ */
+export declare function profileEnv(homeVar: string, profileId: string, home: string, base?: NodeJS.ProcessEnv): NodeJS.ProcessEnv;
+export interface ClaudeStatus {
+    loggedIn: boolean;
+    email?: string;
+    plan?: string;
+    org?: string;
+    authMethod?: string;
+}
+/** `claude auth status --json` (documented: exit 0 when logged in, 1 otherwise). */
+export declare function claudeAuthStatus(bin: string, env: NodeJS.ProcessEnv, timeoutMs?: number): Promise<ClaudeStatus>;
+/**
+ * Login expiry timestamps from the Claude credentials file. Field names are
+ * observed (Claude Code 2.1.x), not a documented contract, so absence is normal.
+ * Only the two numbers are kept; the parsed object is discarded immediately.
+ */
+export declare function claudeLoginExpiry(home: string): {
+    accessExpiresAt?: number;
+    refreshExpiresAt?: number;
+};
+/** Minimal stdio JSON-RPC client for `codex app-server` (the supported transport). */
+export declare class CodexAppServer {
+    private readonly child;
+    private id;
+    private buffer;
+    private readonly pending;
+    private readonly listeners;
+    private closed;
+    private constructor();
+    static start(bin: string, env: NodeJS.ProcessEnv, initializeTimeoutMs?: number): Promise<CodexAppServer>;
+    call<T = unknown>(method: string, params: unknown, timeoutMs?: number): Promise<T>;
+    onNotification(fn: (method: string, params: unknown) => void): () => void;
+    close(): void;
+    private onData;
+}
+/** One-shot use of an app-server for a profile. */
+export declare function withCodex<T>(bin: string, env: NodeJS.ProcessEnv, fn: (s: CodexAppServer) => Promise<T>, initializeTimeoutMs?: number): Promise<T>;
+/** What a Codex runtime offers the account it is signed in to. An empty list is an answer; unknown is not. */
+export type OfferedModels = {
+    state: 'known';
+    models: string[];
+} | {
+    state: 'unknown';
+    reason: string;
+};
+/**
+ * Ask this Codex executable, with this profile's environment, which models it offers (`model/list`,
+ * the call the ACP adapter itself uses). Nothing is inferred when it does not answer.
+ */
+export declare function codexOfferedModels(bin: string, env: NodeJS.ProcessEnv, budgetMs?: number): Promise<OfferedModels>;
+export interface UsageWindow {
+    id: string;
+    label: string;
+    usedPercent: number;
+    windowMins?: number;
+    resetsAt?: string;
+}
+interface CodexWindow {
+    usedPercent?: number;
+    windowDurationMins?: number | null;
+    resetsAt?: number | null;
+}
+interface CodexSnapshot {
+    limitId?: string | null;
+    limitName?: string | null;
+    primary?: CodexWindow | null;
+    secondary?: CodexWindow | null;
+}
+/** Flatten `account/rateLimits/read` into display windows. */
+export declare function codexUsageWindows(result: {
+    rateLimits?: CodexSnapshot;
+    rateLimitsByLimitId?: Record<string, CodexSnapshot | undefined> | null;
+}): UsageWindow[];
+export declare function windowName(mins?: number): string;
+export {};