@elizaos/agent 0.25.8 → 2.0.0-alpha.144

package/packages/typescript/src/features/orchestrator/services/task-registry.js

@@ -0,0 +1,2182 @@
+import crypto from "node:crypto";
+let cachedSqlRaw = null;
+const schemaReady = new WeakSet();
+function asObject(value) {
+    if (!value || typeof value !== "object" || Array.isArray(value))
+        return null;
+    return value;
+}
+function toText(value, fallback = "") {
+    if (typeof value === "string")
+        return value;
+    if (value === null || value === undefined)
+        return fallback;
+    return String(value);
+}
+function toNumber(value, fallback = 0) {
+    if (typeof value === "number" && Number.isFinite(value))
+        return value;
+    if (typeof value === "string") {
+        const parsed = Number(value);
+        if (Number.isFinite(parsed))
+            return parsed;
+    }
+    return fallback;
+}
+function toNullableText(value) {
+    if (value === null || value === undefined || value === "")
+        return null;
+    return toText(value);
+}
+function toNullableNumber(value) {
+    if (value === null || value === undefined || value === "")
+        return null;
+    const parsed = toNumber(value, Number.NaN);
+    return Number.isFinite(parsed) ? parsed : null;
+}
+function toBoolean(value, fallback = false) {
+    if (typeof value === "boolean")
+        return value;
+    if (typeof value === "number")
+        return value !== 0;
+    if (typeof value === "string") {
+        const normalized = value.trim().toLowerCase();
+        if (["1", "true", "yes", "on"].includes(normalized))
+            return true;
+        if (["0", "false", "no", "off"].includes(normalized))
+            return false;
+    }
+    return fallback;
+}
+function parseJsonRecord(value) {
+    if (value === null || value === undefined || value === "")
+        return {};
+    if (typeof value !== "string")
+        return asObject(value) ?? {};
+    try {
+        return asObject(JSON.parse(value)) ?? {};
+    }
+    catch {
+        return {};
+    }
+}
+function parseJsonArray(value) {
+    if (value === null || value === undefined || value === "")
+        return [];
+    if (Array.isArray(value)) {
+        return value.filter((entry) => typeof entry === "string");
+    }
+    if (typeof value !== "string")
+        return [];
+    try {
+        const parsed = JSON.parse(value);
+        return Array.isArray(parsed)
+            ? parsed.filter((entry) => typeof entry === "string")
+            : [];
+    }
+    catch {
+        return [];
+    }
+}
+function isoNow() {
+    return new Date().toISOString();
+}
+function sqlQuote(value) {
+    return `'${value.replace(/'/g, "''")}'`;
+}
+function sqlText(value) {
+    if (value === null || value === undefined)
+        return "NULL";
+    return sqlQuote(value);
+}
+function sqlInteger(value) {
+    if (value === null || value === undefined)
+        return "NULL";
+    if (!Number.isFinite(value)) {
+        throw new Error("invalid numeric SQL literal");
+    }
+    return String(Math.trunc(value));
+}
+function sqlBoolean(value) {
+    return value ? "TRUE" : "FALSE";
+}
+function sqlJson(value) {
+    return sqlQuote(JSON.stringify(value ?? null));
+}
+function sqlStringList(values) {
+    return values.map((value) => sqlQuote(value)).join(", ");
+}
+function normalizeThreadStatus(value) {
+    switch (toText(value).toLowerCase()) {
+        case "active":
+        case "waiting_on_user":
+        case "blocked":
+        case "validating":
+        case "done":
+        case "failed":
+        case "archived":
+        case "interrupted":
+            return toText(value).toLowerCase();
+        default:
+            return "open";
+    }
+}
+function normalizeSessionStatus(value) {
+    switch (toText(value).toLowerCase()) {
+        case "blocked":
+        case "waiting_on_user":
+        case "completed":
+        case "stopped":
+        case "error":
+        case "tool_running":
+        case "interrupted":
+            return toText(value).toLowerCase();
+        default:
+            return "active";
+    }
+}
+function normalizeTaskNodeKind(value) {
+    switch (toText(value).toLowerCase()) {
+        case "goal":
+        case "execution":
+        case "research":
+        case "planning":
+        case "verification":
+        case "handoff":
+            return toText(value).toLowerCase();
+        default:
+            return "execution";
+    }
+}
+function normalizeTaskNodeStatus(value) {
+    switch (toText(value).toLowerCase()) {
+        case "ready":
+        case "claimed":
+        case "running":
+        case "blocked":
+        case "waiting_on_user":
+        case "verifying":
+        case "completed":
+        case "failed":
+        case "canceled":
+        case "interrupted":
+            return toText(value).toLowerCase();
+        default:
+            return "planned";
+    }
+}
+function normalizeTaskDependencyKind(value) {
+    switch (toText(value).toLowerCase()) {
+        case "parent_child":
+        case "artifact":
+        case "handoff":
+            return toText(value).toLowerCase();
+        default:
+            return "blocks";
+    }
+}
+function normalizeTaskClaimType(value) {
+    switch (toText(value).toLowerCase()) {
+        case "verification":
+        case "ownership":
+            return toText(value).toLowerCase();
+        default:
+            return "execution";
+    }
+}
+function normalizeTaskClaimStatus(value) {
+    switch (toText(value).toLowerCase()) {
+        case "released":
+        case "completed":
+        case "failed":
+        case "interrupted":
+            return toText(value).toLowerCase();
+        default:
+            return "active";
+    }
+}
+function normalizeMailboxDeliveryState(value) {
+    switch (toText(value).toLowerCase()) {
+        case "delivered":
+        case "consumed":
+            return toText(value).toLowerCase();
+        default:
+            return "pending";
+    }
+}
+function normalizeVerifierJobStatus(value) {
+    switch (toText(value).toLowerCase()) {
+        case "running":
+        case "passed":
+        case "failed":
+        case "canceled":
+            return toText(value).toLowerCase();
+        default:
+            return "pending";
+    }
+}
+function extractRows(result) {
+    if (Array.isArray(result)) {
+        return result
+            .map((row) => asObject(row))
+            .filter((row) => row !== null);
+    }
+    const obj = asObject(result);
+    if (!obj || !Array.isArray(obj.rows))
+        return [];
+    return obj.rows
+        .map((row) => asObject(row))
+        .filter((row) => row !== null);
+}
+async function getSqlRaw() {
+    if (cachedSqlRaw)
+        return cachedSqlRaw;
+    const drizzle = (await import("drizzle-orm"));
+    cachedSqlRaw = drizzle.sql.raw;
+    return cachedSqlRaw;
+}
+function getRuntimeDb(runtime) {
+    const runtimeLike = runtime;
+    const db = runtimeLike.adapter?.db ?? runtimeLike.databaseAdapter?.db;
+    if (!db || typeof db.execute !== "function") {
+        throw new Error("runtime database adapter unavailable");
+    }
+    return db;
+}
+async function executeRawSql(runtime, sqlTextValue) {
+    const raw = await getSqlRaw();
+    const result = await getRuntimeDb(runtime).execute(raw(sqlTextValue));
+    return extractRows(result);
+}
+function parseThreadRow(row) {
+    return {
+        id: toText(row.id),
+        agentId: toText(row.agent_id),
+        roomId: toNullableText(row.room_id),
+        worldId: toNullableText(row.world_id),
+        ownerUserId: toNullableText(row.owner_user_id),
+        scenarioId: toNullableText(row.scenario_id),
+        batchId: toNullableText(row.batch_id),
+        title: toText(row.title),
+        kind: toText(row.kind, "coding"),
+        status: normalizeThreadStatus(row.status),
+        originalRequest: toText(row.original_request),
+        summary: toText(row.summary),
+        acceptanceCriteria: parseJsonArray(row.acceptance_criteria_json),
+        currentPlan: parseJsonRecord(row.current_plan_json),
+        searchText: toText(row.search_text),
+        createdAt: toText(row.created_at),
+        updatedAt: toText(row.updated_at),
+        closedAt: toNullableText(row.closed_at),
+        archivedAt: toNullableText(row.archived_at),
+        lastUserTurnAt: toNullableText(row.last_user_turn_at),
+        lastCoordinatorTurnAt: toNullableText(row.last_coordinator_turn_at),
+        metadata: parseJsonRecord(row.metadata_json),
+    };
+}
+function parseThreadSummaryRow(row) {
+    return {
+        ...parseThreadRow(row),
+        sessionCount: toNumber(row.session_count, 0),
+        activeSessionCount: toNumber(row.active_session_count, 0),
+        latestSessionId: toNullableText(row.latest_session_id),
+        latestSessionLabel: toNullableText(row.latest_session_label),
+        latestWorkdir: toNullableText(row.latest_workdir),
+        latestRepo: toNullableText(row.latest_repo),
+        latestActivityAt: toNullableNumber(row.latest_activity_at),
+        decisionCount: toNumber(row.decision_count, 0),
+        nodeCount: toNumber(row.node_count, 0),
+        readyNodeCount: toNumber(row.ready_node_count, 0),
+        completedNodeCount: toNumber(row.completed_node_count, 0),
+        verifierJobCount: toNumber(row.verifier_job_count, 0),
+        evidenceCount: toNumber(row.evidence_count, 0),
+    };
+}
+function parseSessionRow(row) {
+    return {
+        id: toText(row.id),
+        threadId: toText(row.thread_id),
+        agentId: toText(row.agent_id),
+        sessionId: toText(row.session_id),
+        framework: toText(row.framework, "claude"),
+        providerSource: toNullableText(row.provider_source),
+        label: toText(row.label),
+        originalTask: toText(row.original_task),
+        workdir: toText(row.workdir),
+        repo: toNullableText(row.repo),
+        status: normalizeSessionStatus(row.status),
+        decisionCount: toNumber(row.decision_count, 0),
+        autoResolvedCount: toNumber(row.auto_resolved_count, 0),
+        registeredAt: toNumber(row.registered_at, 0),
+        lastActivityAt: toNumber(row.last_activity_at, 0),
+        idleCheckCount: toNumber(row.idle_check_count, 0),
+        taskDelivered: toBoolean(row.task_delivered),
+        completionSummary: toNullableText(row.completion_summary),
+        lastSeenDecisionIndex: toNumber(row.last_seen_decision_index, 0),
+        lastInputSentAt: toNullableNumber(row.last_input_sent_at),
+        stoppedAt: toNullableNumber(row.stopped_at),
+        createdAt: toText(row.created_at),
+        updatedAt: toText(row.updated_at),
+        metadata: parseJsonRecord(row.metadata_json),
+    };
+}
+function parseDecisionRow(row) {
+    return {
+        id: toText(row.id),
+        threadId: toText(row.thread_id),
+        sessionId: toText(row.session_id),
+        timestamp: toNumber(row.timestamp, 0),
+        event: toText(row.event_type),
+        promptText: toText(row.prompt_text),
+        decision: toText(row.decision),
+        response: toNullableText(row.response),
+        reasoning: toText(row.reasoning),
+        metadata: parseJsonRecord(row.metadata_json),
+    };
+}
+function parseEventRow(row) {
+    return {
+        id: toText(row.id),
+        threadId: toText(row.thread_id),
+        sessionId: toNullableText(row.session_id),
+        eventType: toText(row.event_type),
+        timestamp: toNumber(row.timestamp, 0),
+        summary: toText(row.summary),
+        data: parseJsonRecord(row.data_json),
+        createdAt: toText(row.created_at),
+    };
+}
+function parseArtifactRow(row) {
+    return {
+        id: toText(row.id),
+        threadId: toText(row.thread_id),
+        sessionId: toNullableText(row.session_id),
+        artifactType: toText(row.artifact_type),
+        title: toText(row.title),
+        path: toNullableText(row.path),
+        uri: toNullableText(row.uri),
+        mimeType: toNullableText(row.mime_type),
+        metadata: parseJsonRecord(row.metadata_json),
+        createdAt: toText(row.created_at),
+    };
+}
+function parseTranscriptRow(row) {
+    return {
+        id: toText(row.id),
+        threadId: toText(row.thread_id),
+        sessionId: toText(row.session_id),
+        timestamp: toNumber(row.timestamp, 0),
+        direction: toText(row.direction),
+        content: toText(row.content),
+        metadata: parseJsonRecord(row.metadata_json),
+        createdAt: toText(row.created_at),
+    };
+}
+function parsePendingDecisionRow(row) {
+    return {
+        sessionId: toText(row.session_id),
+        threadId: toText(row.thread_id),
+        promptText: toText(row.prompt_text),
+        recentOutput: toText(row.recent_output),
+        llmDecision: parseJsonRecord(row.llm_decision_json),
+        taskContext: parseJsonRecord(row.task_context_json),
+        createdAt: toNumber(row.created_at, 0),
+        updatedAt: toText(row.updated_at),
+    };
+}
+function parseTaskNodeRow(row) {
+    return {
+        id: toText(row.id),
+        threadId: toText(row.thread_id),
+        parentNodeId: toNullableText(row.parent_node_id),
+        kind: normalizeTaskNodeKind(row.kind),
+        status: normalizeTaskNodeStatus(row.status),
+        title: toText(row.title),
+        instructions: toText(row.instructions),
+        acceptanceCriteria: parseJsonArray(row.acceptance_criteria_json),
+        requiredCapabilities: parseJsonArray(row.required_capabilities_json),
+        expectedArtifacts: parseJsonArray(row.expected_artifacts_json),
+        assignedSessionId: toNullableText(row.assigned_session_id),
+        assignedLabel: toNullableText(row.assigned_label),
+        agentType: toNullableText(row.agent_type),
+        workdir: toNullableText(row.workdir),
+        repo: toNullableText(row.repo),
+        priority: toNumber(row.priority, 0),
+        depth: toNumber(row.depth, 0),
+        sequence: toNumber(row.sequence, 0),
+        createdFrom: toNullableText(row.created_from),
+        metadata: parseJsonRecord(row.metadata_json),
+        createdAt: toText(row.created_at),
+        updatedAt: toText(row.updated_at),
+        startedAt: toNullableText(row.started_at),
+        completedAt: toNullableText(row.completed_at),
+    };
+}
+function parseTaskDependencyRow(row) {
+    return {
+        id: toText(row.id),
+        threadId: toText(row.thread_id),
+        fromNodeId: toText(row.from_node_id),
+        toNodeId: toText(row.to_node_id),
+        dependencyKind: normalizeTaskDependencyKind(row.dependency_kind),
+        requiredStatus: normalizeTaskNodeStatus(row.required_status),
+        metadata: parseJsonRecord(row.metadata_json),
+        createdAt: toText(row.created_at),
+    };
+}
+function parseTaskClaimRow(row) {
+    return {
+        id: toText(row.id),
+        threadId: toText(row.thread_id),
+        nodeId: toText(row.node_id),
+        sessionId: toText(row.session_id),
+        claimType: normalizeTaskClaimType(row.claim_type),
+        status: normalizeTaskClaimStatus(row.status),
+        claimedAt: toText(row.claimed_at),
+        releasedAt: toNullableText(row.released_at),
+        metadata: parseJsonRecord(row.metadata_json),
+    };
+}
+function parseTaskMailboxMessageRow(row) {
+    return {
+        id: toText(row.id),
+        threadId: toText(row.thread_id),
+        nodeId: toNullableText(row.node_id),
+        sessionId: toNullableText(row.session_id),
+        sender: toText(row.sender),
+        recipient: toText(row.recipient),
+        subject: toText(row.subject),
+        body: toText(row.body),
+        deliveryState: normalizeMailboxDeliveryState(row.delivery_state),
+        metadata: parseJsonRecord(row.metadata_json),
+        createdAt: toText(row.created_at),
+        deliveredAt: toNullableText(row.delivered_at),
+    };
+}
+function parseTaskVerifierJobRow(row) {
+    return {
+        id: toText(row.id),
+        threadId: toText(row.thread_id),
+        nodeId: toText(row.node_id),
+        status: normalizeVerifierJobStatus(row.status),
+        verifierType: toText(row.verifier_type),
+        title: toText(row.title),
+        instructions: toText(row.instructions),
+        config: parseJsonRecord(row.config_json),
+        metadata: parseJsonRecord(row.metadata_json),
+        createdAt: toText(row.created_at),
+        startedAt: toNullableText(row.started_at),
+        completedAt: toNullableText(row.completed_at),
+    };
+}
+function parseTaskEvidenceRow(row) {
+    return {
+        id: toText(row.id),
+        threadId: toText(row.thread_id),
+        nodeId: toNullableText(row.node_id),
+        sessionId: toNullableText(row.session_id),
+        verifierJobId: toNullableText(row.verifier_job_id),
+        evidenceType: toText(row.evidence_type),
+        title: toText(row.title),
+        summary: toText(row.summary),
+        path: toNullableText(row.path),
+        uri: toNullableText(row.uri),
+        content: parseJsonRecord(row.content_json),
+        metadata: parseJsonRecord(row.metadata_json),
+        createdAt: toText(row.created_at),
+    };
+}
+function buildSearchText(parts) {
+    return parts
+        .map((part) => (part ?? "").trim().toLowerCase())
+        .filter(Boolean)
+        .join(" ");
+}
+function isTerminalTaskNodeStatus(status) {
+    return (status === "completed" ||
+        status === "failed" ||
+        status === "canceled" ||
+        status === "interrupted");
+}
+function dependencyStatusSatisfied(actual, required) {
+    if (actual === required)
+        return true;
+    return false;
+}
+function buildThreadListWhereClauses(options) {
+    const clauses = [];
+    if (options.threadId) {
+        clauses.push(`thread.id = ${sqlQuote(options.threadId)}`);
+    }
+    if (!options.includeArchived) {
+        clauses.push("thread.archived_at IS NULL");
+    }
+    if (options.status) {
+        clauses.push(`thread.status = ${sqlQuote(options.status)}`);
+    }
+    if (Array.isArray(options.statuses) && options.statuses.length > 0) {
+        const normalizedStatuses = options.statuses
+            .map((status) => normalizeThreadStatus(status))
+            .filter(Boolean);
+        if (normalizedStatuses.length > 0) {
+            clauses.push(`thread.status IN (${sqlStringList(normalizedStatuses)})`);
+        }
+    }
+    if (options.kind) {
+        clauses.push(`thread.kind = ${sqlQuote(options.kind)}`);
+    }
+    if (options.roomId) {
+        clauses.push(`thread.room_id = ${sqlQuote(options.roomId)}`);
+    }
+    if (options.worldId) {
+        clauses.push(`thread.world_id = ${sqlQuote(options.worldId)}`);
+    }
+    if (options.ownerUserId) {
+        clauses.push(`thread.owner_user_id = ${sqlQuote(options.ownerUserId)}`);
+    }
+    if (options.scenarioId) {
+        clauses.push(`thread.scenario_id = ${sqlQuote(options.scenarioId)}`);
+    }
+    if (options.batchId) {
+        clauses.push(`thread.batch_id = ${sqlQuote(options.batchId)}`);
+    }
+    if (options.createdAfter) {
+        clauses.push(`thread.created_at >= ${sqlQuote(options.createdAfter)}`);
+    }
+    if (options.createdBefore) {
+        clauses.push(`thread.created_at <= ${sqlQuote(options.createdBefore)}`);
+    }
+    if (options.updatedAfter) {
+        clauses.push(`thread.updated_at >= ${sqlQuote(options.updatedAfter)}`);
+    }
+    if (options.updatedBefore) {
+        clauses.push(`thread.updated_at <= ${sqlQuote(options.updatedBefore)}`);
+    }
+    if (typeof options.latestActivityAfter === "number") {
+        clauses.push(`COALESCE(latest.last_activity_at, 0) >= ${sqlInteger(options.latestActivityAfter)}`);
+    }
+    if (typeof options.latestActivityBefore === "number") {
+        clauses.push(`COALESCE(latest.last_activity_at, 0) <= ${sqlInteger(options.latestActivityBefore)}`);
+    }
+    if (typeof options.hasActiveSession === "boolean") {
+        clauses.push(options.hasActiveSession
+            ? "COALESCE(session_counts.active_session_count, 0) > 0"
+            : "COALESCE(session_counts.active_session_count, 0) = 0");
+    }
+    if (options.search?.trim()) {
+        const q = options.search.trim().toLowerCase().replace(/[%_]/g, "\\$&");
+        clauses.push(`thread.search_text LIKE ${sqlQuote(`%${q}%`)}`);
+    }
+    return clauses;
+}
+export class TaskRegistry {
+    runtime;
+    constructor(runtime) {
+        this.runtime = runtime;
+    }
+    schemaKey() {
+        const runtimeLike = this.runtime;
+        return (runtimeLike.adapter ??
+            runtimeLike.databaseAdapter ??
+            this.runtime);
+    }
+    async ensureSchema() {
+        const key = this.schemaKey();
+        if (schemaReady.has(key))
+            return;
+        await executeRawSql(this.runtime, `CREATE TABLE IF NOT EXISTS orchestrator_task_threads (
+        id TEXT PRIMARY KEY,
+        agent_id TEXT NOT NULL,
+        room_id TEXT,
+        world_id TEXT,
+        owner_user_id TEXT,
+        scenario_id TEXT,
+        batch_id TEXT,
+        title TEXT NOT NULL,
+        kind TEXT NOT NULL DEFAULT 'coding',
+        status TEXT NOT NULL DEFAULT 'open',
+        original_request TEXT NOT NULL,
+        summary TEXT NOT NULL DEFAULT '',
+        acceptance_criteria_json TEXT NOT NULL DEFAULT '[]',
+        current_plan_json TEXT NOT NULL DEFAULT '{}',
+        search_text TEXT NOT NULL DEFAULT '',
+        created_at TEXT NOT NULL,
+        updated_at TEXT NOT NULL,
+        closed_at TEXT,
+        archived_at TEXT,
+        last_user_turn_at TEXT,
+        last_coordinator_turn_at TEXT,
+        metadata_json TEXT NOT NULL DEFAULT '{}'
+      )`);
+        await executeRawSql(this.runtime, `CREATE TABLE IF NOT EXISTS orchestrator_task_sessions (
+        id TEXT PRIMARY KEY,
+        thread_id TEXT NOT NULL,
+        agent_id TEXT NOT NULL,
+        session_id TEXT NOT NULL UNIQUE,
+        framework TEXT NOT NULL,
+        provider_source TEXT,
+        label TEXT NOT NULL,
+        original_task TEXT NOT NULL,
+        workdir TEXT NOT NULL,
+        repo TEXT,
+        status TEXT NOT NULL DEFAULT 'active',
+        decision_count INTEGER NOT NULL DEFAULT 0,
+        auto_resolved_count INTEGER NOT NULL DEFAULT 0,
+        registered_at BIGINT NOT NULL,
+        last_activity_at BIGINT NOT NULL,
+        idle_check_count INTEGER NOT NULL DEFAULT 0,
+        task_delivered BOOLEAN NOT NULL DEFAULT FALSE,
+        completion_summary TEXT,
+        last_seen_decision_index INTEGER NOT NULL DEFAULT 0,
+        last_input_sent_at BIGINT,
+        stopped_at BIGINT,
+        created_at TEXT NOT NULL,
+        updated_at TEXT NOT NULL,
+        metadata_json TEXT NOT NULL DEFAULT '{}'
+      )`);
+        await executeRawSql(this.runtime, `CREATE TABLE IF NOT EXISTS orchestrator_task_decisions (
+        id TEXT PRIMARY KEY,
+        thread_id TEXT NOT NULL,
+        session_id TEXT NOT NULL,
+        timestamp BIGINT NOT NULL,
+        event_type TEXT NOT NULL,
+        prompt_text TEXT NOT NULL DEFAULT '',
+        decision TEXT NOT NULL,
+        response TEXT,
+        reasoning TEXT NOT NULL,
+        metadata_json TEXT NOT NULL DEFAULT '{}',
+        created_at TEXT NOT NULL
+      )`);
+        await executeRawSql(this.runtime, `CREATE TABLE IF NOT EXISTS orchestrator_task_events (
+        id TEXT PRIMARY KEY,
+        thread_id TEXT NOT NULL,
+        session_id TEXT,
+        event_type TEXT NOT NULL,
+        timestamp BIGINT NOT NULL,
+        summary TEXT NOT NULL DEFAULT '',
+        data_json TEXT NOT NULL DEFAULT '{}',
+        created_at TEXT NOT NULL
+      )`);
+        await executeRawSql(this.runtime, `CREATE TABLE IF NOT EXISTS orchestrator_task_artifacts (
+        id TEXT PRIMARY KEY,
+        thread_id TEXT NOT NULL,
+        session_id TEXT,
+        artifact_type TEXT NOT NULL,
+        title TEXT NOT NULL,
+        path TEXT,
+        uri TEXT,
+        mime_type TEXT,
+        metadata_json TEXT NOT NULL DEFAULT '{}',
+        created_at TEXT NOT NULL
+      )`);
+        await executeRawSql(this.runtime, `CREATE TABLE IF NOT EXISTS orchestrator_task_transcripts (
+        id TEXT PRIMARY KEY,
+        thread_id TEXT NOT NULL,
+        session_id TEXT NOT NULL,
+        timestamp BIGINT NOT NULL,
+        direction TEXT NOT NULL,
+        content TEXT NOT NULL,
+        metadata_json TEXT NOT NULL DEFAULT '{}',
+        created_at TEXT NOT NULL
+      )`);
+        await executeRawSql(this.runtime, `CREATE TABLE IF NOT EXISTS orchestrator_task_pending_decisions (
+        session_id TEXT PRIMARY KEY,
+        thread_id TEXT NOT NULL,
+        prompt_text TEXT NOT NULL,
+        recent_output TEXT NOT NULL DEFAULT '',
+        llm_decision_json TEXT NOT NULL DEFAULT '{}',
+        task_context_json TEXT NOT NULL DEFAULT '{}',
+        created_at BIGINT NOT NULL,
+        updated_at TEXT NOT NULL
+      )`);
+        await executeRawSql(this.runtime, `CREATE TABLE IF NOT EXISTS orchestrator_task_nodes (
+        id TEXT PRIMARY KEY,
+        thread_id TEXT NOT NULL,
+        parent_node_id TEXT,
+        kind TEXT NOT NULL DEFAULT 'execution',
+        status TEXT NOT NULL DEFAULT 'planned',
+        title TEXT NOT NULL,
+        instructions TEXT NOT NULL DEFAULT '',
+        acceptance_criteria_json TEXT NOT NULL DEFAULT '[]',
+        required_capabilities_json TEXT NOT NULL DEFAULT '[]',
+        expected_artifacts_json TEXT NOT NULL DEFAULT '[]',
+        assigned_session_id TEXT,
+        assigned_label TEXT,
+        agent_type TEXT,
+        workdir TEXT,
+        repo TEXT,
+        priority INTEGER NOT NULL DEFAULT 0,
+        depth INTEGER NOT NULL DEFAULT 0,
+        sequence INTEGER NOT NULL DEFAULT 0,
+        created_from TEXT,
+        metadata_json TEXT NOT NULL DEFAULT '{}',
+        created_at TEXT NOT NULL,
+        updated_at TEXT NOT NULL,
+        started_at TEXT,
+        completed_at TEXT
+      )`);
+        await executeRawSql(this.runtime, `CREATE TABLE IF NOT EXISTS orchestrator_task_dependencies (
+        id TEXT PRIMARY KEY,
+        thread_id TEXT NOT NULL,
+        from_node_id TEXT NOT NULL,
+        to_node_id TEXT NOT NULL,
+        dependency_kind TEXT NOT NULL DEFAULT 'blocks',
+        required_status TEXT NOT NULL DEFAULT 'completed',
+        metadata_json TEXT NOT NULL DEFAULT '{}',
+        created_at TEXT NOT NULL
+      )`);
+        await executeRawSql(this.runtime, `CREATE TABLE IF NOT EXISTS orchestrator_task_claims (
+        id TEXT PRIMARY KEY,
+        thread_id TEXT NOT NULL,
+        node_id TEXT NOT NULL,
+        session_id TEXT NOT NULL,
+        claim_type TEXT NOT NULL DEFAULT 'execution',
+        status TEXT NOT NULL DEFAULT 'active',
+        claimed_at TEXT NOT NULL,
+        released_at TEXT,
+        metadata_json TEXT NOT NULL DEFAULT '{}'
+      )`);
+        await executeRawSql(this.runtime, `CREATE TABLE IF NOT EXISTS orchestrator_task_mailbox (
+        id TEXT PRIMARY KEY,
+        thread_id TEXT NOT NULL,
+        node_id TEXT,
+        session_id TEXT,
+        sender TEXT NOT NULL,
+        recipient TEXT NOT NULL,
+        subject TEXT NOT NULL DEFAULT '',
+        body TEXT NOT NULL,
+        delivery_state TEXT NOT NULL DEFAULT 'pending',
+        metadata_json TEXT NOT NULL DEFAULT '{}',
+        created_at TEXT NOT NULL,
+        delivered_at TEXT
+      )`);
+        await executeRawSql(this.runtime, `CREATE TABLE IF NOT EXISTS orchestrator_task_verifier_jobs (
+        id TEXT PRIMARY KEY,
+        thread_id TEXT NOT NULL,
+        node_id TEXT NOT NULL,
+        status TEXT NOT NULL DEFAULT 'pending',
+        verifier_type TEXT NOT NULL,
+        title TEXT NOT NULL,
+        instructions TEXT NOT NULL DEFAULT '',
+        config_json TEXT NOT NULL DEFAULT '{}',
+        metadata_json TEXT NOT NULL DEFAULT '{}',
+        created_at TEXT NOT NULL,
+        started_at TEXT,
+        completed_at TEXT
+      )`);
+        await executeRawSql(this.runtime, `CREATE TABLE IF NOT EXISTS orchestrator_task_evidence (
+        id TEXT PRIMARY KEY,
+        thread_id TEXT NOT NULL,
+        node_id TEXT,
+        session_id TEXT,
+        verifier_job_id TEXT,
+        evidence_type TEXT NOT NULL,
+        title TEXT NOT NULL,
+        summary TEXT NOT NULL DEFAULT '',
+        path TEXT,
+        uri TEXT,
+        content_json TEXT NOT NULL DEFAULT '{}',
+        metadata_json TEXT NOT NULL DEFAULT '{}',
+        created_at TEXT NOT NULL
+      )`);
+        await executeRawSql(this.runtime, `ALTER TABLE orchestrator_task_threads ADD COLUMN scenario_id TEXT`).catch(() => undefined);
+        await executeRawSql(this.runtime, `ALTER TABLE orchestrator_task_threads ADD COLUMN batch_id TEXT`).catch(() => undefined);
+        await executeRawSql(this.runtime, `CREATE INDEX IF NOT EXISTS idx_orchestrator_task_threads_status
+         ON orchestrator_task_threads(status)`);
+        await executeRawSql(this.runtime, `CREATE INDEX IF NOT EXISTS idx_orchestrator_task_threads_scenario_id
+         ON orchestrator_task_threads(scenario_id)`);
+        await executeRawSql(this.runtime, `CREATE INDEX IF NOT EXISTS idx_orchestrator_task_threads_batch_id
+         ON orchestrator_task_threads(batch_id)`);
+        await executeRawSql(this.runtime, `CREATE INDEX IF NOT EXISTS idx_orchestrator_task_threads_updated_at
+         ON orchestrator_task_threads(updated_at)`);
+        await executeRawSql(this.runtime, `CREATE INDEX IF NOT EXISTS idx_orchestrator_task_threads_archived_at
+         ON orchestrator_task_threads(archived_at)`);
+        await executeRawSql(this.runtime, `CREATE INDEX IF NOT EXISTS idx_orchestrator_task_sessions_thread_id
+         ON orchestrator_task_sessions(thread_id)`);
+        await executeRawSql(this.runtime, `CREATE INDEX IF NOT EXISTS idx_orchestrator_task_sessions_status
+         ON orchestrator_task_sessions(status)`);
+        await executeRawSql(this.runtime, `CREATE INDEX IF NOT EXISTS idx_orchestrator_task_decisions_thread_id
+         ON orchestrator_task_decisions(thread_id, timestamp DESC)`);
+        await executeRawSql(this.runtime, `CREATE INDEX IF NOT EXISTS idx_orchestrator_task_events_thread_id
+         ON orchestrator_task_events(thread_id, timestamp DESC)`);
+        await executeRawSql(this.runtime, `CREATE INDEX IF NOT EXISTS idx_orchestrator_task_transcripts_thread_id
+         ON orchestrator_task_transcripts(thread_id, timestamp DESC)`);
+        await executeRawSql(this.runtime, `CREATE INDEX IF NOT EXISTS idx_orchestrator_task_pending_decisions_thread_id
+         ON orchestrator_task_pending_decisions(thread_id)`);
+        await executeRawSql(this.runtime, `CREATE INDEX IF NOT EXISTS idx_orchestrator_task_pending_decisions_created_at
+         ON orchestrator_task_pending_decisions(created_at DESC)`);
+        await executeRawSql(this.runtime, `CREATE INDEX IF NOT EXISTS idx_orchestrator_task_nodes_thread_id
+         ON orchestrator_task_nodes(thread_id, sequence ASC, created_at ASC)`);
+        await executeRawSql(this.runtime, `CREATE INDEX IF NOT EXISTS idx_orchestrator_task_nodes_status
+         ON orchestrator_task_nodes(thread_id, status)`);
+        await executeRawSql(this.runtime, `CREATE INDEX IF NOT EXISTS idx_orchestrator_task_dependencies_thread_id
+         ON orchestrator_task_dependencies(thread_id)`);
+        await executeRawSql(this.runtime, `CREATE INDEX IF NOT EXISTS idx_orchestrator_task_dependencies_to_node_id
+         ON orchestrator_task_dependencies(to_node_id)`);
+        await executeRawSql(this.runtime, `CREATE INDEX IF NOT EXISTS idx_orchestrator_task_claims_thread_id
+         ON orchestrator_task_claims(thread_id, status, claimed_at DESC)`);
+        await executeRawSql(this.runtime, `CREATE INDEX IF NOT EXISTS idx_orchestrator_task_claims_node_id
+         ON orchestrator_task_claims(node_id, status)`);
+        await executeRawSql(this.runtime, `CREATE INDEX IF NOT EXISTS idx_orchestrator_task_mailbox_thread_id
+         ON orchestrator_task_mailbox(thread_id, created_at ASC)`);
+        await executeRawSql(this.runtime, `CREATE INDEX IF NOT EXISTS idx_orchestrator_task_verifier_jobs_thread_id
+         ON orchestrator_task_verifier_jobs(thread_id, status, created_at ASC)`);
+        await executeRawSql(this.runtime, `CREATE INDEX IF NOT EXISTS idx_orchestrator_task_evidence_thread_id
+         ON orchestrator_task_evidence(thread_id, created_at ASC)`);
+        await executeRawSql(this.runtime, `CREATE INDEX IF NOT EXISTS idx_orchestrator_task_threads_search_text
+         ON orchestrator_task_threads(search_text)`);
+        schemaReady.add(key);
+    }
+    async recoverInterruptedTasks() {
+        await this.ensureSchema();
+        const impactedSessions = await executeRawSql(this.runtime, `SELECT session_id, thread_id
+         FROM orchestrator_task_sessions
+        WHERE status IN ('active', 'blocked', 'tool_running')`);
+        if (impactedSessions.length === 0)
+            return;
+        const nowIso = isoNow();
+        const now = Date.now();
+        await executeRawSql(this.runtime, `UPDATE orchestrator_task_sessions
+          SET status = 'interrupted',
+              updated_at = ${sqlQuote(nowIso)},
+              stopped_at = COALESCE(stopped_at, ${sqlInteger(now)})
+        WHERE status IN ('active', 'blocked', 'tool_running')`);
+        const affectedThreadIds = new Set();
+        for (const row of impactedSessions) {
+            const sessionId = toText(row.session_id);
+            const threadId = toText(row.thread_id);
+            if (!threadId)
+                continue;
+            affectedThreadIds.add(threadId);
+            await this.appendEvent({
+                threadId,
+                sessionId,
+                eventType: "session_interrupted",
+                timestamp: now,
+                summary: "Session interrupted by runtime restart or shutdown",
+                data: { reason: "runtime_restart" },
+            });
+        }
+        for (const threadId of affectedThreadIds) {
+            await this.recomputeThreadStatus(threadId);
+        }
+    }
+    async createThread(input) {
+        await this.ensureSchema();
+        const id = input.id?.trim() || `task-${crypto.randomUUID()}`;
+        const createdAt = isoNow();
+        const acceptanceCriteria = input.acceptanceCriteria ?? [];
+        const currentPlan = input.currentPlan ?? {};
+        const summary = input.summary?.trim() ?? "";
+        const scenarioId = input.scenarioId ??
+            (typeof input.metadata?.scenarioId === "string"
+                ? input.metadata.scenarioId
+                : typeof input.metadata?.scenario_id === "string"
+                    ? input.metadata.scenario_id
+                    : null);
+        const batchId = input.batchId ??
+            (typeof input.metadata?.batchId === "string"
+                ? input.metadata.batchId
+                : typeof input.metadata?.batch_id === "string"
+                    ? input.metadata.batch_id
+                    : null);
+        const searchText = buildSearchText([
+            input.title,
+            input.originalRequest,
+            summary,
+            scenarioId,
+            batchId,
+            input.metadata ? JSON.stringify(input.metadata) : "",
+        ]);
+        await executeRawSql(this.runtime, `INSERT INTO orchestrator_task_threads (
+        id, agent_id, room_id, world_id, owner_user_id, scenario_id, batch_id, title, kind, status,
+        original_request, summary, acceptance_criteria_json, current_plan_json,
+        search_text, created_at, updated_at, closed_at, archived_at,
+        last_user_turn_at, last_coordinator_turn_at, metadata_json
+      ) VALUES (
+        ${sqlQuote(id)},
+        ${sqlQuote(this.runtime.agentId)},
+        ${sqlText(input.roomId ?? null)},
+        ${sqlText(input.worldId ?? null)},
+        ${sqlText(input.ownerUserId ?? null)},
+        ${sqlText(scenarioId ?? null)},
+        ${sqlText(batchId ?? null)},
+        ${sqlQuote(input.title.trim())},
+        ${sqlQuote(input.kind ?? "coding")},
+        'open',
+        ${sqlQuote(input.originalRequest)},
+        ${sqlQuote(summary)},
+        ${sqlJson(acceptanceCriteria)},
+        ${sqlJson(currentPlan)},
+        ${sqlQuote(searchText)},
+        ${sqlQuote(createdAt)},
+        ${sqlQuote(createdAt)},
+        NULL,
+        NULL,
+        ${sqlText(input.lastUserTurnAt ?? createdAt)},
+        NULL,
+        ${sqlJson(input.metadata ?? {})}
+      )`);
+        await this.appendEvent({
+            threadId: id,
+            eventType: "task_created",
+            timestamp: Date.now(),
+            summary: `Created task thread "${input.title.trim()}"`,
+            data: {
+                kind: input.kind ?? "coding",
+                roomId: input.roomId ?? null,
+                worldId: input.worldId ?? null,
+            },
+        });
+        const created = await this.getThreadRecord(id);
+        if (!created) {
+            throw new Error(`Failed to create task thread ${id}`);
+        }
+        return created;
+    }
+    async getThreadRecord(threadId) {
+        await this.ensureSchema();
+        const rows = await executeRawSql(this.runtime, `SELECT *
+         FROM orchestrator_task_threads
+        WHERE id = ${sqlQuote(threadId)}
+        LIMIT 1`);
+        return rows[0] ? parseThreadRow(rows[0]) : null;
+    }
+    async getThread(threadId) {
+        await this.ensureSchema();
+        const summary = await this.getThreadSummary(threadId);
+        if (!summary)
+            return null;
+        const [sessions, decisions, events, artifacts, transcripts, pendingDecisions, nodes, dependencies, claims, mailbox, verifierJobs, evidence,] = await Promise.all([
+            this.listSessionsForThread(threadId),
+            this.listDecisionsForThread(threadId),
+            this.listEventsForThread(threadId),
+            this.listArtifactsForThread(threadId),
+            this.listTranscriptsForThread(threadId),
+            this.listPendingDecisionsForThread(threadId),
+            this.listTaskNodesForThread(threadId),
+            this.listTaskDependenciesForThread(threadId),
+            this.listTaskClaimsForThread(threadId),
+            this.listTaskMailboxMessagesForThread(threadId),
+            this.listTaskVerifierJobsForThread(threadId),
+            this.listTaskEvidenceForThread(threadId),
+        ]);
+        return {
+            ...summary,
+            sessions,
+            decisions,
+            events,
+            artifacts,
+            transcripts,
+            pendingDecisions,
+            nodes,
+            dependencies,
+            claims,
+            mailbox,
+            verifierJobs,
+            evidence,
+        };
+    }
+    async listThreads(options = {}) {
+        await this.ensureSchema();
+        const clauses = buildThreadListWhereClauses(options);
+        const whereClause = clauses.length > 0 ? `WHERE ${clauses.join(" AND ")}` : "";
+        const limitClause = typeof options.limit === "number" && options.limit > 0
+            ? `LIMIT ${Math.trunc(options.limit)}`
+            : "";
+        const rows = await executeRawSql(this.runtime, `SELECT
+          thread.*,
+          COALESCE(session_counts.session_count, 0) AS session_count,
+          COALESCE(session_counts.active_session_count, 0) AS active_session_count,
+          latest.session_id AS latest_session_id,
+          latest.label AS latest_session_label,
+          latest.workdir AS latest_workdir,
+          latest.repo AS latest_repo,
+          latest.last_activity_at AS latest_activity_at,
+          COALESCE(decision_counts.decision_count, 0) AS decision_count,
+          COALESCE(node_counts.node_count, 0) AS node_count,
+          COALESCE(node_counts.ready_node_count, 0) AS ready_node_count,
+          COALESCE(node_counts.completed_node_count, 0) AS completed_node_count,
+          COALESCE(verifier_counts.verifier_job_count, 0) AS verifier_job_count,
+          COALESCE(evidence_counts.evidence_count, 0) AS evidence_count
+        FROM orchestrator_task_threads AS thread
+        LEFT JOIN (
+          SELECT
+            thread_id,
+            COUNT(*) AS session_count,
+            SUM(CASE WHEN status IN ('active', 'blocked', 'tool_running') THEN 1 ELSE 0 END) AS active_session_count
+          FROM orchestrator_task_sessions
+          GROUP BY thread_id
+        ) AS session_counts
+          ON session_counts.thread_id = thread.id
+        LEFT JOIN (
+          SELECT latest_session.thread_id,
+                 latest_session.session_id,
+                 latest_session.label,
+                 latest_session.workdir,
+                 latest_session.repo,
+                 latest_session.last_activity_at
+            FROM orchestrator_task_sessions AS latest_session
+            INNER JOIN (
+              SELECT thread_id, MAX(last_activity_at) AS max_last_activity_at
+                FROM orchestrator_task_sessions
+               GROUP BY thread_id
+            ) AS grouped
+              ON grouped.thread_id = latest_session.thread_id
+             AND grouped.max_last_activity_at = latest_session.last_activity_at
+        ) AS latest
+          ON latest.thread_id = thread.id
+        LEFT JOIN (
+          SELECT thread_id, COUNT(*) AS decision_count
+            FROM orchestrator_task_decisions
+           GROUP BY thread_id
+        ) AS decision_counts
+          ON decision_counts.thread_id = thread.id
+        LEFT JOIN (
+          SELECT
+            thread_id,
+            COUNT(*) AS node_count,
+            SUM(CASE WHEN status = 'ready' THEN 1 ELSE 0 END) AS ready_node_count,
+            SUM(CASE WHEN status = 'completed' THEN 1 ELSE 0 END) AS completed_node_count
+          FROM orchestrator_task_nodes
+          GROUP BY thread_id
+        ) AS node_counts
+          ON node_counts.thread_id = thread.id
+        LEFT JOIN (
+          SELECT thread_id, COUNT(*) AS verifier_job_count
+            FROM orchestrator_task_verifier_jobs
+           GROUP BY thread_id
+        ) AS verifier_counts
+          ON verifier_counts.thread_id = thread.id
+        LEFT JOIN (
+          SELECT thread_id, COUNT(*) AS evidence_count
+            FROM orchestrator_task_evidence
+           GROUP BY thread_id
+        ) AS evidence_counts
+          ON evidence_counts.thread_id = thread.id
+        ${whereClause}
+        ORDER BY thread.updated_at DESC
+        ${limitClause}`);
+        return rows.map(parseThreadSummaryRow);
+    }
+    async countThreads(options = {}) {
+        await this.ensureSchema();
+        const clauses = buildThreadListWhereClauses(options);
+        const whereClause = clauses.length > 0 ? `WHERE ${clauses.join(" AND ")}` : "";
+        const rows = await executeRawSql(this.runtime, `SELECT COUNT(*) AS total
+         FROM orchestrator_task_threads AS thread
+         LEFT JOIN (
+           SELECT
+             thread_id,
+             COUNT(*) AS session_count,
+             SUM(CASE WHEN status IN ('active', 'blocked', 'tool_running') THEN 1 ELSE 0 END) AS active_session_count
+           FROM orchestrator_task_sessions
+           GROUP BY thread_id
+         ) AS session_counts
+           ON session_counts.thread_id = thread.id
+         LEFT JOIN (
+           SELECT latest_session.thread_id,
+                  latest_session.session_id,
+                  latest_session.label,
+                  latest_session.workdir,
+                  latest_session.repo,
+                  latest_session.last_activity_at
+             FROM orchestrator_task_sessions AS latest_session
+             INNER JOIN (
+               SELECT thread_id, MAX(last_activity_at) AS max_last_activity_at
+                 FROM orchestrator_task_sessions
+                GROUP BY thread_id
+             ) AS grouped
+               ON grouped.thread_id = latest_session.thread_id
+              AND grouped.max_last_activity_at = latest_session.last_activity_at
+         ) AS latest
+           ON latest.thread_id = thread.id
+         LEFT JOIN (
+           SELECT
+             thread_id,
+             COUNT(*) AS node_count,
+             SUM(CASE WHEN status = 'ready' THEN 1 ELSE 0 END) AS ready_node_count,
+             SUM(CASE WHEN status = 'completed' THEN 1 ELSE 0 END) AS completed_node_count
+           FROM orchestrator_task_nodes
+           GROUP BY thread_id
+         ) AS node_counts
+           ON node_counts.thread_id = thread.id
+         LEFT JOIN (
+           SELECT thread_id, COUNT(*) AS verifier_job_count
+             FROM orchestrator_task_verifier_jobs
+            GROUP BY thread_id
+         ) AS verifier_counts
+           ON verifier_counts.thread_id = thread.id
+         LEFT JOIN (
+           SELECT thread_id, COUNT(*) AS evidence_count
+             FROM orchestrator_task_evidence
+            GROUP BY thread_id
+         ) AS evidence_counts
+           ON evidence_counts.thread_id = thread.id
+         ${whereClause}`);
+        return toNumber(rows[0]?.total, 0);
+    }
+    async getThreadSummary(threadId) {
+        const rows = await this.listThreads({
+            threadId,
+            includeArchived: true,
+        });
+        return rows[0] ?? null;
+    }
+    async findThreadIdBySessionId(sessionId) {
+        await this.ensureSchema();
+        const rows = await executeRawSql(this.runtime, `SELECT thread_id
+         FROM orchestrator_task_sessions
+        WHERE session_id = ${sqlQuote(sessionId)}
+        LIMIT 1`);
+        return rows[0] ? toText(rows[0].thread_id) : null;
+    }
+    async getSession(sessionId) {
+        await this.ensureSchema();
+        const rows = await executeRawSql(this.runtime, `SELECT *
+         FROM orchestrator_task_sessions
+        WHERE session_id = ${sqlQuote(sessionId)}
+        LIMIT 1`);
+        return rows[0] ? parseSessionRow(rows[0]) : null;
+    }
+    async registerSession(input) {
+        await this.ensureSchema();
+        const nowIso = isoNow();
+        const registeredAt = input.registeredAt ?? Date.now();
+        const lastActivityAt = input.lastActivityAt ?? registeredAt;
+        const existingThread = await this.getThreadRecord(input.threadId);
+        if (!existingThread) {
+            throw new Error(`Task thread ${input.threadId} not found`);
+        }
+        await executeRawSql(this.runtime, `INSERT INTO orchestrator_task_sessions (
+        id, thread_id, agent_id, session_id, framework, provider_source, label,
+        original_task, workdir, repo, status, decision_count, auto_resolved_count,
+        registered_at, last_activity_at, idle_check_count, task_delivered,
+        completion_summary, last_seen_decision_index, last_input_sent_at, stopped_at,
+        created_at, updated_at, metadata_json
+      ) VALUES (
+        ${sqlQuote(input.sessionId)},
+        ${sqlQuote(input.threadId)},
+        ${sqlQuote(this.runtime.agentId)},
+        ${sqlQuote(input.sessionId)},
+        ${sqlQuote(input.framework)},
+        ${sqlText(input.providerSource ?? null)},
+        ${sqlQuote(input.label)},
+        ${sqlQuote(input.originalTask)},
+        ${sqlQuote(input.workdir)},
+        ${sqlText(input.repo ?? null)},
+        ${sqlQuote(input.status ?? "active")},
+        ${sqlInteger(input.decisionCount ?? 0)},
+        ${sqlInteger(input.autoResolvedCount ?? 0)},
+        ${sqlInteger(registeredAt)},
+        ${sqlInteger(lastActivityAt)},
+        ${sqlInteger(input.idleCheckCount ?? 0)},
+        ${sqlBoolean(input.taskDelivered ?? false)},
+        ${sqlText(input.completionSummary ?? null)},
+        ${sqlInteger(input.lastSeenDecisionIndex ?? 0)},
+        ${sqlInteger(input.lastInputSentAt ?? null)},
+        ${sqlInteger(input.stoppedAt ?? null)},
+        ${sqlQuote(nowIso)},
+        ${sqlQuote(nowIso)},
+        ${sqlJson(input.metadata ?? {})}
+      )
+      ON CONFLICT(id) DO UPDATE SET
+        thread_id = EXCLUDED.thread_id,
+        framework = EXCLUDED.framework,
+        provider_source = EXCLUDED.provider_source,
+        label = EXCLUDED.label,
+        original_task = EXCLUDED.original_task,
+        workdir = EXCLUDED.workdir,
+        repo = EXCLUDED.repo,
+        status = EXCLUDED.status,
+        decision_count = EXCLUDED.decision_count,
+        auto_resolved_count = EXCLUDED.auto_resolved_count,
+        registered_at = EXCLUDED.registered_at,
+        last_activity_at = EXCLUDED.last_activity_at,
+        idle_check_count = EXCLUDED.idle_check_count,
+        task_delivered = EXCLUDED.task_delivered,
+        completion_summary = EXCLUDED.completion_summary,
+        last_seen_decision_index = EXCLUDED.last_seen_decision_index,
+        last_input_sent_at = EXCLUDED.last_input_sent_at,
+        stopped_at = EXCLUDED.stopped_at,
+        updated_at = EXCLUDED.updated_at,
+        metadata_json = EXCLUDED.metadata_json`);
+        await this.appendEvent({
+            threadId: input.threadId,
+            sessionId: input.sessionId,
+            eventType: "session_registered",
+            timestamp: registeredAt,
+            summary: `Registered session "${input.label}"`,
+            data: {
+                framework: input.framework,
+                repo: input.repo ?? null,
+                workdir: input.workdir,
+            },
+        });
+        await this.recomputeThreadStatus(input.threadId);
+    }
+    async updateSession(sessionId, patch) {
+        await this.ensureSchema();
+        const threadId = await this.findThreadIdBySessionId(sessionId);
+        if (!threadId)
+            return;
+        const existingRows = await executeRawSql(this.runtime, `SELECT *
+         FROM orchestrator_task_sessions
+        WHERE session_id = ${sqlQuote(sessionId)}
+        LIMIT 1`);
+        if (!existingRows[0])
+            return;
+        const existing = parseSessionRow(existingRows[0]);
+        const nextMeta = patch.metadata
+            ? { ...existing.metadata, ...patch.metadata }
+            : existing.metadata;
+        const nowIso = isoNow();
+        await executeRawSql(this.runtime, `UPDATE orchestrator_task_sessions
+          SET status = ${sqlQuote(patch.status ?? existing.status)},
+              decision_count = ${sqlInteger(patch.decisionCount ?? existing.decisionCount)},
+              auto_resolved_count = ${sqlInteger(patch.autoResolvedCount ?? existing.autoResolvedCount)},
+              last_activity_at = ${sqlInteger(patch.lastActivityAt ?? existing.lastActivityAt)},
+              idle_check_count = ${sqlInteger(patch.idleCheckCount ?? existing.idleCheckCount)},
+              task_delivered = ${sqlBoolean(patch.taskDelivered ?? existing.taskDelivered)},
+              completion_summary = ${sqlText(patch.completionSummary ?? existing.completionSummary)},
+              last_seen_decision_index = ${sqlInteger(patch.lastSeenDecisionIndex ?? existing.lastSeenDecisionIndex)},
+              last_input_sent_at = ${sqlInteger(patch.lastInputSentAt ?? existing.lastInputSentAt)},
+              stopped_at = ${sqlInteger(patch.stoppedAt ?? existing.stoppedAt)},
+              updated_at = ${sqlQuote(nowIso)},
+              metadata_json = ${sqlJson(nextMeta)}
+        WHERE session_id = ${sqlQuote(sessionId)}`);
+        await this.appendEvent({
+            threadId,
+            sessionId,
+            eventType: "session_updated",
+            timestamp: patch.lastActivityAt ?? Date.now(),
+            summary: `Updated session "${existing.label}"`,
+            data: {
+                status: patch.status ?? existing.status,
+                decisionCount: patch.decisionCount ?? existing.decisionCount,
+                autoResolvedCount: patch.autoResolvedCount ?? existing.autoResolvedCount,
+            },
+        });
+        await this.recomputeThreadStatus(threadId);
+    }
+    async recordDecision(input) {
+        await this.ensureSchema();
+        const createdAt = isoNow();
+        await executeRawSql(this.runtime, `INSERT INTO orchestrator_task_decisions (
+        id, thread_id, session_id, timestamp, event_type, prompt_text, decision,
+        response, reasoning, metadata_json, created_at
+      ) VALUES (
+        ${sqlQuote(`decision-${crypto.randomUUID()}`)},
+        ${sqlQuote(input.threadId)},
+        ${sqlQuote(input.sessionId)},
+        ${sqlInteger(input.timestamp)},
+        ${sqlQuote(input.event)},
+        ${sqlQuote(input.promptText)},
+        ${sqlQuote(input.decision)},
+        ${sqlText(input.response ?? null)},
+        ${sqlQuote(input.reasoning)},
+        ${sqlJson(input.metadata ?? {})},
+        ${sqlQuote(createdAt)}
+      )`);
+        await this.appendEvent({
+            threadId: input.threadId,
+            sessionId: input.sessionId,
+            eventType: "decision_recorded",
+            timestamp: input.timestamp,
+            summary: `${input.decision} decision recorded`,
+            data: {
+                event: input.event,
+                promptText: input.promptText,
+                response: input.response ?? null,
+            },
+        });
+    }
+    async appendEvent(input) {
+        await this.ensureSchema();
+        const createdAt = isoNow();
+        const timestamp = input.timestamp ?? Date.now();
+        await executeRawSql(this.runtime, `INSERT INTO orchestrator_task_events (
+        id, thread_id, session_id, event_type, timestamp, summary, data_json, created_at
+      ) VALUES (
+        ${sqlQuote(`event-${crypto.randomUUID()}`)},
+        ${sqlQuote(input.threadId)},
+        ${sqlText(input.sessionId ?? null)},
+        ${sqlQuote(input.eventType)},
+        ${sqlInteger(timestamp)},
+        ${sqlQuote(input.summary ?? "")},
+        ${sqlJson(input.data ?? {})},
+        ${sqlQuote(createdAt)}
+      )`);
+        await executeRawSql(this.runtime, `UPDATE orchestrator_task_threads
+          SET updated_at = ${sqlQuote(createdAt)}
+        WHERE id = ${sqlQuote(input.threadId)}`);
+    }
+    async recordArtifact(input) {
+        await this.ensureSchema();
+        const createdAt = isoNow();
+        await executeRawSql(this.runtime, `INSERT INTO orchestrator_task_artifacts (
+        id, thread_id, session_id, artifact_type, title, path, uri, mime_type, metadata_json, created_at
+      ) VALUES (
+        ${sqlQuote(`artifact-${crypto.randomUUID()}`)},
+        ${sqlQuote(input.threadId)},
+        ${sqlText(input.sessionId ?? null)},
+        ${sqlQuote(input.artifactType)},
+        ${sqlQuote(input.title)},
+        ${sqlText(input.path ?? null)},
+        ${sqlText(input.uri ?? null)},
+        ${sqlText(input.mimeType ?? null)},
+        ${sqlJson(input.metadata ?? {})},
+        ${sqlQuote(createdAt)}
+      )`);
+        await this.appendEvent({
+            threadId: input.threadId,
+            sessionId: input.sessionId ?? null,
+            eventType: "artifact_recorded",
+            summary: `Recorded ${input.artifactType} artifact`,
+            data: {
+                artifactType: input.artifactType,
+                title: input.title,
+                path: input.path ?? null,
+                uri: input.uri ?? null,
+            },
+        });
+    }
+    async recordTranscript(input) {
+        await this.ensureSchema();
+        const createdAt = isoNow();
+        const timestamp = input.timestamp ?? Date.now();
+        await executeRawSql(this.runtime, `INSERT INTO orchestrator_task_transcripts (
+        id, thread_id, session_id, timestamp, direction, content, metadata_json, created_at
+      ) VALUES (
+        ${sqlQuote(`transcript-${crypto.randomUUID()}`)},
+        ${sqlQuote(input.threadId)},
+        ${sqlQuote(input.sessionId)},
+        ${sqlInteger(timestamp)},
+        ${sqlQuote(input.direction)},
+        ${sqlQuote(input.content)},
+        ${sqlJson(input.metadata ?? {})},
+        ${sqlQuote(createdAt)}
+      )`);
+        await executeRawSql(this.runtime, `UPDATE orchestrator_task_threads
+          SET updated_at = ${sqlQuote(createdAt)}
+        WHERE id = ${sqlQuote(input.threadId)}`);
+    }
+    async updateThreadSummary(threadId, summary) {
+        await this.ensureSchema();
+        const thread = await this.getThreadRecord(threadId);
+        if (!thread)
+            return;
+        const nextSearchText = buildSearchText([
+            thread.title,
+            thread.originalRequest,
+            summary,
+            thread.searchText,
+        ]);
+        const nowIso = isoNow();
+        await executeRawSql(this.runtime, `UPDATE orchestrator_task_threads
+          SET summary = ${sqlQuote(summary)},
+              search_text = ${sqlQuote(nextSearchText)},
+              updated_at = ${sqlQuote(nowIso)}
+        WHERE id = ${sqlQuote(threadId)}`);
+        await this.appendEvent({
+            threadId,
+            eventType: "summary_updated",
+            summary: "Updated task summary",
+            data: { summary },
+        });
+    }
+    async updateThread(threadId, patch) {
+        await this.ensureSchema();
+        const existing = await this.getThreadRecord(threadId);
+        if (!existing)
+            return;
+        const nextMetadata = patch.metadata
+            ? { ...existing.metadata, ...patch.metadata }
+            : existing.metadata;
+        const nextSummary = patch.summary ?? existing.summary;
+        const nextSearchText = buildSearchText([
+            existing.title,
+            existing.originalRequest,
+            nextSummary,
+            patch.status ?? existing.status,
+            existing.scenarioId,
+            existing.batchId,
+            JSON.stringify(nextMetadata),
+        ]);
+        const nowIso = isoNow();
+        await executeRawSql(this.runtime, `UPDATE orchestrator_task_threads
+          SET status = ${sqlQuote(patch.status ?? existing.status)},
+              summary = ${sqlQuote(nextSummary)},
+              current_plan_json = ${sqlJson(patch.currentPlan ?? existing.currentPlan)},
+              search_text = ${sqlQuote(nextSearchText)},
+              closed_at = ${sqlText(patch.closedAt !== undefined
+            ? patch.closedAt
+            : existing.closedAt)},
+              archived_at = ${sqlText(patch.archivedAt !== undefined
+            ? patch.archivedAt
+            : existing.archivedAt)},
+              last_user_turn_at = ${sqlText(patch.lastUserTurnAt !== undefined
+            ? patch.lastUserTurnAt
+            : existing.lastUserTurnAt)},
+              last_coordinator_turn_at = ${sqlText(patch.lastCoordinatorTurnAt !== undefined
+            ? patch.lastCoordinatorTurnAt
+            : existing.lastCoordinatorTurnAt)},
+              updated_at = ${sqlQuote(nowIso)},
+              metadata_json = ${sqlJson(nextMetadata)}
+        WHERE id = ${sqlQuote(threadId)}`);
+    }
+    async archiveThread(threadId) {
+        await this.ensureSchema();
+        const nowIso = isoNow();
+        await executeRawSql(this.runtime, `UPDATE orchestrator_task_threads
+          SET status = 'archived',
+              archived_at = ${sqlQuote(nowIso)},
+              closed_at = COALESCE(closed_at, ${sqlQuote(nowIso)}),
+              updated_at = ${sqlQuote(nowIso)}
+        WHERE id = ${sqlQuote(threadId)}`);
+        await this.appendEvent({
+            threadId,
+            eventType: "task_archived",
+            summary: "Archived task thread",
+            data: {},
+        });
+    }
+    async reopenThread(threadId) {
+        await this.ensureSchema();
+        const nowIso = isoNow();
+        await executeRawSql(this.runtime, `UPDATE orchestrator_task_threads
+          SET status = 'open',
+              archived_at = NULL,
+              closed_at = NULL,
+              updated_at = ${sqlQuote(nowIso)}
+        WHERE id = ${sqlQuote(threadId)}`);
+        await this.appendEvent({
+            threadId,
+            eventType: "task_reopened",
+            summary: "Reopened task thread",
+            data: {},
+        });
+        await this.recomputeThreadStatus(threadId);
+    }
+    async upsertPendingDecision(input) {
+        await this.ensureSchema();
+        const createdAt = input.createdAt ?? Date.now();
+        const nowIso = isoNow();
+        await executeRawSql(this.runtime, `INSERT INTO orchestrator_task_pending_decisions (
+        session_id,
+        thread_id,
+        prompt_text,
+        recent_output,
+        llm_decision_json,
+        task_context_json,
+        created_at,
+        updated_at
+      ) VALUES (
+        ${sqlQuote(input.sessionId)},
+        ${sqlQuote(input.threadId)},
+        ${sqlQuote(input.promptText)},
+        ${sqlQuote(input.recentOutput)},
+        ${sqlJson(input.llmDecision)},
+        ${sqlJson(input.taskContext)},
+        ${sqlInteger(createdAt)},
+        ${sqlQuote(nowIso)}
+      )
+      ON CONFLICT(session_id) DO UPDATE SET
+        thread_id = EXCLUDED.thread_id,
+        prompt_text = EXCLUDED.prompt_text,
+        recent_output = EXCLUDED.recent_output,
+        llm_decision_json = EXCLUDED.llm_decision_json,
+        task_context_json = EXCLUDED.task_context_json,
+        created_at = EXCLUDED.created_at,
+        updated_at = EXCLUDED.updated_at`);
+        await executeRawSql(this.runtime, `UPDATE orchestrator_task_threads
+          SET updated_at = ${sqlQuote(nowIso)}
+        WHERE id = ${sqlQuote(input.threadId)}`);
+    }
+    async deletePendingDecision(sessionId) {
+        await this.ensureSchema();
+        const rows = await executeRawSql(this.runtime, `SELECT thread_id
+         FROM orchestrator_task_pending_decisions
+        WHERE session_id = ${sqlQuote(sessionId)}
+        LIMIT 1`);
+        if (rows.length === 0)
+            return;
+        const threadId = toText(rows[0]?.thread_id);
+        await executeRawSql(this.runtime, `DELETE FROM orchestrator_task_pending_decisions
+        WHERE session_id = ${sqlQuote(sessionId)}`);
+        if (threadId) {
+            await executeRawSql(this.runtime, `UPDATE orchestrator_task_threads
+            SET updated_at = ${sqlQuote(isoNow())}
+          WHERE id = ${sqlQuote(threadId)}`);
+        }
+    }
+    async listPendingDecisions() {
+        await this.ensureSchema();
+        const rows = await executeRawSql(this.runtime, `SELECT *
+         FROM orchestrator_task_pending_decisions
+        ORDER BY created_at ASC`);
+        return rows.map(parsePendingDecisionRow);
+    }
+    async listPendingDecisionsForThread(threadId) {
+        await this.ensureSchema();
+        const rows = await executeRawSql(this.runtime, `SELECT *
+         FROM orchestrator_task_pending_decisions
+        WHERE thread_id = ${sqlQuote(threadId)}
+        ORDER BY created_at ASC`);
+        return rows.map(parsePendingDecisionRow);
+    }
+    async createTaskNode(input) {
+        await this.ensureSchema();
+        const nowIso = isoNow();
+        const id = input.id?.trim() || `node-${crypto.randomUUID()}`;
+        await executeRawSql(this.runtime, `INSERT INTO orchestrator_task_nodes (
+        id, thread_id, parent_node_id, kind, status, title, instructions,
+        acceptance_criteria_json, required_capabilities_json, expected_artifacts_json,
+        assigned_session_id, assigned_label, agent_type, workdir, repo, priority,
+        depth, sequence, created_from, metadata_json, created_at, updated_at,
+        started_at, completed_at
+      ) VALUES (
+        ${sqlQuote(id)},
+        ${sqlQuote(input.threadId)},
+        ${sqlText(input.parentNodeId ?? null)},
+        ${sqlQuote(input.kind ?? "execution")},
+        ${sqlQuote(input.status ?? "planned")},
+        ${sqlQuote(input.title)},
+        ${sqlQuote(input.instructions ?? "")},
+        ${sqlJson(input.acceptanceCriteria ?? [])},
+        ${sqlJson(input.requiredCapabilities ?? [])},
+        ${sqlJson(input.expectedArtifacts ?? [])},
+        ${sqlText(input.assignedSessionId ?? null)},
+        ${sqlText(input.assignedLabel ?? null)},
+        ${sqlText(input.agentType ?? null)},
+        ${sqlText(input.workdir ?? null)},
+        ${sqlText(input.repo ?? null)},
+        ${sqlInteger(input.priority ?? 0)},
+        ${sqlInteger(input.depth ?? 0)},
+        ${sqlInteger(input.sequence ?? 0)},
+        ${sqlText(input.createdFrom ?? null)},
+        ${sqlJson(input.metadata ?? {})},
+        ${sqlQuote(nowIso)},
+        ${sqlQuote(nowIso)},
+        ${sqlText(input.startedAt ?? null)},
+        ${sqlText(input.completedAt ?? null)}
+      )`);
+        await this.appendEvent({
+            threadId: input.threadId,
+            sessionId: input.assignedSessionId ?? null,
+            eventType: "task_node_created",
+            summary: `Created task node "${input.title}"`,
+            data: {
+                nodeId: id,
+                kind: input.kind ?? "execution",
+                status: input.status ?? "planned",
+                parentNodeId: input.parentNodeId ?? null,
+            },
+        });
+        const node = await this.getTaskNode(id);
+        if (!node) {
+            throw new Error(`Failed to create task node ${id}`);
+        }
+        await this.recomputeTaskGraphState(input.threadId);
+        return node;
+    }
+    async getTaskNode(nodeId) {
+        await this.ensureSchema();
+        const rows = await executeRawSql(this.runtime, `SELECT *
+         FROM orchestrator_task_nodes
+        WHERE id = ${sqlQuote(nodeId)}
+        LIMIT 1`);
+        return rows[0] ? parseTaskNodeRow(rows[0]) : null;
+    }
+    async updateTaskNode(nodeId, patch) {
+        await this.ensureSchema();
+        const existing = await this.getTaskNode(nodeId);
+        if (!existing)
+            return;
+        const nextMetadata = patch.metadata
+            ? { ...existing.metadata, ...patch.metadata }
+            : existing.metadata;
+        const nextStatus = patch.status ?? existing.status;
+        const nextStartedAt = patch.startedAt !== undefined
+            ? patch.startedAt
+            : nextStatus === "running" || nextStatus === "verifying"
+                ? (existing.startedAt ?? isoNow())
+                : existing.startedAt;
+        const nextCompletedAt = patch.completedAt !== undefined
+            ? patch.completedAt
+            : ["completed", "failed", "canceled", "interrupted"].includes(nextStatus)
+                ? (existing.completedAt ?? isoNow())
+                : null;
+        const nowIso = isoNow();
+        await executeRawSql(this.runtime, `UPDATE orchestrator_task_nodes
+          SET parent_node_id = ${sqlText(patch.parentNodeId !== undefined
+            ? patch.parentNodeId
+            : existing.parentNodeId)},
+              kind = ${sqlQuote(patch.kind ?? existing.kind)},
+              status = ${sqlQuote(nextStatus)},
+              title = ${sqlQuote(patch.title ?? existing.title)},
+              instructions = ${sqlQuote(patch.instructions ?? existing.instructions)},
+              acceptance_criteria_json = ${sqlJson(patch.acceptanceCriteria ?? existing.acceptanceCriteria)},
+              required_capabilities_json = ${sqlJson(patch.requiredCapabilities ?? existing.requiredCapabilities)},
+              expected_artifacts_json = ${sqlJson(patch.expectedArtifacts ?? existing.expectedArtifacts)},
+              assigned_session_id = ${sqlText(patch.assignedSessionId !== undefined
+            ? patch.assignedSessionId
+            : existing.assignedSessionId)},
+              assigned_label = ${sqlText(patch.assignedLabel !== undefined
+            ? patch.assignedLabel
+            : existing.assignedLabel)},
+              agent_type = ${sqlText(patch.agentType !== undefined
+            ? patch.agentType
+            : existing.agentType)},
+              workdir = ${sqlText(patch.workdir !== undefined ? patch.workdir : existing.workdir)},
+              repo = ${sqlText(patch.repo !== undefined ? patch.repo : existing.repo)},
+              priority = ${sqlInteger(patch.priority ?? existing.priority)},
+              depth = ${sqlInteger(patch.depth ?? existing.depth)},
+              sequence = ${sqlInteger(patch.sequence ?? existing.sequence)},
+              created_from = ${sqlText(patch.createdFrom !== undefined
+            ? patch.createdFrom
+            : existing.createdFrom)},
+              metadata_json = ${sqlJson(nextMetadata)},
+              updated_at = ${sqlQuote(nowIso)},
+              started_at = ${sqlText(nextStartedAt)},
+              completed_at = ${sqlText(nextCompletedAt)}
+        WHERE id = ${sqlQuote(nodeId)}`);
+        await this.appendEvent({
+            threadId: existing.threadId,
+            sessionId: patch.assignedSessionId !== undefined
+                ? patch.assignedSessionId
+                : existing.assignedSessionId,
+            eventType: "task_node_updated",
+            summary: `Updated task node "${patch.title ?? existing.title}"`,
+            data: {
+                nodeId,
+                status: nextStatus,
+            },
+        });
+        await this.recomputeTaskGraphState(existing.threadId);
+    }
+    async listTaskNodesForThread(threadId) {
+        await this.ensureSchema();
+        const rows = await executeRawSql(this.runtime, `SELECT *
+         FROM orchestrator_task_nodes
+        WHERE thread_id = ${sqlQuote(threadId)}
+        ORDER BY depth ASC, sequence ASC, created_at ASC`);
+        return rows.map(parseTaskNodeRow);
+    }
+    async listReadyTaskNodesForThread(threadId) {
+        await this.ensureSchema();
+        const rows = await executeRawSql(this.runtime, `SELECT *
+         FROM orchestrator_task_nodes
+        WHERE thread_id = ${sqlQuote(threadId)}
+          AND status = 'ready'
+        ORDER BY priority DESC, depth ASC, sequence ASC, created_at ASC`);
+        return rows.map(parseTaskNodeRow);
+    }
+    async createTaskDependency(input) {
+        await this.ensureSchema();
+        const createdAt = isoNow();
+        const id = input.id?.trim() || `dep-${crypto.randomUUID()}`;
+        await executeRawSql(this.runtime, `INSERT INTO orchestrator_task_dependencies (
+        id, thread_id, from_node_id, to_node_id, dependency_kind, required_status,
+        metadata_json, created_at
+      ) VALUES (
+        ${sqlQuote(id)},
+        ${sqlQuote(input.threadId)},
+        ${sqlQuote(input.fromNodeId)},
+        ${sqlQuote(input.toNodeId)},
+        ${sqlQuote(input.dependencyKind ?? "blocks")},
+        ${sqlQuote(input.requiredStatus ?? "completed")},
+        ${sqlJson(input.metadata ?? {})},
+        ${sqlQuote(createdAt)}
+      )`);
+        await this.appendEvent({
+            threadId: input.threadId,
+            eventType: "task_dependency_created",
+            summary: `Created dependency ${input.fromNodeId} -> ${input.toNodeId}`,
+            data: {
+                dependencyId: id,
+                fromNodeId: input.fromNodeId,
+                toNodeId: input.toNodeId,
+                dependencyKind: input.dependencyKind ?? "blocks",
+                requiredStatus: input.requiredStatus ?? "completed",
+            },
+        });
+        const dependency = await this.getTaskDependency(id);
+        if (!dependency) {
+            throw new Error(`Failed to create task dependency ${id}`);
+        }
+        await this.recomputeTaskGraphState(input.threadId);
+        return dependency;
+    }
+    async getTaskDependency(dependencyId) {
+        await this.ensureSchema();
+        const rows = await executeRawSql(this.runtime, `SELECT *
+         FROM orchestrator_task_dependencies
+        WHERE id = ${sqlQuote(dependencyId)}
+        LIMIT 1`);
+        return rows[0] ? parseTaskDependencyRow(rows[0]) : null;
+    }
+    async listTaskDependenciesForThread(threadId) {
+        await this.ensureSchema();
+        const rows = await executeRawSql(this.runtime, `SELECT *
+         FROM orchestrator_task_dependencies
+        WHERE thread_id = ${sqlQuote(threadId)}
+        ORDER BY created_at ASC`);
+        return rows.map(parseTaskDependencyRow);
+    }
+    async createTaskClaim(input) {
+        await this.ensureSchema();
+        const claimedAt = input.claimedAt ?? isoNow();
+        const id = input.id?.trim() || `claim-${crypto.randomUUID()}`;
+        await executeRawSql(this.runtime, `INSERT INTO orchestrator_task_claims (
+        id, thread_id, node_id, session_id, claim_type, status, claimed_at,
+        released_at, metadata_json
+      ) VALUES (
+        ${sqlQuote(id)},
+        ${sqlQuote(input.threadId)},
+        ${sqlQuote(input.nodeId)},
+        ${sqlQuote(input.sessionId)},
+        ${sqlQuote(input.claimType ?? "execution")},
+        ${sqlQuote(input.status ?? "active")},
+        ${sqlQuote(claimedAt)},
+        ${sqlText(input.releasedAt ?? null)},
+        ${sqlJson(input.metadata ?? {})}
+      )`);
+        await this.appendEvent({
+            threadId: input.threadId,
+            sessionId: input.sessionId,
+            eventType: "task_claim_created",
+            summary: `Claimed task node ${input.nodeId}`,
+            data: {
+                claimId: id,
+                nodeId: input.nodeId,
+                sessionId: input.sessionId,
+                claimType: input.claimType ?? "execution",
+                status: input.status ?? "active",
+            },
+        });
+        const claim = await this.getTaskClaim(id);
+        if (!claim) {
+            throw new Error(`Failed to create task claim ${id}`);
+        }
+        return claim;
+    }
+    async getTaskClaim(claimId) {
+        await this.ensureSchema();
+        const rows = await executeRawSql(this.runtime, `SELECT *
+         FROM orchestrator_task_claims
+        WHERE id = ${sqlQuote(claimId)}
+        LIMIT 1`);
+        return rows[0] ? parseTaskClaimRow(rows[0]) : null;
+    }
+    async findActiveTaskClaim(nodeId, sessionId) {
+        await this.ensureSchema();
+        const rows = await executeRawSql(this.runtime, `SELECT *
+         FROM orchestrator_task_claims
+        WHERE node_id = ${sqlQuote(nodeId)}
+          AND session_id = ${sqlQuote(sessionId)}
+          AND status = 'active'
+        ORDER BY claimed_at DESC
+        LIMIT 1`);
+        return rows[0] ? parseTaskClaimRow(rows[0]) : null;
+    }
+    async updateTaskClaim(claimId, patch) {
+        await this.ensureSchema();
+        const existing = await this.getTaskClaim(claimId);
+        if (!existing)
+            return;
+        const nextMetadata = patch.metadata
+            ? { ...existing.metadata, ...patch.metadata }
+            : existing.metadata;
+        await executeRawSql(this.runtime, `UPDATE orchestrator_task_claims
+          SET status = ${sqlQuote(patch.status ?? existing.status)},
+              released_at = ${sqlText(patch.releasedAt !== undefined
+            ? patch.releasedAt
+            : existing.releasedAt)},
+              metadata_json = ${sqlJson(nextMetadata)}
+        WHERE id = ${sqlQuote(claimId)}`);
+    }
+    async listTaskClaimsForThread(threadId) {
+        await this.ensureSchema();
+        const rows = await executeRawSql(this.runtime, `SELECT *
+         FROM orchestrator_task_claims
+        WHERE thread_id = ${sqlQuote(threadId)}
+        ORDER BY claimed_at ASC`);
+        return rows.map(parseTaskClaimRow);
+    }
+    async appendTaskMailboxMessage(input) {
+        await this.ensureSchema();
+        const id = input.id?.trim() || `mail-${crypto.randomUUID()}`;
+        const createdAt = input.createdAt ?? isoNow();
+        await executeRawSql(this.runtime, `INSERT INTO orchestrator_task_mailbox (
+        id, thread_id, node_id, session_id, sender, recipient, subject, body,
+        delivery_state, metadata_json, created_at, delivered_at
+      ) VALUES (
+        ${sqlQuote(id)},
+        ${sqlQuote(input.threadId)},
+        ${sqlText(input.nodeId ?? null)},
+        ${sqlText(input.sessionId ?? null)},
+        ${sqlQuote(input.sender)},
+        ${sqlQuote(input.recipient)},
+        ${sqlQuote(input.subject ?? "")},
+        ${sqlQuote(input.body)},
+        ${sqlQuote(input.deliveryState ?? "pending")},
+        ${sqlJson(input.metadata ?? {})},
+        ${sqlQuote(createdAt)},
+        ${sqlText(input.deliveredAt ?? null)}
+      )`);
+        await this.appendEvent({
+            threadId: input.threadId,
+            sessionId: input.sessionId ?? null,
+            eventType: "task_mailbox_message",
+            summary: `Mailbox message "${input.subject ?? ""}" queued for ${input.recipient}`,
+            data: {
+                messageId: id,
+                nodeId: input.nodeId ?? null,
+                sender: input.sender,
+                recipient: input.recipient,
+                deliveryState: input.deliveryState ?? "pending",
+            },
+        });
+        const message = await this.getTaskMailboxMessage(id);
+        if (!message) {
+            throw new Error(`Failed to create mailbox message ${id}`);
+        }
+        return message;
+    }
+    async getTaskMailboxMessage(messageId) {
+        await this.ensureSchema();
+        const rows = await executeRawSql(this.runtime, `SELECT *
+         FROM orchestrator_task_mailbox
+        WHERE id = ${sqlQuote(messageId)}
+        LIMIT 1`);
+        return rows[0] ? parseTaskMailboxMessageRow(rows[0]) : null;
+    }
+    async markTaskMailboxMessageDelivered(messageId) {
+        await this.ensureSchema();
+        await executeRawSql(this.runtime, `UPDATE orchestrator_task_mailbox
+          SET delivery_state = 'delivered',
+              delivered_at = ${sqlQuote(isoNow())}
+        WHERE id = ${sqlQuote(messageId)}`);
+    }
+    async listTaskMailboxMessagesForThread(threadId) {
+        await this.ensureSchema();
+        const rows = await executeRawSql(this.runtime, `SELECT *
+         FROM orchestrator_task_mailbox
+        WHERE thread_id = ${sqlQuote(threadId)}
+        ORDER BY created_at ASC`);
+        return rows.map(parseTaskMailboxMessageRow);
+    }
+    async createTaskVerifierJob(input) {
+        await this.ensureSchema();
+        const id = input.id?.trim() || `verify-${crypto.randomUUID()}`;
+        const createdAt = input.createdAt ?? isoNow();
+        await executeRawSql(this.runtime, `INSERT INTO orchestrator_task_verifier_jobs (
+        id, thread_id, node_id, status, verifier_type, title, instructions,
+        config_json, metadata_json, created_at, started_at, completed_at
+      ) VALUES (
+        ${sqlQuote(id)},
+        ${sqlQuote(input.threadId)},
+        ${sqlQuote(input.nodeId)},
+        ${sqlQuote(input.status ?? "pending")},
+        ${sqlQuote(input.verifierType)},
+        ${sqlQuote(input.title)},
+        ${sqlQuote(input.instructions ?? "")},
+        ${sqlJson(input.config ?? {})},
+        ${sqlJson(input.metadata ?? {})},
+        ${sqlQuote(createdAt)},
+        ${sqlText(input.startedAt ?? null)},
+        ${sqlText(input.completedAt ?? null)}
+      )`);
+        await this.appendEvent({
+            threadId: input.threadId,
+            eventType: "verifier_job_created",
+            summary: `Created verifier job "${input.title}"`,
+            data: {
+                verifierJobId: id,
+                nodeId: input.nodeId,
+                verifierType: input.verifierType,
+                status: input.status ?? "pending",
+            },
+        });
+        const job = await this.getTaskVerifierJob(id);
+        if (!job) {
+            throw new Error(`Failed to create verifier job ${id}`);
+        }
+        return job;
+    }
+    async getTaskVerifierJob(verifierJobId) {
+        await this.ensureSchema();
+        const rows = await executeRawSql(this.runtime, `SELECT *
+         FROM orchestrator_task_verifier_jobs
+        WHERE id = ${sqlQuote(verifierJobId)}
+        LIMIT 1`);
+        return rows[0] ? parseTaskVerifierJobRow(rows[0]) : null;
+    }
+    async updateTaskVerifierJob(verifierJobId, patch) {
+        await this.ensureSchema();
+        const existing = await this.getTaskVerifierJob(verifierJobId);
+        if (!existing)
+            return;
+        const nextMetadata = patch.metadata
+            ? { ...existing.metadata, ...patch.metadata }
+            : existing.metadata;
+        await executeRawSql(this.runtime, `UPDATE orchestrator_task_verifier_jobs
+          SET status = ${sqlQuote(patch.status ?? existing.status)},
+              title = ${sqlQuote(patch.title ?? existing.title)},
+              instructions = ${sqlQuote(patch.instructions ?? existing.instructions)},
+              config_json = ${sqlJson(patch.config ?? existing.config)},
+              metadata_json = ${sqlJson(nextMetadata)},
+              started_at = ${sqlText(patch.startedAt !== undefined
+            ? patch.startedAt
+            : existing.startedAt)},
+              completed_at = ${sqlText(patch.completedAt !== undefined
+            ? patch.completedAt
+            : existing.completedAt)}
+        WHERE id = ${sqlQuote(verifierJobId)}`);
+    }
+    async listTaskVerifierJobsForThread(threadId) {
+        await this.ensureSchema();
+        const rows = await executeRawSql(this.runtime, `SELECT *
+         FROM orchestrator_task_verifier_jobs
+        WHERE thread_id = ${sqlQuote(threadId)}
+        ORDER BY created_at ASC`);
+        return rows.map(parseTaskVerifierJobRow);
+    }
+    async recordTaskEvidence(input) {
+        await this.ensureSchema();
+        const id = input.id?.trim() || `evidence-${crypto.randomUUID()}`;
+        const createdAt = isoNow();
+        await executeRawSql(this.runtime, `INSERT INTO orchestrator_task_evidence (
+        id, thread_id, node_id, session_id, verifier_job_id, evidence_type, title,
+        summary, path, uri, content_json, metadata_json, created_at
+      ) VALUES (
+        ${sqlQuote(id)},
+        ${sqlQuote(input.threadId)},
+        ${sqlText(input.nodeId ?? null)},
+        ${sqlText(input.sessionId ?? null)},
+        ${sqlText(input.verifierJobId ?? null)},
+        ${sqlQuote(input.evidenceType)},
+        ${sqlQuote(input.title)},
+        ${sqlQuote(input.summary ?? "")},
+        ${sqlText(input.path ?? null)},
+        ${sqlText(input.uri ?? null)},
+        ${sqlJson(input.content ?? {})},
+        ${sqlJson(input.metadata ?? {})},
+        ${sqlQuote(createdAt)}
+      )`);
+        await this.appendEvent({
+            threadId: input.threadId,
+            sessionId: input.sessionId ?? null,
+            eventType: "task_evidence_recorded",
+            summary: `Recorded ${input.evidenceType} evidence`,
+            data: {
+                evidenceId: id,
+                nodeId: input.nodeId ?? null,
+                verifierJobId: input.verifierJobId ?? null,
+                title: input.title,
+            },
+        });
+        const evidence = await this.getTaskEvidence(id);
+        if (!evidence) {
+            throw new Error(`Failed to create task evidence ${id}`);
+        }
+        return evidence;
+    }
+    async getTaskEvidence(evidenceId) {
+        await this.ensureSchema();
+        const rows = await executeRawSql(this.runtime, `SELECT *
+         FROM orchestrator_task_evidence
+        WHERE id = ${sqlQuote(evidenceId)}
+        LIMIT 1`);
+        return rows[0] ? parseTaskEvidenceRow(rows[0]) : null;
+    }
+    async listTaskEvidenceForThread(threadId) {
+        await this.ensureSchema();
+        const rows = await executeRawSql(this.runtime, `SELECT *
+         FROM orchestrator_task_evidence
+        WHERE thread_id = ${sqlQuote(threadId)}
+        ORDER BY created_at ASC`);
+        return rows.map(parseTaskEvidenceRow);
+    }
+    deriveDependentNodeStatus(node, incomingDependencies, nodesById) {
+        if (isTerminalTaskNodeStatus(node.status)) {
+            return node.status;
+        }
+        if (node.status === "running" ||
+            node.status === "blocked" ||
+            node.status === "waiting_on_user" ||
+            node.status === "verifying" ||
+            node.status === "claimed") {
+            return node.status;
+        }
+        const prerequisiteStatuses = incomingDependencies
+            .map((dependency) => nodesById.get(dependency.fromNodeId))
+            .filter((entry) => Boolean(entry))
+            .map((entry) => entry.status);
+        const allSatisfied = incomingDependencies.length === 0 ||
+            incomingDependencies.every((dependency) => {
+                const source = nodesById.get(dependency.fromNodeId);
+                return (source !== undefined &&
+                    dependencyStatusSatisfied(source.status, dependency.requiredStatus));
+            });
+        const hasFailedPrerequisite = prerequisiteStatuses.some((status) => status === "failed" ||
+            status === "canceled" ||
+            status === "interrupted");
+        if (node.kind === "goal" && incomingDependencies.length > 0) {
+            if (allSatisfied) {
+                return "completed";
+            }
+            return hasFailedPrerequisite ? "failed" : "planned";
+        }
+        if (node.assignedSessionId) {
+            return node.status;
+        }
+        if (allSatisfied) {
+            return "ready";
+        }
+        return hasFailedPrerequisite ? "blocked" : "planned";
+    }
+    async recomputeTaskGraphState(threadId) {
+        const [nodes, dependencies] = await Promise.all([
+            this.listTaskNodesForThread(threadId),
+            this.listTaskDependenciesForThread(threadId),
+        ]);
+        if (nodes.length === 0) {
+            return;
+        }
+        const nodesById = new Map(nodes.map((node) => [node.id, node]));
+        const incomingDependencies = new Map();
+        for (const dependency of dependencies) {
+            const bucket = incomingDependencies.get(dependency.toNodeId) ?? [];
+            bucket.push(dependency);
+            incomingDependencies.set(dependency.toNodeId, bucket);
+        }
+        const nowIso = isoNow();
+        for (const node of nodes) {
+            const nextStatus = this.deriveDependentNodeStatus(node, incomingDependencies.get(node.id) ?? [], nodesById);
+            if (nextStatus === node.status) {
+                continue;
+            }
+            const nextCompletedAt = nextStatus === "completed" || nextStatus === "failed"
+                ? (node.completedAt ?? nowIso)
+                : null;
+            await executeRawSql(this.runtime, `UPDATE orchestrator_task_nodes
+            SET status = ${sqlQuote(nextStatus)},
+                updated_at = ${sqlQuote(nowIso)},
+                completed_at = ${sqlText(nextCompletedAt)}
+          WHERE id = ${sqlQuote(node.id)}`);
+        }
+    }
+    async getLastUsedRepo() {
+        await this.ensureSchema();
+        const rows = await executeRawSql(this.runtime, `SELECT repo
+         FROM orchestrator_task_sessions
+        WHERE repo IS NOT NULL AND repo <> ''
+        ORDER BY last_activity_at DESC
+        LIMIT 1`);
+        return rows[0] ? toText(rows[0].repo) : undefined;
+    }
+    async listSessionsForThread(threadId) {
+        const rows = await executeRawSql(this.runtime, `SELECT *
+         FROM orchestrator_task_sessions
+        WHERE thread_id = ${sqlQuote(threadId)}
+        ORDER BY registered_at ASC`);
+        return rows.map(parseSessionRow);
+    }
+    async listDecisionsForThread(threadId) {
+        const rows = await executeRawSql(this.runtime, `SELECT *
+         FROM orchestrator_task_decisions
+        WHERE thread_id = ${sqlQuote(threadId)}
+        ORDER BY timestamp ASC`);
+        return rows.map(parseDecisionRow);
+    }
+    async listDecisionsForSession(sessionId) {
+        const rows = await executeRawSql(this.runtime, `SELECT *
+         FROM orchestrator_task_decisions
+        WHERE session_id = ${sqlQuote(sessionId)}
+        ORDER BY timestamp ASC`);
+        return rows.map(parseDecisionRow);
+    }
+    async listEventsForThread(threadId) {
+        const rows = await executeRawSql(this.runtime, `SELECT *
+         FROM orchestrator_task_events
+        WHERE thread_id = ${sqlQuote(threadId)}
+        ORDER BY timestamp ASC`);
+        return rows.map(parseEventRow);
+    }
+    async listArtifactsForThread(threadId) {
+        const rows = await executeRawSql(this.runtime, `SELECT *
+         FROM orchestrator_task_artifacts
+        WHERE thread_id = ${sqlQuote(threadId)}
+        ORDER BY created_at ASC`);
+        return rows.map(parseArtifactRow);
+    }
+    async listTranscriptsForThread(threadId) {
+        const rows = await executeRawSql(this.runtime, `SELECT *
+         FROM orchestrator_task_transcripts
+        WHERE thread_id = ${sqlQuote(threadId)}
+        ORDER BY timestamp ASC`);
+        return rows.map(parseTranscriptRow);
+    }
+    async recomputeThreadStatus(threadId) {
+        await this.ensureSchema();
+        const thread = await this.getThreadRecord(threadId);
+        if (!thread)
+            return;
+        if (thread.archivedAt)
+            return;
+        const controlState = toText(thread.metadata.controlState)
+            .trim()
+            .toLowerCase();
+        const sessions = await this.listSessionsForThread(threadId);
+        const nowIso = isoNow();
+        let nextStatus = "open";
+        let closedAt = null;
+        const activeCount = sessions.filter((session) => ["active", "tool_running"].includes(session.status)).length;
+        const waitingOnUserCount = sessions.filter((session) => session.status === "waiting_on_user").length;
+        const blockedCount = sessions.filter((session) => session.status === "blocked").length;
+        const interruptedCount = sessions.filter((session) => ["interrupted", "stopped"].includes(session.status)).length;
+        const errorCount = sessions.filter((session) => session.status === "error").length;
+        const completedCount = sessions.filter((session) => session.status === "completed").length;
+        if (controlState === "paused" && activeCount === 0 && blockedCount === 0) {
+            nextStatus = "waiting_on_user";
+        }
+        else if (controlState === "stopped" &&
+            activeCount === 0 &&
+            blockedCount === 0 &&
+            waitingOnUserCount === 0) {
+            nextStatus = "interrupted";
+            closedAt = nowIso;
+        }
+        else if (sessions.length === 0) {
+            nextStatus = "open";
+        }
+        else if (activeCount > 0) {
+            nextStatus = "active";
+        }
+        else if (waitingOnUserCount > 0) {
+            nextStatus = "waiting_on_user";
+        }
+        else if (blockedCount > 0) {
+            nextStatus = "blocked";
+        }
+        else if (interruptedCount > 0) {
+            nextStatus = "interrupted";
+            closedAt = nowIso;
+        }
+        else if (completedCount === sessions.length) {
+            nextStatus = "done";
+            closedAt = nowIso;
+        }
+        else if (errorCount > 0) {
+            nextStatus = "failed";
+            closedAt = nowIso;
+        }
+        await executeRawSql(this.runtime, `UPDATE orchestrator_task_threads
+          SET status = ${sqlQuote(nextStatus)},
+              closed_at = ${sqlText(closedAt)},
+              updated_at = ${sqlQuote(nowIso)}
+        WHERE id = ${sqlQuote(threadId)}`);
+    }
+}