forge-workflow 0.1.0-beta.2 → 0.1.0-beta.4

package/skills/dev/SKILL.md

@@ -13,12 +13,16 @@ description: >
   opening the PR (ship), for addressing PR review feedback (review), or for orchestrating
   several stages / taking an issue end-to-end to a merged PR (smith).
 allowed-tools: Bash, Read, Write, Edit, Grep, Glob
+next: validate
+terminal: false
 ---
 
 Implement each task from the /plan task list using a subagent-driven loop: implementer → spec compliance reviewer → code quality reviewer per task.
 
 # Dev
 
+> **Chain (HARD-GATE):** the ONLY skill you invoke after `dev` is `validate`. Never open a PR straight from `dev`.
+
 This skill reads the task list created by `/plan` and implements each task using a three-stage subagent loop. TDD is enforced inside each implementer subagent.
 
 ## Usage

package/skills/dev/evals/scorecard.json

@@ -0,0 +1,41 @@
+{
+  "skill": "dev",
+  "fixtures": "present",
+  "static": {
+    "token_cost": {
+      "desc_chars": 962,
+      "body_lines": 328,
+      "score": 20
+    },
+    "caps": {
+      "desc_within": true,
+      "body_within": true,
+      "score": 100
+    },
+    "description_quality": {
+      "has_trigger_cues": true,
+      "has_disambiguation_cues": true,
+      "adequate_length": true,
+      "score": 100
+    }
+  },
+  "router_reachability": {
+    "has_curated_rule": true,
+    "router_exempt": false,
+    "fixtures": "present",
+    "fixtures_total": 6,
+    "fixtures_best_hit": 2,
+    "reachable": true,
+    "keyword_alignment": 0.33
+  },
+  "behavioral": {
+    "trigger_recall": null,
+    "trigger_precision": null,
+    "disambiguation": null,
+    "chain_correctness": null,
+    "outcome_quality": null,
+    "variance": null,
+    "note": "behavioral — W5 (LLM judge): semantic recall/precision/chain/outcome/variance, not deterministic"
+  },
+  "composite": 76
+}

package/skills/gates/SKILL.md

