@deksden-com/dd-flow-cli 0.2.0 → 0.3.1

package/dist/services/lanes.js

@@ -11,15 +11,20 @@ const defaultPollIntervalSeconds = 10;
 export function getLaneStatus(context, input) {
     const project = requireProjectByRoot(context, resolveProjectRoot(input.projectRoot));
     expireStaleLocks(context, project.id);
+    expireStaleWaiters(context, project.id);
     return {
         ok: true,
         lanes: lanesForProject(context, project.id, input.lane),
-        locks: laneLocksForProject(context, project.id, input.lane)
+        locks: laneLocksForProject(context, project.id, input.lane),
+        waiters: laneWaitersForProject(context, project.id, input.lane)
     };
 }
 export function expireProjectLaneLocks(context, projectId) {
     expireStaleLocks(context, projectId);
 }
+export function expireProjectLaneWaiters(context, projectId) {
+    expireStaleWaiters(context, projectId);
+}
 export function setLaneWorkspace(context, input) {
     const project = requireProjectByRoot(context, resolveProjectRoot(input.projectRoot));
     const lane = normalizeLane(input.lane);
@@ -172,6 +177,124 @@ export async function waitForLaneLock(context, input) {
         await delay(pollIntervalSeconds * 1000);
     }
 }
+export function getLaneWaiters(context, input) {
+    const project = requireProjectByRoot(context, resolveProjectRoot(input.projectRoot));
+    expireStaleLocks(context, project.id);
+    expireStaleWaiters(context, project.id);
+    return {
+        ok: true,
+        lane: input.lane ? normalizeLane(input.lane) : null,
+        waiters: laneWaitersForProject(context, project.id, input.lane).map((waiter) => ({
+            ...waiter,
+            position: waiter.status === "queued" ? queuedWaiterPosition(context, project.id, waiter.lane, waiter.id) : null
+        }))
+    };
+}
+export function cancelLaneWaiter(context, input) {
+    const project = requireProjectByRoot(context, resolveProjectRoot(input.projectRoot));
+    const lane = normalizeLane(input.lane);
+    const reason = input.reason.trim();
+    if (!reason) {
+        throw new AppError("validation", "lane waiter cancel requires --reason", 2);
+    }
+    expireStaleWaiters(context, project.id);
+    const now = context.now();
+    const waiter = activeLaneWaiterForWorker(context, project.id, lane, input.workerId);
+    if (!waiter) {
+        return { ok: true, cancelled: false, reason: "no_queued_waiter", lane, worker_id: input.workerId };
+    }
+    context.db.run(`UPDATE lane_waiters
+     SET status = 'cancelled', cancelled_at = ?, reason = ?, updated_at = ?
+     WHERE id = ? AND status = 'queued'`, [now, reason, now, waiter.id]);
+    appendAudit(context, {
+        projectId: project.id,
+        eventType: "lane_waiter.cancelled",
+        reason,
+        payload: { project_id: project.id, lane, worker_id: input.workerId, waiter_id: waiter.id }
+    });
+    return { ok: true, cancelled: true, waiter: laneWaiterById(context, waiter.id) };
+}
+export function cancelLaneWaitersForWorker(context, input) {
+    const project = requireProjectByRoot(context, resolveProjectRoot(input.projectRoot));
+    const now = context.now();
+    const waiters = context.db.all("SELECT * FROM lane_waiters WHERE project_id = ? AND worker_id = ? AND status = 'queued' ORDER BY id ASC", [project.id, input.workerId]);
+    if (waiters.length === 0) {
+        return { ok: true, cancelled: 0 };
+    }
+    context.db.run(`UPDATE lane_waiters
+     SET status = 'cancelled', cancelled_at = ?, reason = ?, updated_at = ?
+     WHERE project_id = ? AND worker_id = ? AND status = 'queued'`, [now, input.reason, now, project.id, input.workerId]);
+    appendAudit(context, {
+        projectId: project.id,
+        eventType: "lane_waiter.cancelled_for_worker",
+        reason: input.reason,
+        payload: { project_id: project.id, worker_id: input.workerId, waiter_ids: waiters.map((waiter) => waiter.id) }
+    });
+    return { ok: true, cancelled: waiters.length, waiter_ids: waiters.map((waiter) => waiter.id) };
+}
+export function expireLaneWaiterById(context, input) {
+    const project = requireProjectByRoot(context, resolveProjectRoot(input.projectRoot));
+    const now = context.now();
+    const result = context.db.run(`UPDATE lane_waiters
+     SET status = 'expired', reason = ?, updated_at = ?
+     WHERE project_id = ? AND id = ? AND status = 'queued'`, [input.reason, now, project.id, input.waiterId]);
+    if (result.changes === 1) {
+        appendAudit(context, {
+            projectId: project.id,
+            eventType: "lane_waiter.expired",
+            reason: input.reason,
+            payload: { project_id: project.id, waiter_id: input.waiterId }
+        });
+    }
+    return { ok: true, expired: result.changes === 1, waiter_id: input.waiterId };
+}
+export async function waitAcquireLaneLock(context, input) {
+    const project = requireProjectByRoot(context, resolveProjectRoot(input.projectRoot));
+    const lane = normalizeLane(input.lane);
+    requireMatchingLaneWorkspace(context, project.id, lane, input.workspacePath);
+    assertWorkerMayAcquireLaneLock(context, project.id, lane, input.workerId);
+    const timeoutSeconds = normalizeNonNegativeNumber(input.timeoutSeconds, 0, "timeout");
+    const pollIntervalSeconds = normalizePositiveNumber(input.pollIntervalSeconds, defaultPollIntervalSeconds, "poll-interval");
+    const ttlSeconds = normalizePositiveNumber(input.ttlSeconds, defaultTtlSeconds, "ttl");
+    const startedAt = Date.now();
+    const waiterDeadline = timeoutSeconds > 0 ? new Date(startedAt + timeoutSeconds * 1000).toISOString() : null;
+    while (true) {
+        const result = tryAcquireQueuedLaneLock(context, {
+            projectRoot: project.root,
+            projectId: project.id,
+            lane,
+            workerId: input.workerId,
+            workspacePath: input.workspacePath,
+            ttlSeconds,
+            reason: input.reason,
+            waiterDeadline,
+            invocationStartedAt: new Date(startedAt).toISOString()
+        });
+        if (result.acquired) {
+            return result.payload;
+        }
+        if (result.payload.status === "expired" && timeoutSeconds > 0 && Date.now() - startedAt >= timeoutSeconds * 1000) {
+            return markLaneWaiterTimedOut(context, {
+                projectId: project.id,
+                lane,
+                workerId: input.workerId,
+                timeoutSeconds
+            });
+        }
+        if (result.payload.status === "cancelled" || result.payload.status === "expired") {
+            return result.payload;
+        }
+        if (timeoutSeconds > 0 && Date.now() - startedAt >= timeoutSeconds * 1000) {
+            return markLaneWaiterTimedOut(context, {
+                projectId: project.id,
+                lane,
+                workerId: input.workerId,
+                timeoutSeconds
+            });
+        }
+        await delay(pollIntervalSeconds * 1000);
+    }
+}
 export function requireLaneLockOwner(context, input) {
     const project = requireProjectByRoot(context, resolveProjectRoot(input.projectRoot));
     const lane = normalizeLane(input.lane);
@@ -236,12 +359,85 @@ function laneLocksForProject(context, projectId, lane) {
     }
     return context.db.all(`SELECT * FROM lane_locks WHERE project_id = ? ORDER BY updated_at DESC, id DESC LIMIT 50`, [projectId]);
 }
+function laneWaitersForProject(context, projectId, lane) {
+    if (lane) {
+        return context.db.all(`SELECT * FROM lane_waiters
+       WHERE project_id = ? AND lane = ?
+       ORDER BY
+         CASE status WHEN 'queued' THEN 0 ELSE 1 END ASC,
+         CASE status WHEN 'queued' THEN queued_at ELSE updated_at END ASC,
+         id ASC
+       LIMIT 50`, [projectId, normalizeLane(lane)]);
+    }
+    return context.db.all(`SELECT * FROM lane_waiters
+     WHERE project_id = ?
+     ORDER BY
+       CASE status WHEN 'queued' THEN 0 ELSE 1 END ASC,
+       CASE status WHEN 'queued' THEN queued_at ELSE updated_at END ASC,
+       id ASC
+     LIMIT 100`, [projectId]);
+}
 function activeLaneLock(context, projectId, lane) {
     expireStaleLocks(context, projectId);
     return context.db.get(`SELECT * FROM lane_locks
      WHERE project_id = ? AND lane = ? AND status = 'active'
      ORDER BY updated_at DESC, id DESC LIMIT 1`, [projectId, lane]);
 }
+function activeLaneWaiterForWorker(context, projectId, lane, workerId) {
+    return context.db.get(`SELECT * FROM lane_waiters
+     WHERE project_id = ? AND lane = ? AND worker_id = ? AND status = 'queued'
+     ORDER BY id ASC LIMIT 1`, [projectId, lane, workerId]);
+}
+function latestLaneWaiterForWorker(context, projectId, lane, workerId) {
+    return context.db.get(`SELECT * FROM lane_waiters
+     WHERE project_id = ? AND lane = ? AND worker_id = ?
+     ORDER BY id DESC LIMIT 1`, [projectId, lane, workerId]);
+}
+function firstQueuedLaneWaiter(context, projectId, lane) {
+    return context.db.get(`SELECT * FROM lane_waiters
+     WHERE project_id = ? AND lane = ? AND status = 'queued'
+     ORDER BY queued_at ASC, id ASC LIMIT 1`, [projectId, lane]);
+}
+function laneWaiterById(context, id) {
+    return context.db.get("SELECT * FROM lane_waiters WHERE id = ?", [id]);
+}
+function queuedWaiterPosition(context, projectId, lane, waiterId) {
+    const waiters = context.db.all(`SELECT id FROM lane_waiters
+     WHERE project_id = ? AND lane = ? AND status = 'queued'
+     ORDER BY queued_at ASC, id ASC`, [projectId, lane]);
+    const index = waiters.findIndex((waiter) => waiter.id === waiterId);
+    return index >= 0 ? index + 1 : null;
+}
+function markLaneWaiterTimedOut(context, input) {
+    const now = context.now();
+    const latest = latestLaneWaiterForWorker(context, input.projectId, input.lane, input.workerId);
+    if (latest && ["queued", "expired"].includes(latest.status)) {
+        context.db.run(`UPDATE lane_waiters
+       SET status = 'timed_out', reason = ?, updated_at = ?
+       WHERE id = ? AND status IN ('queued', 'expired')`, ["lane lock wait-acquire timeout", now, latest.id]);
+    }
+    appendAudit(context, {
+        projectId: input.projectId,
+        eventType: "lane_waiter.wait_timeout",
+        payload: {
+            project_id: input.projectId,
+            lane: input.lane,
+            worker_id: input.workerId,
+            timeout_seconds: input.timeoutSeconds,
+            waiter_id: latest?.id ?? null
+        }
+    });
+    return {
+        ok: true,
+        acquired: false,
+        status: "timed_out",
+        timed_out: true,
+        lane: input.lane,
+        worker_id: input.workerId,
+        waiter: latestLaneWaiterForWorker(context, input.projectId, input.lane, input.workerId) ?? null,
+        lock: activeLaneLock(context, input.projectId, input.lane) ?? null
+    };
+}
 function requireOwnedActiveLock(context, projectId, lane, workerId, leaseToken) {
     const lock = activeLaneLock(context, projectId, lane);
     if (!lock) {
@@ -288,6 +484,142 @@ function expireStaleLocks(context, projectId) {
      SET status = 'expired', updated_at = ?
      WHERE project_id = ? AND status = 'active' AND expires_at <= ?`, [now, projectId, now]);
 }
+function expireStaleWaiters(context, projectId) {
+    const now = context.now();
+    context.db.run(`UPDATE lane_waiters
+     SET status = 'expired', updated_at = ?
+     WHERE project_id = ? AND status = 'queued' AND expires_at IS NOT NULL AND expires_at <= ?`, [now, projectId, now]);
+}
+function ensureQueuedLaneWaiter(context, input) {
+    const existing = activeLaneWaiterForWorker(context, input.projectId, input.lane, input.workerId);
+    if (existing) {
+        return existing;
+    }
+    const now = context.now();
+    context.db.run(`INSERT INTO lane_waiters
+      (project_id, lane, worker_id, status, queued_at, acquired_at, cancelled_at,
+       expires_at, reason, metadata_json, created_at, updated_at)
+     VALUES (?, ?, ?, 'queued', ?, NULL, NULL, ?, ?, '{}', ?, ?)`, [input.projectId, input.lane, input.workerId, now, input.expiresAt, input.reason, now, now]);
+    const waiter = activeLaneWaiterForWorker(context, input.projectId, input.lane, input.workerId);
+    if (!waiter) {
+        throw new AppError("lane_waiter_create_failed", "Failed to create lane waiter", 1, {
+            lane: input.lane,
+            worker_id: input.workerId
+        });
+    }
+    appendAudit(context, {
+        projectId: input.projectId,
+        eventType: "lane_waiter.queued",
+        reason: input.reason,
+        payload: { project_id: input.projectId, lane: input.lane, worker_id: input.workerId, waiter_id: waiter.id }
+    });
+    return waiter;
+}
+function tryAcquireQueuedLaneLock(context, input) {
+    expireStaleLocks(context, input.projectId);
+    expireStaleWaiters(context, input.projectId);
+    context.db.exec("BEGIN IMMEDIATE");
+    try {
+        const existingLock = activeLaneLock(context, input.projectId, input.lane);
+        if (existingLock?.worker_id === input.workerId) {
+            context.db.exec("COMMIT");
+            return {
+                acquired: true,
+                payload: {
+                    ok: true,
+                    acquired: true,
+                    status: "acquired",
+                    lane: input.lane,
+                    worker_id: input.workerId,
+                    waiter: null,
+                    lock: existingLock,
+                    reused: true,
+                    position: 0
+                }
+            };
+        }
+        const latest = latestLaneWaiterForWorker(context, input.projectId, input.lane, input.workerId);
+        if (latest && ["cancelled", "expired"].includes(latest.status) && latest.updated_at >= input.invocationStartedAt) {
+            context.db.exec("COMMIT");
+            return {
+                acquired: false,
+                payload: {
+                    ok: true,
+                    acquired: false,
+                    status: latest.status,
+                    lane: input.lane,
+                    worker_id: input.workerId,
+                    waiter: latest,
+                    lock: existingLock ?? null,
+                    position: null
+                }
+            };
+        }
+        const waiter = ensureQueuedLaneWaiter(context, {
+            projectId: input.projectId,
+            lane: input.lane,
+            workerId: input.workerId,
+            reason: input.reason,
+            expiresAt: input.waiterDeadline
+        });
+        const head = firstQueuedLaneWaiter(context, input.projectId, input.lane);
+        if (!existingLock && head?.id === waiter.id) {
+            const lockResult = acquireLaneLock(context, {
+                projectRoot: input.projectRoot,
+                lane: input.lane,
+                workerId: input.workerId,
+                workspacePath: input.workspacePath,
+                ttlSeconds: input.ttlSeconds,
+                reason: input.reason
+            });
+            const now = context.now();
+            context.db.run(`UPDATE lane_waiters
+         SET status = 'acquired', acquired_at = ?, updated_at = ?
+         WHERE id = ? AND status = 'queued'`, [now, now, waiter.id]);
+            const acquiredWaiter = laneWaiterById(context, waiter.id);
+            appendAudit(context, {
+                projectId: input.projectId,
+                eventType: "lane_waiter.acquired",
+                reason: input.reason,
+                payload: { project_id: input.projectId, lane: input.lane, worker_id: input.workerId, waiter_id: waiter.id }
+            });
+            context.db.exec("COMMIT");
+            return {
+                acquired: true,
+                payload: {
+                    ok: true,
+                    acquired: true,
+                    status: "acquired",
+                    lane: input.lane,
+                    worker_id: input.workerId,
+                    waiter: acquiredWaiter,
+                    lock: lockResult.lock,
+                    reused: lockResult.reused,
+                    position: 0
+                }
+            };
+        }
+        const position = queuedWaiterPosition(context, input.projectId, input.lane, waiter.id);
+        context.db.exec("COMMIT");
+        return {
+            acquired: false,
+            payload: {
+                ok: true,
+                acquired: false,
+                status: "queued",
+                lane: input.lane,
+                worker_id: input.workerId,
+                waiter,
+                lock: existingLock ?? null,
+                position
+            }
+        };
+    }
+    catch (error) {
+        context.db.exec("ROLLBACK");
+        throw error;
+    }
+}
 function resolveExistingPath(value) {
     const absolute = path.resolve(value);
     if (!fs.existsSync(absolute)) {

package/dist/services/merge-queue.js

@@ -2,9 +2,9 @@ import { loadProjectFlowContract } from "../domain/flow-contract.js";
 import { AppError } from "../shared/errors.js";
 import { appendAudit } from "./audit.js";
 import { requireProjectByRoot } from "./projects.js";
-import { persistProtocolState, readProtocolRuntimeState, requireProtocol } from "./protocols.js";
+import { persistProtocolState, protocolRunDiagnostics, readProtocolRuntimeState, requireProtocol } from "./protocols.js";
 import { resolveProjectRoot } from "../storage/paths.js";
-import { acquireLaneLock, ensureLaneWorkspace, heartbeatLaneLock, releaseLaneLock, requireLaneLockOwner } from "./lanes.js";
+import { ensureLaneWorkspace, heartbeatLaneLock, releaseLaneLock, requireLaneLockOwner, waitAcquireLaneLock } from "./lanes.js";
 import { stopMergeWorker, stoppedMergeWorkerState } from "./sessions.js";
 const mergeLockTtlSeconds = 300;
 export function getMergeQueueStatus(context, input) {
@@ -40,14 +40,14 @@ export function claimNextMergeJob(context, input) {
        LIMIT 1`, [project.id]);
         if (!job) {
             context.db.exec("COMMIT");
-            return { ok: true, job: null };
+            return mergeQueueResult(null, { ok: true, outcome: "empty", claimed: false });
         }
         const update = context.db.run(`UPDATE merge_queue
        SET status = 'claimed', claimed_by_session_id = ?, claimed_at = ?, updated_at = ?
        WHERE id = ? AND status IN ('ready', 'requeued')`, [input.workerId, now, now, job.id]);
         if (update.changes !== 1) {
             context.db.exec("COMMIT");
-            return { ok: true, job: null };
+            return mergeQueueResult(null, { ok: true, outcome: "empty", claimed: false });
         }
         appendAudit(context, {
             protocolId: job.protocol_id,
@@ -63,7 +63,11 @@ export function claimNextMergeJob(context, input) {
         context.db.exec("ROLLBACK");
         throw error;
     }
-    return { ok: true, job: claimedProtocolId ? queueJobByProtocol(context, claimedProtocolId) : null };
+    return mergeQueueResult(claimedProtocolId ? queueJobByProtocol(context, claimedProtocolId) : null, {
+        ok: true,
+        outcome: claimedProtocolId ? "claimed" : "empty",
+        claimed: Boolean(claimedProtocolId)
+    });
 }
 export async function waitNextMergeJob(context, input) {
     const project = requireProjectByRoot(context, resolveProjectRoot(input.projectRoot));
@@ -82,19 +86,43 @@ export async function waitNextMergeJob(context, input) {
     }
     const initialStopState = stoppedMergeWorkerState(context, project.id, input.workerId);
     if (initialStopState.stopped) {
-        return { ok: true, job: null, waited: false, timed_out: false, stopped: true, reason: initialStopState.reason };
+        return mergeQueueResult(null, {
+            ok: true,
+            outcome: "stopped",
+            wait_requested: input.acquireLock,
+            waited: false,
+            timed_out: false,
+            stopped: true,
+            reason: initialStopState.reason
+        });
     }
     let releaseLockOnTimeout = false;
     if (input.acquireLock) {
         ensureLaneWorkspace(context, { projectRoot: project.root, lane: "merge", workspacePath: input.workspacePath });
-        const lockResult = acquireLaneLock(context, {
+        const lockResult = (await waitAcquireLaneLock(context, {
             projectRoot: project.root,
             lane: "merge",
             workerId: input.workerId,
             workspacePath: input.workspacePath,
             ttlSeconds: mergeLockTtlSeconds,
+            timeoutSeconds,
+            pollIntervalSeconds,
             reason: "merge queue wait-next"
-        });
+        }));
+        if (!lockResult.acquired) {
+            const outcome = lockResult.timed_out ? "wait_timeout" : "blocked";
+            return mergeQueueResult(null, {
+                ok: true,
+                outcome,
+                wait_requested: true,
+                waited: true,
+                timed_out: Boolean(lockResult.timed_out),
+                lane_waiter: lockResult.waiter ?? null,
+                lane_lock: lockResult.lock ?? null,
+                lane_waiter_status: lockResult.status ?? null,
+                position: lockResult.position ?? null
+            });
+        }
         releaseLockOnTimeout = !lockResult.reused;
     }
     else {
@@ -124,7 +152,15 @@ export async function waitNextMergeJob(context, input) {
                 ...(stopState.reason ? { reason: stopState.reason } : {}),
                 payload: { project_id: project.id, worker_id: input.workerId }
             });
-            return { ok: true, job: null, waited: true, timed_out: false, stopped: true, reason: stopState.reason };
+            return mergeQueueResult(null, {
+                ok: true,
+                outcome: "stopped",
+                wait_requested: input.acquireLock,
+                waited: true,
+                timed_out: false,
+                stopped: true,
+                reason: stopState.reason
+            });
         }
         if (input.acquireLock) {
             heartbeatLaneLock(context, {
@@ -141,7 +177,14 @@ export async function waitNextMergeJob(context, input) {
             workspacePath: input.workspacePath
         });
         if (claimed.job) {
-            return { ...claimed, waited: true, timed_out: false };
+            return {
+                ...claimed,
+                outcome: "claimed",
+                claimed: true,
+                wait_requested: input.acquireLock,
+                waited: true,
+                timed_out: false
+            };
         }
         if (timeoutSeconds > 0 && Date.now() - start >= timeoutSeconds * 1000) {
             appendAudit(context, {
@@ -158,7 +201,13 @@ export async function waitNextMergeJob(context, input) {
                     reason: "merge queue wait-next timeout"
                 });
             }
-            return { ok: true, job: null, waited: true, timed_out: true };
+            return mergeQueueResult(null, {
+                ok: true,
+                outcome: "wait_timeout",
+                wait_requested: input.acquireLock,
+                waited: true,
+                timed_out: true
+            });
         }
         await delay(pollIntervalSeconds * 1000);
     }
@@ -194,7 +243,13 @@ export function completeMergeJob(context, input) {
         payload: { protocol_id: protocol.id, worker_id: input.workerId, summary: input.summary, flow_contract_id: flowContract.id }
     });
     const stop_after_current = stopAfterCurrentIfRequested(context, protocol.project_id, protocol.project_root, input.workerId, "merge complete after stop request");
-    return { ok: true, job: queueJobByProtocol(context, protocol.id), next_stage: targetStage, stop_after_current };
+    return mergeQueueResult(queueJobByProtocol(context, protocol.id), {
+        ok: true,
+        outcome: "merged",
+        merged: true,
+        next_stage: targetStage,
+        stop_after_current
+    });
 }
 export function noteMergeJob(context, input) {
     const protocol = requireProtocol(context, input.protocolId);
@@ -224,7 +279,7 @@ export function noteMergeJob(context, input) {
         eventType: "merge_queue.note",
         payload: { protocol_id: protocol.id, worker_id: input.workerId, summary: input.summary }
     });
-    return { ok: true, job: queueJobByProtocol(context, protocol.id) };
+    return mergeQueueResult(queueJobByProtocol(context, protocol.id), { ok: true, outcome: "noted" });
 }
 export function failMergeJob(context, input) {
     const protocol = requireProtocol(context, input.protocolId);
@@ -258,7 +313,11 @@ export function failMergeJob(context, input) {
         payload: { protocol_id: protocol.id, worker_id: input.workerId, requeue: input.requeue }
     });
     const stop_after_current = stopAfterCurrentIfRequested(context, protocol.project_id, protocol.project_root, input.workerId, "merge fail after stop request");
-    return { ok: true, job: queueJobByProtocol(context, protocol.id), stop_after_current };
+    return mergeQueueResult(queueJobByProtocol(context, protocol.id), {
+        ok: true,
+        outcome: input.requeue ? "requeued" : "failed",
+        stop_after_current
+    });
 }
 export function cancelMergeQueueJob(context, input) {
     const protocol = requireProtocol(context, input.protocolId);
@@ -275,7 +334,7 @@ export function cancelMergeQueueJob(context, input) {
         }
         if (job.status === "cancelled") {
             context.db.exec("COMMIT");
-            return { ok: true, job, cancelled: false, reason: "already_cancelled" };
+            return mergeQueueResult(job, { ok: true, outcome: "cancelled", cancelled: false, reason: "already_cancelled" });
         }
         if (job.status === "claimed" && !input.force) {
             if (!input.workerId) {
@@ -317,7 +376,7 @@ export function cancelMergeQueueJob(context, input) {
         context.db.exec("ROLLBACK");
         throw error;
     }
-    return { ok: true, job: queueJobByProtocol(context, protocol.id), cancelled: true };
+    return mergeQueueResult(queueJobByProtocol(context, protocol.id), { ok: true, outcome: "cancelled", cancelled: true });
 }
 export function queueForProject(context, projectId) {
     return context.db.all(`SELECT * FROM merge_queue WHERE project_id = ? ORDER BY created_at ASC, id ASC`, [projectId]);
@@ -325,6 +384,29 @@ export function queueForProject(context, projectId) {
 function queueJobByProtocol(context, protocolId) {
     return context.db.get("SELECT * FROM merge_queue WHERE protocol_id = ?", [protocolId]);
 }
+function mergeQueueResult(job, extra) {
+    const queueItem = job ?? null;
+    return {
+        ...extra,
+        queue_item: queueItem,
+        protocol: queueItem
+            ? {
+                id: queueItem.protocol_id,
+                queue_status: queueItem.status,
+                project_id: queueItem.project_id
+            }
+            : null,
+        claim: queueItem?.claimed_by_session_id
+            ? {
+                protocol_id: queueItem.protocol_id,
+                worker_id: queueItem.claimed_by_session_id,
+                claimed_at: queueItem.claimed_at,
+                status: queueItem.status
+            }
+            : null,
+        job: queueItem
+    };
+}
 function requireClaimedJob(context, protocolId, sessionId) {
     const job = queueJobByProtocol(context, protocolId);
     if (!job || job.status !== "claimed") {
@@ -349,6 +431,14 @@ function transitionClaimedProtocolToIntegration(context, protocolId, workerId, n
             allowed: ["ready_for_merge", "queued_for_merge"]
         });
     }
+    const diagnostics = protocolRunDiagnostics(context, protocol, state).diagnostics;
+    const blockingDiagnostics = diagnostics.filter((diagnostic) => diagnostic.severity === "error");
+    if (blockingDiagnostics.length > 0) {
+        throw new AppError("merge_protocol_run_mismatch", "Cannot claim a protocol while protocol and run evidence disagree", 1, {
+            protocol_id: protocolId,
+            diagnostics: blockingDiagnostics
+        });
+    }
     persistProtocolState(context, protocol, {
         ...state,
         stage: "integration",