forge-orkes 0.67.0 → 0.70.0

package/bin/create-forge.js

@@ -52,31 +52,22 @@ const FORGE_END = '<!-- forge:end -->';
 
 // --- File classification for upgrades ---
 
-// Framework-owned: Forge controls these entirely
+// Framework-owned: Forge controls these entirely. Auto-clean removes files that
+// dropped out of the template — but ownership is decided per top-level UNIT
+// (a skill DIR under .claude/skills/, an agent FILE under .claude/agents/), and
+// only the template defines which units Forge shipped. A unit the base template
+// never shipped — user-authored, vendored-parity, or an opt-in experimental
+// skill installed separately (e.g. m10's orchestrating, the convention packs) —
+// is NOT framework content and is preserved, never swept, even though it lives
+// under a framework-owned dir. Deleting it would destroy work Forge never owned,
+// and .claude/ is frequently gitignored, so the loss is unrecoverable. Files
+// removed from WITHIN a still-shipped unit (e.g. a renamed helper inside a
+// template skill dir) stay cleanable — their unit is still present in the
+// template. See upgradeDir(). Experimental skills are additionally diffed
+// against their shipped sources by detectExperimentalStaleness() (report-only;
+// re-sync consent lives in the /upgrading skill layer).
 const FRAMEWORK_OWNED_DIRS = ['.claude/agents', '.claude/skills'];
 