@@ -0,0 +1,80 @@
+---
+name: gates
+description: >
+  Toggle Forge's workflow gates and rails — strong-but-toggleable enforcement. `forge gate
+  enable|disable <gate-id>` flips `workflow.gates.<id>.enabled` in `.forge/config.yaml`; the
+  installed git hooks read resolved config at run time, so disabling a rail makes them
+  genuinely inert. `forge gate approve|reject <issue> <gate>` records durable human-gate
+  approval events; `forge gate status`/`check` query them; `forge control <id>
+  <mandatory|optional|permission>` sets tri-state DECLARED intent (writes the same `enabled`
+  field — no independent runtime enforcement). Use when the user says "disable the gate",
+  "turn off TDD enforcement", "the tdd intent rail is blocking me", "toggle or enable a
+  gate", "loosen enforcement", or "approve a human gate". Common default-ON toggleable rails:
+  `rail.tdd_intent`, `rail.kernel_tracking`, `rail.auto_shepherd` — e.g. `forge gate disable
+  rail.tdd_intent`. NOT for addressing PR review feedback (review), NOT the status snapshot
+  of work in flight (status).
+allowed-tools: Bash, Read, Grep, Glob
+terminal: true
+---
+
+Forge's gates and rails are **default-strong but toggleable**. The `gates` skill is how you flip one off (or back on), record a human-gate approval, and see enforcement state. The stored truth is one field — `workflow.gates.<id>.enabled` — and the installed hooks read the resolved config at run time, so a disabled rail is genuinely inert, not cosmetically off.
+
+# Toggling gates and rails
+
+## When to use
+
+- "Disable the gate", "turn off TDD enforcement", "the tdd intent rail is blocking me".
+- "Toggle / enable a gate", "loosen enforcement for this repo".
+- "Approve a human gate" (record a durable approval event on an issue).
+
+## Toggle a gate or rail (the enforcement switch)
+
+```bash
+forge gate disable <gate-id>     # set workflow.gates.<id>.enabled = false in .forge/config.yaml
+forge gate enable  <gate-id>     # set it back to true
+```
+
+An unknown gate id — or disabling a **locked** gate — errors **before** anything is written, never mid-run. Because the hooks resolve config at run time, the flip takes effect immediately with no reinstall.
+
+### Common rails (default-ON, toggleable)
+
+| Rail | What it enforces | Turn off with |
+| --- | --- | --- |
+| `rail.tdd_intent` | Pre-commit TDD gate (source changed ⇒ tests changed). The `minimal` adoption profile ships it off. | `forge gate disable rail.tdd_intent` |
+| `rail.kernel_tracking` | "File every issue" — nothing discussed goes missing. | `forge gate disable rail.kernel_tracking` |
+| `rail.auto_shepherd` | The autonomous PR-shepherd daemon fire. | `forge gate disable rail.auto_shepherd` |
+
+The `gate.*` and `rail.*` id namespaces are disjoint, so `forge gate enable|disable` governs both through one flat surface.
+
+## Human-gate approval events
+
+```bash
+forge gate approve <issue-id> <gate-id>                     # record a durable gate.approved event
+forge gate reject  <issue-id> <gate-id>                     # record gate.rejected
+forge gate status  <issue-id>                               # list recorded events for that issue (resume-safe)
+forge gate check   <issue-id> <gate-id>                     # exit 0 iff gate DISABLED or an approval exists on that issue
+```
+
+`check` is the reusable enforcement primitive a stage skill calls: it passes when the gate is disabled or an approval event has been recorded for that specific issue id (approvals are issue-scoped, so pass the same `<issue-id>` you approved against). Events are durable on the issue, so they survive a compaction or crash.
+
+## Tri-state control (declared intent)
+
+```bash
+forge control <gate-id|rail-id> <mandatory|optional|permission>
+forge control status [--json]
+```
+
+`forge control` sets the **declared intent** vocabulary and writes the **same** `enabled` field that `forge gate` writes — there is deliberately no parallel key. It is a view/intent layer: today no runtime consumer denies purely on a control flag (MCP/rules/skills are presence-only and refused). For actually turning enforcement off, use `forge gate disable`.
+
+## The doc-update gate
+
+```bash
+forge gate doc <detect|check|init|...>     # = forge doc-gate (run `forge doc-gate --help`)
+```
+
+The doc-update gate folds under this noun as `forge gate doc`; bare `forge doc-gate` stays as a back-compat alias.
+
+## Adjacent skills
+
+- Addressing PR review feedback / resolving threads → `review`.
+- The snapshot of where the project stands and what's in flight → `status`.

package/skills/gates/evals/evals.json

@@ -0,0 +1,38 @@
+[
+  {
+    "query": "Disable the tdd gate for this repo.",
+    "should_trigger": true
+  },
+  {
+    "query": "Turn off TDD enforcement — the tdd intent rail is blocking my commit.",
+    "should_trigger": true
+  },
+  {
+    "query": "Toggle the kernel tracking rail off for now.",
+    "should_trigger": true
+  },
+  {
+    "query": "Enable a gate that I disabled earlier and loosen enforcement.",
+    "should_trigger": true
+  },
+  {
+    "query": "Approve the human gate on this issue so the stage can proceed.",
+    "should_trigger": true
+  },
+  {
+    "query": "Disable the auto shepherd rail so no PR daemon fires.",
+    "should_trigger": true
+  },
+  {
+    "query": "Address the CodeRabbit review feedback and resolve the threads.",
+    "should_trigger": false
+  },
+  {
+    "query": "Where am I in the workflow and what work is in flight right now?",
+    "should_trigger": false
+  },
+  {
+    "query": "Run the tests and lint before I push.",
+    "should_trigger": false
+  }
+]

package/skills/gates/evals/scorecard.json

@@ -0,0 +1,41 @@
+{
+  "skill": "gates",
+  "fixtures": "present",
+  "static": {
+    "token_cost": {
+      "desc_chars": 994,
+      "body_lines": 63,
+      "score": 45
+    },
+    "caps": {
+      "desc_within": true,
+      "body_within": true,
+      "score": 100
+    },
+    "description_quality": {
+      "has_trigger_cues": true,
+      "has_disambiguation_cues": true,
+      "adequate_length": true,
+      "score": 100
+    }
+  },
+  "router_reachability": {
+    "has_curated_rule": true,
+    "router_exempt": false,
+    "fixtures": "present",
+    "fixtures_total": 6,
+    "fixtures_best_hit": 6,
+    "reachable": true,
+    "keyword_alignment": 1
+  },
+  "behavioral": {
+    "trigger_recall": null,
+    "trigger_precision": null,
+    "disambiguation": null,
+    "chain_correctness": null,
+    "outcome_quality": null,
+    "variance": null,
+    "note": "behavioral — W5 (LLM judge): semantic recall/precision/chain/outcome/variance, not deterministic"
+  },
+  "composite": 84
+}

package/skills/hermes-forge/SKILL.md

@@ -26,6 +26,7 @@ metadata:
   author: forge
   version: "1.0.0"
   roadmap: forge-2agy.9.7.x
+chainExempt: true
 ---
 
 # Hermes ⇄ Forge consumption contract

package/skills/hermes-forge/evals/scorecard.json

@@ -0,0 +1,41 @@
+{
+  "skill": "hermes-forge",
+  "fixtures": "present",
+  "static": {
+    "token_cost": {
+      "desc_chars": 993,
+      "body_lines": 157,
+      "score": 36
+    },
+    "caps": {
+      "desc_within": true,
+      "body_within": true,
+      "score": 100
+    },
+    "description_quality": {
+      "has_trigger_cues": true,
+      "has_disambiguation_cues": true,
+      "adequate_length": true,
+      "score": 100
+    }
+  },
+  "router_reachability": {
+    "has_curated_rule": true,
+    "router_exempt": false,
+    "fixtures": "present",
+    "fixtures_total": 6,
+    "fixtures_best_hit": 2,
+    "reachable": true,
+    "keyword_alignment": 0.33
+  },
+  "behavioral": {
+    "trigger_recall": null,
+    "trigger_precision": null,
+    "disambiguation": null,
+    "chain_correctness": null,
+    "outcome_quality": null,
+    "variance": null,
+    "note": "behavioral — W5 (LLM judge): semantic recall/precision/chain/outcome/variance, not deterministic"
+  },
+  "composite": 81
+}

package/skills/issue-basics/SKILL.md

@@ -14,6 +14,7 @@ description: >
   the plan->dev->validate->ship pipeline or open a PR (use smith or stage skills); does NOT
   report the current stage or what's in flight (use status).
 allowed-tools: Read, Bash(forge:*)
+terminal: true
 ---
 
 # Issue basics — the CRUD floor

package/skills/issue-basics/evals/scorecard.json

@@ -0,0 +1,41 @@
+{
+  "skill": "issue-basics",
+  "fixtures": "present",
+  "static": {
+    "token_cost": {
+      "desc_chars": 991,
+      "body_lines": 95,
+      "score": 42
+    },
+    "caps": {
+      "desc_within": true,
+      "body_within": true,
+      "score": 100
+    },
+    "description_quality": {
+      "has_trigger_cues": false,
+      "has_disambiguation_cues": true,
+      "adequate_length": true,
+      "score": 60
+    }
+  },
+  "router_reachability": {
+    "has_curated_rule": true,
+    "router_exempt": false,
+    "fixtures": "present",
+    "fixtures_total": 6,
+    "fixtures_best_hit": 0,
+    "reachable": false,
+    "keyword_alignment": 0
+  },
+  "behavioral": {
+    "trigger_recall": null,
+    "trigger_precision": null,
+    "disambiguation": null,
+    "chain_correctness": null,
+    "outcome_quality": null,
+    "variance": null,
+    "note": "behavioral — W5 (LLM judge): semantic recall/precision/chain/outcome/variance, not deterministic"
+  },
+  "composite": 63
+}

package/skills/kernel/SKILL.md

@@ -14,6 +14,7 @@ description: >
   merged PR under gates → `smith`; token-bounded state for the Hermes harness →
   `hermes-forge`.
 allowed-tools: Read, Bash(forge:*)
+terminal: true
 ---
 
 # Forge kernel surface
@@ -56,6 +57,43 @@ mutating it — a claim returning ok:true does not by itself prove ownership).
 status → plan → dev → validate → ship → review → verify
 ```
 
