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

package/dist/services/canon.js

@@ -0,0 +1,227 @@
+import fs from "node:fs";
+import path from "node:path";
+import { spawnSync } from "node:child_process";
+const canonRootKey = "canon.root";
+export function registerCanonRoot(context, input) {
+    const resolution = resolveCanonRoot(context, { explicitRoot: input.root, allowRegistered: false });
+    if (!resolution.ok || !resolution.canon) {
+        return {
+            ...resolution,
+            action: "register",
+            exit_code: 1
+        };
+    }
+    const now = context.now();
+    context.db.run(`INSERT INTO runtime_config (key, value_json, created_at, updated_at)
+     VALUES (?, ?, ?, ?)
+     ON CONFLICT(key) DO UPDATE SET
+       value_json = excluded.value_json,
+       updated_at = excluded.updated_at`, [canonRootKey, JSON.stringify({ root: resolution.canon.root }), now, now]);
+    return {
+        ok: true,
+        action: "register",
+        canon: {
+            ...resolution.canon,
+            source: "registered"
+        },
+        db_path: context.db.path
+    };
+}
+export function getCanonStatus(context, input = {}) {
+    const resolution = resolveCanonRoot(context, { explicitRoot: input.root });
+    return {
+        ...resolution,
+        dd_flow_home: context.ddFlowHome,
+        registered: readRegisteredCanonRoot(context)
+    };
+}
+export function resolveCanonRoot(context, input = {}) {
+    const candidates = canonCandidates(context, input);
+    const validCandidates = candidates.filter((candidate) => candidate.valid && candidate.realpath);
+    const uniqueValid = uniqueBy(validCandidates, (candidate) => candidate.realpath ?? candidate.root);
+    const blockers = candidates.flatMap((candidate) => candidate.blockers);
+    if (uniqueValid.length === 1) {
+        const candidate = uniqueValid[0];
+        if (!candidate) {
+            throw new Error("Expected one canonical candidate.");
+        }
+        const root = candidate.realpath ?? candidate.root;
+        const metadata = readCanonMetadata(root);
+        return {
+            ok: true,
+            canon: {
+                root,
+                source: candidate.source,
+                flow_root: path.join(root, "dd-flow"),
+                memorybank_root: root,
+                version: metadata.version,
+                commit: metadata.commit,
+                flow_contract: metadata.flow_contract,
+                metadata
+            },
+            candidates,
+            blockers: [],
+            bootstrap: []
+        };
+    }
+    if (uniqueValid.length > 1) {
+        return {
+            ok: false,
+            exit_code: 1,
+            candidates,
+            blockers: [
+                "Multiple different canonical Memory Bank roots are configured. Pass --root explicitly or make DD_MEMORYBANK and the registered root point to the same checkout."
+            ],
+            bootstrap: [
+                "dd-flow canon register --root \"$DD_MEMORYBANK\" --json",
+                "dd-flow canon resolve --root /absolute/path/to/dd-memorybank --json"
+            ]
+        };
+    }
+    return {
+        ok: false,
+        exit_code: 1,
+        candidates,
+        blockers: blockers.length > 0 ? blockers : ["Canonical Memory Bank root is not configured."],
+        bootstrap: [
+            "Clone the canonical dd-memorybank repository locally.",
+            "export DD_MEMORYBANK=/absolute/path/to/dd-memorybank",
+            "dd-flow canon register --root \"$DD_MEMORYBANK\" --json"
+        ]
+    };
+}
+function canonCandidates(context, input) {
+    const candidates = [];
+    if (input.explicitRoot) {
+        candidates.push(validateCanonCandidate("explicit", input.explicitRoot));
+        return candidates;
+    }
+    if (context.env.DD_MEMORYBANK) {
+        candidates.push(validateCanonCandidate("env", context.env.DD_MEMORYBANK));
+    }
+    if (input.allowRegistered !== false) {
+        const registered = readRegisteredCanonRoot(context);
+        if (registered?.root) {
+            candidates.push(validateCanonCandidate("registered", registered.root));
+        }
+    }
+    for (const known of knownCanonRoots()) {
+        candidates.push(validateCanonCandidate("known", known));
+    }
+    return uniqueBy(candidates, (candidate) => `${candidate.source}:${candidate.root}`);
+}
+function validateCanonCandidate(source, root) {
+    const absolute = path.resolve(root);
+    const blockers = [];
+    let realpath = null;
+    if (!fs.existsSync(absolute)) {
+        return { source, root: absolute, realpath, valid: false, blockers: [`${source} canonical root does not exist: ${absolute}`] };
+    }
+    realpath = fs.realpathSync(absolute);
+    if (!fs.statSync(realpath).isDirectory()) {
+        blockers.push(`${source} canonical root is not a directory: ${realpath}`);
+    }
+    const requiredFiles = [
+        "dd-flow/README.md",
+        "mbb/index.md",
+        "protocol/index.md",
+        "dd-flow/mb-init.md",
+        "dd-flow/mb-upgrade.md",
+        "dd-flow/mb-upgrade-review.md",
+        "dd-flow/mb-distill.md"
+    ];
+    for (const relativePath of requiredFiles) {
+        const file = path.join(realpath, relativePath);
+        if (!fs.existsSync(file) || !fs.statSync(file).isFile()) {
+            blockers.push(`${source} canonical root is missing ${relativePath}: ${realpath}`);
+        }
+    }
+    return { source, root: absolute, realpath, valid: blockers.length === 0, blockers };
+}
+export function readCanonMetadata(root) {
+    const diagnostics = [];
+    const version = readTrimmed(path.join(root, "VERSION"));
+    if (!version)
+        diagnostics.push("canon_version_missing");
+    const commit = gitCommit(root);
+    if (!commit)
+        diagnostics.push("canon_commit_unknown");
+    const flowContract = readFlowContractId(root);
+    if (!flowContract)
+        diagnostics.push("flow_contract_unknown");
+    return {
+        version,
+        commit,
+        flow_contract: flowContract,
+        status: version && commit && flowContract ? "present" : diagnostics.length > 0 ? "degraded" : "unknown",
+        diagnostics
+    };
+}
+function readTrimmed(file) {
+    try {
+        const value = fs.readFileSync(file, "utf8").trim();
+        return value.length > 0 ? value : null;
+    }
+    catch {
+        return null;
+    }
+}
+function readFlowContractId(root) {
+    try {
+        const parsed = JSON.parse(fs.readFileSync(path.join(root, "dd-flow", "flow-contract.json"), "utf8"));
+        if (parsed && typeof parsed === "object" && !Array.isArray(parsed)) {
+            const id = parsed.id;
+            return typeof id === "string" && id.length > 0 ? id : null;
+        }
+    }
+    catch {
+        return null;
+    }
+    return null;
+}
+function gitCommit(root) {
+    const result = spawnSync("git", ["rev-parse", "HEAD"], { cwd: root, encoding: "utf8" });
+    return result.status === 0 ? result.stdout.trim() || null : null;
+}
+function readRegisteredCanonRoot(context) {
+    const row = context.db.get("SELECT key, value_json, updated_at FROM runtime_config WHERE key = ?", [canonRootKey]);
+    if (!row)
+        return null;
+    const value = JSON.parse(row.value_json);
+    return typeof value.root === "string" ? { root: value.root, updated_at: row.updated_at } : null;
+}
+function knownCanonRoots() {
+    const cwd = process.cwd();
+    const candidates = [];
+    for (const dir of ancestorDirs(cwd)) {
+        if (path.basename(dir) === "dd-memorybank") {
+            candidates.push(dir);
+        }
+        candidates.push(path.join(dir, "dd-memorybank"));
+    }
+    return uniqueBy(candidates.filter((candidate) => fs.existsSync(candidate)), (candidate) => fs.realpathSync(candidate));
+}
+function ancestorDirs(start) {
+    const dirs = [];
+    let current = path.resolve(start);
+    while (true) {
+        dirs.push(current);
+        const parent = path.dirname(current);
+        if (parent === current)
+            break;
+        current = parent;
+    }
+    return dirs;
+}
+function uniqueBy(items, keyFor) {
+    const seen = new Set();
+    const result = [];
+    for (const item of items) {
+        const key = keyFor(item);
+        if (!seen.has(key)) {
+            seen.add(key);
+            result.push(item);
+        }
+    }
+    return result;
+}

