@rpamis/comet 0.4.0-beta.2 → 0.4.0-beta.4

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, path18) {
-      const ctrl = callVisitor(key, node, visitor, path18);
+    function visit_(key, node, visitor, path22) {
+      const ctrl = callVisitor(key, node, visitor, path22);
       if (identity.isNode(ctrl) || identity.isPair(ctrl)) {
-        replaceNode(key, path18, ctrl);
-        return visit_(key, ctrl, visitor, path18);
+        replaceNode(key, path22, ctrl);
+        return visit_(key, ctrl, visitor, path22);
       }
       if (typeof ctrl !== "symbol") {
         if (identity.isCollection(node)) {
-          path18 = Object.freeze(path18.concat(node));
+          path22 = Object.freeze(path22.concat(node));
           for (let i = 0; i < node.items.length; ++i) {
-            const ci = visit_(i, node.items[i], visitor, path18);
+            const ci = visit_(i, node.items[i], visitor, path22);
             if (typeof ci === "number")
               i = ci - 1;
             else if (ci === BREAK)
@@ -147,13 +147,13 @@ var require_visit = __commonJS({
             }
           }
         } else if (identity.isPair(node)) {
-          path18 = Object.freeze(path18.concat(node));
-          const ck = visit_("key", node.key, visitor, path18);
+          path22 = Object.freeze(path22.concat(node));
+          const ck = visit_("key", node.key, visitor, path22);
           if (ck === BREAK)
             return BREAK;
           else if (ck === REMOVE)
             node.key = null;
-          const cv = visit_("value", node.value, visitor, path18);
+          const cv = visit_("value", node.value, visitor, path22);
           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, path18) {
-      const ctrl = await callVisitor(key, node, visitor, path18);
+    async function visitAsync_(key, node, visitor, path22) {
+      const ctrl = await callVisitor(key, node, visitor, path22);
       if (identity.isNode(ctrl) || identity.isPair(ctrl)) {
-        replaceNode(key, path18, ctrl);
-        return visitAsync_(key, ctrl, visitor, path18);
+        replaceNode(key, path22, ctrl);
+        return visitAsync_(key, ctrl, visitor, path22);
       }
       if (typeof ctrl !== "symbol") {
         if (identity.isCollection(node)) {
-          path18 = Object.freeze(path18.concat(node));
+          path22 = Object.freeze(path22.concat(node));
           for (let i = 0; i < node.items.length; ++i) {
-            const ci = await visitAsync_(i, node.items[i], visitor, path18);
+            const ci = await visitAsync_(i, node.items[i], visitor, path22);
             if (typeof ci === "number")
               i = ci - 1;
             else if (ci === BREAK)
@@ -195,13 +195,13 @@ var require_visit = __commonJS({
             }
           }
         } else if (identity.isPair(node)) {
-          path18 = Object.freeze(path18.concat(node));
-          const ck = await visitAsync_("key", node.key, visitor, path18);
+          path22 = Object.freeze(path22.concat(node));
+          const ck = await visitAsync_("key", node.key, visitor, path22);
           if (ck === BREAK)
             return BREAK;
           else if (ck === REMOVE)
             node.key = null;
-          const cv = await visitAsync_("value", node.value, visitor, path18);
+          const cv = await visitAsync_("value", node.value, visitor, path22);
           if (cv === BREAK)
             return BREAK;
           else if (cv === REMOVE)
@@ -228,23 +228,23 @@ var require_visit = __commonJS({
       }
       return visitor;
     }
-    function callVisitor(key, node, visitor, path18) {
+    function callVisitor(key, node, visitor, path22) {
       if (typeof visitor === "function")
-        return visitor(key, node, path18);
+        return visitor(key, node, path22);
       if (identity.isMap(node))
-        return visitor.Map?.(key, node, path18);
+        return visitor.Map?.(key, node, path22);
       if (identity.isSeq(node))
-        return visitor.Seq?.(key, node, path18);
+        return visitor.Seq?.(key, node, path22);
       if (identity.isPair(node))
-        return visitor.Pair?.(key, node, path18);
+        return visitor.Pair?.(key, node, path22);
       if (identity.isScalar(node))
-        return visitor.Scalar?.(key, node, path18);
+        return visitor.Scalar?.(key, node, path22);
       if (identity.isAlias(node))
-        return visitor.Alias?.(key, node, path18);
+        return visitor.Alias?.(key, node, path22);
       return void 0;
     }
-    function replaceNode(key, path18, node) {
-      const parent = path18[path18.length - 1];
+    function replaceNode(key, path22, node) {
+      const parent = path22[path22.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, path18, value) {
+    function collectionFromPath(schema, path22, value) {
       let v = value;
-      for (let i = path18.length - 1; i >= 0; --i) {
-        const k = path18[i];
+      for (let i = path22.length - 1; i >= 0; --i) {
+        const k = path22[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 = (path18) => path18 == null || typeof path18 === "object" && !!path18[Symbol.iterator]().next().done;
+    var isEmptyPath = (path22) => path22 == null || typeof path22 === "object" && !!path22[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(path18, value) {
-        if (isEmptyPath(path18))
+      addIn(path22, value) {
+        if (isEmptyPath(path22))
           this.add(value);
         else {
-          const [key, ...rest] = path18;
+          const [key, ...rest] = path22;
           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(path18) {
-        const [key, ...rest] = path18;
+      deleteIn(path22) {
+        const [key, ...rest] = path22;
         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(path18, keepScalar) {
-        const [key, ...rest] = path18;
+      getIn(path22, keepScalar) {
+        const [key, ...rest] = path22;
         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(path18) {
-        const [key, ...rest] = path18;
+      hasIn(path22) {
+        const [key, ...rest] = path22;
         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(path18, value) {
-        const [key, ...rest] = path18;
+      setIn(path22, value) {
+        const [key, ...rest] = path22;
         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(path18, value) {
+      addIn(path22, value) {
         if (assertCollection(this.contents))
-          this.contents.addIn(path18, value);
+          this.contents.addIn(path22, 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(path18) {
-        if (Collection.isEmptyPath(path18)) {
+      deleteIn(path22) {
+        if (Collection.isEmptyPath(path22)) {
           if (this.contents == null)
             return false;
           this.contents = null;
           return true;
         }
-        return assertCollection(this.contents) ? this.contents.deleteIn(path18) : false;
+        return assertCollection(this.contents) ? this.contents.deleteIn(path22) : 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(path18, keepScalar) {
-        if (Collection.isEmptyPath(path18))
+      getIn(path22, keepScalar) {
+        if (Collection.isEmptyPath(path22))
           return !keepScalar && identity.isScalar(this.contents) ? this.contents.value : this.contents;
-        return identity.isCollection(this.contents) ? this.contents.getIn(path18, keepScalar) : void 0;
+        return identity.isCollection(this.contents) ? this.contents.getIn(path22, 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(path18) {
-        if (Collection.isEmptyPath(path18))
+      hasIn(path22) {
+        if (Collection.isEmptyPath(path22))
           return this.contents !== void 0;
-        return identity.isCollection(this.contents) ? this.contents.hasIn(path18) : false;
+        return identity.isCollection(this.contents) ? this.contents.hasIn(path22) : 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(path18, value) {
-        if (Collection.isEmptyPath(path18)) {
+      setIn(path22, value) {
+        if (Collection.isEmptyPath(path22)) {
           this.contents = value;
         } else if (this.contents == null) {
-          this.contents = Collection.collectionFromPath(this.schema, Array.from(path18), value);
+          this.contents = Collection.collectionFromPath(this.schema, Array.from(path22), value);
         } else if (assertCollection(this.contents)) {
-          this.contents.setIn(path18, value);
+          this.contents.setIn(path22, value);
         }
       }
       /**
@@ -5584,9 +5584,9 @@ var require_cst_visit = __commonJS({
     visit.BREAK = BREAK;
     visit.SKIP = SKIP;
     visit.REMOVE = REMOVE;
-    visit.itemAtPath = (cst, path18) => {
+    visit.itemAtPath = (cst, path22) => {
       let item = cst;
-      for (const [field2, index] of path18) {
+      for (const [field2, index] of path22) {
         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, path18) => {
-      const parent = visit.itemAtPath(cst, path18.slice(0, -1));
-      const field2 = path18[path18.length - 1][0];
+    visit.parentCollection = (cst, path22) => {
+      const parent = visit.itemAtPath(cst, path22.slice(0, -1));
+      const field2 = path22[path22.length - 1][0];
       const coll = parent?.[field2];
       if (coll && "items" in coll)
         return coll;
       throw new Error("Parent collection not found");
     };
-    function _visit(path18, item, visitor) {
-      let ctrl = visitor(item, path18);
+    function _visit(path22, item, visitor) {
+      let ctrl = visitor(item, path22);
       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(path18.concat([[field2, i]])), token.items[i], visitor);
+            const ci = _visit(Object.freeze(path22.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, path18);
+            ctrl = ctrl(item, path22);
         }
       }
-      return typeof ctrl === "function" ? ctrl(item, path18) : ctrl;
+      return typeof ctrl === "function" ? ctrl(item, path22) : ctrl;
     }
     exports.visit = visit;
   }
@@ -6927,14 +6927,14 @@ var require_parser = __commonJS({
             case "scalar":
             case "single-quoted-scalar":
             case "double-quoted-scalar": {
-              const fs17 = this.flowScalar(this.type);
+              const fs21 = this.flowScalar(this.type);
               if (atNextItem || it.value) {
-                map.items.push({ start, key: fs17, sep: [] });
+                map.items.push({ start, key: fs21, sep: [] });
                 this.onKeyLine = true;
               } else if (it.sep) {
-                this.stack.push(fs17);
+                this.stack.push(fs21);
               } else {
-                Object.assign(it, { key: fs17, sep: [] });
+                Object.assign(it, { key: fs21, sep: [] });
                 this.onKeyLine = true;
               }
               return;
@@ -7062,13 +7062,13 @@ var require_parser = __commonJS({
             case "scalar":
             case "single-quoted-scalar":
             case "double-quoted-scalar": {
-              const fs17 = this.flowScalar(this.type);
+              const fs21 = this.flowScalar(this.type);
               if (!it || it.value)
-                fc.items.push({ start: [], key: fs17, sep: [] });
+                fc.items.push({ start: [], key: fs21, sep: [] });
               else if (it.sep)
-                this.stack.push(fs17);
+                this.stack.push(fs21);
               else
-                Object.assign(it, { key: fs17, sep: [] });
+                Object.assign(it, { key: fs21, sep: [] });
               return;
             }
             case "flow-map-end":
@@ -7257,7 +7257,7 @@ var require_public_api = __commonJS({
         return docs;
       return Object.assign([], { empty: true }, composer$1.streamInfo());
     }
-    function parseDocument6(source, options = {}) {
+    function parseDocument7(source, options = {}) {
       const { lineCounter: lineCounter2, prettyErrors } = parseOptions(options);
       const parser$1 = new parser.Parser(lineCounter2?.addNewLine);
       const composer$1 = new composer.Composer(options);
@@ -7283,7 +7283,7 @@ var require_public_api = __commonJS({
       } else if (options === void 0 && reviver && typeof reviver === "object") {
         options = reviver;
       }
-      const doc = parseDocument6(src, options);
+      const doc = parseDocument7(src, options);
       if (!doc)
         return null;
       doc.warnings.forEach((warning) => log.warn(doc.options.logLevel, warning));
@@ -7319,7 +7319,7 @@ var require_public_api = __commonJS({
     }
     exports.parse = parse2;
     exports.parseAllDocuments = parseAllDocuments;
-    exports.parseDocument = parseDocument6;
+    exports.parseDocument = parseDocument7;
     exports.stringify = stringify;
   }
 });
@@ -7573,6 +7573,10 @@ Valid format: lowercase kebab-case (a-z, 0-9, single hyphens)`;
   if (name.includes("..")) return "Change name cannot contain '..' (path traversal not allowed)";
   return null;
 }
+function assertOpenSpecChangeName(name) {
+  const error = openSpecChangeNameError(name);
+  if (error) throw new Error(error);
+}
 async function resolveClassicChangeDirectory(name) {
   const active = `openspec/changes/${name}`;
   if (await exists(filesystemPath(active))) {
@@ -7622,26 +7626,26 @@ function projectRootFor(changeDir) {
   }
   throw new Error(`Classic change is not inside an openspec directory: ${changeDir}`);
 }
-function relativeSource(projectRoot, file) {
-  return path2.relative(projectRoot, file).split(path2.sep).join("/");
+function relativeSource(projectRoot2, file) {
+  return path2.relative(projectRoot2, file).split(path2.sep).join("/");
 }
-async function linkedFileEvidence(projectRoot, code, relativePath2) {
+async function linkedFileEvidence(projectRoot2, code, relativePath2) {
   if (!relativePath2) return { code, satisfied: false };
-  const file = path2.resolve(projectRoot, relativePath2);
+  const file = path2.resolve(projectRoot2, relativePath2);
   return {
     code,
     satisfied: await fileExists(file),
-    source: relativeSource(projectRoot, file)
+    source: relativeSource(projectRoot2, file)
   };
 }
-async function directFileEvidence(projectRoot, code, file) {
+async function directFileEvidence(projectRoot2, code, file) {
   return {
     code,
     satisfied: await fileExists(file),
-    source: relativeSource(projectRoot, file)
+    source: relativeSource(projectRoot2, file)
   };
 }
-async function deltaSpecEvidence(projectRoot, changeDir) {
+async function deltaSpecEvidence(projectRoot2, changeDir) {
   const specsDir = path2.join(changeDir, "specs");
   let entries;
   try {
@@ -7657,11 +7661,11 @@ async function deltaSpecEvidence(projectRoot, changeDir) {
   return {
     code: "openspec.delta-spec",
     satisfied: existing.length > 0,
-    source: existing[0] ? relativeSource(projectRoot, existing[0]) : void 0,
+    source: existing[0] ? relativeSource(projectRoot2, existing[0]) : void 0,
     detail: `${existing.length} delta spec${existing.length === 1 ? "" : "s"}`
   };
 }
-async function taskEvidence(projectRoot, tasksFile) {
+async function taskEvidence(projectRoot2, tasksFile) {
   let source;
   try {
     source = await fs2.readFile(tasksFile, "utf8");
@@ -7676,7 +7680,7 @@ async function taskEvidence(projectRoot, tasksFile) {
   return {
     code: "build.tasks-complete",
     satisfied: tasks.length > 0 && complete === tasks.length,
-    source: relativeSource(projectRoot, tasksFile),
+    source: relativeSource(projectRoot2, tasksFile),
     detail: `${complete} of ${tasks.length} tasks complete`
   };
 }
@@ -7684,29 +7688,33 @@ function evidenceSatisfied(evidence, code) {
   return evidence.some((item) => item.code === code && item.satisfied);
 }
 async function collectClassicEvidence(changeDir, projection) {
-  const projectRoot = projectRootFor(changeDir);
+  const projectRoot2 = projectRootFor(changeDir);
   const classic = projection.classic;
   const proposal = path2.join(changeDir, "proposal.md");
   const design = path2.join(changeDir, "design.md");
   const tasks = path2.join(changeDir, "tasks.md");
   const checkpoint = projection.run ? path2.resolve(changeDir, projection.run.checkpointRef) : path2.join(changeDir, ".comet", "checkpoint.json");
   const evidence = await Promise.all([
-    directFileEvidence(projectRoot, "openspec.proposal", proposal),
-    directFileEvidence(projectRoot, "openspec.design", design),
-    directFileEvidence(projectRoot, "openspec.tasks", tasks),
-    deltaSpecEvidence(projectRoot, changeDir),
-    linkedFileEvidence(projectRoot, "design.document", classic?.designDoc ?? null),
-    linkedFileEvidence(projectRoot, "build.plan", classic?.plan ?? null),
-    taskEvidence(projectRoot, tasks),
-    linkedFileEvidence(projectRoot, "verification.report", classic?.verificationReport ?? null),
-    linkedFileEvidence(projectRoot, "design.handoff", classic?.handoffContext ?? null),
-    directFileEvidence(projectRoot, "run.checkpoint", checkpoint)
+    directFileEvidence(projectRoot2, "openspec.proposal", proposal),
+    directFileEvidence(projectRoot2, "openspec.design", design),
+    directFileEvidence(projectRoot2, "openspec.tasks", tasks),
+    deltaSpecEvidence(projectRoot2, changeDir),
+    linkedFileEvidence(projectRoot2, "design.document", classic?.designDoc ?? null),
+    linkedFileEvidence(projectRoot2, "build.plan", classic?.plan ?? null),
+    taskEvidence(projectRoot2, tasks),
+    linkedFileEvidence(projectRoot2, "verification.report", classic?.verificationReport ?? null),
+    linkedFileEvidence(projectRoot2, "design.handoff", classic?.handoffContext ?? null),
+    directFileEvidence(projectRoot2, "run.checkpoint", checkpoint)
   ]);
   const handoff = evidence.find((item) => item.code === "design.handoff");
   if (handoff && !classic?.handoffHash) {
     handoff.satisfied = false;
     handoff.detail = "handoff hash is missing";
   }
+  evidence.push({
+    code: "archive.confirmed",
+    satisfied: classic?.archiveConfirmation === "confirmed"
+  });
   return evidence;
 }
 
@@ -7753,11 +7761,11 @@ function resolveVerify(profile, classic, evidence) {
   }
   return `${profile}.verify.branch`;
 }
-function resolveArchive(profile, classic, evidence) {
+function resolveArchive(profile, classic) {
   if (classic.verifyResult !== "pass") {
     throw new Error("archive requires verify_result=pass");
   }
-  return evidenceSatisfied(evidence, "archive.confirmed") ? `${profile}.archive.execute` : `${profile}.archive.confirm`;
+  return classic.archiveConfirmation === "confirmed" ? `${profile}.archive.execute` : `${profile}.archive.confirm`;
 }
 function resolveClassicStepId(classic, evidence) {
   const profile = profileFor(classic);
@@ -7778,7 +7786,7 @@ function resolveClassicStepId(classic, evidence) {
     case "verify":
       return resolveVerify(profile, classic, evidence);
     case "archive":
-      return resolveArchive(profile, classic, evidence);
+      return resolveArchive(profile, classic);
   }
 }
 
@@ -7804,6 +7812,7 @@ var ISOLATIONS = ["branch", "worktree"];
 var VERIFY_MODES = ["light", "full"];
 var VERIFY_RESULTS = ["pending", "pass", "fail"];
 var BRANCH_STATUSES = ["pending", "handled"];
+var ARCHIVE_CONFIRMATIONS = ["pending", "confirmed"];
 var CLASSIC_WIRE_KEYS = [
   "workflow",
   "language",
@@ -7825,10 +7834,9 @@ var CLASSIC_WIRE_KEYS = [
   "branch_status",
   "created_at",
   "verified_at",
+  "archive_confirmation",
   "archived",
   "direct_override",
-  "build_command",
-  "verify_command",
   "handoff_context",
   "handoff_hash",
   "classic_profile",
@@ -7935,10 +7943,9 @@ function classicStateFromDocument(doc) {
     branchStatus: enumValue(doc, "branch_status", BRANCH_STATUSES),
     createdAt: nullableString(doc, "created_at"),
     verifiedAt: nullableString(doc, "verified_at"),
+    archiveConfirmation: enumValue(doc, "archive_confirmation", ARCHIVE_CONFIRMATIONS),
     archived: booleanValue(doc, "archived", false),
     directOverride: booleanValue(doc, "direct_override"),
-    buildCommand: nullableString(doc, "build_command"),
-    verifyCommand: nullableString(doc, "verify_command"),
     handoffContext: relativePath(doc, "handoff_context"),
     handoffHash: sha256(doc, "handoff_hash"),
     classicProfile: enumValue(doc, "classic_profile", CLASSIC_PROFILES),
@@ -8000,10 +8007,9 @@ function classicStateToDocument(state) {
     branch_status: state.branchStatus,
     created_at: state.createdAt,
     verified_at: state.verifiedAt,
+    archive_confirmation: state.archiveConfirmation,
     archived: state.archived,
     direct_override: state.directOverride,
-    build_command: state.buildCommand,
-    verify_command: state.verifyCommand,
     handoff_context: state.handoffContext,
     handoff_hash: state.handoffHash,
     classic_profile: state.classicProfile,
@@ -8058,6 +8064,16 @@ function stripLegacyRunFields(document) {
   ];
   for (const key of LEGACY_RUN_KEYS) document.delete(key);
 }
+function stripLegacyCommandFields(document) {
+  let changed = false;
+  for (const key of ["build_command", "verify_command"]) {
+    if (document.has(key)) {
+      document.delete(key);
+      changed = true;
+    }
+  }
+  return changed;
+}
 async function readDocument(file) {
   let source;
   try {
@@ -8073,23 +8089,29 @@ async function readDocument(file) {
   documentRecord(document);
   return document;
 }
-async function readClassicState(changeDir) {
-  const document = await readDocument(path4.join(changeDir, ".comet.yaml"));
-  const doc = documentRecord(document);
+async function readClassicState(changeDir, options = {}) {
+  const shouldMigrate = options.migrate !== false;
+  const file = path4.join(changeDir, ".comet.yaml");
+  const document = await readDocument(file);
+  let doc = documentRecord(document);
+  let migrated = stripLegacyCommandFields(document);
+  if (migrated) doc = documentRecord(document);
   let run = await readRunState(changeDir);
   if (!run && doc.run_id && doc.skill) {
     const { runStateFromDocument: runStateFromDocument2 } = await Promise.resolve().then(() => (init_state(), state_exports));
     run = runStateFromDocument2(doc);
-    if (run) {
+    if (run && shouldMigrate) {
       await writeRunState(changeDir, run);
       stripLegacyRunFields(document);
-      const file = path4.join(changeDir, ".comet.yaml");
-      const temporary = path4.join(changeDir, `.comet.yaml.${randomUUID2()}.tmp`);
-      await fs4.writeFile(temporary, document.toString(), "utf8");
-      await fs4.rename(temporary, file);
+      migrated = true;
     }
   }
-  return parseClassicStateDocument(doc, run);
+  if (migrated && shouldMigrate) {
+    const temporary = path4.join(changeDir, `.comet.yaml.${randomUUID2()}.tmp`);
+    await fs4.writeFile(temporary, document.toString(), "utf8");
+    await fs4.rename(temporary, file);
+  }
+  return parseClassicStateDocument(documentRecord(document), run);
 }
 async function readLegacyState(changeDir) {
   const document = await readDocument(path4.join(changeDir, ".comet.yaml"));
@@ -8821,13 +8843,13 @@ function artifactKey(code) {
   return code.replaceAll(".", "_").replaceAll("-", "_");
 }
 async function migrationArtifacts(changeDir, evidence) {
-  const projectRoot = projectRootFor2(changeDir);
+  const projectRoot2 = projectRootFor2(changeDir);
   const artifacts = Object.fromEntries(
     evidence.filter((item) => item.satisfied && item.source).map((item) => [artifactKey(item.code), item.source])
   );
   const progress = path9.join(changeDir, "subagent-progress.md");
   if (await pathExists2(progress)) {
-    artifacts.subagent_progress = path9.relative(projectRoot, progress).split(path9.sep).join("/");
+    artifacts.subagent_progress = path9.relative(projectRoot2, progress).split(path9.sep).join("/");
   }
   const handoff = evidence.find((item) => item.code === "design.handoff" && item.satisfied);
   if (handoff?.source) artifacts.handoff_context = handoff.source;
@@ -8919,11 +8941,11 @@ async function ensureClassicRun(changeDir, options) {
       classicMigration: CLASSIC_MIGRATION_VERSION
     };
     const artifacts = await migrationArtifacts(changeDir, evidence);
-    const projectRoot = projectRootFor2(changeDir);
+    const projectRoot2 = projectRootFor2(changeDir);
     const handoff = evidence.find((item) => item.code === "design.handoff" && item.satisfied);
     let context = null;
     if (handoff?.source) {
-      context = await fs8.readFile(path9.resolve(projectRoot, handoff.source), "utf8");
+      context = await fs8.readFile(path9.resolve(projectRoot2, handoff.source), "utf8");
       await writeContext(changeDir, run.contextRef, context);
       createdFiles.push(path9.resolve(changeDir, run.contextRef));
     }
@@ -8980,6 +9002,230 @@ async function fileExists2(file) {
     throw error;
   }
 }
+function embeddedClassicRuntimePackage(root) {
+  return {
+    root,
+    packageKind: "runtime",
+    definition: {
+      apiVersion: "comet/v1alpha1",
+      kind: "Skill",
+      metadata: {
+        name: "comet-classic",
+        version: "1",
+        description: "Internal compatibility orchestration for classic Comet full, hotfix, and tweak workflows"
+      },
+      goal: {
+        statement: "Advance or restore a classic Comet Run without changing the user command surface",
+        inputs: [
+          {
+            name: "classic-state",
+            description: "Validated ClassicState consistent with the Run projection",
+            required: true
+          },
+          {
+            name: "evidence",
+            description: "Structured evidence produced by the Classic Evidence collector",
+            required: true
+          }
+        ],
+        outputs: [
+          {
+            name: "run-state",
+            description: "Atomically synchronized Classic and Run state",
+            required: true
+          }
+        ],
+        success: [
+          "Legacy fields and Run fields remain consistent",
+          "Every step invokes only a declared public Comet Skill",
+          "The completed state passes its completion eval"
+        ]
+      },
+      orchestration: {
+        mode: "deterministic",
+        entry: "full.open",
+        steps: [
+          {
+            id: "full.open",
+            action: { type: "invoke_skill", ref: "comet-open" },
+            next: "full.design.handoff"
+          },
+          {
+            id: "full.design.handoff",
+            action: { type: "invoke_skill", ref: "comet-design" },
+            next: "full.design.document"
+          },
+          {
+            id: "full.design.document",
+            action: { type: "invoke_skill", ref: "comet-design" },
+            next: "full.build.plan"
+          },
+          {
+            id: "full.build.plan",
+            action: { type: "invoke_skill", ref: "comet-build" },
+            next: "full.build.plan-ready"
+          },
+          {
+            id: "full.build.plan-ready",
+            action: { type: "invoke_skill", ref: "comet-build" },
+            next: "full.build.configure"
+          },
+          {
+            id: "full.build.configure",
+            action: { type: "invoke_skill", ref: "comet-build" },
+            next: "full.build.execute"
+          },
+          {
+            id: "full.build.execute",
+            action: { type: "invoke_skill", ref: "comet-build" },
+            next: "full.build.complete"
+          },
+          {
+            id: "full.build.complete",
+            action: { type: "invoke_skill", ref: "comet-build" },
+            next: "full.verify.run"
+          },
+          {
+            id: "full.build.fix",
+            action: { type: "invoke_skill", ref: "comet-build" },
+            next: "full.build.execute"
+          },
+          {
+            id: "full.verify.run",
+            action: { type: "invoke_skill", ref: "comet-verify" },
+            next: "full.verify.branch"
+          },
+          {
+            id: "full.verify.branch",
+            action: { type: "invoke_skill", ref: "comet-verify" },
+            next: "full.archive.confirm"
+          },
+          {
+            id: "full.archive.confirm",
+            action: { type: "invoke_skill", ref: "comet-archive" },
+            next: "full.archive.execute"
+          },
+          {
+            id: "full.archive.execute",
+            action: { type: "invoke_skill", ref: "comet-archive" },
+            next: "completed"
+          },
+          {
+            id: "hotfix.open",
+            action: { type: "invoke_skill", ref: "comet-hotfix" },
+            next: "hotfix.build.execute"
+          },
+          {
+            id: "hotfix.build.execute",
+            action: { type: "invoke_skill", ref: "comet-build" },
+            next: "hotfix.build.complete"
+          },
+          {
+            id: "hotfix.build.complete",
+            action: { type: "invoke_skill", ref: "comet-build" },
+            next: "hotfix.verify.run"
+          },
+          {
+            id: "hotfix.verify.run",
+            action: { type: "invoke_skill", ref: "comet-verify" },
+            next: "hotfix.verify.branch"
+          },
+          {
+            id: "hotfix.verify.branch",
+            action: { type: "invoke_skill", ref: "comet-verify" },
+            next: "hotfix.archive.confirm"
+          },
+          {
+            id: "hotfix.archive.confirm",
+            action: { type: "invoke_skill", ref: "comet-archive" },
+            next: "hotfix.archive.execute"
+          },
+          {
+            id: "hotfix.archive.execute",
+            action: { type: "invoke_skill", ref: "comet-archive" },
+            next: "completed"
+          },
+          {
+            id: "tweak.open",
+            action: { type: "invoke_skill", ref: "comet-tweak" },
+            next: "tweak.build.execute"
+          },
+          {
+            id: "tweak.build.execute",
+            action: { type: "invoke_skill", ref: "comet-build" },
+            next: "tweak.build.complete"
+          },
+          {
+            id: "tweak.build.complete",
+            action: { type: "invoke_skill", ref: "comet-build" },
+            next: "tweak.verify.run"
+          },
+          {
+            id: "tweak.verify.run",
+            action: { type: "invoke_skill", ref: "comet-verify" },
+            next: "tweak.verify.branch"
+          },
+          {
+            id: "tweak.verify.branch",
+            action: { type: "invoke_skill", ref: "comet-verify" },
+            next: "tweak.archive.confirm"
+          },
+          {
+            id: "tweak.archive.confirm",
+            action: { type: "invoke_skill", ref: "comet-archive" },
+            next: "tweak.archive.execute"
+          },
+          {
+            id: "tweak.archive.execute",
+            action: { type: "invoke_skill", ref: "comet-archive" },
+            next: "completed"
+          },
+          {
+            id: "completed",
+            action: { type: "checkpoint" },
+            completionEvals: ["classic-completed"]
+          }
+        ]
+      },
+      skills: [
+        { id: "comet-open" },
+        { id: "comet-design" },
+        { id: "comet-build" },
+        { id: "comet-verify" },
+        { id: "comet-archive" },
+        { id: "comet-hotfix" },
+        { id: "comet-tweak" }
+      ],
+      agents: [],
+      tools: []
+    },
+    guardrails: {
+      allowedSkills: [
+        "comet-open",
+        "comet-design",
+        "comet-build",
+        "comet-verify",
+        "comet-archive",
+        "comet-hotfix",
+        "comet-tweak"
+      ],
+      allowedAgents: [],
+      allowedTools: [],
+      maxIterations: 500,
+      maxRetriesPerAction: 3,
+      confirmationRequiredFor: []
+    },
+    evals: [
+      {
+        id: "classic-completed",
+        scope: "completion",
+        type: "state_equals",
+        field: "status",
+        equals: "completed"
+      }
+    ]
+  };
+}
 async function classicRuntimeRoot() {
   const runtimeDirectory = path10.dirname(fileURLToPath(import.meta.url));
   const candidates = [
@@ -8996,7 +9242,7 @@ async function classicRuntimeRoot() {
   for (const candidate of candidates) {
     if (await directoryExists(candidate)) return candidate;
   }
-  throw new Error("Comet classic runtime package is not installed");
+  return null;
 }
 async function loadClassicRuntimePackage(root) {
   if (await fileExists2(path10.join(root, "skill.yaml"))) {
@@ -9007,17 +9253,56 @@ async function loadClassicRuntimePackage(root) {
 async function ensureClassicRuntimeRun(changeDir) {
   const root = await classicRuntimeRoot();
   return ensureClassicRun(changeDir, {
-    skillPackage: await loadClassicRuntimePackage(root)
+    skillPackage: root ? await loadClassicRuntimePackage(root) : embeddedClassicRuntimePackage(path10.dirname(fileURLToPath(import.meta.url)))
   });
 }
 async function ensureStrictClassicRuntimeRun(changeDir) {
   const projection = await readClassicState(changeDir);
-  if (projection.unknownKeys.length > 0) {
+  const unknownKeys = Array.from(new Set(projection.unknownKeys)).sort();
+  if (unknownKeys.length > 0) {
+    throw new Error(`Invalid Classic state: unknown field(s): ${unknownKeys.join(", ")}`);
+  }
+  return ensureClassicRuntimeRun(changeDir);
+}
+async function validateClassicRuntimeRun(changeDir, existingProjection) {
+  const projection = existingProjection ?? await readClassicState(changeDir, { migrate: false });
+  const unknownKeys = Array.from(new Set(projection.unknownKeys)).sort();
+  if (unknownKeys.length > 0) {
+    throw new Error(`Invalid Classic state: unknown field(s): ${unknownKeys.join(", ")}`);
+  }
+  if (!projection.classic || !projection.run) {
+    throw new Error("Classic runtime validation requires synchronized Classic and Run projections");
+  }
+  if (projection.classic.classicMigration !== CLASSIC_MIGRATION_VERSION) {
+    throw new Error("Classic Run exists without a supported classic_migration marker");
+  }
+  const root = await classicRuntimeRoot();
+  const skillPackage = root ? await loadClassicRuntimePackage(root) : embeddedClassicRuntimePackage(path10.dirname(fileURLToPath(import.meta.url)));
+  if (projection.run.skill !== skillPackage.definition.metadata.name) {
     throw new Error(
-      `Invalid Classic state: unknown field(s): ${projection.unknownKeys.join(", ")}`
+      `Classic Run skill mismatch: expected ${skillPackage.definition.metadata.name}, got ${projection.run.skill}`
     );
   }
-  return ensureClassicRuntimeRun(changeDir);
+  const snapshot = await readSkillSnapshot(changeDir, projection.run.skillHash);
+  if (snapshot.definition.metadata.name !== projection.run.skill) {
+    throw new Error(
+      `Classic Run snapshot skill mismatch: expected ${projection.run.skill}, got ${snapshot.definition.metadata.name}`
+    );
+  }
+  const evidence = await collectClassicEvidence(changeDir, projection);
+  const currentStep = resolveClassicStepId(projection.classic, evidence);
+  if (projection.run.currentStep !== currentStep) {
+    throw new Error(
+      `Classic Run step mismatch: expected ${currentStep}, got ${projection.run.currentStep}`
+    );
+  }
+  return {
+    classic: projection.classic,
+    run: projection.run,
+    evidence,
+    migrated: false,
+    snapshotDir: path10.join(changeDir, ".comet", "skill-snapshots", projection.run.skillHash)
+  };
 }
 async function transitionClassicRuntimeRun(changeDir, classic, run, data) {
   const projection = await readClassicState(changeDir);
@@ -9081,6 +9366,7 @@ var CLASSIC_TRANSITION_EVENTS = [
   "build-complete",
   "verify-pass",
   "verify-fail",
+  "archive-confirm",
   "archive-reopen",
   "archived",
   "preset-escalate"
@@ -9111,6 +9397,11 @@ var CLASSIC_TRANSITION_TABLE = {
     from: "verify",
     guardRefs: ["verification-failed"]
   },
+  "archive-confirm": {
+    event: "archive-confirm",
+    from: "archive",
+    guardRefs: ["archive-final-confirmation"]
+  },
   "archive-reopen": {
     event: "archive-reopen",
     from: "archive",
@@ -9119,7 +9410,7 @@ var CLASSIC_TRANSITION_TABLE = {
   archived: {
     event: "archived",
     from: "archive",
-    guardRefs: ["verify-result-pass"]
+    guardRefs: ["verify-result-pass", "archive-confirmed"]
   },
   "preset-escalate": {
     event: "preset-escalate",
@@ -9167,6 +9458,7 @@ function applyClassicTransition(current, event, options = {}) {
     setField(classic, effects, "verifyResult", "pass");
     setField(classic, effects, "phase", "archive");
     setField(classic, effects, "verifiedAt", dateOnly(now));
+    setField(classic, effects, "archiveConfirmation", "pending");
   } else if (event === "verify-fail") {
     setField(classic, effects, "verifyResult", "fail");
     setField(classic, effects, "phase", "build");
@@ -9180,15 +9472,25 @@ function applyClassicTransition(current, event, options = {}) {
     setField(classic, effects, "classicProfile", "full");
     setField(classic, effects, "phase", "design");
     setField(classic, effects, "designDoc", null);
+  } else if (event === "archive-confirm") {
+    if (classic.verifyResult !== "pass") {
+      throw new Error(`Cannot apply ${event}: verifyResult must be pass`);
+    }
+    if (classic.archived) throw new Error(`Cannot apply ${event}: already archived`);
+    setField(classic, effects, "archiveConfirmation", "confirmed");
   } else if (event === "archive-reopen") {
     if (classic.archived) throw new Error(`Cannot apply ${event}: already archived`);
     setField(classic, effects, "verifyResult", "pending");
     setField(classic, effects, "phase", "verify");
     setField(classic, effects, "verifiedAt", null);
+    setField(classic, effects, "archiveConfirmation", null);
   } else {
     if (classic.verifyResult !== "pass") {
       throw new Error(`Cannot apply ${event}: verifyResult must be pass`);
     }
+    if (classic.archiveConfirmation !== "confirmed") {
+      throw new Error(`Cannot apply ${event}: archiveConfirmation must be confirmed`);
+    }
     setField(classic, effects, "archived", true);
   }
   return { classic, effects, definition };
@@ -9251,6 +9553,33 @@ function artifactsHash(artifacts) {
     )
   );
 }
+function exactlyOneFinalNewline(markdown) {
+  return `${markdown.replace(/\n+$/u, "")}
+`;
+}
+function annotatedMarkdown(original, archiveName, extraFields) {
+  const normalized2 = original.replace(/\r\n/gu, "\n");
+  const lines = normalized2.split("\n");
+  const closingDelimiter = lines[0] === "---" ? lines.indexOf("---", 1) : -1;
+  const extraFieldName = extraFields.match(/^([^:\n]+):/u)?.[1]?.trim();
+  if (closingDelimiter !== -1) {
+    const frontmatter = lines.slice(1, closingDelimiter).filter((line) => {
+      const fieldName = line.match(/^([^:\n]+):/u)?.[1]?.trim();
+      if (fieldName === void 0) return true;
+      return fieldName !== "archived-with" && fieldName !== extraFieldName;
+    });
+    frontmatter.push(`archived-with: ${archiveName}`);
+    if (extraFields) frontmatter.push(extraFields);
+    return exactlyOneFinalNewline(
+      ["---", ...frontmatter, "---", ...lines.slice(closingDelimiter + 1)].join("\n")
+    );
+  }
+  const header = ["---", `archived-with: ${archiveName}`];
+  if (extraFields) header.push(extraFields);
+  if (extraFieldName !== "status") header.push("status: final");
+  header.push("---");
+  return exactlyOneFinalNewline([...header, normalized2].join("\n"));
+}
 async function findArchiveDir(change, preferred) {
   if (await exists2(preferred)) return preferred;
   const archiveRoot = "openspec/changes/archive";
@@ -9289,37 +9618,7 @@ async function annotateFrontmatter(output, file, archiveName, extraFields, dryRu
     return;
   }
   const original = await fs11.readFile(file, "utf8");
-  const firstLine = original.split(/\r?\n/u)[0] ?? "";
-  let updated;
-  if (firstLine === "---") {
-    const lines = original.split(/\r?\n/u);
-    const out = [];
-    let sawFirst = false;
-    for (const line of lines) {
-      if (/^archived-with:/u.test(line)) continue;
-      if (line === "---") {
-        if (!sawFirst) {
-          out.push(line);
-          sawFirst = true;
-          continue;
-        }
-        out.push(`archived-with: ${archiveName}`);
-        if (extraFields) out.push(extraFields);
-        out.push(line);
-      } else {
-        out.push(line);
-      }
-    }
-    updated = `${out.join("\n")}
-`;
-  } else {
-    const header = ["---", `archived-with: ${archiveName}`];
-    if (extraFields) header.push(extraFields);
-    header.push("status: final", "---");
-    updated = `${header.join("\n")}
-${original}`;
-    if (!updated.endsWith("\n")) updated += "\n";
-  }
+  const updated = annotatedMarkdown(original, archiveName, extraFields);
   await fs11.writeFile(file, updated);
   output.stderr.push(green(`  [OK] Annotated: ${file}`));
   output.stepsOk += 1;
@@ -9404,6 +9703,13 @@ var classicArchiveCommand = async (args) => {
       if (runtime.run.pending && runtime.run.pending !== actionId) {
         throw new ArchiveFailure(red(`FATAL: another action is pending: ${runtime.run.pending}`));
       }
+      if (!recovering && !classic.archived && classic.archiveConfirmation !== "confirmed") {
+        throw new ArchiveFailure(
+          red(
+            `FATAL: archive_confirmation is '${classic.archiveConfirmation ?? "null"}', expected 'confirmed'. Run final archive confirmation first.`
+          )
+        );
+      }
       if (!recovering) {
         const action = {
           id: actionId,
@@ -9475,7 +9781,10 @@ var classicArchiveCommand = async (args) => {
         archive_directory: archiveDir
       };
       await writeArtifacts(archiveDir, archivedProjection.run.artifactsRef, artifacts);
-      const archiveTransition = applyClassicTransition(archivedProjection.classic, "archived");
+      const archiveTransition = applyClassicTransition(
+        recovering && archivedProjection.classic.archiveConfirmation !== "confirmed" ? { ...archivedProjection.classic, archiveConfirmation: "confirmed" } : archivedProjection.classic,
+        "archived"
+      );
       const archivedClassic = archiveTransition.classic;
       let transitionedRun = archivedProjection.run;
       if (archivedProjection.run.currentStep !== "completed" || archivedProjection.run.status !== "completed") {
@@ -9573,11 +9882,98 @@ var classicArchiveCommand = async (args) => {
 };
 
 // domains/comet-classic/classic-guard.ts
-var import_yaml4 = __toESM(require_dist(), 1);
+var import_yaml5 = __toESM(require_dist(), 1);
 import { spawnSync as spawnSync2 } from "child_process";
 import { createHash as createHash4 } from "crypto";
-import { existsSync, promises as fs13, readFileSync } from "fs";
-import path14 from "path";
+import { existsSync, promises as fs15, readFileSync } from "fs";
+import path16 from "path";
+
+// domains/comet-classic/classic-command-checks.ts
+import path13 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, "..", "..", "..");
+}
+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)) {
+    throw new Error(`Command check cwd must resolve within the project root: '${cwd}'`);
+  }
+  return path13.relative(root, target).replaceAll("\\", "/") || ".";
+}
+function validRecord(changeDir, event) {
+  if (event.type !== "command_check_recorded") return null;
+  const data = event.data;
+  if (typeof data !== "object" || data === null || Array.isArray(data)) return null;
+  const { scope, command, exitCode, cwd } = data;
+  if (scope !== "build" && scope !== "verify" || typeof command !== "string" || command.trim().length === 0 || !Number.isInteger(exitCode) || typeof cwd !== "string") {
+    return null;
+  }
+  let normalized2;
+  try {
+    normalized2 = normalizedCwd(changeDir, cwd);
+  } catch {
+    return null;
+  }
+  return {
+    sequence: event.sequence,
+    timestamp: event.timestamp,
+    runId: event.runId,
+    scope,
+    command,
+    exitCode,
+    cwd: normalized2
+  };
+}
+async function recordCommandCheck(changeDir, run, input) {
+  validateScope(input.scope);
+  if (typeof input.command !== "string" || input.command.trim().length === 0) {
+    throw new Error("Command check command cannot be blank");
+  }
+  if (!Number.isInteger(input.exitCode)) {
+    throw new Error("Command check exitCode must be an integer");
+  }
+  const trajectory = await readTrajectory(changeDir, run.trajectoryRef);
+  const recorded = {
+    sequence: trajectory.reduce((maximum, event) => Math.max(maximum, event.sequence), 0) + 1,
+    timestamp: (/* @__PURE__ */ new Date()).toISOString(),
+    runId: run.runId,
+    scope: input.scope,
+    command: input.command,
+    exitCode: input.exitCode,
+    cwd: normalizedCwd(changeDir, input.cwd)
+  };
+  await appendTrajectory(changeDir, run.trajectoryRef, {
+    sequence: recorded.sequence,
+    timestamp: recorded.timestamp,
+    type: "command_check_recorded",
+    runId: recorded.runId,
+    data: {
+      scope: recorded.scope,
+      command: recorded.command,
+      exitCode: recorded.exitCode,
+      cwd: recorded.cwd
+    }
+  });
+  return recorded;
+}
+async function latestCommandCheck(changeDir, run, scope) {
+  validateScope(scope);
+  const trajectory = await readTrajectory(changeDir, run.trajectoryRef);
+  for (let index = trajectory.length - 1; index >= 0; index -= 1) {
+    const event = trajectory[index];
+    if (event.runId !== run.runId) continue;
+    const record = validRecord(changeDir, event);
+    if (record?.scope === scope) return record;
+  }
+  return null;
+}
 
 // domains/comet-classic/classic-runtime-evals.ts
 var STEP_EVIDENCE = {
@@ -9672,7 +10068,7 @@ 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 path13 from "path";
+import path14 from "path";
 var GREEN2 = "\x1B[32m";
 var RED2 = "\x1B[31m";
 var YELLOW2 = "\x1B[33m";
@@ -9704,6 +10100,7 @@ var ENUMS = {
   auto_transition: ["true", "false"],
   verify_result: ["pending", "pass", "fail"],
   branch_status: ["pending", "handled"],
+  archive_confirmation: ["pending", "confirmed"],
   archived: ["true", "false"],
   direct_override: ["true", "false"],
   classic_profile: ["full", "hotfix", "tweak"],
@@ -9742,7 +10139,7 @@ var classicValidateCommand = async (args) => {
     };
   }
   const { directory, label } = await resolveClassicChangeDirectory(name);
-  const yamlFile = path13.join(directory, ".comet.yaml");
+  const yamlFile = path14.join(directory, ".comet.yaml");
   const lines = [`[VALIDATE] ${label}/.comet.yaml`];
   let errors = 0;
   let warnings = 0;
@@ -9793,7 +10190,7 @@ var classicValidateCommand = async (args) => {
   }
   for (const field2 of ["design_doc", "plan", "handoff_context"]) {
     const value = text(record[field2]);
-    if (value && !await exists3(path13.resolve(value))) {
+    if (value && !await exists3(path14.resolve(value))) {
       fail3(`${field2}='${value}' does not exist on disk`);
     }
   }
@@ -9815,6 +10212,62 @@ var classicValidateCommand = async (args) => {
   return { exitCode: 0, stderr: lines.join("\n") };
 };
 
+// domains/comet-classic/classic-project-config.ts
+var import_yaml4 = __toESM(require_dist(), 1);
+import os from "os";
+import { promises as fs14 } from "fs";
+import path15 from "path";
+
+// platform/fs/file-system.ts
+import { promises as fs13 } from "fs";
+async function fileExists3(filePath) {
+  try {
+    await fs13.access(filePath);
+    return true;
+  } catch {
+    return false;
+  }
+}
+async function readDir(dirPath) {
+  try {
+    return await fs13.readdir(dirPath);
+  } catch (error) {
+    const code = error?.code;
+    if (code === "ENOENT" || code === "ENOTDIR") {
+      return [];
+    }
+    throw error;
+  }
+}
+
+// domains/comet-classic/classic-project-config.ts
+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: path15.resolve(homeDir, ".comet", "config.yaml"),
+      source: "~/.comet/config.yaml"
+    }
+  ];
+  return candidates.filter(
+    (candidate, index) => candidates.findIndex((entry2) => entry2.file === candidate.file) === index
+  );
+}
+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"), {
+      uniqueKeys: false
+    });
+    const value = document.get(field2);
+    if (value === null || value === void 0) continue;
+    return { value: String(value), source: candidate.source };
+  }
+  return null;
+}
+
 // domains/comet-classic/classic-guard.ts
 var GREEN3 = "\x1B[32m";
 var RED3 = "\x1B[31m";
@@ -9879,7 +10332,7 @@ var GuardOutput = class {
 };
 async function exists4(file) {
   try {
-    await fs13.access(file);
+    await fs15.access(file);
     return true;
   } catch (error) {
     if (error.code === "ENOENT") return false;
@@ -9888,7 +10341,7 @@ async function exists4(file) {
 }
 async function nonempty(file) {
   try {
-    return (await fs13.stat(file)).size > 0;
+    return (await fs15.stat(file)).size > 0;
   } catch (error) {
     if (error.code === "ENOENT") return false;
     throw error;
@@ -9901,32 +10354,9 @@ function validateChangeName2(name) {
 async function resolveChangeDir(name) {
   return (await resolveClassicChangeDirectory(name)).label;
 }
-function stripInlineComment(value) {
-  let out = "";
-  let quote = "";
-  for (let i = 0; i < value.length; i += 1) {
-    const c = value[i];
-    if (quote === "") {
-      if (c === '"' || c === "'") {
-        quote = c;
-      } else if (c === "#" && (i === 0 || /\s/u.test(value[i - 1]))) {
-        return out.replace(/\s+$/u, "");
-      }
-    } else if (c === quote) {
-      quote = "";
-    }
-    out += c;
-  }
-  return out;
-}
-function stripWrappingQuotes(value) {
-  if (value.length >= 2 && value.startsWith('"') && value.endsWith('"')) return value.slice(1, -1);
-  if (value.length >= 2 && value.startsWith("'") && value.endsWith("'")) return value.slice(1, -1);
-  return value;
-}
 async function readField(changeDir, field2) {
-  const file = path14.join(changeDir, ".comet.yaml");
-  const document = (0, import_yaml4.parseDocument)(await fs13.readFile(file, "utf8"), { uniqueKeys: false });
+  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 GuardFailure(`ERROR: Invalid .comet.yaml: ${document.errors[0].message}`);
   }
@@ -9939,24 +10369,7 @@ async function readField(changeDir, field2) {
 async function projectConfigValue(field2, changeDir) {
   const changeValue = await readField(changeDir, field2);
   if (changeValue && changeValue !== "null") return changeValue;
-  for (const config of [
-    ".comet/config.yaml",
-    ".comet.yaml",
-    "comet.yaml",
-    ".comet.yml",
-    "comet.yml"
-  ]) {
-    if (!await exists4(config)) continue;
-    for (const line of (await fs13.readFile(config, "utf8")).split(/\r?\n/u)) {
-      if (new RegExp(`^${field2}:`, "u").test(line)) {
-        const value = stripWrappingQuotes(
-          stripInlineComment(line.replace(new RegExp(`^${field2}:\\s*`, "u"), ""))
-        );
-        if (value && value !== "null") return value;
-      }
-    }
-  }
-  return "";
+  return (await readClassicConfigValue(field2))?.value ?? "";
 }
 async function configuredLanguage(changeDir) {
   const language = await projectConfigValue("language", changeDir);
@@ -9984,7 +10397,7 @@ function countEnglishWords(source) {
 }
 async function documentLanguageMatchesConfigured(changeDir, file) {
   const language = await configuredLanguage(changeDir);
-  const source = stripFencedCodeBlocks(await fs13.readFile(file, "utf8"));
+  const source = stripFencedCodeBlocks(await fs15.readFile(file, "utf8"));
   const cjk = countCjkChars(source);
   const englishWords = countEnglishWords(source);
   if (language === "zh-CN" && cjk < 20 && englishWords >= 20) {
@@ -10001,68 +10414,6 @@ Next: regenerate or rewrite this artifact in English while preserving necessary
   }
   return pass();
 }
-function runCommandString(command) {
-  if (!command) return { status: 1, output: red2("ERROR: build/verify command is empty") };
-  const split = splitCommandChain(command);
-  if (typeof split === "string") {
-    return {
-      status: 1,
-      output: `${red2(`ERROR: build/verify command contains shell metacharacters: ${command}`)}
-${red2(
-        split
-      )}`
-    };
-  }
-  const output = [];
-  for (const part of split) {
-    const segment = part.trim();
-    if (!segment) {
-      return { status: 1, output: red2("ERROR: build/verify command contains an empty && step") };
-    }
-    const result3 = spawnSync2(segment, { shell: true, encoding: "utf8", timeout: 3e5 });
-    const combined = `${result3.stdout ?? ""}${result3.stderr ?? ""}`.replace(/\n+$/u, "");
-    output.push(`${red2(`+ ${segment}`)}${combined ? `
-${combined}` : ""}`);
-    if (result3.status !== 0) {
-      return { status: result3.status ?? 1, output: output.join("\n") };
-    }
-  }
-  return { status: 0, output: output.join("\n") };
-}
-function splitCommandChain(command) {
-  const parts = [];
-  let current = "";
-  let quote = "";
-  for (let i = 0; i < command.length; i += 1) {
-    const c = command[i];
-    if (c === "$" || c === "`") {
-      return "Allowed: command words, quotes, paths, and && between sequential commands";
-    }
-    if (quote) {
-      current += c;
-      if (c === quote) quote = "";
-      continue;
-    }
-    if (c === '"' || c === "'") {
-      quote = c;
-      current += c;
-      continue;
-    }
-    if (c === "&" && command[i + 1] === "&") {
-      parts.push(current);
-      current = "";
-      i += 1;
-      continue;
-    }
-    if (c === ";" || c === "|" || c === "&") {
-      return "Allowed: command words, quotes, paths, and && between sequential commands";
-    }
-    current += c;
-  }
-  if (quote) return "Command has an unmatched quote";
-  parts.push(current);
-  return parts;
-}
 function hashFile(file) {
   return createHash4("sha256").update(readFileSync(file)).digest("hex");
 }
@@ -10070,7 +10421,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 fs13.readdir(specs)).sort()) {
+    for (const entry2 of (await fs15.readdir(specs)).sort()) {
       const spec = `${specs}/${entry2}/spec.md`;
       if (await exists4(spec)) files.push(spec);
     }
@@ -10090,20 +10441,30 @@ async function preflight(changeDir, name) {
   if (!await exists4(changeDir)) {
     throw new GuardFailure(red2(`FATAL: change directory not found: ${changeDir}`));
   }
-  if (!await exists4(path14.join(changeDir, ".comet.yaml"))) {
+  if (!await exists4(path16.join(changeDir, ".comet.yaml"))) {
     throw new GuardFailure(red2(`FATAL: .comet.yaml not found in ${changeDir}`));
   }
-  const result3 = await classicValidateCommand([name], { json: false });
-  if (result3.exitCode !== 0) {
-    if (result3.stderr)
-      process.stderr.write(result3.stderr.endsWith("\n") ? result3.stderr : `${result3.stderr}
+  const result5 = await classicValidateCommand([name], { json: false });
+  if (result5.exitCode !== 0) {
+    if (result5.stderr)
+      process.stderr.write(result5.stderr.endsWith("\n") ? result5.stderr : `${result5.stderr}
 `);
     throw new GuardFailure(red2("FATAL: .comet.yaml schema validation failed"));
   }
+  const projection = await readClassicState(changeDir);
+  const unknownKeys = Array.from(new Set(projection.unknownKeys)).sort();
+  if (unknownKeys.length > 0) {
+    throw new GuardFailure(
+      red2(`FATAL: .comet.yaml has unknown field(s): ${unknownKeys.join(", ")}`)
+    );
+  }
 }
 function pushCheck(output, outcome) {
   if (outcome.passed) {
     output.stderr.push(green2(`  [PASS] ${outcome.description}`));
+    if (outcome.detail) {
+      for (const line of outcome.detail.split("\n")) output.stderr.push(green2(`    ${line}`));
+    }
   } else {
     output.stderr.push(red2(`  [FAIL] ${outcome.description}`));
     if (outcome.detail) {
@@ -10114,11 +10475,11 @@ function pushCheck(output, outcome) {
 function check(description, run) {
   return async () => {
     try {
-      const result3 = await run();
+      const result5 = await run();
       return {
         description,
-        passed: result3.passed,
-        detail: ("detail" in result3 ? result3.detail : "") ?? ""
+        passed: result5.passed,
+        detail: ("detail" in result5 ? result5.detail : "") ?? ""
       };
     } catch (error) {
       return {
@@ -10129,8 +10490,8 @@ function check(description, run) {
     }
   };
 }
-function pass() {
-  return { passed: true };
+function pass(detail) {
+  return { passed: true, ...detail ? { detail } : {} };
 }
 function fail(detail) {
   return { passed: false, detail };
@@ -10144,46 +10505,103 @@ async function runChecks(output, builders) {
   }
   return blocked2;
 }
+var INFERRED_COMMAND_SOURCES = [
+  "package.json with a build script",
+  "pom.xml",
+  "Cargo.toml"
+];
+async function removedProjectCommandField(field2) {
+  const config = path16.join(".comet", "config.yaml");
+  if (!await exists4(config)) return false;
+  const document = (0, import_yaml5.parseDocument)(await fs15.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.`
+    );
+  }
+  const value = document.toJS();
+  return Boolean(value) && typeof value === "object" && !Array.isArray(value) && Object.prototype.hasOwnProperty.call(value, field2);
+}
+function removedProjectCommandRun(field2) {
+  return {
+    status: 1,
+    output: `${field2} has been removed from .comet/config.yaml. Delete this field and run any required ${field2 === "build_command" ? "build" : "verification"} command manually before retrying.`
+  };
+}
 function runInferred(command) {
-  const result3 = spawnSync2(command, { shell: true, encoding: "utf8", timeout: 3e5 });
+  const result5 = spawnSync2(command, { shell: true, encoding: "utf8", timeout: 3e5 });
   return {
-    status: result3.status ?? 1,
-    output: `${result3.stdout ?? ""}${result3.stderr ?? ""}`.replace(/\n+$/u, "")
+    status: result5.status ?? 1,
+    output: `${result5.stdout ?? ""}${result5.stderr ?? ""}`.replace(/\n+$/u, "")
   };
 }
-async function buildPasses(changeDir) {
-  if (process.env.COMET_SKIP_BUILD === "1") return { status: 0, output: "" };
-  const configured = await projectConfigValue("build_command", changeDir);
-  if (configured) return runCommandString(configured);
-  if (await exists4("package.json") && /"build"/u.test(await fs13.readFile("package.json", "utf8"))) {
-    return runInferred("npm run build");
+async function inferredBuildCommand() {
+  if (await exists4("package.json") && (() => {
+    const parsed = JSON.parse(readFileSync("package.json", "utf8"));
+    return typeof parsed.scripts?.build === "string";
+  })()) {
+    return "npm run build";
   }
   if (await exists4("pom.xml")) {
     if (process.platform === "win32") {
-      if (existsSync("mvnw.cmd")) return runInferred("mvnw.cmd compile -q");
-      return runInferred("mvn.cmd compile -q");
+      if (existsSync("mvnw.cmd")) return "mvnw.cmd compile -q";
+      return "mvn.cmd compile -q";
     }
-    if (existsSync("mvnw")) return runInferred("./mvnw compile -q");
-    return runInferred("mvn compile -q");
+    if (existsSync("mvnw")) return "./mvnw compile -q";
+    return "mvn compile -q";
   }
-  if (await exists4("Cargo.toml")) return runInferred("cargo build");
-  return { status: 1, output: "" };
+  if (await exists4("Cargo.toml")) return "cargo build";
+  return null;
+}
+function evidenceDetail(record) {
+  return `Evidence: recorded command-check at ${record.timestamp}; command: ${record.command}; cwd: ${record.cwd}`;
 }
-async function verificationCommandPasses(changeDir) {
-  if (process.env.COMET_SKIP_BUILD === "1") return { status: 0, output: "" };
-  const configured = await projectConfigValue("verify_command", changeDir);
-  if (configured) return runCommandString(configured);
-  return buildPasses(changeDir);
+function recoveryCommand(change, scope, command) {
+  return `comet state record-check ${change} ${scope} --command "${command}" --exit-code 0`;
+}
+async function commandCheckPasses(changeDir, change, run, scope) {
+  if (process.env.COMET_SKIP_BUILD === "1") {
+    return { status: 0, output: "SKIPPED via COMET_SKIP_BUILD=1" };
+  }
+  const removedFields = scope === "build" ? ["build_command"] : ["verify_command", "build_command"];
+  for (const removedField of removedFields) {
+    if (await removedProjectCommandField(removedField)) {
+      return removedProjectCommandRun(removedField);
+    }
+  }
+  const inferred = scope === "build" ? await inferredBuildCommand() : null;
+  if (inferred) return runInferred(inferred);
+  const recorded = await latestCommandCheck(changeDir, run, scope);
+  if (!recorded) {
+    return {
+      status: 1,
+      output: scope === "build" ? `No inferred build command or recorded build check. Detection searched: ${INFERRED_COMMAND_SOURCES.join(", ")}.
+Next: run the required command, then record it with:
+${recoveryCommand(change, scope, "<command>")}` : `No recorded verify check.
+Next: run the required verification command, then record it with:
+${recoveryCommand(change, scope, "<command>")}`
+    };
+  }
+  if (recorded.exitCode !== 0) {
+    return {
+      status: recorded.exitCode,
+      output: `Latest recorded ${scope} check failed with exit code ${recorded.exitCode}.
+${evidenceDetail(recorded)}
+Next: rerun the command successfully, then record it with:
+${recoveryCommand(change, scope, recorded.command)}`
+    };
+  }
+  return { status: 0, output: evidenceDetail(recorded) };
 }
 async function tasksAllDone(changeDir) {
-  const tasks = path14.join(changeDir, "tasks.md");
+  const tasks = path16.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 fs13.readFile(tasks, "utf8");
+  const source = await fs15.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]'."
@@ -10200,9 +10618,9 @@ Next: complete or explicitly remove unfinished tasks, then mark tasks.md with '-
   return pass();
 }
 async function tasksHasAny(changeDir) {
-  const tasks = path14.join(changeDir, "tasks.md");
+  const tasks = path16.join(changeDir, "tasks.md");
   if (!await exists4(tasks)) return false;
-  return /- \[/u.test(await fs13.readFile(tasks, "utf8"));
+  return /- \[/u.test(await fs15.readFile(tasks, "utf8"));
 }
 async function planTasksAllDone(changeDir) {
   const plan = await readField(changeDir, "plan");
@@ -10213,7 +10631,7 @@ async function planTasksAllDone(changeDir) {
 Next: restore the Superpowers plan file or update .comet.yaml plan before leaving build.`
     );
   }
-  const source = await fs13.readFile(plan, "utf8");
+  const source = await fs15.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(
@@ -10302,7 +10720,7 @@ async function archivedIsTrue(changeDir) {
   return await readField(changeDir, "archived") === "true";
 }
 async function designDocFrontmatterHas(designDoc, field2, expected) {
-  const source = (await fs13.readFile(designDoc, "utf8")).replace(/^\uFEFF/u, "");
+  const source = (await fs15.readFile(designDoc, "utf8")).replace(/^\uFEFF/u, "");
   let inFrontmatter = false;
   for (const line of source.split(/\r?\n/u)) {
     if (!inFrontmatter) {
@@ -10367,7 +10785,7 @@ 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 fs13.readFile(markdown, "utf8");
+  const source = await fs15.readFile(markdown, "utf8");
   const problems = [];
   if (!/^Generated-by: comet-handoff\.sh$/mu.test(source)) {
     problems.push("handoff markdown is missing Generated-by marker");
@@ -10394,7 +10812,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 fs13.readFile(context, "utf8");
+  const source = await fs15.readFile(context, "utf8");
   const problems = [];
   let parsed;
   try {
@@ -10431,19 +10849,19 @@ async function guardOpenChecks(output, changeDir) {
   const checks = [
     check(
       "proposal.md exists and non-empty",
-      async () => await nonempty(path14.join(changeDir, "proposal.md")) ? pass() : fail("")
+      async () => await nonempty(path16.join(changeDir, "proposal.md")) ? pass() : fail("")
     ),
     check(
       "proposal.md matches configured language",
-      () => documentLanguageMatchesConfigured(changeDir, path14.join(changeDir, "proposal.md"))
+      () => documentLanguageMatchesConfigured(changeDir, path16.join(changeDir, "proposal.md"))
     ),
     check(
       "tasks.md exists and non-empty",
-      async () => await nonempty(path14.join(changeDir, "tasks.md")) ? pass() : fail("")
+      async () => await nonempty(path16.join(changeDir, "tasks.md")) ? pass() : fail("")
     ),
     check(
       "tasks.md matches configured language",
-      () => documentLanguageMatchesConfigured(changeDir, path14.join(changeDir, "tasks.md"))
+      () => documentLanguageMatchesConfigured(changeDir, path16.join(changeDir, "tasks.md"))
     ),
     check(
       "tasks.md has at least one task",
@@ -10456,11 +10874,11 @@ async function guardOpenChecks(output, changeDir) {
       0,
       check(
         "design.md exists and non-empty",
-        async () => await nonempty(path14.join(changeDir, "design.md")) ? pass() : fail("")
+        async () => await nonempty(path16.join(changeDir, "design.md")) ? pass() : fail("")
       ),
       check(
         "design.md matches configured language",
-        () => documentLanguageMatchesConfigured(changeDir, path14.join(changeDir, "design.md"))
+        () => documentLanguageMatchesConfigured(changeDir, path16.join(changeDir, "design.md"))
       )
     );
   }
@@ -10472,27 +10890,27 @@ async function guardDesignChecks(output, changeDir, change) {
   const builders = [
     check(
       "proposal.md exists",
-      async () => await nonempty(path14.join(changeDir, "proposal.md")) ? pass() : fail("")
+      async () => await nonempty(path16.join(changeDir, "proposal.md")) ? pass() : fail("")
     ),
     check(
       "proposal.md matches configured language",
-      () => documentLanguageMatchesConfigured(changeDir, path14.join(changeDir, "proposal.md"))
+      () => documentLanguageMatchesConfigured(changeDir, path16.join(changeDir, "proposal.md"))
     ),
     check(
       "design.md exists",
-      async () => await nonempty(path14.join(changeDir, "design.md")) ? pass() : fail("")
+      async () => await nonempty(path16.join(changeDir, "design.md")) ? pass() : fail("")
     ),
     check(
       "design.md matches configured language",
-      () => documentLanguageMatchesConfigured(changeDir, path14.join(changeDir, "design.md"))
+      () => documentLanguageMatchesConfigured(changeDir, path16.join(changeDir, "design.md"))
     ),
     check(
       "tasks.md exists",
-      async () => await nonempty(path14.join(changeDir, "tasks.md")) ? pass() : fail("")
+      async () => await nonempty(path16.join(changeDir, "tasks.md")) ? pass() : fail("")
     ),
     check(
       "tasks.md matches configured language",
-      () => documentLanguageMatchesConfigured(changeDir, path14.join(changeDir, "tasks.md"))
+      () => documentLanguageMatchesConfigured(changeDir, path16.join(changeDir, "tasks.md"))
     ),
     check("design handoff context exists", () => designHandoffContextValid(changeDir, change)),
     check("design handoff markdown is traceable", () => designHandoffMarkdownTraceable(changeDir))
@@ -10541,7 +10959,7 @@ async function guardDesignChecks(output, changeDir, change) {
   }
   return blocked2;
 }
-async function guardBuildChecks(output, changeDir, change) {
+async function guardBuildChecks(output, changeDir, change, run) {
   return runChecks(output, [
     check("isolation selected", () => isolationSelected(changeDir, change)),
     check("build_mode selected", () => buildModeSelected(changeDir, change)),
@@ -10553,11 +10971,11 @@ async function guardBuildChecks(output, changeDir, change) {
     check("Superpowers plan all tasks checked", () => planTasksAllDone(changeDir)),
     check(
       "proposal.md exists",
-      async () => await nonempty(path14.join(changeDir, "proposal.md")) ? pass() : fail("")
+      async () => await nonempty(path16.join(changeDir, "proposal.md")) ? pass() : fail("")
     ),
     check(
       "proposal.md matches configured language",
-      () => documentLanguageMatchesConfigured(changeDir, path14.join(changeDir, "proposal.md"))
+      () => documentLanguageMatchesConfigured(changeDir, path16.join(changeDir, "proposal.md"))
     ),
     check("Superpowers plan matches configured language", async () => {
       const plan = await readField(changeDir, "plan");
@@ -10567,19 +10985,19 @@ async function guardBuildChecks(output, changeDir, change) {
     // Build check runs last — only after all config checks pass — to avoid
     // wasting time on a build that would be rejected by a config failure.
     check("Build passes", async () => {
-      const buildResult = await buildPasses(changeDir);
-      return buildResult.status === 0 ? pass() : fail(buildResult.output);
+      const buildResult = await commandCheckPasses(changeDir, change, run, "build");
+      return buildResult.status === 0 ? pass(buildResult.output) : fail(buildResult.output);
     })
   ]);
 }
-async function guardVerifyChecks(output, changeDir) {
+async function guardVerifyChecks(output, changeDir, change, run) {
   return runChecks(output, [
     check("tasks.md all tasks checked", () => tasksAllDone(changeDir)),
     // Verification command runs after tasks check — no point running tests
     // if tasks.md is incomplete.
     check("Verification passes", async () => {
-      const verifyResult = await verificationCommandPasses(changeDir);
-      return verifyResult.status === 0 ? pass() : fail(verifyResult.output);
+      const verifyResult = await commandCheckPasses(changeDir, change, run, "verify");
+      return verifyResult.status === 0 ? pass(verifyResult.output) : fail(verifyResult.output);
     }),
     check(
       "verification_report exists",
@@ -10601,11 +11019,11 @@ async function guardArchiveChecks(output, changeDir) {
     check("archived is true", async () => await archivedIsTrue(changeDir) ? pass() : fail("")),
     check(
       "proposal.md exists",
-      async () => await nonempty(path14.join(changeDir, "proposal.md")) ? pass() : fail("")
+      async () => await nonempty(path16.join(changeDir, "proposal.md")) ? pass() : fail("")
     ),
     check(
       "design.md exists",
-      async () => await nonempty(path14.join(changeDir, "design.md")) ? pass() : fail("")
+      async () => await nonempty(path16.join(changeDir, "design.md")) ? pass() : fail("")
     ),
     check("tasks.md all tasks checked", () => tasksAllDone(changeDir))
   ]);
@@ -10613,8 +11031,8 @@ async function guardArchiveChecks(output, changeDir) {
 async function applyStateUpdate(output, change, changeDir, phase, context) {
   const event = CLASSIC_GUARD_TRANSITION_EVENT[phase];
   if (!event) return;
-  const result3 = applyClassicTransition(context.classic, event);
-  await transitionClassicRuntimeRun(changeDir, result3.classic, context.run, {
+  const result5 = applyClassicTransition(context.classic, event);
+  await transitionClassicRuntimeRun(changeDir, result5.classic, context.run, {
     event,
     phase,
     source: "comet-guard"
@@ -10624,15 +11042,15 @@ async function applyStateUpdate(output, change, changeDir, phase, context) {
     event,
     source: "comet-guard",
     from: context.classic,
-    to: result3.classic,
-    effects: result3.effects
+    to: result5.classic,
+    effects: result5.effects
   });
-  for (const effect of result3.effects) {
+  for (const effect of result5.effects) {
     output.stderr.push(green2(`[SET] ${wireField(effect.field)}=${wireValue(effect.to)}`));
   }
   output.stderr.push(green2(`[TRANSITION] ${event}`));
   const template = APPLY_MESSAGE[phase];
-  const message = phase === "open" ? template.replace("PLACEHOLDER", result3.classic.phase) : template;
+  const message = phase === "open" ? template.replace("PLACEHOLDER", result5.classic.phase) : template;
   output.stderr.push(green2(message));
 }
 var classicGuardCommand = async (args, options) => {
@@ -10662,8 +11080,10 @@ Valid phases: open, design, build, verify, archive`
     let blocked2;
     if (phase === "open") blocked2 = await guardOpenChecks(output, changeDir);
     else if (phase === "design") blocked2 = await guardDesignChecks(output, changeDir, change);
-    else if (phase === "build") blocked2 = await guardBuildChecks(output, changeDir, change);
-    else if (phase === "verify") blocked2 = await guardVerifyChecks(output, changeDir);
+    else if (phase === "build")
+      blocked2 = await guardBuildChecks(output, changeDir, change, runContext.run);
+    else if (phase === "verify")
+      blocked2 = await guardVerifyChecks(output, changeDir, change, runContext.run);
     else blocked2 = await guardArchiveChecks(output, changeDir);
     if (blocked2) {
       output.stderr.push("");
@@ -10686,10 +11106,10 @@ Valid phases: open, design, build, verify, archive`
 };
 
 // domains/comet-classic/classic-handoff.ts
-var import_yaml5 = __toESM(require_dist(), 1);
+var import_yaml6 = __toESM(require_dist(), 1);
 import { createHash as createHash5 } from "crypto";
-import { promises as fs14, readFileSync as readFileSync2 } from "fs";
-import path15 from "path";
+import { promises as fs16, readFileSync as readFileSync2 } from "fs";
+import path17 from "path";
 var GREEN4 = "\x1B[32m";
 var RED4 = "\x1B[31m";
 var YELLOW4 = "\x1B[33m";
@@ -10723,7 +11143,7 @@ var HandoffOutput = class {
 };
 async function exists5(file) {
   try {
-    await fs14.access(file);
+    await fs16.access(file);
     return true;
   } catch (error) {
     if (error.code === "ENOENT") return false;
@@ -10732,7 +11152,7 @@ async function exists5(file) {
 }
 async function nonempty2(file) {
   try {
-    return (await fs14.stat(file)).size > 0;
+    return (await fs16.stat(file)).size > 0;
   } catch (error) {
     if (error.code === "ENOENT") return false;
     throw error;
@@ -10761,7 +11181,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 fs14.readdir(specs)).sort()) {
+    for (const entry2 of (await fs16.readdir(specs)).sort()) {
       const spec = `${specs}/${entry2}/spec.md`;
       if (await exists5(spec)) files.push(spec);
     }
@@ -10809,7 +11229,7 @@ async function writeMarkdownContext(changeDir, change, mode, contextHash, output
   ];
   for (const file of await handoffSourceFiles2(changeDir)) {
     if (!await exists5(file)) continue;
-    const content = await fs14.readFile(file, "utf8");
+    const content = await fs16.readFile(file, "utf8");
     const total = lineCount(content);
     lines.push(
       `## ${file}`,
@@ -10834,7 +11254,7 @@ async function writeMarkdownContext(changeDir, change, mode, contextHash, output
     }
     lines.push("");
   }
-  await fs14.writeFile(output, lines.join("\n"));
+  await fs16.writeFile(output, lines.join("\n"));
 }
 async function writeJsonContext(changeDir, change, mode, contextHash, output) {
   const entries = [];
@@ -10857,7 +11277,7 @@ async function writeJsonContext(changeDir, change, mode, contextHash, output) {
     "}",
     ""
   ].join("\n");
-  await fs14.writeFile(output, document);
+  await fs16.writeFile(output, document);
 }
 async function writeSpecProjectionForFile(file, content) {
   return [
@@ -10897,11 +11317,11 @@ async function writeSpecMarkdownContext(changeDir, change, contextHash, output)
   const specs = `${changeDir}/specs`;
   let projected = false;
   if (await exists5(specs)) {
-    for (const entry2 of (await fs14.readdir(specs)).sort()) {
+    for (const entry2 of (await fs16.readdir(specs)).sort()) {
       const spec = `${specs}/${entry2}/spec.md`;
       if (!await exists5(spec)) continue;
       projected = true;
-      lines.push(...await writeSpecProjectionForFile(spec, await fs14.readFile(spec, "utf8")));
+      lines.push(...await writeSpecProjectionForFile(spec, await fs16.readFile(spec, "utf8")));
     }
   }
   if (!projected) {
@@ -10910,7 +11330,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 fs14.writeFile(output, lines.join("\n"));
+  await fs16.writeFile(output, lines.join("\n"));
 }
 async function writeSpecJsonContext(changeDir, change, contextHash, output) {
   const entries = [];
@@ -10919,7 +11339,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 fs14.writeFile(
+  await fs16.writeFile(
     output,
     `${JSON.stringify(
       {
@@ -10938,8 +11358,8 @@ async function writeSpecJsonContext(changeDir, change, contextHash, output) {
   );
 }
 async function readField2(changeDir, field2) {
-  const file = path15.join(changeDir, ".comet.yaml");
-  const document = (0, import_yaml5.parseDocument)(await fs14.readFile(file, "utf8"), { uniqueKeys: false });
+  const file = path17.join(changeDir, ".comet.yaml");
+  const document = (0, import_yaml6.parseDocument)(await fs16.readFile(file, "utf8"), { uniqueKeys: false });
   if (document.errors.length > 0) {
     throw new HandoffFailure(`ERROR: Invalid .comet.yaml: ${document.errors[0].message}`);
   }
@@ -10973,7 +11393,7 @@ async function completedHandoffIsCurrent(changeDir, run, contextHash, contextJso
     readCheckpoint(changeDir, run.checkpointRef)
   ]);
   if (!await exists5(contextJson) || !await exists5(contextMd)) return false;
-  if (context !== await fs14.readFile(contextMd, "utf8")) return false;
+  if (context !== await fs16.readFile(contextMd, "utf8")) return false;
   if (artifacts.handoff_context !== contextJson || artifacts.handoff_markdown !== contextMd) {
     return false;
   }
@@ -11096,7 +11516,7 @@ var classicHandoffCommand = async (args) => {
       run: pendingRun,
       unknownKeys: (await readClassicState(changeDir)).unknownKeys
     });
-    await fs14.mkdir(handoffDir, { recursive: true });
+    await fs16.mkdir(handoffDir, { recursive: true });
     if (handoffMode === "beta") {
       await writeSpecMarkdownContext(changeDir, change, contextHash, contextMd);
       await writeSpecJsonContext(changeDir, change, contextHash, contextJson);
@@ -11104,7 +11524,7 @@ var classicHandoffCommand = async (args) => {
       await writeMarkdownContext(changeDir, change, handoffMode, contextHash, contextMd);
       await writeJsonContext(changeDir, change, handoffMode, contextHash, contextJson);
     }
-    const context = await fs14.readFile(contextMd, "utf8");
+    const context = await fs16.readFile(contextMd, "utf8");
     await writeContext(changeDir, pendingRun.contextRef, context);
     const artifacts = {
       ...await readArtifacts(changeDir, pendingRun.artifactsRef),
@@ -11161,10 +11581,142 @@ var classicHandoffCommand = async (args) => {
 };
 
 // domains/comet-classic/classic-hook-guard.ts
-import { existsSync as existsSync2, promises as fs15, readFileSync as readFileSync3 } from "fs";
-import path16 from "path";
-function result(exitCode, message) {
-  return { exitCode, stderr: message + "\n" };
+import { existsSync as existsSync2, promises as fs18, readFileSync as readFileSync3 } from "fs";
+import path19 from "path";
+
+// domains/comet-classic/classic-current-change.ts
+import { execFileSync } from "child_process";
+import { randomUUID as randomUUID6 } from "crypto";
+import { promises as fs17 } from "fs";
+import path18 from "path";
+function currentChangeFile(projectRoot2) {
+  return path18.join(projectRoot2, ".comet", "current-change.json");
+}
+function currentBranch(projectRoot2) {
+  try {
+    const branch = execFileSync("git", ["rev-parse", "--abbrev-ref", "HEAD"], {
+      cwd: projectRoot2,
+      encoding: "utf8",
+      stdio: ["ignore", "pipe", "ignore"]
+    }).trim();
+    return branch && branch !== "HEAD" ? branch : null;
+  } catch {
+    return null;
+  }
+}
+function changeDirectory(projectRoot2, changeName) {
+  return path18.join(projectRoot2, "openspec", "changes", changeName);
+}
+async function validateActiveChange(projectRoot2, changeName) {
+  assertOpenSpecChangeName(changeName);
+  const changeDir = changeDirectory(projectRoot2, changeName);
+  try {
+    await fs17.access(path18.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 !== 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
+  };
+}
+async function selectCurrentChange(projectRoot2, changeName) {
+  await validateActiveChange(projectRoot2, changeName);
+  const selection = {
+    version: 1,
+    change: changeName,
+    branch: currentBranch(projectRoot2)
+  };
+  const file = currentChangeFile(projectRoot2);
+  const temporary = `${file}.${randomUUID6()}.tmp`;
+  await fs17.mkdir(path18.dirname(file), { recursive: true });
+  try {
+    await fs17.writeFile(temporary, JSON.stringify(selection, null, 2) + "\n", "utf8");
+    await fs17.rename(temporary, file);
+  } catch (error) {
+    await fs17.rm(temporary, { force: true });
+    throw error;
+  }
+  return selection;
+}
+async function resolveCurrentChange(projectRoot2) {
+  let source;
+  try {
+    source = await fs17.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 branch = currentBranch(projectRoot2);
+  if (selection.branch !== null && branch !== selection.branch) {
+    return {
+      status: "stale",
+      reason: `current change '${selection.change}' was selected on branch '${selection.branch}', current branch is '${branch ?? "detached HEAD"}'`
+    };
+  }
+  return { status: "selected", selection };
+}
+async function clearCurrentChange(projectRoot2) {
+  await fs17.rm(currentChangeFile(projectRoot2), { force: true });
+}
+
+// domains/comet-classic/classic-hook-guard.ts
+function result(exitCode, message) {
+  return { exitCode, stderr: message + "\n" };
 }
 function allowed(message) {
   return result(0, `[COMET-HOOK] allowed: ${message}`);
@@ -11187,52 +11739,52 @@ function normalized(value) {
 function parseProjectRoot(args) {
   const index = args.indexOf("--project-root");
   const value = index >= 0 ? args[index + 1] : void 0;
-  return path16.resolve(value && !value.startsWith("--") ? value : process.cwd());
+  return path19.resolve(value && !value.startsWith("--") ? value : process.cwd());
 }
-function relativeToProjectRoot(target, projectRoot) {
-  const relative = normalized(path16.relative(projectRoot, target));
+function relativeToProjectRoot(target, projectRoot2) {
+  const relative = normalized(path19.relative(projectRoot2, target));
   if (relative === "") return "";
-  if (relative.startsWith("../") || relative === ".." || path16.isAbsolute(relative)) return null;
+  if (relative.startsWith("../") || relative === ".." || path19.isAbsolute(relative)) return null;
   return relative;
 }
 async function physicalPathForPossiblyMissingTarget(target) {
-  const resolved = path16.resolve(target);
-  const root = path16.parse(resolved).root;
+  const resolved = path19.resolve(target);
+  const root = path19.parse(resolved).root;
   const missingSegments = [];
   let cursor = resolved;
   while (cursor && cursor !== root) {
     try {
-      const physicalBase = await fs15.realpath(cursor);
-      return path16.join(physicalBase, ...missingSegments.reverse());
+      const physicalBase = await fs18.realpath(cursor);
+      return path19.join(physicalBase, ...missingSegments.reverse());
     } catch (error) {
       const code = error.code;
       if (code !== "ENOENT" && code !== "ENOTDIR") throw error;
-      missingSegments.push(path16.basename(cursor));
-      cursor = path16.dirname(cursor);
+      missingSegments.push(path19.basename(cursor));
+      cursor = path19.dirname(cursor);
     }
   }
   try {
-    const physicalRoot = await fs15.realpath(root);
-    return path16.join(physicalRoot, ...missingSegments.reverse());
+    const physicalRoot = await fs18.realpath(root);
+    return path19.join(physicalRoot, ...missingSegments.reverse());
   } catch {
     return null;
   }
 }
-async function projectRelative(target, projectRoot) {
-  const rawCandidate = path16.isAbsolute(target) ? target : path16.resolve(process.cwd(), target);
+async function projectRelative(target, projectRoot2) {
+  const rawCandidate = path19.isAbsolute(target) ? target : path19.resolve(process.cwd(), target);
   let candidate = normalized(rawCandidate);
-  const rootRelative = relativeToProjectRoot(rawCandidate, projectRoot);
+  const rootRelative = relativeToProjectRoot(rawCandidate, projectRoot2);
   if (rootRelative !== null) return rootRelative;
   try {
     const physicalCandidate = await physicalPathForPossiblyMissingTarget(rawCandidate);
-    const physicalRoot = await fs15.realpath(projectRoot);
+    const physicalRoot = await fs18.realpath(projectRoot2);
     if (physicalCandidate) {
       const physicalRootRelative = relativeToProjectRoot(physicalCandidate, physicalRoot);
       if (physicalRootRelative !== null) return physicalRootRelative;
       candidate = normalized(physicalCandidate);
     }
   } catch {
-    if (!path16.isAbsolute(target)) return normalized(target).replace(/^\.\//u, "");
+    if (!path19.isAbsolute(target)) return normalized(target).replace(/^\.\//u, "");
   }
   return candidate.replace(/^\.\//u, "");
 }
@@ -11256,28 +11808,22 @@ async function loadGoverningChange(changeDir) {
     };
   }
 }
-async function activeChanges(projectRoot) {
-  const changesDir = path16.join(projectRoot, "openspec", "changes");
+async function activeChanges(projectRoot2) {
+  const changesDir = path19.join(projectRoot2, "openspec", "changes");
   const governingChanges = [];
   if (!existsSync2(changesDir)) return governingChanges;
-  for (const entry2 of (await fs15.readdir(changesDir, { withFileTypes: true })).sort(
+  for (const entry2 of (await fs18.readdir(changesDir, { withFileTypes: true })).sort(
     (left, right) => left.name.localeCompare(right.name)
   )) {
     if (!entry2.isDirectory() || entry2.name === "archive") continue;
-    const changeDir = path16.join(changesDir, entry2.name);
-    if (!existsSync2(path16.join(changeDir, ".comet.yaml"))) continue;
+    const changeDir = path19.join(changesDir, entry2.name);
+    if (!existsSync2(path19.join(changeDir, ".comet.yaml"))) continue;
     const governing = await loadGoverningChange(changeDir);
     if (!governing || governing.archived) continue;
     governingChanges.push(governing);
   }
   return governingChanges;
 }
-function blocksSourceWrites(governing) {
-  if (governing.phase === "open" || governing.phase === "design" || governing.phase === "archive") {
-    return true;
-  }
-  return governing.phase === "build" && governing.classic?.workflow === "full" && !governing.classic.designDoc;
-}
 function isSuperpowersArtifactPath(relativePath2) {
   return relativePath2.startsWith("docs/superpowers/");
 }
@@ -11285,7 +11831,7 @@ function allowsSuperpowersArtifacts(governing) {
   return governing.phase === "design" || governing.phase === "build" || governing.phase === "verify";
 }
 function governingChangeName(governing) {
-  return governing.changeDir ? path16.basename(governing.changeDir) : null;
+  return governing.changeDir ? path19.basename(governing.changeDir) : null;
 }
 var SUPERPOWERS_ARTIFACT_SUFFIXES = /* @__PURE__ */ new Set([
   "design",
@@ -11316,8 +11862,8 @@ function matchesSuperpowersArtifactName(relativePath2, changeName) {
   const pattern = new RegExp(`(^|[-_.])${escapeRegex(changeName)}[-_.](${suffixes})$`, "u");
   return pattern.test(stem);
 }
-async function superpowersArtifactGoverningChange(relativePath2, projectRoot) {
-  const active = await activeChanges(projectRoot);
+async function superpowersArtifactGoverningChange(relativePath2, projectRoot2) {
+  const active = await activeChanges(projectRoot2);
   const recorded = active.find(
     (governing) => matchesRecordedSuperpowersArtifact(relativePath2, governing)
   );
@@ -11332,18 +11878,41 @@ async function superpowersArtifactGoverningChange(relativePath2, projectRoot) {
   if (named) return named;
   return null;
 }
-async function repoSourceGoverningChange(projectRoot) {
-  const active = await activeChanges(projectRoot);
-  return active.find(blocksSourceWrites) ?? active[0] ?? null;
+async function repoSourceGoverningChange(projectRoot2, relativePath2) {
+  const active = await activeChanges(projectRoot2);
+  if (active.length === 0) return null;
+  const current = await resolveCurrentChange(projectRoot2);
+  if (current.status === "stale") {
+    return { blockedResult: blockedStaleSelection(relativePath2, current.reason) };
+  }
+  if (current.status === "selected") {
+    const selected = active.find(
+      (governing) => governingChangeName(governing) === current.selection.change
+    );
+    if (selected) return selected;
+    return {
+      blockedResult: blockedStaleSelection(
+        relativePath2,
+        `selected change '${current.selection.change}' is no longer active`
+      )
+    };
+  }
+  if (active.length === 1) return active[0];
+  return {
+    blockedResult: blockedMultipleChanges(
+      relativePath2,
+      active.map((governing) => governingChangeName(governing)).filter(Boolean)
+    )
+  };
 }
-async function governingChange(relativePath2, projectRoot) {
+async function governingChange(relativePath2, projectRoot2) {
   const prefix = "openspec/changes/";
   if (relativePath2.startsWith(prefix)) {
     const rest = relativePath2.slice(prefix.length);
     const [name] = rest.split("/");
     if (name && name !== "archive") {
-      const changeDir = path16.join(projectRoot, "openspec", "changes", name);
-      const stateFile2 = path16.join(changeDir, ".comet.yaml");
+      const changeDir = path19.join(projectRoot2, "openspec", "changes", name);
+      const stateFile2 = path19.join(changeDir, ".comet.yaml");
       if (existsSync2(stateFile2)) {
         const governing = await loadGoverningChange(changeDir);
         if (governing) return governing;
@@ -11353,18 +11922,18 @@ async function governingChange(relativePath2, projectRoot) {
     }
   }
   if (isSuperpowersArtifactPath(relativePath2)) {
-    const superpowers = await superpowersArtifactGoverningChange(relativePath2, projectRoot);
+    const superpowers = await superpowersArtifactGoverningChange(relativePath2, projectRoot2);
     if (superpowers) return { ...superpowers, superpowersArtifact: "matched" };
-    const fallback = await repoSourceGoverningChange(projectRoot);
+    const fallback = (await activeChanges(projectRoot2))[0] ?? null;
     return fallback ? { ...fallback, superpowersArtifact: "unmatched" } : null;
   }
-  return repoSourceGoverningChange(projectRoot);
+  return repoSourceGoverningChange(projectRoot2, relativePath2);
 }
 function isRootMarkdown(relativePath2) {
   return !relativePath2.includes("/") && relativePath2.endsWith(".md");
 }
 function isCometConfig(relativePath2) {
-  return relativePath2 === ".comet.yaml" || relativePath2 === "comet.yaml" || relativePath2 === ".comet.yml" || relativePath2 === "comet.yml" || relativePath2.startsWith(".comet/") || relativePath2.includes("/.comet/");
+  return relativePath2.startsWith(".comet/") || relativePath2.includes("/.comet/");
 }
 function isSuperpowersWorkspace(relativePath2) {
   return relativePath2 === ".superpowers" || relativePath2.startsWith(".superpowers/");
@@ -11462,22 +12031,47 @@ function blockedUnmatchedSuperpowersArtifact(relativePath2, phase) {
     ].join("\n")
   );
 }
+function blockedMultipleChanges(relativePath2, changeNames) {
+  return result(
+    2,
+    [
+      "",
+      "╔══════════════════════════════════════════╗",
+      "║     COMET PHASE GUARD — WRITE BLOCKED    ║",
+      "╚══════════════════════════════════════════╝",
+      "",
+      "  BLOCKED: multiple active changes require a current change",
+      `  Target file: ${relativePath2}`,
+      `  Active changes: ${changeNames.join(", ")}`,
+      "",
+      "  NEXT: run comet state select <change-name>, then retry the source write",
+      ""
+    ].join("\n")
+  );
+}
+function blockedStaleSelection(relativePath2, reason) {
+  return result(
+    2,
+    [
+      "",
+      "╔══════════════════════════════════════════╗",
+      "║     COMET PHASE GUARD — WRITE BLOCKED    ║",
+      "╚══════════════════════════════════════════╝",
+      "",
+      "  BLOCKED: current change selection is stale or invalid",
+      `  Target file: ${relativePath2}`,
+      `  Reason: ${reason}`,
+      "",
+      "  NEXT: run comet state select <change-name>, then retry the source write",
+      ""
+    ].join("\n")
+  );
+}
 var classicHookGuardCommand = async (args) => {
-  const projectRoot = parseProjectRoot(args);
+  const projectRoot2 = parseProjectRoot(args);
   const target = inputTarget();
   if (!target) return allowed("no file path in tool input");
-  const relativePath2 = await projectRelative(target, projectRoot);
-  let governing;
-  try {
-    governing = await governingChange(relativePath2, projectRoot);
-  } catch (error) {
-    return result(
-      2,
-      `[COMET-HOOK] blocked: ${error instanceof Error ? error.message : String(error)}`
-    );
-  }
-  if (!governing) return allowed("no active comet change");
-  if (governing.archived) return allowed(`${relativePath2} (own change archived)`);
+  const relativePath2 = await projectRelative(target, projectRoot2);
   if (isCometConfig(relativePath2)) {
     return allowed(`${relativePath2} (whitelist: comet config)`);
   }
@@ -11490,6 +12084,18 @@ var classicHookGuardCommand = async (args) => {
   if (relativePath2 === "CLAUDE.md" || relativePath2 === "CHANGELOG.md" || relativePath2 === "README.md" || isRootMarkdown(relativePath2)) {
     return allowed(`${relativePath2} (whitelist: root markdown)`);
   }
+  let governing;
+  try {
+    governing = await governingChange(relativePath2, projectRoot2);
+  } catch (error) {
+    return result(
+      2,
+      `[COMET-HOOK] blocked: ${error instanceof Error ? error.message : String(error)}`
+    );
+  }
+  if (!governing) return allowed("no active comet change");
+  if ("blockedResult" in governing) return governing.blockedResult;
+  if (governing.archived) return allowed(`${relativePath2} (own change archived)`);
   const phase = governing.phase;
   const openSpec = openSpecAllowed(relativePath2, phase);
   if (openSpec) return allowed(openSpec);
@@ -11878,12 +12484,438 @@ var classicIntentCommand = async (args, _options) => {
   }
 };
 
+// domains/comet-classic/classic-resume-probe.ts
+import path20 from "path";
+import { promises as fs19 } from "fs";
+import { spawn } from "child_process";
+var COMET_RESUME_PROBE_SCHEMA_VERSION = "comet.resume_probe.v1";
+function isRecord2(value) {
+  return typeof value === "object" && value !== null && !Array.isArray(value);
+}
+function normalizeInput(input) {
+  if (!isRecord2(input)) {
+    throw new Error("Invalid CometResumeProbeInput: input must be an object");
+  }
+  if (input.schema_version !== COMET_RESUME_PROBE_SCHEMA_VERSION) {
+    throw new Error(
+      `Invalid CometResumeProbeInput: schema_version must be ${COMET_RESUME_PROBE_SCHEMA_VERSION}`
+    );
+  }
+  if (typeof input.utterance !== "string") {
+    throw new Error("Invalid CometResumeProbeInput: utterance must be a string");
+  }
+  const context = isRecord2(input.agent_context) ? input.agent_context : {};
+  return {
+    schema_version: COMET_RESUME_PROBE_SCHEMA_VERSION,
+    utterance: input.utterance,
+    locale: typeof input.locale === "string" ? input.locale : "unknown",
+    agent_context: {
+      non_trivial_work: context.non_trivial_work === true,
+      already_in_comet_flow: context.already_in_comet_flow === true
+    }
+  };
+}
+function result3(action, change, confidence, reason, evidence = []) {
+  return {
+    schema_version: COMET_RESUME_PROBE_SCHEMA_VERSION,
+    action,
+    changeName: change?.name ?? null,
+    phase: change?.phase ?? null,
+    nextCommand: action === "auto_resume" || action === "ask_user" ? change?.nextCommand ?? null : null,
+    confidence,
+    reason,
+    evidence
+  };
+}
+async function readIfExists(filePath) {
+  if (!await fileExists3(filePath)) return "";
+  return fs19.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(path20.join(changeDir, file)));
+  }
+  return parts.join("\n").toLowerCase();
+}
+function nextCommandForPhase2(phase) {
+  switch (phase) {
+    case "open":
+      return "/comet-open";
+    case "design":
+      return "/comet-design";
+    case "build":
+      return "/comet-build";
+    case "verify":
+      return "/comet-verify";
+    case "archive":
+      return "/comet-archive";
+    default:
+      return null;
+  }
+}
+function diagnosticFromProjection(changeDir, name, projection) {
+  const classic = projection.classic;
+  const unknownKeys = projection.unknownKeys.filter((key) => key !== "run_id");
+  if (!classic) {
+    return {
+      name,
+      valid: false,
+      workflow: "unknown",
+      phase: "invalid",
+      currentStep: null,
+      nextCommand: null,
+      runtimeMode: "invalid",
+      runtimeEval: null,
+      evidence: [],
+      error: `${changeDir} does not contain valid Comet state`
+    };
+  }
+  if (unknownKeys.length > 0) {
+    return {
+      name,
+      valid: false,
+      workflow: classic.workflow,
+      phase: classic.phase,
+      currentStep: null,
+      nextCommand: null,
+      runtimeMode: "invalid",
+      runtimeEval: null,
+      evidence: [],
+      error: `unknown field(s): ${unknownKeys.join(", ")}`
+    };
+  }
+  return {
+    name,
+    valid: true,
+    workflow: classic.workflow,
+    phase: classic.phase,
+    currentStep: null,
+    nextCommand: nextCommandForPhase2(classic.phase),
+    runtimeMode: "engine-projection",
+    runtimeEval: null,
+    evidence: []
+  };
+}
+async function hasOpenSpecChangeFiles(changeDir) {
+  return await fileExists3(path20.join(changeDir, "proposal.md")) || await fileExists3(path20.join(changeDir, "design.md")) || await fileExists3(path20.join(changeDir, "tasks.md"));
+}
+async function discoverActiveChanges(projectRoot2) {
+  const changesDir = path20.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 = path20.join(changesDir, entry2);
+    const stat = await fs19.stat(changeDir).catch(() => null);
+    if (!stat?.isDirectory()) continue;
+    const hasCometState = await fileExists3(path20.join(changeDir, ".comet.yaml"));
+    if (!hasCometState) {
+      if (!await hasOpenSpecChangeFiles(changeDir)) continue;
+      const missingStateChange = {
+        name: entry2,
+        workflow: "unknown",
+        phase: "invalid",
+        nextCommand: null,
+        diagnostic: {
+          name: entry2,
+          valid: false,
+          workflow: "unknown",
+          phase: "invalid",
+          currentStep: null,
+          nextCommand: null,
+          runtimeMode: "invalid",
+          runtimeEval: null,
+          evidence: [],
+          error: "missing Comet state"
+        },
+        buildPause: null,
+        hasClassicProjection: false,
+        verifyResult: null,
+        text: "",
+        missingCometState: true
+      };
+      missingStateChange.text = await changeSearchText(changeDir, missingStateChange);
+      changes.push(missingStateChange);
+      continue;
+    }
+    const projection = await readClassicState(changeDir, { migrate: false });
+    const classic = projection.classic;
+    const diagnostic = diagnosticFromProjection(changeDir, entry2, projection);
+    const hasClassicProjection = Boolean(classic);
+    const phase = classic?.phase ?? diagnostic.phase;
+    const workflow = classic?.workflow ?? diagnostic.workflow;
+    if (phase === "archive" || classic?.archived) continue;
+    const change = {
+      name: entry2,
+      workflow,
+      phase,
+      nextCommand: diagnostic.nextCommand,
+      diagnostic,
+      buildPause: classic?.buildPause ?? null,
+      hasClassicProjection,
+      verifyResult: classic?.verifyResult ?? null,
+      text: "",
+      missingCometState: false
+    };
+    change.text = await changeSearchText(changeDir, change);
+    changes.push(change);
+  }
+  return changes;
+}
+var RESUME_WORDS = [
+  "continue",
+  "resume",
+  "carry on",
+  "finish",
+  "run it",
+  "commit",
+  "verify",
+  "archive",
+  "继续",
+  "接着",
+  "恢复",
+  "跑完",
+  "提交",
+  "验证",
+  "归档",
+  "修刚才"
+];
+var QUESTION_WORDS = [
+  "what",
+  "why",
+  "how",
+  "explain",
+  "summarize",
+  "reliable",
+  "靠谱吗",
+  "是什么",
+  "为什么",
+  "解释",
+  "总结",
+  "取名",
+  "命名"
+];
+var GENERIC_RELATED_TOKENS = /* @__PURE__ */ new Set([
+  "add",
+  "build",
+  "cache",
+  "change",
+  "code",
+  "design",
+  "docs",
+  "file",
+  "fix",
+  "implement",
+  "plan",
+  "readme",
+  "task",
+  "test",
+  "update",
+  "修改",
+  "更新",
+  "修复",
+  "添加",
+  "文档",
+  "任务",
+  "计划",
+  "实现"
+]);
+var OPT_OUT_WORDS = [
+  "do not resume",
+  "don't resume",
+  "without comet",
+  "skip comet",
+  "不要恢复",
+  "不走 comet",
+  "不要走 comet",
+  "直接解释",
+  "只回答"
+];
+function includesAny(text2, words) {
+  return words.some((word) => text2.includes(word));
+}
+function hasDecisionPoint(change) {
+  if (change.missingCometState) return true;
+  if (!change.hasClassicProjection) return true;
+  if (!change.diagnostic.valid) return true;
+  if (change.phase === "archive") return true;
+  if (change.verifyResult === "fail") return true;
+  if (change.diagnostic.runtimeEval && !change.diagnostic.runtimeEval.passed) return true;
+  if (change.phase !== "build") return false;
+  if (change.buildPause === "plan-ready") return true;
+  return false;
+}
+function relatedEvidence(utterance, change) {
+  const text2 = utterance.toLowerCase();
+  const evidence = [];
+  if (text2.includes(change.name.toLowerCase())) {
+    evidence.push({ source: "user", quote: change.name });
+  }
+  const tokens = change.text.split(/[^a-zA-Z0-9_\-\u4e00-\u9fff/]+/u).map((token) => token.trim().toLowerCase()).filter((token) => token.length >= 4 && !GENERIC_RELATED_TOKENS.has(token));
+  const matched = [...new Set(tokens.filter((token) => text2.includes(token)))].slice(0, 3);
+  for (const token of matched) {
+    evidence.push({ source: "repo", quote: token });
+  }
+  return evidence;
+}
+async function gitDirtyFiles(projectRoot2) {
+  return new Promise((resolve) => {
+    const child = spawn("git", ["status", "--short", "--untracked-files=all"], {
+      cwd: projectRoot2,
+      stdio: ["ignore", "pipe", "ignore"],
+      shell: false
+    });
+    const chunks = [];
+    child.stdout.on("data", (chunk) => {
+      chunks.push(Buffer.isBuffer(chunk) ? chunk : Buffer.from(String(chunk)));
+    });
+    child.on("error", () => resolve([]));
+    child.on("exit", (code) => {
+      if (code !== 0) {
+        resolve([]);
+        return;
+      }
+      const dirtyFiles = Buffer.concat(chunks).toString("utf8").split(/\r?\n/u).map((line) => line.trim()).filter(Boolean);
+      resolve(dirtyFiles);
+    });
+  });
+}
+async function resolveCometResumeProbe(projectRoot2, rawInput) {
+  const input = normalizeInput(rawInput);
+  const utterance = input.utterance.trim();
+  const lower = utterance.toLowerCase();
+  if (input.agent_context.already_in_comet_flow) {
+    return result3("out_of_scope", null, "low", "already in Comet flow");
+  }
+  if (includesAny(lower, OPT_OUT_WORDS)) {
+    return result3("out_of_scope", null, "low", "user opted out of Comet resume", [
+      { source: "user", quote: utterance }
+    ]);
+  }
+  const changes = await discoverActiveChanges(projectRoot2);
+  if (changes.length === 0) {
+    return result3("none", null, "none", "no active Comet changes");
+  }
+  const dirtyFiles = await gitDirtyFiles(projectRoot2);
+  if (changes.length > 1) {
+    const named = changes.find((change2) => lower.includes(change2.name.toLowerCase()));
+    if (!named) {
+      return result3("ask_user", null, "low", "multiple active changes require a change name");
+    }
+    if (dirtyFiles.length > 0) {
+      return result3("ask_user", named, "low", "uncommitted worktree changes require attribution", [
+        { source: "repo", quote: `${dirtyFiles.length} dirty file(s)` }
+      ]);
+    }
+    return hasDecisionPoint(named) ? result3("ask_user", named, "low", "active change is at a decision point") : result3("auto_resume", named, "high", "request names an active change", [
+      { source: "user", quote: named.name }
+    ]);
+  }
+  const [change] = changes;
+  if (dirtyFiles.length > 0) {
+    return result3("ask_user", change, "low", "uncommitted worktree changes require attribution", [
+      { source: "repo", quote: `${dirtyFiles.length} dirty file(s)` }
+    ]);
+  }
+  if (hasDecisionPoint(change)) {
+    if (change.missingCometState) {
+      return result3("ask_user", change, "low", "active OpenSpec change is missing Comet state");
+    }
+    return result3("ask_user", change, "low", "active change is at a decision point", [
+      { source: "state", quote: `phase: ${change.phase}` }
+    ]);
+  }
+  const resumeLike = includesAny(lower, RESUME_WORDS);
+  const questionLike = !input.agent_context.non_trivial_work && includesAny(lower, QUESTION_WORDS);
+  if (questionLike && !resumeLike) {
+    return result3("out_of_scope", change, "low", "user asked a question without workflow work");
+  }
+  const evidence = relatedEvidence(utterance, change);
+  if (resumeLike || evidence.length > 0) {
+    return result3("auto_resume", change, "high", "single active change and request is related", [
+      { source: "state", quote: `phase: ${change.phase}` },
+      ...evidence
+    ]);
+  }
+  if (input.agent_context.non_trivial_work) {
+    return result3(
+      "ask_user",
+      change,
+      "low",
+      "single active change exists but request looks unrelated"
+    );
+  }
+  return result3("out_of_scope", change, "low", "request is not workflow work");
+}
+
+// domains/comet-classic/classic-resume-probe-command.ts
+function result4(exitCode, stdout, stderr) {
+  return {
+    exitCode,
+    ...stdout === void 0 ? {} : { stdout },
+    ...stderr === void 0 ? {} : { stderr }
+  };
+}
+function usage2() {
+  return result4(
+    64,
+    void 0,
+    "Usage: comet-resume-probe.mjs probe <input-json>\nUsage: comet-resume-probe.mjs probe --stdin"
+  );
+}
+async function readStdin2() {
+  const chunks = [];
+  for await (const chunk of process.stdin) {
+    chunks.push(Buffer.isBuffer(chunk) ? chunk : Buffer.from(String(chunk)));
+  }
+  return Buffer.concat(chunks).toString("utf8");
+}
+function rawUtteranceInput(utterance) {
+  return {
+    schema_version: COMET_RESUME_PROBE_SCHEMA_VERSION,
+    utterance,
+    locale: "unknown",
+    agent_context: {
+      non_trivial_work: true,
+      already_in_comet_flow: false
+    }
+  };
+}
+function parseStdinInput(source) {
+  try {
+    return JSON.parse(source);
+  } catch {
+    return rawUtteranceInput(source);
+  }
+}
+var classicResumeProbeCommand = async (args) => {
+  const [subcommand, input] = args;
+  if (subcommand !== "probe") return usage2();
+  const fromStdin = input === "--stdin";
+  const source = fromStdin ? await readStdin2() : input;
+  if (!source) return usage2();
+  try {
+    const parsedInput = fromStdin ? parseStdinInput(source) : JSON.parse(source);
+    const resolution = await resolveCometResumeProbe(process.cwd(), parsedInput);
+    return result4(0, `${JSON.stringify(resolution, null, 2)}
+`);
+  } catch (error) {
+    if (error instanceof SyntaxError) {
+      return result4(1, void 0, `Invalid JSON: ${error.message}`);
+    }
+    return result4(1, void 0, error instanceof Error ? error.message : String(error));
+  }
+};
+
 // domains/comet-classic/classic-state-command.ts
-var import_yaml6 = __toESM(require_dist(), 1);
+var import_yaml7 = __toESM(require_dist(), 1);
 import { spawnSync as spawnSync3 } from "child_process";
-import { randomUUID as randomUUID6 } from "crypto";
-import { existsSync as existsSync3, promises as fs16 } from "fs";
-import path17 from "path";
+import { randomUUID as randomUUID7 } from "crypto";
+import { existsSync as existsSync3, promises as fs20 } from "fs";
+import path21 from "path";
 init_state();
 var GREEN5 = "\x1B[32m";
 var RED5 = "\x1B[31m";
@@ -11895,6 +12927,7 @@ var ARTIFACT_LANGUAGES2 = ["en", "zh-CN"];
 var EVENTS = CLASSIC_TRANSITION_EVENTS;
 var MACHINE_OWNED_FIELDS = /* @__PURE__ */ new Set([
   ...RUN_WIRE_KEYS,
+  "archive_confirmation",
   "classic_profile",
   "classic_migration"
 ]);
@@ -11915,6 +12948,7 @@ var FIELD_ENUMS = {
   auto_transition: ["true", "false"],
   verify_result: ["pending", "pass", "fail"],
   branch_status: ["pending", "handled"],
+  archive_confirmation: ["pending", "confirmed"],
   archived: ["true", "false"],
   direct_override: ["true", "false"],
   classic_profile: PROFILES,
@@ -11930,6 +12964,7 @@ var CLASSIC_FIELD_WIRE_NAMES2 = {
   phase: "phase",
   verificationReport: "verification_report",
   verifiedAt: "verified_at",
+  archiveConfirmation: "archive_confirmation",
   verifyResult: "verify_result",
   workflow: "workflow"
 };
@@ -11991,7 +13026,7 @@ function validateRelativePath(value, field2) {
 }
 async function exists6(file) {
   try {
-    await fs16.access(file);
+    await fs20.access(file);
     return true;
   } catch (error) {
     if (error.code === "ENOENT") return false;
@@ -12000,39 +13035,39 @@ async function exists6(file) {
 }
 async function nonempty3(file) {
   try {
-    return (await fs16.stat(file)).size > 0;
+    return (await fs20.stat(file)).size > 0;
   } catch (error) {
     if (error.code === "ENOENT") return false;
     throw error;
   }
 }
-async function changeDirectory(name) {
+async function changeDirectory2(name) {
   return resolveClassicChangeDirectory(name);
 }
 async function readDocument2(file) {
   let source;
   try {
-    source = await fs16.readFile(file, "utf8");
+    source = await fs20.readFile(file, "utf8");
   } catch (error) {
     if (error.code === "ENOENT") {
       fail2(
-        `ERROR: .comet.yaml not found at ${path17.relative(process.cwd(), file).replaceAll("\\", "/")}`
+        `ERROR: .comet.yaml not found at ${path21.relative(process.cwd(), file).replaceAll("\\", "/")}`
       );
     }
     throw error;
   }
-  const document = (0, import_yaml6.parseDocument)(source, { uniqueKeys: false });
+  const document = (0, import_yaml7.parseDocument)(source, { uniqueKeys: false });
   if (document.errors.length > 0) fail2(`ERROR: Invalid .comet.yaml: ${document.errors[0].message}`);
   return document;
 }
 async function atomicWrite2(file, content) {
-  await fs16.mkdir(path17.dirname(file), { recursive: true });
-  const temporary = `${file}.${randomUUID6()}.tmp`;
+  await fs20.mkdir(path21.dirname(file), { recursive: true });
+  const temporary = `${file}.${randomUUID7()}.tmp`;
   try {
-    await fs16.writeFile(temporary, content, "utf8");
-    await fs16.rename(temporary, file);
+    await fs20.writeFile(temporary, content, "utf8");
+    await fs20.rename(temporary, file);
   } catch (error) {
-    await fs16.rm(temporary, { force: true });
+    await fs20.rm(temporary, { force: true });
     throw error;
   }
 }
@@ -12108,10 +13143,14 @@ function sparseClassicState(record) {
     branchStatus: enumRecordValue(record, "branch_status", ["pending", "handled"], null),
     createdAt: nullableRecordString(record, "created_at"),
     verifiedAt: nullableRecordString(record, "verified_at"),
+    archiveConfirmation: enumRecordValue(
+      record,
+      "archive_confirmation",
+      ["pending", "confirmed"],
+      null
+    ),
     archived: nullableRecordBoolean(record, "archived") ?? false,
     directOverride: nullableRecordBoolean(record, "direct_override"),
-    buildCommand: nullableRecordString(record, "build_command"),
-    verifyCommand: nullableRecordString(record, "verify_command"),
     handoffContext: nullableRecordString(record, "handoff_context"),
     handoffHash: nullableRecordString(record, "handoff_hash"),
     classicProfile: enumRecordValue(record, "classic_profile", PROFILES, workflow),
@@ -12119,17 +13158,13 @@ function sparseClassicState(record) {
   };
 }
 async function projectConfigValue2(field2) {
-  const file = path17.resolve(".comet", "config.yaml");
-  if (!await exists6(file)) return null;
-  const document = await readDocument2(file);
-  const value = document.get(field2);
-  return value === null || value === void 0 ? null : scalar(value);
+  return (await readClassicConfigValue(field2))?.value ?? null;
 }
 async function projectLanguageDefault() {
   if (process.env.COMET_LANGUAGE)
     return validateLanguage(process.env.COMET_LANGUAGE, "COMET_LANGUAGE");
-  const value = await projectConfigValue2("language");
-  if (value) return validateLanguage(value, ".comet/config.yaml");
+  const configured = await readClassicConfigValue("language");
+  if (configured) return validateLanguage(configured.value, configured.source);
   return "en";
 }
 async function contextCompression() {
@@ -12157,14 +13192,14 @@ Valid values: off, standard, thorough`);
   return value === "null" ? null : value;
 }
 function gitOutput(args) {
-  const result3 = spawnSync3("git", args, { encoding: "utf8" });
-  return result3.status === 0 ? result3.stdout.trim() : null;
+  const result5 = spawnSync3("git", args, { encoding: "utf8" });
+  return result5.status === 0 ? result5.stdout.trim() : null;
 }
 async function stateFile(name) {
-  const change = await changeDirectory(name);
+  const change = await changeDirectory2(name);
   return {
     ...change,
-    file: path17.join(change.directory, ".comet.yaml")
+    file: path21.join(change.directory, ".comet.yaml")
   };
 }
 async function readField3(name, field2) {
@@ -12182,7 +13217,7 @@ async function readField3(name, field2) {
   return scalar(value);
 }
 function parsedValue(field2, value) {
-  const document = (0, import_yaml6.parseDocument)(`${field2}: ${value}
+  const document = (0, import_yaml7.parseDocument)(`${field2}: ${value}
 `);
   if (document.errors.length > 0) fail2(`ERROR: Invalid value: '${value}'`);
   return document.get(field2);
@@ -12204,7 +13239,7 @@ function validateSetValue(field2, value) {
 }
 async function setField2(output, name, field2, value, options = {}) {
   if (MACHINE_OWNED_FIELDS.has(field2) && !options.machineOwned) {
-    fail2(`ERROR: '${field2}' is a machine-owned Run field and cannot be set directly`);
+    fail2(`ERROR: '${field2}' is a machine-owned field and cannot be set directly`);
   }
   if (!SETTABLE_FIELDS.has(field2) && !MACHINE_OWNED_FIELDS.has(field2)) {
     fail2(`ERROR: Unknown field: '${field2}'`);
@@ -12267,10 +13302,10 @@ 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 fs16.mkdir(directory, { recursive: true });
+  await fs20.mkdir(directory, { recursive: true });
   const preset = workflow !== "full";
   const reviewMode = preset ? "off" : await reviewModeDefault();
-  const document = new import_yaml6.Document({
+  const document = new import_yaml7.Document({
     workflow,
     language: await projectLanguageDefault(),
     phase: "open",
@@ -12291,10 +13326,11 @@ async function init(output, name, workflow) {
     branch_status: "pending",
     created_at: (/* @__PURE__ */ new Date()).toISOString().slice(0, 10),
     verified_at: null,
+    archive_confirmation: null,
     archived: false
   });
   await atomicWrite2(file, document.toString());
-  output.stderr.push(green4(`Initialized: ${label}/.comet.yaml (workflow=${workflow})`));
+  output.stdout.push(green4(`Initialized: ${label}/.comet.yaml (workflow=${workflow})`));
 }
 async function requirePhase(name, expected) {
   const actual = await readField3(name, "phase");
@@ -12345,13 +13381,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(path17.join(directory, artifact))) {
+    if (!await nonempty3(path21.join(directory, artifact))) {
       fail2(
         `ERROR: Cannot transition '${name}': ${artifact} must exist and be non-empty before leaving open`
       );
     }
   }
-  if (workflow === "full" && !await nonempty3(path17.join(directory, "design.md"))) {
+  if (workflow === "full" && !await nonempty3(path21.join(directory, "design.md"))) {
     fail2(
       `ERROR: Cannot transition '${name}': design.md must exist and be non-empty before leaving open`
     );
@@ -12359,14 +13395,14 @@ async function requireOpenArtifacts(name) {
 }
 async function requireDesignEvidence(name) {
   const designDoc = await readField3(name, "design_doc");
-  if (!designDoc || designDoc === "null" || !await nonempty3(path17.resolve(designDoc))) {
+  if (!designDoc || designDoc === "null" || !await nonempty3(path21.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 = path17.join(directory, ".comet.yaml");
+  const file = path21.join(directory, ".comet.yaml");
   const document = await readDocument2(file);
   for (const effect of effects) {
     const field2 = wireField2(effect.field);
@@ -12381,21 +13417,21 @@ 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(path17.join(directory, ".comet.yaml"));
+    const document = await readDocument2(path21.join(directory, ".comet.yaml"));
     classic = sparseClassicState(document.toJS());
     sparse = true;
   }
-  const result3 = applyClassicTransition(classic, event);
+  const result5 = applyClassicTransition(classic, event);
   if (projection.run) {
-    await transitionClassicRuntimeRun(directory, result3.classic, projection.run, {
+    await transitionClassicRuntimeRun(directory, result5.classic, projection.run, {
       event,
       source: "comet-state"
     });
   } else if (sparse) {
-    await writeSparseTransitionEffects(directory, result3.effects);
+    await writeSparseTransitionEffects(directory, result5.effects);
   } else {
     await writeClassicState(directory, {
-      classic: result3.classic,
+      classic: result5.classic,
       run: null,
       unknownKeys: projection.unknownKeys
     });
@@ -12405,10 +13441,10 @@ async function applyTransitionEvent(output, name, event) {
     event,
     source: "comet-state",
     from: classic,
-    to: result3.classic,
-    effects: result3.effects
+    to: result5.classic,
+    effects: result5.effects
   });
-  for (const effect of result3.effects) {
+  for (const effect of result5.effects) {
     output.stderr.push(green4(`[SET] ${wireField2(effect.field)}=${wireValue2(effect.to)}`));
   }
   output.stderr.push(green4(`[TRANSITION] ${event}`));
@@ -12428,7 +13464,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(path17.resolve(report))) {
+    if (!report || !await exists6(path21.resolve(report))) {
       fail2(
         `ERROR: Cannot transition '${name}': verification_report must point to an existing report file`
       );
@@ -12438,6 +13474,14 @@ async function transition(output, name, event) {
     }
   } else if (event === "verify-fail") {
     await requirePhase(name, "verify");
+  } else if (event === "archive-confirm") {
+    await requirePhase(name, "archive");
+    if (await readField3(name, "verify_result") !== "pass") {
+      fail2(`ERROR: Cannot transition '${name}': verify_result must be pass before archiving`);
+    }
+    if (await readField3(name, "archived") === "true") {
+      fail2(`ERROR: Cannot transition '${name}': already archived`);
+    }
   } else if (event === "preset-escalate") {
     await requirePhase(name, "build");
     const workflow = await readField3(name, "workflow");
@@ -12456,6 +13500,11 @@ async function transition(output, name, event) {
     if (await readField3(name, "verify_result") !== "pass") {
       fail2(`ERROR: Cannot transition '${name}': verify_result must be pass before archiving`);
     }
+    if (await readField3(name, "archive_confirmation") !== "confirmed") {
+      fail2(
+        `ERROR: Cannot transition '${name}': archive_confirmation must be confirmed before archiving`
+      );
+    }
   }
   await applyTransitionEvent(output, name, event);
 }
@@ -12482,9 +13531,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 = path17.resolve(taskFile);
+  const file = path21.resolve(taskFile);
   if (!await exists6(file)) fail2(`ERROR: Task file not found: ${taskFile}`);
-  const lines = (await fs16.readFile(file, "utf8")).split(/\r?\n/u);
+  const lines = (await fs20.readFile(file, "utf8")).split(/\r?\n/u);
   const matches = lines.filter(
     (line) => [`- [ ] ${taskText}`, `- [x] ${taskText}`, `- [X] ${taskText}`].includes(line)
   );
@@ -12522,21 +13571,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(path17.join(directory, artifact)) ? pass2 : reject)(
-        `${artifact} ${await nonempty3(path17.join(directory, artifact)) ? "non-empty" : "missing or empty"}`
+      (await nonempty3(path21.join(directory, artifact)) ? pass2 : reject)(
+        `${artifact} ${await nonempty3(path21.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(path17.resolve(designDoc)) ? pass2 : reject)(`design_doc=${designDoc} (expected: non-null and file exists)`);
+      (designDoc && designDoc !== "null" && await exists6(path21.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(path17.join(directory, artifact)) ? pass2 : reject)(
-        `${artifact} ${await nonempty3(path17.join(directory, artifact)) ? "non-empty" : "missing or empty"}`
+      (await nonempty3(path21.join(directory, artifact)) ? pass2 : reject)(
+        `${artifact} ${await nonempty3(path21.join(directory, artifact)) ? "non-empty" : "missing or empty"}`
       );
     }
   } else if (phase === "verify") {
@@ -12558,7 +13607,7 @@ async function check2(output, name, phase) {
 }
 function fieldStatus(field2, value, file) {
   if (!value || value === "null") return `  - ${field2}: PENDING`;
-  if (file && !existsSync3(path17.resolve(file))) {
+  if (file && !existsSync3(path21.resolve(file))) {
     return `  - ${field2}: BROKEN (path ${value} does not exist)`;
   }
   return `  - ${field2}: DONE (${value})`;
@@ -12567,7 +13616,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(path17.join(directory, artifact));
+    const done = await nonempty3(path21.join(directory, artifact));
     if (done) complete += 1;
     output.stdout.push(`  - ${artifact}: ${done ? "DONE" : "PENDING"}`);
   }
@@ -12580,7 +13629,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(path17.join(directory, artifact)) ? "DONE" : "MISSING (unexpected in design phase)"}`
+      `  - ${artifact}: ${await nonempty3(path21.join(directory, artifact)) ? "DONE" : "MISSING (unexpected in design phase)"}`
     );
   }
   const handoff = await readField3(name, "handoff_context");
@@ -12594,11 +13643,11 @@ async function recoverDesign(output, name, directory) {
     fieldStatus("design_doc", design, design),
     ""
   );
-  if (design && design !== "null" && await exists6(path17.resolve(design))) {
+  if (design && design !== "null" && await exists6(path21.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(path17.resolve(handoff))) {
+  } else if (handoff && handoff !== "null" && await exists6(path21.resolve(handoff))) {
     output.stdout.push(
       "Recovery action: Handoff generated but Design Doc not yet created. Resume from brainstorming confirmation (Step 1c)."
     );
@@ -12628,7 +13677,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 = path17.join(directory, "tasks.md");
+  const tasks = path21.join(directory, "tasks.md");
   if (!await exists6(tasks)) {
     output.stdout.push(
       "  Tasks: tasks.md MISSING",
@@ -12637,14 +13686,14 @@ async function recoverBuild(output, name, directory, workflow) {
     );
     return;
   }
-  const lines = (await fs16.readFile(tasks, "utf8")).split(/\r?\n/u);
+  const lines = (await fs20.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(path17.resolve(plan))) {
-    const planLines = (await fs16.readFile(path17.resolve(plan), "utf8")).split(/\r?\n/u);
+  if (plan && plan !== "null" && await exists6(path21.resolve(plan))) {
+    const planLines = (await fs20.readFile(path21.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;
   }
@@ -12716,27 +13765,29 @@ function resolveBuildRecoveryAction(workflow, isolation, buildMode, pause, subag
   return "Recovery action: All tasks done. Run guard to transition to verify.";
 }
 async function recoverVerify(output, name) {
-  const result3 = await readField3(name, "verify_result");
+  const result5 = await readField3(name, "verify_result");
   const mode = await readField3(name, "verify_mode");
   const report = await readField3(name, "verification_report");
   const branch = await readField3(name, "branch_status");
   output.stdout.push(
     "  Verification:",
-    fieldStatus("verify_result", result3),
+    fieldStatus("verify_result", result5),
     fieldStatus("verify_mode", mode),
     fieldStatus("verification_report", report, report),
     fieldStatus("branch_status", branch),
     "",
-    result3 === "pass" && branch === "handled" ? "Recovery action: Verification complete. Run guard to transition to archive." : result3 === "fail" ? "Recovery action: Verification failed and rolled back to build. Resume from /comet-build." : "Recovery action: Verification not yet started or in progress. Run scale assessment then verify."
+    result5 === "pass" && branch === "handled" ? "Recovery action: Verification complete. Run guard to transition to archive." : result5 === "fail" ? "Recovery action: Verification failed and rolled back to build. Resume from /comet-build." : "Recovery action: Verification not yet started or in progress. Run scale assessment then verify."
   );
 }
 async function recoverArchive(output, name) {
+  const archiveConfirmation = await readField3(name, "archive_confirmation");
   output.stdout.push(
     "  Archive:",
     fieldStatus("verify_result", await readField3(name, "verify_result")),
+    fieldStatus("archive_confirmation", archiveConfirmation),
     fieldStatus("archived", await readField3(name, "archived")),
     "",
-    "Recovery action: Run /comet-archive to complete archiving."
+    archiveConfirmation === "confirmed" ? "Recovery action: Archive is confirmed. Run /comet-archive to complete archiving." : "Recovery action: Ask for final archive confirmation in /comet-archive before running the archive command."
   );
 }
 async function recover(output, name) {
@@ -12771,19 +13822,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 = path17.join(directory, "tasks.md");
-  const taskCount = await exists6(tasksFile) ? (await fs16.readFile(tasksFile, "utf8")).split(/\r?\n/u).filter((line) => /^- \[/u.test(line)).length : 0;
-  const specs = path17.join(directory, "specs");
+  const tasksFile = path21.join(directory, "tasks.md");
+  const taskCount = await exists6(tasksFile) ? (await fs20.readFile(tasksFile, "utf8")).split(/\r?\n/u).filter((line) => /^- \[/u.test(line)).length : 0;
+  const specs = path21.join(directory, "specs");
   let deltaSpecs = 0;
   if (await exists6(specs)) {
-    for (const entry2 of await fs16.readdir(specs)) {
-      if (await exists6(path17.join(specs, entry2, "spec.md"))) deltaSpecs += 1;
+    for (const entry2 of await fs20.readdir(specs)) {
+      if (await exists6(path21.join(specs, entry2, "spec.md"))) deltaSpecs += 1;
     }
   }
   const plan = await readField3(name, "plan");
   let baseRef = "";
-  if (plan && plan !== "null" && await exists6(path17.resolve(plan))) {
-    const match = (await fs16.readFile(path17.resolve(plan), "utf8")).match(/^base-ref:\s*(.+)$/mu);
+  if (plan && plan !== "null" && await exists6(path21.resolve(plan))) {
+    const match = (await fs20.readFile(path21.resolve(plan), "utf8")).match(/^base-ref:\s*(.+)$/mu);
     baseRef = match?.[1].trim() ?? "";
   }
   if (!baseRef) baseRef = await readField3(name, "base_ref");
@@ -12793,19 +13844,102 @@ async function scale(output, name) {
     ...baseRef && baseRef !== "null" ? [`${baseRef}...HEAD`] : ["HEAD"]
   ]);
   const changedFiles = changed ? changed.split(/\r?\n/u).filter(Boolean).length : 0;
-  const result3 = taskCount > 3 || deltaSpecs > 1 || changedFiles > 8 ? "full" : "light";
-  await setField2(new CommandOutput(), name, "verify_mode", result3);
+  const result5 = taskCount > 3 || deltaSpecs > 1 || changedFiles > 8 ? "full" : "light";
+  await setField2(new CommandOutput(), name, "verify_mode", result5);
   output.stderr.push(
     `=== Scale Assessment: ${name} ===`,
     `  Tasks: ${taskCount} (threshold: 3)`,
     `  Delta specs: ${deltaSpecs} capabilities (threshold: 1)`,
     `  Changed files: ${changedFiles} (threshold: 8)`,
-    `  → Result: ${result3}`,
-    green4(`[SCALE] verify_mode=${result3}`)
+    `  → Result: ${result5}`,
+    green4(`[SCALE] verify_mode=${result5}`)
   );
 }
-function required(args, count, usage2) {
-  if (args.length < count) fail2(usage2);
+function parseRecordCheckOptions(args) {
+  let command;
+  let exitCodeText;
+  let cwd;
+  for (let index = 0; index < args.length; index += 2) {
+    const option = args[index];
+    if (!["--command", "--exit-code", "--cwd"].includes(option)) {
+      fail2(`ERROR: Unknown option: ${option}`);
+    }
+    const value = args[index + 1];
+    if (value === void 0) fail2(`ERROR: Missing value for option: ${option}`);
+    if (option === "--command") command = value;
+    else if (option === "--exit-code") exitCodeText = value;
+    else cwd = value;
+  }
+  if (command === void 0) fail2("ERROR: Missing option: --command");
+  if (exitCodeText === void 0) fail2("ERROR: Missing option: --exit-code");
+  if (!/^-?\d+$/u.test(exitCodeText)) fail2("ERROR: --exit-code must be an integer");
+  return { command, exitCode: Number(exitCodeText), ...cwd === void 0 ? {} : { cwd } };
+}
+async function recordCheck(output, name, scopeText, args) {
+  validateChangeName4(name);
+  if (scopeText !== "build" && scopeText !== "verify") {
+    fail2(`ERROR: Invalid command check scope: '${scopeText}'`);
+  }
+  const options = parseRecordCheckOptions(args);
+  const { label, directory, file } = await stateFile(name);
+  if (label !== `openspec/changes/${name}` || !await exists6(file)) {
+    fail2(`ERROR: command checks require an active change: ${name}`);
+  }
+  try {
+    const projection = await readClassicState(directory, { migrate: false });
+    if (!projection.classic || !projection.run) {
+      throw new Error("command checks require an existing synchronized Classic Run");
+    }
+    const { run } = await validateClassicRuntimeRun(directory, projection);
+    const recorded = await recordCommandCheck(directory, run, {
+      scope: scopeText,
+      ...options
+    });
+    output.stderr.push(
+      green4(
+        `[RECORDED] ${recorded.scope} exit=${recorded.exitCode} cwd=${recorded.cwd} command=${recorded.command}`
+      )
+    );
+  } catch (error) {
+    fail2(`ERROR: ${error.message}`);
+  }
+}
+function required(args, count, usage3) {
+  if (args.length < count) fail2(usage3);
+}
+function requiredExact(args, count, usage3) {
+  if (args.length !== count) fail2(usage3);
+}
+async function selectChange(output, name) {
+  validateChangeName4(name);
+  try {
+    const selection = await selectCurrentChange(process.cwd(), name);
+    output.stderr.push(
+      green4(
+        `[SELECTED] current change: ${selection.change}${selection.branch ? ` (branch: ${selection.branch})` : ""}`
+      )
+    );
+  } catch (error) {
+    fail2(`ERROR: ${error instanceof Error ? error.message : String(error)}`);
+  }
+}
+async function currentChange(output) {
+  const resolution = await resolveCurrentChange(process.cwd());
+  if (resolution.status === "selected") {
+    output.stdout.push(resolution.selection.change);
+    return;
+  }
+  if (resolution.status === "missing") {
+    fail2("ERROR: no current change selected\nUse: comet-state.mjs select <change-name>");
+  }
+  fail2(
+    `ERROR: current change selection is stale: ${resolution.reason}
+Use: comet-state.mjs select <change-name>`
+  );
+}
+async function clearSelection(output) {
+  await clearCurrentChange(process.cwd());
+  output.stderr.push(green4("[CLEARED] current change selection"));
 }
 var classicStateCommand = async (args) => {
   const output = new CommandOutput();
@@ -12832,9 +13966,25 @@ var classicStateCommand = async (args) => {
     } else if (subcommand === "scale") {
       required(rest, 1, "Usage: comet-state.mjs scale <change-name>");
       await scale(output, rest[0]);
+    } else if (subcommand === "record-check") {
+      required(
+        rest,
+        2,
+        "Usage: comet state record-check <change> <build|verify> --command <text> --exit-code <int> [--cwd <path>]"
+      );
+      await recordCheck(output, rest[0], rest[1], rest.slice(2));
     } else if (subcommand === "task-checkoff") {
       required(rest, 2, "Usage: comet-state.mjs task-checkoff <file> <task-text>");
       await taskCheckoff(output, rest[0], rest[1]);
+    } else if (subcommand === "select") {
+      requiredExact(rest, 1, "Usage: comet-state.mjs select <change-name>");
+      await selectChange(output, rest[0]);
+    } else if (subcommand === "current") {
+      requiredExact(rest, 0, "Usage: comet-state.mjs current");
+      await currentChange(output);
+    } else if (subcommand === "clear-selection") {
+      requiredExact(rest, 0, "Usage: comet-state.mjs clear-selection");
+      await clearSelection(output);
     } else if (subcommand === "next") {
       required(rest, 1, "Usage: comet-state.mjs next <change-name>");
       await next(output, rest[0]);
@@ -12859,7 +14009,8 @@ var CLASSIC_COMMANDS = [
   "handoff",
   "archive",
   "hook-guard",
-  "intent"
+  "intent",
+  "resume-probe"
 ];
 var DEFAULT_HANDLERS = {
   state: classicStateCommand,
@@ -12868,7 +14019,8 @@ var DEFAULT_HANDLERS = {
   handoff: classicHandoffCommand,
   archive: classicArchiveCommand,
   "hook-guard": classicHookGuardCommand,
-  intent: classicIntentCommand
+  intent: classicIntentCommand,
+  "resume-probe": classicResumeProbeCommand
 };
 function isClassicCommand(value) {
   return CLASSIC_COMMANDS.includes(value);
@@ -12903,14 +14055,14 @@ async function dispatch(command, args, options, handlers) {
     };
   }
 }
-function jsonResult(command, result3) {
+function jsonResult(command, result5) {
   return {
-    exitCode: result3.exitCode,
+    exitCode: result5.exitCode,
     stdout: JSON.stringify({
       command: command ?? null,
-      exitCode: result3.exitCode,
-      ...result3.stdout === void 0 ? {} : { stdout: result3.stdout },
-      ...result3.stderr === void 0 ? {} : { stderr: result3.stderr }
+      exitCode: result5.exitCode,
+      ...result5.stdout === void 0 ? {} : { stdout: result5.stdout },
+      ...result5.stderr === void 0 ? {} : { stderr: result5.stderr }
     }) + "\n"
   };
 }
@@ -12918,15 +14070,15 @@ async function runClassicCli(argv, handlers = DEFAULT_HANDLERS) {
   const json = argv.includes("--json");
   const args = argv.filter((argument) => argument !== "--json");
   const command = args.shift();
-  const result3 = await dispatch(command, args, { json }, handlers);
-  return json ? jsonResult(command, result3) : result3;
+  const result5 = await dispatch(command, args, { json }, handlers);
+  return json ? jsonResult(command, result5) : result5;
 }
 async function main(argv = process.argv.slice(2)) {
-  const result3 = await runClassicCli(argv);
-  if (result3.stdout) process.stdout.write(result3.stdout);
-  if (result3.stderr)
-    process.stderr.write(result3.stderr + (result3.stderr.endsWith("\n") ? "" : "\n"));
-  return result3.exitCode;
+  const result5 = await runClassicCli(argv);
+  if (result5.stdout) process.stdout.write(result5.stdout);
+  if (result5.stderr)
+    process.stderr.write(result5.stderr + (result5.stderr.endsWith("\n") ? "" : "\n"));
+  return result5.exitCode;
 }
 var entry = process.argv[1];
 if (entry && import.meta.url === pathToFileURL(entry).href) {