@deksden-com/dd-flow-cli 0.5.0 → 0.7.0

package/dist/runtime/context.js

@@ -1,10 +1,16 @@
 import { getDatabase } from "../storage/database.js";
 import { resolveDdFlowHome } from "../storage/paths.js";
-export function createContext(env) {
+export function createRouterContext(env) {
+    return {
+        ddFlowHome: resolveDdFlowHome(env),
+        now: () => new Date().toISOString()
+    };
+}
+export function createContext(env, mode = "initialize") {
     const ddFlowHome = resolveDdFlowHome(env);
     return {
         ddFlowHome,
-        db: getDatabase(ddFlowHome),
+        db: getDatabase(ddFlowHome, mode),
         env,
         now: () => new Date().toISOString()
     };

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

@@ -124,10 +124,15 @@
     "run": {
       "type": "object",
       "additionalProperties": true,
-      "required": ["run_id", "run_state"],
+      "required": ["run_id"],
+      "anyOf": [
+        {"required": ["run_state"]},
+        {"required": ["run_index"]}
+      ],
       "properties": {
         "run_id": { "type": "string", "pattern": "^RUN-[0-9]{3}-[a-z0-9]+(?:-[a-z0-9]+)*$" },
-        "run_state": { "type": "string", "minLength": 1 }
+        "run_state": { "type": "string", "minLength": 1 },
+        "run_index": { "type": "string", "minLength": 1 }
       }
     },
     "stage": {

package/dist/schemas/engine-manifest.schema.json

@@ -44,6 +44,28 @@
         "items": { "type": "string", "minLength": 1 }
       }
     },
+    "schema_registry": {
+      "type": "object",
+      "additionalProperties": false,
+      "required": ["schema_id", "entries"],
+      "properties": {
+        "schema_id": { "const": "dd-flow/engine-schema-registry@1" },
+        "entries": {
+          "type": "array",
+          "items": {
+            "type": "object",
+            "additionalProperties": false,
+            "required": ["name", "id", "path", "checksum"],
+            "properties": {
+              "name": { "type": "string", "pattern": "^[a-z0-9][a-z0-9-]*$" },
+              "id": { "type": "string", "minLength": 1 },
+              "path": { "type": "string", "pattern": "^dist/schemas/[a-z0-9][a-z0-9-]*\\.schema\\.json$" },
+              "checksum": { "type": "string", "pattern": "^[a-f0-9]{64}$" }
+            }
+          }
+        }
+      }
+    },
     "integrity": {
       "type": "object",
       "additionalProperties": false,

package/dist/schemas/flow-contract.schema.json

@@ -1,8 +1,8 @@
 {
   "$schema": "http://json-schema.org/draft-07/schema#",
-  "$id": "dd-flow/flow-contract@5",
+  "$id": "dd-flow/flow-contract@6",
   "title": "dd-flow canonical runtime contract",
-  "description": "Structural contract for the SPC-004 v0.2 and SPC-005 runtime/PLAN cutover. Dynamic command and cross-repository checks belong to companion projects.",
+  "description": "Structural contract for the SPC-004/005/006 runtime, PLAN and deterministic stage-context cutover. Dynamic command and cross-repository checks belong to companion projects.",
   "type": "object",
   "additionalProperties": false,
   "required": [
@@ -25,21 +25,21 @@
     "policy"
   ],
   "properties": {
-    "schema_id": {"const": "dd-flow/flow-contract@5"},
+    "schema_id": {"const": "dd-flow/flow-contract@6"},
     "id": {"const": "dd-flow-canonical-2026-08"},
     "contract_id": {"type": "string", "pattern": "^dd-flow-canonical-[0-9]{4}-[0-9]{2}$"},
-    "version": {"const": 5},
+    "version": {"const": 6},
     "status": {"const": "active"},
     "source": {"const": ".memory-bank/dd-flow/common/runtime-contract.md"},
     "specifications": {
       "type": "array",
-      "minItems": 2,
+      "minItems": 3,
       "items": {
         "type": "object",
         "additionalProperties": false,
         "required": ["id", "version", "sha256"],
         "properties": {
-          "id": {"enum": ["SPC-004", "SPC-005"]},
+          "id": {"enum": ["SPC-004", "SPC-005", "SPC-006"]},
           "version": {"type": "string", "pattern": "^[0-9]+\\.[0-9]+\\.[0-9]+$"},
           "sha256": {"type": "string", "pattern": "^[a-f0-9]{64}$"}
         }
@@ -73,21 +73,23 @@
     "stageLifecycle": {
       "type": "object",
       "additionalProperties": false,
-      "required": ["actions", "start_command", "finish_command", "prompt_sections", "current_write_alias", "archive_pattern"],
+      "required": ["actions", "start_command", "bootstrap_command", "finish_command", "prompt_sections", "current_write_alias", "archive_pattern"],
       "properties": {
         "actions": {
           "const": ["stage_start", "stage_finish"]
         },
         "start_command": {"const": "dd-flow stage start <RUN> --stage <stage> --json"},
-        "finish_command": {"const": "dd-flow stage finish <RUN> --stage <stage> --status done --json"},
+        "bootstrap_command": {"const": "dd-flow stage start --bootstrap --stage specify --project-root <root> --subject <label> --intake-file <path> --json"},
+        "finish_command": {"const": "dd-flow stage finish <RUN> --stage <stage> --outcome <outcome> --json"},
         "prompt_sections": {
           "const": [
             "stage_identity",
-            "runtime_context",
-            "intake",
+            "authoritative_runtime_facts",
+            "preflight",
+            "task_intake",
             "applicable_instructions",
-            "stage_cli",
-            "file_boundaries",
+            "required_context",
+            "work_contract",
             "completion_contract"
           ]
         },
@@ -112,7 +114,7 @@
       "required": ["finish_outputs", "model_input", "mechanical_facts"],
       "properties": {
         "finish_outputs": {"const": ["stage-report.json", "stage-report.md", "stage-report.html", "summary.md"]},
-        "model_input": {"const": "semantic-only"},
+        "model_input": {"const": "semantic-only; outcome flag"},
         "mechanical_facts": {"const": "cli-owned"}
       }
     },

package/dist/schemas/flow-run.schema.json

@@ -123,6 +123,7 @@
         "expected": {"type": "array", "items": {"type": "string"}},
         "observed": {"type": "array", "items": {"type": "string"}},
         "missing": {"type": "array", "items": {"type": "string"}},
+        "diagnostics": {"type": "array", "items": {"type": "string"}},
         "reason": {"type": "string"}
       }
     },

package/dist/schemas/mb-upgrade-migration-report.schema.json

@@ -70,12 +70,14 @@
     },
     "backup": {
       "type": "object",
-      "required": ["status", "path", "created_at", "rollback_route"],
+      "required": ["status", "path", "created_at", "rollback_route", "size_bytes", "sha256"],
       "additionalProperties": true,
       "properties": {
         "status": { "enum": ["present", "planned", "missing"] },
         "path": { "type": ["string", "null"] },
         "created_at": { "type": ["string", "null"] },
+        "size_bytes": { "type": ["integer", "null"], "minimum": 1 },
+        "sha256": { "type": ["string", "null"], "pattern": "^[a-f0-9]{64}$" },
         "rollback_route": { "type": "string", "minLength": 1 }
       }
     },

package/dist/schemas/merge-stage-report-legacy-0.4.2.schema.json

@@ -0,0 +1,24 @@
+{
+  "$schema": "http://json-schema.org/draft-07/schema#",
+  "$id": "dd-flow/merge-stage-report@2/engine-0.4.2",
+  "title": "Merge stage report emitted by dd-flow engine 0.4.2",
+  "type": "object",
+  "additionalProperties": true,
+  "required": ["schema_id", "run", "stage", "project", "subject", "overall", "breadcrumbs", "implemented_goals", "acceptance_scenarios", "changed_files", "checks", "review", "review_gates", "defs"],
+  "properties": {
+    "schema_id": { "const": "dd-flow/merge-stage-report@2" },
+    "run": { "type": "object", "required": ["run_id", "run_index"], "properties": { "run_id": { "type": "string", "pattern": "^RUN-[0-9]{3}-[a-z0-9]+(?:-[a-z0-9]+)*$" }, "run_index": { "type": "string", "minLength": 1 } } },
+    "stage": { "type": "object", "required": ["name", "dir", "status"] },
+    "project": { "type": "object", "required": ["id", "title"] },
+    "subject": { "type": "object", "required": ["id", "title"] },
+    "overall": { "type": "object", "required": ["verdict", "summary", "next_action"], "properties": { "verdict": { "enum": ["accepted", "blocked", "failed"] }, "summary": { "type": "string", "minLength": 1 }, "next_action": { "type": "string", "minLength": 1 } } },
+    "breadcrumbs": { "type": "array" },
+    "implemented_goals": { "type": "array" },
+    "acceptance_scenarios": { "type": "array" },
+    "changed_files": { "type": "array" },
+    "checks": { "type": "array" },
+    "review": { "type": "object" },
+    "review_gates": { "type": "array" },
+    "defs": { "type": "array" }
+  }
+}

package/dist/schemas/run-engine-binding.schema.json

@@ -0,0 +1,37 @@
+{
+  "$schema": "http://json-schema.org/draft-07/schema#",
+  "$id": "dd-flow/run-engine-binding@1",
+  "title": "Immutable RUN engine binding",
+  "type": "object",
+  "additionalProperties": false,
+  "required": ["schema_id", "run_id", "project_root", "bound_at", "source", "reason", "engine", "probe"],
+  "properties": {
+    "schema_id": {"const": "dd-flow/run-engine-binding@1"},
+    "run_id": {"type": "string", "pattern": "^RUN-[0-9]+-[a-z0-9][a-z0-9-]*$"},
+    "project_root": {"type": "string", "minLength": 1},
+    "bound_at": {"type": "string", "format": "date-time"},
+    "source": {"enum": ["run_creation", "legacy_recovery"]},
+    "reason": {"type": "string", "minLength": 1},
+    "engine": {
+      "type": "object",
+      "additionalProperties": false,
+      "required": ["package_name", "package_version", "engine_version", "integrity_checksum", "snapshot_root"],
+      "properties": {
+        "package_name": {"type": "string", "minLength": 1},
+        "package_version": {"type": "string", "minLength": 1},
+        "engine_version": {"type": "string", "minLength": 1},
+        "integrity_checksum": {"type": "string", "pattern": "^[a-f0-9]{64}$"},
+        "snapshot_root": {"type": "string", "minLength": 1}
+      }
+    },
+    "probe": {
+      "type": "object",
+      "additionalProperties": false,
+      "required": ["status", "command"],
+      "properties": {
+        "status": {"enum": ["not_required", "passed"]},
+        "command": {"type": ["string", "null"]}
+      }
+    }
+  }
+}

package/dist/schemas/stage-prompt.schema.json

@@ -1,6 +1,6 @@
 {
   "$schema": "http://json-schema.org/draft-07/schema#",
-  "$id": "dd-flow/stage-prompt@1",
+  "$id": "dd-flow/stage-prompt@2",
   "title": "Generated stage prompt",
   "type": "object",
   "additionalProperties": false,
@@ -16,16 +16,20 @@
       }
     }
   ],
-  "required": ["schema_id", "run_id", "stage", "generated_at", "prompt_path", "sections", "aliases", "write_boundary", "source_fragments"],
+  "required": ["schema_id", "run_id", "stage", "generated_at", "prompt_path", "sections", "aliases", "write_boundary", "source_fragments", "authoritative_facts", "preflight", "required_context", "worker_prompt_markdown"],
   "properties": {
-    "schema_id": {"const": "dd-flow/stage-prompt@1"},
+    "schema_id": {"const": "dd-flow/stage-prompt@2"},
     "run_id": {"type": "string", "minLength": 1},
     "stage": {"type": "string", "minLength": 1},
     "generated_at": {"type": "string", "format": "date-time"},
     "prompt_path": {"type": "string", "minLength": 1},
-    "sections": {"type": "array", "minItems": 7, "maxItems": 7, "items": {"enum": ["stage_identity", "runtime_context", "intake", "applicable_instructions", "stage_cli", "file_boundaries", "completion_contract"]}},
+    "sections": {"const": ["stage_identity", "authoritative_runtime_facts", "preflight", "task_intake", "applicable_instructions", "required_context", "work_contract", "completion_contract"]},
     "aliases": {"type": "object", "required": ["project", "workspace", "run", "stage", "protocol", "intake"], "additionalProperties": {"type": "string"}},
     "write_boundary": {"type": "object", "required": ["current", "archive", "archive_writable"], "properties": {"current": {"const": "@stage"}, "archive": {"pattern": "try-[0-9]{3}"}, "archive_writable": {"const": false}}, "additionalProperties": false},
-    "source_fragments": {"type": "array", "items": {"type": "string", "minLength": 1}}
+    "source_fragments": {"type": "array", "items": {"type": "string", "minLength": 1}},
+    "authoritative_facts": {"type": "object", "required": ["git", "runtime"], "additionalProperties": true},
+    "preflight": {"type": "object", "required": ["compatibility", "permissions", "session_binding"], "additionalProperties": true},
+    "required_context": {"type": "array", "items": {"type": "object", "additionalProperties": false, "required": ["path", "reason", "stop_condition"], "properties": {"path": {"type": "string", "minLength": 1}, "reason": {"type": "string", "minLength": 1}, "stop_condition": {"type": "string", "minLength": 1}}}},
+    "worker_prompt_markdown": {"type": "string", "minLength": 1}
   }
 }

package/dist/schemas/stage-start-response.schema.json

@@ -1,6 +1,6 @@
 {
   "$schema": "http://json-schema.org/draft-07/schema#",
-  "$id": "dd-flow/stage-start-response@1",
+  "$id": "dd-flow/stage-start-response@2",
   "title": "Stage start response",
   "type": "object",
   "additionalProperties": false,
@@ -10,9 +10,9 @@
       "then": {"required": ["plan_ref", "aspect_map_ref"]}
     }
   ],
