hivehq 2.0.0

package/dist/src/server/agent-run-store.js

@@ -0,0 +1,137 @@
+import { parseSessionIdCapture } from './session-capture.js';
+const parseArgsJson = (argsJson, agentId) => {
+    try {
+        const parsed = JSON.parse(argsJson);
+        if (Array.isArray(parsed) && parsed.every((item) => typeof item === 'string')) {
+            return parsed;
+        }
+    }
+    catch (error) {
+        console.warn(`Invalid args_json for agent ${agentId}; falling back to empty args`, error);
+        return [];
+    }
+    console.warn(`Invalid args_json for agent ${agentId}; falling back to empty args`);
+    return [];
+};
+const parseSessionIdCaptureJson = (value) => {
+    if (!value)
+        return null;
+    return parseSessionIdCapture(JSON.parse(value));
+};
+export const createAgentRunStore = (db) => {
+    let closed = false;
+    const close = () => {
+        closed = true;
+    };
+    const listLaunchConfigs = () => {
+        if (closed) {
+            return [];
+        }
+        return db
+            .prepare(`SELECT workspace_id, agent_id, command, args_json, command_preset_id, interactive_command, preset_augmentation_disabled, resume_args_template, session_id_capture_json
+         FROM agent_launch_configs ORDER BY updated_at ASC`)
+            .all()
+            .map((row) => {
+            const typedRow = row;
+            return {
+                agentId: typedRow.agent_id,
+                config: {
+                    command: typedRow.command,
+                    args: parseArgsJson(typedRow.args_json, typedRow.agent_id),
+                    commandPresetId: typedRow.command_preset_id,
+                    interactiveCommand: typedRow.interactive_command,
+                    presetAugmentationDisabled: typedRow.preset_augmentation_disabled === 1,
+                    resumeArgsTemplate: typedRow.resume_args_template,
+                    sessionIdCapture: parseSessionIdCaptureJson(typedRow.session_id_capture_json),
+                },
+                workspaceId: typedRow.workspace_id,
+            };
+        });
+    };
+    const saveLaunchConfig = (workspaceId, agentId, input) => {
+        if (closed) {
+            return;
+        }
+        const createdAt = Date.now();
+        db.prepare(`INSERT INTO agent_launch_configs (
+         workspace_id,
+         agent_id,
+         command,
+         args_json,
+         command_preset_id,
+         interactive_command,
+         preset_augmentation_disabled,
+         resume_args_template,
+         session_id_capture_json,
+         created_at,
+         updated_at
+       )
+       VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?)
+       ON CONFLICT(workspace_id, agent_id) DO UPDATE SET
+          command = excluded.command,
+          args_json = excluded.args_json,
+          command_preset_id = excluded.command_preset_id,
+          interactive_command = excluded.interactive_command,
+          preset_augmentation_disabled = excluded.preset_augmentation_disabled,
+          resume_args_template = excluded.resume_args_template,
+          session_id_capture_json = excluded.session_id_capture_json,
+          updated_at = excluded.updated_at`).run(workspaceId, agentId, input.command, JSON.stringify(input.args ?? []), input.commandPresetId ?? null, input.interactiveCommand ?? null, input.presetAugmentationDisabled ? 1 : 0, input.resumeArgsTemplate ?? null, input.sessionIdCapture ? JSON.stringify(input.sessionIdCapture) : null, createdAt, createdAt);
+    };
+    const deleteLaunchConfig = (workspaceId, agentId) => {
+        if (closed) {
+            return;
+        }
+        db.prepare('DELETE FROM agent_launch_configs WHERE workspace_id = ? AND agent_id = ?').run(workspaceId, agentId);
+    };
+    const insertAgentRun = (runId, agentId, startedAt, pid, status = 'starting', exitCode = null, endedAt = null) => {
+        if (closed) {
+            return;
+        }
+        db.prepare(`INSERT INTO agent_runs (run_id, agent_id, pid, status, exit_code, started_at, ended_at, created_at, updated_at)
+       VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?)`).run(runId, agentId, pid, status, exitCode, startedAt, endedAt, startedAt, startedAt);
+    };
+    const updatePersistedRun = (runId, status, exitCode, endedAt) => {
+        if (closed) {
+            return;
+        }
+        db.prepare('UPDATE agent_runs SET status = ?, exit_code = ?, ended_at = ?, updated_at = ? WHERE run_id = ?').run(status, exitCode, endedAt, Date.now(), runId);
+    };
+    const listAgentRuns = (agentId) => {
+        if (closed) {
+            return [];
+        }
+        return db
+            .prepare('SELECT run_id, agent_id, pid, status, exit_code, started_at, ended_at FROM agent_runs WHERE agent_id = ? ORDER BY started_at DESC')
+            .all(agentId)
+            .map((row) => {
+            const typedRow = row;
+            return {
+                runId: typedRow.run_id,
+                agentId: typedRow.agent_id,
+                pid: typedRow.pid,
+                status: typedRow.status,
+                exitCode: typedRow.exit_code,
+                startedAt: typedRow.started_at,
+                endedAt: typedRow.ended_at,
+            };
+        });
+    };
+    const markUnfinishedRunsStale = (endedAt = Date.now()) => {
+        if (closed) {
+            return;
+        }
+        db.prepare(`UPDATE agent_runs
+       SET status = 'error', exit_code = NULL, ended_at = ?, updated_at = ?
+       WHERE status IN ('starting', 'running')`).run(endedAt, endedAt);
+    };
+    return {
+        close,
+        insertAgentRun,
+        deleteLaunchConfig,
+        listAgentRuns,
+        listLaunchConfigs,
+        markUnfinishedRunsStale,
+        saveLaunchConfig,
+        updatePersistedRun,
+    };
+};

