@ikon85/agent-workflow-kit 0.38.0 → 0.40.0

package/.claude/hooks/drift-guard.py

@@ -13,8 +13,8 @@ NOT a board-wide scan, NOT a "grill-exit" event (no clean tool hook for that).
 Accepted gap: Bash redirect / tee / cp into `.handoff/` is not covered — the
 threat model is "skill/agent forgot", not an adversary; handoff writes via Write.
 
-Mechanism: self-filters to `.handoff/*.md`; extracts the issue (content anchor
-first, filename fallback); delegates graph coherence to
+Mechanism: self-filters to `.handoff/*.md`; extracts the issue (an own-repository
+content anchor first, then the filename); delegates graph coherence to
 scripts/execute-ready-check.py (`--mode handoff`) and census state/fingerprint
 evaluation to `scripts/census/index.mjs`. Deny = exit 2 + stderr (house pattern:
 enforce-worktree.py, block-secrets.py). A deliberate
@@ -39,8 +39,18 @@ from _hook_utils import log
 HOOK_NAME = "drift-guard"
 HANDLED_TOOLS = {"Write", "Edit", "MultiEdit"}
 HANDOFF_PATH_RE = re.compile(r"/\.handoff/[^/]*\.md$")
-ISSUE_ANCHOR_RE = re.compile(r"/issues/(\d+)")          # content-first: [#n](…/issues/n)
-FILENAME_ISSUE_RE = re.compile(r"(\d+)\.md$")           # fallback: <date>-<n>.md
+ISSUE_ANCHOR_RE = re.compile(r"/issues/(\d+)")          # any repo: [#n](…/issues/n)
+FILENAME_ISSUE_RE = re.compile(r"(\d+)\.md$")           # skill-controlled: <date>-<n>.md
+# Remote URL → host/owner/repo. Covers scp-style (`git@host:owner/repo.git`),
+# https and ssh:// forms; deeper namespaces and local paths deliberately do not
+# match — an unparsable remote falls back to the filename anchor.
+REMOTE_URL_RE = re.compile(
+    r"^(?:[a-z][a-z0-9+.-]*://)?(?:[^@/\s]+@)?(?P<host>[^/:\s]+)[/:]"
+    r"(?P<owner>[^/\s]+)/(?P<repo>[^/\s]+?)(?:\.git)?/?$",
+    re.IGNORECASE,
+)
+# Bounded diagnostics: a large drift reports its head plus a remainder counter.
+CENSUS_DELTA_LIMIT = 10
 # Override must be issue-scoped, rev-scoped, reasoned, by-user (Codex R1 — not the cheap `known`).
 GUARD_ACK_RE = re.compile(r"<!--\s*guard-ack:\s*#?\d+\s+r\d+\s+reason:.+\bby-user\s*-->",
                           re.IGNORECASE | re.DOTALL)
@@ -168,6 +178,42 @@ const hasOpen = uniqueReasons.some((reason) => reason.startsWith('proof:'))
     .some(({ status }) => status === CENSUS_VERDICTS.open);
 if (hasOpen) uniqueReasons.push('open');
 const delta = active === null ? null : diffCensus(active, fresh);
+// The guard already knows WHAT moved; report it instead of forcing a blocked
+// consumer to rebuild the diff from the kit internals.
+const pathHashes = (entries) => new Map(
+  (Array.isArray(entries) ? entries : []).map(({ path, hash }) => [path, hash]),
+);
+const diffEntries = (before, after) => {
+  const previous = pathHashes(before);
+  const next = pathHashes(after);
+  return {
+    added: [...next.keys()].filter((path) => !previous.has(path)).sort(),
+    changed: [...next.keys()]
+      .filter((path) => previous.has(path) && previous.get(path) !== next.get(path)).sort(),
+    removed: [...previous.keys()].filter((path) => !next.has(path)).sort(),
+  };
+};
+const familyIndex = (families) => new Map([
+  ...(families?.surfaces ?? []), ...(families?.behaviors ?? []),
+].map(({ name, status, type }) => [`${type}:${name}`, status]));
+const familyDelta = (before, after) => {
+  const previous = familyIndex(before);
+  const next = familyIndex(after);
+  return {
+    added: [...next.keys()].filter((key) => !previous.has(key)).sort(),
+    removed: [...previous.keys()].filter((key) => !next.has(key)).sort(),
+    statusChanged: [...next.keys()]
+      .filter((key) => previous.has(key) && previous.get(key) !== next.get(key)).sort()
+      .map((key) => `${key}: ${previous.get(key)} → ${next.get(key)}`),
+  };
+};
+const deltaReport = active === null ? null : {
+  denominator: {
+    added: delta.added, changed: delta.changed, removed: delta.removed,
+  },
+  evidence: diffEntries(active.evidence, fresh.evidence),
+  families: { ...familyDelta(active.families, fresh.families), open: delta.open },
+};
 const denominatorUnchanged = delta !== null
   && Object.values(delta).every((paths) => paths.length === 0);
 const familiesUnchanged = active !== null
@@ -184,6 +230,7 @@ const state = resolveCensusState({
 writeResult(JSON.stringify({
   builderVersion: CENSUS_BUILDER_VERSION,
   changeBinding: fresh.fingerprints.topology,
+  delta: deltaReport,
   fresh: {
     ...fresh,
     profileReport: {
@@ -367,18 +414,71 @@ def extract_content(payload: dict) -> str:
     return ""
 
 
-def extract_issue(payload: dict, content: str):
-    # Content anchor first, filename fallback. Deliberately NO branch fallback:
-    # a meta/tooling handoff carries no issue (handoff skill supports this) and
-    # must fail-open; a branch-based guess would mis-attribute the branch's issue
-    # and false-block. None here → should_block() allows (not the stale handoff we guard).
-    m = ISSUE_ANCHOR_RE.search(content or "")
-    if m:
-        return int(m.group(1))
+def own_repository_slugs(repo_root: Path) -> list[str]:
+    """Return the `host/owner/repo` slugs this repository's remotes point at."""
+    try:
+        completed = subprocess.run(
+            ["git", "-C", str(repo_root), "config", "--get-regexp", r"^remote\..*\.url$"],
+            capture_output=True,
+            text=True,
+            timeout=5,
+        )
+    except (OSError, subprocess.SubprocessError):
+        return []
+    if completed.returncode != 0:
+        return []
+    slugs = []
+    for line in completed.stdout.splitlines():
+        parts = line.split(None, 1)
+        if len(parts) != 2:
+            continue
+        match = REMOTE_URL_RE.match(parts[1].strip())
+        if match is None:
+            continue
+        slug = f"{match.group('host')}/{match.group('owner')}/{match.group('repo')}"
+        if slug not in slugs:
+            slugs.append(slug)
+    return slugs
+
+
+def own_issue_pattern(repo_root):
+    """Match only issue links of the repository that owns the handoff.
+
+    A handoff routinely links the upstream issues a session produced. Without
+    this restriction the first `/issues/<n>` in the prose wins, so a foreign
+    link hijacks the anchor and the guard reports an unrelated issue number.
+    """
+    if repo_root is None:
+        return None
+    slugs = own_repository_slugs(repo_root)
+    if not slugs:
+        return None
+    alternatives = "|".join(re.escape(slug) for slug in slugs)
+    return re.compile(rf"(?<![A-Za-z0-9.-])(?:{alternatives})/issues/(\d+)", re.IGNORECASE)
+
+
+def extract_issue(payload: dict, content: str, repo_root=None):
+    # Own-repository content anchor first, then the skill-controlled filename.
+    # The unrestricted content anchor only remains for a repository whose remote
+    # is unparsable — there the filename is the only trustworthy signal, and a
+    # handoff without one keeps today's behaviour. Deliberately NO branch
+    # fallback: a meta/tooling handoff carries no issue (handoff skill supports
+    # this) and must fail-open; a branch-based guess would mis-attribute the
+    # branch's issue and false-block. None here → should_block() allows (not the
+    # stale handoff we guard).
+    own = own_issue_pattern(repo_root)
+    if own is not None:
+        m = own.search(content or "")
+        if m:
+            return int(m.group(1))
     fp = (payload.get("tool_input") or {}).get("file_path", "")
     m = FILENAME_ISSUE_RE.search(fp)
     if m:
         return int(m.group(1))
+    if own is None:
+        m = ISSUE_ANCHOR_RE.search(content or "")
+        if m:
+            return int(m.group(1))
     return None
 
 
@@ -534,15 +634,89 @@ def evaluate_census(repo_root: Path, proof_timeout_ms=CENSUS_PROOF_TIMEOUT_MS) -
         "override_applied": override_applied,
         "change_binding": result["changeBinding"],
         "mechanical_false_positive": result["mechanicalFalsePositive"],
+        "delta": result.get("delta"),
     }
 
 
-def build_census_block_message(issue: int, result: dict) -> str:
+def _cap_entries(entries, limit: int):
+    if not isinstance(entries, list) or len(entries) <= limit:
+        return entries
+    return [*entries[:limit], f"…and {len(entries) - limit} more"]
+
+
+def cap_delta(delta, limit: int = CENSUS_DELTA_LIMIT):
+    """Keep a diagnostic delta readable — head plus an honest remainder count."""
+    if not isinstance(delta, dict):
+        return delta
+    capped = {}
+    for group, entries in delta.items():
+        if isinstance(entries, dict):
+            capped[group] = {key: _cap_entries(value, limit) for key, value in entries.items()}
+        else:
+            capped[group] = _cap_entries(entries, limit)
+    return capped
+
+
+def worktree_identity(path):
+    """Return (checkout root, shared git dir) or None when git cannot answer."""
+    try:
+        completed = subprocess.run(
+            ["git", "-C", str(path), "rev-parse", "--show-toplevel", "--git-common-dir"],
+            capture_output=True,
+            text=True,
+            timeout=5,
+        )
+    except (OSError, subprocess.SubprocessError):
+        return None
+    if completed.returncode != 0:
+        return None
+    lines = completed.stdout.splitlines()
+    if len(lines) != 2 or not lines[0] or not lines[1]:
+        return None
+    # `--git-common-dir` may answer relative to the directory git ran in.
+    toplevel = Path(os.path.realpath(lines[0]))
+    common = Path(os.path.realpath(Path(path) / lines[1]))
+    return toplevel, common
+
+
+def checkout_diagnostic_lines(census_root, cwd=None) -> list[str]:
+    """Name the checkout the census verdict describes.
+
+    The census root comes from the handoff TARGET path, not from the session's
+    working directory — handoff documents live in the main checkout so they
+    survive worktree cleanup. A census describes the tree it was scanned in, so
+    a refresh in another worktree legitimately does not count here; without this
+    diagnosis the block reads as simply wrong to a session working elsewhere.
+    """
+    if census_root is None:
+        return []
+    lines = [
+        f"  · evaluated checkout: {census_root}",
+        "    (derived from the handoff target path — a census refresh in another",
+        "     worktree does not count for this checkout)",
+    ]
+    try:
+        # A diagnostic must never cost the block: an unusable working directory
+        # only drops the extra sentence.
+        here = worktree_identity(Path.cwd() if cwd is None else Path(cwd))
+        there = worktree_identity(census_root)
+    except OSError:
+        return lines
+    if here and there and here[1] == there[1] and here[0] != there[0]:
+        lines += [
+            "  · your working directory is a different worktree of the same repository:",
+            f"    {here[0]} — refresh the evaluated checkout above, not this one",
+        ]
+    return lines
+
+
+def build_census_block_message(issue: int, result: dict, census_root=None, cwd=None) -> str:
     reasons = ", ".join(result.get("reasons", [])) or "activated census is stale"
     lines = [
         f"CENSUS — Build-Handoff für #{issue} BLOCKED ({result.get('state', 'refresh_required')}):",
         "",
         f"  · {reasons}",
+        *checkout_diagnostic_lines(census_root, cwd),
         "  · run `$census-update` and activate a verified current census",
     ]
     if result.get("overrides"):
@@ -557,24 +731,38 @@ def should_block(payload: dict):
     if not is_handoff_write(payload):
         return False, ""
     content = extract_content(payload)
-    issue = extract_issue(payload, content)
+    # The owning repository decides which issue links may anchor the handoff,
+    # so it is resolved before the anchor is extracted.
+    census_root = None
+    root_error = None
+    try:
+        census_root = resolve_handoff_repo_root(payload)
+    except Exception as error:
+        root_error = error
+    issue = extract_issue(payload, content, census_root)
     if issue is None:
         log(HOOK_NAME, "no identifiable issue target → fail-open allow")
         return False, ""
     intent = _infer_intent(content)
-    try:
-        census_root = resolve_handoff_repo_root(payload)
-        census = evaluate_census(census_root)
-    except Exception as error:
-        census = {
+
+    def unavailable(error):
+        return {
             "state": "failed",
             "block_handoff": intent == "build",
             "reasons": [f"target repository unavailable ({error})"],
             "overrides": [],
         }
+
+    if census_root is None:
+        census = unavailable(root_error)
+    else:
+        try:
+            census = evaluate_census(census_root)
+        except Exception as error:
+            census = unavailable(error)
     log(HOOK_NAME, f"census state={census['state']} reasons={census.get('reasons', [])}")
     if intent == "build" and census.get("block_handoff"):
-        return True, build_census_block_message(issue, census)
+        return True, build_census_block_message(issue, census, census_root)
     if GUARD_ACK_RE.search(content):
         log(HOOK_NAME, "guard-ack override present → allow graph gate only")
         return False, ""
@@ -608,7 +796,8 @@ def build_block_message(issue: int, intent: str, result: dict) -> str:
 
 
 def main() -> int:
-    if sys.argv[1:] == ["--census-status"]:
+    arguments = sys.argv[1:]
+    if arguments[:1] == ["--census-status"] and arguments[1:] in ([], ["--verbose"]):
         try:
             root = resolve_census_root_from_cwd(Path.cwd())
             result = evaluate_census(root)
@@ -617,6 +806,8 @@ def main() -> int:
                       "detail": f"target repository unavailable ({error})",
                       "reasons": ["repository"], "overrides": [],
                       "override_applied": False}
+        if arguments[1:] != ["--verbose"]:
+            result["delta"] = cap_delta(result.get("delta"))
         print(json.dumps(result, sort_keys=True))
         return 0
     try:

package/.claude/skills/grill-me/SKILL.md

@@ -52,7 +52,7 @@ For a cross-cutting plan, run `python3 .claude/hooks/drift-guard.py --census-sta
 
 ## Plan-lock — writing PLAN.md
 
-Once all decisions are made (plan locked, before sign-off/handoff) and the session runs in a **worktree** → write the locked plan as `PLAN.md` to the worktree root (gitignored since, doesn't travel over git — consistent with CLAUDE.md "plan inside the worktree"). This way the locked plan survives a session cut and `to-prd` finds its default source. Continuing same-session work **without** a worktree stays allowed (conversation = source); but for a deliberate **session cut** before `to-prd`, `PLAN.md` is mandatory. (The `-codex` variant already writes `PLAN.md` anyway.)
+Once all decisions are made (plan locked, before sign-off/handoff) and the session runs in a **worktree** → write the locked plan as `PLAN.md` to the worktree root. `PLAN.md` is **expected** to be ignored by git so it never travels over git — the kit never edits your `.gitignore` by itself, but `/setup-workflow` offers to add that rule (consistent with CLAUDE.md "plan inside the worktree"). This way the locked plan survives a session cut and `to-prd` finds its default source. Continuing same-session work **without** a worktree stays allowed (conversation = source); but for a deliberate **session cut** before `to-prd`, `PLAN.md` is mandatory. (The `-codex` variant already writes `PLAN.md` anyway.)
 
 ## Re-grill reconcile — execute-ready (Wave 26)
 

package/.claude/skills/grill-with-docs/SKILL.md

@@ -40,7 +40,7 @@ For a cross-cutting plan, run `python3 .claude/hooks/drift-guard.py --census-sta
 
 ## Plan-lock — writing PLAN.md
 
-Once all decisions are made (plan locked, before sign-off/handoff) and the session runs in a **worktree** → write the locked plan as `PLAN.md` to the worktree root (gitignored since, doesn't travel over git — consistent with CLAUDE.md "plan inside the worktree"). This way the locked plan survives a session cut and `to-prd` finds its default source. Continuing same-session work **without** a worktree stays allowed (conversation = source); but for a deliberate **session cut** before `to-prd`, `PLAN.md` is mandatory. (The `-codex` variant already writes `PLAN.md` anyway.)
+Once all decisions are made (plan locked, before sign-off/handoff) and the session runs in a **worktree** → write the locked plan as `PLAN.md` to the worktree root. `PLAN.md` is **expected** to be ignored by git so it never travels over git — the kit never edits your `.gitignore` by itself, but `/setup-workflow` offers to add that rule (consistent with CLAUDE.md "plan inside the worktree"). This way the locked plan survives a session cut and `to-prd` finds its default source. Continuing same-session work **without** a worktree stays allowed (conversation = source); but for a deliberate **session cut** before `to-prd`, `PLAN.md` is mandatory. (The `-codex` variant already writes `PLAN.md` anyway.)
 
 </plan-lock>
 

package/.claude/skills/kit-update/SKILL.md

@@ -105,6 +105,19 @@ release contain the same artifact.
    and safe routes—never file content. Automated update pull
    requests carry the same availability summary and remain manual-merge only.
 
+   Read the required consumer migrations alongside the file delta. A release
+   that forces the Consumer to commit a decision registers it as declarative,
+   versioned data in the Kit's migration registry — never as release-note prose.
+   Preview and the terminal report expose the same structured record, so an
+   interactive run, a `--yes` run, `update --json`, and the automated update
+   pull request all name the same outstanding actions. Each action names the
+   workflow that resolves it, the Consumer file that carries the decision, and
+   the exact missing decision. `kit-update` only detects and reports it: it
+   never writes the decision, never infers a value, and never invents or
+   auto-accepts a pattern that would grant deletion authority. An empty but
+   explicit decision is a committed decision and clears the action; a missing
+   one keeps it pending on every rerun.
+
    For each conflicted kit-shipped file, always ask the user whether the local
    edit is a generic improvement or project-specific; never decide or act
    automatically. For a generic improvement retained as a bridge, run
@@ -131,7 +144,26 @@ release contain the same artifact.
    resume the transaction through the update API's `resumeFrom` option. Do not
    copy staged files into the consumer by hand.
 
-5. Check the optional project census after the update:
+5. Review the consumer profile's glob dialect after the update:
+
+   ```sh
+   python3 scripts/profile_globs.py docs/agents/workflow-capabilities.json
+   ```
+
+   Every consumer-profile glob — Worktree Lifecycle `scratchPatterns` and
+   `wrapup.landingGeneratedArtifactPatterns`, Workflow Advisories
+   `baseline.sourceGlobs` and the `preRefactor`/`stopChecks` surface globs — is
+   matched by one shared repository-relative dialect. A pattern written for an
+   older matcher can narrow or widen. The check names each such pattern with
+   the witness path that proves the difference and marks the keys that carry
+   deletion authority; exit code 1 means at least one needs review. Report the
+   named patterns and let the user rewrite them. The updater never rewrites a
+   consumer pattern, and a widened deletion-authority pattern is never accepted
+   silently — an update must not expand what cleanup may remove. A missing or
+   disabled profile leaves nothing to review and does not invalidate the
+   update.
+
+6. Check the optional project census after the update:
 
    ```sh
    python3 .claude/hooks/drift-guard.py --census-status

package/.claude/skills/orchestrate-wave/SKILL.md

@@ -146,8 +146,8 @@ replace the ~30-second heartbeat; otherwise the standing heartbeat remains requi
    points there). Bring its branch to current `main`:
    `git -C <wave> merge --ff-only origin/main` (if your repo guards destructive
    git, ff-merge is the safe path — not `reset --hard`). Install dependencies with
-   your package manager after (the lockfile may have moved). A gitignored plan doc
-   survives the merge.
+   your package manager after (the lockfile may have moved). A plan doc the repository
+   ignores survives the merge; a tracked one may not (`/setup-workflow` offers those rules).
 5. **Run project setup steps (`§Setup`)** the later verify needs — e.g. a DB
    tunnel or service the live-verify depends on. Absent layer → start whatever your
    live-verify environment requires before Phase 4.
@@ -332,8 +332,8 @@ written · merge order documented.
 - **Release this run's slice claims.** A landed slice's PR supersedes its claim;
   for a pulled or abandoned slice remove the claim this run planted (unassign +
   `claim released` comment) so it stays grabbable. Foreign ones stay untouched.
-- **Before removing any slice worktree, read its `ANNAHMEN.md`** (an assumptions
-  log, gitignored at worktree-root) and propagate each build-time assumption marker
+- **Before removing any slice worktree, read its `ANNAHMEN.md`** (an assumptions log at
+  the worktree root, **expected** to be ignored by git — `/setup-workflow` offers that rule) and propagate each build-time assumption marker
   to the sibling issue it carries. A hand-driven multi-PR / migration landing does
   NOT run `wrapup`'s assumption-propagation step — this is the only place it
   happens; `worktree remove` deletes the log.

package/.claude/skills/setup-workflow/SKILL.md

@@ -37,6 +37,7 @@ This is a prompt-driven skill, not a deterministic script. Explore, present what
 | `docs/agents/workflow-capabilities.json` + capability assets | consumer-owned Worktree Lifecycle, Memory Lifecycle, Workflow Advisories, and Safety Guardrails choices (Sections A4–A7) |
 | `.claude/settings.json` | additive activation of the advisory kit-origin Edit/Write hint (Section A8) |
 | user-local routing profile | familiar agent surfaces + switching autonomy (Section A9; never package- or repository-owned) |
+| `.gitignore` | **offered only** — one previewed, append-only marker block with the ignore rules for the planning artifacts the skills write (Section A11) |
 
 ## Idempotency contract — read before writing anything
 
@@ -216,6 +217,15 @@ Worktree Lifecycle for this repository?"* Offer exactly **Yes**, **Later**, and
 - **Disable** — remove only the exact kit-owned hook commands first, then set
   `enabled: false`; retain the profile, setup policy, and unknown keys.
 
+Whenever a profile already carries patterns — on **Yes** over an existing
+section and on **Existing** — run
+`python3 scripts/profile_globs.py docs/agents/workflow-capabilities.json` and
+report every pattern it names. Patterns whose match set narrows or widens under
+the shared dialect are a consumer decision: name them with their witness path,
+mark the deletion-authority keys, and let the consumer rewrite them. Never
+rewrite a pattern for them, and never accept a widened deletion-authority
+pattern silently.
+
 The default setup entry is
 `python3 scripts/worktree-lifecycle/setup.py`; a proven consumer-native helper
 may remain the configured `setupEntry` for parity. The handoff advisory always
@@ -273,6 +283,12 @@ repository?"* Offer exactly **Yes**, **Later**, and **No**.
 - **Disable** — remove exact kit-owned commands first, then set `enabled:
   false`; preserve every profile value and unknown key.
 
+`baseline.sourceGlobs` and the `preRefactor`/`stopChecks` surface globs use the
+same shared dialect as the Worktree Lifecycle patterns above. An adopted
+profile written for the older whole-string matcher can change meaning, so run
+`python3 scripts/profile_globs.py docs/agents/workflow-capabilities.json` and
+report every pattern it names before treating the section as reconciled.
+
 ### 2f. Section A7 — Optional Safety Guardrails
 
 > Safety Guardrails is a counted group of seven independently selectable
@@ -390,6 +406,55 @@ machine, checkout path, repository name, credentials, or current GitHub login.
 Even a valid capability authorizes local preparation only; a pull request,
 push, publish, or merge remains a separate explicit approval.
 
+### 2j. Section A11 — Planning-artifact ignore rules (offered)
+
+> The planning skills write `PLAN.md`, `PLAN-REVIEW-LOG.md`, and `ANNAHMEN.md`
+> into a session worktree. `.gitignore` is the consumer's file: the kit does not
+> own it and never touches it during `init` or `update`, so those artifacts are
+> ignored only if this repository already says so. Without the rules every
+> planning worktree reports a permanently dirty tree, the Worktree Lifecycle
+> cleanup refuses to remove it, and a plan doc can be committed by accident.
+
+Read the current state first. The preview is read-only and writes nothing:
+
+```bash
+python3 scripts/worktree-lifecycle/ignore_seed.py preview
+```
+
+- `nothing-to-do` — this repository already ignores every declared artifact.
+  Report it and ask nothing.
+- `blocked` — the marker block exists but no longer covers everything. That
+  block is consumer-owned: name the uncovered artifacts, let the user edit
+  `.gitignore` themselves, and never repair or rewrite it.
+- `append` — show the exact lines the preview printed, the whole marker block
+  verbatim and nothing summarized, then ask: *"Should setup add these ignore
+  rules to `.gitignore`?"*
+
+Offer exactly two choices:
+
+- **Add the rules** — run the seeder once. It appends that one marker block and
+  touches nothing else:
+
+```bash
+python3 scripts/worktree-lifecycle/ignore_seed.py apply
+```
+
+- **Not now** — write nothing. Explain that the planning skills still work, that
+  the artifacts will keep showing up as untracked changes, and that re-running
+  `/setup-workflow` offers this again.
+
+The write is append-only inside one idempotent marker block: it never rewrites,
+reorders, or removes an existing line; a re-run after an approval is a
+byte-identical no-op; and a decline leaves the file exactly as it was. An
+artifact already committed to history is reported separately — an ignore rule
+cannot untrack it, and setup never runs `git rm`. Only this explicit, approved
+step may write `.gitignore`; `init` and `update` reconciliation never reach the
+seeder.
+
+Report `appended · nothing to do (already ignored) · declined · blocked
+(consumer-edited block)`. After an approval — and only then — the Section A4
+`scratchPatterns` derivation has real ignored planning artefacts to read.
+
 ### 3. Section B — Triage labels
 
 > When `triage` processes an incoming issue it applies labels (or your tracker's equivalent). It needs strings you've actually configured, or it creates duplicates.
@@ -411,13 +476,29 @@ Seed `docs/agents/domain.md` from [domain.md](./domain.md).
 
 **Skip entirely if Section A is not GitHub** → write `board-sync.md` with `state=not-applicable`, `mode=none`, a one-line "this project does not use a GitHub-Projects board" note. Terminal; never re-prompts.
 
-**Preflight:** `gh auth status`. If `project`/`read:project` scope is missing, surface the exact remedy: `gh auth refresh -s project,read:project`, then fall through to the stub path below.
+**Preflight:** `gh auth status` (or `python3 scripts/board_bootstrap.py preflight --json` for the machine-readable answer). If `project`/`read:project` scope is missing, surface the exact remedy: `gh auth refresh -s project,read:project`, then fall through to the stub path below — without the write scope, never attempt creation.
 
-**Discover (the success path):** `gh project list --owner <remote-owner> --format json`. If **exactly one** project clearly belongs to this repo's owner, read its fields: `gh project field-list <number> --owner <owner> --format json`. Record each field's `id`, `name`, `dataType` (single-select / number / text), and for single-selects the option `id`s. Write `board-sync.md` with `state=filled`, `mode=github-projects-v2`, the project node id + repo + the discovered field/option IDs, seeded from [board-sync.md](./board-sync.md). Fill the `<!-- board-sync:profile -->` **JSON block** (the machine SSOT `scripts/board_config.py` parses) — replace each `<…>` placeholder under `repo`/`project`/`fields` with the discovered value; leave the convention values (`labels`/`branchPrefixes`/`prMarkers`/`headings`) at their seeded defaults unless this project's conventions differ.
+**Discover (the existing-board path):** `gh project list --owner <remote-owner> --format json`. If **exactly one** project clearly belongs to this repo's owner, read its fields: `gh project field-list <number> --owner <owner> --format json`. Record each field's `id`, `name`, `dataType` (single-select / number / text), and for single-selects the option `id`s. Write `board-sync.md` with `state=filled`, `mode=github-projects-v2`, the project node id + repo + the discovered field/option IDs, seeded from [board-sync.md](./board-sync.md). Fill the `<!-- board-sync:profile -->` **JSON block** (the machine SSOT `scripts/board_config.py` parses) — replace each `<…>` placeholder under `repo`/`project`/`fields` with the discovered value; leave the convention values (`labels`/`branchPrefixes`/`prMarkers`/`headings`) at their seeded defaults unless this project's conventions differ.
 
 **Map the status roles (`fields.status.roles`):** the seeded map carries the recommended English stage names (`Idea/Triaged/Spec/In Progress/Review/Done`). Reconcile it against the **discovered** Status option names: an exact (case-sensitive) match keeps its seeded entry; for every role whose seeded name is NOT among the discovered options, ask the user which of their actual option names plays that role (a stage they don't have may be omitted from the map — say so). Never guess a mapping from similarity. Finish with a validation pass: every role value in the map MUST appear in `fields.status.options`, else fix before writing `state=filled`.
 
-**Fallback (the single catch-all — no board / >1 / ambiguous / scope error / read failure):** do **not** auto-create a board (`gh project create` alone cannot provision the Status options + workflow fields a board needs). Write `board-sync.md` with `state=stub`, `mode=github-projects-v2`, and inline **instructions**: which fields the workflow profile needs (a Status single-select with your stage options; optionally a Wave number, a Cluster text, a Spec-Path / Plan-Path text), how to create the board in the GitHub UI / `gh`, and "then run `/setup-workflow` again — it will discover and fill the IDs." Retryable.
+**Offer creation (no board found, scope present):** a fresh repo can reach a working board in this run — `gh project create` provisions the shell and `gh project field-create --single-select-options` provisions the Status single-select together with its options. Minting a GitHub Project is an outward, user-visible action, so **ask first and never create a board without an explicit yes**. Name the stage options the board will get (the seed's `fields.status.roles` values) in the question, and edit those role values in the seed *before* creating if the user wants a different stage vocabulary — they become the board's Status options verbatim. Present exactly two choices:
+
+- **Create it now** — run the one creation path (never hand-assemble the `gh` sequence):
+
+```bash
+python3 scripts/board_bootstrap.py create --owner <owner> --repo <owner>/<repo> \
+  --title "<repo> Workflow" --seed <path of this skill folder>/board-sync.md \
+  --out docs/agents/board-sync.md
+```
+
+  It re-checks the destination and the scope before it writes anything, creates the project, the Status single-select (option names read from the seed profile's `fields.status.roles` — the board's own stage vocabulary, never a literal), and the Wave / Cluster / Spec-Path / Plan-Path fields, then discovers the real field/option IDs via `gh project field-list` and writes `docs/agents/board-sync.md` at `state=filled`, `mode=github-projects-v2` **from that readback**. Show the user `--dry-run` output first if they want to see the exact sequence. Report the created project's number and URL, and that its Status roles now resolve.
+
+- **Not now** — create nothing and take the stub path below unchanged.
+
+**A non-zero exit is a stub, never a partial claim.** The helper writes no profile when the destination is consumer-owned, the scope is missing (exit 3), or creation/readback/validation fails — so a half-created board can never produce a profile claiming fields that do not exist. On any non-zero exit, relay its message (it names the project it created, if any, so the user can finish or delete it), then take the stub path; never hand-write a `state=filled` profile and never retry creation without asking again.
+
+**Fallback (the single catch-all — declined / no board / >1 / ambiguous / scope error / read failure / creation failure):** write `board-sync.md` with `state=stub`, `mode=github-projects-v2`, and inline **instructions**: which fields the workflow profile needs (a Status single-select with your stage options; optionally a Wave number, a Cluster text, a Spec-Path / Plan-Path text), how to create the board in the GitHub UI / `gh`, and "then run `/setup-workflow` again — it will discover and fill the IDs." Retryable.
 
 **Optional — Phase field + saved Views (Program route only):** never
 auto-discovered or auto-created, unlike the fields above — a Phase field's

package/.claude/skills/setup-workflow/board-sync.md

@@ -3,8 +3,8 @@
 How the board-managed workflow skills (`to-prd`, `to-issues`, `board-to-waves`, …) address this project's GitHub-Projects board. A board stores its fields under opaque GraphQL IDs that differ per board, so they are recorded here rather than hardcoded in any skill.
 
 `/setup-workflow` writes this file in one of three states (see the sentinel on the first line):
-- **`state=filled`** — the IDs below were discovered from your board.
-- **`state=stub`** — no single board was found; fill the IDs by creating the board (below) and re-running `/setup-workflow`.
+- **`state=filled`** — the IDs below were discovered from your board (an existing one, or the one `/setup-workflow` offered to create for you).
+- **`state=stub`** — no single board was filled: you declined the creation offer, `gh` lacked the `project` scope, several boards were ambiguous, or creation failed. Create the board (below) and re-run `/setup-workflow`.
 - **`state=not-applicable`** (`mode=none`) — this project does not use a GitHub-Projects board.
 
 ## Board profile — fields the workflow skills use
@@ -106,6 +106,10 @@ their titles unchanged; set it once to match your board's language.
 
 ## If the IDs are not yet filled (stub)
 
+**Let setup create the board.** Ensure `gh` has the scopes (`gh auth refresh -s project,read:project`) and re-run `/setup-workflow`: with no board and the scope present it *offers* to create one. On your yes it runs `scripts/board_bootstrap.py`, which creates the project plus the Status single-select (its options named after the `roles` map below) and the Wave / Cluster / Spec-Path / Plan-Path fields, reads the real IDs back, and rewrites this file at `state=filled`. Nothing is created without that explicit yes, and a failed run leaves this stub in place rather than a half-true profile.
+
+**Or build it by hand:**
+
 1. Create a GitHub-Projects (v2) board for this owner and add the fields above (at minimum a `Status` single-select with your stage options — the recommended stage names are `Idea, Triaged, Spec, In Progress, Review, Done`, matching the seeded `roles` defaults).
 2. Ensure `gh` has the scopes: `gh auth refresh -s project,read:project`.
 3. Re-run `/setup-workflow` — it discovers the board (`gh project field-list`) and fills the IDs here automatically.

package/.claude/skills/setup-workflow/workflow-advisories.md

@@ -74,6 +74,40 @@ key. Consumer values are never normalized on adoption.
 Empty command surfaces are honest inactive defaults. Setup recommends concrete
 project commands from the tools already present, then asks before activating.
 
+## Profile glob dialect
+
+`baseline.sourceGlobs`, `preRefactor.surfaces[].globs`, and
+`stopChecks.surfaces[].globs` are matched by the one shared dialect in
+`scripts/profile_globs.py` — the same matcher Worktree Lifecycle uses for its
+scratch and landing-artifact policies. There is no second matcher and no
+per-capability variant:
+
+- `*` matches any run of characters inside one path segment, never `/`.
+- `?` matches exactly one character inside one path segment.
+- `[seq]` and `[!seq]` are per-segment character classes; `/` is always a
+  separator and never a class member.
+- `**` as a complete segment matches zero or more segments, so a leading `**/`
+  also matches the repository root and `dir/**` also matches `dir` itself.
+- Matching is always case-sensitive, on every host filesystem.
+- A pattern must match the whole repository-relative path.
+
+Thus `src/**` covers `src/a/b.ts`, `**/*.ts` covers both `index.ts` and
+`src/index.ts`, and `*.ts` covers only a root-level file.
+
+A profile written for the older whole-string matcher can therefore change
+meaning. When adopting an existing profile, or after any kit update, review it:
+
+```bash
+python3 scripts/profile_globs.py docs/agents/workflow-capabilities.json
+```
+
+The check names every pattern whose match set narrows or widens, prints the
+concrete witness path that proves the difference, and separately flags patterns
+that only matched case-insensitively on the previous matcher. Exit code 1 means
+at least one pattern needs review. Report the named patterns and let the
+consumer rewrite them; never migrate a pattern automatically. The check reads
+the profile and never edits it.
+
 ## Hook ownership
 
 - PreToolUse on Read: