@rpamis/comet 0.4.0-beta.1 → 0.4.0-beta.3

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

@@ -7827,8 +7827,6 @@ var CLASSIC_WIRE_KEYS = [
   "verified_at",
   "archived",
   "direct_override",
-  "build_command",
-  "verify_command",
   "handoff_context",
   "handoff_hash",
   "classic_profile",
@@ -7937,8 +7935,6 @@ function classicStateFromDocument(doc) {
     verifiedAt: nullableString(doc, "verified_at"),
     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),
@@ -8002,8 +7998,6 @@ function classicStateToDocument(state) {
     verified_at: state.verifiedAt,
     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 +8052,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 {
@@ -8074,8 +8078,11 @@ async function readDocument(file) {
   return document;
 }
 async function readClassicState(changeDir) {
-  const document = await readDocument(path4.join(changeDir, ".comet.yaml"));
-  const doc = documentRecord(document);
+  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));
@@ -8083,13 +8090,15 @@ async function readClassicState(changeDir) {
     if (run) {
       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) {
+    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"));
@@ -8980,6 +8989,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 +9229,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,15 +9240,14 @@ 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) {
-    throw new Error(
-      `Invalid Classic state: unknown field(s): ${projection.unknownKeys.join(", ")}`
-    );
+  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);
 }
@@ -9939,13 +10171,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"
-  ]) {
+  for (const config of [".comet/config.yaml"]) {
     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)) {
@@ -10001,68 +10227,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");
 }
