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

package/dist/schemas/plan-stage-report.schema.json

@@ -1,9 +1,18 @@
 {
   "$schema": "http://json-schema.org/draft-07/schema#",
-  "$id": "dd-flow/plan-stage-report@1",
+  "$id": "dd-flow/plan-stage-report@2",
   "title": "dd-flow plan stage report data",
   "type": "object",
   "additionalProperties": false,
+  "allOf": [
+    {
+      "if": {
+        "properties": { "schema_id": { "const": "dd-flow/plan-stage-report@2" } },
+        "required": ["schema_id"]
+      },
+      "then": { "required": ["flow_flags"] }
+    }
+  ],
   "required": [
     "schema_id",
     "generated_at",
@@ -17,7 +26,7 @@
   ],
   "properties": {
     "schema_id": {
-      "const": "dd-flow/plan-stage-report@1"
+      "enum": ["dd-flow/plan-stage-report@1", "dd-flow/plan-stage-report@2"]
     },
     "generated_at": {
       "type": "string",
@@ -88,6 +97,7 @@
         "reason": {"type": "string"}
       }
     },
+    "flow_flags": { "$ref": "#/definitions/flowFlags" },
     "graph": {
       "type": "object",
       "additionalProperties": false,
@@ -153,6 +163,50 @@
         }
       }
     },
+    "review_gates": {
+      "type": "array",
+      "items": { "$ref": "#/definitions/reviewGate" }
+    },
+    "design_aspect_traceability": {
+      "type": "object",
+      "additionalProperties": true,
+      "properties": {
+        "source": {"type": "string"},
+        "verdict": {"type": "string"},
+        "summary": {"type": "string"},
+        "design_aspects": {
+          "type": "array",
+          "items": {"type": "string"}
+        },
+        "requirements": {
+          "type": "array",
+          "items": {"type": "string"}
+        },
+        "verification_seeds": {
+          "type": "array",
+          "items": {"type": "string"}
+        },
+        "gaps": {
+          "type": "array",
+          "items": {"type": "string"}
+        }
+      }
+    },
+    "testing_system": {
+      "type": "object",
+      "additionalProperties": true,
+      "properties": {
+        "applicability": {"type": "string"},
+        "applicability_reason": {"type": "string"},
+        "stages": {"type": "array"},
+        "test_levels": {"type": "object"},
+        "datasets": {"type": "array"},
+        "scenario_links": {"type": "array"},
+        "design_decision_coverage": {"type": "array"},
+        "gaps": {"type": "array"}
+      }
+    },
+    "aspect_map": { "$ref": "#/definitions/aspectMap" },
     "sdlc_contours": {
       "type": "object",
       "additionalProperties": true,
@@ -183,6 +237,7 @@
         "next_delivery_action": {"type": "string"}
       }
     },
+    "policy_context": { "$ref": "#/definitions/policyContext" },
     "links": {
       "type": "object",
       "additionalProperties": { "$ref": "#/definitions/link" },
@@ -250,6 +305,105 @@
         "degraded_reason": { "type": "string" },
         "source": { "type": "string" }
       }
