@deksden-com/dd-flow-cli 0.3.0 → 0.4.0

package/dist/services/merge-queue.js

@@ -4,8 +4,9 @@ import { appendAudit } from "./audit.js";
 import { requireProjectByRoot } from "./projects.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";
+import { getProtocolBranchContext, requireClaimableBranchBundle } from "./branch-context.js";
 const mergeLockTtlSeconds = 300;
 export function getMergeQueueStatus(context, input) {
     const project = requireProjectByRoot(context, resolveProjectRoot(input.projectRoot));
@@ -14,6 +15,9 @@ export function getMergeQueueStatus(context, input) {
         queue: queueForProject(context, project.id)
     };
 }
+export function getMergeBundleStatus(context, input) {
+    return getProtocolBranchContext(context, { projectRoot: input.projectRoot, workspacePath: input.workspacePath });
+}
 export function claimNextMergeJob(context, input) {
     const project = requireProjectByRoot(context, resolveProjectRoot(input.projectRoot));
     const stopState = stoppedMergeWorkerState(context, project.id, input.workerId);
@@ -40,14 +44,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 +67,72 @@ 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 function claimMergeBundle(context, input) {
+    const { project, protocolIds } = requireClaimableBranchBundle(context, {
+        projectRoot: input.projectRoot,
+        workspacePath: input.workspacePath
+    });
+    const stopState = stoppedMergeWorkerState(context, project.id, input.workerId);
+    if (stopState.stopped) {
+        throw new AppError("merge_worker_stopped", "Stopped or stopping merge worker cannot claim a merge bundle", 1, {
+            worker_id: input.workerId,
+            status: stopState.status,
+            reason: stopState.reason
+        });
+    }
+    requireLaneLockOwner(context, {
+        projectRoot: project.root,
+        lane: "merge",
+        workerId: input.workerId,
+        workspacePath: input.workspacePath
+    });
+    const now = context.now();
+    context.db.exec("BEGIN IMMEDIATE");
+    try {
+        for (const protocolId of protocolIds) {
+            const update = context.db.run(`UPDATE merge_queue
+         SET status = 'claimed', claimed_by_session_id = ?, claimed_at = ?, updated_at = ?
+         WHERE protocol_id = ? AND project_id = ? AND status IN ('ready', 'requeued')`, [input.workerId, now, now, protocolId, project.id]);
+            if (update.changes !== 1) {
+                throw new AppError("merge_bundle_claim_race", "Branch bundle changed while claiming", 1, {
+                    protocol_id: protocolId,
+                    protocol_ids: protocolIds
+                });
+            }
+            transitionClaimedProtocolToIntegration(context, protocolId, input.workerId, now);
+            appendAudit(context, {
+                protocolId,
+                projectId: project.id,
+                eventType: "merge_bundle.claimed_protocol",
+                payload: { protocol_id: protocolId, worker_id: input.workerId, protocol_ids: protocolIds }
+            });
+        }
+        appendAudit(context, {
+            projectId: project.id,
+            eventType: "merge_bundle.claimed",
+            payload: { project_id: project.id, worker_id: input.workerId, protocol_ids: protocolIds, workspace_path: input.workspacePath }
+        });
+        context.db.exec("COMMIT");
+    }
+    catch (error) {
+        context.db.exec("ROLLBACK");
+        throw error;
+    }
+    return mergeBundleResult(context, {
+        ok: true,
+        outcome: "claimed",
+        claimed: true,
+        projectRoot: project.root,
+        workspacePath: input.workspacePath,
+        workerId: input.workerId,
+        protocolIds
+    });
 }
 export async function waitNextMergeJob(context, input) {
     const project = requireProjectByRoot(context, resolveProjectRoot(input.projectRoot));
@@ -82,19 +151,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 +217,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 +242,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 +266,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 +308,78 @@ 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 completeMergeBundle(context, input) {
+    const project = requireProjectByRoot(context, resolveProjectRoot(input.projectRoot));
+    requireLaneLockOwner(context, {
+        projectRoot: project.root,
+        lane: "merge",
+        workerId: input.workerId,
+        workspacePath: input.workspacePath
+    });
+    const protocolIds = claimedBundleProtocolIds(context, { projectRoot: project.root, workspacePath: input.workspacePath, workerId: input.workerId });
+    if (protocolIds.length === 0) {
+        throw new AppError("merge_bundle_not_claimed", "No claimed protocols found for this branch bundle and worker", 1, {
+            worker_id: input.workerId,
+            workspace_path: input.workspacePath
+        });
+    }
+    const now = context.now();
+    context.db.exec("BEGIN IMMEDIATE");
+    try {
+        for (const protocolId of protocolIds) {
+            const protocol = requireProtocol(context, protocolId);
+            const job = requireClaimedJob(context, protocolId, input.workerId);
+            context.db.run(`UPDATE merge_queue
+         SET status = 'merged', last_reason = ?, completed_at = ?, updated_at = ?
+         WHERE id = ?`, [input.summary, now, now, job.id]);
+            const state = readProtocolRuntimeState(context, protocol).state;
+            const flowContract = loadProjectFlowContract(protocol.project_root);
+            const targetStage = flowContract.merge_queue.complete.target_stage;
+            const targetStatus = flowContract.stages[targetStage]?.terminal ? targetStage : "running";
+            persistProtocolState(context, protocol, {
+                ...state,
+                stage: targetStage,
+                status: targetStatus,
+                next_action: flowContract.merge_queue.complete.next_action,
+                updated_at: now
+            });
+            appendAudit(context, {
+                protocolId,
+                projectId: project.id,
+                eventType: "merge_bundle.completed_protocol",
+                payload: { protocol_id: protocolId, worker_id: input.workerId, summary: input.summary, protocol_ids: protocolIds }
+            });
+        }
+        appendAudit(context, {
+            projectId: project.id,
+            eventType: "merge_bundle.completed",
+            payload: { project_id: project.id, worker_id: input.workerId, summary: input.summary, protocol_ids: protocolIds }
+        });
+        context.db.exec("COMMIT");
+    }
+    catch (error) {
+        context.db.exec("ROLLBACK");
+        throw error;
+    }
+    const stop_after_current = stopAfterCurrentIfRequested(context, project.id, project.root, input.workerId, "merge bundle complete after stop request");
+    return mergeBundleResult(context, {
+        ok: true,
+        outcome: "merged",
+        merged: true,
+        projectRoot: project.root,
+        workspacePath: input.workspacePath,
+        workerId: input.workerId,
+        protocolIds,
+        stop_after_current
+    });
 }
 export function noteMergeJob(context, input) {
     const protocol = requireProtocol(context, input.protocolId);
@@ -224,7 +409,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 +443,77 @@ 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 failMergeBundle(context, input) {
+    const project = requireProjectByRoot(context, resolveProjectRoot(input.projectRoot));
+    requireLaneLockOwner(context, {
+        projectRoot: project.root,
+        lane: "merge",
+        workerId: input.workerId,
+        workspacePath: input.workspacePath
+    });
+    const protocolIds = claimedBundleProtocolIds(context, { projectRoot: project.root, workspacePath: input.workspacePath, workerId: input.workerId });
+    if (protocolIds.length === 0) {
+        throw new AppError("merge_bundle_not_claimed", "No claimed protocols found for this branch bundle and worker", 1, {
+            worker_id: input.workerId,
+            workspace_path: input.workspacePath
+        });
+    }
+    const now = context.now();
+    const status = input.requeue ? "requeued" : "failed";
+    context.db.exec("BEGIN IMMEDIATE");
+    try {
+        for (const protocolId of protocolIds) {
+            const protocol = requireProtocol(context, protocolId);
+            const job = requireClaimedJob(context, protocolId, input.workerId);
+            context.db.run(`UPDATE merge_queue
+         SET status = ?, attempts_count = attempts_count + 1, last_reason = ?, updated_at = ?
+         WHERE id = ?`, [status, input.reason, now, job.id]);
+            if (input.requeue) {
+                const state = readProtocolRuntimeState(context, protocol).state;
+                persistProtocolState(context, protocol, {
+                    ...state,
+                    stage: "ready_for_merge",
+                    status: "running",
+                    next_action: "merge_requeued",
+                    updated_at: now
+                });
+            }
+            appendAudit(context, {
+                protocolId,
+                projectId: project.id,
+                eventType: "merge_bundle.failed_protocol",
+                reason: input.reason,
+                payload: { protocol_id: protocolId, worker_id: input.workerId, requeue: input.requeue, protocol_ids: protocolIds }
+            });
+        }
+        appendAudit(context, {
+            projectId: project.id,
+            eventType: "merge_bundle.failed",
+            reason: input.reason,
+            payload: { project_id: project.id, worker_id: input.workerId, requeue: input.requeue, protocol_ids: protocolIds }
+        });
+        context.db.exec("COMMIT");
+    }
+    catch (error) {
+        context.db.exec("ROLLBACK");
+        throw error;
+    }
+    const stop_after_current = stopAfterCurrentIfRequested(context, project.id, project.root, input.workerId, "merge bundle fail after stop request");
+    return mergeBundleResult(context, {
+        ok: true,
+        outcome: input.requeue ? "requeued" : "failed",
+        projectRoot: project.root,
+        workspacePath: input.workspacePath,
+        workerId: input.workerId,
+        protocolIds,
+        stop_after_current
+    });
 }
 export function cancelMergeQueueJob(context, input) {
     const protocol = requireProtocol(context, input.protocolId);
@@ -275,7 +530,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 +572,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 +580,46 @@ 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 mergeBundleResult(context, input) {
+    const branchContext = getProtocolBranchContext(context, { projectRoot: input.projectRoot, workspacePath: input.workspacePath }).branch_context;
+    return {
+        ...input,
+        protocol_ids: input.protocolIds,
+        branch_context: branchContext,
+        queue_items: input.protocolIds.map((protocolId) => queueJobByProtocol(context, protocolId) ?? null)
+    };
+}
+function claimedBundleProtocolIds(context, input) {
+    const branchContext = getProtocolBranchContext(context, { projectRoot: input.projectRoot, workspacePath: input.workspacePath }).branch_context;
+    const protocols = Array.isArray(branchContext.protocols) ? branchContext.protocols : [];
+    return protocols
+        .filter((protocol) => protocol.queue_status === "claimed" && protocol.queue_claimed_by === input.workerId)
+        .map((protocol) => String(protocol.id))
+        .filter(Boolean);
+}
 function requireClaimedJob(context, protocolId, sessionId) {
     const job = queueJobByProtocol(context, protocolId);
     if (!job || job.status !== "claimed") {

package/dist/services/merge-worker.js

@@ -7,13 +7,17 @@ import { requireProjectByRoot } from "./projects.js";
 import { buildStaticFlowGuidance } from "./flow-guidance.js";
 import { readProtocolRuntimeState, requireProtocol } from "./protocols.js";
 import { registerFlowSession, stopMergeWorker } from "./sessions.js";
+import { getProtocolBranchContext } from "./branch-context.js";
 export function getMergeWorkerStatus(context, input) {
     const project = requireProjectByRoot(context, resolveProjectRoot(input.projectRoot));
     return {
         ok: true,
         project: { id: project.id, root: project.root },
         merge_worker: detectMergeWorkerState(context, project.id),
-        queue: queueForProject(context, project.id).map((job) => withJobGuidance(context, { ...job }))
+        queue: queueForProject(context, project.id).map((job) => withJobGuidance(context, { ...job })),
+        branch_context: input.workspacePath
+            ? getProtocolBranchContext(context, { projectRoot: project.root, workspacePath: input.workspacePath }).branch_context
+            : null
     };
 }
 export function startMergeWorker(context, input) {
@@ -21,7 +25,17 @@ export function startMergeWorker(context, input) {
     const workspacePath = resolveProjectRoot(input.workspacePath ?? project.root);
     const detection = detectMergeWorkerState(context, project.id);
     if (detection.state !== "clear") {
-        return { ok: true, started: false, reason: "merge_worker_already_active", merge_worker: detection, queue: queueForProject(context, project.id) };
+        return {
+            ok: true,
+            started: false,
+            claimed: false,
+            mode: "status_only",
+            outcome: "status_only",
+            reason: "merge_worker_already_active",
+            merge_worker: detection,
+            queue: queueForProject(context, project.id),
+            branch_context: getProtocolBranchContext(context, { projectRoot: project.root, workspacePath }).branch_context
+        };
     }
     ensureLaneWorkspace(context, { projectRoot: project.root, lane: "merge", workspacePath, branch: input.branch });
     const registered = registerFlowSession(context, {
@@ -82,7 +96,16 @@ export function oneShotMergeClaim(context, input) {
     const workspacePath = resolveProjectRoot(input.workspacePath ?? project.root);
     const detection = detectMergeWorkerState(context, project.id);
     if (detection.state !== "clear") {
-        return { ok: true, claimed: false, mode: "status_only", reason: "active_merge_worker_or_lock", merge_worker: detection, queue: queueForProject(context, project.id) };
+        return {
+            ok: true,
+            claimed: false,
+            mode: "status_only",
+            outcome: "status_only",
+            reason: "active_merge_worker_or_lock",
+            merge_worker: detection,
+            queue: queueForProject(context, project.id),
+            branch_context: getProtocolBranchContext(context, { projectRoot: project.root, workspacePath }).branch_context
+        };
     }
     ensureLaneWorkspace(context, { projectRoot: project.root, lane: "merge", workspacePath });
     const lock = acquireLaneLock(context, {
@@ -107,8 +130,26 @@ export function oneShotMergeClaim(context, input) {
         ok: true,
         claimed: Boolean(claimed.job),
         mode: "one_shot",
+        outcome: claimed.job ? "claimed" : "empty",
+        queue_item: claimed.job ? withJobGuidance(context, { ...claimed.job }) : null,
+        protocol: claimed.job
+            ? {
+                id: String(claimed.job.protocol_id ?? ""),
+                queue_status: String(claimed.job.status ?? ""),
+                project_id: String(claimed.job.project_id ?? "")
+            }
+            : null,
+        claim: claimed.job?.claimed_by_session_id
+            ? {
+                protocol_id: String(claimed.job.protocol_id ?? ""),
+                worker_id: String(claimed.job.claimed_by_session_id ?? ""),
+                claimed_at: claimed.job.claimed_at ?? null,
+                status: claimed.job.status ?? null
+            }
+            : null,
         job: claimed.job ? withJobGuidance(context, { ...claimed.job }) : null,
         lock: claimed.job ? lock.lock : null,
+        branch_context: getProtocolBranchContext(context, { projectRoot: project.root, workspacePath }).branch_context,
         flow_guidance: claimed.job ? withJobGuidance(context, { ...claimed.job }).flow_guidance : undefined
     };
 }