package/dist/src/server/agent-run-sync.d.ts

@@ -0,0 +1,10 @@
+import type { AgentRunSnapshot } from './agent-manager.js';
+import type { PersistedAgentRun } from './agent-run-store.js';
+import type { LiveAgentRun } from './agent-runtime-types.js';
+type PersistedRunStatus = PersistedAgentRun['status'];
+interface AgentRunSyncStore {
+    updatePersistedRun: (runId: string, status: PersistedRunStatus, exitCode: number | null, endedAt: number | null) => void;
+}
+export declare const syncPersistedRun: (run: LiveAgentRun, snapshot: AgentRunSnapshot, store: AgentRunSyncStore) => LiveAgentRun;
+export declare const completeLiveRun: (run: LiveAgentRun, exitCode: number | null, endedAt: number, store: AgentRunSyncStore) => void;
+export {};

package/dist/src/server/agent-run-sync.js

@@ -0,0 +1,32 @@
+import { classifyCompletedRunStatus } from './agent-exit-classification.js';
+const MAX_RUN_OUTPUT_LENGTH = 1_000_000;
+const toPersistedStatus = (run) => {
+    if ('userStopped' in run &&
+        run.userStopped === true &&
+        (run.status === 'error' || run.status === 'exited')) {
+        return 'exited';
+    }
+    if (run.status === 'error' || run.status === 'exited' || run.status === 'starting') {
+        return run.status;
+    }
+    return run.exitCode === null ? 'running' : classifyCompletedRunStatus(run.exitCode);
+};
+export const syncPersistedRun = (run, snapshot, store) => {
+    const nextStatus = toPersistedStatus(run.userStopped ? { ...snapshot, userStopped: true } : snapshot);
+    const output = snapshot.output.slice(-MAX_RUN_OUTPUT_LENGTH);
+    if (run.status === nextStatus && run.exitCode === snapshot.exitCode && run.output === output) {
+        return run;
+    }
+    const endedAt = nextStatus === 'exited' || nextStatus === 'error' ? Date.now() : null;
+    store.updatePersistedRun(run.runId, nextStatus, snapshot.exitCode, endedAt);
+    run.status = nextStatus;
+    run.output = output;
+    run.exitCode = snapshot.exitCode;
+    return run;
+};
+export const completeLiveRun = (run, exitCode, endedAt, store) => {
+    const nextStatus = run.userStopped ? 'exited' : classifyCompletedRunStatus(exitCode);
+    store.updatePersistedRun(run.runId, nextStatus, exitCode, endedAt);
+    run.status = nextStatus;
+    run.exitCode = exitCode;
+};