+### Chain map (each skill declares its successor)
+
+Every skill carries chain metadata in its frontmatter (`next`, `terminal`,
+`subskills`, `handoffs`); each workflow STAGE skill additionally carries a
+HARD-GATE chain line in its body, so each stage announces the next one. The
+linear ladder:
+
+| Skill | `next` | `terminal` |
+|-------|--------|-----------|
+| `plan` | `dev` | `false` |
+| `dev` | `validate` | `false` |
+| `validate` | `ship` | `false` |
+| `ship` | `review` | `false` |
+| `review` | `verify` | `false` |
+| `verify` | `ship` | `false` |
+
+The `next` column is each stage's DEFAULT / critical-path successor (`plan`
+composes `research`; `ship` and `review` also carry a `shepherd` handoff). The
+actual successor after `ship`, `review`, and `verify` is classification-dependent
+— see the note below. `verify`'s `next` (`ship`) is the `docs`-only pre-ship
+reuse; in every other flow nothing follows `verify`.
+
+Feeders into the chain: `triage-ready` → `claim-safety` → `dev` (rank the pick,
+prove the live lease, then work it). `research` is standalone / callable
+mid-workflow and returns to its CALLER (no forced `next`); it is also a `subskill`
+of `plan`. The `smith` orchestrator composes the six stages (`subskills`).
+Utility/terminal skills (`status`, `shepherd`, `kernel`, `issue-basics`, `memory`,
+`rollback`, `research`, `sonarcloud`, `sonarcloud-analysis`,
+`parallel-deep-research`, `using-forge`) declare no forward-stage `next`. Meta
+skills (`hermes-forge`) are chain-exempt.
+
+The stage `next` values above are the DEFAULT / critical-path successors. The
+actual successor after `ship`, `review`, and `verify` is
+classification-dependent — the authoritative matrix is `lib/workflow/stages.js`
+(Simple/Hotfix/Refactor end at `ship`; Standard ends at `review`; Critical runs
+through `verify`; the `docs` classification reuses `verify` → `ship`).
+
 ## Orchestrator super-skill
 
 `smith` is the flagship: a thin orchestrator that COMPOSES the skills above into

