@rpamis/comet 0.4.0-beta.5 → 0.4.0-beta.7

package/assets/skills/comet/SKILL.md

@@ -1,293 +1,28 @@
 ---
 name: comet
-description: "Use when the user explicitly invokes /comet, asks to start or resume a Comet-managed workflow, or repository evidence identifies one unambiguous active Comet change; route through the intent runtime and .comet.yaml."
+description: "Route /comet requests or an active Comet change to the permanent Comet Native or Comet Classic entry selected by project configuration."
 ---
 
-# Comet — OpenSpec + Superpowers Dual-Star Development Workflow
+# Comet Entry
 
-OpenSpec and Superpowers orbit the same goal like a binary star system.
+`/comet` only selects an entry. It does not contain either workflow's execution method.
 
-```
-OpenSpec handles WHAT  — outline, proposal, spec lifecycle, archive
-Superpowers handles HOW — technical design, planning, execution, closing
-```
+1. First try the Comet CLI installed on PATH in the current project:
 
-**Core principle: brainstorming cannot be skipped. Every change must undergo deep design (except hotfix and tweak presets).**
+   ```text
+   comet workflow resolve . --json
+   ```
 
----
-
-## Decision Core
-
-Agents need only read this section for decision-making. Refer to the Reference Appendix as needed.
-
-### Output Language Rule
-
-Use the configured Comet artifact language as the output language for every OpenSpec and Superpowers artifact. The configured value is a normalized language id, `en` or `zh-CN`. For an existing change, read `language` from `openspec/changes/<name>/.comet.yaml` using `comet state get <name> language`. Before `.comet.yaml` exists, read `language` from project `.comet/config.yaml`, then fall back to global `~/.comet/config.yaml`; if neither exists, fall back to the current user request language. Include the resolved language explicitly in every prompt or ARGUMENTS passed to external OpenSpec/Superpowers skills.
-
-### Automatic Phase Detection
-
-**Step 0: Active Change Discovery and Intent Resolution**
-
-1. First load script locations through `comet/reference/scripts.md` and ensure `$COMET_INTENT` is available.
-2. Run `openspec list --json` to collect active changes.
-3. Fill a `CometIntentFrame` from the user request, active change list, and necessary repository state.
-4. Prefer `node "$COMET_INTENT" route --stdin` to pass the frame JSON and get the runtime-normalized route. `CometIntentFrame + runtime scorer` is the source of truth; this prose is only for intent recognition slot extraction.
-5. Handle the runtime route:
-   - `hotfix` → invoke `/comet-hotfix`
-   - `tweak` → invoke `/comet-tweak`
-   - `full` → follow the active-change table to invoke `/comet-open` or ask for confirmation
-   - `resume` → continue to Step 1 and read the selected change `.comet.yaml`
-   - `ask_user` → pause through `comet/reference/decision-point.md` and wait for the user's choice
-   - `out_of_scope` → explain that the input is not a Comet workflow start/resume request and do not initialize a change
-
-After the runtime route, Ambient Resume, or user choice resolves one explicit change, bind the current execution context before entering its phase Skill:
-
-```bash
-comet state select <change-name>
-```
-
-When multiple active changes exist and the user has not selected one, do not bind early; keep the existing `ask_user` decision point.
-
-### Comet Ambient Resume
-
-When the user did not explicitly invoke `/comet`, but this repository may already have an active Comet change, run the read-only probe before starting work that may need code changes or investigation:
-
-```bash
-node "$COMET_RESUME_PROBE" probe --stdin
-```
-
-The probe only reads repository state. Follow the returned action:
-
-- `auto_resume`: print one line, `[COMET] Detected active change <name>; resuming via <nextCommand>.`, then enter `nextCommand`.
-- `ask_user`: ask one short question and wait.
-- `out_of_scope` or `none`: do not enter the Comet workflow.
-
-Never attach unrelated work to an active Comet change only because `.comet.yaml` exists.
-
-**Minimal CometIntentFrame Skeleton**:
-
-```json
-{
-  "schema_version": "comet.intent.v1",
-  "utterance": "<user request>",
-  "intent": { "name": "start_change", "confidence": 0.8 },
-  "slots": {
-    "requested_action": "start",
-    "workflow_candidate": "full",
-    "user_explicit_workflow": null,
-    "change_id": null,
-    "existing_behavior": null,
-    "new_capability": null,
-    "public_api_change": null,
-    "schema_change": null,
-    "cross_module_change": null
-  },
-  "context": {
-    "active_changes_count": 0,
-    "active_change_names": []
-  },
-  "evidence": [],
-  "proposed_route": {
-    "name": "ask_user",
-    "confidence": 0.5
-  }
-}
-```
-
-**Intent Recognition Slot Extraction**:
-See `comet/reference/intent-frame.md` for complete field meanings; normal routing only needs the minimal skeleton above.
-
-- `fix_bug` + `existing_behavior: true` + no new capability/public API/schema/cross-module signal → prefer `hotfix`
-- User explicitly describes a lightweight/medium change that can fit in a single OpenSpec change, should be executed through OpenSpec apply, and does not need full `/comet` deep design/plan → prefer `tweak`
-- Copy, config, docs, prompt, or a lightweight/medium single OpenSpec change → prefer `tweak`
-- New capability, public API, schema change, cross-module coordination, or architecture work → prefer `full`
-- Multiple active changes without an explicit change → `ask_user`
-- Low confidence, missing key evidence, or explicit workflow conflicting with risk signals → `ask_user`
-
-| Active changes | User input | Behavior |
-|----------------|------------|----------|
-| None | `full` route | → Invoke `/comet-open` |
-| Exactly 1 | `/comet <description>` | → **Ask**: continue this change or create a new change |
-| Multiple | `/comet <description>` | → **Ask**: continue existing or create new; if continuing, list changes for selection |
-| Exactly 1 | `/comet` with no description | → Auto-select, enter Step 1 |
-| Multiple | `/comet` with no description | → List changes for user selection |
-
-<IMPORTANT>
-When the user chooses "create a new change", **must invoke `/comet-open`**. Do not call `/opsx:new` directly.
-`/comet-open` performs dual initialization: OpenSpec artifacts (created by internal `/opsx:new`) plus `.comet.yaml` state file.
-Calling `/opsx:new` directly leaves `.comet.yaml` missing and breaks later phase detection.
-</IMPORTANT>
-
-**Step 1: Read `.comet.yaml` state metadata**
-
-Prefer reading `openspec/changes/<name>/.comet.yaml`. If not available, fall back to `openspec status --change "<name>" --json`, `tasks.md`, and `docs/superpowers/` file checks.
-
-**Resume rules**:
-- On every context resume, rerun Step 0 and Step 1; do not trust conversation history for phase detection
-- If there is an active change and the worktree has uncommitted changes, handle them through `comet/reference/dirty-worktree.md`. That protocol defines checks, attribution, and prohibitions; this file does not repeat them
-- If `phase: build`, first check `build_pause`, `plan`, `isolation`, `build_mode`, `tdd_mode`, and `review_mode` (see details below):
-  - If `build_pause: plan-ready` but `isolation`, `build_mode`, `tdd_mode`, and `review_mode` are all already set, treat as stale pause: first output `[COMET] Detected stale pause (build_pause=plan-ready but isolation/build_mode/tdd_mode/review_mode are set), auto-clearing and continuing`, then run `comet state set <name> build_pause null`, then read the next unchecked task from tasks.md and resume execution per `build_mode`
-  - If `build_pause: plan-ready` and the plan file exists, but `isolation`, `build_mode`, `tdd_mode`, or `review_mode` is not yet set, return to the `/comet-build` plan-ready resume point, prompt the user to complete/confirm workspace isolation, execution method, TDD mode, and code review mode, and do not regenerate the plan
-  - If `build_pause: plan-ready` but the plan file is missing, return to `/comet-build` to handle corrupted state or regenerate the plan
-  - If `isolation`, `build_mode`, `tdd_mode`, or `review_mode` is unset, return to the corresponding `/comet-build` step to supplement before executing
-  - If all are set, read the next unchecked task from tasks.md and continue:
-    - If `build_mode: subagent-driven-development`, do not execute tasks directly in the main window; return to `/comet-build`'s background subagent dispatch rules, main window only coordinates
-    - Other execution modes follow `/comet-build`'s corresponding rules
-- If `verify_result: fail`, read `verify_failures`. At 3 or fewer failures, invoke `/comet-build` directly to continue the recorded repair loop without re-asking. Above the automatic limit, return to `/comet-verify` for the exception decision. User input is required only to accept a WARNING/SUGGESTION deviation or choose a strategy after the retry limit
-- If `phase: open` but OpenSpec `applyRequires` is complete, run `comet guard <change-name> open --apply` to repair state, then continue detection
-- If `phase: archive`, only invoke `/comet-archive`; confirm first, archive, commit exact archive paths, then handle the branch and run the archive guard
-
-**Step 2: Phase Determination** (check in order, first match wins)
-
-1. `archived: true` or change moved to archive → Workflow complete
-2. `verify_result: pass` and `archived` is not `true` → Invoke `/comet-archive` (first perform final archive confirmation)
-3. `verify_result: fail` → Invoke `/comet-build` automatically to continue repair. If `verify_failures` exceeds the automatic limit, enter `/comet-verify`'s retry-limit strategy decision
-4. `phase: verify` or tasks.md all checked → Invoke `/comet-verify`
-5. `phase: build` or has Design Doc but plan/execution incomplete → Route by workflow: `hotfix` → `/comet-hotfix`, `tweak` → `/comet-tweak`, `full` → `/comet-build`
-6. `phase: design` or has change but no Design Doc → Invoke `/comet-design`
-7. `phase: open` or active change exists but `.comet.yaml` is missing → Invoke `/comet-open`
-8. No active change → Invoke `/comet-open`
-
-If metadata conflicts with file state, use verifiable file state as source of truth and correct `.comet.yaml` before continuing.
-
-### Preset Upgrade Assessment
-
-hotfix/tweak scope assessment uses a three-layer division of labor, avoiding "using pure file count as a hard upgrade condition" that wrongly blocks normal small changes:
-
-1. **Qualitative-change signals** (agent semantic recognition; hitting any one pauses and delegates a two-choice decision to the user): cross-module coordinated change, new capability needed, database schema change, introduces new public API, hits deep architecture issues (each preset reuses this core signal set and may add its own context-specific signal, such as tweak's "needing to split into multiple OpenSpec changes")
-2. **File-count tripwire** (user decides; not an automatic upgrade): when changed files exceed a hint threshold, pause and let the user decide whether to continue the preset or upgrade to full; do not auto-kick
-3. **Verification weight** (scale script decides): `comet state scale` only decides `verify_mode` (verification weight); it does not block the flow or trigger an upgrade
-
-**Upgrade decision point (user chooses one of two)**:
-- Continue the preset lightweight flow (user confirms scope is manageable)
-- Upgrade to full `/comet` (use `comet state transition <name> preset-escalate` to legally rewind to design and clear preset-only build settings; after the Design Doc, choose the full workflow configuration again in one joint decision)
-
-See the "Upgrade Assessment" section of each `comet-hotfix` / `comet-tweak` for detailed rules.
-
-### Error Handling Quick Reference
-
-| Scenario | Handling |
-|----------|----------|
-| `openspec list --json` fails | Check if openspec is installed, prompt user to run `openspec init` |
-| Sub-skill unavailable | Stop workflow, prompt to install or enable the corresponding skill |
-| `.comet.yaml` missing | Enter the relevant preset's `/comet-open` initialization, then run `comet state select`; never skip initialization |
-| `.comet.yaml` malformed | Stop and report the parse error; repair from version control, backup, or verifiable artifacts, never overwrite it with `comet state set` |
-| Build/test fails | Return to build phase for fixes, do not enter verify |
-| Incomplete change directory structure | Fill missing files according to `comet-open` artifact requirements |
-
-### Phase Transitions
-
-<IMPORTANT>
-A single `/comet` invocation starts from the detected phase and advances to the next phase when exit conditions are met.
-
-Flow chain: open → design → build → verify → archive
-
-**Continuous execution requirement**: starting from the detected phase, the agent automatically continues through all later phases. But **auto-advancing only applies at transition points without user decisions**. When encountering user decision points, **must use the current platform's available user input/confirmation mechanism to pause and wait for the user's explicit response**. Must not use recommendation rules, defaults, or historical preferences to substitute for user confirmation, and must not just output a text prompt and then continue executing.
-
-**Distinguish phase advancement vs automatic handoff**: each sub-skill runs phase guard `--apply` before exit to advance the `.comet.yaml` `phase` field. This step **always happens** and is not controlled by `auto_transition`. After that, the sub-skill runs `comet state next <name>` to resolve the next action: when `auto_transition` is not `false`, output is `NEXT: auto` (auto-invoke next skill); when `auto_transition` is `false`, output is `NEXT: manual` (do not invoke next skill; return control with `HINT`). `NEXT: manual` is not a user decision point and must not ask whether to continue. Therefore `auto_transition` **only controls next skill invocation, not phase advancement**. Regardless of `auto_transition`, genuine user decision points below remain blocking.
-
-**Decision points are blocking points**: whenever reaching any of the following nodes, the current `/comet` invocation must stop, and follow the `comet/reference/decision-point.md` protocol to obtain the user's explicit choice. Only after the user explicitly chooses can the corresponding state fields be written and operations executed, then auto-advance resumes.
-
-Nodes requiring user participation (pause only at these nodes):
-1. Workflow target selection: multiple active changes, continue an existing change versus create a new one, or choose which completed batch item starts first
-2. Open-phase final proposal/design/tasks review, including the change name and scope; clear requests have no pre-artifact summary/name confirmation
-3. Confirm the design approach during brainstorming
-4. One joint build decision: plan-ready pause or all available workflow settings (workspace isolation + execution method + TDD mode + code review mode, plus branch name when branch is selected)
-5. Verify-phase acceptance of WARNING/SUGGESTION deviations, Spec drift handling, or continue/stop after the 4th failure; the first 3 clearly repairable failures close automatically
-6. Archive phase final confirmation before running the archive script
-7. Choose finishing-branch handling after exact archive changes are committed
-8. Encounter an upgrade-assessment signal (hotfix/tweak → user chooses one of two: continue preset / upgrade to full workflow)
-9. Build phase scope expansion requiring redesign or new change split
-10. Open phase large PRD split confirmation
-
-Agents should not skip these decision points; other unambiguous phase transitions must proceed automatically, must not exit midway. At decision points, **must not skip user confirmation or choose automatically — must explicitly obtain the user's choice through the current platform's available user input/confirmation mechanism before continuing**.
-
-**Red Flags** — when these thoughts appear, STOP and check:
-
-| Agent Thought | Actual Risk |
-|--------------|-------------|
-| "The user would probably agree with this approach" | Cannot decide for the user — use the current platform's user input/confirmation mechanism |
-| "This is a small change, confirmation isn't needed" | Decision points have no size exception — blocking points must wait |
-| "The user chose A last time, so A again" | Historical preference cannot substitute for current confirmation |
-| "I explained the plan and the user didn't object" | No objection ≠ consent — must use tool to get explicit choice |
-| "The flow has reached this point, should be fine" | Verification not passed ≠ passed — check verify_result |
-</IMPORTANT>
-
----
-
-## Subcommand Quick Reference
-
-| Command | Phase | Owner | Artifacts |
-|---------|-------|-------|-----------|
-| `/comet-open` | 1. Open | OpenSpec | proposal.md, design.md, tasks.md |
-| `/comet-design` | 2. Deep Design | Superpowers | Design Doc, delta spec |
-| `/comet-build` | 3. Plan and Build | Superpowers | Implementation plan, code commits |
-| `/comet-verify` | 4. Verify | Both | Verification report |
-| `/comet-archive` | 5. Archive and Close | OpenSpec | delta→main spec sync, design doc markup, archive commit, branch handling |
-| `/comet-hotfix` | Preset path | Both | Quick fix (skip brainstorming) |
-| `/comet-tweak` | Preset path | Both | OpenSpec-chained medium change (delta spec is first-class, skip brainstorming and full plan) |
-
-```
-/comet
-  ↓ Auto-detect
-/comet-open ──→ /comet-design ──→ /comet-build ──→ /comet-verify ──→ /comet-archive
-  (OpenSpec)      (Superpowers)     (Superpowers)     (Both)          (OpenSpec)
-
-/comet-hotfix (preset, skip brainstorming)
-  open ──→ build ──→ verify ──→ archive
-    ↑ Upgrade-assessment signal hit → user chooses one of two (continue preset / upgrade full) → if upgrade, transition preset-escalate → supplement Design Doc → return to full workflow
-
-/comet-tweak (lightweight preset, chains OpenSpec, delta spec is first-class)
-  open ──→ build ──→ verify ──→ archive
-    ↑ Upgrade-assessment signal hit → user chooses one of two (continue preset / upgrade full) → if upgrade, transition preset-escalate → supplement Design Doc → return to full workflow
-```
-
----
-
-## Reference Appendix
-
-### State Machine Hard Constraints
-
-- Before full-workflow `build → verify`, `isolation` must be `branch` or `worktree`; hotfix/tweak may truthfully use `current`
-- Before `build → verify`, `build_mode` must be selected
-- `build_mode: subagent-driven-development` must also have `subagent_dispatch: confirmed`
-- Before full workflow leaves build phase, `tdd_mode` must be selected as `tdd` or `direct`
-- Before full workflow leaves build phase, `review_mode` must be selected as `off`, `standard`, or `thorough`
-- `build_mode: direct` is allowed by default only for `hotfix` / `tweak`; full workflow requires `direct_override: true`
-- `build_pause` is not an execution method and must not be written to `build_mode`
-- These constraints are enforced by both `comet guard <name> build --apply` and `comet state transition <name> build-complete`
-
-### .comet.yaml Field Reference
-
-See `comet/reference/comet-yaml-fields.md` for complete field reference with examples and descriptions.
-
-### File Structure
-
-See `comet/reference/file-structure.md` for the complete directory layout and artifact organization.
-
-### Auto-Transition Protocol
-
-See `comet/reference/auto-transition.md` for the complete automatic handoff workflow.
-
-### Context Recovery
-
-See `comet/reference/context-recovery.md` for structured recovery after context compression.
-
-### Decision Point Protocol
-
-See `comet/reference/decision-point.md` for the complete user decision point protocol.
-
-### Debug Gate Protocol
-
-See `comet/reference/debug-gate.md` for the complete debug gate protocol.
+2. **Only** when the host explicitly reports `command not found`, `executable not found`, or `ENOENT`, proving that `comet` is absent from PATH, locate `<comet-skill-root>` from this `SKILL.md` and run the bundled entry runtime:
 
-### Script Location
+   ```text
+   node <comet-skill-root>/scripts/comet-entry-runtime.mjs . --json
+   ```
 
-Use the stable `comet` CLI for workflow state, guards, handoff, and archive. Locate internal launchers through `comet/reference/scripts.md` only for intent/resume probes that do not yet have a public subcommand. Key entry points:
+   If the CLI starts but exits nonzero, configuration parsing fails, output is not JSON, or a required field is invalid, do not retry through the bundled runtime. Stop and report the original error without falling back or guessing.
+3. Parse the JSON. Only accept `schema: comet.workflow-resolution.v1` and a `skill` value listed below.
+4. Invoke exactly one entry based only on the returned `skill`, passing the user's original request through unchanged:
+   - `comet-native` → `/comet-native`
+   - `comet-classic` → `/comet-classic`
 
-```bash
-comet guard <change-name> <phase> --apply             # phase guard + state update
-comet state transition <change-name> <event>          # open-complete | design-complete | build-complete | verify-pass | verify-fail
-comet state next <change-name>                        # NEXT: auto|manual|done + SKILL: <skill-name>
-comet archive <change-name>                           # full archive in one command
-```
+Do not switch workflows based on task size, file count, active changes, or model judgment. Native and Classic changes, states, and artifacts always remain independent.

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

@@ -21,6 +21,7 @@ tdd_mode: tdd
 review_mode: standard
 auto_transition: true
 isolation: branch
+bound_branch: null
 verify_mode: light
 verify_result: pending
 verify_failures: 0
@@ -37,7 +38,7 @@ archived: false
 | Field | Meaning |
 |-------|---------|
 | `workflow` | `full`, `hotfix`, or `tweak` |
-| `language` | Artifact language, `en` or `zh-CN`. Written to the project or global `.comet/config.yaml` according to install scope, snapshotted into `.comet.yaml` with project-over-global precedence when a change is created, and used as the main-language constraint for OpenSpec / Superpowers artifacts |
+| `language` | Artifact language, `en` or `zh-CN`. Written to `classic.language` in the project or global `.comet/config.yaml` according to install scope, snapshotted into `.comet.yaml` with project-over-global precedence when a change is created, and used as the main-language constraint for OpenSpec / Superpowers artifacts |
 | `phase` | Current phase: `open`, `design`, `build`, `verify`, `archive` (init sets `open`; guard handles transitions) |
 | `design_doc` | Associated Superpowers Design Doc path; may be empty |
 | `plan` | Associated Superpowers Plan path; may be empty |
@@ -47,7 +48,8 @@ archived: false
 | `subagent_dispatch` | `null` or `confirmed`. Only when the platform's real background subagent/Task/multi-agent dispatch capability is confirmed may `build_mode: subagent-driven-development` be written and used to leave the build phase |
 | `tdd_mode` | `tdd` or `direct`. Full workflow must select before leaving build. `tdd` forces write-failing-test-first per task; `direct` skips per-task TDD but still requires relevant tests and bug-regression evidence. hotfix/tweak default to `direct` |
 | `review_mode` | `off`, `standard`, or `thorough`. Full workflow must select before leaving build; hotfix/tweak default to `off` |
-| `isolation` | `current`, `branch`, or `worktree`. Full init may be `null` but must use a real `branch` or `worktree` before leaving build; hotfix/tweak default to `current` and must not claim branch isolation before creating one |
+| `isolation` | `current`, `branch`, or `worktree`. Full init may be `null`, but before leaving build the user must explicitly select `current`, create/select a real `branch`, or create/select a real `worktree`; hotfix/tweak may also truthfully use all three modes after the entry user decision point, and must not claim branch isolation before creating one |
+| `bound_branch` | Workspace branch binding record; may be empty. `isolation: current` / `branch` / `worktree` records the current Git branch of the directory the command runs in on first setting or entry check (for worktree mode, run set/check/guard inside that worktree, or the wrong branch gets bound/compared); switching `isolation` between workspace modes re-binds to the current branch, while repeating the same mode keeps the existing binding. Later `comet state select` / `comet state check` must confirm the bound branch still matches the current branch. On drift, `select` refuses and checks return `BLOCKED`; follow the decision-point protocol so the user chooses whether to switch back to the bound branch or explicitly confirm and run `comet state rebind <change-name>`. Clearing `isolation` clears this field |
 | `verify_mode` | `light` or `full`; may be empty |
 | `auto_transition` | `true` or `false`. Only controls whether to automatically invoke the next skill after phase guard advances phase; `false` outputs `manual` from `comet-state next`, pausing next-skill invocation but not blocking phase field updates |
 | `verify_result` | `pending`, `pass`, or `fail` |
@@ -67,7 +69,7 @@ archived: false
 
 ## State Machine Hard Constraints
 
-- Before full-workflow `build → verify`, `isolation` must be `branch` or `worktree`; hotfix/tweak may use `current`
+- Before `build → verify`, `isolation` must be `current`, `branch`, or `worktree`
 - Before `build → verify`, `build_mode` must be selected
 - `build_mode: subagent-driven-development` requires `subagent_dispatch: confirmed`
 - Full workflow must select `tdd_mode` as `tdd` or `direct` before leaving build

package/assets/skills/comet/reference/context-recovery.md

@@ -12,11 +12,11 @@ The user may resume the workflow directly from `/comet-open`, `/comet-design`, `
 comet state check <change-name> <phase> --recover
 ```
 
-If the check shows the actual phase, workflow, or evidence belongs to another skill, switch according to script output and `/comet` routing rules; do not keep writing state in the wrong phase. If the worktree has uncommitted changes, attribute them first via `comet/reference/dirty-worktree.md`.
+If the check shows the actual phase, workflow, or evidence belongs to another skill, switch according to script output and `/comet-classic` routing rules; do not keep writing state in the wrong phase. If the worktree has uncommitted changes, attribute them first via `comet/reference/dirty-worktree.md`.
 
-## Recovery Without Explicit `/comet`
+## Recovery Without Explicit `/comet-classic`
 
-If the user did not mention `/comet`, but this repository may have an active change, run the Ambient Resume probe before starting work that may need code changes or investigation. First locate scripts via `comet/reference/scripts.md` and ensure `$COMET_RESUME_PROBE` is available, then pass the current user request on stdin:
+If the user did not mention `/comet-classic`, but this repository may have an active change, run the Ambient Resume probe before starting work that may need code changes or investigation. First locate scripts via `comet/reference/scripts.md` and ensure `$COMET_RESUME_PROBE` is available, then pass the current user request on stdin:
 
 ```bash
 node "$COMET_RESUME_PROBE" probe --stdin

package/assets/skills/comet/reference/intent-frame.md

@@ -1,13 +1,13 @@
 # CometIntentFrame Field Reference
 
-Read this file only when field meanings are needed. Normal `/comet` routing only needs the minimal skeleton in the main Skill; the runtime fills omitted defaults and outputs the final `route`.
+Read this file only when field meanings are needed. Normal `/comet-classic` routing only needs the minimal skeleton in the main Skill; the runtime fills omitted defaults and outputs the final `route`.
 
 ## Top-Level Fields
 
 | Field | Meaning |
 |-------|---------|
 | `schema_version` | Frame version. Currently fixed to `comet.intent.v1`. |
-| `utterance` | The user request that triggered `/comet`. |
+| `utterance` | The user request that triggered `/comet-classic`. |
 | `intent` | High-level user intent and confidence. If confidence is below the runtime threshold, routing falls back to `ask_user`. |
 | `slots` | Routing slots normalized from the user request. |
 | `context` | Repository context read from local state; this is not extracted from the user utterance. |

package/assets/skills/comet/reference/scripts.md

@@ -24,7 +24,7 @@ Guard `--apply` advances state after checks pass. Use `comet state transition` w
 
 ## Compatibility, Recovery, and Internal Command Bootstrap
 
-The script discovery below is only for legacy compatibility, recovery when the CLI is unavailable, and internal `/comet` entry commands. Normal public workflows must not prefer it. Comet scripts are distributed in `comet/scripts/`; recovery code must locate them once and cache environment variables instead of hardcoding paths:
+The script discovery below is only for legacy compatibility, recovery when the CLI is unavailable, and internal `/comet-classic` entry commands. Normal public workflows must not prefer it. Comet scripts are distributed in `comet/scripts/`; recovery code must locate them once and cache environment variables instead of hardcoding paths:
 
 ```bash
 COMET_ENV="${COMET_ENV:-$(find . "$HOME"/.*/skills "$HOME/.config" "$HOME/.gemini" -path '*/comet/scripts/comet-env.mjs' -type f -print -quit 2>/dev/null)}"
@@ -55,7 +55,7 @@ Agents run this bootstrap only when entering one of the compatibility, recovery,
 | `COMET_GUARD` | Phase exit guard and `--apply` state advancement |
 | `COMET_HANDOFF` | Design/Build handoff context pack generation |
 | `COMET_ARCHIVE` | One-command archive and main spec sync |
-| `COMET_INTENT` | `/comet` entry intent recognition and route scoring |
+| `COMET_INTENT` | `/comet-classic` entry intent recognition and route scoring |
 | `COMET_RESUME_PROBE` | Read-only Ambient Resume probe that decides whether to resume an active Comet workflow |
 
 ## Auto state update

package/assets/skills/comet/rules/comet-workflow-guard.en.md

@@ -0,0 +1,32 @@
+# Comet Current-Change Phase Rule
+
+This Rule is the persistent soft safeguard shared by Native and Classic. A project may enable both workflows, but one request must be owned by exactly one workflow/change; never apply both phase models at the same time.
+
+## Resolve the current request first
+
+At the start of every turn, when resuming work, or after possible context compression:
+
+1. Read `.comet/config.yaml`: `workflows` lists enabled capabilities, while `default_workflow` only selects the default `/comet` entry.
+2. Read `.comet/current-change.json`: its `workflow + change` identifies the current request owner.
+3. Without a selection, infer read-only ownership only when exactly one active Comet change exists across the project. Multiple candidates require an explicit user selection.
+4. Stop on an invalid, stale, cross-branch, missing, or archived selection. Never fall back to `default_workflow` to guess ownership.
+
+A legacy Classic project without the current project schema uses only the Classic legacy fallback; that fallback never enables Native.
+
+## Apply only the selected phase model
+
+| Workflow | Ordinary implementation writes blocked | Ordinary implementation writes allowed |
+| --- | --- | --- |
+| Native | Shape, Verify, Archive | Build |
+| Classic | Open, Design, Archive | Build, Verify |
+
+- Native Verify only runs checks and records evidence. When it exposes an implementation problem, record the failed result and use the Native Runtime to return to Build before modifying the implementation. Ordinary dot-prefixed project files do not become cross-phase allowlisted paths merely because of their names.
+- For Native ownership, resume `/comet-native` and continue from Native state, evidence, and automatic-progression rules.
+- For Classic ownership, resume `/comet-classic` and continue from Classic state, decision points, and phase rules.
+- Never convert a Native change into a Classic change or vice versa. Switching workflows means selecting a separate change.
+
+## Hook constraint
+
+Each platform must install exactly one Comet Hook Router. One write event may invoke at most one workflow Guard; do not run separate Native and Classic Hooks.
+
+The Hook evaluates multi-file and patch targets atomically. It fails closed when the current phase blocks ordinary project writes, ownership is ambiguous, state is stale, or a write target cannot be determined safely. Never bypass the Hook; follow its denial message to resume the owning workflow and select the current change again.

package/assets/skills/comet/rules/comet-workflow-guard.md

@@ -0,0 +1,32 @@
+# Comet 当前需求阶段规则
+
+本规则是 Native 与 Classic 共用的常驻软性防线。项目可以启用两种 workflow，但一个需求只能由一个 workflow/change 管理；不得同时套用两套阶段规则。
+
+## 先确定当前需求
+
+每轮开始、恢复工作或怀疑上下文被压缩后，按以下顺序检查：
+
+1. 读取 `.comet/config.yaml`：`workflows` 表示项目启用的能力，`default_workflow` 只决定 `/comet` 的默认入口。
+2. 读取 `.comet/current-change.json`：其中的 `workflow + change` 才是当前需求所有者。
+3. selection 缺失时，只有全项目恰好一个 Comet 活跃 change 才能只读推断；存在多个候选时必须暂停并让用户选择。
+4. selection 无效、过期、跨分支失效或指向已归档 change 时停止，不得回退到 `default_workflow` 猜测。
+
+Classic 旧项目没有新版配置时只按 Classic legacy fallback 处理，不得因此启用 Native。
+
+## 只应用选中的阶段规则
+
+| Workflow | 禁止普通实现写入 | 允许普通实现写入 |
+| --- | --- | --- |
+| Native | Shape、Verify、Archive | Build |
+| Classic | Open、Design、Archive | Build、Verify |
+
+- Native 的 Verify 只运行检查并记录证据；发现实现问题时，先记录失败并通过 Native Runtime 回到 Build，再修改实现。点号开头的普通项目文件不因名称而自动成为跨阶段白名单。
+- 当前 workflow 是 Native：恢复 `/comet-native`，由 Native 状态、证据和自动推进协议继续。
+- 当前 workflow 是 Classic：恢复 `/comet-classic`，由 Classic 状态、确认点和阶段协议继续。
+- 不要把 Native change 转换成 Classic change，或反向转换；切换 workflow 必须选择另一个独立 change。
+
+## Hook 约束
+
+平台只应安装一个 Comet Hook Router。一次写入事件最多进入一个 workflow Guard；不得分别运行 Native 和 Classic Hook。
+
+Hook 会对多文件和 patch 目标整体裁决。当前阶段不允许普通项目写入、selection 不明确、状态失效或目标无法安全判断时会失败关闭。不要绕过 Hook；按拒绝信息恢复对应 workflow 并重新选择当前 change。