package/dist/src/server/agent-runtime-active-run.d.ts

@@ -0,0 +1,3 @@
+import type { LiveAgentRun } from './agent-runtime-types.js';
+import type { LiveRunRegistry } from './live-run-registry.js';
+export declare const getActiveRunByAgent: (registry: LiveRunRegistry, getWorkspaceId: (agentId: string) => string | undefined, syncRun: (run: LiveAgentRun) => LiveAgentRun, workspaceId: string, agentId: string) => LiveAgentRun | undefined;

package/dist/src/server/agent-runtime-active-run.js

@@ -0,0 +1,10 @@
+export const getActiveRunByAgent = (registry, getWorkspaceId, syncRun, workspaceId, agentId) => {
+    return registry
+        .list()
+        .filter((run) => run.agentId === agentId && getWorkspaceId(run.agentId) === workspaceId)
+        .sort((left, right) => right.startedAt - left.startedAt)
+        .find((run) => {
+        const status = syncRun(run).status;
+        return status === 'starting' || status === 'running';
+    });
+};

package/dist/src/server/agent-runtime-close.d.ts

@@ -0,0 +1,5 @@
+import type { AgentManager } from './agent-manager.js';
+import type { LiveAgentRun } from './agent-runtime-types.js';
+import type { LiveRunRegistry } from './live-run-registry.js';
+export declare const AGENT_RUNTIME_CLOSE_TIMEOUT_MS = 5000;
+export declare const closeAgentRuntime: (agentManager: AgentManager | undefined, registry: LiveRunRegistry, syncRun: (run: LiveAgentRun) => LiveAgentRun) => Promise<void>;

package/dist/src/server/agent-runtime-close.js

@@ -0,0 +1,36 @@
+export const AGENT_RUNTIME_CLOSE_TIMEOUT_MS = 5000;
+const waitForExitEntries = async (entries, timeoutMs = AGENT_RUNTIME_CLOSE_TIMEOUT_MS) => {
+    if (entries.length === 0)
+        return;
+    let timer;
+    const timeout = new Promise((resolve) => {
+        timer = setTimeout(() => resolve('timeout'), timeoutMs);
+        timer.unref?.();
+    });
+    try {
+        const result = await Promise.race([
+            Promise.all(entries.map((entry) => entry.promise)).then(() => 'done'),
+            timeout,
+        ]);
+        if (result === 'timeout') {
+            const runIds = entries.map((entry) => entry.runId).join(', ');
+            console.error(`[hive] timed out waiting for agent exit during shutdown: ${runIds}`);
+        }
+    }
+    finally {
+        if (timer)
+            clearTimeout(timer);
+    }
+};
+export const closeAgentRuntime = async (agentManager, registry, syncRun) => {
+    const runs = registry.list();
+    for (const run of runs) {
+        syncRun(run);
+        agentManager?.stopRun(run.runId);
+    }
+    await waitForExitEntries(registry.listExitEntries());
+    for (const run of registry.list()) {
+        agentManager?.removeRun(run.runId);
+        registry.remove(run.runId);
+    }
+};

package/dist/src/server/agent-runtime-contract.d.ts