@@ -10100,6 +10264,13 @@ async function preflight(changeDir, name) {
 `);
     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) {
@@ -10144,6 +10315,24 @@ async function runChecks(output, builders) {
   }
   return blocked2;
 }
+async function removedProjectCommandField(field2) {
+  const config = path14.join(".comet", "config.yaml");
+  if (!await exists4(config)) return false;
+  const document = (0, import_yaml4.parseDocument)(await fs13.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 });
   return {
@@ -10151,10 +10340,11 @@ function runInferred(command) {
     output: `${result3.stdout ?? ""}${result3.stderr ?? ""}`.replace(/\n+$/u, "")
   };
 }
-async function buildPasses(changeDir) {
+async function buildPasses() {
   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 removedProjectCommandField("build_command")) {
+    return removedProjectCommandRun("build_command");
+  }
   if (await exists4("package.json") && /"build"/u.test(await fs13.readFile("package.json", "utf8"))) {
     return runInferred("npm run build");
   }
@@ -10169,11 +10359,12 @@ async function buildPasses(changeDir) {
   if (await exists4("Cargo.toml")) return runInferred("cargo build");
   return { status: 1, output: "" };
 }
-async function verificationCommandPasses(changeDir) {
+async function verificationCommandPasses() {
   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);
+  if (await removedProjectCommandField("verify_command")) {
+    return removedProjectCommandRun("verify_command");
+  }
+  return buildPasses();
 }
 async function tasksAllDone(changeDir) {
   const tasks = path14.join(changeDir, "tasks.md");
@@ -10567,7 +10758,7 @@ 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);
+      const buildResult = await buildPasses();
       return buildResult.status === 0 ? pass() : fail(buildResult.output);
     })
   ]);
@@ -10578,7 +10769,7 @@ async function guardVerifyChecks(output, 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);
+      const verifyResult = await verificationCommandPasses();
       return verifyResult.status === 0 ? pass() : fail(verifyResult.output);
     }),
     check(
@@ -11278,6 +11469,60 @@ function blocksSourceWrites(governing) {
   }
   return governing.phase === "build" && governing.classic?.workflow === "full" && !governing.classic.designDoc;
 }
+function isSuperpowersArtifactPath(relativePath2) {
+  return relativePath2.startsWith("docs/superpowers/");
+}
+function allowsSuperpowersArtifacts(governing) {
+  return governing.phase === "design" || governing.phase === "build" || governing.phase === "verify";
+}
+function governingChangeName(governing) {
+  return governing.changeDir ? path16.basename(governing.changeDir) : null;
+}
+var SUPERPOWERS_ARTIFACT_SUFFIXES = /* @__PURE__ */ new Set([
+  "design",
+  "plan",
+  "verify",
+  "verification",
+  "verification-report",
+  "report"
+]);
+function escapeRegex(value) {
+  return value.replace(/[.*+?^${}()|[\]\\]/gu, "\\$&");
+}
+function matchesRecordedSuperpowersArtifact(relativePath2, governing) {
+  const artifactPaths = [
+    governing.classic?.designDoc,
+    governing.classic?.plan,
+    governing.classic?.verificationReport
+  ];
+  return artifactPaths.some(
+    (artifactPath) => artifactPath && normalized(artifactPath) === relativePath2
+  );
+}
+function matchesSuperpowersArtifactName(relativePath2, changeName) {
+  const fileName = relativePath2.split("/").at(-1) ?? relativePath2;
+  const stem = fileName.replace(/\.[^.]+$/u, "");
+  if (stem === changeName) return true;
+  const suffixes = [...SUPERPOWERS_ARTIFACT_SUFFIXES].map(escapeRegex).join("|");
+  const pattern = new RegExp(`(^|[-_.])${escapeRegex(changeName)}[-_.](${suffixes})$`, "u");
+  return pattern.test(stem);
+}
+async function superpowersArtifactGoverningChange(relativePath2, projectRoot) {
+  const active = await activeChanges(projectRoot);
+  const recorded = active.find(
+    (governing) => matchesRecordedSuperpowersArtifact(relativePath2, governing)
+  );
+  if (recorded) return recorded;
+  const eligible = active.filter(allowsSuperpowersArtifacts);
+  const named = eligible.filter((governing) => {
+    const name = governingChangeName(governing);
+    return name !== null && matchesSuperpowersArtifactName(relativePath2, name);
+  }).sort(
+    (a, b) => (governingChangeName(b)?.length ?? 0) - (governingChangeName(a)?.length ?? 0)
+  )[0];
+  if (named) return named;
+  return null;
+}
 async function repoSourceGoverningChange(projectRoot) {
   const active = await activeChanges(projectRoot);
   return active.find(blocksSourceWrites) ?? active[0] ?? null;
@@ -11298,13 +11543,19 @@ async function governingChange(relativePath2, projectRoot) {
       return { changeDir, phase: "open", classic: null, archived: false };
     }
   }
+  if (isSuperpowersArtifactPath(relativePath2)) {
+    const superpowers = await superpowersArtifactGoverningChange(relativePath2, projectRoot);
+    if (superpowers) return { ...superpowers, superpowersArtifact: "matched" };
+    const fallback = await repoSourceGoverningChange(projectRoot);
+    return fallback ? { ...fallback, superpowersArtifact: "unmatched" } : null;
+  }
   return repoSourceGoverningChange(projectRoot);
 }
 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/");
@@ -11383,6 +11634,25 @@ function blockedMissingDesignDoc(relativePath2) {
     ].join("\n")
   );
 }
+function blockedUnmatchedSuperpowersArtifact(relativePath2, phase) {
+  return result(
+    2,
+    [
+      "",
+      "╔══════════════════════════════════════════╗",
+      "║     COMET PHASE GUARD — WRITE BLOCKED    ║",
+      "╚══════════════════════════════════════════╝",
+      "",
+      `  Current phase: ${phase}`,
+      `  Target file: ${relativePath2}`,
+      "",
+      "  BLOCKED: unmatched Superpowers artifact",
+      "  This docs/superpowers/ path does not match any active change artifact",
+      "  NEXT: record the artifact path in .comet.yaml or include the change name in the artifact filename",
+      ""
+    ].join("\n")
+  );
+}
 var classicHookGuardCommand = async (args) => {
   const projectRoot = parseProjectRoot(args);
   const target = inputTarget();
@@ -11414,8 +11684,13 @@ var classicHookGuardCommand = async (args) => {
   const phase = governing.phase;
   const openSpec = openSpecAllowed(relativePath2, phase);
   if (openSpec) return allowed(openSpec);
-  if (relativePath2.startsWith("docs/superpowers/") && (phase === "design" || phase === "build" || phase === "verify")) {
-    return allowed(`${relativePath2} (phase: ${phase}, superpowers)`);
+  if (isSuperpowersArtifactPath(relativePath2)) {
+    if (governing.superpowersArtifact === "matched" && allowsSuperpowersArtifacts(governing)) {
+      return allowed(`${relativePath2} (phase: ${phase}, superpowers)`);
+    }
+    if (governing.superpowersArtifact === "unmatched") {
+      return blockedUnmatchedSuperpowersArtifact(relativePath2, phase);
+    }
   }
   if (phase === "build" && governing.classic?.workflow === "full" && !governing.classic.designDoc) {
     return blockedMissingDesignDoc(relativePath2);
@@ -12026,8 +12301,6 @@ function sparseClassicState(record) {
     verifiedAt: nullableRecordString(record, "verified_at"),
     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),
@@ -12210,7 +12483,7 @@ async function init(output, name, workflow) {
     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");

package/assets/skills/comet-build/SKILL.md

@@ -284,15 +284,7 @@ Build is the longest phase and may span many tasks. To support resume after cont
 - Code review has been completed per the `executing-plans` review gate (Section "Execute plan") for the chosen `review_mode`: under `standard` or `thorough`, code review has been requested and CRITICAL review findings fixed or non-CRITICAL acceptance rationale recorded; under `review_mode: off`, the reason for skipping automatic code review has been recorded in a persistent artifact
 - **Phase guard**: Run `node "$COMET_GUARD" <change-name> build --apply`; after all PASS, state advances to `phase: verify`
 
-Guard reads project command configuration first:
-
-```yaml
-build_command: <build command>
-verify_command: <verify command>
-```
-
-Configuration can live in the change `.comet.yaml`, or in repo-root `.comet.yaml` / `comet.yaml` / `.comet.yml` / `comet.yml`.
-Configured commands use a restricted shell grammar: command words, quotes, paths, and `&&` for sequential steps are allowed; `;`, pipes, bare `&`, `$`, and backticks are rejected. Only when no command is configured does guard fall back to `npm run build`, Maven, or Cargo auto-detection. When a command fails, guard prints the command output as evidence for debugging.
+Guard runs the inferred project build check (`npm run build`, Maven, or Cargo when detected). When the inferred command fails, guard prints the command output as evidence for debugging.
 
 Before exit, run guard to auto-transition:
 

package/assets/skills-zh/comet/reference/comet-yaml-fields.md

@@ -2,7 +2,7 @@
 
 规范路径：`comet/reference/comet-yaml-fields.md`
 
-本文件是 `.comet.yaml` 状态文件的字段参考。按需查阅，不随 skill 一次性加载。
+本文件是 `openspec/changes/<name>/` 下每个 change 级 `.comet.yaml` 状态文件的字段参考。按需查阅，不随 skill 一次性加载。项目级默认配置只放在 `.comet/config.yaml`。
 
 ## 示例
 
@@ -59,8 +59,6 @@ archived: false
 | 字段 | 含义 |
 |------|------|
 | `direct_override` | `true`/`false`。full workflow 如需使用 `build_mode: direct`，必须显式设为 `true` |
-| `build_command` | 项目构建命令。guard 优先运行；支持命令词、引号、路径和 `&&` 顺序步骤；拒绝 `;`、管道、裸 `&`、`$` 和反引号 |
-| `verify_command` | 项目验证命令。verify guard 优先运行；使用与 `build_command` 相同的受限命令语法，未配置时回退到构建命令 |
 
 ## 状态机硬约束