@devflow-tools/database 0.17.8 → 0.18.0

package/dist/database.js

@@ -14,9 +14,10 @@ const host_actions_1 = require("./host-actions");
 const retrieval_sessions_1 = require("./retrieval-sessions");
 const learning_candidates_1 = require("./learning-candidates");
 const workflow_workers_1 = require("./workflow-workers");
+const retrieval_ledger_1 = require("./retrieval-ledger");
 const task_semantic_control_1 = require("./task-semantic-control");
 const task_runtime_1 = require("./task-runtime");
-const semantic_resolution_1 = require("./semantic-resolution");
+const sdk_1 = require("@devflow-tools/sdk");
 const CONTEXT_REQUIRED_SKILLS = new Set([
     'react', 'vue', 'nest', 'nextjs', 'graphql', 'typescript',
 ]);
@@ -58,8 +59,7 @@ function obligationsForSkill(skillName, configured) {
     return configuredTools.slice(0, 1);
 }
 function getGlobalDevFlowDbPath(home = (0, os_1.homedir)()) {
-    const stateDir = process.env.DEVFLOW_STATE_DIR ?? (0, path_1.join)(home, '.devflow', 'global');
-    return (0, path_1.join)(stateDir, 'devflow.db');
+    return (0, path_1.join)((0, sdk_1.getDevFlowStateRoot)({ homeDir: home }), 'global', 'devflow.db');
 }
 function openGlobalDevFlowDatabase(home = (0, os_1.homedir)(), options) {
     return new DevFlowDatabase(home, {
@@ -400,35 +400,6 @@ class DevFlowDatabase {
       CREATE UNIQUE INDEX IF NOT EXISTS idx_task_intent_source
         ON devflow_task_intent_artifacts(project_root, session_id, source_hash, version);
 
-      CREATE TABLE IF NOT EXISTS devflow_semantic_resolutions (
-        frame_hash TEXT PRIMARY KEY,
-        project_root TEXT NOT NULL,
-        project_id TEXT NOT NULL,
-        host_id TEXT NOT NULL,
-        session_id TEXT NOT NULL,
-        turn_id TEXT NOT NULL,
-        request_id TEXT NOT NULL,
-        source_hash TEXT NOT NULL,
-        artifact_hash TEXT NOT NULL,
-        artifact_revision INTEGER NOT NULL CHECK(artifact_revision > 0),
-        supersedes_frame_hash TEXT,
-        state TEXT NOT NULL CHECK(state IN ('provisional', 'resolved', 'abstained', 'unavailable')),
-        generated_by TEXT NOT NULL CHECK(generated_by IN ('deterministic', 'embedding_router', 'host_semantic', 'hybrid')),
-        model_id TEXT,
-        model_revision TEXT,
-        route_catalog_version TEXT NOT NULL,
-        threshold_version TEXT NOT NULL,
-        route_json TEXT NOT NULL,
-        sampling_json TEXT NOT NULL,
-        conflicts_json TEXT NOT NULL,
-        frame_json TEXT NOT NULL,
-        duration_ms INTEGER NOT NULL CHECK(duration_ms >= 0),
-        created_at INTEGER NOT NULL,
-        UNIQUE(project_root, session_id, turn_id, artifact_revision)
-      );
-      CREATE INDEX IF NOT EXISTS idx_semantic_resolution_latest
-        ON devflow_semantic_resolutions(project_root, session_id, turn_id, artifact_revision DESC);
-
       CREATE TABLE IF NOT EXISTS devflow_channel_query_plans (
         plan_hash TEXT PRIMARY KEY,
         source_intent_hash TEXT NOT NULL,
@@ -528,6 +499,109 @@ class DevFlowDatabase {
         PRIMARY KEY(project_root, session_id, turn_id)
       );
 
+      CREATE TABLE IF NOT EXISTS devflow_task_definitions_v2 (
+        definition_hash TEXT PRIMARY KEY,
+        project_root TEXT NOT NULL,
+        session_id TEXT NOT NULL,
+        turn_id TEXT NOT NULL,
+        revision INTEGER NOT NULL CHECK(revision > 0),
+        definition_json TEXT NOT NULL,
+        created_at INTEGER NOT NULL,
+        UNIQUE(project_root, session_id, turn_id, revision)
+      );
+
+      CREATE TABLE IF NOT EXISTS devflow_runtime_activations_v1 (
+        snapshot_hash TEXT NOT NULL,
+        project_root TEXT NOT NULL,
+        project_id TEXT NOT NULL,
+        host_id TEXT NOT NULL,
+        session_id TEXT NOT NULL,
+        turn_id TEXT NOT NULL,
+        request_id TEXT NOT NULL,
+        execution_id TEXT,
+        revision INTEGER NOT NULL CHECK(revision > 0),
+        snapshot_json TEXT NOT NULL,
+        created_at INTEGER NOT NULL,
+        PRIMARY KEY(project_root, session_id, turn_id, revision)
+      );
+      CREATE INDEX IF NOT EXISTS idx_runtime_activation_hash_v1
+        ON devflow_runtime_activations_v1(snapshot_hash);
+
+      CREATE TABLE IF NOT EXISTS devflow_semantic_execution_contexts (
+        context_hash TEXT PRIMARY KEY,
+        project_root TEXT NOT NULL,
+        session_id TEXT NOT NULL,
+        turn_id TEXT NOT NULL,
+        revision INTEGER NOT NULL CHECK(revision > 0),
+        facts_hash TEXT NOT NULL,
+        plan_hash TEXT NOT NULL,
+        activation_snapshot_hash TEXT NOT NULL,
+        definition_hash TEXT NOT NULL,
+        context_json TEXT NOT NULL,
+        created_at INTEGER NOT NULL,
+        UNIQUE(project_root, session_id, turn_id, revision)
+      );
+
+      CREATE TABLE IF NOT EXISTS devflow_task_aggregate_events_v2 (
+        event_id TEXT PRIMARY KEY,
+        idempotency_key TEXT NOT NULL UNIQUE,
+        project_root TEXT NOT NULL,
+        project_id TEXT NOT NULL,
+        host_id TEXT NOT NULL,
+        session_id TEXT NOT NULL,
+        turn_id TEXT NOT NULL,
+        request_id TEXT NOT NULL,
+        execution_id TEXT,
+        revision INTEGER NOT NULL CHECK(revision > 0),
+        sequence INTEGER NOT NULL CHECK(sequence > 0),
+        kind TEXT NOT NULL,
+        producer TEXT NOT NULL,
+        producer_version TEXT NOT NULL,
+        causation_id TEXT,
+        correlation_id TEXT,
+        payload_json TEXT NOT NULL DEFAULT '{}',
+        event_json TEXT NOT NULL,
+        created_at INTEGER NOT NULL,
+        UNIQUE(project_root, session_id, turn_id, revision, sequence)
+      );
+      CREATE INDEX IF NOT EXISTS idx_task_aggregate_event_identity_v2
+        ON devflow_task_aggregate_events_v2(project_root, session_id, turn_id, revision, sequence);
+
+      CREATE TABLE IF NOT EXISTS devflow_task_aggregates_v2 (
+        project_root TEXT NOT NULL,
+        session_id TEXT NOT NULL,
+        turn_id TEXT NOT NULL,
+        revision INTEGER NOT NULL CHECK(revision > 0),
+        definition_hash TEXT NOT NULL,
+        activation_snapshot_hash TEXT NOT NULL,
+        last_event_sequence INTEGER NOT NULL CHECK(last_event_sequence > 0),
+        snapshot_json TEXT NOT NULL,
+        snapshot_hash TEXT NOT NULL,
+        updated_at INTEGER NOT NULL,
+        PRIMARY KEY(project_root, session_id, turn_id, revision)
+      );
+
+      CREATE TABLE IF NOT EXISTS devflow_task_outbox_v2 (
+        operation_id TEXT PRIMARY KEY,
+        event_id TEXT NOT NULL,
+        project_root TEXT NOT NULL,
+        session_id TEXT NOT NULL,
+        turn_id TEXT NOT NULL,
+        revision INTEGER NOT NULL CHECK(revision > 0),
+        kind TEXT NOT NULL,
+        payload_json TEXT NOT NULL DEFAULT '{}',
+        state TEXT NOT NULL CHECK(state IN ('pending','leased','completed','dead_letter')),
+        lease_owner TEXT,
+        lease_expires_at INTEGER,
+        fencing_token INTEGER NOT NULL DEFAULT 0 CHECK(fencing_token >= 0),
+        attempts INTEGER NOT NULL DEFAULT 0 CHECK(attempts >= 0),
+        created_at INTEGER NOT NULL,
+        updated_at INTEGER NOT NULL,
+        FOREIGN KEY(event_id) REFERENCES devflow_task_aggregate_events_v2(event_id)
+      );
+      CREATE INDEX IF NOT EXISTS idx_task_outbox_ready_v2
+        ON devflow_task_outbox_v2(project_root, state, updated_at);
+
       CREATE TABLE IF NOT EXISTS devflow_transcript_checkpoints (
         id TEXT PRIMARY KEY,
         project_root TEXT NOT NULL,
@@ -597,6 +671,53 @@ class DevFlowDatabase {
       CREATE UNIQUE INDEX IF NOT EXISTS idx_retrieval_cycles_receipt
         ON devflow_retrieval_cycles(receipt);
 
+      CREATE TABLE IF NOT EXISTS devflow_retrieval_sessions_v2 (
+        id TEXT PRIMARY KEY,
+        project_root TEXT NOT NULL,
+        project_id TEXT NOT NULL,
+        host_id TEXT NOT NULL,
+        task_session_id TEXT NOT NULL,
+        turn_id TEXT NOT NULL,
+        request_id TEXT NOT NULL,
+        execution_id TEXT,
+        task_revision INTEGER NOT NULL CHECK(task_revision > 0),
+        facts_hash TEXT NOT NULL,
+        plan_hash TEXT NOT NULL,
+        activation_snapshot_hash TEXT NOT NULL,
+        coordinator_version TEXT NOT NULL,
+        state TEXT NOT NULL CHECK(state IN ('open','sufficient','gap_actionable','gap_unavailable','abstain')),
+        cycle INTEGER NOT NULL DEFAULT 0 CHECK(cycle BETWEEN 0 AND 3),
+        no_gain_count INTEGER NOT NULL DEFAULT 0 CHECK(no_gain_count BETWEEN 0 AND 2),
+        max_cycles INTEGER NOT NULL DEFAULT 3 CHECK(max_cycles = 3),
+        initial_token_budget INTEGER NOT NULL CHECK(initial_token_budget >= 0),
+        remaining_token_budget INTEGER NOT NULL CHECK(remaining_token_budget >= 0),
+        final_receipt_hash TEXT,
+        created_at INTEGER NOT NULL,
+        updated_at INTEGER NOT NULL,
+        expires_at INTEGER NOT NULL,
+        UNIQUE(project_root, task_session_id, turn_id, task_revision, coordinator_version)
+      );
+      CREATE INDEX IF NOT EXISTS idx_retrieval_sessions_v2_owner
+        ON devflow_retrieval_sessions_v2(project_root, task_session_id, state, updated_at);
+
+      CREATE TABLE IF NOT EXISTS devflow_retrieval_cycles_v2 (
+        retrieval_session_id TEXT NOT NULL,
+        cycle INTEGER NOT NULL CHECK(cycle BETWEEN 1 AND 3),
+        signature_hashes_json TEXT NOT NULL,
+        receipt_json TEXT NOT NULL,
+        receipt_hash TEXT NOT NULL UNIQUE,
+        evidence_hash TEXT NOT NULL,
+        token_cost INTEGER NOT NULL CHECK(token_cost >= 0),
+        stable_ref_gain INTEGER NOT NULL CHECK(stable_ref_gain >= 0),
+        no_gain_count INTEGER NOT NULL CHECK(no_gain_count BETWEEN 0 AND 2),
+        sufficiency TEXT NOT NULL CHECK(sufficiency IN ('sufficient','gap_actionable','gap_unavailable','abstain')),
+        created_at INTEGER NOT NULL,
+        PRIMARY KEY(retrieval_session_id, cycle),
+        FOREIGN KEY(retrieval_session_id) REFERENCES devflow_retrieval_sessions_v2(id)
+      );
+      CREATE INDEX IF NOT EXISTS idx_retrieval_cycle_v2_evidence
+        ON devflow_retrieval_cycles_v2(retrieval_session_id, evidence_hash);
+
       CREATE TABLE IF NOT EXISTS devflow_memory_distill_checkpoints (
         id TEXT PRIMARY KEY,
         project_root TEXT NOT NULL,
@@ -3035,6 +3156,119 @@ class DevFlowDatabase {
             throw error;
         }
     }
+    createRetrievalSessionV2(input) {
+        if (!input.id || !Number.isSafeInteger(input.taskRevision) || input.taskRevision < 1
+            || !Number.isSafeInteger(input.tokenBudget) || input.tokenBudget < 0) {
+            throw new Error('RETRIEVAL_SESSION_V2_INVALID');
+        }
+        const existing = this.getRetrievalSessionV2(input.id);
+        if (existing) {
+            const compatible = existing.identity.projectRoot === input.identity.projectRoot
+                && existing.identity.sessionId === input.identity.sessionId
+                && existing.identity.turnId === input.identity.turnId
+                && existing.taskRevision === input.taskRevision
+                && existing.factsHash === input.factsHash
+                && existing.planHash === input.planHash
+                && existing.activationSnapshotHash === input.activationSnapshotHash
+                && existing.coordinatorVersion === input.coordinatorVersion
+                && existing.initialTokenBudget === input.tokenBudget;
+            if (!compatible)
+                throw new Error('RETRIEVAL_SESSION_V2_CONFLICT');
+            return existing;
+        }
+        const now = input.createdAt ?? Date.now();
+        const identity = input.identity;
+        this.db.prepare(`INSERT INTO devflow_retrieval_sessions_v2 (
+      id, project_root, project_id, host_id, task_session_id, turn_id, request_id,
+      execution_id, task_revision, facts_hash, plan_hash, activation_snapshot_hash,
+      coordinator_version, state, cycle, no_gain_count, max_cycles,
+      initial_token_budget, remaining_token_budget, created_at, updated_at, expires_at
+    ) VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, 'open', 0, 0, 3, ?, ?, ?, ?, ?)`)
+            .run(input.id, identity.projectRoot, identity.projectId, identity.hostId, identity.sessionId, identity.turnId, identity.requestId, identity.executionId ?? null, input.taskRevision, input.factsHash, input.planHash, input.activationSnapshotHash, input.coordinatorVersion, input.tokenBudget, input.tokenBudget, now, now, input.expiresAt);
+        return this.getRetrievalSessionV2(input.id);
+    }
+    getRetrievalSessionV2(id) {
+        const row = this.db.prepare('SELECT * FROM devflow_retrieval_sessions_v2 WHERE id = ?')
+            .get(id);
+        return row ? mapRetrievalSessionV2(row) : null;
+    }
+    listRetrievalCyclesV2(sessionId) {
+        return this.db.prepare(`SELECT receipt_json FROM devflow_retrieval_cycles_v2
+      WHERE retrieval_session_id = ? ORDER BY cycle`).all(sessionId)
+            .map(row => JSON.parse(row.receipt_json));
+    }
+    appendRetrievalCycleV2(input) {
+        return this.db.transaction(() => {
+            const session = this.getRetrievalSessionV2(input.sessionId);
+            if (!session)
+                throw new Error(`RETRIEVAL_SESSION_V2_NOT_FOUND:${input.sessionId}`);
+            if (session.identity.projectRoot !== input.projectRoot
+                || session.identity.sessionId !== input.taskSessionId)
+                throw new Error('RETRIEVAL_SESSION_V2_IDENTITY_MISMATCH');
+            if (input.receipt.sessionId !== session.id)
+                throw new Error('RETRIEVAL_CYCLE_V2_SESSION_MISMATCH');
+            const { receiptHash: cycleHash, ...cycleBody } = input.receipt;
+            const { receiptHash: compositeHash, ...compositeBody } = input.receipt.compositeReceipt;
+            if ((0, task_runtime_1.stableTaskRuntimeHash)(cycleBody) !== cycleHash
+                || (0, task_runtime_1.stableTaskRuntimeHash)(compositeBody) !== compositeHash) {
+                throw new Error('RETRIEVAL_CYCLE_V2_HASH_MISMATCH');
+            }
+            if (input.receipt.compositeReceipt.factsHash !== session.factsHash
+                || input.receipt.compositeReceipt.planHash !== session.planHash
+                || input.receipt.compositeReceipt.activationSnapshotHash !== session.activationSnapshotHash
+                || input.receipt.compositeReceipt.coordinatorVersion !== session.coordinatorVersion) {
+                throw new Error('RETRIEVAL_CYCLE_V2_BINDING_MISMATCH');
+            }
+            const signaturesValid = input.receipt.requestSignatures.every(signature => sameTaskIdentity(signature.identity, session.identity)
+                && signature.taskRevision === session.taskRevision
+                && signature.factsHash === session.factsHash
+                && signature.planHash === session.planHash
+                && signature.activationSnapshotHash === session.activationSnapshotHash);
+            if (!signaturesValid)
+                throw new Error('RETRIEVAL_SIGNATURE_V2_BINDING_MISMATCH');
+            const existing = this.db.prepare(`SELECT receipt_json FROM devflow_retrieval_cycles_v2
+        WHERE retrieval_session_id = ? AND cycle = ?`).get(input.sessionId, input.receipt.cycle);
+            if (existing?.receipt_json) {
+                const receipt = JSON.parse(existing.receipt_json);
+                if (receipt.receiptHash !== input.receipt.receiptHash)
+                    throw new Error('RETRIEVAL_CYCLE_V2_CONFLICT');
+                return session;
+            }
+            if (session.state !== 'open' || session.expiresAt <= input.receipt.createdAt) {
+                throw new Error(`RETRIEVAL_SESSION_V2_TERMINAL:${session.state}`);
+            }
+            if (input.receipt.cycle !== session.cycle + 1 || input.receipt.cycle > 3) {
+                throw new Error('RETRIEVAL_CYCLE_V2_SEQUENCE');
+            }
+            const priorCycles = this.listRetrievalCyclesV2(input.sessionId);
+            const priorRefs = new Set(priorCycles.flatMap(cycle => cycle.selectedRefs));
+            const expectedGain = input.receipt.selectedRefs.filter(ref => !priorRefs.has(ref)).length;
+            const expectedNoGain = expectedGain > 0 ? 0 : Math.min(2, session.noGainCount + 1);
+            if (input.receipt.stableRefGain !== expectedGain || input.receipt.noGainCount !== expectedNoGain) {
+                throw new Error('RETRIEVAL_CYCLE_V2_GAIN_MISMATCH');
+            }
+            if (input.remainingTokenBudget !== session.remainingTokenBudget - input.receipt.tokenCost
+                || input.remainingTokenBudget < 0)
+                throw new Error('RETRIEVAL_CYCLE_V2_BUDGET');
+            this.db.prepare(`INSERT INTO devflow_retrieval_cycles_v2 (
+        retrieval_session_id, cycle, signature_hashes_json, receipt_json, receipt_hash,
+        evidence_hash, token_cost, stable_ref_gain, no_gain_count, sufficiency, created_at
+      ) VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?)`)
+                .run(input.sessionId, input.receipt.cycle, (0, task_runtime_1.stableTaskRuntimeJson)(input.receipt.requestSignatures.map(item => item.signatureHash)), (0, task_runtime_1.stableTaskRuntimeJson)(input.receipt), input.receipt.receiptHash, input.receipt.evidenceHash, input.receipt.tokenCost, input.receipt.stableRefGain, input.receipt.noGainCount, input.receipt.sufficiency, input.receipt.createdAt);
+            const terminal = input.receipt.sufficiency === 'sufficient'
+                || input.receipt.sufficiency === 'gap_unavailable'
+                || input.receipt.sufficiency === 'abstain'
+                || input.receipt.noGainCount >= 2
+                || input.receipt.cycle >= 3
+                || input.remainingTokenBudget === 0;
+            const state = terminal ? input.receipt.sufficiency : 'open';
+            this.db.prepare(`UPDATE devflow_retrieval_sessions_v2 SET
+        state = ?, cycle = ?, no_gain_count = ?, remaining_token_budget = ?,
+        final_receipt_hash = ?, updated_at = ? WHERE id = ?`)
+                .run(state, input.receipt.cycle, input.receipt.noGainCount, input.remainingTokenBudget, terminal ? input.receipt.compositeReceipt.receiptHash : null, input.receipt.createdAt, input.sessionId);
+            return this.getRetrievalSessionV2(input.sessionId);
+        });
+    }
     getRetrievalSession(projectRoot, sessionId, id) {
         const row = this.db.prepare(`
       SELECT * FROM devflow_retrieval_sessions
@@ -3294,7 +3528,13 @@ class DevFlowDatabase {
     `).run(event.id, event.projectRoot, event.sessionId, event.executionId, event.requestId ?? null, event.selectionType, event.candidateId, event.toolName, event.toolUseId ?? null, event.selectedAt).changes > 0;
     }
     appendRetrievalLedgerEvent(event) {
-        if ((event.stage === 'selected' || event.stage === 'exposed')
+        if (!new Set([
+            'eligible', 'candidate', 'selected', 'consumed', 'verified',
+            'positive_outcome', 'negative_outcome', 'unknown_outcome', 'rejected',
+        ]).has(event.stage)) {
+            throw new Error(`RETRIEVAL_LEDGER_STAGE_INVALID:${event.stage}`);
+        }
+        if (event.stage === 'selected'
             && typeof event.payload.returnedFinalScore === 'number'
             && event.payload.returnedFinalScore > 0
             && event.finalScore === 0) {
@@ -3309,7 +3549,57 @@ class DevFlowDatabase {
       ) VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?)
     `).run(event.id, event.projectRoot, event.sessionId, event.executionId ?? null, event.turnId ?? null, event.requestId, event.contextReceipt, event.sourceType, event.sourceId, event.stage, event.rank ?? null, event.rawScore ?? null, event.normalizedScore ?? null, event.finalScore ?? null, JSON.stringify(event.applicability), event.reason ?? null, JSON.stringify(event.toolEvidence), event.verificationReceipt ?? null, JSON.stringify(event.payload), event.createdAt, event.schemaVersion ?? 'retrieval-ledger-event.v1', event.taskSpecHash ?? null, event.actor ?? null, event.sourceVersion ?? null, event.sourceContentHash ?? null, JSON.stringify(event.evidenceIds ?? []), event.reasonCode ?? null).changes > 0;
     }
+    verifyReceiptBoundRetrieval(input) {
+        for (const [field, value] of Object.entries({
+            projectRoot: input.projectRoot,
+            sessionId: input.sessionId,
+            executionId: input.executionId,
+            contextReceipt: input.contextReceipt,
+            toolUseId: input.toolUseId,
+            verificationReceipt: input.verificationReceipt,
+        })) {
+            if (typeof value !== 'string' || value.trim().length === 0) {
+                throw new Error(`RETRIEVAL_LEDGER_INVALID_${field}`);
+            }
+        }
+        if (!Number.isSafeInteger(input.verifiedAt) || input.verifiedAt < 0) {
+            throw new Error('RETRIEVAL_LEDGER_INVALID_verifiedAt');
+        }
+        return this.db.transaction(() => {
+            const selected = this.listRetrievalLedgerEvents({
+                projectRoot: input.projectRoot,
+                sessionId: input.sessionId,
+                executionId: input.executionId,
+            }).filter(event => event.stage === 'selected'
+                && event.contextReceipt === input.contextReceipt);
+            if (selected.length === 0)
+                throw new Error('RETRIEVAL_LEDGER_SELECTIONS_NOT_FOUND');
+            for (const selection of selected) {
+                const consumed = {
+                    ...selection,
+                    id: (0, retrieval_ledger_1.retrievalLedgerTransitionId)(selection.id, 'consumed', input.toolUseId),
+                    stage: 'consumed',
+                    actor: 'devflow_report_step',
+                    reasonCode: 'verified_host_action',
+                    toolEvidence: [input.toolUseId],
+                    payload: { ...selection.payload, consumedByTool: 'devflow_report_step' },
+                    createdAt: input.verifiedAt,
+                };
+                this.appendRetrievalLedgerEvent(consumed);
+                this.appendRetrievalLedgerEvent({
+                    ...consumed,
+                    id: (0, retrieval_ledger_1.retrievalLedgerTransitionId)(consumed.id, 'verified', input.verificationReceipt),
+                    stage: 'verified',
+                    verificationReceipt: `${input.verificationReceipt}:${selection.sourceId}`,
+                });
+            }
+            return { selected: selected.length, consumed: selected.length, verified: selected.length };
+        });
+    }
     appendTaskIntentArtifact(record) {
+        return this.db.transaction(() => this.appendTaskIntentArtifactInTransaction(record));
+    }
+    appendTaskIntentArtifactInTransaction(record) {
         (0, task_semantic_control_1.assertTaskIdentity)(record);
         if (!Number.isSafeInteger(record.version) || record.version <= 0) {
             throw new Error('TASK_INTENT_INVALID_VERSION');
@@ -3321,18 +3611,16 @@ class DevFlowDatabase {
             }
             return existingByHash;
         }
-        this.db.exec('BEGIN IMMEDIATE');
-        try {
-            const conflicting = this.db.prepare(`
+        const conflicting = this.db.prepare(`
         SELECT * FROM devflow_task_intent_artifacts
         WHERE project_root = ? AND session_id = ? AND turn_id = ? AND version = ?
       `).get(record.projectRoot, record.sessionId, record.turnId, record.version);
-            if (conflicting)
-                throw new Error(`TASK_INTENT_VERSION_CONFLICT:${record.turnId}:${record.version}`);
-            if (record.supersedesHash && !this.getTaskIntentArtifact(record.supersedesHash)) {
-                throw new Error(`TASK_INTENT_SUPERSEDED_NOT_FOUND:${record.supersedesHash}`);
-            }
-            this.db.prepare(`
+        if (conflicting)
+            throw new Error(`TASK_INTENT_VERSION_CONFLICT:${record.turnId}:${record.version}`);
+        if (record.supersedesHash && !this.getTaskIntentArtifact(record.supersedesHash)) {
+            throw new Error(`TASK_INTENT_SUPERSEDED_NOT_FOUND:${record.supersedesHash}`);
+        }
+        this.db.prepare(`
         INSERT INTO devflow_task_intent_artifacts (
           artifact_hash, project_root, project_id, host_id, session_id, turn_id, request_id,
           execution_id, version, supersedes_hash, raw_prompt, normalized_prompt, command,
@@ -3341,17 +3629,7 @@ class DevFlowDatabase {
           source_hash, created_at
         ) VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?)
       `).run(record.artifactHash, record.projectRoot, record.projectId, record.hostId, record.sessionId, record.turnId, record.requestId, record.executionId ?? null, record.version, record.supersedesHash ?? null, record.rawPrompt, record.normalizedPrompt, record.command ?? null, (0, task_semantic_control_1.stableSemanticJson)(record.slashArgs), record.activeSkill ?? null, record.intent, record.action, (0, task_semantic_control_1.stableSemanticJson)(record.entities), (0, task_semantic_control_1.stableSemanticJson)(record.targetAnchors), (0, task_semantic_control_1.stableSemanticJson)(record.policyConstraints), (0, task_semantic_control_1.stableSemanticJson)(record.classificationEvidence), (0, task_semantic_control_1.stableSemanticJson)(record.sourceEventIds), record.sourceHash, record.createdAt);
-            const created = this.getTaskIntentArtifact(record.artifactHash);
-            this.db.exec('COMMIT');
-            return created;
-        }
-        catch (error) {
-            try {
-                this.db.exec('ROLLBACK');
-            }
-            catch { }
-            throw error;
-        }
+        return this.getTaskIntentArtifact(record.artifactHash);
     }
     getTaskIntentArtifact(artifactHash) {
         const row = this.db.prepare(`
@@ -3386,77 +3664,6 @@ class DevFlowDatabase {
     `).get(input.projectRoot, input.sessionId, input.sourceHash);
         return row ? (0, task_semantic_control_1.mapTaskIntentArtifactRow)(row) : null;
     }
-    appendSemanticResolution(record) {
-        (0, semantic_resolution_1.assertSemanticResolutionRecord)(record);
-        const existing = this.getSemanticResolution(record.frameHash);
-        if (existing) {
-            if ((0, semantic_resolution_1.stableSemanticResolutionJson)(existing) !== (0, semantic_resolution_1.stableSemanticResolutionJson)(record)) {
-                throw new Error(`SEMANTIC_RESOLUTION_HASH_CONFLICT:${record.frameHash}`);
-            }
-            return false;
-        }
-        this.db.exec('BEGIN IMMEDIATE');
-        try {
-            const conflicting = this.db.prepare(`
-        SELECT frame_hash FROM devflow_semantic_resolutions
-        WHERE project_root = ? AND session_id = ? AND turn_id = ? AND artifact_revision = ?
-      `).get(record.projectRoot, record.sessionId, record.turnId, record.artifactRevision);
-            if (conflicting) {
-                throw new Error(`SEMANTIC_RESOLUTION_REVISION_CONFLICT:${record.turnId}:${record.artifactRevision}`);
-            }
-            if (record.supersedesFrameHash) {
-                const superseded = this.getSemanticResolution(record.supersedesFrameHash);
-                if (!superseded) {
-                    throw new Error(`SEMANTIC_RESOLUTION_SUPERSEDED_NOT_FOUND:${record.supersedesFrameHash}`);
-                }
-                if (superseded.projectRoot !== record.projectRoot
-                    || superseded.sessionId !== record.sessionId
-                    || superseded.turnId !== record.turnId
-                    || superseded.artifactRevision >= record.artifactRevision) {
-                    throw new Error('SEMANTIC_RESOLUTION_SUPERSEDES_INVALID');
-                }
-            }
-            this.db.prepare(`
-        INSERT INTO devflow_semantic_resolutions (
-          frame_hash, project_root, project_id, host_id, session_id, turn_id, request_id,
-          source_hash, artifact_hash, artifact_revision, supersedes_frame_hash, state,
-          generated_by, model_id, model_revision, route_catalog_version, threshold_version,
-          route_json, sampling_json, conflicts_json, frame_json, duration_ms, created_at
-        ) VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?)
-      `).run(record.frameHash, record.projectRoot, record.projectId, record.hostId, record.sessionId, record.turnId, record.requestId, record.sourceHash, record.artifactHash, record.artifactRevision, record.supersedesFrameHash ?? null, record.state, record.generatedBy, record.modelId ?? null, record.modelRevision ?? null, record.routeCatalogVersion, record.thresholdVersion, (0, semantic_resolution_1.stableSemanticResolutionJson)(record.route), (0, semantic_resolution_1.stableSemanticResolutionJson)(record.sampling), (0, semantic_resolution_1.stableSemanticResolutionJson)(record.conflicts), (0, semantic_resolution_1.stableSemanticResolutionJson)(record.frame), record.durationMs, record.createdAt);
-            this.db.exec('COMMIT');
-            return true;
-        }
-        catch (error) {
-            try {
-                this.db.exec('ROLLBACK');
-            }
-            catch { }
-            throw error;
-        }
-    }
-    getSemanticResolution(frameHash) {
-        const row = this.db.prepare(`
-      SELECT * FROM devflow_semantic_resolutions WHERE frame_hash = ?
-    `).get(frameHash);
-        return row ? (0, semantic_resolution_1.mapSemanticResolutionRow)(row) : null;
-    }
-    getLatestSemanticResolution(projectRoot, sessionId, turnId) {
-        const row = this.db.prepare(`
-      SELECT * FROM devflow_semantic_resolutions
-      WHERE project_root = ? AND session_id = ? AND turn_id = ?
-      ORDER BY artifact_revision DESC, created_at DESC LIMIT 1
-    `).get(projectRoot, sessionId, turnId);
-        return row ? (0, semantic_resolution_1.mapSemanticResolutionRow)(row) : null;
-    }
-    listSemanticResolutions(projectRoot, sessionId, turnId) {
-        return this.db.prepare(`
-      SELECT * FROM devflow_semantic_resolutions
-      WHERE project_root = ? AND session_id = ? AND turn_id = ?
-      ORDER BY artifact_revision ASC, created_at ASC
-    `).all(projectRoot, sessionId, turnId)
-            .map(semantic_resolution_1.mapSemanticResolutionRow);
-    }
     listLatestTaskIntentArtifacts(projectRoot, sessionId) {
         return this.db.prepare(`
       SELECT artifact.* FROM devflow_task_intent_artifacts artifact
@@ -3660,6 +3867,232 @@ class DevFlowDatabase {
       WHERE project_root = ? AND session_id = ? AND turn_id = ?
     `).run(projectRoot, sessionId, turnId).changes > 0;
     }
+    appendTaskAggregate(input) {
+        return this.db.transaction(() => {
+            const existingByKey = this.db.prepare(`
+        SELECT event_json FROM devflow_task_aggregate_events_v2 WHERE idempotency_key = ?
+      `).get(input.event.idempotencyKey);
+            if (existingByKey?.event_json) {
+                const existing = JSON.parse(existingByKey.event_json);
+                if ((0, task_runtime_1.stableTaskRuntimeJson)(existing) !== (0, task_runtime_1.stableTaskRuntimeJson)(input.event)) {
+                    throw new Error('TASK_EVENT_IDEMPOTENCY_CONFLICT');
+                }
+                const snapshot = this.getTaskAggregateSnapshot(input.event.identity.projectRoot, input.event.identity.sessionId, input.event.identity.turnId, input.event.revision);
+                if (!snapshot)
+                    throw new Error('TASK_AGGREGATE_SNAPSHOT_MISSING');
+                return { event: existing, snapshot, replayed: true };
+            }
+            if (input.definition)
+                this.putTaskDefinitionV2(input.definition, input.event.createdAt);
+            const current = this.getTaskAggregateSnapshot(input.event.identity.projectRoot, input.event.identity.sessionId, input.event.identity.turnId, input.event.revision);
+            const expectedSequence = (current?.lastEventSequence ?? 0) + 1;
+            if (input.event.sequence !== expectedSequence) {
+                throw new Error(`TASK_AGGREGATE_SEQUENCE_CONFLICT:${expectedSequence}->${input.event.sequence}`);
+            }
+            if (input.snapshot.lastEventSequence !== input.event.sequence) {
+                throw new Error('TASK_AGGREGATE_SNAPSHOT_SEQUENCE_MISMATCH');
+            }
+            const identity = input.event.identity;
+            this.db.prepare(`
+        INSERT INTO devflow_task_aggregate_events_v2 (
+          event_id, idempotency_key, project_root, project_id, host_id, session_id,
+          turn_id, request_id, execution_id, revision, sequence, kind, producer,
+          producer_version, causation_id, correlation_id, payload_json, event_json, created_at
+        ) VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?)
+      `).run(input.event.eventId, input.event.idempotencyKey, identity.projectRoot, identity.projectId, identity.hostId, identity.sessionId, identity.turnId, identity.requestId, identity.executionId ?? null, input.event.revision, input.event.sequence, input.event.kind, input.event.producer, input.event.producerVersion, input.event.causationId ?? null, input.event.correlationId ?? null, (0, task_runtime_1.stableTaskRuntimeJson)(input.event.payload), (0, task_runtime_1.stableTaskRuntimeJson)(input.event), input.event.createdAt);
+            this.db.prepare(`
+        INSERT INTO devflow_task_aggregates_v2 (
+          project_root, session_id, turn_id, revision, definition_hash,
+          activation_snapshot_hash, last_event_sequence, snapshot_json, snapshot_hash, updated_at
+        ) VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?, ?)
+        ON CONFLICT(project_root, session_id, turn_id, revision) DO UPDATE SET
+          definition_hash=excluded.definition_hash,
+          activation_snapshot_hash=excluded.activation_snapshot_hash,
+          last_event_sequence=excluded.last_event_sequence,
+          snapshot_json=excluded.snapshot_json,
+          snapshot_hash=excluded.snapshot_hash,
+          updated_at=excluded.updated_at
+      `).run(identity.projectRoot, identity.sessionId, identity.turnId, input.event.revision, input.snapshot.taskDefinitionHash, input.snapshot.activationSnapshotHash, input.snapshot.lastEventSequence, (0, task_runtime_1.stableTaskRuntimeJson)(input.snapshot), input.snapshot.snapshotHash, input.snapshot.updatedAt);
+            if (input.outbox) {
+                this.db.prepare(`
+          INSERT INTO devflow_task_outbox_v2 (
+            operation_id, event_id, project_root, session_id, turn_id, revision,
+            kind, payload_json, state, created_at, updated_at
+          ) VALUES (?, ?, ?, ?, ?, ?, ?, ?, 'pending', ?, ?)
+        `).run(input.outbox.operationId, input.event.eventId, identity.projectRoot, identity.sessionId, identity.turnId, input.event.revision, input.outbox.kind, (0, task_runtime_1.stableTaskRuntimeJson)(input.outbox.payload), input.event.createdAt, input.event.createdAt);
+            }
+            return { event: input.event, snapshot: input.snapshot, replayed: false };
+        });
+    }
+    bindRuntimeActivation(input) {
+        return this.db.transaction(() => this.bindRuntimeActivationInTransaction(input));
+    }
+    bindRuntimeActivationInTransaction(input) {
+        const existing = this.getRuntimeActivation(input.identity.projectRoot, input.identity.sessionId, input.identity.turnId, input.revision);
+        if (existing) {
+            if ((0, task_runtime_1.stableTaskRuntimeJson)(existing) !== (0, task_runtime_1.stableTaskRuntimeJson)(input.snapshot)) {
+                throw new Error('RUNTIME_ACTIVATION_CONFLICT');
+            }
+            return { snapshot: existing, replayed: true };
+        }
+        const identity = input.identity;
+        this.db.prepare(`
+        INSERT INTO devflow_runtime_activations_v1 (
+          snapshot_hash, project_root, project_id, host_id, session_id, turn_id,
+          request_id, execution_id, revision, snapshot_json, created_at
+        ) VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?)
+      `).run(input.snapshot.snapshotHash, identity.projectRoot, identity.projectId, identity.hostId, identity.sessionId, identity.turnId, identity.requestId, identity.executionId ?? null, input.revision, (0, task_runtime_1.stableTaskRuntimeJson)(input.snapshot), input.snapshot.createdAt);
+        return { snapshot: input.snapshot, replayed: false };
+    }
+    getRuntimeActivation(projectRoot, sessionId, turnId, revision) {
+        const row = this.db.prepare(`
+      SELECT snapshot_json FROM devflow_runtime_activations_v1
+      WHERE project_root = ? AND session_id = ? AND turn_id = ? AND revision = ?
+    `).get(projectRoot, sessionId, turnId, revision);
+        return row?.snapshot_json ? JSON.parse(row.snapshot_json) : null;
+    }
+    putSemanticExecutionContext(input) {
+        const context = input.context;
+        if (context.plan.sourceFactsHash !== context.facts.factsHash) {
+            throw new Error('SEMANTIC_EXECUTION_CONTEXT_FACTS_PLAN_MISMATCH');
+        }
+        const existing = this.getSemanticExecutionContext(context.identity.projectRoot, context.identity.sessionId, context.identity.turnId, input.revision);
+        if (existing) {
+            if ((0, task_runtime_1.stableTaskRuntimeJson)(existing) !== (0, task_runtime_1.stableTaskRuntimeJson)(context)) {
+                throw new Error('SEMANTIC_EXECUTION_CONTEXT_CONFLICT');
+            }
+            return existing;
+        }
+        this.db.prepare(`INSERT INTO devflow_semantic_execution_contexts (
+      context_hash, project_root, session_id, turn_id, revision, facts_hash,
+      plan_hash, activation_snapshot_hash, definition_hash, context_json, created_at
+    ) VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?)`).run(context.contextHash, context.identity.projectRoot, context.identity.sessionId, context.identity.turnId, input.revision, context.facts.factsHash, context.plan.planHash, context.activationSnapshotHash, context.taskDefinitionHash, (0, task_runtime_1.stableTaskRuntimeJson)(context), context.createdAt);
+        return context;
+    }
+    putCanonicalSemanticTask(input) {
+        const { activation, context, definition } = input;
+        if (input.revision !== definition.revision
+            || context.taskDefinitionHash !== definition.definitionHash
+            || definition.semanticContextHash !== context.contextHash
+            || context.activationSnapshotHash !== activation.snapshotHash
+            || (0, task_runtime_1.stableTaskRuntimeJson)(context.identity) !== (0, task_runtime_1.stableTaskRuntimeJson)(definition.identity)) {
+            throw new Error('CANONICAL_SEMANTIC_TASK_BINDING_INVALID');
+        }
+        return this.db.transaction(() => {
+            this.bindRuntimeActivationInTransaction({
+                identity: context.identity, revision: input.revision, snapshot: activation,
+            });
+            this.putTaskDefinitionV2(definition, context.createdAt);
+            const persisted = this.putSemanticExecutionContext({ context, revision: input.revision });
+            return persisted;
+        });
+    }
+    getSemanticExecutionContext(projectRoot, sessionId, turnId, revision) {
+        const row = this.db.prepare(`SELECT context_json FROM devflow_semantic_execution_contexts
+      WHERE project_root = ? AND session_id = ? AND turn_id = ? AND revision = ?`)
+            .get(projectRoot, sessionId, turnId, revision);
+        return row?.context_json ? JSON.parse(row.context_json) : null;
+    }
+    getSemanticExecutionContextByHash(contextHash) {
+        const row = this.db.prepare(`SELECT context_json FROM devflow_semantic_execution_contexts
+      WHERE context_hash = ?`).get(contextHash);
+        return row?.context_json ? JSON.parse(row.context_json) : null;
+    }
+    getLatestSemanticExecutionContext(input) {
+        const row = this.db.prepare(`SELECT context_json, revision FROM devflow_semantic_execution_contexts
+      WHERE project_root = ? AND session_id = ? AND turn_id = ?
+      ORDER BY revision DESC, created_at DESC LIMIT 1`)
+            .get(input.projectRoot, input.sessionId, input.turnId);
+        return row?.context_json ? { context: JSON.parse(row.context_json), revision: Number(row.revision) } : null;
+    }
+    listTaskAggregateEvents(projectRoot, sessionId, turnId, revision) {
+        return this.db.prepare(`
+      SELECT event_json FROM devflow_task_aggregate_events_v2
+      WHERE project_root = ? AND session_id = ? AND turn_id = ? AND revision = ?
+      ORDER BY sequence ASC
+    `).all(projectRoot, sessionId, turnId, revision)
+            .map(row => JSON.parse(row.event_json));
+    }
+    getTaskAggregateEventByIdempotencyKey(idempotencyKey) {
+        const row = this.db.prepare(`
+      SELECT event_json FROM devflow_task_aggregate_events_v2 WHERE idempotency_key = ?
+    `).get(idempotencyKey);
+        return row?.event_json ? JSON.parse(row.event_json) : null;
+    }
+    getTaskAggregateSnapshot(projectRoot, sessionId, turnId, revision) {
+        const row = this.db.prepare(`
+      SELECT snapshot_json FROM devflow_task_aggregates_v2
+      WHERE project_root = ? AND session_id = ? AND turn_id = ? AND revision = ?
+    `).get(projectRoot, sessionId, turnId, revision);
+        return row?.snapshot_json ? JSON.parse(row.snapshot_json) : null;
+    }
+    getTaskDefinitionV2(definitionHash) {
+        const row = this.db.prepare(`
+      SELECT definition_json FROM devflow_task_definitions_v2 WHERE definition_hash = ?
+    `).get(definitionHash);
+        return row?.definition_json ? JSON.parse(row.definition_json) : null;
+    }
+    leaseTaskOutbox(input) {
+        if (!input.owner.trim() || input.limit <= 0 || input.leaseMs <= 0)
+            return [];
+        const now = input.now ?? Date.now();
+        return this.db.transaction(() => {
+            const rows = this.db.prepare(`
+        SELECT operation_id FROM devflow_task_outbox_v2
+        WHERE project_root = ? AND (state = 'pending' OR (state = 'leased' AND lease_expires_at <= ?))
+        ORDER BY created_at ASC LIMIT ?
+      `).all(input.projectRoot, now, Math.min(1000, Math.floor(input.limit)));
+            const leased = [];
+            for (const row of rows) {
+                const changed = this.db.prepare(`
+          UPDATE devflow_task_outbox_v2
+          SET state='leased', lease_owner=?, lease_expires_at=?, fencing_token=fencing_token+1,
+              attempts=attempts+1, updated_at=?
+          WHERE operation_id=? AND (state='pending' OR (state='leased' AND lease_expires_at <= ?))
+        `).run(input.owner, now + input.leaseMs, now, row.operation_id, now).changes;
+                if (changed === 1)
+                    leased.push(this.getTaskOutbox(row.operation_id));
+            }
+            return leased;
+        });
+    }
+    completeTaskOutbox(operationId, owner, fencingToken, now = Date.now()) {
+        return this.db.prepare(`
+      UPDATE devflow_task_outbox_v2
+      SET state='completed', lease_owner=NULL, lease_expires_at=NULL, updated_at=?
+      WHERE operation_id=? AND state='leased' AND lease_owner=? AND fencing_token=?
+    `).run(now, operationId, owner, fencingToken).changes === 1;
+    }
+    getTaskOutbox(operationId) {
+        const row = this.db.prepare(`SELECT * FROM devflow_task_outbox_v2 WHERE operation_id = ?`)
+            .get(operationId);
+        if (!row)
+            return null;
+        return {
+            operationId: String(row.operation_id), eventId: String(row.event_id), projectRoot: String(row.project_root),
+            sessionId: String(row.session_id), turnId: String(row.turn_id), revision: Number(row.revision),
+            kind: String(row.kind), payload: JSON.parse(String(row.payload_json)),
+            state: row.state,
+            ...(row.lease_owner ? { leaseOwner: String(row.lease_owner) } : {}),
+            ...(row.lease_expires_at != null ? { leaseExpiresAt: Number(row.lease_expires_at) } : {}),
+            fencingToken: Number(row.fencing_token), attempts: Number(row.attempts),
+            createdAt: Number(row.created_at), updatedAt: Number(row.updated_at),
+        };
+    }
+    putTaskDefinitionV2(definition, createdAt) {
+        const existing = this.getTaskDefinitionV2(definition.definitionHash);
+        if (existing) {
+            if ((0, task_runtime_1.stableTaskRuntimeJson)(existing) !== (0, task_runtime_1.stableTaskRuntimeJson)(definition)) {
+                throw new Error('TASK_DEFINITION_HASH_CONFLICT');
+            }
+            return;
+        }
+        this.db.prepare(`
+      INSERT INTO devflow_task_definitions_v2 (
+        definition_hash, project_root, session_id, turn_id, revision, definition_json, created_at
+      ) VALUES (?, ?, ?, ?, ?, ?, ?)
+    `).run(definition.definitionHash, definition.identity.projectRoot, definition.identity.sessionId, definition.identity.turnId, definition.revision, (0, task_runtime_1.stableTaskRuntimeJson)(definition), createdAt);
+    }
     getTerminalTransition(receiptId) {
         const row = this.db.prepare(`
       SELECT * FROM devflow_terminal_transitions WHERE receipt_id = ?
@@ -3716,7 +4149,7 @@ class DevFlowDatabase {
             executionId: row.execution_id ?? undefined, turnId: row.turn_id ?? undefined,
             requestId: row.request_id, contextReceipt: row.context_receipt,
             schemaVersion: row.schema_version ?? 'retrieval-ledger-event.v1',
-            sourceType: row.source_type, sourceId: row.source_id, stage: row.stage === 'adopted' ? 'consumed' : row.stage,
+            sourceType: row.source_type, sourceId: row.source_id, stage: row.stage,
             taskSpecHash: row.task_spec_hash ?? undefined, actor: row.actor ?? undefined,
             sourceVersion: row.source_version ?? undefined, sourceContentHash: row.source_content_hash ?? undefined,
             evidenceIds: parseJsonStringArray(row.evidence_ids), reasonCode: row.reason_code ?? undefined,
@@ -4705,3 +5138,28 @@ function sameTaskIdentity(left, right) {
         && left.requestId === right.requestId
         && left.executionId === right.executionId;
 }
+function mapRetrievalSessionV2(row) {
+    const executionId = typeof row.execution_id === 'string' ? row.execution_id.trim() : '';
+    if (!executionId)
+        throw new Error('RETRIEVAL_SESSION_IDENTITY_INVALID:execution_id');
+    return {
+        id: String(row.id),
+        identity: {
+            projectRoot: String(row.project_root), projectId: String(row.project_id),
+            hostId: String(row.host_id), sessionId: String(row.task_session_id),
+            turnId: String(row.turn_id), requestId: String(row.request_id),
+            executionId,
+        },
+        taskRevision: Number(row.task_revision),
+        factsHash: String(row.facts_hash),
+        planHash: String(row.plan_hash),
+        activationSnapshotHash: String(row.activation_snapshot_hash),
+        coordinatorVersion: String(row.coordinator_version),
+        state: row.state,
+        cycle: Number(row.cycle), noGainCount: Number(row.no_gain_count), maxCycles: 3,
+        initialTokenBudget: Number(row.initial_token_budget),
+        remainingTokenBudget: Number(row.remaining_token_budget),
+        ...(row.final_receipt_hash ? { finalReceiptHash: String(row.final_receipt_hash) } : {}),
+        createdAt: Number(row.created_at), updatedAt: Number(row.updated_at), expiresAt: Number(row.expires_at),
+    };
+}