bmad-module-skill-forge 4.0.0 → 5.0.0

package/src/shared/scripts/skf-count-tokens.py

@@ -23,11 +23,24 @@ Measured artifacts (all relative to the positional skill-package dir):
                            extracted from the first --target-file that contains one
                            (shared across the batch; measured once)
 
+The managed_section object also gives `skills`, the number of skill rows (each
+`[name v...]` row header) in the measured block, and `target_files`, every --target-file
+that holds a block, in the order passed and each once. A target file that cannot be read
+as UTF-8 text is skipped.
+
 package_total sums context-snippet.md + SKILL.md + metadata.json + references_total and
 DELIBERATELY EXCLUDES the managed-section row — the managed section is a shared all-skills
 cost reported separately, and including it would double-count this skill's own snippet
 (see references/token-report.md §1).
 
+context_budget gives the token report's Context Budget Impact values, in tokens:
+  - always_on:       the managed section (loaded in every session); null when no
+                     target file holds a block
+  - on_trigger:      SKILL.md (loaded when the skill triggers)
+  - full_disclosure: SKILL.md + references_total (loaded when every reference is read too);
+                     neither the snippet nor metadata.json, so it is not package_total
+  - snippet:         context-snippet.md (this skill's share of the managed section)
+
 CLI:
   python3 skf-count-tokens.py <skill-package-dir>
   python3 skf-count-tokens.py <skill-package-dir> --target-file CLAUDE.md
@@ -52,6 +65,13 @@ MANAGED_SECTION_RE = re.compile(
     re.DOTALL,
 )
 
+# A skill row header of the managed section: `[name v<version>]` at the start of a line,
+# optionally after the format's leading `|`, with or without a `root:` field. The
+# ` v<version>` keeps the section's own `[SKF Skills]|{n} skills|{m} stack` header out.
+# This is skf-rebuild-managed-sections.py's ROW_HEADER_PATTERN, so both scripts count the
+# rows parse_managed_rows returns (test-skf-count-tokens.py keeps them in step).
+MANAGED_ROW_RE = re.compile(r"^\|?\[(?P<name>[^\]]+?) v(?P<version>[^\]\s]+)\]", re.MULTILINE)
+
 # Core per-skill artifacts, in report order. (references/ is handled separately.)
 CORE_ARTIFACTS = [
     ("context-snippet.md", "context-snippet"),
@@ -87,6 +107,11 @@ def extract_managed_section(text: str) -> str | None:
     return m.group(0) if m else None
 
 
+def count_managed_skills(section: str) -> int:
+    """The number of skill rows (`[name v...]` row headers) in a managed section."""
+    return len(MANAGED_ROW_RE.findall(section))
+
+
 def measure_reference_files(references_dir: Path) -> tuple[list[dict], dict]:
     """Measure every file under references/ (recursively, sorted). Returns (per-file rows, total)."""
     rows: list[dict] = []
@@ -144,20 +169,38 @@ def count_package(skill_dir: Path, target_files: list[Path] | None = None) -> di
         "tokens": sum(core_by_role[r]["tokens"] for r in core_by_role) + references_total["tokens"],
     }
 
-    # Managed section — first --target-file that actually contains a block wins.
-    managed_section = {"present": False, "source_file": None, "words": 0, "tokens": 0}
+    # Managed section: the first --target-file that actually contains a block is measured;
+    # target_files lists every one that holds a block.
+    managed_section = {"present": False, "source_file": None, "target_files": [], "skills": 0,
+                       "words": 0, "tokens": 0}
+    seen: set[Path] = set()
     for tf in target_files:
         tf = Path(tf)
-        if not tf.is_file():
+        if tf.resolve() in seen or not tf.is_file():
             continue
-        section = extract_managed_section(_read_text(tf))
-        if section is not None:
-            managed_section = {
-                "present": True,
-                "source_file": tf.as_posix(),
+        seen.add(tf.resolve())
+        try:
+            section = extract_managed_section(_read_text(tf))
+        except (OSError, UnicodeDecodeError):
+            continue  # unreadable or not UTF-8: it holds no block this helper can measure
+        if section is None:
+            continue
+        managed_section["target_files"].append(tf.as_posix())
+        if not managed_section["present"]:
+            managed_section.update(
+                present=True,
+                source_file=tf.as_posix(),
+                skills=count_managed_skills(section),
                 **measure(section),
-            }
-            break
+            )
+
+    # The Context Budget Impact values token-report.md §2 renders.
+    context_budget = {
+        "always_on": managed_section["tokens"] if managed_section["present"] else None,
+        "on_trigger": core_by_role["skill-md"]["tokens"],
+        "full_disclosure": core_by_role["skill-md"]["tokens"] + references_total["tokens"],
+        "snippet": core_by_role["context-snippet"]["tokens"],
+    }
 
     return {
         "status": "ok",
@@ -166,6 +209,7 @@ def count_package(skill_dir: Path, target_files: list[Path] | None = None) -> di
         "references_total": references_total,
         "managed_section": managed_section,
         "package_total": package_total,
+        "context_budget": context_budget,
     }
 
 

package/src/shared/scripts/skf-detect-workspaces.py

@@ -160,6 +160,26 @@ skf-recommend-scope-type.py reads (registry.ts, components.ts and their .tsx
 forms, at any depth), found by that script's own rule (the sibling in this
 folder, which must sit beside this script).
 