package/skills/kernel/evals/scorecard.json

@@ -0,0 +1,41 @@
+{
+  "skill": "kernel",
+  "fixtures": "present",
+  "static": {
+    "token_cost": {
+      "desc_chars": 993,
+      "body_lines": 187,
+      "score": 33
+    },
+    "caps": {
+      "desc_within": true,
+      "body_within": true,
+      "score": 100
+    },
+    "description_quality": {
+      "has_trigger_cues": true,
+      "has_disambiguation_cues": true,
+      "adequate_length": true,
+      "score": 100
+    }
+  },
+  "router_reachability": {
+    "has_curated_rule": true,
+    "router_exempt": false,
+    "fixtures": "present",
+    "fixtures_total": 6,
+    "fixtures_best_hit": 0,
+    "reachable": false,
+    "keyword_alignment": 0
+  },
+  "behavioral": {
+    "trigger_recall": null,
+    "trigger_precision": null,
+    "disambiguation": null,
+    "chain_correctness": null,
+    "outcome_quality": null,
+    "variance": null,
+    "note": "behavioral — W5 (LLM judge): semantic recall/precision/chain/outcome/variance, not deterministic"
+  },
+  "composite": 80
+}

package/skills/memory/SKILL.md

@@ -13,6 +13,7 @@ description: >
   The local backend is always the offline floor. Not for: issue create/list/close ops
   (issue-basics), workflow status (status), or transient scratch notes.
 allowed-tools: Bash, Read, Grep, Glob
+terminal: true
 ---
 
 # Memory
@@ -20,6 +21,16 @@ allowed-tools: Bash, Read, Grep, Glob
 Durable project memory for agents. This skill teaches you where a fact belongs,
 which backend is active, and how to use graph memory when it is enabled.
 
+## Applies to: Forge-managed memory
+
+This skill describes memory managed by **Forge's own store** — `forge remember` /
+`forge recall`, whose backend the Backends section (below) explains. If the repo you are working in ships
+its **own** memory system (a database, an API, a "log a decision" surface, an
+in-app memory service), **that** system is authoritative here and this skill does
+not apply — follow the repo's own memory instructions instead. When unsure, prefer
+the host repo's memory over `forge remember`; a note written to the wrong store is
+a note nobody finds.
+
 ## The one rule
 
 Persistent, project-level knowledge goes to **`forge remember`** — never to a
@@ -33,7 +44,11 @@ is a local file store, so they always work offline with zero setup.
   convention, a decision and its rationale, a non-obvious gotcha, an environment
   quirk, a "we tried X, it failed because Y". Add `--tag <label>` for retrieval.
 - **`forge recall "<query>"`** — before assuming, check what is already known.
