@rpamis/comet 0.4.0-beta.6 → 0.4.0-beta.8

package/assets/skills/comet/scripts/comet-runtime.mjs

@@ -126,17 +126,17 @@ var require_visit = __commonJS({
     visit.BREAK = BREAK;
     visit.SKIP = SKIP;
     visit.REMOVE = REMOVE;
-    function visit_(key, node, visitor, path23) {
-      const ctrl = callVisitor(key, node, visitor, path23);
+    function visit_(key, node, visitor, path24) {
+      const ctrl = callVisitor(key, node, visitor, path24);
       if (identity.isNode(ctrl) || identity.isPair(ctrl)) {
-        replaceNode(key, path23, ctrl);
-        return visit_(key, ctrl, visitor, path23);
+        replaceNode(key, path24, ctrl);
+        return visit_(key, ctrl, visitor, path24);
       }
       if (typeof ctrl !== "symbol") {
         if (identity.isCollection(node)) {
-          path23 = Object.freeze(path23.concat(node));
+          path24 = Object.freeze(path24.concat(node));
           for (let i = 0; i < node.items.length; ++i) {
-            const ci = visit_(i, node.items[i], visitor, path23);
+            const ci = visit_(i, node.items[i], visitor, path24);
             if (typeof ci === "number")
               i = ci - 1;
             else if (ci === BREAK)
@@ -147,13 +147,13 @@ var require_visit = __commonJS({
             }
           }
         } else if (identity.isPair(node)) {
-          path23 = Object.freeze(path23.concat(node));
-          const ck = visit_("key", node.key, visitor, path23);
+          path24 = Object.freeze(path24.concat(node));
+          const ck = visit_("key", node.key, visitor, path24);
           if (ck === BREAK)
             return BREAK;
           else if (ck === REMOVE)
             node.key = null;
-          const cv = visit_("value", node.value, visitor, path23);
+          const cv = visit_("value", node.value, visitor, path24);
           if (cv === BREAK)
             return BREAK;
           else if (cv === REMOVE)
@@ -174,17 +174,17 @@ var require_visit = __commonJS({
     visitAsync.BREAK = BREAK;
     visitAsync.SKIP = SKIP;
     visitAsync.REMOVE = REMOVE;
-    async function visitAsync_(key, node, visitor, path23) {
-      const ctrl = await callVisitor(key, node, visitor, path23);
+    async function visitAsync_(key, node, visitor, path24) {
+      const ctrl = await callVisitor(key, node, visitor, path24);
       if (identity.isNode(ctrl) || identity.isPair(ctrl)) {
-        replaceNode(key, path23, ctrl);
-        return visitAsync_(key, ctrl, visitor, path23);
+        replaceNode(key, path24, ctrl);
+        return visitAsync_(key, ctrl, visitor, path24);
       }
       if (typeof ctrl !== "symbol") {
         if (identity.isCollection(node)) {
-          path23 = Object.freeze(path23.concat(node));
+          path24 = Object.freeze(path24.concat(node));
           for (let i = 0; i < node.items.length; ++i) {
-            const ci = await visitAsync_(i, node.items[i], visitor, path23);
+            const ci = await visitAsync_(i, node.items[i], visitor, path24);
             if (typeof ci === "number")
               i = ci - 1;
             else if (ci === BREAK)
@@ -195,13 +195,13 @@ var require_visit = __commonJS({
             }
           }
         } else if (identity.isPair(node)) {
-          path23 = Object.freeze(path23.concat(node));
-          const ck = await visitAsync_("key", node.key, visitor, path23);
+          path24 = Object.freeze(path24.concat(node));
+          const ck = await visitAsync_("key", node.key, visitor, path24);
           if (ck === BREAK)
             return BREAK;
           else if (ck === REMOVE)
             node.key = null;
-          const cv = await visitAsync_("value", node.value, visitor, path23);
+          const cv = await visitAsync_("value", node.value, visitor, path24);
           if (cv === BREAK)
             return BREAK;
           else if (cv === REMOVE)
@@ -228,23 +228,23 @@ var require_visit = __commonJS({
       }
       return visitor;
     }
-    function callVisitor(key, node, visitor, path23) {
+    function callVisitor(key, node, visitor, path24) {
       if (typeof visitor === "function")
-        return visitor(key, node, path23);
+        return visitor(key, node, path24);
       if (identity.isMap(node))
-        return visitor.Map?.(key, node, path23);
+        return visitor.Map?.(key, node, path24);
       if (identity.isSeq(node))
-        return visitor.Seq?.(key, node, path23);
+        return visitor.Seq?.(key, node, path24);
       if (identity.isPair(node))
-        return visitor.Pair?.(key, node, path23);
+        return visitor.Pair?.(key, node, path24);
       if (identity.isScalar(node))
-        return visitor.Scalar?.(key, node, path23);
+        return visitor.Scalar?.(key, node, path24);
       if (identity.isAlias(node))
-        return visitor.Alias?.(key, node, path23);
+        return visitor.Alias?.(key, node, path24);
       return void 0;
     }
-    function replaceNode(key, path23, node) {
-      const parent = path23[path23.length - 1];
+    function replaceNode(key, path24, node) {
+      const parent = path24[path24.length - 1];
       if (identity.isCollection(parent)) {
         parent.items[key] = node;
       } else if (identity.isPair(parent)) {
@@ -854,10 +854,10 @@ var require_Collection = __commonJS({
     var createNode = require_createNode();
     var identity = require_identity();
     var Node = require_Node();
-    function collectionFromPath(schema, path23, value) {
+    function collectionFromPath(schema, path24, value) {
       let v = value;
-      for (let i = path23.length - 1; i >= 0; --i) {
-        const k = path23[i];
+      for (let i = path24.length - 1; i >= 0; --i) {
+        const k = path24[i];
         if (typeof k === "number" && Number.isInteger(k) && k >= 0) {
           const a = [];
           a[k] = v;
@@ -876,7 +876,7 @@ var require_Collection = __commonJS({
         sourceObjects: /* @__PURE__ */ new Map()
       });
     }
-    var isEmptyPath = (path23) => path23 == null || typeof path23 === "object" && !!path23[Symbol.iterator]().next().done;
+    var isEmptyPath = (path24) => path24 == null || typeof path24 === "object" && !!path24[Symbol.iterator]().next().done;
     var Collection = class extends Node.NodeBase {
       constructor(type, schema) {
         super(type);
@@ -906,11 +906,11 @@ var require_Collection = __commonJS({
        * be a Pair instance or a `{ key, value }` object, which may not have a key
        * that already exists in the map.
        */
-      addIn(path23, value) {
-        if (isEmptyPath(path23))
+      addIn(path24, value) {
+        if (isEmptyPath(path24))
           this.add(value);
         else {
-          const [key, ...rest] = path23;
+          const [key, ...rest] = path24;
           const node = this.get(key, true);
           if (identity.isCollection(node))
             node.addIn(rest, value);
@@ -924,8 +924,8 @@ var require_Collection = __commonJS({
        * Removes a value from the collection.
        * @returns `true` if the item was found and removed.
        */
-      deleteIn(path23) {
-        const [key, ...rest] = path23;
+      deleteIn(path24) {
+        const [key, ...rest] = path24;
         if (rest.length === 0)
           return this.delete(key);
         const node = this.get(key, true);
@@ -939,8 +939,8 @@ var require_Collection = __commonJS({
        * scalar values from their surrounding node; to disable set `keepScalar` to
        * `true` (collections are always returned intact).
        */
-      getIn(path23, keepScalar) {
-        const [key, ...rest] = path23;
+      getIn(path24, keepScalar) {
+        const [key, ...rest] = path24;
         const node = this.get(key, true);
         if (rest.length === 0)
           return !keepScalar && identity.isScalar(node) ? node.value : node;
@@ -958,8 +958,8 @@ var require_Collection = __commonJS({
       /**
        * Checks if the collection includes a value with the key `key`.
        */
-      hasIn(path23) {
-        const [key, ...rest] = path23;
+      hasIn(path24) {
+        const [key, ...rest] = path24;
         if (rest.length === 0)
           return this.has(key);
         const node = this.get(key, true);
@@ -969,8 +969,8 @@ var require_Collection = __commonJS({
        * Sets a value in this collection. For `!!set`, `value` needs to be a
        * boolean to add/remove the item from the set.
        */
-      setIn(path23, value) {
-        const [key, ...rest] = path23;
+      setIn(path24, value) {
+        const [key, ...rest] = path24;
         if (rest.length === 0) {
           this.set(key, value);
         } else {
@@ -3485,9 +3485,9 @@ var require_Document = __commonJS({
           this.contents.add(value);
       }
       /** Adds a value to the document. */
-      addIn(path23, value) {
+      addIn(path24, value) {
         if (assertCollection(this.contents))
-          this.contents.addIn(path23, value);
+          this.contents.addIn(path24, value);
       }
       /**
        * Create a new `Alias` node, ensuring that the target `node` has the required anchor.
@@ -3562,14 +3562,14 @@ var require_Document = __commonJS({
        * Removes a value from the document.
        * @returns `true` if the item was found and removed.
        */
-      deleteIn(path23) {
-        if (Collection.isEmptyPath(path23)) {
+      deleteIn(path24) {
+        if (Collection.isEmptyPath(path24)) {
           if (this.contents == null)
             return false;
           this.contents = null;
           return true;
         }
-        return assertCollection(this.contents) ? this.contents.deleteIn(path23) : false;
+        return assertCollection(this.contents) ? this.contents.deleteIn(path24) : false;
       }
       /**
        * Returns item at `key`, or `undefined` if not found. By default unwraps
@@ -3584,10 +3584,10 @@ var require_Document = __commonJS({
        * scalar values from their surrounding node; to disable set `keepScalar` to
        * `true` (collections are always returned intact).
        */
-      getIn(path23, keepScalar) {
-        if (Collection.isEmptyPath(path23))
+      getIn(path24, keepScalar) {
+        if (Collection.isEmptyPath(path24))
           return !keepScalar && identity.isScalar(this.contents) ? this.contents.value : this.contents;
-        return identity.isCollection(this.contents) ? this.contents.getIn(path23, keepScalar) : void 0;
+        return identity.isCollection(this.contents) ? this.contents.getIn(path24, keepScalar) : void 0;
       }
       /**
        * Checks if the document includes a value with the key `key`.
@@ -3598,10 +3598,10 @@ var require_Document = __commonJS({
       /**
        * Checks if the document includes a value at `path`.
        */
-      hasIn(path23) {
-        if (Collection.isEmptyPath(path23))
+      hasIn(path24) {
+        if (Collection.isEmptyPath(path24))
           return this.contents !== void 0;
-        return identity.isCollection(this.contents) ? this.contents.hasIn(path23) : false;
+        return identity.isCollection(this.contents) ? this.contents.hasIn(path24) : false;
       }
       /**
        * Sets a value in this document. For `!!set`, `value` needs to be a
@@ -3618,13 +3618,13 @@ var require_Document = __commonJS({
        * Sets a value in this document. For `!!set`, `value` needs to be a
        * boolean to add/remove the item from the set.
        */
-      setIn(path23, value) {
-        if (Collection.isEmptyPath(path23)) {
+      setIn(path24, value) {
+        if (Collection.isEmptyPath(path24)) {
           this.contents = value;
         } else if (this.contents == null) {
-          this.contents = Collection.collectionFromPath(this.schema, Array.from(path23), value);
+          this.contents = Collection.collectionFromPath(this.schema, Array.from(path24), value);
         } else if (assertCollection(this.contents)) {
-          this.contents.setIn(path23, value);
+          this.contents.setIn(path24, value);
         }
       }
       /**
@@ -5584,9 +5584,9 @@ var require_cst_visit = __commonJS({
     visit.BREAK = BREAK;
     visit.SKIP = SKIP;
     visit.REMOVE = REMOVE;
-    visit.itemAtPath = (cst, path23) => {
+    visit.itemAtPath = (cst, path24) => {
       let item = cst;
-      for (const [field2, index] of path23) {
+      for (const [field2, index] of path24) {
         const tok = item?.[field2];
         if (tok && "items" in tok) {
           item = tok.items[index];
@@ -5595,23 +5595,23 @@ var require_cst_visit = __commonJS({
       }
       return item;
     };
-    visit.parentCollection = (cst, path23) => {
-      const parent = visit.itemAtPath(cst, path23.slice(0, -1));
-      const field2 = path23[path23.length - 1][0];
+    visit.parentCollection = (cst, path24) => {
+      const parent = visit.itemAtPath(cst, path24.slice(0, -1));
+      const field2 = path24[path24.length - 1][0];
       const coll = parent?.[field2];
       if (coll && "items" in coll)
         return coll;
       throw new Error("Parent collection not found");
     };
-    function _visit(path23, item, visitor) {
-      let ctrl = visitor(item, path23);
+    function _visit(path24, item, visitor) {
+      let ctrl = visitor(item, path24);
       if (typeof ctrl === "symbol")
         return ctrl;
       for (const field2 of ["key", "value"]) {
         const token = item[field2];
         if (token && "items" in token) {
           for (let i = 0; i < token.items.length; ++i) {
-            const ci = _visit(Object.freeze(path23.concat([[field2, i]])), token.items[i], visitor);
+            const ci = _visit(Object.freeze(path24.concat([[field2, i]])), token.items[i], visitor);
             if (typeof ci === "number")
               i = ci - 1;
             else if (ci === BREAK)
@@ -5622,10 +5622,10 @@ var require_cst_visit = __commonJS({
             }
           }
           if (typeof ctrl === "function" && field2 === "key")
-            ctrl = ctrl(item, path23);
+            ctrl = ctrl(item, path24);
         }
       }
-      return typeof ctrl === "function" ? ctrl(item, path23) : ctrl;
+      return typeof ctrl === "function" ? ctrl(item, path24) : ctrl;
     }
     exports.visit = visit;
   }
@@ -6927,14 +6927,14 @@ var require_parser = __commonJS({
             case "scalar":
             case "single-quoted-scalar":
             case "double-quoted-scalar": {
-              const fs22 = this.flowScalar(this.type);
+              const fs23 = this.flowScalar(this.type);
               if (atNextItem || it.value) {
-                map.items.push({ start, key: fs22, sep: [] });
+                map.items.push({ start, key: fs23, sep: [] });
                 this.onKeyLine = true;
               } else if (it.sep) {
-                this.stack.push(fs22);
+                this.stack.push(fs23);
               } else {
-                Object.assign(it, { key: fs22, sep: [] });
+                Object.assign(it, { key: fs23, sep: [] });
                 this.onKeyLine = true;
               }
               return;
@@ -7062,13 +7062,13 @@ var require_parser = __commonJS({
             case "scalar":
             case "single-quoted-scalar":
             case "double-quoted-scalar": {
-              const fs22 = this.flowScalar(this.type);
+              const fs23 = this.flowScalar(this.type);
               if (!it || it.value)
-                fc.items.push({ start: [], key: fs22, sep: [] });
+                fc.items.push({ start: [], key: fs23, sep: [] });
               else if (it.sep)
-                this.stack.push(fs22);
+                this.stack.push(fs23);
               else
-                Object.assign(it, { key: fs22, sep: [] });
+                Object.assign(it, { key: fs23, sep: [] });
               return;
             }
             case "flow-map-end":
@@ -7546,8 +7546,8 @@ import { pathToFileURL } from "url";
 // domains/comet-classic/classic-archive.ts
 import { createHash as createHash3 } from "crypto";
 import { spawnSync } from "child_process";
-import { promises as fs11 } from "fs";
-import path12 from "path";
+import { promises as fs14 } from "fs";
+import path15 from "path";
 
 // domains/comet-classic/classic-paths.ts
 import { promises as fs } from "fs";
@@ -9016,6 +9016,11 @@ async function fileExists2(file) {
     throw error;
   }
 }
+async function isClassicRuntimePackageRoot(root) {
+  if (!await directoryExists(root)) return false;
+  if (await fileExists2(path10.join(root, "skill.yaml"))) return true;
+  return await fileExists2(path10.join(root, "SKILL.md")) && await fileExists2(path10.join(root, "comet", "skill.yaml"));
+}
 function embeddedClassicRuntimePackage(root) {
   return {
     root,
@@ -9254,7 +9259,7 @@ async function classicRuntimeRoot() {
     path10.resolve("assets", "skills", "comet-classic")
   ].filter((candidate) => Boolean(candidate));
   for (const candidate of candidates) {
-    if (await directoryExists(candidate)) return candidate;
+    if (await isClassicRuntimePackageRoot(candidate)) return candidate;
   }
   return null;
 }
@@ -9525,6 +9530,324 @@ function applyClassicTransition(current, event, options = {}) {
   return { classic, effects, definition };
 }
 
+// domains/comet-classic/classic-current-change.ts
+import { promises as fs13 } from "fs";
+import path14 from "path";
+
+// domains/comet-entry/current-selection.ts
+import { randomUUID as randomUUID6 } from "crypto";
+import { promises as fs11 } from "fs";
+import path12 from "path";
+var COMET_CURRENT_SELECTION_SCHEMA = "comet.selection.v2";
+var COMET_CURRENT_SELECTION_MAX_BYTES = 16 * 1024;
+function cometCurrentSelectionFile(projectRoot2) {
+  return path12.join(projectRoot2, ".comet", "current-change.json");
+}
+function isRecord(value) {
+  return Boolean(value) && typeof value === "object" && !Array.isArray(value);
+}
+function validBranch(value) {
+  return value === null || typeof value === "string";
+}
+function parseSelection(source) {
+  let value;
+  try {
+    value = JSON.parse(source);
+  } catch (error) {
+    throw new Error(
+      `current change selection contains invalid JSON: ${error instanceof Error ? error.message : String(error)}`,
+      { cause: error }
+    );
+  }
+  if (!isRecord(value)) {
+    throw new Error("current change selection must be a JSON object");
+  }
+  if (value.version === 1) {
+    if (typeof value.change !== "string") {
+      throw new Error("legacy current change selection change must be a string");
+    }
+    if (value.branch !== void 0 && !validBranch(value.branch)) {
+      throw new Error("legacy current change selection branch must be a string or null");
+    }
+    return {
+      selection: {
+        schema: COMET_CURRENT_SELECTION_SCHEMA,
+        workflow: "classic",
+        change: value.change,
+        branch: value.branch ?? null
+      },
+      legacy: true
+    };
+  }
+  if (value.schema !== COMET_CURRENT_SELECTION_SCHEMA) {
+    throw new Error(`current change selection schema must be ${COMET_CURRENT_SELECTION_SCHEMA}`);
+  }
+  if (value.workflow !== "native" && value.workflow !== "classic") {
+    throw new Error("current change selection workflow must be native or classic");
+  }
+  if (typeof value.change !== "string") {
+    throw new Error("current change selection change must be a string");
+  }
+  if (!validBranch(value.branch)) {
+    throw new Error("current change selection branch must be a string or null");
+  }
+  if (value.workflow === "native" && value.branch !== null) {
+    throw new Error("Native current change selection branch must be null");
+  }
+  return { selection: value, legacy: false };
+}
+async function readCometCurrentSelection(projectRoot2) {
+  let source;
+  try {
+    const stat = await fs11.lstat(cometCurrentSelectionFile(projectRoot2));
+    if (stat.isSymbolicLink() || !stat.isFile()) {
+      throw new Error("current change selection must be a regular file");
+    }
+    if (stat.size > COMET_CURRENT_SELECTION_MAX_BYTES) {
+      throw new Error(
+        `current change selection exceeds ${COMET_CURRENT_SELECTION_MAX_BYTES} bytes`
+      );
+    }
+    source = await fs11.readFile(cometCurrentSelectionFile(projectRoot2), "utf8");
+  } catch (error) {
+    if (error.code === "ENOENT") return { status: "missing" };
+    throw new Error(
+      `cannot read current change selection: ${error instanceof Error ? error.message : String(error)}`,
+      { cause: error }
+    );
+  }
+  const parsed = parseSelection(source);
+  return { status: "selected", ...parsed };
+}
+async function writeCometCurrentSelection(projectRoot2, selection) {
+  const parsed = parseSelection(JSON.stringify(selection));
+  if (parsed.legacy) throw new Error("cannot write a legacy current change selection");
+  const file = cometCurrentSelectionFile(projectRoot2);
+  const temporary = `${file}.${randomUUID6()}.tmp`;
+  await fs11.mkdir(path12.dirname(file), { recursive: true });
+  try {
+    await fs11.writeFile(temporary, `${JSON.stringify(parsed.selection, null, 2)}
+`, "utf8");
+    await fs11.rename(temporary, file);
+  } catch (error) {
+    await fs11.rm(temporary, { force: true });
+    throw error;
+  }
+}
+async function clearCometCurrentSelection(projectRoot2) {
+  await fs11.rm(cometCurrentSelectionFile(projectRoot2), { force: true });
+}
+async function clearCometCurrentSelectionIf(projectRoot2, workflow, change) {
+  const current = await readCometCurrentSelection(projectRoot2);
+  if (current.status !== "selected" || current.selection.workflow !== workflow || current.selection.change !== change) {
+    return false;
+  }
+  await clearCometCurrentSelection(projectRoot2);
+  return true;
+}
+
+// domains/comet-classic/classic-branch-binding.ts
+var import_yaml3 = __toESM(require_dist(), 1);
+import { execFileSync } from "child_process";
+import { randomUUID as randomUUID7 } from "crypto";
+import { promises as fs12 } from "fs";
+import path13 from "path";
+function liveGitBranch(cwd) {
+  try {
+    const branch = execFileSync("git", ["rev-parse", "--abbrev-ref", "HEAD"], {
+      cwd,
+      encoding: "utf8",
+      stdio: ["ignore", "pipe", "ignore"]
+    }).trim();
+    return branch && branch !== "HEAD" ? branch : null;
+  } catch {
+    return null;
+  }
+}
+function isGitWorkTree(cwd) {
+  try {
+    return execFileSync("git", ["rev-parse", "--is-inside-work-tree"], {
+      cwd,
+      encoding: "utf8",
+      stdio: ["ignore", "pipe", "ignore"]
+    }).trim() === "true";
+  } catch {
+    return false;
+  }
+}
+var BOUND_BRANCH_ISOLATIONS = ["current", "branch", "worktree"];
+function requiresBranchBinding(isolation) {
+  return BOUND_BRANCH_ISOLATIONS.includes(isolation);
+}
+function evaluateBranchBinding(input) {
+  if (!requiresBranchBinding(input.isolation)) return { status: "not-applicable" };
+  if (input.boundBranch === null && input.currentBranch === null && input.gitWorkTree === false) {
+    return { status: "not-applicable" };
+  }
+  if (input.boundBranch === null) {
+    return input.currentBranch === null ? { status: "unbound-detached" } : { status: "needs-heal", branch: input.currentBranch };
+  }
+  if (input.currentBranch === input.boundBranch) return { status: "ok" };
+  return { status: "drift", boundBranch: input.boundBranch, currentBranch: input.currentBranch };
+}
+async function resolveBranchBinding(changeDir, options) {
+  const file = path13.join(changeDir, ".comet.yaml");
+  const document = (0, import_yaml3.parseDocument)(await fs12.readFile(file, "utf8"), { uniqueKeys: false });
+  if (document.errors.length > 0) {
+    throw new Error(`Invalid .comet.yaml: ${document.errors[0].message}`);
+  }
+  const record = document.toJS() ?? {};
+  const isolation = typeof record.isolation === "string" ? record.isolation : null;
+  const boundBranch = typeof record.bound_branch === "string" && record.bound_branch !== "" ? record.bound_branch : null;
+  const bindingRequired = requiresBranchBinding(isolation);
+  const currentBranch = liveGitBranch(options.cwd);
+  const gitWorkTree = bindingRequired && boundBranch === null && currentBranch === null ? isGitWorkTree(options.cwd) : true;
+  const verdict = evaluateBranchBinding({ isolation, boundBranch, currentBranch, gitWorkTree });
+  if (verdict.status === "needs-heal" && options.heal) {
+    await healBoundBranch(changeDir, verdict.branch);
+    return { status: "healed", branch: verdict.branch, bindingRequired, currentBranch };
+  }
+  return { ...verdict, bindingRequired, currentBranch };
+}
+async function healBoundBranch(changeDir, branch) {
+  const file = path13.join(changeDir, ".comet.yaml");
+  const document = (0, import_yaml3.parseDocument)(await fs12.readFile(file, "utf8"), { uniqueKeys: false });
+  document.set("bound_branch", branch);
+  const temporary = `${file}.${randomUUID7()}.tmp`;
+  try {
+    await fs12.writeFile(temporary, document.toString(), "utf8");
+    await fs12.rename(temporary, file);
+  } catch (error) {
+    await fs12.rm(temporary, { force: true });
+    throw error;
+  }
+}
+function branchLabel(currentBranch) {
+  return currentBranch ?? "detached HEAD";
+}
+function driftBlockedMessage(change, boundBranch, currentBranch) {
+  return `change '${change}' is bound to branch '${boundBranch}', but current branch is '${branchLabel(currentBranch)}'.
+Next: ask the user to confirm — switch back to '${boundBranch}', or run \`comet state rebind ${change}\` after explicit confirmation.`;
+}
+function driftStaleReason(change, boundBranch, currentBranch) {
+  return `change '${change}' is bound to branch '${boundBranch}', but current branch is '${branchLabel(currentBranch)}'`;
+}
+function unboundDetachedMessage(change) {
+  return `change '${change}' uses a branch-bound workspace mode but has no bound branch and HEAD is detached; checkout a branch first before continuing.`;
+}
+
+// domains/comet-classic/classic-current-change.ts
+function changeDirectory(projectRoot2, changeName) {
+  return path14.join(projectRoot2, "openspec", "changes", changeName);
+}
+async function validateActiveChange(projectRoot2, changeName) {
+  assertOpenSpecChangeName(changeName);
+  const changeDir = changeDirectory(projectRoot2, changeName);
+  try {
+    await fs13.access(path14.join(changeDir, ".comet.yaml"));
+  } catch (error) {
+    if (error.code === "ENOENT") {
+      throw new Error(
+        `Cannot select current change '${changeName}': active change state not found`,
+        {
+          cause: error
+        }
+      );
+    }
+    throw error;
+  }
+  const projection = await readClassicState(changeDir, { migrate: false });
+  if (!projection.classic) {
+    throw new Error(`Cannot select current change '${changeName}': Classic state is incomplete`);
+  }
+  if (projection.classic.archived) {
+    throw new Error(`Cannot select current change '${changeName}': change is archived`);
+  }
+}
+async function selectCurrentChange(projectRoot2, changeName) {
+  await validateActiveChange(projectRoot2, changeName);
+  const outcome = await resolveBranchBinding(changeDirectory(projectRoot2, changeName), {
+    heal: true,
+    cwd: projectRoot2
+  });
+  if (outcome.status === "drift") {
+    throw new Error(driftStaleReason(changeName, outcome.boundBranch, outcome.currentBranch));
+  }
+  if (outcome.status === "unbound-detached") {
+    throw new Error(unboundDetachedMessage(changeName));
+  }
+  const selection = {
+    schema: "comet.selection.v2",
+    workflow: "classic",
+    change: changeName,
+    branch: outcome.currentBranch
+  };
+  await writeCometCurrentSelection(projectRoot2, selection);
+  return selection;
+}
+async function resolveCurrentChange(projectRoot2) {
+  let current;
+  try {
+    current = await readCometCurrentSelection(projectRoot2);
+  } catch (error) {
+    return {
+      status: "stale",
+      reason: error instanceof Error ? error.message : String(error)
+    };
+  }
+  if (current.status === "missing") return { status: "missing" };
+  if (current.selection.workflow !== "classic") {
+    return {
+      status: "stale",
+      reason: `current change '${current.selection.change}' belongs to Native, not Classic`
+    };
+  }
+  const selection = current.selection;
+  try {
+    await validateActiveChange(projectRoot2, selection.change);
+  } catch (error) {
+    return {
+      status: "stale",
+      reason: error instanceof Error ? error.message : String(error)
+    };
+  }
+  const outcome = await resolveBranchBinding(changeDirectory(projectRoot2, selection.change), {
+    heal: false,
+    cwd: projectRoot2
+  });
+  if (outcome.status === "drift") {
+    return {
+      status: "stale",
+      reason: driftStaleReason(selection.change, outcome.boundBranch, outcome.currentBranch)
+    };
+  }
+  if (outcome.status === "unbound-detached") {
+    return { status: "stale", reason: unboundDetachedMessage(selection.change) };
+  }
+  if (outcome.status === "ok") return { status: "selected", selection };
+  if (selection.branch !== null && outcome.currentBranch !== selection.branch) {
+    return {
+      status: "stale",
+      reason: `current change '${selection.change}' was selected on branch '${selection.branch}', current branch is '${outcome.currentBranch ?? "detached HEAD"}'`
+    };
+  }
+  return { status: "selected", selection };
+}
+async function clearCurrentChange(projectRoot2) {
+  let current;
+  try {
+    current = await readCometCurrentSelection(projectRoot2);
+  } catch {
+    return;
+  }
+  if (current.status === "selected" && current.selection.workflow === "classic") {
+    await clearCometCurrentSelection(projectRoot2);
+  }
+}
+async function clearCurrentChangeIf(projectRoot2, change) {
+  return clearCometCurrentSelectionIf(projectRoot2, "classic", change);
+}
+
 // domains/comet-classic/classic-archive.ts
 var GREEN = "\x1B[32m";
 var RED = "\x1B[31m";
@@ -9559,7 +9882,7 @@ var ArchiveOutput = class {
 };
 async function exists2(file) {
   try {
-    await fs11.access(file);
+    await fs14.access(file);
     return true;
   } catch (error) {
     if (error.code === "ENOENT") return false;
@@ -9613,10 +9936,10 @@ async function findArchiveDir(change, preferred) {
   if (await exists2(preferred)) return preferred;
   const archiveRoot = "openspec/changes/archive";
   if (!await exists2(archiveRoot)) return null;
-  for (const entry2 of (await fs11.readdir(archiveRoot)).sort()) {
+  for (const entry2 of (await fs14.readdir(archiveRoot)).sort()) {
     if (!entry2.endsWith(`-${change}`)) continue;
     const candidate = `${archiveRoot}/${entry2}`;
-    if ((await fs11.stat(candidate)).isDirectory()) return candidate;
+    if ((await fs14.stat(candidate)).isDirectory()) return candidate;
   }
   return null;
 }
@@ -9646,9 +9969,9 @@ async function annotateFrontmatter(output, file, archiveName, extraFields, dryRu
     output.stepsTotal += 1;
     return;
   }
-  const original = await fs11.readFile(file, "utf8");
+  const original = await fs14.readFile(file, "utf8");
   const updated = annotatedMarkdown(original, archiveName, extraFields);
-  await fs11.writeFile(file, updated);
+  await fs14.writeFile(file, updated);
   output.stderr.push(green(`  [OK] Annotated: ${file}`));
   output.stepsOk += 1;
   output.stepsTotal += 1;
@@ -9657,10 +9980,10 @@ async function verifyMainSpecsClean() {
   const specsRoot = "openspec/specs";
   if (!await exists2(specsRoot)) return;
   let found = false;
-  for (const entry2 of await fs11.readdir(specsRoot)) {
+  for (const entry2 of await fs14.readdir(specsRoot)) {
     const specFile = `${specsRoot}/${entry2}/spec.md`;
     if (!await exists2(specFile)) continue;
-    const matches = (await fs11.readFile(specFile, "utf8")).split(/\r?\n/u).map((line, index) => ({ line, number: index + 1 })).filter((item) => /^## (ADDED|MODIFIED|REMOVED|RENAMED) Requirements$/u.test(item.line));
+    const matches = (await fs14.readFile(specFile, "utf8")).split(/\r?\n/u).map((line, index) => ({ line, number: index + 1 })).filter((item) => /^## (ADDED|MODIFIED|REMOVED|RENAMED) Requirements$/u.test(item.line));
     if (matches.length > 0) {
       found = true;
       process.stderr.write(
@@ -9692,7 +10015,7 @@ var classicArchiveCommand = async (args) => {
     }
     if (recoveredArchive) {
       archiveDir = recoveredArchive;
-      archiveName = path12.basename(recoveredArchive);
+      archiveName = path15.basename(recoveredArchive);
     }
     const projection = await readClassicState(changeDir);
     if (!projection.classic) {
@@ -9787,7 +10110,7 @@ var classicArchiveCommand = async (args) => {
         return output.toResult(1);
       }
       archiveDir = resolvedArchive;
-      archiveName = path12.basename(resolvedArchive);
+      archiveName = path15.basename(resolvedArchive);
       output.stderr.push(green(`  [OK] OpenSpec archive completed: ${archiveDir}`));
       output.stepsOk += 1;
       output.stepsTotal += 1;
@@ -9894,6 +10217,7 @@ var classicArchiveCommand = async (args) => {
       output.stepsOk += 1;
       output.stepsTotal += 1;
     }
+    if (!dryRun) await clearCurrentChangeIf(process.cwd(), change);
     output.stderr.push("");
     output.stderr.push(
       dryRun ? yellow(`Dry run complete. ${output.stepsOk}/${output.stepsTotal} steps would succeed.`) : green(`Archive complete. ${output.stepsOk}/${output.stepsTotal} steps succeeded.`)
@@ -9914,27 +10238,27 @@ var classicArchiveCommand = async (args) => {
 var import_yaml6 = __toESM(require_dist(), 1);
 import { spawnSync as spawnSync2 } from "child_process";
 import { createHash as createHash4 } from "crypto";
-import { existsSync, promises as fs16, readFileSync } from "fs";
-import path17 from "path";
+import { existsSync, promises as fs18, readFileSync } from "fs";
+import path19 from "path";
 
 // domains/comet-classic/classic-command-checks.ts
-import path13 from "path";
+import path16 from "path";
 function validateScope(scope) {
   if (scope !== "build" && scope !== "verify") {
     throw new Error(`Invalid command check scope: '${String(scope)}'`);
   }
 }
 function projectRoot(changeDir) {
-  return path13.resolve(changeDir, "..", "..", "..");
+  return path16.resolve(changeDir, "..", "..", "..");
 }
 function normalizedCwd(changeDir, cwd = ".") {
   if (cwd.trim().length === 0) throw new Error("Command check cwd cannot be blank");
   const root = projectRoot(changeDir);
-  const target = path13.resolve(root, cwd);
-  if (target !== root && !target.startsWith(root + path13.sep)) {
+  const target = path16.resolve(root, cwd);
+  if (target !== root && !target.startsWith(root + path16.sep)) {
     throw new Error(`Command check cwd must resolve within the project root: '${cwd}'`);
   }
-  return path13.relative(root, target).replaceAll("\\", "/") || ".";
+  return path16.relative(root, target).replaceAll("\\", "/") || ".";
 }
 function validRecord(changeDir, event) {
   if (event.type !== "command_check_recorded") return null;
@@ -10095,9 +10419,9 @@ async function inspectClassicChange(changeDir, name) {
 }
 
 // domains/comet-classic/classic-validate-command.ts
-var import_yaml3 = __toESM(require_dist(), 1);
-import { promises as fs12 } from "fs";
-import path14 from "path";
+var import_yaml4 = __toESM(require_dist(), 1);
+import { promises as fs15 } from "fs";
+import path17 from "path";
 var GREEN2 = "\x1B[32m";
 var RED2 = "\x1B[31m";
 var YELLOW2 = "\x1B[33m";
@@ -10147,7 +10471,7 @@ function color(code, message) {
 }
 async function exists3(file) {
   try {
-    await fs12.access(file);
+    await fs15.access(file);
     return true;
   } catch (error) {
     if (error.code === "ENOENT") return false;
@@ -10168,7 +10492,7 @@ var classicValidateCommand = async (args) => {
     };
   }
   const { directory, label } = await resolveClassicChangeDirectory(name);
-  const yamlFile = path14.join(directory, ".comet.yaml");
+  const yamlFile = path17.join(directory, ".comet.yaml");
   const lines = [`[VALIDATE] ${label}/.comet.yaml`];
   let errors = 0;
   let warnings = 0;
@@ -10182,7 +10506,7 @@ var classicValidateCommand = async (args) => {
   };
   let source;
   try {
-    source = await fs12.readFile(yamlFile, "utf8");
+    source = await fs15.readFile(yamlFile, "utf8");
   } catch (error) {
     if (error.code === "ENOENT") {
       fail3(".comet.yaml does not exist");
@@ -10191,10 +10515,10 @@ var classicValidateCommand = async (args) => {
     }
     throw error;
   }
-  const document = (0, import_yaml3.parseDocument)(source);
-  if (document.errors.length > 0 || !(0, import_yaml3.isMap)(document.contents)) {
+  const document = (0, import_yaml4.parseDocument)(source);
+  if (document.errors.length > 0 || !(0, import_yaml4.isMap)(document.contents)) {
     for (const error of document.errors) fail3(error.message);
-    if (!(0, import_yaml3.isMap)(document.contents)) fail3("document root must be a mapping");
+    if (!(0, import_yaml4.isMap)(document.contents)) fail3("document root must be a mapping");
     lines.push("", color(RED2, `${errors} error(s), ${warnings} warning(s) — validation FAILED`));
     return { exitCode: 1, stderr: lines.join("\n") };
   }
@@ -10231,7 +10555,7 @@ var classicValidateCommand = async (args) => {
   }
   for (const field2 of ["design_doc", "plan", "handoff_context"]) {
     const value = text(record[field2]);
-    if (value && !await exists3(path14.resolve(value))) {
+    if (value && !await exists3(path17.resolve(value))) {
       fail3(`${field2}='${value}' does not exist on disk`);
     }
   }
@@ -10254,16 +10578,16 @@ var classicValidateCommand = async (args) => {
 };
 
 // domains/comet-classic/classic-project-config.ts
-var import_yaml4 = __toESM(require_dist(), 1);
+var import_yaml5 = __toESM(require_dist(), 1);
 import os from "os";
-import { promises as fs14 } from "fs";
-import path15 from "path";
+import { promises as fs17 } from "fs";
+import path18 from "path";
 
 // platform/fs/file-system.ts
-import { promises as fs13 } from "fs";
+import { promises as fs16 } from "fs";
 async function fileExists3(filePath) {
   try {
-    await fs13.access(filePath);
+    await fs16.access(filePath);
     return true;
   } catch (error) {
     if (isNotFoundError(error)) return false;
@@ -10272,7 +10596,7 @@ async function fileExists3(filePath) {
 }
 async function readDir(dirPath) {
   try {
-    return await fs13.readdir(dirPath);
+    return await fs16.readdir(dirPath);
   } catch (error) {
     const code = error?.code;
     if (code === "ENOENT" || code === "ENOTDIR") {
@@ -10290,9 +10614,9 @@ function configCandidates(options = {}) {
   const cwd = options.cwd ?? process.cwd();
   const homeDir = options.homeDir ?? os.homedir();
   const candidates = [
-    { file: path15.resolve(cwd, ".comet", "config.yaml"), source: ".comet/config.yaml" },
+    { file: path18.resolve(cwd, ".comet", "config.yaml"), source: ".comet/config.yaml" },
     {
-      file: path15.resolve(homeDir, ".comet", "config.yaml"),
+      file: path18.resolve(homeDir, ".comet", "config.yaml"),
       source: "~/.comet/config.yaml"
     }
   ];
@@ -10303,106 +10627,20 @@ function configCandidates(options = {}) {
 async function readClassicConfigValue(field2, options = {}) {
   for (const candidate of configCandidates(options)) {
     if (!await fileExists3(candidate.file)) continue;
-    const document = (0, import_yaml4.parseDocument)(await fs14.readFile(candidate.file, "utf8"), {
+    const document = (0, import_yaml5.parseDocument)(await fs17.readFile(candidate.file, "utf8"), {
       uniqueKeys: false
     });
-    const value = document.get(field2);
+    const root = document.toJS();
+    if (!root || typeof root !== "object" || Array.isArray(root)) continue;
+    const classic = root.classic;
+    if (!classic || typeof classic !== "object" || Array.isArray(classic)) continue;
+    const value = classic[field2];
     if (value === null || value === void 0) continue;
     return { value: String(value), source: candidate.source };
   }
   return null;
 }
 
-// domains/comet-classic/classic-branch-binding.ts
-var import_yaml5 = __toESM(require_dist(), 1);
-import { execFileSync } from "child_process";
-import { randomUUID as randomUUID6 } from "crypto";
-import { promises as fs15 } from "fs";
-import path16 from "path";
-function liveGitBranch(cwd) {
-  try {
-    const branch = execFileSync("git", ["rev-parse", "--abbrev-ref", "HEAD"], {
-      cwd,
-      encoding: "utf8",
-      stdio: ["ignore", "pipe", "ignore"]
-    }).trim();
-    return branch && branch !== "HEAD" ? branch : null;
-  } catch {
-    return null;
-  }
-}
-function isGitWorkTree(cwd) {
-  try {
-    return execFileSync("git", ["rev-parse", "--is-inside-work-tree"], {
-      cwd,
-      encoding: "utf8",
-      stdio: ["ignore", "pipe", "ignore"]
-    }).trim() === "true";
-  } catch {
-    return false;
-  }
-}
-var BOUND_BRANCH_ISOLATIONS = ["current", "branch", "worktree"];
-function requiresBranchBinding(isolation) {
-  return BOUND_BRANCH_ISOLATIONS.includes(isolation);
-}
-function evaluateBranchBinding(input) {
-  if (!requiresBranchBinding(input.isolation)) return { status: "not-applicable" };
-  if (input.boundBranch === null && input.currentBranch === null && input.gitWorkTree === false) {
-    return { status: "not-applicable" };
-  }
-  if (input.boundBranch === null) {
-    return input.currentBranch === null ? { status: "unbound-detached" } : { status: "needs-heal", branch: input.currentBranch };
-  }
-  if (input.currentBranch === input.boundBranch) return { status: "ok" };
-  return { status: "drift", boundBranch: input.boundBranch, currentBranch: input.currentBranch };
-}
-async function resolveBranchBinding(changeDir, options) {
-  const file = path16.join(changeDir, ".comet.yaml");
-  const document = (0, import_yaml5.parseDocument)(await fs15.readFile(file, "utf8"), { uniqueKeys: false });
-  if (document.errors.length > 0) {
-    throw new Error(`Invalid .comet.yaml: ${document.errors[0].message}`);
-  }
-  const record = document.toJS() ?? {};
-  const isolation = typeof record.isolation === "string" ? record.isolation : null;
-  const boundBranch = typeof record.bound_branch === "string" && record.bound_branch !== "" ? record.bound_branch : null;
-  const bindingRequired = requiresBranchBinding(isolation);
-  const currentBranch = liveGitBranch(options.cwd);
-  const gitWorkTree = bindingRequired && boundBranch === null && currentBranch === null ? isGitWorkTree(options.cwd) : true;
-  const verdict = evaluateBranchBinding({ isolation, boundBranch, currentBranch, gitWorkTree });
-  if (verdict.status === "needs-heal" && options.heal) {
-    await healBoundBranch(changeDir, verdict.branch);
-    return { status: "healed", branch: verdict.branch, bindingRequired, currentBranch };
-  }
-  return { ...verdict, bindingRequired, currentBranch };
-}
-async function healBoundBranch(changeDir, branch) {
-  const file = path16.join(changeDir, ".comet.yaml");
-  const document = (0, import_yaml5.parseDocument)(await fs15.readFile(file, "utf8"), { uniqueKeys: false });
-  document.set("bound_branch", branch);
-  const temporary = `${file}.${randomUUID6()}.tmp`;
-  try {
-    await fs15.writeFile(temporary, document.toString(), "utf8");
-    await fs15.rename(temporary, file);
-  } catch (error) {
-    await fs15.rm(temporary, { force: true });
-    throw error;
-  }
-}
-function branchLabel(currentBranch) {
-  return currentBranch ?? "detached HEAD";
-}
-function driftBlockedMessage(change, boundBranch, currentBranch) {
-  return `change '${change}' is bound to branch '${boundBranch}', but current branch is '${branchLabel(currentBranch)}'.
-Next: ask the user to confirm — switch back to '${boundBranch}', or run \`comet state rebind ${change}\` after explicit confirmation.`;
-}
-function driftStaleReason(change, boundBranch, currentBranch) {
-  return `change '${change}' is bound to branch '${boundBranch}', but current branch is '${branchLabel(currentBranch)}'`;
-}
-function unboundDetachedMessage(change) {
-  return `change '${change}' uses a branch-bound workspace mode but has no bound branch and HEAD is detached; checkout a branch first before continuing.`;
-}
-
 // domains/comet-classic/classic-guard.ts
 var GREEN3 = "\x1B[32m";
 var RED3 = "\x1B[31m";
@@ -10467,7 +10705,7 @@ var GuardOutput = class {
 };
 async function exists4(file) {
   try {
-    await fs16.access(file);
+    await fs18.access(file);
     return true;
   } catch (error) {
     if (error.code === "ENOENT") return false;
@@ -10476,7 +10714,7 @@ async function exists4(file) {
 }
 async function nonempty(file) {
   try {
-    return (await fs16.stat(file)).size > 0;
+    return (await fs18.stat(file)).size > 0;
   } catch (error) {
     if (error.code === "ENOENT") return false;
     throw error;
@@ -10490,8 +10728,8 @@ async function resolveChangeDir(name) {
   return (await resolveClassicChangeDirectory(name)).label;
 }
 async function readField(changeDir, field2) {
-  const file = path17.join(changeDir, ".comet.yaml");
-  const document = (0, import_yaml6.parseDocument)(await fs16.readFile(file, "utf8"), { uniqueKeys: false });
+  const file = path19.join(changeDir, ".comet.yaml");
+  const document = (0, import_yaml6.parseDocument)(await fs18.readFile(file, "utf8"), { uniqueKeys: false });
   if (document.errors.length > 0) {
     throw new GuardFailure(`ERROR: Invalid .comet.yaml: ${document.errors[0].message}`);
   }
@@ -10532,7 +10770,7 @@ function countEnglishWords(source) {
 }
 async function documentLanguageMatchesConfigured(changeDir, file) {
   const language = await configuredLanguage(changeDir);
-  const source = stripFencedCodeBlocks(await fs16.readFile(file, "utf8"));
+  const source = stripFencedCodeBlocks(await fs18.readFile(file, "utf8"));
   const cjk = countCjkChars(source);
   const englishWords = countEnglishWords(source);
   if (language === "zh-CN" && cjk < 20 && englishWords >= 20) {
@@ -10556,7 +10794,7 @@ async function handoffSourceFiles(changeDir) {
   const files = [`${changeDir}/proposal.md`, `${changeDir}/design.md`, `${changeDir}/tasks.md`];
   const specs = `${changeDir}/specs`;
   if (await exists4(specs)) {
-    for (const entry2 of (await fs16.readdir(specs)).sort()) {
+    for (const entry2 of (await fs18.readdir(specs)).sort()) {
       const spec = `${specs}/${entry2}/spec.md`;
       if (await exists4(spec)) files.push(spec);
     }
@@ -10576,7 +10814,7 @@ async function preflight(changeDir, name) {
   if (!await exists4(changeDir)) {
     throw new GuardFailure(red2(`FATAL: change directory not found: ${changeDir}`));
   }
-  if (!await exists4(path17.join(changeDir, ".comet.yaml"))) {
+  if (!await exists4(path19.join(changeDir, ".comet.yaml"))) {
     throw new GuardFailure(red2(`FATAL: .comet.yaml not found in ${changeDir}`));
   }
   const result5 = await classicValidateCommand([name], { json: false });
@@ -10646,9 +10884,9 @@ var INFERRED_COMMAND_SOURCES = [
   "Cargo.toml"
 ];
 async function removedProjectCommandField(field2) {
-  const config = path17.join(".comet", "config.yaml");
+  const config = path19.join(".comet", "config.yaml");
   if (!await exists4(config)) return false;
-  const document = (0, import_yaml6.parseDocument)(await fs16.readFile(config, "utf8"));
+  const document = (0, import_yaml6.parseDocument)(await fs18.readFile(config, "utf8"));
   if (document.errors.length > 0) {
     throw new Error(
       `.comet/config.yaml is invalid YAML (${document.errors[0].message}); cannot check for removed "${field2}" field. Fix the config and retry.`
@@ -10729,14 +10967,14 @@ ${recoveryCommand(change, scope, recorded.command)}`
   return { status: 0, output: evidenceDetail(recorded) };
 }
 async function tasksAllDone(changeDir) {
-  const tasks = path17.join(changeDir, "tasks.md");
+  const tasks = path19.join(changeDir, "tasks.md");
   if (!await exists4(tasks)) {
     return fail(
       `tasks.md is missing at ${tasks}
 Next: restore or create tasks.md for this change before leaving build.`
     );
   }
-  const source = await fs16.readFile(tasks, "utf8");
+  const source = await fs18.readFile(tasks, "utf8");
   if (!/- \[x\]/u.test(source)) {
     return fail(
       "tasks.md has no completed tasks.\nNext: complete implementation tasks and mark them with '- [x]'."
@@ -10753,9 +10991,9 @@ Next: complete or explicitly remove unfinished tasks, then mark tasks.md with '-
   return pass();
 }
 async function tasksHasAny(changeDir) {
-  const tasks = path17.join(changeDir, "tasks.md");
+  const tasks = path19.join(changeDir, "tasks.md");
   if (!await exists4(tasks)) return false;
-  return /- \[/u.test(await fs16.readFile(tasks, "utf8"));
+  return /- \[/u.test(await fs18.readFile(tasks, "utf8"));
 }
 async function planTasksAllDone(changeDir) {
   const plan = await readField(changeDir, "plan");
@@ -10766,7 +11004,7 @@ async function planTasksAllDone(changeDir) {
 Next: restore the Superpowers plan file or update .comet.yaml plan before leaving build.`
     );
   }
-  const source = await fs16.readFile(plan, "utf8");
+  const source = await fs18.readFile(plan, "utf8");
   const unfinished = source.split(/\r?\n/u).map((line, index) => ({ line, number: index + 1 })).filter((entry2) => /^\s*- \[ \]/u.test(entry2.line));
   if (unfinished.length > 0) {
     return fail(
@@ -10880,7 +11118,7 @@ async function archivedIsTrue(changeDir) {
   return await readField(changeDir, "archived") === "true";
 }
 async function designDocFrontmatterHas(designDoc, field2, expected) {
-  const source = (await fs16.readFile(designDoc, "utf8")).replace(/^\uFEFF/u, "");
+  const source = (await fs18.readFile(designDoc, "utf8")).replace(/^\uFEFF/u, "");
   let inFrontmatter = false;
   for (const line of source.split(/\r?\n/u)) {
     if (!inFrontmatter) {
@@ -10945,7 +11183,8 @@ async function designHandoffMarkdownTraceable(changeDir) {
   const markdown = `${context.replace(/\.json$/u, "")}.md`;
   if (!await nonempty(markdown))
     return fail(`design handoff markdown is missing or empty: ${markdown}`);
-  const source = await fs16.readFile(markdown, "utf8");
+  const source = await fs18.readFile(markdown, "utf8");
+  const lines = new Set(source.split(/\r?\n/u));
   const problems = [];
   if (!/^Generated-by: comet-handoff\.sh$/mu.test(source)) {
     problems.push("handoff markdown is missing Generated-by marker");
@@ -10955,10 +11194,10 @@ async function designHandoffMarkdownTraceable(changeDir) {
   }
   for (const file of await handoffSourceFiles(changeDir)) {
     if (!await exists4(file)) continue;
-    if (!new RegExp(`^- Source: ${file}$`, "mu").test(source)) {
+    if (!lines.has(`- Source: ${file}`)) {
       problems.push(`handoff markdown is missing source reference: ${file}`);
     }
-    if (!new RegExp(`^- SHA256: ${hashFile(file)}$`, "mu").test(source)) {
+    if (!lines.has(`- SHA256: ${hashFile(file)}`)) {
       problems.push(`handoff markdown is missing current sha256 for: ${file}`);
     }
   }
@@ -10972,7 +11211,7 @@ async function betaSpecJsonStructurallyValid(changeDir) {
   const context = await readField(changeDir, "handoff_context");
   if (!context || context === "null") return fail("handoff_context is missing from .comet.yaml");
   if (!await nonempty(context)) return fail(`spec-context.json is missing or empty: ${context}`);
-  const source = await fs16.readFile(context, "utf8");
+  const source = await fs18.readFile(context, "utf8");
   const problems = [];
   let parsed;
   try {
@@ -11009,19 +11248,19 @@ async function guardOpenChecks(output, changeDir) {
   const checks = [
     check(
       "proposal.md exists and non-empty",
-      async () => await nonempty(path17.join(changeDir, "proposal.md")) ? pass() : fail("")
+      async () => await nonempty(path19.join(changeDir, "proposal.md")) ? pass() : fail("")
     ),
     check(
       "proposal.md matches configured language",
-      () => documentLanguageMatchesConfigured(changeDir, path17.join(changeDir, "proposal.md"))
+      () => documentLanguageMatchesConfigured(changeDir, path19.join(changeDir, "proposal.md"))
     ),
     check(
       "tasks.md exists and non-empty",
-      async () => await nonempty(path17.join(changeDir, "tasks.md")) ? pass() : fail("")
+      async () => await nonempty(path19.join(changeDir, "tasks.md")) ? pass() : fail("")
     ),
     check(
       "tasks.md matches configured language",
-      () => documentLanguageMatchesConfigured(changeDir, path17.join(changeDir, "tasks.md"))
+      () => documentLanguageMatchesConfigured(changeDir, path19.join(changeDir, "tasks.md"))
     ),
     check(
       "tasks.md has at least one task",
@@ -11034,11 +11273,11 @@ async function guardOpenChecks(output, changeDir) {
       0,
       check(
         "design.md exists and non-empty",
-        async () => await nonempty(path17.join(changeDir, "design.md")) ? pass() : fail("")
+        async () => await nonempty(path19.join(changeDir, "design.md")) ? pass() : fail("")
       ),
       check(
         "design.md matches configured language",
-        () => documentLanguageMatchesConfigured(changeDir, path17.join(changeDir, "design.md"))
+        () => documentLanguageMatchesConfigured(changeDir, path19.join(changeDir, "design.md"))
       )
     );
   }
@@ -11050,27 +11289,27 @@ async function guardDesignChecks(output, changeDir, change) {
   const builders = [
     check(
       "proposal.md exists",
-      async () => await nonempty(path17.join(changeDir, "proposal.md")) ? pass() : fail("")
+      async () => await nonempty(path19.join(changeDir, "proposal.md")) ? pass() : fail("")
     ),
     check(
       "proposal.md matches configured language",
-      () => documentLanguageMatchesConfigured(changeDir, path17.join(changeDir, "proposal.md"))
+      () => documentLanguageMatchesConfigured(changeDir, path19.join(changeDir, "proposal.md"))
     ),
     check(
       "design.md exists",
-      async () => await nonempty(path17.join(changeDir, "design.md")) ? pass() : fail("")
+      async () => await nonempty(path19.join(changeDir, "design.md")) ? pass() : fail("")
     ),
     check(
       "design.md matches configured language",
-      () => documentLanguageMatchesConfigured(changeDir, path17.join(changeDir, "design.md"))
+      () => documentLanguageMatchesConfigured(changeDir, path19.join(changeDir, "design.md"))
     ),
     check(
       "tasks.md exists",
-      async () => await nonempty(path17.join(changeDir, "tasks.md")) ? pass() : fail("")
+      async () => await nonempty(path19.join(changeDir, "tasks.md")) ? pass() : fail("")
     ),
     check(
       "tasks.md matches configured language",
-      () => documentLanguageMatchesConfigured(changeDir, path17.join(changeDir, "tasks.md"))
+      () => documentLanguageMatchesConfigured(changeDir, path19.join(changeDir, "tasks.md"))
     ),
     check("design handoff context exists", () => designHandoffContextValid(changeDir, change)),
     check("design handoff markdown is traceable", () => designHandoffMarkdownTraceable(changeDir))
@@ -11132,11 +11371,11 @@ async function guardBuildChecks(output, changeDir, change, run) {
     check("Superpowers plan all tasks checked", () => planTasksAllDone(changeDir)),
     check(
       "proposal.md exists",
-      async () => await nonempty(path17.join(changeDir, "proposal.md")) ? pass() : fail("")
+      async () => await nonempty(path19.join(changeDir, "proposal.md")) ? pass() : fail("")
     ),
     check(
       "proposal.md matches configured language",
-      () => documentLanguageMatchesConfigured(changeDir, path17.join(changeDir, "proposal.md"))
+      () => documentLanguageMatchesConfigured(changeDir, path19.join(changeDir, "proposal.md"))
     ),
     check("Superpowers plan matches configured language", async () => {
       const plan = await readField(changeDir, "plan");
@@ -11178,11 +11417,11 @@ async function guardArchiveChecks(output, changeDir, change) {
     check("archived is true", async () => await archivedIsTrue(changeDir) ? pass() : fail("")),
     check(
       "proposal.md exists",
-      async () => await nonempty(path17.join(changeDir, "proposal.md")) ? pass() : fail("")
+      async () => await nonempty(path19.join(changeDir, "proposal.md")) ? pass() : fail("")
     ),
     check(
       "design.md exists",
-      async () => await nonempty(path17.join(changeDir, "design.md")) ? pass() : fail("")
+      async () => await nonempty(path19.join(changeDir, "design.md")) ? pass() : fail("")
     ),
     check("tasks.md all tasks checked", () => tasksAllDone(changeDir)),
     check(
@@ -11272,8 +11511,8 @@ Valid phases: open, design, build, verify, archive`
 // domains/comet-classic/classic-handoff.ts
 var import_yaml7 = __toESM(require_dist(), 1);
 import { createHash as createHash5 } from "crypto";
-import { promises as fs17, readFileSync as readFileSync2 } from "fs";
-import path18 from "path";
+import { promises as fs19, readFileSync as readFileSync2 } from "fs";
+import path20 from "path";
 var GREEN4 = "\x1B[32m";
 var RED4 = "\x1B[31m";
 var YELLOW4 = "\x1B[33m";
@@ -11307,7 +11546,7 @@ var HandoffOutput = class {
 };
 async function exists5(file) {
   try {
-    await fs17.access(file);
+    await fs19.access(file);
     return true;
   } catch (error) {
     if (error.code === "ENOENT") return false;
@@ -11316,7 +11555,7 @@ async function exists5(file) {
 }
 async function nonempty2(file) {
   try {
-    return (await fs17.stat(file)).size > 0;
+    return (await fs19.stat(file)).size > 0;
   } catch (error) {
     if (error.code === "ENOENT") return false;
     throw error;
@@ -11345,7 +11584,7 @@ async function handoffSourceFiles2(changeDir) {
   const files = [`${changeDir}/proposal.md`, `${changeDir}/design.md`, `${changeDir}/tasks.md`];
   const specs = `${changeDir}/specs`;
   if (await exists5(specs)) {
-    for (const entry2 of (await fs17.readdir(specs)).sort()) {
+    for (const entry2 of (await fs19.readdir(specs)).sort()) {
       const spec = `${specs}/${entry2}/spec.md`;
       if (await exists5(spec)) files.push(spec);
     }
@@ -11393,7 +11632,7 @@ async function writeMarkdownContext(changeDir, change, mode, contextHash, output
   ];
   for (const file of await handoffSourceFiles2(changeDir)) {
     if (!await exists5(file)) continue;
-    const content = await fs17.readFile(file, "utf8");
+    const content = await fs19.readFile(file, "utf8");
     const total = lineCount(content);
     lines.push(
       `## ${file}`,
@@ -11418,7 +11657,7 @@ async function writeMarkdownContext(changeDir, change, mode, contextHash, output
     }
     lines.push("");
   }
-  await fs17.writeFile(output, lines.join("\n"));
+  await fs19.writeFile(output, lines.join("\n"));
 }
 async function writeJsonContext(changeDir, change, mode, contextHash, output) {
   const entries = [];
@@ -11441,7 +11680,7 @@ async function writeJsonContext(changeDir, change, mode, contextHash, output) {
     "}",
     ""
   ].join("\n");
-  await fs17.writeFile(output, document);
+  await fs19.writeFile(output, document);
 }
 async function writeSpecProjectionForFile(file, content) {
   return [
@@ -11481,11 +11720,11 @@ async function writeSpecMarkdownContext(changeDir, change, contextHash, output)
   const specs = `${changeDir}/specs`;
   let projected = false;
   if (await exists5(specs)) {
-    for (const entry2 of (await fs17.readdir(specs)).sort()) {
+    for (const entry2 of (await fs19.readdir(specs)).sort()) {
       const spec = `${specs}/${entry2}/spec.md`;
       if (!await exists5(spec)) continue;
       projected = true;
-      lines.push(...await writeSpecProjectionForFile(spec, await fs17.readFile(spec, "utf8")));
+      lines.push(...await writeSpecProjectionForFile(spec, await fs19.readFile(spec, "utf8")));
     }
   }
   if (!projected) {
@@ -11494,7 +11733,7 @@ async function writeSpecMarkdownContext(changeDir, change, contextHash, output)
   lines.push(
     "Full source files remain canonical. If a required heading or scenario is missing here, regenerate the handoff or read the source spec directly. Supporting files (proposal, design, tasks) are referenced by hash only."
   );
-  await fs17.writeFile(output, lines.join("\n"));
+  await fs19.writeFile(output, lines.join("\n"));
 }
 async function writeSpecJsonContext(changeDir, change, contextHash, output) {
   const entries = [];
@@ -11503,7 +11742,7 @@ async function writeSpecJsonContext(changeDir, change, contextHash, output) {
     const role = /\/specs\/[^/]+\/spec\.md$/u.test(file) ? "spec" : "supporting";
     entries.push({ path: file, sha256: hashFile2(file), role });
   }
-  await fs17.writeFile(
+  await fs19.writeFile(
     output,
     `${JSON.stringify(
       {
@@ -11522,8 +11761,8 @@ async function writeSpecJsonContext(changeDir, change, contextHash, output) {
   );
 }
 async function readField2(changeDir, field2) {
-  const file = path18.join(changeDir, ".comet.yaml");
-  const document = (0, import_yaml7.parseDocument)(await fs17.readFile(file, "utf8"), { uniqueKeys: false });
+  const file = path20.join(changeDir, ".comet.yaml");
+  const document = (0, import_yaml7.parseDocument)(await fs19.readFile(file, "utf8"), { uniqueKeys: false });
   if (document.errors.length > 0) {
     throw new HandoffFailure(`ERROR: Invalid .comet.yaml: ${document.errors[0].message}`);
   }
@@ -11557,7 +11796,7 @@ async function completedHandoffIsCurrent(changeDir, run, contextHash, contextJso
     readCheckpoint(changeDir, run.checkpointRef)
   ]);
   if (!await exists5(contextJson) || !await exists5(contextMd)) return false;
-  if (context !== await fs17.readFile(contextMd, "utf8")) return false;
+  if (context !== await fs19.readFile(contextMd, "utf8")) return false;
   if (artifacts.handoff_context !== contextJson || artifacts.handoff_markdown !== contextMd) {
     return false;
   }
@@ -11680,7 +11919,7 @@ var classicHandoffCommand = async (args) => {
       run: pendingRun,
       unknownKeys: (await readClassicState(changeDir)).unknownKeys
     });
-    await fs17.mkdir(handoffDir, { recursive: true });
+    await fs19.mkdir(handoffDir, { recursive: true });
     if (handoffMode === "beta") {
       await writeSpecMarkdownContext(changeDir, change, contextHash, contextMd);
       await writeSpecJsonContext(changeDir, change, contextHash, contextJson);
@@ -11688,7 +11927,7 @@ var classicHandoffCommand = async (args) => {
       await writeMarkdownContext(changeDir, change, handoffMode, contextHash, contextMd);
       await writeJsonContext(changeDir, change, handoffMode, contextHash, contextJson);
     }
-    const context = await fs17.readFile(contextMd, "utf8");
+    const context = await fs19.readFile(contextMd, "utf8");
     await writeContext(changeDir, pendingRun.contextRef, context);
     const artifacts = {
       ...await readArtifacts(changeDir, pendingRun.artifactsRef),
@@ -11745,152 +11984,8 @@ var classicHandoffCommand = async (args) => {
 };
 
 // domains/comet-classic/classic-hook-guard.ts
-import { existsSync as existsSync2, promises as fs19, readFileSync as readFileSync3 } from "fs";
-import path20 from "path";
-
-// domains/comet-classic/classic-current-change.ts
-import { randomUUID as randomUUID7 } from "crypto";
-import { promises as fs18 } from "fs";
-import path19 from "path";
-function currentChangeFile(projectRoot2) {
-  return path19.join(projectRoot2, ".comet", "current-change.json");
-}
-function changeDirectory(projectRoot2, changeName) {
-  return path19.join(projectRoot2, "openspec", "changes", changeName);
-}
-async function validateActiveChange(projectRoot2, changeName) {
-  assertOpenSpecChangeName(changeName);
-  const changeDir = changeDirectory(projectRoot2, changeName);
-  try {
-    await fs18.access(path19.join(changeDir, ".comet.yaml"));
-  } catch (error) {
-    if (error.code === "ENOENT") {
-      throw new Error(
-        `Cannot select current change '${changeName}': active change state not found`,
-        {
-          cause: error
-        }
-      );
-    }
-    throw error;
-  }
-  const projection = await readClassicState(changeDir, { migrate: false });
-  if (!projection.classic) {
-    throw new Error(`Cannot select current change '${changeName}': Classic state is incomplete`);
-  }
-  if (projection.classic.archived) {
-    throw new Error(`Cannot select current change '${changeName}': change is archived`);
-  }
-}
-function parseSelection(source) {
-  let value;
-  try {
-    value = JSON.parse(source);
-  } catch (error) {
-    throw new Error(
-      `current change selection contains invalid JSON: ${error instanceof Error ? error.message : String(error)}`,
-      { cause: error }
-    );
-  }
-  if (!value || typeof value !== "object" || Array.isArray(value)) {
-    throw new Error("current change selection must be a JSON object");
-  }
-  const record = value;
-  if (record.version !== 1) {
-    throw new Error("current change selection version must be 1");
-  }
-  if (typeof record.change !== "string") {
-    throw new Error("current change selection change must be a string");
-  }
-  assertOpenSpecChangeName(record.change);
-  if (record.branch !== void 0 && record.branch !== null && typeof record.branch !== "string") {
-    throw new Error("current change selection branch must be a string or null");
-  }
-  return {
-    version: 1,
-    change: record.change,
-    branch: record.branch ?? null
-  };
-}
-async function selectCurrentChange(projectRoot2, changeName) {
-  await validateActiveChange(projectRoot2, changeName);
-  const outcome = await resolveBranchBinding(changeDirectory(projectRoot2, changeName), {
-    heal: true,
-    cwd: projectRoot2
-  });
-  if (outcome.status === "drift") {
-    throw new Error(driftStaleReason(changeName, outcome.boundBranch, outcome.currentBranch));
-  }
-  if (outcome.status === "unbound-detached") {
-    throw new Error(unboundDetachedMessage(changeName));
-  }
-  const selection = {
-    version: 1,
-    change: changeName,
-    branch: outcome.currentBranch
-  };
-  const file = currentChangeFile(projectRoot2);
-  const temporary = `${file}.${randomUUID7()}.tmp`;
-  await fs18.mkdir(path19.dirname(file), { recursive: true });
-  try {
-    await fs18.writeFile(temporary, JSON.stringify(selection, null, 2) + "\n", "utf8");
-    await fs18.rename(temporary, file);
-  } catch (error) {
-    await fs18.rm(temporary, { force: true });
-    throw error;
-  }
-  return selection;
-}
-async function resolveCurrentChange(projectRoot2) {
-  let source;
-  try {
-    source = await fs18.readFile(currentChangeFile(projectRoot2), "utf8");
-  } catch (error) {
-    if (error.code === "ENOENT") return { status: "missing" };
-    return {
-      status: "stale",
-      reason: `cannot read current change selection: ${error instanceof Error ? error.message : String(error)}`
-    };
-  }
-  let selection;
-  try {
-    selection = parseSelection(source);
-    await validateActiveChange(projectRoot2, selection.change);
-  } catch (error) {
-    return {
-      status: "stale",
-      reason: error instanceof Error ? error.message : String(error)
-    };
-  }
-  const outcome = await resolveBranchBinding(changeDirectory(projectRoot2, selection.change), {
-    heal: false,
-    cwd: projectRoot2
-  });
-  if (outcome.status === "drift") {
-    return {
-      status: "stale",
-      reason: driftStaleReason(selection.change, outcome.boundBranch, outcome.currentBranch)
-    };
-  }
-  if (outcome.status === "unbound-detached") {
-    return { status: "stale", reason: unboundDetachedMessage(selection.change) };
-  }
-  if (outcome.status === "ok") {
-    return { status: "selected", selection };
-  }
-  if (selection.branch !== null && outcome.currentBranch !== selection.branch) {
-    return {
-      status: "stale",
-      reason: `current change '${selection.change}' was selected on branch '${selection.branch}', current branch is '${outcome.currentBranch ?? "detached HEAD"}'`
-    };
-  }
-  return { status: "selected", selection };
-}
-async function clearCurrentChange(projectRoot2) {
-  await fs18.rm(currentChangeFile(projectRoot2), { force: true });
-}
-
-// domains/comet-classic/classic-hook-guard.ts
+import { existsSync as existsSync2, promises as fs20, readFileSync as readFileSync3 } from "fs";
+import path21 from "path";
 function result(exitCode, message) {
   return { exitCode, stderr: message + "\n" };
 }
@@ -11919,52 +12014,52 @@ function comparisonKey(value) {
 function parseProjectRoot(args) {
   const index = args.indexOf("--project-root");
   const value = index >= 0 ? args[index + 1] : void 0;
-  return path20.resolve(value && !value.startsWith("--") ? value : process.cwd());
+  return path21.resolve(value && !value.startsWith("--") ? value : process.cwd());
 }
 function relativeToProjectRoot(target, projectRoot2) {
-  const relative = normalized(path20.relative(projectRoot2, target));
+  const relative = normalized(path21.relative(projectRoot2, target));
   if (relative === "") return "";
-  if (relative.startsWith("../") || relative === ".." || path20.isAbsolute(relative)) return null;
+  if (relative.startsWith("../") || relative === ".." || path21.isAbsolute(relative)) return null;
   return relative;
 }
 async function physicalPathForPossiblyMissingTarget(target) {
-  const resolved = path20.resolve(target);
-  const root = path20.parse(resolved).root;
+  const resolved = path21.resolve(target);
+  const root = path21.parse(resolved).root;
   const missingSegments = [];
   let cursor = resolved;
   while (cursor && cursor !== root) {
     try {
-      const physicalBase = await fs19.realpath(cursor);
-      return path20.join(physicalBase, ...missingSegments.reverse());
+      const physicalBase = await fs20.realpath(cursor);
+      return path21.join(physicalBase, ...missingSegments.reverse());
     } catch (error) {
       const code = error.code;
       if (code !== "ENOENT" && code !== "ENOTDIR") throw error;
-      missingSegments.push(path20.basename(cursor));
-      cursor = path20.dirname(cursor);
+      missingSegments.push(path21.basename(cursor));
+      cursor = path21.dirname(cursor);
     }
   }
   try {
-    const physicalRoot = await fs19.realpath(root);
-    return path20.join(physicalRoot, ...missingSegments.reverse());
+    const physicalRoot = await fs20.realpath(root);
+    return path21.join(physicalRoot, ...missingSegments.reverse());
   } catch {
     return null;
   }
 }
 async function projectRelative(target, projectRoot2) {
-  const rawCandidate = path20.isAbsolute(target) ? target : path20.resolve(process.cwd(), target);
+  const rawCandidate = path21.isAbsolute(target) ? target : path21.resolve(process.cwd(), target);
   let candidate = normalized(rawCandidate);
   const rootRelative = relativeToProjectRoot(rawCandidate, projectRoot2);
   if (rootRelative !== null) return rootRelative;
   try {
     const physicalCandidate = await physicalPathForPossiblyMissingTarget(rawCandidate);
-    const physicalRoot = await fs19.realpath(projectRoot2);
+    const physicalRoot = await fs20.realpath(projectRoot2);
     if (physicalCandidate) {
       const physicalRootRelative = relativeToProjectRoot(physicalCandidate, physicalRoot);
       if (physicalRootRelative !== null) return physicalRootRelative;
       candidate = normalized(physicalCandidate);
     }
   } catch {
-    if (!path20.isAbsolute(target)) return normalized(target).replace(/^\.\//u, "");
+    if (!path21.isAbsolute(target)) return normalized(target).replace(/^\.\//u, "");
   }
   return candidate.replace(/^\.\//u, "");
 }
@@ -11994,15 +12089,15 @@ async function loadGoverningChange(changeDir) {
   }
 }
 async function activeChanges(projectRoot2) {
-  const changesDir = path20.join(projectRoot2, "openspec", "changes");
+  const changesDir = path21.join(projectRoot2, "openspec", "changes");
   const governingChanges = [];
   if (!existsSync2(changesDir)) return governingChanges;
-  for (const entry2 of (await fs19.readdir(changesDir, { withFileTypes: true })).sort(
+  for (const entry2 of (await fs20.readdir(changesDir, { withFileTypes: true })).sort(
     (left, right) => left.name.localeCompare(right.name)
   )) {
     if (!entry2.isDirectory() || entry2.name === "archive") continue;
-    const changeDir = path20.join(changesDir, entry2.name);
-    if (!existsSync2(path20.join(changeDir, ".comet.yaml"))) continue;
+    const changeDir = path21.join(changesDir, entry2.name);
+    if (!existsSync2(path21.join(changeDir, ".comet.yaml"))) continue;
     const governing = await loadGoverningChange(changeDir);
     if (!governing || governing.archived) continue;
     governingChanges.push(governing);
@@ -12050,7 +12145,7 @@ function allowsSuperpowersArtifacts(governing) {
   return governing.phase === "design" || governing.phase === "build" || governing.phase === "verify";
 }
 function governingChangeName(governing) {
-  return governing.changeDir ? path20.basename(governing.changeDir) : null;
+  return governing.changeDir ? path21.basename(governing.changeDir) : null;
 }
 var SUPERPOWERS_ARTIFACT_SUFFIXES = /* @__PURE__ */ new Set([
   "design",
@@ -12097,9 +12192,20 @@ async function superpowersArtifactGoverningChange(relativePath2, projectRoot2) {
   if (named) return { governing: named, match: "named" };
   return null;
 }
-async function repoSourceGoverningChange(projectRoot2, relativePath2) {
+async function repoSourceGoverningChange(projectRoot2, relativePath2, selectedChangeName) {
   const active = await activeChanges(projectRoot2);
   if (active.length === 0) return null;
+  if (selectedChangeName) {
+    const selected = active.find(
+      (governing) => governingChangeName(governing) === selectedChangeName
+    );
+    return selected ?? {
+      blockedResult: blockedStaleSelection(
+        relativePath2,
+        `selected change '${selectedChangeName}' is no longer active`
+      )
+    };
+  }
   const current = await resolveCurrentChange(projectRoot2);
   if (current.status === "stale") {
     return { blockedResult: blockedStaleSelection(relativePath2, current.reason) };
@@ -12147,14 +12253,14 @@ async function repoSourceGoverningChange(projectRoot2, relativePath2) {
     )
   };
 }
-async function governingChange(relativePath2, projectRoot2) {
+async function governingChange(relativePath2, projectRoot2, selectedChangeName) {
   const prefix = "openspec/changes/";
   if (relativePath2.startsWith(prefix)) {
     const rest = relativePath2.slice(prefix.length);
     const [name] = rest.split("/");
     if (name && name !== "archive") {
-      const changeDir = path20.join(projectRoot2, "openspec", "changes", name);
-      const stateFile2 = path20.join(changeDir, ".comet.yaml");
+      const changeDir = path21.join(projectRoot2, "openspec", "changes", name);
+      const stateFile2 = path21.join(changeDir, ".comet.yaml");
       if (existsSync2(stateFile2)) {
         const governing = await loadGoverningChange(changeDir);
         if (governing) return governing;
@@ -12177,7 +12283,11 @@ async function governingChange(relativePath2, projectRoot2) {
       } : { ...superpowers.governing, superpowersArtifact: "matched" };
     }
     if (slot) {
-      const candidate = await repoSourceGoverningChange(projectRoot2, relativePath2);
+      const candidate = await repoSourceGoverningChange(
+        projectRoot2,
+        relativePath2,
+        selectedChangeName
+      );
       if (!candidate || "blockedResult" in candidate) return candidate;
       return {
         ...candidate,
@@ -12185,10 +12295,11 @@ async function governingChange(relativePath2, projectRoot2) {
         superpowersSlot: slot
       };
     }
-    const fallback = (await activeChanges(projectRoot2))[0] ?? null;
+    const active = await activeChanges(projectRoot2);
+    const fallback = selectedChangeName ? active.find((candidate) => governingChangeName(candidate) === selectedChangeName) ?? null : active[0] ?? null;
     return fallback ? { ...fallback, superpowersArtifact: "unmatched" } : null;
   }
-  return repoSourceGoverningChange(projectRoot2, relativePath2);
+  return repoSourceGoverningChange(projectRoot2, relativePath2, selectedChangeName);
 }
 function isRootMarkdown(relativePath2) {
   return !relativePath2.includes("/") && relativePath2.endsWith(".md");
@@ -12344,10 +12455,7 @@ function blockedStaleSelection(relativePath2, reason) {
     ].join("\n")
   );
 }
-var classicHookGuardCommand = async (args) => {
-  const projectRoot2 = parseProjectRoot(args);
-  const target = inputTarget();
-  if (!target) return allowed("no file path in tool input");
+async function inspectClassicHookTarget(projectRoot2, target, selectedChangeName) {
   const relativePath2 = await projectRelative(target, projectRoot2);
   if (isCometConfig(relativePath2)) {
     return allowed(`${relativePath2} (whitelist: comet config)`);
@@ -12363,7 +12471,7 @@ var classicHookGuardCommand = async (args) => {
   }
   let governing;
   try {
-    governing = await governingChange(relativePath2, projectRoot2);
+    governing = await governingChange(relativePath2, projectRoot2, selectedChangeName);
   } catch (error) {
     return result(
       2,
@@ -12391,6 +12499,12 @@ var classicHookGuardCommand = async (args) => {
     return allowed(`${relativePath2} (phase: ${phase})`);
   }
   return blocked(relativePath2, phase);
+}
+var classicHookGuardCommand = async (args) => {
+  const projectRoot2 = parseProjectRoot(args);
+  const target = inputTarget();
+  if (!target) return allowed("no file path in tool input");
+  return inspectClassicHookTarget(projectRoot2, target);
 };
 
 // domains/comet-classic/classic-intent.ts
@@ -12446,7 +12560,7 @@ ${issues.map((issue) => `- ${issue}`).join("\n")}`);
   }
   issues;
 };
-function isRecord(value) {
+function isRecord2(value) {
   return typeof value === "object" && value !== null && !Array.isArray(value);
 }
 function enumValue2(value, allowed2, field2, issues) {
@@ -12499,15 +12613,15 @@ function nonNegativeIntegerValue(value, field2, issues) {
 }
 function validateFrame(input) {
   const issues = [];
-  if (!isRecord(input)) throw new CometIntentValidationError(["frame must be an object"]);
-  const intent = isRecord(input.intent) ? input.intent : {};
-  if (!isRecord(input.intent)) issues.push("intent must be an object");
-  const slots = isRecord(input.slots) ? input.slots : {};
-  if (!isRecord(input.slots)) issues.push("slots must be an object");
-  const context = isRecord(input.context) ? input.context : {};
-  if (!isRecord(input.context)) issues.push("context must be an object");
-  const proposedRouteInput = isRecord(input.proposed_route) ? input.proposed_route : {};
-  if (!isRecord(input.proposed_route)) issues.push("proposed_route must be an object");
+  if (!isRecord2(input)) throw new CometIntentValidationError(["frame must be an object"]);
+  const intent = isRecord2(input.intent) ? input.intent : {};
+  if (!isRecord2(input.intent)) issues.push("intent must be an object");
+  const slots = isRecord2(input.slots) ? input.slots : {};
+  if (!isRecord2(input.slots)) issues.push("slots must be an object");
+  const context = isRecord2(input.context) ? input.context : {};
+  if (!isRecord2(input.context)) issues.push("context must be an object");
+  const proposedRouteInput = isRecord2(input.proposed_route) ? input.proposed_route : {};
+  if (!isRecord2(input.proposed_route)) issues.push("proposed_route must be an object");
   const entities = input.entities === void 0 ? [] : Array.isArray(input.entities) ? input.entities : [];
   if (input.entities !== void 0 && !Array.isArray(input.entities)) {
     issues.push("entities must be an array");
@@ -12528,8 +12642,8 @@ function validateFrame(input) {
       confidence: confidenceValue(intent.confidence, "intent.confidence", issues)
     },
     entities: entities.map((entity, index) => {
-      const record = isRecord(entity) ? entity : {};
-      if (!isRecord(entity)) issues.push(`entities[${index}] must be an object`);
+      const record = isRecord2(entity) ? entity : {};
+      if (!isRecord2(entity)) issues.push(`entities[${index}] must be an object`);
       return {
         type: enumValue2(record.type, ENTITY_TYPES, `entities[${index}].type`, issues) ?? "risk_signal",
         value: stringValue(record.value, `entities[${index}].value`, issues),
@@ -12577,7 +12691,7 @@ function validateFrame(input) {
         "context.active_changes_count",
         issues
       ),
-      active_change_names: isRecord(context) ? (() => {
+      active_change_names: isRecord2(context) ? (() => {
         if (!Array.isArray(context.active_change_names)) {
           issues.push("context.active_change_names must be an array");
           return [];
@@ -12595,8 +12709,8 @@ function validateFrame(input) {
       )
     },
     evidence: evidence.map((item, index) => {
-      const record = isRecord(item) ? item : {};
-      if (!isRecord(item)) issues.push(`evidence[${index}] must be an object`);
+      const record = isRecord2(item) ? item : {};
+      if (!isRecord2(item)) issues.push(`evidence[${index}] must be an object`);
       return {
         field: stringValue(record.field, `evidence[${index}].field`, issues),
         quote: stringValue(record.quote, `evidence[${index}].quote`, issues),
@@ -12762,15 +12876,15 @@ var classicIntentCommand = async (args, _options) => {
 };
 
 // domains/comet-classic/classic-resume-probe.ts
-import path21 from "path";
-import { promises as fs20 } from "fs";
+import path22 from "path";
+import { promises as fs21 } from "fs";
 import { spawn } from "child_process";
 var COMET_RESUME_PROBE_SCHEMA_VERSION = "comet.resume_probe.v1";
-function isRecord2(value) {
+function isRecord3(value) {
   return typeof value === "object" && value !== null && !Array.isArray(value);
 }
 function normalizeInput(input) {
-  if (!isRecord2(input)) {
+  if (!isRecord3(input)) {
     throw new Error("Invalid CometResumeProbeInput: input must be an object");
   }
   if (input.schema_version !== COMET_RESUME_PROBE_SCHEMA_VERSION) {
@@ -12781,7 +12895,7 @@ function normalizeInput(input) {
   if (typeof input.utterance !== "string") {
     throw new Error("Invalid CometResumeProbeInput: utterance must be a string");
   }
-  const context = isRecord2(input.agent_context) ? input.agent_context : {};
+  const context = isRecord3(input.agent_context) ? input.agent_context : {};
   return {
     schema_version: COMET_RESUME_PROBE_SCHEMA_VERSION,
     utterance: input.utterance,
@@ -12806,13 +12920,13 @@ function result3(action, change, confidence, reason, evidence = []) {
 }
 async function readIfExists(filePath) {
   if (!await fileExists3(filePath)) return "";
-  return fs20.readFile(filePath, "utf8");
+  return fs21.readFile(filePath, "utf8");
 }
 async function changeSearchText(changeDir, classic) {
   const files = ["proposal.md", "design.md", "tasks.md"];
   const parts = [classic.name, classic.workflow, classic.phase];
   for (const file of files) {
-    parts.push(await readIfExists(path21.join(changeDir, file)));
+    parts.push(await readIfExists(path22.join(changeDir, file)));
   }
   return parts.join("\n").toLowerCase();
 }
@@ -12876,19 +12990,19 @@ function diagnosticFromProjection(changeDir, name, projection) {
   };
 }
 async function hasOpenSpecChangeFiles(changeDir) {
-  return await fileExists3(path21.join(changeDir, "proposal.md")) || await fileExists3(path21.join(changeDir, "design.md")) || await fileExists3(path21.join(changeDir, "tasks.md"));
+  return await fileExists3(path22.join(changeDir, "proposal.md")) || await fileExists3(path22.join(changeDir, "design.md")) || await fileExists3(path22.join(changeDir, "tasks.md"));
 }
 async function discoverActiveChanges(projectRoot2) {
-  const changesDir = path21.join(projectRoot2, "openspec", "changes");
+  const changesDir = path22.join(projectRoot2, "openspec", "changes");
   if (!await fileExists3(changesDir)) return [];
   const entries = await readDir(changesDir);
   const changes = [];
   for (const entry2 of entries) {
     if (entry2 === "archive") continue;
-    const changeDir = path21.join(changesDir, entry2);
-    const stat = await fs20.stat(changeDir).catch(() => null);
+    const changeDir = path22.join(changesDir, entry2);
+    const stat = await fs21.stat(changeDir).catch(() => null);
     if (!stat?.isDirectory()) continue;
-    const hasCometState = await fileExists3(path21.join(changeDir, ".comet.yaml"));
+    const hasCometState = await fileExists3(path22.join(changeDir, ".comet.yaml"));
     if (!hasCometState) {
       if (!await hasOpenSpecChangeFiles(changeDir)) continue;
       const missingStateChange = {
@@ -13191,8 +13305,8 @@ var classicResumeProbeCommand = async (args) => {
 var import_yaml8 = __toESM(require_dist(), 1);
 import { spawnSync as spawnSync3 } from "child_process";
 import { randomUUID as randomUUID8 } from "crypto";
-import { existsSync as existsSync3, promises as fs21 } from "fs";
-import path22 from "path";
+import { existsSync as existsSync3, promises as fs22 } from "fs";
+import path23 from "path";
 init_state();
 var GREEN5 = "\x1B[32m";
 var RED5 = "\x1B[31m";
@@ -13306,7 +13420,7 @@ function validateRelativePath(value, field2) {
 }
 async function exists6(file) {
   try {
-    await fs21.access(file);
+    await fs22.access(file);
     return true;
   } catch (error) {
     if (error.code === "ENOENT") return false;
@@ -13315,7 +13429,7 @@ async function exists6(file) {
 }
 async function nonempty3(file) {
   try {
-    return (await fs21.stat(file)).size > 0;
+    return (await fs22.stat(file)).size > 0;
   } catch (error) {
     if (error.code === "ENOENT") return false;
     throw error;
@@ -13327,11 +13441,11 @@ async function changeDirectory2(name) {
 async function readDocument2(file) {
   let source;
   try {
-    source = await fs21.readFile(file, "utf8");
+    source = await fs22.readFile(file, "utf8");
   } catch (error) {
     if (error.code === "ENOENT") {
       fail2(
-        `ERROR: .comet.yaml not found at ${path22.relative(process.cwd(), file).replaceAll("\\", "/")}`
+        `ERROR: .comet.yaml not found at ${path23.relative(process.cwd(), file).replaceAll("\\", "/")}`
       );
     }
     throw error;
@@ -13341,13 +13455,13 @@ async function readDocument2(file) {
   return document;
 }
 async function atomicWrite2(file, content) {
-  await fs21.mkdir(path22.dirname(file), { recursive: true });
+  await fs22.mkdir(path23.dirname(file), { recursive: true });
   const temporary = `${file}.${randomUUID8()}.tmp`;
   try {
-    await fs21.writeFile(temporary, content, "utf8");
-    await fs21.rename(temporary, file);
+    await fs22.writeFile(temporary, content, "utf8");
+    await fs22.rename(temporary, file);
   } catch (error) {
-    await fs21.rm(temporary, { force: true });
+    await fs22.rm(temporary, { force: true });
     throw error;
   }
 }
@@ -13490,7 +13604,7 @@ async function stateFile(name) {
   const change = await changeDirectory2(name);
   return {
     ...change,
-    file: path22.join(change.directory, ".comet.yaml")
+    file: path23.join(change.directory, ".comet.yaml")
   };
 }
 async function readField3(name, field2) {
@@ -13621,7 +13735,7 @@ async function init(output, name, workflow) {
   validateEnum(workflow, PROFILES);
   const { file, label, directory } = await stateFile(name);
   if (await exists6(file)) fail2(`ERROR: .comet.yaml already exists at ${label}/.comet.yaml`);
-  await fs21.mkdir(directory, { recursive: true });
+  await fs22.mkdir(directory, { recursive: true });
   const preset = workflow !== "full";
   const reviewMode = preset ? "off" : await reviewModeDefault();
   const document = new import_yaml8.Document({
@@ -13702,13 +13816,13 @@ async function requireOpenArtifacts(name) {
   const { directory } = await stateFile(name);
   const workflow = await readField3(name, "workflow");
   for (const artifact of ["proposal.md", "tasks.md"]) {
-    if (!await nonempty3(path22.join(directory, artifact))) {
+    if (!await nonempty3(path23.join(directory, artifact))) {
       fail2(
         `ERROR: Cannot transition '${name}': ${artifact} must exist and be non-empty before leaving open`
       );
     }
   }
-  if (workflow === "full" && !await nonempty3(path22.join(directory, "design.md"))) {
+  if (workflow === "full" && !await nonempty3(path23.join(directory, "design.md"))) {
     fail2(
       `ERROR: Cannot transition '${name}': design.md must exist and be non-empty before leaving open`
     );
@@ -13716,14 +13830,14 @@ async function requireOpenArtifacts(name) {
 }
 async function requireDesignEvidence(name) {
   const designDoc = await readField3(name, "design_doc");
-  if (!designDoc || designDoc === "null" || !await nonempty3(path22.resolve(designDoc))) {
+  if (!designDoc || designDoc === "null" || !await nonempty3(path23.resolve(designDoc))) {
     fail2(
       `ERROR: Cannot transition '${name}': design_doc must point to an existing Design Doc before leaving design`
     );
   }
 }
 async function writeSparseTransitionEffects(directory, effects) {
-  const file = path22.join(directory, ".comet.yaml");
+  const file = path23.join(directory, ".comet.yaml");
   const document = await readDocument2(file);
   for (const effect of effects) {
     const field2 = wireField2(effect.field);
@@ -13738,7 +13852,7 @@ async function applyTransitionEvent(output, name, event) {
   let sparse = false;
   if (!classic) {
     if (projection.run) fail2("ERROR: Classic state projection is missing");
-    const document = await readDocument2(path22.join(directory, ".comet.yaml"));
+    const document = await readDocument2(path23.join(directory, ".comet.yaml"));
     classic = sparseClassicState(document.toJS());
     sparse = true;
   }
@@ -13785,7 +13899,7 @@ async function transition(output, name, event) {
   } else if (event === "verify-pass") {
     await requirePhase(name, "verify");
     const report = await readField3(name, "verification_report");
-    if (!report || !await exists6(path22.resolve(report))) {
+    if (!report || !await exists6(path23.resolve(report))) {
       fail2(
         `ERROR: Cannot transition '${name}': verification_report must point to an existing report file`
       );
@@ -13849,9 +13963,9 @@ async function next(output, name) {
 async function taskCheckoff(output, taskFile, taskText) {
   validateRelativePath(taskFile, "task file");
   if (!taskText) fail2("ERROR: Task text cannot be empty");
-  const file = path22.resolve(taskFile);
+  const file = path23.resolve(taskFile);
   if (!await exists6(file)) fail2(`ERROR: Task file not found: ${taskFile}`);
-  const lines = (await fs21.readFile(file, "utf8")).split(/\r?\n/u);
+  const lines = (await fs22.readFile(file, "utf8")).split(/\r?\n/u);
   const matches = lines.filter(
     (line) => [`- [ ] ${taskText}`, `- [x] ${taskText}`, `- [X] ${taskText}`].includes(line)
   );
@@ -13889,21 +14003,21 @@ async function check2(output, name, phase) {
       designDoc ? `design_doc=${designDoc} (expected: empty/null)` : "design_doc is empty/null"
     );
     for (const artifact of ["proposal.md", "design.md", "tasks.md"]) {
-      (await nonempty3(path22.join(directory, artifact)) ? pass2 : reject)(
-        `${artifact} ${await nonempty3(path22.join(directory, artifact)) ? "non-empty" : "missing or empty"}`
+      (await nonempty3(path23.join(directory, artifact)) ? pass2 : reject)(
+        `${artifact} ${await nonempty3(path23.join(directory, artifact)) ? "non-empty" : "missing or empty"}`
       );
     }
   } else if (phase === "build") {
     const workflow = await readField3(name, "workflow");
     const designDoc = await readField3(name, "design_doc");
     if (workflow === "full") {
-      (designDoc && designDoc !== "null" && await exists6(path22.resolve(designDoc)) ? pass2 : reject)(`design_doc=${designDoc} (expected: non-null and file exists)`);
+      (designDoc && designDoc !== "null" && await exists6(path23.resolve(designDoc)) ? pass2 : reject)(`design_doc=${designDoc} (expected: non-null and file exists)`);
     } else {
       pass2(`workflow=${workflow} (design_doc not required)`);
     }
     for (const artifact of ["proposal.md", "tasks.md"]) {
-      (await nonempty3(path22.join(directory, artifact)) ? pass2 : reject)(
-        `${artifact} ${await nonempty3(path22.join(directory, artifact)) ? "non-empty" : "missing or empty"}`
+      (await nonempty3(path23.join(directory, artifact)) ? pass2 : reject)(
+        `${artifact} ${await nonempty3(path23.join(directory, artifact)) ? "non-empty" : "missing or empty"}`
       );
     }
   } else if (phase === "verify") {
@@ -13948,7 +14062,7 @@ async function check2(output, name, phase) {
 }
 function fieldStatus(field2, value, file) {
   if (!value || value === "null") return `  - ${field2}: PENDING`;
-  if (file && !existsSync3(path22.resolve(file))) {
+  if (file && !existsSync3(path23.resolve(file))) {
     return `  - ${field2}: BROKEN (path ${value} does not exist)`;
   }
   return `  - ${field2}: DONE (${value})`;
@@ -13957,7 +14071,7 @@ async function recoverOpen(output, directory) {
   output.stdout.push("  Artifacts:");
   let complete = 0;
   for (const artifact of ["proposal.md", "design.md", "tasks.md"]) {
-    const done = await nonempty3(path22.join(directory, artifact));
+    const done = await nonempty3(path23.join(directory, artifact));
     if (done) complete += 1;
     output.stdout.push(`  - ${artifact}: ${done ? "DONE" : "PENDING"}`);
   }
@@ -13970,7 +14084,7 @@ async function recoverDesign(output, name, directory) {
   output.stdout.push("  Artifacts:");
   for (const artifact of ["proposal.md", "design.md", "tasks.md"]) {
     output.stdout.push(
-      `  - ${artifact}: ${await nonempty3(path22.join(directory, artifact)) ? "DONE" : "MISSING (unexpected in design phase)"}`
+      `  - ${artifact}: ${await nonempty3(path23.join(directory, artifact)) ? "DONE" : "MISSING (unexpected in design phase)"}`
     );
   }
   const handoff = await readField3(name, "handoff_context");
@@ -13984,11 +14098,11 @@ async function recoverDesign(output, name, directory) {
     fieldStatus("design_doc", design, design),
     ""
   );
-  if (design && design !== "null" && await exists6(path22.resolve(design))) {
+  if (design && design !== "null" && await exists6(path23.resolve(design))) {
     output.stdout.push(
       "Recovery action: Design Doc already created and linked. Run guard to transition to build."
     );
-  } else if (handoff && handoff !== "null" && await exists6(path22.resolve(handoff))) {
+  } else if (handoff && handoff !== "null" && await exists6(path23.resolve(handoff))) {
     output.stdout.push(
       "Recovery action: Handoff generated but Design Doc not yet created. Resume from brainstorming confirmation (Step 1c)."
     );
@@ -14018,7 +14132,7 @@ async function recoverBuild(output, name, directory, workflow) {
     decisions.push(fieldStatus("subagent_dispatch", subagentDispatch));
   }
   output.stdout.push(...decisions, "", "  Plan:", fieldStatus("plan", plan, plan), "");
-  const tasks = path22.join(directory, "tasks.md");
+  const tasks = path23.join(directory, "tasks.md");
   if (!await exists6(tasks)) {
     output.stdout.push(
       "  Tasks: tasks.md MISSING",
@@ -14027,14 +14141,14 @@ async function recoverBuild(output, name, directory, workflow) {
     );
     return;
   }
-  const lines = (await fs21.readFile(tasks, "utf8")).split(/\r?\n/u);
+  const lines = (await fs22.readFile(tasks, "utf8")).split(/\r?\n/u);
   const total = lines.filter((line) => /^\s*- \[[ xX]\] /u.test(line)).length;
   const done = lines.filter((line) => /^\s*- \[[xX]\] /u.test(line)).length;
   const pending = total - done;
   let planTotal = 0;
   let planDone = 0;
-  if (plan && plan !== "null" && await exists6(path22.resolve(plan))) {
-    const planLines = (await fs21.readFile(path22.resolve(plan), "utf8")).split(/\r?\n/u);
+  if (plan && plan !== "null" && await exists6(path23.resolve(plan))) {
+    const planLines = (await fs22.readFile(path23.resolve(plan), "utf8")).split(/\r?\n/u);
     planTotal = planLines.filter((line) => /^\s*- \[[ xX]\] /u.test(line)).length;
     planDone = planLines.filter((line) => /^\s*- \[[xX]\] /u.test(line)).length;
   }
@@ -14165,19 +14279,19 @@ async function scale(output, name) {
   validateChangeName4(name);
   const { file, directory, label } = await stateFile(name);
   if (!await exists6(file)) fail2(`ERROR: .comet.yaml not found at ${label}/.comet.yaml`);
-  const tasksFile = path22.join(directory, "tasks.md");
-  const taskCount = await exists6(tasksFile) ? (await fs21.readFile(tasksFile, "utf8")).split(/\r?\n/u).filter((line) => /^- \[/u.test(line)).length : 0;
-  const specs = path22.join(directory, "specs");
+  const tasksFile = path23.join(directory, "tasks.md");
+  const taskCount = await exists6(tasksFile) ? (await fs22.readFile(tasksFile, "utf8")).split(/\r?\n/u).filter((line) => /^- \[/u.test(line)).length : 0;
+  const specs = path23.join(directory, "specs");
   let deltaSpecs = 0;
   if (await exists6(specs)) {
-    for (const entry2 of await fs21.readdir(specs)) {
-      if (await exists6(path22.join(specs, entry2, "spec.md"))) deltaSpecs += 1;
+    for (const entry2 of await fs22.readdir(specs)) {
+      if (await exists6(path23.join(specs, entry2, "spec.md"))) deltaSpecs += 1;
     }
   }
   const plan = await readField3(name, "plan");
   let baseRef = "";
-  if (plan && plan !== "null" && await exists6(path22.resolve(plan))) {
-    const match = (await fs21.readFile(path22.resolve(plan), "utf8")).match(/^base-ref:\s*(.+)$/mu);
+  if (plan && plan !== "null" && await exists6(path23.resolve(plan))) {
+    const match = (await fs22.readFile(path23.resolve(plan), "utf8")).match(/^base-ref:\s*(.+)$/mu);
     baseRef = match?.[1].trim() ?? "";
   }
   if (!baseRef) baseRef = await readField3(name, "base_ref");