package/dist/services/lanes.js

@@ -17,6 +17,9 @@ export function getLaneStatus(context, input) {
         locks: laneLocksForProject(context, project.id, input.lane)
     };
 }
+export function expireProjectLaneLocks(context, projectId) {
+    expireStaleLocks(context, projectId);
+}
 export function setLaneWorkspace(context, input) {
     const project = requireProjectByRoot(context, resolveProjectRoot(input.projectRoot));
     const lane = normalizeLane(input.lane);
@@ -267,10 +270,11 @@ function assertWorkerMayAcquireLaneLock(context, projectId, lane, workerId) {
     const latest = context.db.get(`SELECT status, stop_reason, flow_kind FROM flow_sessions
      WHERE project_id = ? AND worker_id = ? AND flow_kind IN ('merge_worker', 'merge_job')
      ORDER BY updated_at DESC, rowid DESC LIMIT 1`, [projectId, workerId]);
-    if (latest?.status === "stopped") {
-        throw new AppError("merge_worker_stopped", "Stopped merge worker cannot acquire the merge lane lock until it registers a new active session", 1, {
+    if (latest && ["stopped", "stopping"].includes(latest.status)) {
+        throw new AppError("merge_worker_stopped", "Stopped or stopping merge worker cannot acquire the merge lane lock until it registers a new active session", 1, {
             worker_id: workerId,
             flow_kind: latest.flow_kind,
+            status: latest.status,
             stop_reason: latest.stop_reason
         });
     }

package/dist/services/merge-queue.js

@@ -5,7 +5,7 @@ import { requireProjectByRoot } from "./projects.js";
 import { persistProtocolState, readProtocolRuntimeState, requireProtocol } from "./protocols.js";
 import { resolveProjectRoot } from "../storage/paths.js";
 import { acquireLaneLock, ensureLaneWorkspace, heartbeatLaneLock, releaseLaneLock, requireLaneLockOwner } from "./lanes.js";
-import { stoppedMergeWorkerState } from "./sessions.js";
+import { stopMergeWorker, stoppedMergeWorkerState } from "./sessions.js";
 const mergeLockTtlSeconds = 300;
 export function getMergeQueueStatus(context, input) {
     const project = requireProjectByRoot(context, resolveProjectRoot(input.projectRoot));
@@ -16,6 +16,14 @@ export function getMergeQueueStatus(context, input) {
 }
 export function claimNextMergeJob(context, input) {
     const project = requireProjectByRoot(context, resolveProjectRoot(input.projectRoot));
+    const stopState = stoppedMergeWorkerState(context, project.id, input.workerId);
+    if (stopState.stopped) {
+        throw new AppError("merge_worker_stopped", "Stopped or stopping merge worker cannot claim another merge job", 1, {
+            worker_id: input.workerId,
+            status: stopState.status,
+            reason: stopState.reason
+        });
+    }
     requireLaneLockOwner(context, {
         projectRoot: project.root,
         lane: "merge",
@@ -47,6 +55,7 @@ export function claimNextMergeJob(context, input) {
             eventType: "merge_queue.claimed",
             payload: { protocol_id: job.protocol_id, worker_id: input.workerId }
         });
+        transitionClaimedProtocolToIntegration(context, job.protocol_id, input.workerId, now);
         claimedProtocolId = job.protocol_id;
         context.db.exec("COMMIT");
     }
@@ -184,7 +193,8 @@ export function completeMergeJob(context, input) {
         eventType: "merge_queue.completed",
         payload: { protocol_id: protocol.id, worker_id: input.workerId, summary: input.summary, flow_contract_id: flowContract.id }
     });
-    return { ok: true, job: queueJobByProtocol(context, protocol.id), next_stage: targetStage };
+    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 };
 }
 export function noteMergeJob(context, input) {
     const protocol = requireProtocol(context, input.protocolId);
@@ -230,6 +240,16 @@ export function failMergeJob(context, input) {
     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: protocol.id,
         projectId: protocol.project_id,
@@ -237,7 +257,8 @@ export function failMergeJob(context, input) {
         reason: input.reason,
         payload: { protocol_id: protocol.id, worker_id: input.workerId, requeue: input.requeue }
     });
-    return { ok: true, job: queueJobByProtocol(context, protocol.id) };
+    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 };
 }
 export function cancelMergeQueueJob(context, input) {
     const protocol = requireProtocol(context, input.protocolId);
@@ -317,6 +338,31 @@ function requireClaimedJob(context, protocolId, sessionId) {
     }
     return job;
 }
+function transitionClaimedProtocolToIntegration(context, protocolId, workerId, now) {
+    const protocol = requireProtocol(context, protocolId);
+    const state = readProtocolRuntimeState(context, protocol).state;
+    const flowContract = loadProjectFlowContract(protocol.project_root);
+    if (!["ready_for_merge", "queued_for_merge"].includes(state.stage)) {
+        throw new AppError("merge_protocol_not_ready", "Cannot claim a protocol whose runtime state is not ready for merge", 1, {
+            protocol_id: protocolId,
+            stage: state.stage,
+            allowed: ["ready_for_merge", "queued_for_merge"]
+        });
+    }
+    persistProtocolState(context, protocol, {
+        ...state,
+        stage: "integration",
+        status: flowContract.stages.integration?.terminal ? "integration" : "running",
+        next_action: "run_integration",
+        updated_at: now
+    });
+    appendAudit(context, {
+        protocolId,
+        projectId: protocol.project_id,
+        eventType: "protocol.integration_claimed",
+        payload: { protocol_id: protocolId, worker_id: workerId, flow_contract_id: flowContract.id }
+    });
+}
 function releaseLaneLockIfOwned(context, input) {
     try {
         releaseLaneLock(context, input);
@@ -328,6 +374,16 @@ function releaseLaneLockIfOwned(context, input) {
         throw error;
     }
 }
+function stopAfterCurrentIfRequested(context, projectId, projectRoot, workerId, reason) {
+    const requested = context.db.get(`SELECT session_id FROM flow_sessions
+     WHERE project_id = ? AND worker_id = ? AND flow_kind = 'merge_worker'
+       AND status = 'stopping' AND current_stage = 'stop_after_current'
+     ORDER BY updated_at DESC, rowid DESC LIMIT 1`, [projectId, workerId]);
+    if (!requested) {
+        return { requested: false };
+    }
+    return { requested: true, stop: stopMergeWorker(context, { projectRoot, workerId, reason }) };
+}
 async function delay(milliseconds) {
     await new Promise((resolve) => setTimeout(resolve, milliseconds));
 }

package/dist/services/merge-worker.js

@@ -0,0 +1,148 @@
+import { AppError } from "../shared/errors.js";
+import { resolveProjectRoot } from "../storage/paths.js";
+import { appendAudit } from "./audit.js";
+import { ensureLaneWorkspace, acquireLaneLock, releaseLaneLock, expireProjectLaneLocks } from "./lanes.js";
+import { claimNextMergeJob, queueForProject } from "./merge-queue.js";
+import { requireProjectByRoot } from "./projects.js";
+import { registerFlowSession, stopMergeWorker } from "./sessions.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)
+    };
+}
+export function startMergeWorker(context, input) {
+    const project = requireProjectByRoot(context, resolveProjectRoot(input.projectRoot));
+    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) };
+    }
+    ensureLaneWorkspace(context, { projectRoot: project.root, lane: "merge", workspacePath, branch: input.branch });
+    const registered = registerFlowSession(context, {
+        payloadJson: JSON.stringify({
+            project_root: project.root,
+            flow_kind: "merge_worker",
+            protocol_id: null,
+            worker_id: input.workerId,
+            workspace_path: workspacePath,
+            continuation_policy: "merge_queue",
+            current_stage: "waiting_for_merge_job",
+            next_action: "merge_queue_wait_next"
+        })
+    });
+    appendAudit(context, {
+        projectId: project.id,
+        eventType: "merge_worker.started",
+        payload: { project_id: project.id, worker_id: input.workerId, workspace_path: workspacePath }
+    });
+    return { ok: true, started: true, session: registered.session, merge_worker: detectMergeWorkerState(context, project.id) };
+}
+export function stopProjectMergeWorker(context, input) {
+    const project = requireProjectByRoot(context, resolveProjectRoot(input.projectRoot));
+    const workers = activeMergeWorkerSessions(context, project.id);
+    const targetWorkerId = input.workerId ?? uniqueWorkerId(workers);
+    if (!targetWorkerId) {
+        return { ok: true, stopped: false, reason: "no_active_merge_worker", merge_worker: detectMergeWorkerState(context, project.id) };
+    }
+    const targetSessions = workers.filter((session) => session.worker_id === targetWorkerId);
+    if (targetSessions.length === 0) {
+        throw new AppError("merge_worker_not_found", "Merge worker is not active", 1, { worker_id: targetWorkerId });
+    }
+    const claimed = claimedJobsForWorker(context, project.id, targetWorkerId);
+    if (claimed.length > 0) {
+        const now = context.now();
+        for (const session of targetSessions) {
+            context.db.run(`UPDATE flow_sessions
+         SET status = 'stopping', stop_reason = ?, current_stage = ?, next_action = ?, updated_at = ?
+         WHERE project_id = ? AND session_id = ?`, [input.reason, "stop_after_current", "finish_current_merge_job_then_stop", now, project.id, session.session_id]);
+        }
+        appendAudit(context, {
+            projectId: project.id,
+            eventType: "merge_worker.stop_after_current",
+            reason: input.reason,
+            payload: { project_id: project.id, worker_id: targetWorkerId, claimed_jobs: claimed.map((job) => job.protocol_id) }
+        });
+        return { ok: true, stopped: false, stop_after_current: true, worker_id: targetWorkerId, claimed_jobs: claimed, merge_worker: detectMergeWorkerState(context, project.id) };
+    }
+    return {
+        ...stopMergeWorker(context, { projectRoot: project.root, workerId: targetWorkerId, reason: input.reason }),
+        stopped: true,
+        worker_id: targetWorkerId,
+        merge_worker: detectMergeWorkerState(context, project.id)
+    };
+}
+export function oneShotMergeClaim(context, input) {
+    const project = requireProjectByRoot(context, resolveProjectRoot(input.projectRoot));
+    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) };
+    }
+    ensureLaneWorkspace(context, { projectRoot: project.root, lane: "merge", workspacePath });
+    const lock = acquireLaneLock(context, {
+        projectRoot: project.root,
+        lane: "merge",
+        workerId: input.workerId,
+        workspacePath,
+        ttlSeconds: 300,
+        reason: "one-shot merge"
+    });
+    const claimed = claimNextMergeJob(context, { projectRoot: project.root, workerId: input.workerId, workspacePath });
+    if (!claimed.job) {
+        releaseLaneLock(context, {
+            projectRoot: project.root,
+            lane: "merge",
+            workerId: input.workerId,
+            workspacePath,
+            reason: "one-shot merge no job"
+        });
+    }
+    return { ok: true, claimed: Boolean(claimed.job), mode: "one_shot", job: claimed.job ?? null, lock: claimed.job ? lock.lock : null };
+}
+function detectMergeWorkerState(context, projectId) {
+    expireProjectLaneLocks(context, projectId);
+    const workers = activeMergeWorkerSessions(context, projectId);
+    const workerIds = [...new Set(workers.map((worker) => worker.worker_id).filter((value) => Boolean(value)))];
+    const claimed = context.db.all(`SELECT protocol_id, claimed_by_session_id, status, updated_at FROM merge_queue
+     WHERE project_id = ? AND status = 'claimed'
+     ORDER BY updated_at DESC, id DESC`, [projectId]);
+    const lock = context.db.get(`SELECT worker_id, status, expires_at, reason FROM lane_locks
+     WHERE project_id = ? AND lane = 'merge' AND status = 'active'
+     ORDER BY updated_at DESC, id DESC LIMIT 1`, [projectId]);
+    if (workerIds.length > 1) {
+        return { state: "blocked", reason: "multiple_active_merge_workers", workers };
+    }
+    if (workerIds.length === 1) {
+        return { state: "active_worker", worker_id: workerIds[0], workers, claimed_jobs: claimed.filter((job) => job.claimed_by_session_id === workerIds[0]), lock: lock ?? null };
+    }
+    if (claimed.length > 0) {
+        return { state: "blocked", reason: "claimed_job_without_active_worker", claimed_jobs: claimed, lock: lock ?? null };
+    }
+    if (lock) {
+        return { state: "blocked", reason: "active_merge_lock_without_worker", lock };
+    }
+    return { state: "clear" };
+}
+function activeMergeWorkerSessions(context, projectId) {
+    return context.db.all(`SELECT session_id, worker_id, status, current_stage, next_action, updated_at FROM flow_sessions
+     WHERE project_id = ? AND flow_kind = 'merge_worker' AND status IN ('pending', 'active', 'waiting_user', 'blocked', 'stopping')
+     ORDER BY updated_at DESC, rowid DESC`, [projectId]);
+}
+function claimedJobsForWorker(context, projectId, workerId) {
+    return context.db.all(`SELECT protocol_id, claimed_by_session_id, status, updated_at FROM merge_queue
+     WHERE project_id = ? AND status = 'claimed' AND claimed_by_session_id = ?
+     ORDER BY updated_at DESC, id DESC`, [projectId, workerId]);
+}
+function uniqueWorkerId(workers) {
+    const workerIds = [...new Set(workers.map((worker) => worker.worker_id).filter((value) => Boolean(value)))];
+    if (workerIds.length === 0)
+        return undefined;
+    if (workerIds.length > 1) {
+        throw new AppError("merge_worker_ambiguous", "Multiple active merge workers exist; pass --worker-id", 1, { worker_ids: workerIds });
+    }
+    return workerIds[0];
+}

