@ours.network/fleet 1.0.4 → 1.1.0-nightly.1

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.d.ts

@@ -1,15 +1,12 @@
 import { type ResolvedRole } from './config.js';
-import type { Launch } from './harness/types.js';
-import { Tmux } from './tmux.js';
 import { type MonitorHandle, type MonitorOpts, type FetchLike } from './monitor.js';
 import { type Exec } from './exec.js';
-import { type AcpSessionOptions } from './session/acp.js';
 import { RoleControlServer } from './session/control.js';
-import type { ExitRecord, SessionHandle, TurnResult } from './session/types.js';
+import type { AgentSession, ExitRecord, TurnResult } from './session/types.js';
+import type { AgentSessionAdapter, AgentSessionStartOptions } from './harness/agent-session.js';
 import { type OwnerChannelHandle, type OwnerChannelOptions } from './owner-channel/channel.js';
 import { type OwnerBinderLease } from './owner-channel/binder.js';
 export interface RunnerDeps {
-    tmux: Tmux;
     exec: Exec;
     cpuDelegated(): boolean;
     isAlive(pid: number): boolean;
@@ -23,9 +20,10 @@ export interface RunnerDeps {
     /** Construct trusted owner ingress (injectable for lifecycle tests). */
     createOwnerChannel(opts: OwnerChannelOptions): OwnerChannelHandle;
     /** Start the ACP transport (injectable for deterministic runner lifecycle tests). */
-    startAcpSession(opts: AcpSessionOptions): Promise<SessionHandle>;
+    /** Neutral construction seam for deterministic runner lifecycle tests. */
+    startAgentSession(adapter: AgentSessionAdapter, options: AgentSessionStartOptions): Promise<AgentSession>;
     /** Construct the authenticated role control route (injectable where sockets are unavailable). */
-    createControlServer(stateDir: string, session: SessionHandle, log: (line: string) => void): Pick<RoleControlServer, 'start' | 'close' | 'setFleetSpawner' | 'setOwnerChannel' | 'setConfigReloader' | 'setLoopManager'>;
+    createControlServer(stateDir: string, session: AgentSession, log: (line: string) => void): Pick<RoleControlServer, 'start' | 'close' | 'setFleetSpawner' | 'setOwnerChannel' | 'setConfigReloader' | 'setLoopManager'>;
     /** Acquire the cross-process owner-channel binder lease before replacing the control socket. */
     acquireOwnerBinder(stateDir: string, role: string, identity: string): Promise<OwnerBinderLease>;
     /** Ask the still-authenticated predecessor to emit the fixed recovery notice. */
@@ -51,14 +49,6 @@ export declare function harnessChildEnv(role: ResolvedRole, launchEnv: Record<st
  * responsible for.
  */
 export declare function recordMonitorOwner(dir: string, owner: 'fleet' | 'native'): boolean;
-/**
- * Compose the tmux pane shell command: env prefix + argv + exit-status capture.
- * `paneArgv` defaults to `launch.argv`; when isolation is active the caller passes
- * the sandbox-wrapped argv (e.g. `bwrap … -- claude …`). The `env` prefix and the
- * `echo $? > exitfile` capture stay host-side, outside the sandbox, so the runner
- * still sees the real exit code.
- */
-export declare function buildPaneCommand(launch: Launch, roleEnv: Record<string, string> | undefined, exitStatusPath: string, paneArgv?: string[]): string;
 /**
  * Read the pane's `.exit-status`. Three shapes are accepted: the structured
  * record written above, a bare number left by a pre-upgrade pane (so an