-  Search first; do not re-derive knowledge the project already recorded.
+  Search first; do not re-derive knowledge the project already recorded. Note that
+  memory relevant to your current prompt **may already be injected automatically**
+  (a per-turn hook surfaces the best-matching notes; silent when nothing clears the
+  relevance bar). Treat auto-surfaced memory as a head start, and still `recall`
+  explicitly when you need to search for something specific it did not surface.
 - **`forge issue comment <id> "<note>"`** — progress or context that belongs to
   ONE issue's lifecycle (status, a blocker, a hand-off). Issue-scoped, not global.
 - **Rule of thumb:** would a future session on a *different* issue want this? →

package/skills/memory/evals/scorecard.json

@@ -0,0 +1,41 @@
+{
+  "skill": "memory",
+  "fixtures": "no-fixtures",
+  "static": {
+    "token_cost": {
+      "desc_chars": 938,
+      "body_lines": 101,
+      "score": 44
+    },
+    "caps": {
+      "desc_within": true,
+      "body_within": true,
+      "score": 100
+    },
+    "description_quality": {
+      "has_trigger_cues": true,
+      "has_disambiguation_cues": true,
+      "adequate_length": true,
+      "score": 100
+    }
+  },
+  "router_reachability": {
+    "has_curated_rule": true,
+    "router_exempt": false,
+    "fixtures": "no-fixtures",
+    "fixtures_total": 0,
+    "fixtures_best_hit": 0,
+    "reachable": null,
+    "keyword_alignment": null
+  },
+  "behavioral": {
+    "trigger_recall": null,
+    "trigger_precision": null,
+    "disambiguation": null,
+    "chain_correctness": null,
+    "outcome_quality": null,
+    "variance": null,
+    "note": "behavioral — W5 (LLM judge): semantic recall/precision/chain/outcome/variance, not deterministic"
+  },
+  "composite": 83
+}

package/skills/parallel-deep-research/SKILL.md

@@ -17,6 +17,7 @@ compatibility: Requires PARALLEL_API_KEY in .env.local. Uses curl. Takes 3-25 mi
 metadata:
   author: harshanandak
   version: "1.0.0"
+terminal: true
 ---
 
 # Parallel Deep Research

package/skills/parallel-deep-research/evals/scorecard.json

@@ -0,0 +1,41 @@
+{
+  "skill": "parallel-deep-research",
+  "fixtures": "present",
+  "static": {
+    "token_cost": {
+      "desc_chars": 996,
+      "body_lines": 92,
+      "score": 42
+    },
+    "caps": {
+      "desc_within": true,
+      "body_within": true,
+      "score": 100
+    },
+    "description_quality": {
+      "has_trigger_cues": true,
+      "has_disambiguation_cues": true,
+      "adequate_length": true,
+      "score": 100
+    }
+  },
+  "router_reachability": {
+    "has_curated_rule": true,
+    "router_exempt": false,
+    "fixtures": "present",
+    "fixtures_total": 5,
+    "fixtures_best_hit": 1,
+    "reachable": true,
+    "keyword_alignment": 0.2
+  },
+  "behavioral": {
+    "trigger_recall": null,
+    "trigger_precision": null,
+    "disambiguation": null,
+    "chain_correctness": null,
+    "outcome_quality": null,
+    "variance": null,
+    "note": "behavioral — W5 (LLM judge): semantic recall/precision/chain/outcome/variance, not deterministic"
+  },
+  "composite": 83
+}

package/skills/plan/SKILL.md

@@ -13,12 +13,18 @@ description: >
   where work stands or what is stale (status), and NOT for everyday issue create/list/close or
   picking the next ready issue (issue-basics / triage-ready).
 allowed-tools: Bash, Read, Write, Edit, Grep, Glob
+next: dev
+terminal: false
+subskills:
+  - research
 ---
 
 Plan a feature from scratch: brainstorm design intent, research technical approach, then set up branch, worktree, and a complete task list ready for /dev.
 
 # Plan
 
+> **Chain (HARD-GATE):** the next skill after `plan` is `dev`. `plan` composes the `research` sub-skill for its Phase 2 technical bundle. Do not skip ahead past `dev`.
+
 `/plan` is the default planning super-skill. A full invocation runs the three legacy sections below (intent, research, setup/task list), but v3 treats the internal planning work as callable sub-skills:
 
 - `plan.intent_capture`