@@ -0,0 +1,48 @@
+import type { WorkspaceSummary } from '../shared/types.js';
+import type { PersistedAgentRun } from './agent-run-store.js';
+import type { LiveAgentRun } from './agent-runtime-types.js';
+import type { AgentTokenRegistry } from './agent-tokens.js';
+import type { PtyOutputBus } from './pty-output-bus.js';
+interface StartAgentOptions {
+    hivePort: string;
+}
+export interface AgentRuntime {
+    close: () => Promise<void>;
+    configureAgentLaunch: (workspaceId: string, agentId: string, input: import('./agent-run-store.js').AgentLaunchConfigInput) => void;
+    deleteAgentLaunchConfig: (workspaceId: string, agentId: string) => void;
+    getActiveRunByAgentId: (workspaceId: string, agentId: string) => LiveAgentRun | undefined;
+    peekAgentLaunchConfig: (workspaceId: string, agentId: string) => import('./agent-run-store.js').AgentLaunchConfigInput | undefined;
+    getLiveRun: (runId: string) => LiveAgentRun;
+    getPtyOutputBus: () => PtyOutputBus;
+    listAgentRuns: (agentId: string) => PersistedAgentRun[];
+    pauseRun: (runId: string) => void;
+    peekAgentToken: (agentId: string) => string | undefined;
+    resizeAgentRun: (runId: string, cols: number, rows: number) => void;
+    resumeRun: (runId: string) => void;
+    startAgent: (workspace: WorkspaceSummary, agentId: string, input: StartAgentOptions) => Promise<LiveAgentRun>;
+    stopAgentRun: (runId: string) => void;
+    validateAgentToken: AgentTokenRegistry['validate'];
+    writeReportPrompt: (workspaceId: string, workerName: string, workerId: string, text: string, artifacts: string[], input?: {
+        requireActiveRun?: boolean;
+    }) => void;
+    writeStatusPrompt: (workspaceId: string, workerName: string, workerId: string, text: string, artifacts: string[], input?: {
+        requireActiveRun?: boolean;
+    }) => void;
+    writeSendPrompt: (workspaceId: string, workerId: string, dispatchId: string, fromAgentName: string, workerDescription: string, text: string) => Promise<void>;
+    writeCancelPrompt: (workspaceId: string, workerId: string, dispatchId: string, reason: string, input?: {
+        requireActiveRun?: boolean;
+    }) => void;
+    writeUserInputPrompt: (workspaceId: string, text: string) => void;
+    writeSystemMessageToAgent: (workspaceId: string, agentId: string, text: string) => void;
+    /** Awaitable report delivery — rejects if the orchestrator PTY write fails,
+     *  so the caller can persist the report to the redelivery outbox. */
+    deliverReportToOrchestrator: (workspaceId: string, workerName: string, text: string, artifacts: string[], input?: {
+        requireActiveRun?: boolean;
+    }) => Promise<void>;
+    /** Awaitable opaque delivery — used to drain the report outbox so an entry
+     *  is marked delivered only after the PTY write resolves. */
+    deliverSystemMessageToAgent: (workspaceId: string, agentId: string, text: string, input?: {
+        requireActiveRun?: boolean;
+    }) => Promise<void>;
+}
+export type { StartAgentOptions };

package/dist/src/server/agent-runtime-contract.js

@@ -0,0 +1 @@
+export {};

package/dist/src/server/agent-runtime-flow-adapter.d.ts

@@ -0,0 +1,10 @@
+import type { AgentManager } from './agent-manager.js';
+import type { PtyOutputBus } from './pty-output-bus.js';
+interface FlowAdapterManager {
+    getOutputBus: () => PtyOutputBus;
+    pauseRun: (runId: string) => void;
+    resizeRun: (runId: string, cols: number, rows: number) => void;
+    resumeRun: (runId: string) => void;
+}
+export declare const createAgentRuntimeFlowAdapter: (requireManager: () => AgentManager) => FlowAdapterManager;
+export {};

package/dist/src/server/agent-runtime-flow-adapter.js

@@ -0,0 +1,14 @@
+export const createAgentRuntimeFlowAdapter = (requireManager) => ({
+    getOutputBus() {
+        return requireManager().getOutputBus();
+    },
+    pauseRun(runId) {
+        requireManager().pauseRun(runId);
+    },
+    resizeRun(runId, cols, rows) {
+        requireManager().resizeRun(runId, cols, rows);
+    },
+    resumeRun(runId) {
+        requireManager().resumeRun(runId);
+    },
+});

package/dist/src/server/agent-runtime-list-runs.d.ts

@@ -0,0 +1,3 @@
+import type { PersistedAgentRun } from './agent-run-store.js';
+import type { LiveRunRegistry } from './live-run-registry.js';
+export declare const listRunsWithFallback: (registry: LiveRunRegistry, persistedRuns: PersistedAgentRun[], agentId: string) => PersistedAgentRun[];