+    },
+    "reviewGate": {
+      "type": "object",
+      "additionalProperties": true,
+      "required": ["id", "label", "stage", "applicability", "verdict", "summary"],
+      "properties": {
+        "id": { "type": "string", "minLength": 1 },
+        "label": { "type": "string", "minLength": 1 },
+        "stage": { "type": "string", "minLength": 1 },
+        "applicability": { "type": "string", "minLength": 1 },
+        "verdict": { "type": "string", "minLength": 1 },
+        "summary": { "type": "string", "minLength": 1 },
+        "evidence": {
+          "type": "array",
+          "items": { "type": "string", "minLength": 1 }
+        }
+      }
+    },
+    "aspectMap": {
+      "type": "object",
+      "additionalProperties": true,
+      "required": ["path", "schema_id", "status"],
+      "properties": {
+        "path": { "type": "string", "minLength": 1 },
+        "schema_id": { "type": "string", "minLength": 1 },
+        "status": { "type": "string", "minLength": 1 },
+        "summary": { "type": "string" },
+        "counts": {
+          "type": "object",
+          "additionalProperties": true,
+          "properties": {
+            "applicable": { "type": "integer", "minimum": 0 },
+            "not_applicable": { "type": "integer", "minimum": 0 },
+            "unknown": { "type": "integer", "minimum": 0 }
+          }
+        }
+      }
+    },
+    "policyContext": {
+      "type": "object",
+      "additionalProperties": true,
+      "required": ["sources", "git", "checks", "delivery", "gaps"],
+      "properties": {
+        "sources": { "type": "object", "additionalProperties": true },
+        "git": {
+          "type": "object",
+          "additionalProperties": true,
+          "properties": {
+            "workspace_route": { "type": "string" },
+            "delivery_strategy": {
+              "type": "string",
+              "enum": ["direct_commit", "direct_commit_push", "feature_merge", "pull_request", "merge_queue", "squash_merge", "rebase_ff", "release_branch", "external_handoff", "local_only", "no_git"]
+            },
+            "fixation_required": { "type": "boolean" },
+            "result_evidence_required": { "type": "array", "items": { "type": "string" } }
+          }
+        },
+        "checks": { "type": "object", "additionalProperties": true },
+        "delivery": { "type": "object", "additionalProperties": true },
+        "gaps": { "type": "object", "additionalProperties": true }
+      }
+    },
+    "flowFlags": {
+      "type": "object",
+      "additionalProperties": false,
+      "required": ["flow_kind", "snapshot_revision", "resolution_status", "values", "snapshot_checksum"],
+      "properties": {
+        "contract": { "type": "object", "additionalProperties": true },
+        "flow_kind": { "type": "string", "minLength": 1 },
+        "preset": { "type": "object", "additionalProperties": true },
+        "snapshot_revision": { "type": "integer", "minimum": 1 },
+        "resolution_status": { "type": "string", "enum": ["valid", "legacy_incomplete", "reconciliation_required"] },
+        "values": { "type": "object", "additionalProperties": { "$ref": "#/definitions/flagValue" } },
+        "snapshot_checksum": { "type": "string", "pattern": "^[a-f0-9]{64}$" },
+        "floors_applied": { "type": "array", "items": { "type": "string" } },
+        "resolved_at": { "type": "string", "format": "date-time" }
+      }
+    },
+    "flagValue": {
+      "type": "object",
+      "additionalProperties": false,
+      "required": ["value", "value_type", "owner", "source", "rationale", "resolved_at"],
+      "properties": {
+        "value": {},
+        "value_type": { "type": "string", "minLength": 1 },
+        "owner": { "type": "string", "minLength": 1 },
+        "source": {
+          "type": "object",
+          "additionalProperties": false,
+          "required": ["kind", "ref"],
+          "properties": {
+            "kind": { "type": "string", "minLength": 1 },
+            "ref": { "type": "string", "minLength": 1 },
+            "revision": { "type": ["integer", "null"] }
+          }
+        },
+        "rationale": { "type": "string", "minLength": 1 },
+        "resolved_at": { "type": "string", "format": "date-time" }
+      }
     }
   }
 }

package/dist/schemas/release-impact.schema.json

@@ -0,0 +1,16 @@
+{
+  "$schema": "http://json-schema.org/draft-07/schema#",
+  "$id": "dd-flow/release-impact@1",
+  "title": "Canonical release impact",
+  "type": "object",
+  "additionalProperties": false,
+  "required": ["schema_id", "from_version", "to_version", "minimum_upgrade_mode", "domains", "path_migration", "runtime_migration", "required_checks"],
+  "properties": {
+    "schema_id": {"const": "dd-flow/release-impact@1"},
+    "from_version": {"type": "string"}, "to_version": {"type": "string"},
+    "minimum_upgrade_mode": {"enum": ["patch", "targeted_minor", "full_migration"]},
+    "domains": {"type": "array", "items": {"type": "string"}},
+    "path_migration": {"type": "boolean"}, "runtime_migration": {"type": "boolean"},
+    "required_checks": {"type": "array", "items": {"type": "string"}, "minItems": 1}, "notes": {"type": "string"}
+  }
+}

package/dist/services/audit.js

@@ -11,9 +11,9 @@ export function appendAudit(context, input) {
         context.now()
     ]);
 }
-export function getAuditEvents(context, protocolId) {
+export function getAuditEvents(context, projectId, protocolId) {
     return context.db.all(`SELECT id, protocol_id, project_id, event_type, forced, reason, payload_json, created_at
      FROM audit_events
-     WHERE protocol_id = ?
-     ORDER BY id ASC`, [protocolId]);
+     WHERE project_id = ? AND protocol_id = ?
+     ORDER BY id ASC`, [projectId, protocolId]);
 }

package/dist/services/branch-context.js

@@ -0,0 +1,266 @@
+import fs from "node:fs";
+import path from "node:path";
+import { spawnSync } from "node:child_process";
+import { AppError } from "../shared/errors.js";
+import { resolveProjectRoot } from "../storage/paths.js";
+import { requireProjectByRoot } from "./projects.js";
+import { normalizeProtocolLifecycle } from "./protocol-lifecycle.js";
+export function getProtocolBranchContext(context, input) {
+    const resolved = resolveBranchContextInput(context, input);
+    const rows = context.db.all(`SELECT id, project_id, project_root, status, stage, next_action, workspace_json, route_json, active_def_json, updated_at
+     FROM protocols
+     WHERE project_id = ?
+     ORDER BY updated_at ASC, id ASC`, [resolved.project.id]);
+    const queues = new Map(context.db
+        .all(`SELECT protocol_id, status, claimed_by_session_id, claimed_at, attempts_count, updated_at
+         FROM merge_queue
+         WHERE project_id = ?`, [resolved.project.id])
+        .map((row) => [row.protocol_id, row]));
+    const worktrees = new Map(context.db
+        .all(`SELECT protocol_id, integration_branch, feature_branch, base_ref, worktree_path, status
+         FROM worktree_records
+         WHERE project_id = ?`, [resolved.project.id])
+        .map((row) => [row.protocol_id, row]));
+    const sessions = context.db.all(`SELECT protocol_id, worker_id, flow_kind, status, current_stage, next_action
+     FROM flow_sessions
+     WHERE project_id = ? AND status IN ('pending', 'active', 'waiting_user', 'blocked', 'stopping')`, [resolved.project.id]);
+    const sessionsByProtocol = new Map();
+    for (const session of sessions) {
+        if (!session.protocol_id)
+            continue;
+        sessionsByProtocol.set(session.protocol_id, [...(sessionsByProtocol.get(session.protocol_id) ?? []), session]);
+    }
+    const candidates = rows.map((row) => summarizeProtocol(row, queues.get(row.id), worktrees.get(row.id), sessionsByProtocol.get(row.id) ?? []));
+    const protocols = candidates.filter((candidate) => protocolMatchesBranch(candidate, resolved));
+    const eligible = protocols.filter((item) => item.bundle_eligible).map((item) => item.id);
+    const notReady = protocols.filter((item) => !item.bundle_eligible && !terminalStage(item.stage) && item.queue_status !== "claimed").map((item) => item.id);
+    const claimed = protocols.filter((item) => item.queue_status === "claimed").map((item) => item.id);
+    const blocked = protocols.filter((item) => item.stage === "blocked" || item.bundle_blockers.length > 0).map((item) => item.id);
+    const diagnostics = branchDiagnostics(resolved);
+    const diagnosticBlockers = diagnostics.filter((item) => item.severity === "error").map((item) => String(item.code));
+    const claimable = eligible.length > 0 && notReady.length === 0 && claimed.length === 0 && blocked.length === 0 && diagnosticBlockers.length === 0;
+    return {
+        ok: true,
+        branch_context: {
+            current_protocol_id: resolved.protocol?.id ?? null,
+            project_id: resolved.project.id,
+            project_root: resolved.project.root,
+            integration_branch: resolved.integrationBranch,
+            feature_branch: resolved.featureBranch,
+            worktree_path: resolved.workspacePath,
+            grouping_key: resolved.groupingKey,
+            git: resolved.git,
+            diagnostics,
+            protocols,
+            merge_bundle: {
+                eligible_protocols: eligible,
+                not_ready_protocols: notReady,
+                claimed_protocols: claimed,
+                blocked_protocols: blocked,
+                claimable,
+                reason: claimable ? "claimable" : bundleReason(eligible, notReady, claimed, blocked, diagnosticBlockers)
+            }
+        }
+    };
+}
+export function requireClaimableBranchBundle(context, input) {
+    const branchContext = getProtocolBranchContext(context, { projectRoot: input.projectRoot, workspacePath: input.workspacePath });
+    const contextBody = branchContext.branch_context;
+    const bundle = contextBody.merge_bundle;
+    if (bundle.claimable !== true) {
+        throw new AppError("merge_bundle_not_claimable", "Branch bundle is not claimable", 1, { branch_context: contextBody });
+    }
+    const protocolIds = Array.isArray(bundle.eligible_protocols) ? bundle.eligible_protocols.map(String) : [];
+    if (protocolIds.length === 0) {
+        throw new AppError("merge_bundle_empty", "Branch bundle has no ready protocols", 1, { branch_context: contextBody });
+    }
+    const project = requireProjectByRoot(context, resolveProjectRoot(input.projectRoot));
+    return { project, branchContext, protocolIds };
+}
+function resolveBranchContextInput(context, input) {
+    if (input.protocolId) {
+        const scopedProject = input.projectRoot
+            ? requireProjectByRoot(context, resolveProjectRoot(input.projectRoot))
+            : null;
+        const matches = context.db.all(scopedProject
+            ? `SELECT id, project_id, project_root, status, stage, next_action, workspace_json, route_json, active_def_json, updated_at
+           FROM protocols WHERE project_id = ? AND id = ? ORDER BY project_id`
+            : `SELECT id, project_id, project_root, status, stage, next_action, workspace_json, route_json, active_def_json, updated_at
+           FROM protocols WHERE id = ? ORDER BY project_id`, scopedProject ? [scopedProject.id, input.protocolId] : [input.protocolId]);
+        if (matches.length > 1) {
+            throw new AppError("ambiguous_protocol", `Protocol id is ambiguous without project context: ${input.protocolId}`, 1, {
+                protocol_id: input.protocolId,
+                candidates: matches.map((item) => ({ project_id: item.project_id, project_root: item.project_root }))
+            });
+        }
+        const protocol = matches[0];
+        if (!protocol) {
+            throw new AppError("not_found", `Protocol is not registered: ${input.protocolId}`, 1, { protocol_id: input.protocolId });
+        }
+        const project = scopedProject ?? requireProjectByRoot(context, protocol.project_root);
+        const workspace = parseRecord(protocol.workspace_json);
+        const worktree = context.db.get("SELECT * FROM worktree_records WHERE project_id = ? AND protocol_id = ?", [protocol.project_id, protocol.id]);
+        const workspacePath = normalizePath(input.workspacePath ?? stringValue(worktree?.worktree_path) ?? stringValue(workspace.worktree_path));
+        const git = gitFacts(workspacePath ?? project.root);
+        const featureBranch = stringValue(worktree?.feature_branch) ?? stringValue(workspace.feature_branch) ?? stringValue(git.actual_branch);
+        return {
+            project,
+            protocol,
+            featureBranch,
+            workspacePath,
+            integrationBranch: stringValue(worktree?.integration_branch) ?? stringValue(workspace.integration_branch),
+            groupingKey: groupingKey(project.id, featureBranch, workspacePath),
+            git: { ...git, matches_runtime: branchMatches(featureBranch, stringValue(git.actual_branch)) }
+        };
+    }
+    if (!input.projectRoot) {
+        throw new AppError("usage", "branch context requires <protocol-id> or --project-root", 2);
+    }
+    const project = requireProjectByRoot(context, resolveProjectRoot(input.projectRoot));
+    const workspacePath = normalizePath(input.workspacePath ?? project.root);
+    const git = gitFacts(workspacePath ?? project.root);
+    const featureBranch = stringValue(git.actual_branch);
+    return {
+        project,
+        protocol: null,
+        featureBranch,
+        workspacePath,
+        integrationBranch: null,
+        groupingKey: groupingKey(project.id, featureBranch, workspacePath),
+        git: { ...git, matches_runtime: true }
+    };
+}
+function summarizeProtocol(row, queue, worktree, activeSessions) {
+    const workspace = parseRecord(row.workspace_json);
+    const featureBranch = stringValue(worktree?.feature_branch) ?? stringValue(workspace.feature_branch);
+    const worktreePath = normalizePath(stringValue(worktree?.worktree_path) ?? stringValue(workspace.worktree_path));
+    const activeDef = parseJsonArray(row.active_def_json);
+    const queueStatus = queue?.status ?? null;
+    const bundleBlockers = bundleBlockersFor(row.stage, queueStatus, activeDef.length);
+    return {
+        id: row.id,
+        stage: row.stage,
+        status: row.status,
+        lifecycle: normalizeProtocolLifecycle({ rawStage: row.stage, rawStatus: row.status, queueStatus }),
+        queue_status: queueStatus,
+        queue_claimed_by: queue?.claimed_by_session_id ?? null,
+        active_sessions: activeSessions,
+        integration_branch: stringValue(worktree?.integration_branch) ?? stringValue(workspace.integration_branch),
+        feature_branch: featureBranch,
+        worktree_path: worktreePath,
+        bundle_eligible: ["ready_for_merge", "queued_for_merge"].includes(row.stage) && ["ready", "requeued"].includes(queueStatus ?? "") && activeDef.length === 0,
+        bundle_blockers: bundleBlockers,
+        updated_at: row.updated_at
+    };
+}
+function protocolMatchesBranch(item, resolved) {
+    if (resolved.featureBranch && item.feature_branch) {
+        return item.feature_branch === resolved.featureBranch;
+    }
+    if (resolved.workspacePath && item.worktree_path) {
+        return item.worktree_path === resolved.workspacePath;
+    }
+    return false;
+}
+function gitFacts(workspacePath) {
+    if (!fs.existsSync(workspacePath)) {
+        return { status: "missing_workspace", actual_branch: null, dirty: null, path: workspacePath };
+    }
+    const branch = spawnSync("git", ["-C", workspacePath, "rev-parse", "--abbrev-ref", "HEAD"], { encoding: "utf8" });
+    if (branch.status !== 0) {
+        return { status: "not_git_checkout", actual_branch: null, dirty: null, path: workspacePath };
+    }
+    const status = spawnSync("git", ["-C", workspacePath, "status", "--porcelain"], { encoding: "utf8" });
+    return {
+        status: "ok",
+        actual_branch: branch.stdout.trim() || null,
+        dirty: status.status === 0 ? status.stdout.trim().length > 0 : null,
+        path: workspacePath
+    };
+}
+function branchDiagnostics(resolved) {
+    const diagnostics = [];
+    if (resolved.git.status !== "ok") {
+        diagnostics.push({ code: "git_workspace_degraded", severity: "warning", summary: `Git workspace status is ${String(resolved.git.status)}` });
+    }
+    if (resolved.featureBranch && resolved.git.actual_branch && resolved.featureBranch !== resolved.git.actual_branch) {
+        diagnostics.push({
+            code: "branch_runtime_mismatch",
+            severity: "error",
+            summary: `Runtime branch ${resolved.featureBranch} does not match Git branch ${String(resolved.git.actual_branch)}.`
+        });
+    }
+    return diagnostics;
+}
+function bundleBlockersFor(stage, queueStatus, activeDefCount) {
+    const blockers = [];
+    if (activeDefCount > 0)
+        blockers.push("active_def");
+    if (stage === "blocked")
+        blockers.push("protocol_blocked");
+    if (queueStatus === "claimed")
+        blockers.push("already_claimed");
+    return blockers;
+}
+function bundleReason(eligible, notReady, claimed, blocked, diagnostics) {
+    if (diagnostics.length > 0)
+        return diagnostics[0] ?? "diagnostic_blocker";
+    if (claimed.length > 0)
+        return "branch_has_claimed_protocols";
+    if (blocked.length > 0)
+        return "branch_has_blocked_protocols";
+    if (notReady.length > 0)
+        return "branch_has_not_ready_protocols";
+    if (eligible.length === 0)
+        return "no_ready_protocols";
+    return "unknown";
+}
+function terminalStage(stage) {
+    return ["closed", "cancelled"].includes(stage);
+}
+function groupingKey(projectId, featureBranch, workspacePath) {
+    if (featureBranch)
+        return `${projectId}:branch:${featureBranch}`;
+    if (workspacePath)
+        return `${projectId}:worktree:${workspacePath}`;
+    return `${projectId}:unknown`;
+}
+function branchMatches(expected, actual) {
+    if (!expected || !actual)
+        return null;
+    return expected === actual;
+}
+function normalizePath(value) {
+    if (!value)
+        return null;
+    const absolute = path.resolve(value);
+    if (fs.existsSync(absolute))
+        return fs.realpathSync(absolute);
+    const parent = path.dirname(absolute);
+    if (fs.existsSync(parent))
+        return path.join(fs.realpathSync(parent), path.basename(absolute));
+    return absolute;
+}
+function parseRecord(value) {
+    try {
+        const parsed = JSON.parse(value);
+        return parsed && typeof parsed === "object" && !Array.isArray(parsed) ? parsed : {};
+    }
+    catch {
+        return {};
+    }
+}
+function parseJsonArray(value) {
+    if (typeof value !== "string")
+        return [];
+    try {
+        const parsed = JSON.parse(value);
+        return Array.isArray(parsed) ? parsed : [];
+    }
+    catch {
+        return [];
+    }
+}
+function stringValue(value) {
+    return typeof value === "string" && value.trim().length > 0 ? value : null;
+}

package/dist/services/canon.js

@@ -217,7 +217,6 @@ function assessLayout(root, layout, memorybankRoot) {
         "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) {

package/dist/services/cleanup.js

@@ -31,7 +31,7 @@ export function cleanupScan(context, input) {
             });
         }
         if (terminal) {
-            const queue = context.db.get("SELECT status FROM merge_queue WHERE protocol_id = ? AND status IN ('ready', 'requeued', 'claimed')", [protocol.id]);
+            const queue = context.db.get("SELECT status FROM merge_queue WHERE project_id = ? AND protocol_id = ? AND status IN ('ready', 'requeued', 'claimed')", [project.id, protocol.id]);
             if (queue) {
                 pushFinding(findings, actions, "active_queue_for_terminal_protocol", "warning", {
                     protocol_id: protocol.id,
@@ -40,7 +40,7 @@ export function cleanupScan(context, input) {
                 });
             }
         }
-        const fullProtocol = requireProtocol(context, protocol.id);
+        const fullProtocol = requireProtocol(context, protocol.id, project.id);
         const state = readProtocolRuntimeState(context, fullProtocol).state;
         const diagnostics = protocolRunDiagnostics(context, fullProtocol, state).diagnostics;
         for (const diagnostic of diagnostics.filter((entry) => entry.code === "protocol_run_stage_mismatch")) {
@@ -55,7 +55,7 @@ export function cleanupScan(context, input) {
         }
     }
     const orphanQueueJobs = context.db.all(`SELECT mq.protocol_id, mq.status FROM merge_queue mq
-     LEFT JOIN protocols p ON p.id = mq.protocol_id
+     LEFT JOIN protocols p ON p.project_id = mq.project_id AND p.id = mq.protocol_id
      WHERE mq.project_id = ?
        AND mq.status IN ('ready', 'requeued')
        AND p.id IS NULL
@@ -72,7 +72,7 @@ export function cleanupScan(context, input) {
      ORDER BY updated_at ASC, session_id ASC`, [project.id]);
     for (const session of staleSessions) {
         const protocol = session.protocol_id
-            ? context.db.get("SELECT status, stage FROM protocols WHERE id = ?", [session.protocol_id])
+            ? context.db.get("SELECT status, stage FROM protocols WHERE project_id = ? AND id = ?", [project.id, session.protocol_id])
             : undefined;
         const missingWorkspace = !fs.existsSync(session.workspace_path);
         const terminalProtocol = Boolean(protocol && (["closed", "cancelled"].includes(protocol.status) || ["closed", "cancelled"].includes(protocol.stage)));
@@ -112,7 +112,7 @@ export function cleanupScan(context, input) {
         });
     }
     const staleWorktrees = context.db.all(`SELECT wr.protocol_id, wr.worktree_path FROM worktree_records wr
-     JOIN protocols p ON p.id = wr.protocol_id
+     JOIN protocols p ON p.project_id = wr.project_id AND p.id = wr.protocol_id
      WHERE wr.project_id = ?
        AND wr.status = 'active'
        AND (p.status IN ('closed', 'cancelled') OR p.stage IN ('closed', 'cancelled') OR wr.worktree_path = '')
@@ -242,7 +242,7 @@ function validateNoDestructiveSurprises(context, plan, force) {
 }
 function applyAction(context, action, reason, force, now) {
     if (action.kind === "repair_protocol_state" && action.protocol_id) {
-        const protocol = requireProtocol(context, action.protocol_id);
+        const protocol = requireProtocol(context, action.protocol_id, action.project_id);
         const beforePath = protocol.state_path;
         const existed = fs.existsSync(beforePath);
         readProtocolRuntimeState(context, protocol);

package/dist/services/cli-operation-classifier.js

@@ -69,7 +69,7 @@ function isReadOnlyDiagnostic(family, command, action) {
     if (family === "project")
         return command === "status" || command === "resolve";
     if (family === "protocol")
-        return ["status", "ready", "blockers", "implement"].includes(command ?? "");
+        return ["status", "branch-status", "ready", "blockers", "implement"].includes(command ?? "");
     if (family === "plan")
         return command === "status";
     if (family === "run")