-// Experimental / opt-in skills installed separately (e.g. from experimental/m10).
-// They are NOT in the shipped base template, so the framework-owned auto-clean
-// would otherwise delete them on upgrade. Preserve them instead.
-//
-// The npm tarball ships experimental/ alongside bin/ + template/, so this route
-// CAN diff an installed experimental skill against its same-tarball source:
-// detectExperimentalStaleness() reports unchanged|stale with the differing files.
-// (Blind preservation is what silently froze these pre-0.33.0 — issue #5: a base
-// migration that changed experimental-skill behavior became a no-op.) Detection
-// only — consent for a re-sync lives in the /upgrading skill layer, and
-// load-bearing conventions are still promoted to base (FORGE.md) rather than
-// left to a frozen skill. This preserve-list gates auto-clean only; staleness
-// discovery is by directory scan of the shipped experimental/ tree.
-const EXPERIMENTAL_SKILL_PATHS = ['.claude/skills/orchestrating'];
-
-function isExperimentalSkillPath(displayPath) {
-  const norm = displayPath.split(path.sep).join('/');
-  return EXPERIMENTAL_SKILL_PATHS.some(
-    (p) => norm === p || norm.startsWith(p + '/')
-  );
-}
-
 // Compare dotted numeric versions (e.g. "0.19.1"). Returns 1 if a>b, -1 if a<b, 0 if equal.
 function compareVersions(a, b) {
   const pa = String(a).split('.').map((n) => parseInt(n, 10) || 0);
@@ -259,9 +250,15 @@ function upgradeDir(relDir, { autoClean = false } = {}) {
     const srcPath = path.join(srcDir, rel);
     if (!fs.existsSync(srcPath)) {
       const displayPath = path.join(relDir, rel);
-      // Never auto-clean opt-in experimental skills — they live outside the base template.
-      if (autoClean && isExperimentalSkillPath(displayPath)) {
-        result.preserved.push(displayPath);
+      // Ownership is per top-level unit: the first path segment of `rel` is the
+      // skill dir (or, for flat agents, the file itself). If the template no
+      // longer ships that unit at all, the file is user-authored, vendored, or an
+      // opt-in experimental skill — not Forge's to delete. Preserve it. Only
+      // files whose unit the template STILL ships (a stale file inside a shipped
+      // skill dir) remain removal candidates.
+      const topUnit = rel.split(path.sep)[0];
+      if (autoClean && !fs.existsSync(path.join(srcDir, topUnit))) {
+        result.preserved.push(`${displayPath} (kept — not shipped by the base template)`);
         continue;
       }
       const destPath = path.join(destDir, rel);
@@ -374,6 +371,30 @@ function mergeManagedDeny(destSettings, srcSettings) {
   }
 }
 
+/**
+ * Union the template's managed allow rules into the project's permissions.allow.
+ * Additive — a user's own allow/deny entries are untouched (mirrors
+ * mergeManagedDeny). Forge automates a worktree-heavy workflow (streams, the
+ * slice runner, orchestration/human-verified teardown), but the harness auto-mode
+ * classifier soft-denies `git worktree remove` for a worktree the session didn't
+ * create in-session, and a Remote-Control / detached session cannot enter
+ * bypassPermissions after launch. A NARROW allow rule survives auto mode and runs
+ * before the classifier, so the automating session can clean up its own worktrees.
+ * These are read/teardown of Forge-managed worktrees only — `remove` is git-guarded
+ * (refuses on a dirty/untracked tree without --force) and, in the Forge flow, only
+ * ever runs on a merged, human-verified worktree. It never touches commits or
+ * branches — worktree removal drops a checkout, not history.
+ */
+function mergeManagedAllow(destSettings, srcSettings) {
+  const srcAllow = (srcSettings.permissions && srcSettings.permissions.allow) || [];
+  if (!srcAllow.length) return;
+  destSettings.permissions = destSettings.permissions || {};
+  const destAllow = destSettings.permissions.allow || (destSettings.permissions.allow = []);
+  for (const rule of srcAllow) {
+    if (!destAllow.includes(rule)) destAllow.push(rule);
+  }
+}
+
 /**
  * Strip the legacy *inline* active-skill guard from PreToolUse (forge#12). It was
  * an inline `if [ ! -f .../.forge/.active-skill ]; then ... exit 2; fi` one-liner;
@@ -437,6 +458,7 @@ function upgradeSettings() {
   // Additively install framework-managed safety guardrails (ADR-017)
   mergeManagedHooks(destSettings, srcSettings);
   mergeManagedDeny(destSettings, srcSettings);
+  mergeManagedAllow(destSettings, srcSettings);
 
   const after = JSON.stringify(destSettings);
   if (before === after) return 'unchanged';
@@ -949,7 +971,7 @@ async function upgrade() {
     if (results.preserved.length > 0) {
       say(`  Preserved (${results.preserved.length}):`);
       for (const f of results.preserved) {
-        say(`    ${f} (kept — opt-in experimental skill)`);
+        say(`    ${f}`);
       }
       for (const e of experimental) {
         say(

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "forge-orkes",
-  "version": "0.67.0",
+  "version": "0.70.0",
   "description": "Set up the Forge meta-prompting framework for Claude Code in your project",
   "bin": {
     "create-forge": "./bin/create-forge.js"

package/template/.claude/hooks/forge-slice-runner.sh

@@ -571,7 +571,15 @@ for phase in $PHASES; do
 
     # (4) REQUIRE the on-disk phase-report.yml. Absent = crash → halt now (do NOT
     #     spend the retry on a crash; the resume path re-runs it from files).
+    #     This is a slice END, so it MUST ping like the other two ends (checks-failed
+    #     halt below, done) — a silent phone is never success. Live gap: canvaz
+    #     2026-07-23, m-EVT01 hit error_max_turns and the slice died dark. Key is
+    #     per-phase ("$phase-crash"), NOT the shared "slice" key: a crash marker on
+    #     the shared key would suppress a LATER legitimate checks-failed halt after
+    #     resume; a re-crash of the same phase stays deduped (append-once semantics).
     if [ ! -f "$report" ]; then
+      slice_notify halt "$phase-crash" \
+        "slice HALTED at phase $phase ($idx/$total) — launcher crash, no phase-report.yml written (attempt $attempt); see $wdir/result.json + $wdir/launch.err"
       printf '[runner] phase %s: no phase-report.yml written at %s — halting\n' "$phase" "$report" >&2
       printf 'SLICE_RESULT phases=%s touches=%s last_ping=%s\n' "$COMPLETED" "$TOUCHES" "$LAST_PING"
       exit 1

package/template/.claude/settings.json

@@ -1,6 +1,6 @@
 {
   "forge": {
-    "version": "0.58.3",
+    "version": "0.68.0",
     "default_tier": "standard",
     "beads_integration": false,
     "context_gates": {
@@ -48,6 +48,11 @@
       "Edit(**/.secrets/**)",
       "Edit(**/*.pem)",
       "Edit(**/*.key)"
+    ],
+    "allow": [
+      "Bash(git worktree remove *)",
+      "Bash(git worktree prune)",
+      "Bash(git worktree prune *)"
     ]
   },
   "hooks": {

package/template/.claude/skills/planning/SKILL.md

@@ -139,6 +139,8 @@ If a sibling milestone (e.g. m50) has state + requirements but is missing from `
 
 **Promoted-from-backlog milestone (`milestone.origin` set).** If `state/milestone-{N}.yml` carries `milestone.origin: {R-id}` (set by `forge` Step 1.2 when promoting a Standard-tier refactor item), no extra bookkeeping is needed here — the originating backlog item is flipped to `done` automatically when the milestone completes (see `reviewing` → **Promoted Milestone Completion Hook**). Just plan it as a normal milestone.
 
+**Roadmap integrity check (advisory, m-39).** After writing or updating `roadmap.yml` in any of the three cases above, run `.forge/checks/forge-roadmap-check.sh`. If it exits non-zero, surface every `finding=...` line to the operator as one advisory note (e.g. *"roadmap-check found {N} issue(s): {lines}"*). This NEVER blocks — Step 9 Present and the handoff proceed regardless of findings; it is a signal, not a gate (same advisory posture as `verification.commands` in FORGE.md → Verification Gates). Script absent (pre-m-39 install) → skip silently.
+
 ## Step 6: Decompose Tasks
 
 ### Step 6.1: Cross-Layer Contract Detection

package/template/.claude/skills/upgrading/SKILL.md

@@ -139,7 +139,7 @@ Source version (`{source}/packages/create-forge/package.json`) **<** installed (
 
 Dev mode syncs from a checkout, so it keeps file-classification semantics — **the npm bin's sync behavior is the spec**; do not re-derive it here. Categories:
 
-- **Framework-owned** (`.claude/agents/*.md`, `.claude/skills/*/SKILL.md`, `.forge/FORGE.md`) → overwrite when different; a local skill dir absent from the template defers to the experimental pass below (only no-source dirs report *removed from template* — never deleted).
+- **Framework-owned** (`.claude/agents/*.md`, `.claude/skills/*/SKILL.md`, `.forge/FORGE.md`) → overwrite when different. Ownership is per top-level **unit** — a skill DIR under `.claude/skills/`, a flat agent FILE under `.claude/agents/`: a unit the template doesn't ship (user-authored, vendored-parity, or an opt-in experimental skill) is **preserved, never deleted**; only stale files *inside* a still-shipped skill dir are cleaned. Experimental skills additionally get the staleness pass below.
 - **Template-only** (`.forge/templates/**`, `.forge/migrations/**`, `.forge/adapters/**`, `.forge/gitignore` → `.forge/.gitignore`) → overwrite; `.forge/FORGE.md` lands BEFORE the CLAUDE.md pass.
 - **Additive** (`.claude/hooks/**` incl. `tests/`, `.claude/rules/**`, `.forge/checks/**`) → add + overwrite template-shipped files, never delete local extras, `chmod +x` synced `*.sh`.
 - **Import-managed** `CLAUDE.md` → the bin's `ensureClaudeMdImport()` cases verbatim; user content outside a forge section is never modified.

package/template/.forge/checks/forge-jarvis-dispatch.sh

@@ -91,17 +91,25 @@ materialize_work_order() {
   # Prefer the worktree's OWN milestone — .forge/phases/ carries the repo's whole milestone
   # history (32 dirs on the forge repo), so "the only milestone dir" is a fixture-world
   # assumption. The Worktree Convention names the branch forge/{anchor} with anchor =
-  # {milestone-id}[-{session}]; derive the id and pick that milestone's dir.
+  # {milestone-id}[-{session}]; derive the id and pick that milestone's dir. The id's own
+  # m- may be a strippable prefix (m-40 → milestone-40) or PART of a labeled id kept
+  # verbatim (m-EVT01 → milestone-m-EVT01) — canvaz first run 2026-07-22: stripping it
+  # unconditionally missed milestone-m-EVT01 and fell through to a 38-dir refusal. Try the
+  # anchor verbatim before the m--stripped form, then both again minus one trailing
+  # -{session} token; first existing dir wins (exact/longer forms first).
   _mdir=""
   _branch="$(git -C "$WORKTREE" branch --show-current 2>/dev/null)"
   case "$_branch" in
-    forge/m-*)
-      _anchor="${_branch#forge/m-}"                                   # 40 | 40-a1b2c3d4 | R61-002
-      [ -d "$WORKTREE/.forge/phases/milestone-$_anchor" ] && _mdir="$WORKTREE/.forge/phases/milestone-$_anchor"
-      if [ -z "$_mdir" ]; then
-        _short="${_anchor%-*}"                                        # strip one trailing -token (session suffix)
-        [ "$_short" != "$_anchor" ] && [ -d "$WORKTREE/.forge/phases/milestone-$_short" ] && _mdir="$WORKTREE/.forge/phases/milestone-$_short"
-      fi ;;
+    forge/*)
+      _anchor="${_branch#forge/}"                    # m-40 | m-40-a1b2c3d4 | m-EVT01-e6063597
+      _short="${_anchor%-*}"                         # minus one trailing -token (session suffix)
+      for _cand in "$_anchor" "${_anchor#m-}" "$_short" "${_short#m-}"; do
+        [ -n "$_cand" ] || continue
+        if [ -d "$WORKTREE/.forge/phases/milestone-$_cand" ]; then
+          _mdir="$WORKTREE/.forge/phases/milestone-$_cand"
+          break
+        fi
+      done ;;
   esac
   # Fallback (non-git fixture dirs / unconventional branches): a SINGLE milestone dir is
   # unambiguous; several without a branch-derived pick is a refusal, never a guess.

package/template/.forge/checks/forge-roadmap-check.sh

@@ -0,0 +1,246 @@
+#!/usr/bin/env sh
+# forge-roadmap-check.sh — structural integrity check for .forge/roadmap.yml (m-39).
+#
+# Validates the roadmap against the drift class that caused the m-34/m-36 phase-id
+# collision: two independent renumbering passes both picked phase id 63. A flat
+# grep over "id: N" cannot tell a milestone's id from a phase's id from an
+# unrelated numeral (estimated_hours: 63), and cannot catch a field that drifted
+# to the wrong indentation depth. This check instead walks the file as a small
+# indentation-keyed state machine over roadmap.yml's three fixed second-level
+# blocks (milestones:/phases:/waves:) — HONEST LIMIT: it understands exactly this
+# one fixed shape, not arbitrary YAML.
+#
+#   forge-roadmap-check.sh [<roadmap-file>]      # default: <git-root>/.forge/roadmap.yml
+#
+#   stdout (machine-parseable, fold style):
+#     ok=clean                                   # no findings
+#     finding=<rule>:<detail>                     # one line per problem
+#     rule ∈ missing-field | duplicate-phase-id | dangling-phase-ref | orphan-phase
+#          | bad-milestone-dir | dangling-wave-ref
+#   exit: 0 = ok=clean; 1 = one or more findings; 2 = bad invocation (missing/unreadable file)
+#
+# Required fields (confirmed against the live file — zero false positives today):
+#   milestone entry: id, name, phases (non-empty)
+#   phase entry:     id, name, goal, requirements, dependencies, success_criteria,
+#                    estimated_hours, status
+#   milestone_dir is DELIBERATELY not required — 17/65 live phase entries predate
+#   the nested-layout convention. Validated only when present (bad-milestone-dir).
+#
+# Pure POSIX sh + awk. No git-repo dependency (reads the file directly, unlike the
+# diff-scoped forge-hold-check.sh/forge-check-lint.sh). Collects every finding in
+# one pass before deciding exit code — a single run surfaces everything wrong.
+set -u
+
+FILE="${1:-}"
+if [ -z "$FILE" ]; then
+  ROOT="$(git rev-parse --show-toplevel 2>/dev/null || pwd)"
+  FILE="$ROOT/.forge/roadmap.yml"
+fi
+
+if [ ! -f "$FILE" ] || [ ! -r "$FILE" ]; then
+  echo "roadmap-check: $FILE: not found or unreadable" >&2
+  exit 2
+fi
+
+awk '
+function trim(s) {
+  gsub(/^[ \t]+|[ \t]+$/, "", s)
+  return s
+}
+function unquote(s) {
+  gsub(/"/, "", s)
+  return s
+}
+function bare_num(s,   n) {
+  n = unquote(trim(s))
+  if (n ~ /^m-/) n = substr(n, 3)
+  return n
+}
+function finish_entry() {
+  if (!entry_open) return
+  if (entry_type == "milestone") {
+    ms_count++
+    ms_id[ms_count] = cur_id
+    ms_fields[ms_count] = cur_fields
+    ms_phaselist[ms_count] = cur_phaselist
+  } else if (entry_type == "phase") {
+    ph_count++
+    ph_id[ph_count] = cur_id + 0
+    ph_fields[ph_count] = cur_fields
+    ph_mdir[ph_count] = cur_mdir
+  }
+  entry_open = 0
+  cur_id = ""; cur_fields = ""; cur_mdir = ""; cur_phaselist = ""
+}
+
+# 2-space block header
+$0 ~ /^  (milestones|phases|waves):[ \t]*$/ {
+  finish_entry()
+  block = trim($0)
+  gsub(/:$/, "", block)
+  next
+}
+
+# waves block: "    N: [a, b, c]"
+block == "waves" && $0 ~ /^    [0-9]+:/ {
+  line = $0
+  sub(/^    /, "", line)
+  split(line, kv, ":")
+  wnum = trim(kv[1])
+  rest = line
+  sub(/^[^:]*:/, "", rest)
+  if (match(rest, /\[[^]]*\]/)) {
+    ids = substr(rest, RSTART + 1, RLENGTH - 2)
+  } else {
+    ids = ""
+  }
+  wave_count++
+  wave_num[wave_count] = wnum
+  wave_ids[wave_count] = ids
+  next
+}
+
+# entry open: "    - id: 36" / "    - id: \"m-33\""
+(block == "milestones" || block == "phases") && $0 ~ /^    - id:/ {
+  finish_entry()
+  entry_open = 1
+  entry_type = (block == "milestones" ? "milestone" : "phase")
+  val = $0
+  sub(/^    - id:[ \t]*/, "", val)
+  cur_id = unquote(trim(val))
+  cur_fields = " id "
+  next
+}
+
+# 6-space field line inside an open entry
+(block == "milestones" || block == "phases") && entry_open && $0 ~ /^      [A-Za-z_]+:/ {
+  line = $0
+  sub(/^      /, "", line)
+  match(line, /^[A-Za-z_]+/)
+  field = substr(line, RSTART, RLENGTH)
+  cur_fields = cur_fields field " "
+  if (field == "milestone_dir") {
+    val = line
+    sub(/^milestone_dir:[ \t]*/, "", val)
+    cur_mdir = unquote(trim(val))
+  }
+  if (field == "phases" && entry_type == "milestone") {
+    rest = line
+    if (match(rest, /\[[^]]*\]/)) {
+      cur_phaselist = substr(rest, RSTART + 1, RLENGTH - 2)
+    }
+  }
+  next
+}
+
+# any other 4-space line inside milestones:/phases: (not "- id:") -> malformed
+# dedent: closes the current entry without opening a new one.
+(block == "milestones" || block == "phases") && $0 ~ /^    [A-Za-z_-]/ {
+  finish_entry()
+  next
+}
+
+END {
+  finish_entry()
+
+  required_ms = "name phases"
+  required_ph = "name goal requirements dependencies success_criteria estimated_hours status"
+
+  # 1. required fields
+  for (i = 1; i <= ms_count; i++) {
+    n = split(required_ms, reqs, " ")
+    for (j = 1; j <= n; j++) {
+      if (index(ms_fields[i], " " reqs[j] " ") == 0) {
+        print "finding=missing-field:milestone:" ms_id[i] ":" reqs[j]
+        found++
+      }
+    }
+  }
+  for (i = 1; i <= ph_count; i++) {
+    n = split(required_ph, reqs, " ")
+    for (j = 1; j <= n; j++) {
+      if (index(ph_fields[i], " " reqs[j] " ") == 0) {
+        print "finding=missing-field:phase:" ph_id[i] ":" reqs[j]
+        found++
+      }
+    }
+  }
+
+  # phase-id set + first-seen order tracking for duplicate detection
+  for (i = 1; i <= ph_count; i++) {
+    id = ph_id[i]
+    phase_seen[id] = phase_seen[id] "" (phase_seen[id] == "" ? "" : ",")
+    dup_list[id] = (dup_list[id] == "" ? "" : dup_list[id] ",") (ph_mdir[i] == "" ? "(none)" : ph_mdir[i])
+    dup_count[id]++
+    phase_exists[id] = 1
+  }
+
+  # 2. duplicate phase ids
+  for (id in dup_count) {
+    if (dup_count[id] > 1) {
+      print "finding=duplicate-phase-id:" id ":" dup_list[id]
+      found++
+    }
+  }
+
+  # 3. dangling-phase-ref (milestone claims a phase id with no phase entry)
+  for (i = 1; i <= ms_count; i++) {
+    m = split(ms_phaselist[i], claimed, /[ ,]+/)
+    for (j = 1; j <= m; j++) {
+      pid = trim(claimed[j])
+      if (pid == "") continue
+      claimed_by[pid] = 1
+      if (!(pid in phase_exists)) {
+        print "finding=dangling-phase-ref:milestone:" ms_id[i] ":phase:" pid
+        found++
+      }
+    }
+  }
+
+  # orphan-phase (phase entry claimed by zero milestones)
+  for (i = 1; i <= ph_count; i++) {
+    id = ph_id[i]
+    if (!(id in claimed_by)) {
+      print "finding=orphan-phase:" id ":" (ph_mdir[i] == "" ? "(none)" : ph_mdir[i])
+      found++
+    }
+  }
+
+  # 4. bad-milestone-dir (milestone_dir prefix must resolve to a real milestone id)
+  for (i = 1; i <= ms_count; i++) {
+    ms_numeral[bare_num(ms_id[i])] = 1
+  }
+  for (i = 1; i <= ph_count; i++) {
+    if (ph_mdir[i] == "") continue
+    if (match(ph_mdir[i], /^milestone-[^\/]+/)) {
+      prefix = substr(ph_mdir[i], RSTART, RLENGTH)
+      numeral = prefix
+      sub(/^milestone-/, "", numeral)
+      if (!(numeral in ms_numeral)) {
+        print "finding=bad-milestone-dir:" ph_id[i] ":" ph_mdir[i]
+        found++
+      }
+    }
+  }
+
+  # 5. dangling-wave-ref
+  for (i = 1; i <= wave_count; i++) {
+    m = split(wave_ids[i], wids, /[ ,]+/)
+    for (j = 1; j <= m; j++) {
+      pid = trim(wids[j])
+      if (pid == "") continue
+      if (!(pid in phase_exists)) {
+        print "finding=dangling-wave-ref:" wave_num[i] ":" pid
+        found++
+      }
+    }
+  }
+
+  if (found + 0 == 0) {
+    print "ok=clean"
+    exit 0
+  }
+  exit 1
+}
+' "$FILE"
+exit $?