+Brief scope (scoped_tree)
+-------------------------
+
+scoped_tree(tree, excludes, glob_match) is the tree a skill brief's
+scope.exclude globs leave, as workspace detection reads it (#780): a
+workspace member counts only through the files the brief keeps. It holds
+each file no exclude glob matches, but a manifest (a MEMBER_MANIFESTS name);
+each root manifest (a file at the root named in MEMBER_MANIFESTS,
+CONTENT_MANIFESTS or nx.json), always; and each member manifest (a
+MEMBER_MANIFESTS name below the root) whose folder still holds, at any
+depth, a non-manifest file no exclude glob matches, whether or not a glob
+matches the manifest itself. A member manifest whose folder holds no
+non-manifest file at all stays unless a glob matches it. So `rust/**`,
+`rust/**/*.rs` or `rust/*/src/**` drops the members under rust/,
+`**/Cargo.toml` alone drops none, and a workspace with no member left is
+no workspace, while one with a member left still is. With no exclude glob
+the tree is returned as given. Callers (test-skill's stage-helper-payload.py
+and skf-extract-public-api.py's monorepo arm) pass the glob rule of
+skf-resolve-authoritative-files.py, which this script does not load.
+
 Exit codes:
 
   0  success (regardless of is_monorepo value)
@@ -181,6 +201,7 @@ import posixpath
 import re
 import sys
 import tomllib
+from collections.abc import Callable
 from pathlib import Path
 from typing import Optional
 
@@ -200,6 +221,11 @@ RECOGNISED_MANIFESTS = (
 # in the tree alone): --manifest-files lists them, --manifest-dir reads them,
 # and a warning names each one the tree lists that was not supplied.
 CONTENT_MANIFESTS = ("package.json", "pnpm-workspace.yaml", "lerna.json", "rush.json", "Cargo.toml")
+# The manifest a workspace member is found by: a recognised one, or an Nx
+# project's project.json. scoped_tree keeps one while its folder keeps a file.
+MEMBER_MANIFESTS = RECOGNISED_MANIFESTS + ("project.json",)
+# The root files scoped_tree keeps whatever the brief excludes.
+ROOT_MANIFESTS = frozenset(MEMBER_MANIFESTS + CONTENT_MANIFESTS + ("nx.json",))
 MAX_MANIFEST_BYTES = 1024 * 1024
 # Folders a snapshot's module root is never followed down through (names
 # matched in lower case): tests, test helpers and fixtures, docs and sites,
@@ -698,6 +724,47 @@ def detect(payload: dict) -> dict:
     }
 
 
+# --------------------------------------------------------------------------
+# Brief scope
+# --------------------------------------------------------------------------
+
+
+def scoped_tree(tree: list[str], excludes: list[str], glob_match: Callable[[str, str], bool]) -> list[str]:
+    """The paths of `tree` workspace detection reads under a brief whose
+    scope.exclude globs are `excludes`, in their order: see "Brief scope" in
+    the module docstring. `glob_match(path, glob)` is the brief's glob rule."""
+    if not excludes:
+        return list(tree)
+
+    def manifest(path: str) -> bool:
+        return posixpath.basename(path) in MEMBER_MANIFESTS
+
+    excluded = {path for path in tree if any(glob_match(path, glob) for glob in excludes)}
+    holding: set[str] = set()  # folders holding a non-manifest file
+    kept_holding: set[str] = set()  # folders holding one no exclude glob matches
+    for path in tree:
+        if manifest(path):
+            continue
+        parts = path.split("/")
+        for depth in range(1, len(parts)):
+            folder = "/".join(parts[:depth])
+            holding.add(folder)
+            if path not in excluded:
+                kept_holding.add(folder)
+    kept = []
+    for path in tree:
+        if "/" not in path and path in ROOT_MANIFESTS:
+            keep = True
+        elif not manifest(path):
+            keep = path not in excluded
+        else:
+            folder = posixpath.dirname(path)
+            keep = folder in kept_holding or (folder not in holding and path not in excluded)
+        if keep:
+            kept.append(path)
+    return kept
+
+
 # --------------------------------------------------------------------------
 # Tree snapshot
 # --------------------------------------------------------------------------

package/src/shared/scripts/skf-emit-result-envelope.py

@@ -423,11 +423,12 @@ def _compute_tool_deltas(current: dict, previous) -> tuple[list[str], list[str]]
 def _resolver_warning(payload: dict) -> list[str]:
     """The customization_resolver_unavailable warning, when the payload reports one.
 
-    Every workflow's On Activation runs resolve_customization.py. When that
-    script is missing or fails, the run falls back to the skill's own
-    customize.toml, so the team and user overrides under `_bmad/custom/`
-    silently do nothing; the payload key carries the resolver's reason so
-    the envelope says so.
+    Every workflow's On Activation runs skf-resolve-customization.py, which
+    runs BMAD core's resolve_customization.py. When either script is missing
+    or fails, or a core before 6.11.0 would read another folder's overrides,
+    the run falls back to the skill's own customize.toml, so the team and
+    user overrides under `_bmad/custom/` silently do nothing; the payload
+    key carries the reason, whatever its words, so the envelope says so.
     """
     reason = payload.get("customization_resolver_unavailable")
     if not reason: