@botbotgo/agent-harness 0.0.80 → 0.0.81

package/dist/api.d.ts

@@ -1,4 +1,4 @@
-import type { ApprovalRecord, RunRecord, RunOptions, RunSummary, ResumeOptions, RuntimeHealthSnapshot, RuntimeAdapterOptions, ThreadSummary, ThreadRecord, WorkspaceLoadOptions } from "./contracts/types.js";
+import type { ApprovalRecord, CancelOptions, RunRecord, RunOptions, RunSummary, ResumeOptions, RuntimeHealthSnapshot, RuntimeAdapterOptions, ThreadSummary, ThreadRecord, WorkspaceLoadOptions } from "./contracts/types.js";
 import { AgentHarnessRuntime } from "./runtime/harness.js";
 import type { InventoryAgentRecord, InventorySkillRecord } from "./runtime/inventory.js";
 import type { RequirementAssessmentOptions } from "./runtime/skill-requirements.js";
@@ -30,6 +30,7 @@ export declare function describeInventory(runtime: AgentHarnessRuntime, options?
     agents: InventoryAgentRecord[];
 };
 export declare function resolveApproval(runtime: AgentHarnessRuntime, options: ResumeOptions): Promise<import("./contracts/types.js").RunResult>;
+export declare function cancelRun(runtime: AgentHarnessRuntime, options: CancelOptions): Promise<import("./contracts/types.js").RunResult>;
 export declare function stop(runtime: AgentHarnessRuntime): Promise<void>;
 export declare function createToolMcpServer(runtime: AgentHarnessRuntime, options: ToolMcpServerOptions): Promise<import("@modelcontextprotocol/sdk/server/mcp.js").McpServer>;
 export declare function serveToolsOverStdio(runtime: AgentHarnessRuntime, options: ToolMcpServerOptions): Promise<import("@modelcontextprotocol/sdk/server/mcp.js").McpServer>;

package/dist/api.js