package/dist/src/server/agent-runtime-list-runs.js

@@ -0,0 +1,18 @@
+export const listRunsWithFallback = (registry, persistedRuns, agentId) => {
+    if (persistedRuns.length > 0) {
+        return persistedRuns;
+    }
+    return registry
+        .list()
+        .filter((run) => run.agentId === agentId)
+        .map(({ runId, pid, status, exitCode, startedAt }) => ({
+        runId,
+        agentId,
+        pid,
+        status,
+        exitCode,
+        startedAt,
+        endedAt: status === 'exited' || status === 'error' ? Date.now() : null,
+    }))
+        .sort((left, right) => right.startedAt - left.startedAt);
+};

package/dist/src/server/agent-runtime-ports.d.ts

@@ -0,0 +1,22 @@
+import type { AgentLaunchConfigInput, PersistedAgentRun } from './agent-run-store.js';
+type PersistedRunStatus = PersistedAgentRun['status'];
+export interface AgentRunStorePort {
+    close?: () => void;
+    insertAgentRun: (runId: string, agentId: string, startedAt: number, pid: number | null, status?: PersistedRunStatus, exitCode?: number | null, endedAt?: number | null) => void;
+    listAgentRuns: (agentId: string) => PersistedAgentRun[];
+    listLaunchConfigs: () => Array<{
+        agentId: string;
+        config: AgentLaunchConfigInput;
+        workspaceId: string;
+    }>;
+    markUnfinishedRunsStale: (endedAt?: number) => void;
+    deleteLaunchConfig: (workspaceId: string, agentId: string) => void;
+    saveLaunchConfig: (workspaceId: string, agentId: string, input: AgentLaunchConfigInput) => void;
+    updatePersistedRun: (runId: string, status: PersistedRunStatus, exitCode: number | null, endedAt: number | null) => void;
+}
+export interface AgentSessionStorePort {
+    clearLastSessionId: (workspaceId: string, agentId: string) => void;
+    getLastSessionId: (workspaceId: string, agentId: string) => string | undefined;
+    setLastSessionId: (workspaceId: string, agentId: string, sessionId: string) => void;
+}
+export {};

package/dist/src/server/agent-runtime-ports.js

@@ -0,0 +1 @@
+export {};

package/dist/src/server/agent-runtime-stop-run.d.ts

@@ -0,0 +1,4 @@
+import type { AgentManager } from './agent-manager.js';
+import type { LiveAgentRun } from './agent-runtime-types.js';
+import type { LiveRunRegistry } from './live-run-registry.js';
+export declare const stopLiveRun: (agentManager: AgentManager | undefined, registry: LiveRunRegistry, syncRun: (run: LiveAgentRun) => LiveAgentRun, runId: string, onUserStop?: (runId: string) => void) => void;

package/dist/src/server/agent-runtime-stop-run.js

@@ -0,0 +1,19 @@
+export const stopLiveRun = (agentManager, registry, syncRun, runId, onUserStop) => {
+    if (!agentManager) {
+        throw new Error('Agent manager is required to stop agents');
+    }
+    const liveRun = registry.get(runId);
+    if (liveRun) {
+        const status = syncRun(liveRun).status;
+        if (status === 'exited' || status === 'error') {
+            return;
+        }
+    }
+    else if (['error', 'exited'].includes(agentManager.getRun(runId).status)) {
+        return;
+    }
+    // Reaching here means the run was genuinely live and we are about to kill it
+    // at the user's request — distinct from a crash that already ended the run.
+    onUserStop?.(runId);
+    agentManager.stopRun(runId);
+};

package/dist/src/server/agent-runtime-types.d.ts

@@ -0,0 +1,5 @@
+import type { AgentRunSnapshot } from './agent-manager.js';
+export interface LiveAgentRun extends AgentRunSnapshot {
+    startedAt: number;
+    userStopped?: boolean;
+}

package/dist/src/server/agent-runtime-types.js

@@ -0,0 +1 @@
+export {};

package/dist/src/server/agent-runtime.d.ts