package/skills/plan/evals/scorecard.json

@@ -0,0 +1,41 @@
+{
+  "skill": "plan",
+  "fixtures": "present",
+  "static": {
+    "token_cost": {
+      "desc_chars": 958,
+      "body_lines": 530,
+      "score": 3
+    },
+    "caps": {
+      "desc_within": true,
+      "body_within": true,
+      "score": 100
+    },
+    "description_quality": {
+      "has_trigger_cues": false,
+      "has_disambiguation_cues": true,
+      "adequate_length": true,
+      "score": 60
+    }
+  },
+  "router_reachability": {
+    "has_curated_rule": true,
+    "router_exempt": false,
+    "fixtures": "present",
+    "fixtures_total": 5,
+    "fixtures_best_hit": 4,
+    "reachable": true,
+    "keyword_alignment": 0.8
+  },
+  "behavioral": {
+    "trigger_recall": null,
+    "trigger_precision": null,
+    "disambiguation": null,
+    "chain_correctness": null,
+    "outcome_quality": null,
+    "variance": null,
+    "note": "behavioral — W5 (LLM judge): semantic recall/precision/chain/outcome/variance, not deterministic"
+  },
+  "composite": 51
+}

package/skills/portability/SKILL.md

@@ -0,0 +1,47 @@
+---
+name: portability
+description: >
+  Forge kernel data portability — getting issue data in and out of the local kernel. `forge
+  export [--dir] [--dry-run]` writes the kernel backlog to deterministic git-tracked JSONL
+  (D16 portability projection); `forge export --import` reads that committed snapshot back
+  into the kernel (hydrate). `forge migrate --from beads [--dry-run] [--source <dir>]` imports
+  a Beads issue store into the kernel — the onboarding path for users coming from Beads. Use
+  when the user says "export the kernel backlog to JSONL", "back up / snapshot the backlog",
+  "re-import / hydrate the backlog", "migrate from beads", or "import a beads store". Honesty:
+  bare `forge migrate --dry-run` (no `--from`) is v2→v3 preview only; a re-import that applies
+  nothing reports "already hydrated". NOT the cloud/backend sync of the kernel (that is `forge
+  sync`, cloud-native), NOT a database/schema migration (plan/dev), NOT memory notes (memory),
+  NOT syncing a git branch with main (ship).
+allowed-tools: Bash, Read, Grep, Glob
+terminal: true
+---
+
+Moving Forge kernel issue data across a boundary: project the backlog to a git-committable snapshot (and hydrate it back), or import an existing issue store into the kernel. This is data portability — distinct from schema/database migrations and from the cloud backend sync (`forge sync`).
+
+# Export / re-import the backlog
+
+```bash
+forge export                     # write the kernel backlog to git-tracked JSONL (deterministic)
+forge export --dir <path>        # choose the projection directory
+forge export --dry-run           # show what would be written, change nothing
+forge export --import            # read the committed JSONL snapshot back INTO the kernel (hydrate)
+```
+
+`forge export` is the **D16 portability projection**: a deterministic, git-committable snapshot of the backlog you can review in a diff and carry between machines or checkouts. `forge export --import` is the reverse — it hydrates the kernel from that on-disk snapshot; a re-import that finds everything already present reports "already hydrated" rather than claiming it imported anything.
+
+# Migrate in from Beads (or preview v2→v3)
+
+```bash
+forge migrate --from beads [--dry-run]     # import a Beads issue store into the kernel
+forge migrate --from beads --source <dir>  # point at exported beads *.jsonl (defaults to auto-detecting .beads/)
+forge migrate --dry-run                    # preview the v2→v3 migration (the ONLY supported mode without --from)
+```
+
+`forge migrate --from beads` is the **onboarding path for users coming from Beads** — it imports a Beads issue store into the Forge Kernel (`--dry-run` reads + maps only, writing nothing). Without `--from`, migrate is **v2→v3 preview only**: `--dry-run` is required and applying the migration is not yet available.
+
+## Boundaries
+
+- The **cloud/backend sync** of the kernel is `forge sync` (cloud-native) — a different operation; this skill is the local, git-based portability projection.
+- A **database/schema** migration (adding a column, altering a table) is application work — that's **plan**/**dev**, not `forge migrate`.
+- Persisting a decision or note is **memory** (`forge remember`), not export.
+- Syncing a git **branch** with main before a PR is **ship**/**worktree**.