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

package/dist/runner.js

@@ -5,16 +5,13 @@ import { parse } from 'yaml';
 import { agentDir, stateRoot } from './paths.js';
 import { loadConfig, findRole, isolationContextFor, resolveMonitorConfig, resolvePermissions, } from './config.js';
 import { getAdapter } from './harness/registry.js';
-import { Tmux } from './tmux.js';
 import { createMonitor, probeIdentityPresence, } from './monitor.js';
-import { realExec, shq } from './exec.js';
+import { realExec } from './exec.js';
 import { resolveIsolation } from './isolation/policy.js';
 import { selectIsolationBackend } from './isolation/registry.js';
 import { resourceArgs, cpuControllerDelegated } from './isolation/resources.js';
 import { resolveLaunchRuntime } from './isolation/runtime.js';
-import { AcpSession } from './session/acp.js';
 import { controlRequest, RoleControlServer } from './session/control.js';
-import { TmuxSession } from './session/tmux.js';
 import { ACP_CANCEL_DEADLINE_EXCEEDED, classifyShellStatus } from './session/types.js';
 import { effectiveModelForRole, modelRecoveryHeld, reconcileModelRecovery, recordModelFailure, classifyFailureText, } from './model-recovery.js';
 import { rotateWorklog } from './worklog.js';