-  "required": ["schema_id", "run_id", "stage", "attempt_number", "stage_root", "prompt_path", "aliases", "next_command"],
+  "required": ["schema_id", "run_id", "stage", "attempt_number", "stage_root", "prompt_path", "aliases", "next_command", "worker_prompt_markdown"],
   "properties": {
-    "schema_id": {"const": "dd-flow/stage-start-response@1"},
+    "schema_id": {"const": "dd-flow/stage-start-response@2"},
     "run_id": {"type": "string", "minLength": 1},
     "stage": {"type": "string", "minLength": 1},
     "attempt_number": {"type": "integer", "minimum": 1},
@@ -23,7 +23,8 @@
     "resolved_context": {"type": "object", "additionalProperties": true},
     "plan_ref": {"type": "string", "pattern": "^\\.memory-bank/protocol/[^/]+/plan\\.json$"},
     "aspect_map_ref": {"type": "string", "minLength": 1},
-    "next_command": {"const": "dd-flow stage finish"},
-    "permission_probe": {"type": "object", "additionalProperties": true}
+    "next_command": {"type": "string", "pattern": "^dd-flow stage finish "},
+    "permission_probe": {"type": "object", "additionalProperties": true},
+    "worker_prompt_markdown": {"type": "string", "minLength": 1}
   }
 }