@@ -0,0 +1,10 @@
+import type { AgentSummary } from '../shared/types.js';
+import type { AgentManager } from './agent-manager.js';
+import type { AgentRuntime } from './agent-runtime-contract.js';
+import type { AgentRunStorePort, AgentSessionStorePort } from './agent-runtime-ports.js';
+import type { CommandPresetRecord } from './command-preset-store.js';
+import type { FeatureFlags } from './feature-flags.js';
+import { type RestartPolicy } from './restart-policy.js';
+import type { TeamMemoryInjectionService } from './team-memory-injection.js';
+export declare const createAgentRuntime: (agentManager: AgentManager | undefined, agentRunStore: AgentRunStorePort, sessionStore: AgentSessionStorePort, getCommandPreset: (id: string) => CommandPresetRecord | undefined, onAgentExit: (workspaceId: string, agentId: string) => void, restartPolicy?: RestartPolicy, getAgent?: (workspaceId: string, agentId: string) => AgentSummary | undefined, getFlags?: () => FeatureFlags, memoryInjection?: TeamMemoryInjectionService) => AgentRuntime;
+export type { AgentRuntime };

package/dist/src/server/agent-runtime.js

@@ -0,0 +1,143 @@
+import { createAgentLaunchCache } from './agent-launch-cache.js';
+import { createAgentRunStarter } from './agent-run-starter.js';
+import { syncPersistedRun } from './agent-run-sync.js';
+import { getActiveRunByAgent } from './agent-runtime-active-run.js';
+import { closeAgentRuntime } from './agent-runtime-close.js';
+import { createAgentRuntimeFlowAdapter } from './agent-runtime-flow-adapter.js';
+import { listRunsWithFallback } from './agent-runtime-list-runs.js';
+import { stopLiveRun } from './agent-runtime-stop-run.js';
+import { createAgentStdinDispatcher } from './agent-stdin-dispatcher.js';
+import { createAgentTokenRegistry } from './agent-tokens.js';
+import { createLiveRunRegistry } from './live-run-registry.js';
+import { createNoopRestartPolicy } from './restart-policy.js';
+export const createAgentRuntime = (agentManager, agentRunStore, sessionStore, getCommandPreset, onAgentExit, restartPolicy = createNoopRestartPolicy(), getAgent, getFlags, memoryInjection) => {
+    const registry = createLiveRunRegistry();
+    const launchCache = createAgentLaunchCache(agentRunStore);
+    const tokenRegistry = createAgentTokenRegistry();
+    const startPromises = new Map();
+    let closing = false;
+    const requireManager = () => {
+        if (!agentManager)
+            throw new Error('Agent manager is required for PTY terminal operations');
+        return agentManager;
+    };
+    const flowAdapter = createAgentRuntimeFlowAdapter(requireManager);
+    const syncRun = (run) => agentManager ? syncPersistedRun(run, agentManager.getRun(run.runId), agentRunStore) : run;
+    const stdinDispatcher = createAgentStdinDispatcher({
+        agentManager,
+        getLaunchConfig: launchCache.peek,
+        getWorkspaceId: launchCache.getWorkspaceId,
+        registry,
+        syncRun,
+        ...(getFlags ? { getFlags } : {}),
+        ...(memoryInjection ? { memoryInjection } : {}),
+    });
+    const startLiveRun = createAgentRunStarter({
+        agentManager,
+        registry,
+        onAgentExit,
+        store: agentRunStore,
+        sessionStore,
+        tokenRegistry,
+        getCommandPreset,
+        getAgent,
+        restartPolicy,
+        ...(getFlags ? { getFlags } : {}),
+        ...(memoryInjection ? { memoryInjection } : {}),
+    });
+    return {
+        async close() {
+            closing = true;
+            await Promise.allSettled([...startPromises.values()]);
+            await closeAgentRuntime(agentManager, registry, syncRun);
+        },
+        configureAgentLaunch(workspaceId, agentId, input) {
+            launchCache.save(workspaceId, agentId, input);
+        },
+        deleteAgentLaunchConfig(workspaceId, agentId) {
+            launchCache.remove(workspaceId, agentId);
+        },
+        peekAgentLaunchConfig(workspaceId, agentId) {
+            return launchCache.peek(workspaceId, agentId);
+        },
+        getActiveRunByAgentId(workspaceId, agentId) {
+            return getActiveRunByAgent(registry, launchCache.getWorkspaceId, syncRun, workspaceId, agentId);
+        },
+        getLiveRun(runId) {
+            const run = registry.get(runId);
+            if (!run)
+                throw new Error(`Live run not found: ${runId}`);
+            return syncRun(run);
+        },
+        getPtyOutputBus() {
+            return flowAdapter.getOutputBus();
+        },
+        listAgentRuns(agentId) {
+            return listRunsWithFallback(registry, agentRunStore.listAgentRuns(agentId), agentId);
+        },
+        pauseRun(runId) {
+            flowAdapter.pauseRun(runId);
+        },
+        peekAgentToken(agentId) {
+            return tokenRegistry.peek(agentId);
+        },
+        resizeAgentRun(runId, cols, rows) {
+            flowAdapter.resizeRun(runId, cols, rows);
+        },
+        resumeRun(runId) {
+            flowAdapter.resumeRun(runId);
+        },
+        async startAgent(workspace, agentId, input) {
+            if (closing)
+                throw new Error('Agent runtime is closing');
+            launchCache.setWorkspaceId(agentId, workspace.id);
+            const key = `${workspace.id}:${agentId}`;
+            const activeRun = getActiveRunByAgent(registry, launchCache.getWorkspaceId, syncRun, workspace.id, agentId);
+            if (activeRun)
+                return activeRun;
+            const pendingStart = startPromises.get(key);
+            if (pendingStart)
+                return pendingStart;
+            const startPromise = startLiveRun(workspace, agentId, launchCache.get(workspace.id, agentId), input.hivePort).finally(() => {
+                if (startPromises.get(key) === startPromise) {
+                    startPromises.delete(key);
+                }
+            });
+            startPromises.set(key, startPromise);
+            return startPromise;
+        },
+        stopAgentRun(runId) {
+            stopLiveRun(agentManager, registry, syncRun, runId, (stoppedRunId) => {
+                const liveRun = registry.get(stoppedRunId);
+                if (liveRun)
+                    liveRun.userStopped = true;
+                restartPolicy.markUserStopped(stoppedRunId);
+            });
+        },
+        validateAgentToken: tokenRegistry.validate,
+        writeReportPrompt(workspaceId, workerName, _workerId, text, artifacts, input = {}) {
+            stdinDispatcher.writeReportPrompt(workspaceId, workerName, text, artifacts, input);
+        },
+        writeStatusPrompt(workspaceId, workerName, _workerId, text, artifacts, input = {}) {
+            stdinDispatcher.writeStatusPrompt(workspaceId, workerName, text, artifacts, input);
+        },
+        writeSendPrompt(workspaceId, workerId, dispatchId, fromAgentName, workerDescription, text) {
+            return stdinDispatcher.writeSendPrompt(workspaceId, workerId, dispatchId, fromAgentName, workerDescription, text);
+        },
+        writeCancelPrompt(workspaceId, workerId, dispatchId, reason, input = {}) {
+            stdinDispatcher.writeCancelPrompt(workspaceId, workerId, dispatchId, reason, input);
+        },
+        writeUserInputPrompt(workspaceId, text) {
+            stdinDispatcher.writeUserInputPrompt(workspaceId, text);
+        },
+        writeSystemMessageToAgent(workspaceId, agentId, text) {
+            stdinDispatcher.writeSystemMessageToAgent(workspaceId, agentId, text);
+        },
+        deliverReportToOrchestrator(workspaceId, workerName, text, artifacts, input = {}) {
+            return stdinDispatcher.deliverReportToOrchestrator(workspaceId, workerName, text, artifacts, input);
+        },
+        deliverSystemMessageToAgent(workspaceId, agentId, text, input = {}) {
+            return stdinDispatcher.deliverSystemMessageToAgent(workspaceId, agentId, text, input);
+        },
+    };
+};