@@ -28,7 +25,6 @@ import { effectivePermissionMode } from './permissions.js';
 import { assertModelPinReachesChild, effectiveRoleModel, repinModelEnv } from './model-env.js';
 import { archiveTempState, markTempSupervisorActive, requestedTempStopReason, } from './temp-lifecycle.js';
 const defaultDeps = () => ({
-    tmux: new Tmux(),
     exec: realExec,
     cpuDelegated: () => cpuControllerDelegated(),
     isAlive: pid => { try {
@@ -44,7 +40,7 @@ const defaultDeps = () => ({
     fetch: (url, init) => globalThis.fetch(url, init),
     createMonitor: opts => createMonitor(opts),
     createOwnerChannel: opts => new OwnerChannel(opts),
-    startAcpSession: opts => AcpSession.start(opts),
+    startAgentSession: (adapter, options) => adapter.start(options),
     createControlServer: (stateDir, session, log) => new RoleControlServer(stateDir, session, log),
     acquireOwnerBinder: (stateDir, role, identity) => acquireOwnerBinderLease(stateDir, role, identity),
     reportOwnerStartupFailure: async (stateDir) => {
@@ -133,38 +129,10 @@ export function recordMonitorOwner(dir, owner) {
     catch { /* ownership diagnostics must never take the role down */ }
     return owner === 'fleet' && previous === 'native';
 }
-/**
- * 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 function buildPaneCommand(launch, roleEnv, exitStatusPath, paneArgv = launch.argv) {
-    const env = {
-        PATH: process.env.PATH ?? '', COLORTERM: 'truecolor', ...launch.env, ...(roleEnv ?? {}),
-    };
-    delete env[OBSOLETE_OURS_AUTOSTART_ENV];
-    // Interactive panes should advertise colour even when the supervisor itself
-    // was launched with NO_COLOR. A role may still deliberately opt back in to
-    // NO_COLOR (or replace COLORTERM) through its explicit env block.
-    const unsetNoColor = Object.prototype.hasOwnProperty.call(roleEnv ?? {}, 'NO_COLOR')
-        ? '' : '-u NO_COLOR ';
-    const envPfx = 'env -u OURS_AUTOSTART ' + unsetNoColor
-        + Object.entries(env).map(([k, v]) => `${k}=${shq(v)}`).join(' ');
-    const cmd = paneArgv.map(shq).join(' ');
-    // Write a structured record, not a bare number: the wait status alone cannot
-    // say whether the file is missing because the program never exited or because
-    // nothing ever wrote it. `printf` is POSIX; no shell branching is needed
-    // because classification happens in one place, in TypeScript.
-    const record = `'{"version":1,"backend":"tmux","status":'"$__ofs"'}'`;
-    return `${envPfx} ${cmd}; __ofs=$?; printf %s ${record} > ${shq(exitStatusPath)}`;
-}
 /** Adapt runner deps and the role's daemon-profile overrides for the monitor. */
 function monitorDeps(deps, roleEnv) {
     return {
         fetch: deps.fetch,
-        tmux: deps.tmux,
         isAlive: deps.isAlive,
         sleep: deps.sleep,
         now: deps.now,
@@ -484,16 +452,9 @@ export async function runOnce(name, opts = {}, partialDeps = {}) {
     writeFileSync(bootedFile, `${new Date(deps.now()).toISOString()} ${mode}\n`);
     const runCwd = role.cwd && existsSync(role.cwd) ? role.cwd : dir;
     const prep = await adapter.prepareSession(role, { stateDir: dir, runCwd });
-    const sessionBackend = role.session ?? 'tmux';
-    let launch = sessionBackend === 'acp'
-        ? (() => {
-            if (!adapter.buildAcpLaunch)
-                throw new Error(`harness '${role.harness}' does not support the ACP session backend`);
-            return adapter.buildAcpLaunch(role, prep);
-        })()
-        : adapter.buildLaunch(role, mode, { sessionId }, prep);
-    // Isolation is additive: only roles that declare `isolation:` are wrapped. The
-    // env prefix + exit capture in buildPaneCommand stay host-side.
+    const sessionBackend = role.session ?? 'acp';
+    let launch = adapter.agentSession.prepareLaunch(role, prep);
+    // Isolation is additive: only roles that declare `isolation:` are wrapped.
     let wrappedArgv = launch.argv;
     if (role.isolation) {
         // Start with the same durable context that config validation and doctor judged,
@@ -530,7 +491,7 @@ export async function runOnce(name, opts = {}, partialDeps = {}) {
     // user unit concurrently on boot; `ours-fleet up`/restart-all bulk-start) does not
     // hit the harness/API rate limit at once. Time-based via a shared launch gate, so
     // a lone start or a solo crash-restart waits zero. Applied right before the harness
-    // launch (tmux.newSession); the cheap monitor prime still runs immediately after.
+    // agent-session start; the cheap monitor prime still runs immediately after.
     if (staggerMs > 0) {
         const slot = await reserveLaunchSlot(stateRoot(), staggerMs, deps);
         const wait = slot - deps.now();
@@ -575,7 +536,7 @@ export async function runOnce(name, opts = {}, partialDeps = {}) {
         await monitor.prime({ resetCursor: resetMonitorCursor });
     rmSync(exitFile, { force: true });
     let pid;
-    let acpSession;
+    let agentSession;
     let control;
     let unsubscribeRecovery;
     let monitorLoop;
@@ -590,7 +551,7 @@ export async function runOnce(name, opts = {}, partialDeps = {}) {
     let loopGeneration = JSON.stringify((role.loops ?? []).map(loop => [
         loop.name, loop.definitionHash, loop.promptHash,
     ]));
-    if (sessionBackend === 'acp') {
+    {
         const perms = role.permissions ?? resolvePermissions(undefined, undefined);
         // Say once, at startup, that this role will decide permission requests by
         // itself. Without it the only trace of an auto-denied tool call is a turn
@@ -598,34 +559,16 @@ export async function runOnce(name, opts = {}, partialDeps = {}) {
         if (perms.unattended === 'deny')
             deps.log(`[${name}] permission policy: unattended=deny — with no console attached, ` +
                 `permission requests are automatically denied once each (reject_once) and the turn continues`);
-        acpSession = await deps.startAcpSession({
-            name,
-            argv: wrappedArgv,
-            cwd: runCwd,
-            env: harnessChildEnv(role, launch.env, dir),
-            stateDir: dir,
-            mode,
-            permissions: perms,
-            modeId: adapter.acpPermissionModeId?.(role),
-            // The role's declared MCP servers, and the bundled agent's `_meta`
-            // vocabulary for the options it takes no flag for. Both come from the
-            // ADAPTER and from `prep`: the ACP launch cannot carry `prep.argv`, so this
-            // is the route by which harness_options that used to be silently dropped
-            // for an ACP role actually reach the session.
-            mcpServers: adapter.acpMcpServers?.(role),
-            sessionMeta: adapter.acpSessionMeta?.(role, prep),
-            permissionMode: effectivePermissionMode(role),
-            // Provenance travels with the exact ACP launch. Keeping it out of a
-            // role-only adapter hook prevents a PATH fallback or resolver skew from
-            // claiming metadata trust for an argv it did not authenticate.
-            permissionMetadataSource: launch.permissionMetadataSource,
-            scrubObsoleteOursAutostart: true,
-            log: deps.log,
+        agentSession = await deps.startAgentSession(adapter.agentSession, {
+            role, prep,
+            launch: { ...launch, argv: wrappedArgv, env: harnessChildEnv(role, launch.env, dir) },
+            cwd: runCwd, stateDir: dir, mode, permissions: perms,
+            permissionMode: effectivePermissionMode(role), log: deps.log,
         });
-        pid = acpSession.pid;
-        arbiter = new RoleTurnArbiter(acpSession);
+        pid = agentSession.pid;
+        arbiter = new RoleTurnArbiter(agentSession);
         sessionHandle = arbiter;
-        unsubscribeRecovery = acpSession.subscribe(event => {
+        unsubscribeRecovery = agentSession.subscribe(event => {
             if (event.kind !== 'error' || !event.text)
                 return;
             const evidence = classifyFailureText(event.text, 'acp', new Date(deps.now()).toISOString());
@@ -647,7 +590,7 @@ export async function runOnce(name, opts = {}, partialDeps = {}) {
                             + `${notifyError?.message ?? String(notifyError)}`);
                     }
                 }
-                await acpSession.close();
+                await agentSession.close();
                 unsubscribeRecovery?.();
                 throw new Error(`[${name}] owner channel failed to start: `
                     + `${error?.message ?? String(error)}`);
@@ -659,7 +602,7 @@ export async function runOnce(name, opts = {}, partialDeps = {}) {
         }
         catch (error) {
             ownerBinder?.release();
-            await acpSession.close();
+            await agentSession.close();
             unsubscribeRecovery?.();
             throw error;
         }
@@ -740,7 +683,7 @@ export async function runOnce(name, opts = {}, partialDeps = {}) {
         const started = await starting;
         // A temporary role's first turn can be the active turn when an ours wake
         // needs immediate attention. A typed console/monitor cancellation ends
-        // only that turn: the already-live ACP session and any queued wake remain
+        // only that turn: the already-live agent session and any queued wake remain
         // valid. Keep every unproven cancellation, refusal, shutdown, and genuine
         // failure terminal so a role that never accepted its briefing is not
         // silently reported as healthy.
@@ -749,7 +692,7 @@ export async function runOnce(name, opts = {}, partialDeps = {}) {
             monitor?.stop();
             await control.close();
             ownerBinder?.release();
-            await acpSession.close();
+            await agentSession.close();
             unsubscribeRecovery?.();
             if (modelRecovery) {
                 if (monitorLoop)
@@ -795,7 +738,7 @@ export async function runOnce(name, opts = {}, partialDeps = {}) {
                 await ownerChannel.close().catch(() => undefined);
                 await control.close();
                 ownerBinder?.release();
-                await acpSession.close();
+                await agentSession.close();
                 unsubscribeRecovery?.();
                 throw new Error(`[${name}] owner channel failed to start: `
                     + `${error?.message ?? String(error)}`);
@@ -854,20 +797,6 @@ export async function runOnce(name, opts = {}, partialDeps = {}) {
             }
         }
     }
-    else {
-        await deps.tmux.kill(name);
-        await deps.tmux.newSession(name, runCwd, buildPaneCommand(launch, role.env, exitFile, wrappedArgv));
-        let panePid = null;
-        for (let i = 0; i < 40 && panePid === null; i++) {
-            panePid = await deps.tmux.panePid(name);
-            if (panePid === null)
-                await deps.sleep(250);
-        }
-        if (panePid === null)
-            throw new Error(`[${name}] could not resolve tmux pane pid`);
-        pid = panePid;
-        sessionHandle = new TmuxSession(name, pid, deps.tmux, deps.isAlive);
-    }
     deps.log(`[${name}] up; pid=${pid} cwd=${runCwd} harness=${role.harness} session=${sessionBackend} mode=${mode}`);
     // The monitor loop lives exactly as long as the session: it starts once the
     // pane pid is known and is stopped when that pid dies (task dies with runner).
@@ -899,7 +828,7 @@ export async function runOnce(name, opts = {}, partialDeps = {}) {
             else if (presence.state === 'absent' && identityObserved) {
                 identityAbsentSince ??= now;
                 // Require a continuous, time-bounded run of authoritative absence.
-                // The first positive observation is the readiness gate: cold tmux
+                // The first positive observation is the readiness gate: cold harness
                 // starts may spend minutes loading the harness and briefing before the
                 // agent creates/binds its identity, and absence before then is not a
                 // close event. After readiness, debounce a real disappearance.
@@ -948,19 +877,14 @@ export async function runOnce(name, opts = {}, partialDeps = {}) {
         await monitorLoop;
     }
     unsubscribeRecovery?.();
-    if (acpSession && !sessionClosed)
-        await acpSession.close();
+    if (agentSession && !sessionClosed)
+        await agentSession.close();
     const elapsed = (deps.now() - start) / 1000;
     // Establish what actually happened before deciding anything. Absence of a
     // record is `unknown` — except when the console itself is gone, which is a
     // different event with a different consequence.
-    const exitRecord = acpSession
-        ? acpSession.exitResult()
-            ?? { version: 1, class: 'unknown', detail: 'the ACP agent stopped without reporting an exit' }
-        : readExitRecord(exitFile)
-            ?? (await deps.tmux.has(name)
-                ? { version: 1, class: 'unknown', detail: 'the pane process ended without writing an exit record' }
-                : { version: 1, class: 'session-destroyed', detail: `the tmux session '${name}' no longer exists` });
+    const exitRecord = agentSession.exitResult()
+        ?? { version: 1, class: 'unknown', detail: 'the agent session stopped without reporting an exit' };
     writeFileSync(exitFile, JSON.stringify({
         ...exitRecord, at: new Date(deps.now()).toISOString(), elapsedSecs: Number(elapsed.toFixed(1)),
     }) + '\n');

package/dist/sensitive-config.d.ts

@@ -0,0 +1,2 @@
+/** Shared recursive configuration redaction boundary for operator-facing models. */
+export declare function isSensitiveConfigKey(key: string): boolean;

package/dist/sensitive-config.js

@@ -0,0 +1,4 @@
+/** Shared recursive configuration redaction boundary for operator-facing models. */
+export function isSensitiveConfigKey(key) {
+    return /(?:secret|token|password|credential|private[_-]?key|auth|invite|api[_-]?key)/i.test(key);
+}

package/dist/session/acp.d.ts

@@ -3,7 +3,7 @@ import type { CommonPermissions } from '../config.js';
 import type { AcpMcpServer } from '../harness/types.js';
 import { ConversationEventStore } from './conversation-store.js';
 import type { ConversationSnapshot, PromptOrigin, PromptReceipt, SubmitPromptCommand } from './conversation-types.js';
-import type { ConversationHandlePage, ExitRecord, InterruptOutcome, QueuedPrompt, SessionEvent, RuntimeSelectorMetadata, SessionHandle, SessionSnapshot, SubmitPromptOptions, TurnCancellationSource, TurnOutcome, TurnResult } from './types.js';
+import type { ConversationHandlePage, ExitRecord, InterruptOutcome, QueuedPrompt, SessionEvent, AgentSession, RuntimeSelectorMetadata, SessionSnapshot, SubmitPromptOptions, TurnCancellationSource, TurnOutcome, TurnResult } from './types.js';
 /** Bound safe-boundary waiting without turning a hung tool into cancellation. */
 export declare const AFTER_TOOL_BOUNDARY_TIMEOUT_MS = 120000;
 /**
@@ -81,7 +81,7 @@ export declare function classifyStopReason(stopReason: string | undefined): Turn
  * Persistent ACP v1 client. It is the sole owner of the agent's stdio; all
  * human/automation attachment happens through the fleet role-control protocol.
  */
-export declare class AcpSession implements SessionHandle {
+export declare class AcpSession implements AgentSession {
     private readonly options;
     readonly backend: "acp";
     readonly pid: number;

package/dist/session/acp.js

@@ -281,8 +281,7 @@ export class AcpSession {
                 clearTimeout(this.cancelForceKill);
             this.cancelForceKill = undefined;
             this.releaseSteeringOccupancy('adapter exited');
-            // Record the child's real exit code/signal. The tmux path can only see a
-            // shell's `$?`; here the truth is available, so keep it.
+            // Record the child's real exit code/signal while the truth is available.
             const classified = classifyChildExit(code, signal);
             this.exit = this.cancelRecoveryReason
                 ? { ...classified, detail: `${this.cancelRecoveryReason}; ${classified.detail}` }
@@ -1476,7 +1475,7 @@ export class AcpSession {
             ...(normalized.adapterMeta ? { adapterMeta: normalized.adapterMeta } : {}),
         });
     }
-    // ── conversation ledger access (SessionHandle) ─────────────────────────────
+    // ── conversation ledger access (AgentSession) ─────────────────────────────
     conversationPage(request = {}) {
         const floor = Number(this.conversationStartCursor ?? 0);
         const requested = Number(request.after ?? 0);

package/dist/session/activity.d.ts

@@ -18,9 +18,8 @@ export interface ObservedActivity {
     lastUpdateAt?: string;
 }
 /**
- * Classify agent-side activity. `unobservable` is NOT `quiet`: a backend that
- * cannot see the agent (tmux) has no evidence, and no evidence must never be
- * reported as "doing nothing".
+ * Classify agent-side activity. `unobservable` is NOT `quiet`: absent evidence
+ * must never be reported as "doing nothing".
  */
 export declare function classifyActivity(activity: SessionActivity | undefined, now?: number): ObservedActivity;
 /**

package/dist/session/activity.js

@@ -11,9 +11,8 @@
  */
 export const ACTIVITY_WINDOW_MS = 60_000;
 /**
- * Classify agent-side activity. `unobservable` is NOT `quiet`: a backend that
- * cannot see the agent (tmux) has no evidence, and no evidence must never be
- * reported as "doing nothing".
+ * Classify agent-side activity. `unobservable` is NOT `quiet`: absent evidence
+ * must never be reported as "doing nothing".
  */
 export function classifyActivity(activity, now = Date.now()) {
     if (!activity)

package/dist/session/arbiter.d.ts

@@ -1,4 +1,4 @@
-import type { ConversationHandlePage, ExitRecord, InterruptOutcome, PromptOrigin, QueuedPrompt, SessionEvent, SessionHandle, SessionSnapshot, SubmitPromptOptions, TurnCancellationSource, TurnResult } from './types.js';
+import type { ConversationHandlePage, ExitRecord, InterruptOutcome, PromptOrigin, QueuedPrompt, SessionEvent, AgentSession, SessionSnapshot, SubmitPromptOptions, TurnCancellationSource, TurnResult } from './types.js';
 import type { ConversationEventV1, ConversationSnapshot, PromptReceipt, SubmitPromptCommand } from './conversation-types.js';
 export type ScheduledAttempt = {
     state: 'started';
@@ -15,9 +15,9 @@ export type ScheduledAttempt = {
  * producers retain ACP queue semantics while making their unsettled claim
  * visible before another producer can inspect idle state.
  */
-export declare class RoleTurnArbiter implements SessionHandle {
+export declare class RoleTurnArbiter implements AgentSession {
     private readonly session;
-    readonly backend: import("../config.js").SessionBackendId;
+    readonly backend: "acp";
     readonly pid: number;
     private tail;
     private unsettled;
@@ -26,7 +26,7 @@ export declare class RoleTurnArbiter implements SessionHandle {
     private generation;
     /** Resolves the instant the CURRENT generation is retired. */
     private retirement;
-    constructor(session: SessionHandle);
+    constructor(session: AgentSession);
     /**
      * Waiters race the tail against their own generation's retirement, so a
      * single operation that never settles cannot own the boundary forever. A

package/dist/session/control.d.ts

@@ -1,5 +1,5 @@
 import { type Socket } from 'node:net';
-import type { ControlFailureKind, SessionEvent, SessionHandle, SessionSnapshot } from './types.js';
+import type { AgentSession, ControlFailureKind, SessionEvent, 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';
@@ -48,7 +48,7 @@ export interface RetainedEventPage {
     truncated: boolean;
 }
 /** The one retained-range projection shared by polling and live-follow admission. */
-export declare function retainedEventPage(session: SessionHandle, since: number): RetainedEventPage;
+export declare function retainedEventPage(session: AgentSession, 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
@@ -105,7 +105,7 @@ export declare class RoleControlServer {
     private loopManager?;
     private reloadConfig?;
     private fleetSpawner?;
-    constructor(stateDir: string, session: SessionHandle, log: (line: string) => void);
+    constructor(stateDir: string, session: AgentSession, log: (line: string) => void);
     start(): Promise<void>;
     close(): Promise<void>;
     /** Attach only the already-started supervisor-owned channel client. */

package/dist/session/types.d.ts

@@ -96,7 +96,7 @@ export interface InterruptOutcome {
     reasonCode?: string;
 }
 /**
- * What a `SessionHandle.interrupt` implementation may resolve. Before 0.17.1 the
+ * What an `AgentSession.interrupt` implementation may resolve. Before 0.17.1 the
  * contract was `Promise<void>`, and resolving at all meant the cancellation had
  * taken effect cooperatively — so an implementation written against that
  * contract stays valid and keeps its exact meaning. Only in-tree consumers read
@@ -146,7 +146,7 @@ export interface ExitRecord {
     code?: number;
     /** Signal that killed it, when one did. */
     signal?: string;
-    /** Raw wait status as the pane shell saw it (tmux only). */
+    /** Raw wait status retained when migrating a legacy shell-exit record. */
     status?: number;
     at?: string;
     /** One line an operator can read. */
@@ -194,8 +194,7 @@ export interface SessionSnapshot {
     };
     /**
      * Observed agent activity, independent of turn occupancy: the evidence a
-     * human-facing surface needs before calling a role idle. Absent on backends
-     * that cannot observe the agent at all (tmux), which is itself honest — no
+     * human-facing surface needs before calling a role idle. When absent, no
      * evidence is not evidence of inactivity.
      */
     activity?: SessionActivity;
@@ -259,7 +258,12 @@ export interface ConversationHandlePage {
     hasMore: boolean;
     snapshot: ConversationSnapshot;
 }
-export interface SessionHandle {
+/**
+ * The live, harness-neutral contract between Fleet and one agent session.
+ * Harness adapters construct this handle; orchestration code must not depend
+ * on the ACP transport which currently implements it.
+ */
+export interface AgentSession {
     readonly backend: SessionBackendId;
     readonly pid: number;
     isAlive(): boolean;
@@ -301,3 +305,5 @@ export interface SessionHandle {
     exitResult(): ExitRecord | null;
     close(): Promise<void>;
 }
+/** @deprecated Public compatibility name; use AgentSession. */
+export type SessionHandle = AgentSession;

package/dist/spawn.d.ts

@@ -85,17 +85,17 @@ export declare const effectiveIdentity: (o: SpawnOpts) => string;
 export interface SpawnDryRun {
     schemaVersion: 1;
     warning: string;
-    roleDocument: {
-        roles: Record<string, RoleConfig>;
-    };
+    roleDocument: Record<string, unknown>;
     resolvedRole: ResolvedRole;
 }
+/** Bare Agent document written by v2 spawn: inline Role × inline Brain + operations. */
+export declare function buildAgentDocument(raw: RoleConfig): Record<string, unknown>;
 /**
  * Validate and resolve a spawn without reserving names, contacting the daemon,
  * or writing state. Collision checks are necessarily a point-in-time snapshot.
  */
 export declare function spawnDryRun(o: SpawnOpts): SpawnDryRun;
-/** Permanent spawn: persist to ~/fleet.d/<Name>.yaml, then bring it up. */
+/** Permanent spawn: persist one bare Agent document under the selected v2 root. */
 export declare function spawnPermanent(o: SpawnOpts, deps: OpsDeps, creation?: CreationDeps): Promise<string>;
 export type { SupervisorLauncher } from './temp-lifecycle.js';
 /** Temp spawn: live state under ~/.ours-fleet/tmp, independent transient supervision. */