package/dist/services/protocols.js

@@ -141,6 +141,18 @@ export function readyForMerge(context, input) {
     const state = readProtocolRuntimeState(context, protocol).state;
     const flowContract = flowContractForState(state);
     const stage = requireStage(state.stage, flowContract);
+    const existingQueueJob = context.db.get("SELECT status FROM merge_queue WHERE protocol_id = ?", [
+        protocol.id
+    ]);
+    if (existingQueueJob && ["claimed", "merged", "cancelled", "failed"].includes(existingQueueJob.status)) {
+        appendAudit(context, {
+            protocolId: protocol.id,
+            projectId: protocol.project_id,
+            eventType: "protocol.ready_for_merge_unchanged",
+            payload: { protocol_id: protocol.id, queue_status: existingQueueJob.status, flow_contract_id: flowContract.id }
+        });
+        return { ok: true, protocol_id: protocol.id, queue_status: existingQueueJob.status, state };
+    }
     if (!flowContract.readiness.allowed_from.includes(stage)) {
         throw new AppError("readiness_invalid_stage", "Protocol state does not allow ready-for-merge", 1, {
             stage: state.stage,
@@ -166,18 +178,6 @@ export function readyForMerge(context, input) {
     const nextStage = flowContract.readiness.target_stage;
     const nextState = { ...state, stage: nextStage, status: statusForStage(nextStage, flowContract), updated_at: now };
     persistProtocolState(context, protocol, nextState);
-    const existingQueueJob = context.db.get("SELECT status FROM merge_queue WHERE protocol_id = ?", [
-        protocol.id
-    ]);
-    if (existingQueueJob && ["claimed", "merged", "cancelled", "failed"].includes(existingQueueJob.status)) {
-        appendAudit(context, {
-            protocolId: protocol.id,
-            projectId: protocol.project_id,
-            eventType: "protocol.ready_for_merge_unchanged",
-            payload: { protocol_id: protocol.id, queue_status: existingQueueJob.status, flow_contract_id: flowContract.id }
-        });
-        return { ok: true, protocol_id: protocol.id, queue_status: existingQueueJob.status, state: nextState };
-    }
     context.db.run(`INSERT INTO merge_queue
        (protocol_id, project_id, status, claimed_by_session_id, claimed_at, completed_at, created_at, updated_at)
      VALUES (?, ?, ?, NULL, NULL, NULL, ?, ?)

package/dist/services/schema-validation.js

@@ -50,11 +50,10 @@ function resolveSchema(options) {
     if (options.schemaDir) {
         candidates.push({ path: path.join(path.resolve(options.schemaDir), fileName), source: "schema_dir" });
     }
-    else {
-        const projectRoot = path.resolve(options.projectRoot ?? process.cwd());
-        candidates.push({ path: path.join(projectRoot, ".memory-bank", "dd-flow", "schemas", fileName), source: "project" });
-        candidates.push({ path: path.join(bundledSchemaDir(), fileName), source: "bundled" });
-    }
+    const projectRoot = path.resolve(options.projectRoot ?? process.cwd());
+    candidates.push({ path: path.join(projectRoot, ".memory-bank", "dd-flow", "schemas", fileName), source: "project" });
+    candidates.push({ path: path.join(projectRoot, "dd-flow", "schemas", fileName), source: "canonical" });
+    candidates.push({ path: path.join(bundledSchemaDir(), fileName), source: "bundled" });
     const found = candidates.find((candidate) => fs.existsSync(candidate.path));
     if (!found) {
         throw new AppError("schema_not_found", `Schema not found: ${options.schemaName}`, 2, {

package/dist/services/sessions.js

@@ -60,8 +60,9 @@ export function stoppedMergeWorkerState(context, projectId, workerId) {
      WHERE project_id = ? AND worker_id = ? AND flow_kind = 'merge_worker'
      ORDER BY updated_at DESC, rowid DESC LIMIT 1`, [projectId, workerId]);
     return {
-        stopped: latest?.status === "stopped",
-        reason: latest?.stop_reason ?? null
+        stopped: latest ? ["stopped", "stopping"].includes(latest.status) : false,
+        reason: latest?.stop_reason ?? null,
+        status: latest?.status ?? null
     };
 }
 export function activeFlowSessionsForProject(context, projectId) {