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

package/dist/services/engines.js

@@ -2,13 +2,16 @@ import fs from "node:fs";
 import path from "node:path";
 import { fileURLToPath } from "node:url";
 import { spawn } from "node:child_process";
+import { createRequire } from "node:module";
 import { getCliBuildInfo } from "./build-info.js";
 import { AppError } from "../shared/errors.js";
 import { ensureDir, engineStoreRoot, engineVersionRoot, resolveProjectRoot } from "../storage/paths.js";
 import { classifyCliOperation } from "./cli-operation-classifier.js";
+import { requireProtocol } from "./protocols.js";
 export const engineManifestSchemaId = "dd-flow/engine-manifest@1";
 const routerNativeFamilies = new Set(["engine", "version", "schema"]);
 const sourceFile = fileURLToPath(import.meta.url);
+const packageRequire = createRequire(sourceFile);
 export function isEngineMode(env) {
     return env.DD_FLOW_ENGINE_MODE === "1";
 }
@@ -115,11 +118,11 @@ export function doctorEngines(context, input = {}) {
         exit_code: checks.every((check) => check.status === "ok") && selection.status !== "missing" ? 0 : 1
     };
 }
-export function routeArgsThroughEngine(context, args, io, stdin, env) {
+export function routeArgsThroughEngine(context, args, io, stdin, env, resolvedProjectRoot) {
     if (isEngineMode(env) || isRouterNativeCommand(args))
         return Promise.resolve(null);
     installCurrentEngine(context);
-    const selection = selectEngine(context, { projectRoot: projectRootFromArgs(args) });
+    const selection = selectEngine(context, { projectRoot: resolvedProjectRoot ?? resolveOperationProjectRoot(context, args) ?? undefined });
     if (selection.status === "missing") {
         const classification = classifyCliOperation(args, env);
         if (classification.mode === "read_only_diagnostics" || classification.mode === "mb_upgrade") {
@@ -170,6 +173,34 @@ export function selectEngine(context, input) {
         diagnostics: selected ? [] : [`No installed engine satisfies ${packageName} ${requiredRange}`]
     };
 }
+export function resolveOperationProjectRoot(context, args) {
+    const [family, command, ...rest] = args;
+    const parsed = parseLightArgs(rest);
+    const allArgs = parseLightArgs(args);
+    const explicitRoot = option(allArgs, "project-root") ?? option(allArgs, "root");
+    if (explicitRoot)
+        return explicitRoot;
+    let protocolId = null;
+    if (family === "protocol" && ["status", "branch-status", "transition", "sync-from-run", "ready-for-merge", "cancel", "implement"].includes(command ?? "")) {
+        protocolId = positional(parsed, 0);
+    }
+    else if (family === "transition") {
+        protocolId = positional(parseLightArgs([command ?? "", ...rest]), 0);
+    }
+    else if (family === "plan" && ["set", "status"].includes(command ?? "")) {
+        protocolId = positional(parsed, 0);
+    }
+    else if (family === "plan" && command === "item") {
+        protocolId = positional(parsed, 1);
+    }
+    else if (family === "worktree") {
+        protocolId = option(parsed, "protocol-id");
+    }
+    else if (family === "merge-queue" && ["complete", "note", "fail", "cancel"].includes(command ?? "")) {
+        protocolId = positional(parsed, 0);
+    }
+    return protocolId ? requireProtocol(context, protocolId).project_root : null;
+}
 function readCompatibilityForProject(projectRoot) {
     let resolvedProjectRoot = null;
     if (projectRoot) {
@@ -191,17 +222,38 @@ function readCompatibilityForProject(projectRoot) {
     }
     return null;
 }
-function projectRootFromArgs(args) {
+function parseLightArgs(args) {
+    const positional = [];
+    const options = new Map();
     for (let index = 0; index < args.length; index += 1) {
-        const arg = args[index];
-        if ((arg === "--project-root" || arg === "--root") && args[index + 1])
-            return args[index + 1];
-        if (arg?.startsWith("--project-root="))
-            return arg.slice("--project-root=".length);
-        if (arg?.startsWith("--root="))
-            return arg.slice("--root=".length);
+        const value = args[index];
+        if (value?.startsWith("--")) {
+            const equal = value.indexOf("=");
+            if (equal > 2) {
+                const key = value.slice(2, equal);
+                options.set(key, [...(options.get(key) ?? []), value.slice(equal + 1)]);
+                continue;
+            }
+            const key = value.slice(2);
+            const next = args[index + 1];
+            if (!next || next.startsWith("--"))
+                options.set(key, [...(options.get(key) ?? []), ""]);
+            else {
+                options.set(key, [...(options.get(key) ?? []), next]);
+                index += 1;
+            }
+        }
+        else if (value)
+            positional.push(value);
     }
-    return undefined;
+    return { positional, options };
+}
+function option(parsed, key) {
+    const values = parsed.options.get(key);
+    return values?.[values.length - 1] || null;
+}
+function positional(parsed, index) {
+    return parsed.positional[index] ?? null;
 }
 function buildManifest(context, packageName, version, packageRoot, snapshotRoot, checksumRoot) {
     return {
@@ -242,6 +294,63 @@ function copyPackageSnapshot(packageRoot, target) {
             fs.copyFileSync(from, to);
         }
     }
+    copyProductionDependencies(packageRoot, target);
+}
+function copyProductionDependencies(packageRoot, target) {
+    const queue = [{ sourceRoot: packageRoot, targetRoot: target, ancestors: new Set() }];
+    const copied = new Set();
+    while (queue.length > 0) {
+        const current = queue.shift();
+        if (!current)
+            continue;
+        for (const dependency of readProductionDependencies(current.sourceRoot)) {
+            const sourceRoot = resolvePackageRoot(dependency, current.sourceRoot);
+            if (!sourceRoot)
+                throw new AppError("engine_install_failed", `Cannot resolve runtime dependency: ${dependency}`, 1);
+            const targetRoot = path.join(current.targetRoot, "node_modules", dependency);
+            const copyKey = `${sourceRoot}\n${targetRoot}`;
+            if (copied.has(copyKey))
+                continue;
+            copied.add(copyKey);
+            copyDir(sourceRoot, targetRoot, true);
+            if (current.ancestors.has(sourceRoot))
+                continue;
+            queue.push({ sourceRoot, targetRoot, ancestors: new Set([...current.ancestors, sourceRoot]) });
+        }
+    }
+}
+function readProductionDependencies(packageRoot) {
+    try {
+        const manifest = JSON.parse(fs.readFileSync(path.join(packageRoot, "package.json"), "utf8"));
+        const dependencies = new Set();
+        for (const field of ["dependencies", "optionalDependencies"]) {
+            const value = manifest[field];
+            if (!value || typeof value !== "object" || Array.isArray(value))
+                continue;
+            for (const name of Object.keys(value))
+                dependencies.add(name);
+        }
+        return [...dependencies];
+    }
+    catch {
+        return [];
+    }
+}
+function resolvePackageRoot(name, from) {
+    try {
+        let current = path.dirname(packageRequire.resolve(name, { paths: [from] }));
+        while (true) {
+            if (fs.existsSync(path.join(current, "package.json")))
+                return fs.realpathSync(current);
+            const parent = path.dirname(current);
+            if (parent === current)
+                return null;
+            current = parent;
+        }
+    }
+    catch {
+        return null;
+    }
 }
 function inferInstallSource(packageRoot, ddFlowHome) {
     const normalized = path.resolve(packageRoot);
@@ -265,13 +374,15 @@ function hasAncestorFile(start, name) {
         current = parent;
     }
 }
-function copyDir(from, to) {
+function copyDir(from, to, skipNodeModules = false) {
     ensureDir(to);
     for (const entry of fs.readdirSync(from, { withFileTypes: true })) {
+        if (skipNodeModules && entry.name === "node_modules")
+            continue;
         const source = path.join(from, entry.name);
         const target = path.join(to, entry.name);
         if (entry.isDirectory())
-            copyDir(source, target);
+            copyDir(source, target, skipNodeModules);
         else if (entry.isFile())
             fs.copyFileSync(source, target);
     }

package/dist/services/hooks.js

@@ -695,7 +695,7 @@ function stopDecision(context, project, sessionId) {
     if (!session || ["waiting_user", "blocked", "stopping", "stopped", "closed"].includes(session.status)) {
         return {};
     }
-    if (session.protocol_id && protocolAllowsStop(context, session.protocol_id)) {
+    if (session.protocol_id && protocolAllowsStop(context, project.id, session.protocol_id)) {
         return {};
     }
     if (session.flow_kind === "merge_worker" && session.continuation_policy === "merge_queue") {
@@ -704,17 +704,17 @@ function stopDecision(context, project, sessionId) {
     if (session.flow_kind === "merge_job" && session.continuation_policy === "merge_job") {
         return stopContinuationDecision(context, project.id, sessionId, `merge-job:${session.protocol_id ?? session.session_id}:${session.next_action ?? "none"}`, `Continue dd-flow merge job ${session.protocol_id ?? ""}: complete merge work, close the protocol, and report terminal state.`);
     }
-    const nextAction = session.next_action ?? nextActionFromProtocol(context, session.protocol_id);
+    const nextAction = session.next_action ?? nextActionFromProtocol(context, project.id, session.protocol_id);
     if (!nextAction || nextAction === "none" || session.continuation_policy === "none") {
         return {};
     }
     return stopContinuationDecision(context, project.id, sessionId, `${session.flow_kind}:${session.protocol_id ?? session.session_id}:${nextAction}`, `Continue dd-flow ${session.flow_kind}${session.protocol_id ? ` ${session.protocol_id}` : ""}: ${nextAction}`);
 }
-function nextActionFromProtocol(context, protocolId) {
+function nextActionFromProtocol(context, projectId, protocolId) {
     if (!protocolId) {
         return null;
     }
-    const protocol = context.db.get("SELECT id, status, stage, next_action FROM protocols WHERE id = ?", [protocolId]);
+    const protocol = context.db.get("SELECT id, status, stage, next_action FROM protocols WHERE project_id = ? AND id = ?", [projectId, protocolId]);
     if (!protocol) {
         return null;
     }
@@ -723,8 +723,8 @@ function nextActionFromProtocol(context, protocolId) {
     }
     return protocol.next_action;
 }
-function protocolAllowsStop(context, protocolId) {
-    const protocol = context.db.get("SELECT status, stage FROM protocols WHERE id = ?", [protocolId]);
+function protocolAllowsStop(context, projectId, protocolId) {
+    const protocol = context.db.get("SELECT status, stage FROM protocols WHERE project_id = ? AND id = ?", [projectId, protocolId]);
     return Boolean(protocol && (["closed", "cancelled"].includes(protocol.status) || ["closed", "cancelled"].includes(protocol.stage)));
 }
 function stopContinuationDecision(context, projectId, sessionId, actionKey, reason, options = {}) {

package/dist/services/ids.js

@@ -2,10 +2,10 @@ import fs from "node:fs";
 import path from "node:path";
 import { formatFullId, parseFullEntityId } from "../domain/entity-ids.js";
 import { AppError } from "../shared/errors.js";
-import { projectRunHome, resolveProjectRoot } from "../storage/paths.js";
+import { resolveProjectRoot } from "../storage/paths.js";
 const kindConfig = {
     protocol: { type: "PRT", table: "protocols", fileRoot: ".memory-bank/protocol" },
-    run: { type: "RUN", table: "flow_runs", fileRoot: ".tasks/dd-flow-runs" }
+    run: { type: "RUN", table: "flow_runs" }
 };
 export function previewNextEntityId(context, input) {
     const projectRoot = resolveProjectRoot(input.projectRoot);
@@ -13,51 +13,31 @@ export function previewNextEntityId(context, input) {
     const slug = normalizeSlug(input.slug);
     const config = kindConfig[kind];
     const used = new Set();
-    for (const id of databaseIds(context, config.table, config.type)) {
+    const project = context.db.get("SELECT id FROM projects WHERE root = ?", [projectRoot]);
+    for (const id of databaseIds(context, config.table, config.type, project?.id)) {
         addSequence(used, id, config.type);
     }
-    for (const id of filesystemIds(projectRoot, config.fileRoot, config.type)) {
-        addSequence(used, id, config.type);
-    }
-    if (kind === "run") {
-        for (const id of homeRunIds(context, projectRoot)) {
+    if (config.fileRoot) {
+        for (const id of filesystemIds(projectRoot, config.fileRoot, config.type)) {
             addSequence(used, id, config.type);
         }
-        for (const id of filesystemIds(projectRoot, ".tasks", config.type)) {
-            addSequence(used, id, config.type);
-        }
-    }
-    for (let sequence = 1; sequence <= 999; sequence += 1) {
-        if (used.has(sequence))
-            continue;
-        const id = formatFullId(config.type, sequence, slug);
-        const parsed = parseFullEntityId(id);
-        return {
-            ok: true,
-            project_root: projectRoot,
-            entity: {
-                kind,
-                type: config.type,
-                id,
-                short_id: parsed.shortId,
-                slug,
-                sequence,
-                reserved: false
-            }
-        };
-    }
-    throw new AppError("validation", `${config.type} id sequence exhausted`, 2);
-}
-function homeRunIds(context, projectRoot) {
-    const project = context.db.get("SELECT id FROM projects WHERE root = ? AND status = 'active'", [projectRoot]);
-    if (!project) {
-        return [];
     }
-    const root = projectRunHome(context.ddFlowHome, project.id, "__placeholder__").replace(/__placeholder__$/, "");
-    if (!fs.existsSync(root) || !fs.statSync(root).isDirectory()) {
-        return [];
-    }
-    return fs.readdirSync(root).filter((entry) => entry.startsWith("RUN-"));
+    const sequence = Math.max(0, ...used) + 1;
+    const id = formatFullId(config.type, sequence, slug);
+    const parsed = parseFullEntityId(id);
+    return {
+        ok: true,
+        project_root: projectRoot,
+        entity: {
+            kind,
+            type: config.type,
+            id,
+            short_id: parsed.shortId,
+            slug,
+            sequence,
+            reserved: false
+        }
+    };
 }
 function parseEntityKind(value) {
     const normalized = value.toLowerCase();
@@ -67,20 +47,28 @@ function parseEntityKind(value) {
         return "run";
     throw new AppError("validation", "--type must be protocol or run", 2, { type: value });
 }
-function databaseIds(context, table, type) {
-    return context.db.all(`SELECT id FROM ${table} WHERE id LIKE ?`, [`${type}-%`]).map((row) => row.id);
+function databaseIds(context, table, type, projectId) {
+    if (!projectId)
+        return [];
+    return context.db
+        .all(`SELECT id FROM ${table} WHERE project_id = ? AND id LIKE ?`, [projectId, `${type}-%`])
+        .map((row) => row.id);
 }
 function filesystemIds(projectRoot, relativeRoot, type) {
     const root = path.join(projectRoot, relativeRoot);
-    if (!fs.existsSync(root) || !fs.statSync(root).isDirectory()) {
+    try {
+        return fs
+            .readdirSync(root)
+            .filter((entry) => entry.startsWith(`${type}-`))
+            .map((entry) => entry.replace(/\.md$/, ""));
+    }
+    catch {
         return [];
     }
-    return fs
-        .readdirSync(root)
-        .filter((entry) => entry.startsWith(`${type}-`))
-        .map((entry) => entry.replace(/\.md$/, ""));
 }
 function addSequence(used, id, type) {
+    if (type === "PRT" && isLegacyDateProtocolId(id))
+        return;
     try {
         const parsed = parseFullEntityId(id);
         if (parsed.type !== type)
@@ -91,6 +79,9 @@ function addSequence(used, id, type) {
         return;
     }
 }
+function isLegacyDateProtocolId(id) {
+    return /^PRT-\d{4}-\d{2}-\d{2}(?:-|$)/.test(id);
+}
 function normalizeSlug(value) {
     const slug = value
         .normalize("NFKD")

package/dist/services/merge-queue.js

@@ -59,7 +59,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);
+        transitionClaimedProtocolToIntegration(context, project.id, job.protocol_id, input.workerId, now);
         claimedProtocolId = job.protocol_id;
         context.db.exec("COMMIT");
     }
@@ -67,7 +67,7 @@ export function claimNextMergeJob(context, input) {
         context.db.exec("ROLLBACK");
         throw error;
     }
-    return mergeQueueResult(claimedProtocolId ? queueJobByProtocol(context, claimedProtocolId) : null, {
+    return mergeQueueResult(claimedProtocolId ? queueJobByProtocol(context, project.id, claimedProtocolId) : null, {
         ok: true,
         outcome: claimedProtocolId ? "claimed" : "empty",
         claimed: Boolean(claimedProtocolId)
@@ -105,7 +105,7 @@ export function claimMergeBundle(context, input) {
                     protocol_ids: protocolIds
                 });
             }
-            transitionClaimedProtocolToIntegration(context, protocolId, input.workerId, now);
+            transitionClaimedProtocolToIntegration(context, project.id, protocolId, input.workerId, now);
             appendAudit(context, {
                 protocolId,
                 projectId: project.id,
@@ -278,8 +278,9 @@ export async function waitNextMergeJob(context, input) {
     }
 }
 export function completeMergeJob(context, input) {
-    const protocol = requireProtocol(context, input.protocolId);
-    const job = requireClaimedJob(context, input.protocolId, input.workerId);
+    const project = requireProjectByRoot(context, resolveProjectRoot(input.projectRoot));
+    const protocol = requireProtocol(context, input.protocolId, project.id);
+    const job = requireClaimedJob(context, protocol.project_id, input.protocolId, input.workerId);
     requireLaneLockOwner(context, {
         projectRoot: protocol.project_root,
         lane: "merge",
@@ -308,7 +309,7 @@ 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 mergeQueueResult(queueJobByProtocol(context, protocol.id), {
+    return mergeQueueResult(queueJobByProtocol(context, protocol.project_id, protocol.id), {
         ok: true,
         outcome: "merged",
         merged: true,
@@ -335,8 +336,8 @@ export function completeMergeBundle(context, input) {
     context.db.exec("BEGIN IMMEDIATE");
     try {
         for (const protocolId of protocolIds) {
-            const protocol = requireProtocol(context, protocolId);
-            const job = requireClaimedJob(context, protocolId, input.workerId);
+            const protocol = requireProtocol(context, protocolId, project.id);
+            const job = requireClaimedJob(context, project.id, 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]);
@@ -382,8 +383,9 @@ export function completeMergeBundle(context, input) {
     });
 }
 export function noteMergeJob(context, input) {
-    const protocol = requireProtocol(context, input.protocolId);
-    const job = queueJobByProtocol(context, protocol.id);
+    const project = requireProjectByRoot(context, resolveProjectRoot(input.projectRoot));
+    const protocol = requireProtocol(context, input.protocolId, project.id);
+    const job = queueJobByProtocol(context, protocol.project_id, protocol.id);
     if (!job) {
         throw new AppError("not_found", "Merge queue job is not found", 1, { protocol_id: protocol.id });
     }
@@ -409,11 +411,12 @@ export function noteMergeJob(context, input) {
         eventType: "merge_queue.note",
         payload: { protocol_id: protocol.id, worker_id: input.workerId, summary: input.summary }
     });
-    return mergeQueueResult(queueJobByProtocol(context, protocol.id), { ok: true, outcome: "noted" });
+    return mergeQueueResult(queueJobByProtocol(context, protocol.project_id, protocol.id), { ok: true, outcome: "noted" });
 }
 export function failMergeJob(context, input) {
-    const protocol = requireProtocol(context, input.protocolId);
-    const job = requireClaimedJob(context, input.protocolId, input.workerId);
+    const project = requireProjectByRoot(context, resolveProjectRoot(input.projectRoot));
+    const protocol = requireProtocol(context, input.protocolId, project.id);
+    const job = requireClaimedJob(context, protocol.project_id, input.protocolId, input.workerId);
     requireLaneLockOwner(context, {
         projectRoot: protocol.project_root,
         lane: "merge",
@@ -443,7 +446,7 @@ 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 mergeQueueResult(queueJobByProtocol(context, protocol.id), {
+    return mergeQueueResult(queueJobByProtocol(context, protocol.project_id, protocol.id), {
         ok: true,
         outcome: input.requeue ? "requeued" : "failed",
         stop_after_current
@@ -469,8 +472,8 @@ export function failMergeBundle(context, input) {
     context.db.exec("BEGIN IMMEDIATE");
     try {
         for (const protocolId of protocolIds) {
-            const protocol = requireProtocol(context, protocolId);
-            const job = requireClaimedJob(context, protocolId, input.workerId);
+            const protocol = requireProtocol(context, protocolId, project.id);
+            const job = requireClaimedJob(context, project.id, 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]);
@@ -516,7 +519,8 @@ export function failMergeBundle(context, input) {
     });
 }
 export function cancelMergeQueueJob(context, input) {
-    const protocol = requireProtocol(context, input.protocolId);
+    const project = requireProjectByRoot(context, resolveProjectRoot(input.projectRoot));
+    const protocol = requireProtocol(context, input.protocolId, project.id);
     const reason = input.reason.trim();
     if (!reason) {
         throw new AppError("validation", "merge-queue cancel requires --reason", 2);
@@ -524,7 +528,7 @@ export function cancelMergeQueueJob(context, input) {
     const now = context.now();
     context.db.exec("BEGIN IMMEDIATE");
     try {
-        const job = queueJobByProtocol(context, protocol.id);
+        const job = queueJobByProtocol(context, protocol.project_id, protocol.id);
         if (!job) {
             throw new AppError("not_found", "Merge queue job is not found", 1, { protocol_id: protocol.id });
         }
@@ -572,13 +576,13 @@ export function cancelMergeQueueJob(context, input) {
         context.db.exec("ROLLBACK");
         throw error;
     }
-    return mergeQueueResult(queueJobByProtocol(context, protocol.id), { ok: true, outcome: "cancelled", cancelled: true });
+    return mergeQueueResult(queueJobByProtocol(context, protocol.project_id, 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]);
 }
-function queueJobByProtocol(context, protocolId) {
-    return context.db.get("SELECT * FROM merge_queue WHERE protocol_id = ?", [protocolId]);
+function queueJobByProtocol(context, projectId, protocolId) {
+    return context.db.get("SELECT * FROM merge_queue WHERE project_id = ? AND protocol_id = ?", [projectId, protocolId]);
 }
 function mergeQueueResult(job, extra) {
     const queueItem = job ?? null;
@@ -609,7 +613,10 @@ function mergeBundleResult(context, input) {
         ...input,
         protocol_ids: input.protocolIds,
         branch_context: branchContext,
-        queue_items: input.protocolIds.map((protocolId) => queueJobByProtocol(context, protocolId) ?? null)
+        queue_items: input.protocolIds.map((protocolId) => {
+            const project = requireProjectByRoot(context, resolveProjectRoot(input.projectRoot));
+            return queueJobByProtocol(context, project.id, protocolId) ?? null;
+        })
     };
 }
 function claimedBundleProtocolIds(context, input) {
@@ -620,8 +627,8 @@ function claimedBundleProtocolIds(context, input) {
         .map((protocol) => String(protocol.id))
         .filter(Boolean);
 }
-function requireClaimedJob(context, protocolId, sessionId) {
-    const job = queueJobByProtocol(context, protocolId);
+function requireClaimedJob(context, projectId, protocolId, sessionId) {
+    const job = queueJobByProtocol(context, projectId, protocolId);
     if (!job || job.status !== "claimed") {
         throw new AppError("merge_job_not_claimed", "Merge job is not claimed", 1, { protocol_id: protocolId });
     }
@@ -633,8 +640,8 @@ function requireClaimedJob(context, protocolId, sessionId) {
     }
     return job;
 }
-function transitionClaimedProtocolToIntegration(context, protocolId, workerId, now) {
-    const protocol = requireProtocol(context, protocolId);
+function transitionClaimedProtocolToIntegration(context, projectId, protocolId, workerId, now) {
+    const protocol = requireProtocol(context, protocolId, projectId);
     const state = readProtocolRuntimeState(context, protocol).state;
     const flowContract = loadProjectFlowContract(protocol.project_root);
     if (!["ready_for_merge", "queued_for_merge"].includes(state.stage)) {

package/dist/services/merge-worker.js

@@ -158,7 +158,8 @@ function withJobGuidance(context, job) {
     if (!protocolId)
         return job;
     try {
-        const protocol = requireProtocol(context, protocolId);
+        const projectId = typeof job.project_id === "string" ? job.project_id : undefined;
+        const protocol = requireProtocol(context, protocolId, projectId);
         const state = readProtocolRuntimeState(context, protocol).state;
         return {
             ...job,

package/dist/services/migrations.js

@@ -3,6 +3,70 @@ import path from "node:path";
 import { AppError } from "../shared/errors.js";
 import { requireProjectByRoot } from "./projects.js";
 import { getProjectVersionStatus, resolveStatusProjectRoot } from "./version-status.js";
+import { resolveCanonRoot } from "./canon.js";
+export function assessMigrationImpact(context, input) {
+    const root = resolveStatusProjectRoot({ requestedRoot: input.projectRoot, cwd: process.cwd() });
+    if (!root.root)
+        throw new AppError("not_found", `Project root does not exist: ${input.projectRoot}`, 1);
+    const canon = resolveCanonRoot(context);
+    if (!canon.ok || !canon.canon)
+        throw new AppError("canon_unavailable", "Cannot resolve canonical Memory Bank for upgrade impact assessment", 1, { blockers: canon.blockers, bootstrap: canon.bootstrap });
+    const status = getProjectVersionStatus({ projectRoot: root.root, rootSource: root.root_source, canon: { root: canon.canon.root, metadata: canon.canon.metadata } });
+    const from = status?.memory_bank.version ?? null;
+    const to = input.targetVersion ?? canon.canon.version;
+    const forced = input.mode === "full_migration";
+    const impacts = readImpacts(path.join(canon.canon.memorybank_root, "release-impact"));
+    const chain = [];
+    const domains = new Set();
+    const blockers = [];
+    let mode = "patch";
+    if (!from || !to)
+        blockers.push("project or canonical Memory Bank version is unavailable");
+    let current = from;
+    while (current && to && current !== to) {
+        const impact = impacts.find((item) => item.from_version === current);
+        if (!impact) {
+            blockers.push(`missing adjacent release impact from ${current}`);
+            break;
+        }
+        chain.push(impact);
+        for (const domain of impact.domains)
+            domains.add(domain);
+        mode = stricterMode(mode, impact.minimum_upgrade_mode);
+        if (impact.path_migration || impact.runtime_migration)
+            mode = "full_migration";
+        current = impact.to_version;
+    }
+    if (current && to && current !== to)
+        blockers.push(`release impact chain does not reach ${to}`);
+    if (status?.flow_pack.status !== "present" && from !== to)
+        blockers.push("project flow-pack provenance is not present");
+    if (blockers.length > 0)
+        mode = "full_migration";
+    if (forced)
+        mode = "full_migration";
+    return { ok: true, schema_id: "dd-flow/mb-upgrade-impact-assessment@1", project_root: root.root, source_version: from, target_version: to, mode, forced_full_migration: forced, chain, domains: [...domains].sort(), blockers, required_checks: [...new Set(chain.flatMap((item) => item.required_checks))], next_action: mode === "full_migration" ? "run full mb-upgrade contour" : "run selected mb-upgrade contour" };
+}
+function readImpacts(dir) {
+    if (!fs.existsSync(dir))
+        return [];
+    return fs.readdirSync(dir).filter((file) => file.endsWith(".json")).flatMap((file) => {
+        try {
+            const value = JSON.parse(fs.readFileSync(path.join(dir, file), "utf8"));
+            if (value.schema_id !== "dd-flow/release-impact@1")
+                return [];
+            if (typeof value.from_version !== "string" || typeof value.to_version !== "string" || !Array.isArray(value.domains) || !Array.isArray(value.required_checks))
+                return [];
+            if (!["patch", "targeted_minor", "full_migration"].includes(String(value.minimum_upgrade_mode)))
+                return [];
+            return [{ from_version: value.from_version, to_version: value.to_version, minimum_upgrade_mode: value.minimum_upgrade_mode, domains: value.domains.filter((item) => typeof item === "string"), path_migration: value.path_migration === true, runtime_migration: value.runtime_migration === true, required_checks: value.required_checks.filter((item) => typeof item === "string") }];
+        }
+        catch {
+            return [];
+        }
+    });
+}
+function stricterMode(left, right) { return ["patch", "targeted_minor", "full_migration"][Math.max(["patch", "targeted_minor", "full_migration"].indexOf(left), ["patch", "targeted_minor", "full_migration"].indexOf(right))]; }
 export function planMigration(context, input) {
     const rootResolution = resolveStatusProjectRoot({ requestedRoot: input.projectRoot, cwd: process.cwd() });
     if (!rootResolution.root) {