package/dist/src/server/agent-session-store.d.ts

@@ -0,0 +1,7 @@
+import type { Database } from 'better-sqlite3';
+export interface AgentSessionStore {
+    clearLastSessionId: (workspaceId: string, agentId: string) => void;
+    getLastSessionId: (workspaceId: string, agentId: string) => string | undefined;
+    setLastSessionId: (workspaceId: string, agentId: string, sessionId: string) => void;
+}
+export declare const createAgentSessionStore: (db: Database) => AgentSessionStore;

package/dist/src/server/agent-session-store.js

@@ -0,0 +1,45 @@
+export const createAgentSessionStore = (db) => {
+    const lastSessionIds = new Map();
+    for (const row of db
+        .prepare('SELECT agent_id, workspace_id, last_session_id FROM agent_sessions ORDER BY updated_at ASC')
+        .all()) {
+        lastSessionIds.set(`${row.workspace_id}:${row.agent_id}`, row.last_session_id);
+    }
+    return {
+        clearLastSessionId(workspaceId, agentId) {
+            db.transaction(() => {
+                db.prepare('DELETE FROM agent_sessions WHERE workspace_id = ? AND agent_id = ?').run(workspaceId, agentId);
+                db.prepare('UPDATE workers SET last_session_id = NULL WHERE id = ? AND workspace_id = ?').run(agentId, workspaceId);
+            })();
+            lastSessionIds.delete(`${workspaceId}:${agentId}`);
+        },
+        getLastSessionId(workspaceId, agentId) {
+            return lastSessionIds.get(`${workspaceId}:${agentId}`);
+        },
+        setLastSessionId(workspaceId, agentId, sessionId) {
+            const updatedAt = Date.now();
+            const workerExists = Boolean(db
+                .prepare('SELECT 1 FROM workers WHERE workspace_id = ? AND id = ?')
+                .get(workspaceId, agentId));
+            const isOrchestrator = agentId === `${workspaceId}:orchestrator`;
+            const workspaceExists = isOrchestrator &&
+                Boolean(db.prepare('SELECT 1 FROM workspaces WHERE id = ?').get(workspaceId));
+            if (!workerExists && !workspaceExists) {
+                lastSessionIds.delete(`${workspaceId}:${agentId}`);
+                return;
+            }
+            db.transaction(() => {
+                db.prepare(`INSERT INTO agent_sessions (agent_id, workspace_id, last_session_id, updated_at)
+           VALUES (?, ?, ?, ?)
+           ON CONFLICT(workspace_id, agent_id) DO UPDATE SET
+             workspace_id = excluded.workspace_id,
+             last_session_id = excluded.last_session_id,
+             updated_at = excluded.updated_at`).run(agentId, workspaceId, sessionId, updatedAt);
+                if (workerExists) {
+                    db.prepare('UPDATE workers SET last_session_id = ? WHERE id = ? AND workspace_id = ?').run(sessionId, agentId, workspaceId);
+                }
+            })();
+            lastSessionIds.set(`${workspaceId}:${agentId}`, sessionId);
+        },
+    };
+};

package/dist/src/server/agent-startup-instructions.d.ts

@@ -0,0 +1,20 @@
+import type { AgentSummary, WorkspaceSummary } from '../shared/types.js';
+import { type FeatureFlags } from './feature-flags.js';
+export declare const buildAgentSessionBindingMarker: ({ agent, workspace, }: {
+    agent: AgentSummary;
+    workspace: WorkspaceSummary;
+}) => string;
+export declare const buildAgentLegacyIdentityMarker: ({ agent, workspace, }: {
+    agent: AgentSummary;
+    workspace: WorkspaceSummary;
+}) => string;
+export declare const buildAgentStartupInstructions: ({ agent, memoryDigest, workspace, flags, }: {
+    agent: AgentSummary;
+    memoryDigest?: string | null | undefined;
+    workspace: WorkspaceSummary;
+    /** Live experimental flags. `workflowsEnabled` gates the `team workflow`
+     *  command line + the workflow-authoring rule (so a fresh orchestrator isn't
+     *  told to run a command the runtime rejects); `autostaffEnabled` gates the
+     *  team-sizing rule. Omitted → all off. */
+    flags?: FeatureFlags;
+}) => string;