package/template/.forge/checks/tests/forge-jarvis-dispatch.test.sh

@@ -157,6 +157,41 @@ else
   bad "dry-run side effects" "dry-run wrote work-order files"
 fi
 
+# --- 13-14. BRANCH-DERIVED MILESTONE PICK (canvaz first run 2026-07-22): with several
+#     milestone dirs, the forge/{anchor} branch names the one to build. The id's m- may be
+#     strippable (m-40 → milestone-40) or part of a labeled id (m-EVT01 → milestone-m-EVT01);
+#     unconditional stripping refused a clean labeled-id dispatch. These fixtures are real
+#     git repos — cases 9-12 (mktemp dirs) never reach the branch path.
+mkbranch() { git -C "$1" init -q -b "$2" 2>/dev/null || { git -C "$1" init -q && git -C "$1" checkout -q -b "$2"; }; }
+
+# 13. labeled id: forge/m-EVT01-<session> resolves milestone-m-EVT01 (m- is part of the id)
+LSLICE="$ROOT/labeled-wt"
+mkdir -p "$LSLICE/.forge/phases/milestone-m-EVT01/1-evt" "$LSLICE/.forge/phases/milestone-5/1-decoy"
+printf 'evt plan\n' > "$LSLICE/.forge/phases/milestone-m-EVT01/1-evt/plan-01.md"
+printf 'decoy\n'    > "$LSLICE/.forge/phases/milestone-5/1-decoy/plan-01.md"
+mkbranch "$LSLICE" forge/m-EVT01-e6063597
+err13="$(sh "$DISPATCH" --slice "$LSLICE" --materialize-only 2>&1)"; rc=$?
+if [ "$rc" = 0 ] && grep -q '^  - 1-evt$' "$LSLICE/slice.yml" 2>/dev/null \
+   && grep -q 'evt plan' "$LSLICE/phases/1-evt/plan.md" 2>/dev/null && [ ! -d "$LSLICE/phases/1-decoy" ]; then
+  ok "labeled milestone id: branch picks milestone-m-EVT01 among several dirs (m- kept)"
+else
+  bad "labeled-id branch pick" "rc=$rc err=$err13"
+fi
+
+# 14. numeric id + session suffix: forge/m-40-<session> still resolves milestone-40 (m- stripped)
+QSLICE="$ROOT/numeric-wt"
+mkdir -p "$QSLICE/.forge/phases/milestone-40/1-num" "$QSLICE/.forge/phases/milestone-39/1-decoy"
+printf 'num plan\n' > "$QSLICE/.forge/phases/milestone-40/1-num/plan-01.md"
+printf 'decoy\n'    > "$QSLICE/.forge/phases/milestone-39/1-decoy/plan-01.md"
+mkbranch "$QSLICE" forge/m-40-a1b2c3d4
+err14="$(sh "$DISPATCH" --slice "$QSLICE" --materialize-only 2>&1)"; rc=$?
+if [ "$rc" = 0 ] && grep -q '^  - 1-num$' "$QSLICE/slice.yml" 2>/dev/null \
+   && grep -q 'num plan' "$QSLICE/phases/1-num/plan.md" 2>/dev/null && [ ! -d "$QSLICE/phases/1-decoy" ]; then
+  ok "numeric milestone id: branch picks milestone-40 among several dirs (m- stripped)"
+else
+  bad "numeric-id branch pick" "rc=$rc err=$err14"
+fi
+
 # --- summary -----------------------------------------------------------------
 printf '\n%s: %d passed, %d failed\n' "$(basename "$0")" "$PASSED" "$FAILED"
 [ "$FAILED" = 0 ]