package/dist/services/canon.js

@@ -36,7 +36,21 @@ export function getCanonStatus(context, input = {}) {
     };
 }
 export function resolveCanonRoot(context, input = {}) {
-    const candidates = canonCandidates(context, input);
+    return resolveCanonCandidates(canonCandidates(context, input));
+}
+/** Read only: resolve an explicit/environment/nearby canon without opening DD_FLOW_HOME. */
+export function resolveCanonRootBeforeContext(env, input = {}) {
+    const candidates = [];
+    if (input.explicitRoot)
+        candidates.push(validateCanonCandidate("explicit", input.explicitRoot));
+    else if (env.DD_MEMORYBANK)
+        candidates.push(validateCanonCandidate("env", env.DD_MEMORYBANK));
+    else
+        for (const known of knownCanonRoots())
+            candidates.push(validateCanonCandidate("known", known));
+    return resolveCanonCandidates(uniqueBy(candidates, (candidate) => `${candidate.source}:${candidate.root}`));
+}
+function resolveCanonCandidates(candidates) {
     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);

package/dist/services/cleanup.js

@@ -12,6 +12,7 @@ const actionKinds = new Set([
     "repair_protocol_state",
     "cancel_queue_job",
     "close_flow_session",
+    "discard_stale_run",
     "expire_lane_lock",
     "expire_lane_waiter",
     "close_worktree_record"
@@ -86,6 +87,36 @@ export function cleanupScan(context, input) {
             });
         }
     }
