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

package/dist/services/merge-queue.js

@@ -6,6 +6,7 @@ import { persistProtocolState, protocolRunDiagnostics, readProtocolRuntimeState,
 import { resolveProjectRoot } from "../storage/paths.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);
@@ -55,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");
     }
@@ -63,12 +67,73 @@ 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)
     });
 }
+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, project.id, 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));
     const timeoutSeconds = input.timeoutSeconds ?? 0;
@@ -213,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",
@@ -243,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,
@@ -251,9 +317,75 @@ export function completeMergeJob(context, input) {
         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, 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]);
+            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);
-    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 });
     }
@@ -279,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",
@@ -313,14 +446,81 @@ 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
     });
 }
+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, 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]);
+            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);
+    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);
@@ -328,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 });
         }
@@ -376,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;
@@ -407,8 +607,28 @@ function mergeQueueResult(job, extra) {
         job: queueItem
     };
 }
-function requireClaimedJob(context, protocolId, sessionId) {
-    const job = queueJobByProtocol(context, protocolId);
+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) => {
+            const project = requireProjectByRoot(context, resolveProjectRoot(input.projectRoot));
+            return queueJobByProtocol(context, project.id, 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, 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 });
     }
@@ -420,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

@@ -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) {
@@ -29,7 +33,8 @@ export function startMergeWorker(context, input) {
             outcome: "status_only",
             reason: "merge_worker_already_active",
             merge_worker: detection,
-            queue: queueForProject(context, project.id)
+            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 });
@@ -98,7 +103,8 @@ export function oneShotMergeClaim(context, input) {
             outcome: "status_only",
             reason: "active_merge_worker_or_lock",
             merge_worker: detection,
-            queue: queueForProject(context, project.id)
+            queue: queueForProject(context, project.id),
+            branch_context: getProtocolBranchContext(context, { projectRoot: project.root, workspacePath }).branch_context
         };
     }
     ensureLaneWorkspace(context, { projectRoot: project.root, lane: "merge", workspacePath });
@@ -143,6 +149,7 @@ export function oneShotMergeClaim(context, input) {
             : 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
     };
 }
