guardian-framework 0.1.153 → 0.1.154

package/dist/cli.js

@@ -3206,7 +3206,7 @@ __export(exports_package, {
   bin: () => bin,
   author: () => author
 });
-var name = "guardian-framework", version = "0.1.153", description = "Token-optimized agentic framework scaffolder with pi-first architecture", type = "module", main = "dist/exports.js", exports, types = "dist/exports.d.ts", bin, files, engines, scripts, publishConfig, pi, repository, homepage = "https://github.com/arman-jalili/guardian-framework#readme", bugs, dependencies, devDependencies, keywords, author = "Arman Wolkensteiner-Jalili", license = "MIT", package_default;
+var name = "guardian-framework", version = "0.1.154", description = "Token-optimized agentic framework scaffolder with pi-first architecture", type = "module", main = "dist/exports.js", exports, types = "dist/exports.d.ts", bin, files, engines, scripts, publishConfig, pi, repository, homepage = "https://github.com/arman-jalili/guardian-framework#readme", bugs, dependencies, devDependencies, keywords, author = "Arman Wolkensteiner-Jalili", license = "MIT", package_default;
 var init_package = __esm(() => {
   exports = {
     ".": {

package/dist/exports.js

@@ -1991,7 +1991,7 @@ __export(exports_package, {
   bin: () => bin,
   author: () => author
 });
-var name = "guardian-framework", version = "0.1.153", description = "Token-optimized agentic framework scaffolder with pi-first architecture", type = "module", main = "dist/exports.js", exports, types = "dist/exports.d.ts", bin, files, engines, scripts, publishConfig, pi, repository, homepage = "https://github.com/arman-jalili/guardian-framework#readme", bugs, dependencies, devDependencies, keywords, author = "Arman Wolkensteiner-Jalili", license = "MIT", package_default;
+var name = "guardian-framework", version = "0.1.154", description = "Token-optimized agentic framework scaffolder with pi-first architecture", type = "module", main = "dist/exports.js", exports, types = "dist/exports.d.ts", bin, files, engines, scripts, publishConfig, pi, repository, homepage = "https://github.com/arman-jalili/guardian-framework#readme", bugs, dependencies, devDependencies, keywords, author = "Arman Wolkensteiner-Jalili", license = "MIT", package_default;
 var init_package = __esm(() => {
   exports = {
     ".": {

package/package.json

@@ -1,6 +1,6 @@
 {
 	"name": "guardian-framework",
-	"version": "0.1.153",
+	"version": "0.1.154",
 	"description": "Token-optimized agentic framework scaffolder with pi-first architecture",
 	"type": "module",
 	"main": "dist/exports.js",

package/templates/pi/preflight_report.json

@@ -1,5 +1,5 @@
 {
-  "timestamp": "2026-11-13T16:44:03Z",
+  "timestamp": "2026-11-13T16:52:48Z",
   "mode": "all",
   "stages_run": [],
   "summary": {

package/templates/pi/scripts/epic-fanout.sh

@@ -170,13 +170,15 @@ echo ""
 # ── Dependency gate ─────────────────────────────────────────────────────────
 # A module may only run in parallel once the modules it depends on are
 # implemented. Deps inside this same batch cannot be satisfied yet either.
-DEP_CHECK="$(python3 - "$ROOT" ${MODULES[@]+"${MODULES[@]}"} <<'PY'
+DEP_CHECK="$(python3 - "$ROOT" "$COMMON_ABS/guardian/epics.json" ${MODULES[@]+"${MODULES[@]}"} <<'PY'
 import os, re, sys
 
 root = sys.argv[1]
-batch = sys.argv[2:]
+registry_path = sys.argv[2]
+batch = sys.argv[3:]
 mods_dir = os.path.join(root, ".pi/architecture/modules")
 
+
 def doc_path(slug):
     p = os.path.join(mods_dir, f"{slug}.md")
     return p if os.path.exists(p) else None
@@ -199,63 +201,128 @@ def status_of(slug):
     return "planned"
 
 def deps_of(slug):
+    """Modules this one depends on.
+
+    Module docs use several shapes, all of which appear in real projects:
+        **Depends On:** none.
+        **Depends On:** Alpha, Beta
+        ### Depends On
+        | Module | What it provides |
+        | **Mandate** | ... |
+
+    Critically, a doc may also carry a "Used By" table listing its CONSUMERS.
+    Those must never be read as dependencies (that would invert the graph and
+    block a module on the work that depends on it).
+    """
     p = doc_path(slug)
     if not p:
         return []
-    text = open(p, encoding="utf-8", errors="ignore").read()
-    m = re.search(r"\*\*Depends On:\*\*(.*?)(?:\n##|\Z)", text, re.S | re.I)
-    if not m:
-        m = re.search(r"##\s*Dependencies(.*?)(?:\n##|\Z)", text, re.S | re.I)
-    if not m:
+    lines = open(p, encoding="utf-8", errors="ignore").read().splitlines()
+
+    # Scope: the "## Dependencies" section if present, else the whole doc.
+    scope, sec = list(lines), None
+    for i, ln in enumerate(lines):
+        if re.match(r"^##\s+Dependencies\b", ln, re.I):
+            sec = i
+            break
+    if sec is not None:
+        scope = []
+        for ln in lines[sec + 1:]:
+            if re.match(r"^##\s+", ln):
+                break
+            scope.append(ln)
+
+    # Inside that scope, take only the "Depends On" sub-block.
+    block, in_deps = [], False
+    for ln in scope:
+        label = ln.strip()
+        heading = re.match(r"^#{2,4}\s*Depends On\b(.*)$", label, re.I)
+        bold = re.match(r"^\*\*Depends On:?\*\*(.*)$", label, re.I)
+        if heading or bold:
+            in_deps = True
+            rest = (heading.group(1) if heading else bold.group(1)).strip()
+            if rest:
+                block.append(rest)
+            continue
+        if in_deps and re.match(r"^#{2,4}\s", label):
+            in_deps = False  # next sibling section, e.g. "### Used By"
+            continue
+        if in_deps:
+            block.append(label)
+
+    if not block:
         return []
-    block = m.group(1)
-    if re.search(r"\bnone\b", block, re.I):
+
+    # An explicit "none" anywhere in the Depends On block means: no dependencies.
+    joined = " ".join(block)
+    if re.search(r"\bnone\b", joined, re.I):
         return []
+
     found = []
-    # Inline form: '**Depends On:** Alpha, Beta' or 'Alpha' (single line, no table)
-    first = next((ln.strip() for ln in block.splitlines() if ln.strip()), "")
-    if first and not first.startswith("|") and not first.startswith("-"):
-        for part in re.split(r"[,;]", first):
-            nm = part.strip().strip(chr(96) + "* ").rstrip(".")
-            if nm and not nm.lower().startswith("none"):
-                found.append(nm)
-    for line in block.splitlines():
-        line = line.strip()
-        if not line.startswith("|"):
+    for ln in block:
+        if not ln:
             continue
-        cells = [c.strip() for c in line.strip("|").split("|")]
-        if not cells:
-            continue
-        name = cells[0].replace(chr(96), "").replace("*", "").strip()
-        if not name or name.lower() in ("module", "modules") or set(name) <= set("-: "):
-            continue
-        found.append(name)
-    # also allow "- Name" bullets
-    for line in block.splitlines():
-        line = line.strip()
-        if line.startswith("- "):
-            name = line[2:].split("—")[0].split(":")[0].strip().strip(chr(96) + "* ")
+        if ln.startswith("|"):
+            cells = [c.strip() for c in ln.strip("|").split("|")]
+            if not cells:
+                continue
+            name = cells[0].replace(chr(96), "").replace("*", "").strip()
+            if not name or name.lower() in ("module", "modules") or set(name) <= set("-: "):
+                continue
+            found.append(name)
+        elif ln.startswith("- "):
+            name = ln[2:].split("\u2014")[0].split(":")[0].strip().strip(chr(96) + "* ")
             if name and name.lower() != "none":
                 found.append(name)
+        else:
+            # inline list: "Alpha, Beta"
+            for part in re.split(r"[,;]", ln):
+                nm = part.strip().strip(chr(96) + "* ").rstrip(".")
+                if nm and not nm.lower().startswith("none") and len(nm) < 60:
+                    found.append(nm)
     return found
 
+
 def slugify(name):
     return re.sub(r"[^a-z0-9]+", "-", name.lower()).strip("-")
 
-batch_slugs = set(batch)
+# Registry state: which modules have frozen contracts. Freeze is the gate for
+# parallel work ("merge the contract-freeze issue first"), implementation the
+# stricter also-accepted case. Loaded here because it needs slugify().
+frozen = set()
+try:
+    import json
+    _reg = json.load(open(registry_path, encoding="utf-8"))
+    for _mod, _entry in (_reg.get("epics") or {}).items():
+        if isinstance(_entry, dict) and _entry.get("contractFrozen"):
+            frozen.add(slugify(_mod))
+except Exception:
+    frozen = set()
+
 problems = []
-for slug in batch:
+for idx, slug in enumerate(batch):
     for dep_name in deps_of(slug):
         dep = slugify(dep_name)
         st = status_of(dep)
-        if st in ("implemented",):
+        if st == "implemented":
+            continue
+        if dep in frozen:
             continue
-        if dep in batch_slugs:
-            problems.append(f"{slug}: depends on '{dep_name}' which is in this same batch — start it in an earlier batch")
+        if dep in batch and batch.index(dep) < idx:
+            continue  # frozen earlier in this very run
+        if dep in batch:
+            problems.append(
+                f"{slug}: depends on '{dep_name}', which comes later in this batch — "
+                f"reorder so it starts first")
         elif st == "unknown":
-            problems.append(f"{slug}: depends on '{dep_name}' which has no module doc under .pi/architecture/modules/")
+            problems.append(
+                f"{slug}: depends on '{dep_name}' with no module doc under "
+                f".pi/architecture/modules/")
         else:
-            problems.append(f"{slug}: depends on '{dep_name}' ({st}) — not implemented yet")
+            problems.append(
+                f"{slug}: depends on '{dep_name}' ({st}) and its contracts are not "
+                f"frozen — merge its contract-freeze issue, then: "
+                f"bash .pi/scripts/epic-registry.sh freeze \"{dep_name}\" --frozen")
 
 if problems:
     print("\n".join(problems))