+    const staleRuns = context.db.all(`SELECT id, runtime_path, run_dir, workspace_root FROM flow_runs
+     WHERE project_id = ? AND status = 'running'
+     ORDER BY updated_at ASC, id ASC`, [project.id]);
+    for (const run of staleRuns) {
+        const missingAuthority = !fs.existsSync(run.runtime_path);
+        const missingRunHome = !fs.existsSync(run.run_dir);
+        const missingWorkspace = !fs.existsSync(run.workspace_root);
+        if (!missingAuthority)
+            continue;
+        const details = {
+            code: "stale_run_missing_authority",
+            severity: "warning",
+            run_id: run.id,
+            runtime_path: run.runtime_path,
+            missing_run_home: missingRunHome,
+            missing_workspace: missingWorkspace
+        };
+        if (missingRunHome && missingWorkspace) {
+            pushFinding(findings, actions, details.code, details.severity, {
+                run_id: run.id,
+                runtime_path: run.runtime_path,
+                missing_run_home: missingRunHome,
+                missing_workspace: missingWorkspace,
+                action: { kind: "discard_stale_run", project_id: project.id, run_id: run.id }
+            });
+        }
+        else {
+            findings.push({ ...details, action: null, reason: "manual_reconciliation_required" });
+        }
+    }
     const now = context.now();
     const expiredLocks = context.db.all(`SELECT id, lane, worker_id, expires_at FROM lane_locks
      WHERE project_id = ? AND status = 'active' AND expires_at <= ?
@@ -289,6 +320,41 @@ function applyAction(context, action, reason, force, now) {
         });
         return { kind: action.kind, changed: true, session_id: action.session_id };
     }
+    if (action.kind === "discard_stale_run" && action.run_id) {
+        const run = context.db.get("SELECT status, runtime_path, run_dir, workspace_root, index_json FROM flow_runs WHERE project_id = ? AND id = ?", [action.project_id, action.run_id]);
+        if (!run) {
+            return { kind: action.kind, changed: false, skipped: true, reason: "run_not_found", run_id: action.run_id };
+        }
+        if (run.status === "discarded") {
+            const index = discardedRunIndex(run.index_json, reason, now);
+            context.db.run("UPDATE flow_runs SET verdict = 'discarded', next_action = ?, index_json = ?, updated_at = ?, completed_at = COALESCE(completed_at, ?) WHERE project_id = ? AND id = ?", [reason, JSON.stringify(index), now, now, action.project_id, action.run_id]);
+            if (fs.existsSync(run.runtime_path))
+                fs.writeFileSync(run.runtime_path, `${JSON.stringify(index, null, 2)}\n`);
+            return { kind: action.kind, changed: true, run_id: action.run_id };
+        }
+        if (run.status !== "running") {
+            return { kind: action.kind, changed: false, skipped: true, reason: `already_${run.status}`, run_id: action.run_id };
+        }
+        if (fs.existsSync(run.runtime_path) || fs.existsSync(run.run_dir) || fs.existsSync(run.workspace_root)) {
+            return { kind: action.kind, changed: false, skipped: true, reason: "runtime_or_workspace_reappeared", run_id: action.run_id };
+        }
+        const index = discardedRunIndex(run.index_json, reason, now);
+        context.db.run(`UPDATE flow_runs SET status = 'discarded', verdict = 'discarded', next_action = ?, index_json = ?, updated_at = ?, completed_at = ?
+       WHERE project_id = ? AND id = ? AND status = 'running'`, [reason, JSON.stringify(index), now, now, action.project_id, action.run_id]);
+        fs.mkdirSync(run.run_dir, { recursive: true });
+        fs.writeFileSync(run.runtime_path, `${JSON.stringify(index, null, 2)}\n`);
+        context.db.run(`UPDATE flow_sessions SET status = 'stopped', stop_reason = ?, updated_at = ?, stopped_at = ?
+       WHERE project_id = ? AND run_id = ? AND status IN ('pending', 'active', 'waiting_user', 'blocked', 'stopping')`, [reason, now, now, action.project_id, action.run_id]);
+        context.db.run("UPDATE flow_session_segments SET ended_at = ? WHERE project_id = ? AND run_id = ? AND ended_at IS NULL", [now, action.project_id, action.run_id]);
+        appendAudit(context, {
+            projectId: action.project_id,
+            eventType: "flow_run.discarded",
+            reason,
+            forced: force,
+            payload: { run_id: action.run_id, source: "cleanup.apply", authority_missing: true }
+        });
+        return { kind: action.kind, changed: true, run_id: action.run_id };
+    }
     if (action.kind === "expire_lane_lock" && typeof action.lock_id === "number") {
         const result = context.db.run("UPDATE lane_locks SET status = 'expired', reason = ?, updated_at = ? WHERE project_id = ? AND id = ? AND status = 'active'", [reason, now, action.project_id, action.lock_id]);
         return {
@@ -330,6 +396,17 @@ function applyAction(context, action, reason, force, now) {
     }
     return { kind: action.kind, changed: false, skipped: true, reason: "invalid_action" };
 }
+function discardedRunIndex(indexJson, reason, now) {
+    const index = JSON.parse(indexJson);
+    index.schema_id = "dd-flow/flow-run@2";
+    index.status = "discarded";
+    index.verdict = "discarded";
+    index.next_action = reason;
+    index.updated_at = now;
+    index.completed_at ??= now;
+    index.finished_at ??= now;
+    return index;
+}
 function dirtyGit(worktreePath) {
     if (!fs.existsSync(worktreePath)) {
         return false;

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

@@ -34,21 +34,63 @@ export function isReadOnlyCliOperation(args, env = process.env) {
 export function isMbUpgradeCliOperation(args, env = process.env) {
     return classifyCliOperation(args, env).mode === "mb_upgrade";
 }
-function isMbUpgradeMode(args, env) {
-    if (env.DD_FLOW_COMPATIBILITY_MODE === "mb-upgrade" || env.DD_FLOW_MB_UPGRADE_MODE === "1") {
+export function requiresExplicitUpgradeAuthorization(args) {
+    const positional = positionalArgs(args);
+    const [family, command] = positional;
+    if (family === "migration" && command === "apply")
         return true;
-    }
+    if (family === "run" && command === "start" && optionValue(args, "flow-kind") === "mb-upgrade")
+        return true;
+    return false;
+}
+function isMbUpgradeMode(args, env) {
+    const marked = env.DD_FLOW_COMPATIBILITY_MODE === "mb-upgrade" || env.DD_FLOW_MB_UPGRADE_MODE === "1";
     for (let index = 0; index < args.length; index += 1) {
         const arg = args[index];
         if (arg === "--compatibility-mode" && args[index + 1] === "mb-upgrade")
-            return true;
+            return isUpgradeAllowlisted(args);
         if (arg === "--mb-upgrade-mode")
-            return true;
-        if (arg?.startsWith("--compatibility-mode="))
-            return arg.slice("--compatibility-mode=".length) === "mb-upgrade";
+            return isUpgradeAllowlisted(args);
+        if (arg?.startsWith("--compatibility-mode=") && arg.slice("--compatibility-mode=".length) === "mb-upgrade") {
+            return isUpgradeAllowlisted(args);
+        }
     }
+    return marked && isUpgradeAllowlisted(args);
+}
+function isUpgradeAllowlisted(args) {
+    const positional = positionalArgs(args);
+    const [family, command] = positional;
+    if (family === "status")
+        return true;
+    if (family === "engine" && command === "resolve")
+        return true;
+    if (family === "migration" && ["impact", "plan", "report", "verify", "apply"].includes(command ?? ""))
+        return true;
+    if (family === "memory" && command === "permissions" && positional[2] === "preflight")
+        return true;
+    if (family === "run" && command === "start")
+        return optionValue(args, "flow-kind") === "mb-upgrade";
+    if (family === "stage" && ["start", "finish"].includes(command ?? ""))
+        return hasRunBinding(args);
+    if (family === "session" && ["status", "register", "stop", "usage"].includes(command ?? ""))
+        return hasRunBinding(args);
+    if (family === "dashboard" && ["data", "render", "refresh", "open"].includes(command ?? ""))
+        return true;
     return false;
 }
+function hasRunBinding(args) {
+    return Boolean(optionValue(args, "run") || positionalArgs(args).some((value) => value.startsWith("RUN-")));
+}
+function optionValue(args, name) {
+    for (let index = args.length - 1; index >= 0; index -= 1) {
+        const arg = args[index];
+        if (arg === `--${name}`)
+            return args[index + 1] ?? null;
+        if (arg?.startsWith(`--${name}=`))
+            return arg.slice(name.length + 3);
+    }
+    return null;
+}
 function isRouterNative(args) {
     const first = args[0];
     if (!first || first === "--version")
@@ -57,7 +99,9 @@ function isRouterNative(args) {
         return true;
     if (args.includes("--help") || args.includes("-h"))
         return true;
-    return ["engine", "version", "schema"].includes(first);
+    if (["engine", "version", "schema"].includes(first))
+        return true;
+    return first === "codex" && args[1] === "hook" && args[2] === "handle";
 }
 function isReadOnlyDiagnostic(family, command, action) {
     if (!family)

package/dist/services/compatibility-preflight.js

@@ -11,7 +11,7 @@ export function preflightCliCompatibility(context, args, env = process.env, reso
     if (!projectRoot) {
         return { ok: true, classification, compatibility: null };
     }
-    const selection = selectEngine(context, { projectRoot });
+    const selection = selectEngine(context, { projectRoot, env }, { allowCurrentInProcess: true }, classification);
     const compatibility = compatibilityReport(selection, classification);
     if (classification.mode === "read_only_diagnostics" || classification.mode === "mb_upgrade") {
         return { ok: true, classification, compatibility };

package/dist/services/dashboard.js

@@ -893,7 +893,7 @@ function planSummaryForProtocol(context, projectId, protocolId) {
         return { plan_id: "none", total: 0, done: 0, blocked: 0 };
     }
     try {
-        const summary = planSummary(context, { projectId, protocolId, planPath: protocol.plan_path });
+        const summary = planSummary(context, { projectId, protocolId, planPath: protocol.plan_path }, { bind: false });
         return { plan_id: summary.plan_id, total: summary.total, done: summary.done, blocked: summary.blocked };
     }
     catch {
@@ -909,7 +909,7 @@ function activePlanItems(context, projectId, protocols) {
         }
         let plan;
         try {
-            plan = planWithProgress(context, { projectId, protocolId: protocol.id, planPath: record.plan_path }).plan;
+            plan = planWithProgress(context, { projectId, protocolId: protocol.id, planPath: record.plan_path }, { bind: false }).plan;
         }
         catch {
             continue;