@@ -46,6 +46,9 @@ export function describeInventory(runtime, options) {
 export async function resolveApproval(runtime, options) {
     return runtime.resume(options);
 }
+export async function cancelRun(runtime, options) {
+    return runtime.cancelRun(options);
+}
 export async function stop(runtime) {
     return runtime.stop();
 }

package/dist/contracts/types.d.ts

@@ -4,7 +4,7 @@ export type RuntimeCapabilities = {
     delegation?: boolean;
     memory?: boolean;
 };
-export type RunState = "queued" | "running" | "waiting_for_approval" | "resuming" | "completed" | "failed";
+export type RunState = "queued" | "claimed" | "running" | "waiting_for_approval" | "resuming" | "cancelling" | "cancelled" | "completed" | "failed";
 export type ParsedAgentObject = {
     id: string;
     executionMode: ExecutionMode;
@@ -440,6 +440,10 @@ export type ResumeOptions = {
     decision?: "approve" | "edit" | "reject";
     editedInput?: Record<string, unknown>;
 };
+export type CancelOptions = {
+    runId: string;
+    reason?: string;
+};
 export type RestartConversationOptions = {
     threadId: string;
     mode: "restart-in-thread" | "restart-new-thread";

package/dist/index.d.ts

@@ -1,3 +1,3 @@
-export { AgentHarnessRuntime, createAgentHarness, createToolMcpServer, deleteThread, describeInventory, getApproval, getHealth, getRun, getThread, listAgentSkills, listApprovals, listRuns, listThreads, resolveApproval, run, serveToolsOverStdio, subscribe, stop, } from "./api.js";
+export { AgentHarnessRuntime, cancelRun, createAgentHarness, createToolMcpServer, deleteThread, describeInventory, getApproval, getHealth, getRun, getThread, listAgentSkills, listApprovals, listRuns, listThreads, resolveApproval, run, serveToolsOverStdio, subscribe, stop, } from "./api.js";
 export type { ToolMcpServerOptions } from "./mcp.js";
 export { tool } from "./tools.js";

package/dist/index.js

@@ -1,2 +1,2 @@
-export { AgentHarnessRuntime, createAgentHarness, createToolMcpServer, deleteThread, describeInventory, getApproval, getHealth, getRun, getThread, listAgentSkills, listApprovals, listRuns, listThreads, resolveApproval, run, serveToolsOverStdio, subscribe, stop, } from "./api.js";
+export { AgentHarnessRuntime, cancelRun, createAgentHarness, createToolMcpServer, deleteThread, describeInventory, getApproval, getHealth, getRun, getThread, listAgentSkills, listApprovals, listRuns, listThreads, resolveApproval, run, serveToolsOverStdio, subscribe, stop, } from "./api.js";
 export { tool } from "./tools.js";

package/dist/package-version.d.ts

@@ -1 +1 @@
-export declare const AGENT_HARNESS_VERSION = "0.0.79";
+export declare const AGENT_HARNESS_VERSION = "0.0.80";

package/dist/package-version.js

@@ -1 +1 @@
-export const AGENT_HARNESS_VERSION = "0.0.79";
+export const AGENT_HARNESS_VERSION = "0.0.80";

package/dist/persistence/file-store.d.ts

@@ -1,5 +1,5 @@
 import type { ArtifactListing, ArtifactRecord, DelegationRecord, HarnessEvent, InternalApprovalRecord, RunSummary, RunState, ThreadSummary, ThreadRunRecord, TranscriptMessage } from "../contracts/types.js";
-import type { PersistedRunRequest, PersistenceLifecycle as Lifecycle, RuntimePersistence, RecoveryIntent, PersistenceRunMeta as RunMeta, PersistenceThreadMeta as ThreadMeta } from "./types.js";
+import type { PersistedRunRequest, PersistedRunControlRecord, PersistedRunQueueRecord, PersistenceLifecycle as Lifecycle, RuntimePersistence, RecoveryIntent, PersistenceRunMeta as RunMeta, PersistenceThreadMeta as ThreadMeta } from "./types.js";
 type RunIndexRecord = {
     runId: string;
     threadId: string;
@@ -14,6 +14,8 @@ export declare class FilePersistence implements RuntimePersistence {
     private runIndexPath;
     private approvalIndexPath;
     private delegationIndexPath;
+    private runQueuePath;
+    private runControlPath;
     initialize(): Promise<void>;
     threadDir(threadId: string): string;
     runDir(threadId: string, runId: string): string;
@@ -64,5 +66,31 @@ export declare class FilePersistence implements RuntimePersistence {
     saveRecoveryIntent(threadId: string, runId: string, intent: RecoveryIntent): Promise<void>;
     getRecoveryIntent(threadId: string, runId: string): Promise<RecoveryIntent | null>;
     clearRecoveryIntent(threadId: string, runId: string): Promise<void>;
+    enqueueRun(input: {
+        threadId: string;
+        runId: string;
+        priority?: number;
+        queueKey?: string | null;
+        availableAt?: string;
+    }): Promise<void>;
+    getQueuedRun(runId: string): Promise<PersistedRunQueueRecord | null>;
+    claimQueuedRun(input: {
+        threadId: string;
+        runId: string;
+        workerId: string;
+        claimedAt?: string;
+        leaseExpiresAt: string;
+    }): Promise<PersistedRunQueueRecord>;
+    renewRunLease(input: {
+        runId: string;
+        workerId: string;
+        heartbeatAt?: string;
+        leaseExpiresAt: string;
+    }): Promise<void>;
+    releaseRunClaim(runId: string): Promise<void>;
+    listExpiredClaimedRuns(cutoffIso: string): Promise<PersistedRunQueueRecord[]>;
+    getRunControl(runId: string): Promise<PersistedRunControlRecord | null>;
+    requestRunCancel(runId: string, reason?: string): Promise<PersistedRunControlRecord>;
+    clearRunCancel(runId: string): Promise<void>;
 }
 export {};

package/dist/persistence/file-store.js

@@ -22,12 +22,20 @@ export class FilePersistence {
     delegationIndexPath(delegationId) {
         return path.join(this.runRoot, "indexes", "delegations", `${delegationId}.json`);
     }
+    runQueuePath(runId) {
+        return path.join(this.runRoot, "indexes", "queue", `${runId}.json`);
+    }
+    runControlPath(runId) {
+        return path.join(this.runRoot, "indexes", "run-control", `${runId}.json`);
+    }
     async initialize() {
         await Promise.all([
             "indexes/threads",
             "indexes/runs",
             "indexes/approvals",
             "indexes/delegations",
+            "indexes/queue",
+            "indexes/run-control",
             "threads",
         ].map((segment) => ensureDir(path.join(this.runRoot, segment))));
     }
@@ -107,6 +115,15 @@ export class FilePersistence {
                 resumable: false,
                 updatedAt: input.createdAt,
             }),
+            writeJson(this.runControlPath(input.runId), {
+                runId: input.runId,
+                cancelRequested: false,
+                cancelReason: null,
+                cancelRequestedAt: null,
+                heartbeatAt: null,
+                workerId: null,
+                workerStartedAt: null,
+            }),
         ]);
     }
     async setRunState(threadId, runId, state, checkpointRef) {
@@ -314,6 +331,9 @@ export class FilePersistence {
             ...approvals
                 .filter((record) => record.threadId === threadId)
                 .map((record) => rm(this.approvalIndexPath(record.approvalId), { force: true })),
+            ...runIndexes
+                .filter((record) => record.threadId === threadId)
+                .flatMap((record) => [rm(this.runQueuePath(record.runId), { force: true }), rm(this.runControlPath(record.runId), { force: true })]),
             ...delegations
                 .filter((record) => record.threadId === threadId)
                 .map((record) => rm(this.delegationIndexPath(record.delegationId), { force: true })),
@@ -427,4 +447,148 @@ export class FilePersistence {
         }
         await rm(intentPath, { force: true });
     }
+    async enqueueRun(input) {
+        const current = (await this.getQueuedRun(input.runId)) ?? {
+            runId: input.runId,
+            threadId: input.threadId,
+            priority: input.priority ?? 0,
+            queueKey: input.queueKey ?? null,
+            enqueuedAt: nowIso(),
+            availableAt: input.availableAt ?? nowIso(),
+            claimedBy: null,
+            claimedAt: null,
+            leaseExpiresAt: null,
+            attemptCount: 0,
+            lastError: null,
+        };
+        await writeJson(this.runQueuePath(input.runId), {
+            ...current,
+            threadId: input.threadId,
+            priority: input.priority ?? current.priority,
+            queueKey: input.queueKey ?? current.queueKey,
+            availableAt: input.availableAt ?? current.availableAt,
+            claimedBy: null,
+            claimedAt: null,
+            leaseExpiresAt: null,
+            lastError: null,
+        });
+    }
+    async getQueuedRun(runId) {
+        const filePath = this.runQueuePath(runId);
+        if (!(await fileExists(filePath))) {
+            return null;
+        }
+        return readJson(filePath);
+    }
+    async claimQueuedRun(input) {
+        const current = await this.getQueuedRun(input.runId);
+        if (!current) {
+            throw new Error(`Missing queued run ${input.runId}`);
+        }
+        const claimedAt = input.claimedAt ?? nowIso();
+        const next = {
+            ...current,
+            threadId: input.threadId,
+            claimedBy: input.workerId,
+            claimedAt,
+            leaseExpiresAt: input.leaseExpiresAt,
+            attemptCount: current.attemptCount + 1,
+        };
+        await writeJson(this.runQueuePath(input.runId), next);
+        await writeJson(this.runControlPath(input.runId), {
+            ...(await this.getRunControl(input.runId) ?? {
+                runId: input.runId,
+                cancelRequested: false,
+                cancelReason: null,
+                cancelRequestedAt: null,
+                heartbeatAt: null,
+                workerId: null,
+                workerStartedAt: null,
+            }),
+            heartbeatAt: claimedAt,
+            workerId: input.workerId,
+            workerStartedAt: claimedAt,
+        });
+        return next;
+    }
+    async renewRunLease(input) {
+        const current = await this.getQueuedRun(input.runId);
+        if (current) {
+            await writeJson(this.runQueuePath(input.runId), {
+                ...current,
+                claimedBy: input.workerId,
+                claimedAt: current.claimedAt ?? input.heartbeatAt ?? nowIso(),
+                leaseExpiresAt: input.leaseExpiresAt,
+            });
+        }
+        await writeJson(this.runControlPath(input.runId), {
+            ...(await this.getRunControl(input.runId) ?? {
+                runId: input.runId,
+                cancelRequested: false,
+                cancelReason: null,
+                cancelRequestedAt: null,
+                heartbeatAt: null,
+                workerId: null,
+                workerStartedAt: null,
+            }),
+            heartbeatAt: input.heartbeatAt ?? nowIso(),
+            workerId: input.workerId,
+            workerStartedAt: (await this.getRunControl(input.runId))?.workerStartedAt ?? input.heartbeatAt ?? nowIso(),
+        });
+    }
+    async releaseRunClaim(runId) {
+        await rm(this.runQueuePath(runId), { force: true });
+        const current = await this.getRunControl(runId);
+        if (!current) {
+            return;
+        }
+        await writeJson(this.runControlPath(runId), {
+            ...current,
+            heartbeatAt: null,
+            workerId: null,
+            workerStartedAt: null,
+        });
+    }
+    async listExpiredClaimedRuns(cutoffIso) {
+        const queueDir = path.join(this.runRoot, "indexes", "queue");
+        if (!(await fileExists(queueDir))) {
+            return [];
+        }
+        const entries = (await readdir(queueDir)).sort();
+        const records = await Promise.all(entries.map((entry) => readJson(path.join(queueDir, entry))));
+        return records.filter((record) => record.claimedBy && record.leaseExpiresAt && record.leaseExpiresAt <= cutoffIso);
+    }
+    async getRunControl(runId) {
+        const filePath = this.runControlPath(runId);
+        if (!(await fileExists(filePath))) {
+            return null;
+        }
+        return readJson(filePath);
+    }
+    async requestRunCancel(runId, reason) {
+        const current = await this.getRunControl(runId);
+        if (!current) {
+            throw new Error(`Missing run control for ${runId}`);
+        }
+        const updated = {
+            ...current,
+            cancelRequested: true,
+            cancelReason: reason ?? null,
+            cancelRequestedAt: nowIso(),
+        };
+        await writeJson(this.runControlPath(runId), updated);
+        return updated;
+    }
+    async clearRunCancel(runId) {
+        const current = await this.getRunControl(runId);
+        if (!current) {
+            return;
+        }
+        await writeJson(this.runControlPath(runId), {
+            ...current,
+            cancelRequested: false,
+            cancelReason: null,
+            cancelRequestedAt: null,
+        });
+    }
 }

package/dist/persistence/sqlite-store.d.ts

@@ -1,5 +1,5 @@
 import type { ArtifactListing, ArtifactRecord, HarnessEvent, InternalApprovalRecord, RunState, RunSummary, ThreadRunRecord, ThreadSummary, TranscriptMessage } from "../contracts/types.js";
-import type { PersistedRunRequest, PersistenceLifecycle, PersistenceRunMeta, PersistenceThreadMeta, RecoveryIntent, RuntimePersistence } from "./types.js";
+import type { PersistedRunRequest, PersistedRunControlRecord, PersistedRunQueueRecord, PersistenceLifecycle, PersistenceRunMeta, PersistenceThreadMeta, RecoveryIntent, RuntimePersistence } from "./types.js";
 export declare function listProtectedCheckpointThreadIds(dbPath: string): Promise<Set<string>>;
 export declare class SqlitePersistence implements RuntimePersistence {
     private readonly runRoot;
@@ -64,5 +64,33 @@ export declare class SqlitePersistence implements RuntimePersistence {
     saveRecoveryIntent(threadId: string, runId: string, intent: RecoveryIntent): Promise<void>;
     getRecoveryIntent(threadId: string, runId: string): Promise<RecoveryIntent | null>;
     clearRecoveryIntent(threadId: string, runId: string): Promise<void>;
+    private mapQueuedRun;
+    private mapRunControl;
+    enqueueRun(input: {
+        threadId: string;
+        runId: string;
+        priority?: number;
+        queueKey?: string | null;
+        availableAt?: string;
+    }): Promise<void>;
+    getQueuedRun(runId: string): Promise<PersistedRunQueueRecord | null>;
+    claimQueuedRun(input: {
+        threadId: string;
+        runId: string;
+        workerId: string;
+        claimedAt?: string;
+        leaseExpiresAt: string;
+    }): Promise<PersistedRunQueueRecord>;
+    renewRunLease(input: {
+        runId: string;
+        workerId: string;
+        heartbeatAt?: string;
+        leaseExpiresAt: string;
+    }): Promise<void>;
+    releaseRunClaim(runId: string): Promise<void>;
+    listExpiredClaimedRuns(cutoffIso: string): Promise<PersistedRunQueueRecord[]>;
+    getRunControl(runId: string): Promise<PersistedRunControlRecord | null>;
+    requestRunCancel(runId: string, reason?: string): Promise<PersistedRunControlRecord>;
+    clearRunCancel(runId: string): Promise<void>;
     readArtifact(threadId: string, runId: string, artifactPath: string): Promise<unknown>;
 }

package/dist/persistence/sqlite-store.js

@@ -2,7 +2,7 @@ import path from "node:path";
 import { mkdir, rm } from "node:fs/promises";
 import { createClient } from "@libsql/client";
 import { fileExists, readJson, writeJson } from "../utils/fs.js";
-const RUNTIME_SQLITE_SCHEMA_VERSION = 1;
+const RUNTIME_SQLITE_SCHEMA_VERSION = 2;
 const RUNTIME_SQLITE_SCHEMA_FAMILY = "agent-harness-runtime";
 function asRow(value) {
     return value;
@@ -187,6 +187,37 @@ export class SqlitePersistence {
           FOREIGN KEY (thread_id) REFERENCES threads(thread_id),
           FOREIGN KEY (run_id) REFERENCES runs(run_id)
         )
+      `);
+            await this.rawExecute(`
+        CREATE TABLE IF NOT EXISTS run_queue (
+          run_id TEXT PRIMARY KEY,
+          thread_id TEXT NOT NULL,
+          priority INTEGER NOT NULL DEFAULT 0,
+          queue_key TEXT,
+          enqueued_at TEXT NOT NULL,
+          available_at TEXT NOT NULL,
+          claimed_by TEXT,
+          claimed_at TEXT,
+          lease_expires_at TEXT,
+          attempt_count INTEGER NOT NULL DEFAULT 0,
+          last_error TEXT,
+          FOREIGN KEY (thread_id) REFERENCES threads(thread_id),
+          FOREIGN KEY (run_id) REFERENCES runs(run_id)
+        )
+      `);
+            await this.rawExecute("CREATE INDEX IF NOT EXISTS run_queue_available_idx ON run_queue(available_at, priority DESC, enqueued_at ASC)");
+            await this.rawExecute("CREATE INDEX IF NOT EXISTS run_queue_claim_idx ON run_queue(claimed_by, lease_expires_at)");
+            await this.rawExecute(`
+        CREATE TABLE IF NOT EXISTS run_control (
+          run_id TEXT PRIMARY KEY,
+          cancel_requested INTEGER NOT NULL DEFAULT 0,
+          cancel_reason TEXT,
+          cancel_requested_at TEXT,
+          heartbeat_at TEXT,
+          worker_id TEXT,
+          worker_started_at TEXT,
+          FOREIGN KEY (run_id) REFERENCES runs(run_id)
+        )
       `);
             await this.rawExecute(`
         CREATE TABLE IF NOT EXISTS artifacts (
@@ -292,6 +323,10 @@ export class SqlitePersistence {
         if (family !== RUNTIME_SQLITE_SCHEMA_FAMILY) {
             throw new Error(`Unsupported runtime sqlite schema family ${JSON.stringify(family)} in ${this.dbPath}. Expected ${JSON.stringify(RUNTIME_SQLITE_SCHEMA_FAMILY)}.`);
         }
+        if (version === "1") {
+            await this.rawExecute("INSERT OR REPLACE INTO runtime_metadata (key, value) VALUES (?, ?)", ["schema_version", String(RUNTIME_SQLITE_SCHEMA_VERSION)]);
+            return;
+        }
         if (version !== String(RUNTIME_SQLITE_SCHEMA_VERSION)) {
             throw new Error(`Unsupported runtime sqlite schema version ${JSON.stringify(version)} in ${this.dbPath}. Expected ${RUNTIME_SQLITE_SCHEMA_VERSION}.`);
         }
@@ -321,6 +356,9 @@ export class SqlitePersistence {
             0,
             null,
         ]);
+        await this.execute(`INSERT OR REPLACE INTO run_control
+       (run_id, cancel_requested, cancel_reason, cancel_requested_at, heartbeat_at, worker_id, worker_started_at)
+       VALUES (?, 0, NULL, NULL, NULL, NULL, NULL)`, [input.runId]);
     }
     async setRunState(threadId, runId, state, checkpointRef) {
         const current = await this.getRunLifecycle(threadId, runId);
@@ -445,9 +483,11 @@ export class SqlitePersistence {
         await this.execute("DELETE FROM artifacts WHERE thread_id = ?", [threadId]);
         await this.execute("DELETE FROM approvals WHERE thread_id = ?", [threadId]);
         await this.execute("DELETE FROM events WHERE thread_id = ?", [threadId]);
+        await this.execute("DELETE FROM run_queue WHERE thread_id = ?", [threadId]);
         await this.execute("DELETE FROM run_requests WHERE thread_id = ?", [threadId]);
         await this.execute("DELETE FROM recovery_intents WHERE thread_id = ?", [threadId]);
         await this.execute("DELETE FROM thread_messages WHERE thread_id = ?", [threadId]);
+        await this.execute("DELETE FROM run_control WHERE run_id IN (SELECT run_id FROM runs WHERE thread_id = ?)", [threadId]);
         await this.execute("DELETE FROM runs WHERE thread_id = ?", [threadId]);
         await this.execute("DELETE FROM threads WHERE thread_id = ?", [threadId]);
         await rm(this.threadDir(threadId), { recursive: true, force: true });
@@ -559,6 +599,108 @@ export class SqlitePersistence {
     async clearRecoveryIntent(threadId, runId) {
         await this.execute("DELETE FROM recovery_intents WHERE thread_id = ? AND run_id = ?", [threadId, runId]);
     }
+    mapQueuedRun(row) {
+        return {
+            runId: asString(row.run_id),
+            threadId: asString(row.thread_id),
+            priority: Number(row.priority ?? 0),
+            queueKey: asNullableString(row.queue_key),
+            enqueuedAt: asString(row.enqueued_at),
+            availableAt: asString(row.available_at),
+            claimedBy: asNullableString(row.claimed_by),
+            claimedAt: asNullableString(row.claimed_at),
+            leaseExpiresAt: asNullableString(row.lease_expires_at),
+            attemptCount: Number(row.attempt_count ?? 0),
+            lastError: asNullableString(row.last_error),
+        };
+    }
+    mapRunControl(row) {
+        return {
+            runId: asString(row.run_id),
+            cancelRequested: asBoolean(row.cancel_requested),
+            cancelReason: asNullableString(row.cancel_reason),
+            cancelRequestedAt: asNullableString(row.cancel_requested_at),
+            heartbeatAt: asNullableString(row.heartbeat_at),
+            workerId: asNullableString(row.worker_id),
+            workerStartedAt: asNullableString(row.worker_started_at),
+        };
+    }
+    async enqueueRun(input) {
+        const enqueuedAt = nowIso();
+        await this.execute(`INSERT OR REPLACE INTO run_queue
+       (run_id, thread_id, priority, queue_key, enqueued_at, available_at, claimed_by, claimed_at, lease_expires_at, attempt_count, last_error)
+       VALUES (?, ?, ?, ?, ?, ?, NULL, NULL, NULL, COALESCE((SELECT attempt_count FROM run_queue WHERE run_id = ?), 0), NULL)`, [
+            input.runId,
+            input.threadId,
+            input.priority ?? 0,
+            input.queueKey ?? null,
+            enqueuedAt,
+            input.availableAt ?? enqueuedAt,
+            input.runId,
+        ]);
+    }
+    async getQueuedRun(runId) {
+        const row = await this.selectOne("SELECT * FROM run_queue WHERE run_id = ?", [runId]);
+        return row ? this.mapQueuedRun(row) : null;
+    }
+    async claimQueuedRun(input) {
+        const claimedAt = input.claimedAt ?? nowIso();
+        await this.execute(`UPDATE run_queue
+       SET claimed_by = ?, claimed_at = ?, lease_expires_at = ?, attempt_count = attempt_count + 1
+       WHERE run_id = ? AND thread_id = ?`, [input.workerId, claimedAt, input.leaseExpiresAt, input.runId, input.threadId]);
+        await this.execute(`UPDATE run_control
+       SET heartbeat_at = ?, worker_id = ?, worker_started_at = COALESCE(worker_started_at, ?)
+       WHERE run_id = ?`, [claimedAt, input.workerId, claimedAt, input.runId]);
+        const claimed = await this.getQueuedRun(input.runId);
+        if (!claimed) {
+            throw new Error(`Missing queued run ${input.runId}`);
+        }
+        return claimed;
+    }
+    async renewRunLease(input) {
+        const heartbeatAt = input.heartbeatAt ?? nowIso();
+        await this.execute(`UPDATE run_queue
+       SET lease_expires_at = ?, claimed_by = COALESCE(claimed_by, ?), claimed_at = COALESCE(claimed_at, ?)
+       WHERE run_id = ?`, [input.leaseExpiresAt, input.workerId, heartbeatAt, input.runId]);
+        await this.execute(`UPDATE run_control
+       SET heartbeat_at = ?, worker_id = ?, worker_started_at = COALESCE(worker_started_at, ?)
+       WHERE run_id = ?`, [heartbeatAt, input.workerId, heartbeatAt, input.runId]);
+    }
+    async releaseRunClaim(runId) {
+        await this.execute("DELETE FROM run_queue WHERE run_id = ?", [runId]);
+        await this.execute(`UPDATE run_control
+       SET heartbeat_at = NULL, worker_id = NULL, worker_started_at = NULL
+       WHERE run_id = ?`, [runId]);
+    }
+    async listExpiredClaimedRuns(cutoffIso) {
+        const rows = await this.selectAll(`SELECT *
+       FROM run_queue
+       WHERE claimed_by IS NOT NULL
+         AND lease_expires_at IS NOT NULL
+         AND lease_expires_at <= ?
+       ORDER BY lease_expires_at ASC, run_id ASC`, [cutoffIso]);
+        return rows.map((row) => this.mapQueuedRun(row));
+    }
+    async getRunControl(runId) {
+        const row = await this.selectOne("SELECT * FROM run_control WHERE run_id = ?", [runId]);
+        return row ? this.mapRunControl(row) : null;
+    }
+    async requestRunCancel(runId, reason) {
+        const now = nowIso();
+        await this.execute(`UPDATE run_control
+       SET cancel_requested = 1, cancel_reason = ?, cancel_requested_at = ?
+       WHERE run_id = ?`, [reason ?? null, now, runId]);
+        const updated = await this.getRunControl(runId);
+        if (!updated) {
+            throw new Error(`Missing run control for ${runId}`);
+        }
+        return updated;
+    }
+    async clearRunCancel(runId) {
+        await this.execute(`UPDATE run_control
+       SET cancel_requested = 0, cancel_reason = NULL, cancel_requested_at = NULL
+       WHERE run_id = ?`, [runId]);
+    }
     async readArtifact(threadId, runId, artifactPath) {
         const filePath = path.join(this.runDir(threadId, runId), artifactPath);
         if (!(await fileExists(filePath))) {

package/dist/persistence/types.d.ts

@@ -37,6 +37,28 @@ export type RecoveryIntent = {
     resumePayload: unknown;
     attempts: number;
 };
+export type PersistedRunQueueRecord = {
+    runId: string;
+    threadId: string;
+    priority: number;
+    queueKey: string | null;
+    enqueuedAt: string;
+    availableAt: string;
+    claimedBy: string | null;
+    claimedAt: string | null;
+    leaseExpiresAt: string | null;
+    attemptCount: number;
+    lastError: string | null;
+};
+export type PersistedRunControlRecord = {
+    runId: string;
+    cancelRequested: boolean;
+    cancelReason: string | null;
+    cancelRequestedAt: string | null;
+    heartbeatAt: string | null;
+    workerId: string | null;
+    workerStartedAt: string | null;
+};
 export interface RuntimePersistence {
     initialize(): Promise<void>;
     createThread(input: {
@@ -80,4 +102,30 @@ export interface RuntimePersistence {
     saveRecoveryIntent(threadId: string, runId: string, intent: RecoveryIntent): Promise<void>;
     getRecoveryIntent(threadId: string, runId: string): Promise<RecoveryIntent | null>;
     clearRecoveryIntent(threadId: string, runId: string): Promise<void>;
+    enqueueRun(input: {
+        threadId: string;
+        runId: string;
+        priority?: number;
+        queueKey?: string | null;
+        availableAt?: string;
+    }): Promise<void>;
+    getQueuedRun(runId: string): Promise<PersistedRunQueueRecord | null>;
+    claimQueuedRun(input: {
+        threadId: string;
+        runId: string;
+        workerId: string;
+        claimedAt?: string;
+        leaseExpiresAt: string;
+    }): Promise<PersistedRunQueueRecord>;
+    renewRunLease(input: {
+        runId: string;
+        workerId: string;
+        heartbeatAt?: string;
+        leaseExpiresAt: string;
+    }): Promise<void>;
+    releaseRunClaim(runId: string): Promise<void>;
+    listExpiredClaimedRuns(cutoffIso: string): Promise<PersistedRunQueueRecord[]>;
+    getRunControl(runId: string): Promise<PersistedRunControlRecord | null>;
+    requestRunCancel(runId: string, reason?: string): Promise<PersistedRunControlRecord>;
+    clearRunCancel(runId: string): Promise<void>;
 }

package/dist/runtime/agent-runtime-adapter.js

@@ -1377,7 +1377,15 @@ export class AgentRuntimeAdapter {
         const visibleOutput = extractedOutput && !isLikelyToolArgsObject(tryParseJson(extractedOutput)) ? extractedOutput : "";
         const emptyAssistantMessageFailure = extractEmptyAssistantMessageFailure(result);
         const toolFallback = extractToolFallbackContext(result);
-        const synthesizedOutput = await this.synthesizeDeepAgentAnswer(binding, input, result);
+        let synthesizedOutput = "";
+        try {
+            synthesizedOutput = await this.synthesizeDeepAgentAnswer(binding, input, result);
+        }
+        catch (error) {
+            if (!(error instanceof RuntimeOperationTimeoutError) || !toolFallback) {
+                throw error;
+            }
+        }
         if (!visibleOutput && !synthesizedOutput && !toolFallback && emptyAssistantMessageFailure) {
             throw new Error(emptyAssistantMessageFailure);
         }

package/dist/runtime/harness.d.ts

@@ -1,4 +1,4 @@
-import type { ApprovalRecord, HarnessEvent, HarnessStreamItem, RuntimeHealthSnapshot, MessageContent, RunRecord, RunStartOptions, RestartConversationOptions, RuntimeAdapterOptions, ResumeOptions, RunOptions, RunResult, RunSummary, ThreadSummary, ThreadRecord, WorkspaceBundle } from "../contracts/types.js";
+import type { ApprovalRecord, CancelOptions, HarnessEvent, HarnessStreamItem, RuntimeHealthSnapshot, MessageContent, RunRecord, RunStartOptions, RestartConversationOptions, RuntimeAdapterOptions, ResumeOptions, RunOptions, RunResult, RunSummary, ThreadSummary, ThreadRecord, WorkspaceBundle } from "../contracts/types.js";
 import { type ToolMcpServerOptions } from "../mcp.js";
 import { type InventoryAgentRecord, type InventorySkillRecord } from "./inventory.js";
 import type { RequirementAssessmentOptions } from "./skill-requirements.js";
@@ -27,6 +27,7 @@ export declare class AgentHarnessRuntime {
     private readonly healthMonitor;
     private readonly recoveryConfig;
     private readonly concurrencyConfig;
+    private readonly workerId;
     private activeRunSlots;
     private readonly pendingRunSlots;
     private runtimeEventSequence;
@@ -84,6 +85,9 @@ export declare class AgentHarnessRuntime {
     private loadPriorHistory;
     private loadRunInput;
     private appendAssistantMessage;
+    private getRunCancellation;
+    private expirePendingApprovals;
+    private finalizeCancelledRun;
     private invokeWithHistory;
     private buildPersistedRunRequest;
     private executeQueuedRun;
@@ -100,6 +104,7 @@ export declare class AgentHarnessRuntime {
     private isDecisionRun;
     private notifyListener;
     private acquireRunSlot;
+    private dropPendingRunSlot;
     private dispatchRunListeners;
     run(options: RunOptions): Promise<RunResult>;
     streamEvents(options: RunStartOptions): AsyncGenerator<HarnessStreamItem>;
@@ -110,6 +115,9 @@ export declare class AgentHarnessRuntime {
     }>;
     close(): Promise<void>;
     stop(): Promise<void>;
+    cancelRun(options: CancelOptions): Promise<RunResult>;
     private recoverStartupRuns;
+    private reclaimExpiredClaimedRuns;
+    private isStaleRunningRun;
 }
 export { AgentHarnessRuntime as AgentHarness };