@@ -151,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) {

package/dist/services/plans.js

@@ -6,15 +6,17 @@ import { parseJsonObject } from "../shared/json.js";
 import { ensureReadableFile } from "../storage/database.js";
 import { appendAudit } from "./audit.js";
 import { persistProtocolState, readProtocolRuntimeState, requireProtocol } from "./protocols.js";
+import { requireProjectByRoot } from "./projects.js";
+import { resolveProjectRoot } from "../storage/paths.js";
 import { writePlanFile } from "../protocol/local-files.js";
 export function setProtocolPlan(context, input) {
-    const protocol = requireProtocol(context, input.protocolId);
+    const protocol = scopedProtocol(context, input.projectRoot, input.protocolId);
     ensureReadableFile(input.file);
     const plan = validatePlan(parseJsonObject(fs.readFileSync(input.file, "utf8"), input.file), protocol.id);
     writePlanFile(protocol.plan_path, plan);
-    context.db.run(`INSERT INTO plans (protocol_id, plan_json, updated_at)
-     VALUES (?, ?, ?)
-     ON CONFLICT(protocol_id) DO UPDATE SET plan_json = excluded.plan_json, updated_at = excluded.updated_at`, [protocol.id, JSON.stringify(plan), context.now()]);
+    context.db.run(`INSERT INTO plans (project_id, protocol_id, plan_json, updated_at)
+     VALUES (?, ?, ?, ?)
+     ON CONFLICT(project_id, protocol_id) DO UPDATE SET plan_json = excluded.plan_json, updated_at = excluded.updated_at`, [protocol.project_id, protocol.id, JSON.stringify(plan), context.now()]);
     updateStatePlanSummary(context, protocol, plan);
     appendAudit(context, {
         protocolId: protocol.id,
@@ -25,8 +27,8 @@ export function setProtocolPlan(context, input) {
     return { ok: true, protocol_id: protocol.id, plan: summarizePlan(plan) };
 }
 export function getPlanStatus(context, input) {
-    const protocol = requireProtocol(context, input.protocolId);
-    const plan = requireStoredPlan(context, protocol.id);
+    const protocol = scopedProtocol(context, input.projectRoot, input.protocolId);
+    const plan = requireStoredPlan(context, protocol.project_id, protocol.id);
     return {
         ok: true,
         protocol_id: protocol.id,
@@ -43,7 +45,7 @@ export function getPlanStatus(context, input) {
     };
 }
 export function startPlanItem(context, input) {
-    return updatePlanItem(context, input.protocolId, input.itemId, (item, plan) => {
+    return updatePlanItem(context, input.projectRoot, input.protocolId, input.itemId, (item, plan) => {
         assertDependenciesClosed(plan, item);
         return {
             ...item,
@@ -53,7 +55,7 @@ export function startPlanItem(context, input) {
     });
 }
 export function completePlanItem(context, input) {
-    return updatePlanItem(context, input.protocolId, input.itemId, (item, plan) => {
+    return updatePlanItem(context, input.projectRoot, input.protocolId, input.itemId, (item, plan) => {
         assertDependenciesClosed(plan, item);
         return {
             ...item,
@@ -64,7 +66,7 @@ export function completePlanItem(context, input) {
     });
 }
 export function blockPlanItem(context, input) {
-    return updatePlanItem(context, input.protocolId, input.itemId, (item) => ({
+    return updatePlanItem(context, input.projectRoot, input.protocolId, input.itemId, (item) => ({
         ...item,
         status: "blocked",
         summary: input.reason,
@@ -73,15 +75,15 @@ export function blockPlanItem(context, input) {
     }));
 }
 export function skipPlanItem(context, input) {
-    return updatePlanItem(context, input.protocolId, input.itemId, (item) => ({
+    return updatePlanItem(context, input.projectRoot, input.protocolId, input.itemId, (item) => ({
         ...item,
         status: "skipped",
         summary: input.reason
     }));
 }
-function updatePlanItem(context, protocolId, itemId, transform) {
-    const protocol = requireProtocol(context, protocolId);
-    const plan = requireStoredPlan(context, protocol.id);
+function updatePlanItem(context, projectRoot, protocolId, itemId, transform) {
+    const protocol = scopedProtocol(context, projectRoot, protocolId);
+    const plan = requireStoredPlan(context, protocol.project_id, protocol.id);
     const item = plan.items.find((candidate) => candidate.id === itemId);
     if (!item) {
         throw new AppError("not_found", `Plan item is not found: ${itemId}`, 1);
@@ -92,9 +94,10 @@ function updatePlanItem(context, protocolId, itemId, transform) {
     };
     const validated = validatePlan(nextPlan, protocol.id);
     writePlanFile(protocol.plan_path, validated);
-    context.db.run("UPDATE plans SET plan_json = ?, updated_at = ? WHERE protocol_id = ?", [
+    context.db.run("UPDATE plans SET plan_json = ?, updated_at = ? WHERE project_id = ? AND protocol_id = ?", [
         JSON.stringify(validated),
         context.now(),
+        protocol.project_id,
         protocol.id
     ]);
     updateStatePlanSummary(context, protocol, validated);
@@ -111,8 +114,12 @@ function updatePlanItem(context, protocolId, itemId, transform) {
     });
     return { ok: true, protocol_id: protocol.id, item: validated.items.find((candidate) => candidate.id === itemId) };
 }
-function requireStoredPlan(context, protocolId) {
-    const row = context.db.get("SELECT plan_json FROM plans WHERE protocol_id = ?", [protocolId]);
+function scopedProtocol(context, projectRoot, protocolId) {
+    const project = requireProjectByRoot(context, resolveProjectRoot(projectRoot));
+    return requireProtocol(context, protocolId, project.id);
+}
+function requireStoredPlan(context, projectId, protocolId) {
+    const row = context.db.get("SELECT plan_json FROM plans WHERE project_id = ? AND protocol_id = ?", [projectId, protocolId]);
     if (!row) {
         throw new AppError("not_found", `Plan is not attached to protocol: ${protocolId}`, 1);
     }

package/dist/services/projects.js

@@ -91,7 +91,7 @@ export function resolveProject(context, input) {
     }
     const details = { input: input.idOrAlias };
     if (!isFullEntityId(input.idOrAlias) && !isShortEntityId(input.idOrAlias)) {
-        details.expected = "Use full id PRJ-NNN-slug, short alias PRJ-NNN, slug, root path, or --root for root-based commands.";
+        details.expected = "Use full id PRJ-<sequence>-slug, short alias PRJ-<sequence>, slug, root path, or --root for root-based commands.";
     }
     throw new AppError("not_found", `Project is not registered: ${input.idOrAlias}`, 1, details);
 }
@@ -108,7 +108,7 @@ export function requireProjectByReference(context, reference) {
     }
     throw new AppError("not_found", `Project is not registered: ${reference}`, 1, {
         input: reference,
-        expected: "Use full id PRJ-NNN-slug, short alias PRJ-NNN, slug, or project root path."
+        expected: "Use full id PRJ-<sequence>-slug, short alias PRJ-<sequence>, slug, or project root path."
     });
 }
 export function migrateProjectIds(context, input) {