aw-spec-cli 0.1.21 → 0.1.23

package/assets/.appweaver/scripts/python/aw-plangate.py

@@ -0,0 +1,216 @@
+#!/usr/bin/env python3
+"""
+aw-plangate — the analyze-plan receipt, written and read in one place.
+
+THE RECEIPT. `analyze-plan` records which bytes it checked against each other — spec.md,
+the context's domain-model.md and every lane plan on disk — and the verdict it reached.
+`implement` generates from the plans and deliberately does NOT read the spec, on the
+strength of that receipt, so the pair of operations that write and read it is the hinge the
+whole bootstrap path turns on.
+
+WHY IT LIVES HERE. Both halves were embedded twice, as a bash heredoc and as a natively
+re-written PowerShell function, and the rule they implement is a set of sha comparisons
+with three deliberate asymmetries in it — an absent spec sha does not block, an absent
+model sha does, and an unrecognised verdict records as `gaps`. That rule changed twice
+(MF-19, then MF-20) and each time it had to be re-derived by hand on the PowerShell side
+and kept in step by eye. One module both shells invoke removes the question: there is
+nothing left to keep in step. Same reason aw-crstate.py owns "has this change merged".
+
+NO BASELINE IS NOT "NOTHING MOVED". `spec_moved` / `model_moved` report "" where there is
+nothing to compare against — no receipt, or a receipt that hashed nothing for that
+document. "" is falsy in Python, in PowerShell and to the engine's require_true, so every
+flag computed from them reads exactly as a false did; what it buys is that a reader can
+tell "unchanged" from "unknown", which a bare false cannot express.
+
+Usage:
+  aw-plangate.py stamp --feature-dir <p> --context-dir <p> --root <p>
+                       [--spec-version <v>] [--mode <text>]
+                       [--verdict conformant|routed-gaps|gaps] [--plan-gaps <n>]
+                       [--routed <json list>]
+      -> {file, gated, spec_version, verdict, plan_gaps, routed_gaps, hashed[], count}
+  aw-plangate.py check --feature-dir <p> --context-dir <p> --root <p>
+      -> {file, tracked, gate_fresh, verdict, may_generate, plan_gaps, routed_gaps[],
+          routed_csv, spec_moved, model_moved, plans_changed[], plans_changed_csv,
+          gated, spec_version, reason}
+"""
+
+import argparse
+import datetime
+import hashlib
+import json
+import os
+import sys
+
+RECEIPT = ".aw-plan-gate.json"
+VERDICTS = ("conformant", "routed-gaps", "gaps")
+
+# Every document the gate READ. A lane that is not declared has no plan on disk and is
+# simply absent from the map — the check treats a name it does not carry as not gated,
+# never as changed, so declaring a second lane later does not read as tampering.
+#
+# THE LEGACY NAMES ARE HERE FOR THE SAME REASON version-stamp CARRIES THEM. feature-paths
+# resolves design.md / design.ui.md under the backend_plan / frontend_plan keys, so a tree
+# that has not been through `plan` since the rename — every brownfield feature `adopt`
+# produces — is GATED on those documents. Hashing only the new names would leave such a
+# feature with an empty plan map: a receipt that looks tracked and fresh while the document
+# implement actually generates from is unwatched.
+PLAN_NAMES = ("backend-plan.md", "frontend-plan.md", "design.md", "design.ui.md")
+
+NOTE = ("Written by every master-mode analyze-plan run. It records the bytes that were "
+        "checked against each other and the verdict on them, not a version — the plans' "
+        "**Version**: headers are stamped in lockstep by close-delta and cannot answer "
+        "this. implement reads it through plan-gate-check: moved bytes or verdict `gaps` "
+        "refuse; `routed-gaps` lists what /appweaver specify still has to lift.")
+
+
+def sha(path):
+    try:
+        with open(path, "rb") as fh:
+            return hashlib.sha256(fh.read()).hexdigest()
+    except Exception:
+        return ""
+
+
+def stamp(fd, ctx, root, spec_version="", mode="master", verdict="conformant",
+          plan_gaps=0, routed=None):
+    plans = {}
+    for name in PLAN_NAMES:
+        h = sha(os.path.join(fd, name))
+        if h:
+            plans[name] = h
+    # An unrecognised verdict is recorded as `gaps`, the one that refuses.
+    verdict = (verdict or "").strip()
+    if verdict not in VERDICTS:
+        verdict = "gaps"
+    try:
+        plan_gaps = int(plan_gaps or 0)
+    except (TypeError, ValueError):
+        plan_gaps = 0
+    routed = [str(x) for x in (routed or [])]
+    rec = {
+        "gated": datetime.datetime.now(datetime.timezone.utc).strftime("%Y-%m-%dT%H:%M:%SZ"),
+        "gate_mode": mode or "master",
+        "spec_version": (spec_version or "").strip(),
+        "verdict": verdict,
+        "plan_gaps": plan_gaps,
+        "routed_gaps": routed,
+        "spec_sha": sha(os.path.join(fd, "spec.md")),
+        "model_sha": sha(os.path.join(ctx, "domain-model.md")),
+        "plans": plans,
+        "note": NOTE,
+    }
+    path = os.path.join(fd, RECEIPT)
+    with open(path, "w", encoding="utf-8") as fh:
+        fh.write(json.dumps(rec, indent=2) + "\n")
+    return {"file": os.path.relpath(path, root), "gated": rec["gated"],
+            "spec_version": rec["spec_version"], "verdict": verdict,
+            "plan_gaps": plan_gaps, "routed_gaps": len(routed),
+            "hashed": sorted(plans.keys()), "count": len(plans), "ok": True}
+
+
+def check(fd, ctx, root):
+    path = os.path.join(fd, RECEIPT)
+    try:
+        rec = json.load(open(path, encoding="utf-8"))
+    except Exception:
+        rec = None
+    out = {"file": os.path.relpath(path, root), "tracked": bool(rec), "gate_fresh": False,
+           "verdict": "", "may_generate": True, "plan_gaps": 0, "routed_gaps": [],
+           "routed_csv": "", "spec_moved": "", "model_moved": "", "plans_changed": [],
+           "plans_changed_csv": "", "gated": "", "spec_version": "", "reason": "", "ok": True}
+    if not rec:
+        # Never gated. Not a failure and not a stale plan — an unknown, and the only honest
+        # thing to report about a tree that has not run analyze-plan since this op existed.
+        out["reason"] = ("no .aw-plan-gate.json — this feature has not been through "
+                         "analyze-plan in master mode since the gate began leaving a receipt")
+        return out
+
+    out["gated"] = rec.get("gated", "")
+    out["spec_version"] = rec.get("spec_version", "")
+    # A receipt from before the verdict existed was only ever written on a clean pass.
+    out["verdict"] = rec.get("verdict") or "conformant"
+    out["plan_gaps"] = rec.get("plan_gaps") or 0
+    out["routed_gaps"] = [str(x) for x in (rec.get("routed_gaps") or [])]
+    out["routed_csv"] = "; ".join(out["routed_gaps"])
+
+    # A receipt that hashed nothing for a document has no baseline for it either, so the
+    # question is unanswerable for that one document and says so.
+    spec_base = rec.get("spec_sha") or ""
+    out["spec_moved"] = (spec_base != sha(os.path.join(fd, "spec.md"))) if spec_base else ""
+    # A model recorded as absent that is still absent has not moved. A context that GAINED a
+    # domain model since the gate has moved: check 4 never ran against it — that stays a
+    # move, including for a receipt predating model_sha, because a model nothing has been
+    # checked against is the condition this field exists to catch. Only a receipt carrying
+    # no model_sha with no model on disk either leaves nothing to compare.
+    model_base = rec.get("model_sha")
+    model_now = sha(os.path.join(ctx, "domain-model.md"))
+    out["model_moved"] = ((model_base or "") != model_now
+                          if (model_base is not None or model_now) else "")
+
+    changed = []
+    for name, was in sorted((rec.get("plans") or {}).items()):
+        if sha(os.path.join(fd, name)) != was:
+            changed.append(name)
+    out["plans_changed"] = changed
+    out["plans_changed_csv"] = ", ".join(changed)
+    out["gate_fresh"] = not (out["spec_moved"] or out["model_moved"] or changed)
+    # Moved bytes refuse whatever the verdict was; unmoved bytes refuse only on `gaps`.
+    out["may_generate"] = out["gate_fresh"] and out["verdict"] != "gaps"
+
+    if not out["gate_fresh"]:
+        bits = []
+        if out["spec_moved"]:
+            bits.append("spec.md has changed")
+        if out["model_moved"]:
+            bits.append("domain-model.md has changed")
+        if changed:
+            bits.append("%s changed (a re-derive by `plan main`, or a hand edit)"
+                        % ", ".join(changed))
+        out["reason"] = "since analyze-plan checked them on %s: %s" % (out["gated"],
+                                                                      "; ".join(bits))
+    elif out["verdict"] == "gaps":
+        out["reason"] = ("analyze-plan on %s left %s gap(s) a plan rewrite closes, unrepaired"
+                         % (out["gated"], out["plan_gaps"] or "some"))
+    elif out["verdict"] == "routed-gaps":
+        out["reason"] = ("the spec, the model and every gated plan are byte-identical to what "
+                         "analyze-plan checked on %s; it left %d gap(s) only /appweaver specify "
+                         "can close: %s" % (out["gated"], len(out["routed_gaps"]),
+                                            out["routed_csv"]))
+    else:
+        out["reason"] = ("the spec, the model and every gated plan are byte-identical to what "
+                         "analyze-plan passed on %s" % out["gated"])
+    return out
+
+
+def main():
+    ap = argparse.ArgumentParser(description="the analyze-plan receipt, written and read")
+    sub = ap.add_subparsers(dest="cmd", required=True)
+    for name in ("stamp", "check"):
+        p = sub.add_parser(name)
+        p.add_argument("--feature-dir", required=True)
+        p.add_argument("--context-dir", required=True)
+        p.add_argument("--root", required=True)
+        if name == "stamp":
+            p.add_argument("--spec-version", default="")
+            p.add_argument("--mode", default="master")
+            p.add_argument("--verdict", default="conformant")
+            p.add_argument("--plan-gaps", default="0")
+            p.add_argument("--routed", default="[]")
+    args = ap.parse_args()
+
+    if args.cmd == "stamp":
+        try:
+            routed = json.loads(args.routed or "[]")
+        except Exception:
+            routed = []
+        if not isinstance(routed, list):
+            routed = []
+        out = stamp(args.feature_dir, args.context_dir, args.root, args.spec_version,
+                    args.mode, args.verdict, args.plan_gaps, routed)
+    else:
+        out = check(args.feature_dir, args.context_dir, args.root)
+    sys.stdout.write(json.dumps(out) + "\n")
+
+
+if __name__ == "__main__":
+    main()

package/assets/.appweaver/scripts/python/aw-principles.py

@@ -0,0 +1,108 @@
+#!/usr/bin/env python3
+"""
+aw-principles — enumerate the ratified NON-NEGOTIABLE principles.
+
+WHY A SCRIPT AND NOT A JUDGEMENT. `specify` settles [NEEDS CLARIFICATION] markers by
+asking, and a non-interactive run answers with the FIRST option offered — so an agent's
+option ordering becomes project policy unattended. The gate that checks those answers
+against the constitution has to name the principle it is invoking, and an agent asked to
+both find the principle and judge the contradiction can invent the principle it then
+objects to. Splitting it means the factual half is checkable: this module reads the
+headings and nothing else, the agent judges only whether a settled answer departs from
+one of THESE, and a citation outside the list is visibly wrong.
+
+It also answers "are there any?" deterministically. A project whose constitution ratifies
+no NON-NEGOTIABLE principle has nothing for the gate to check, and `count` is what lets
+the workflow skip it rather than asking an agent to confirm an empty set.
+
+WHAT COUNTS. A principle heading of the form `### <id>. <title> (NON-NEGOTIABLE)`, which
+is what all three constitution templates emit. The id is whatever precedes the first
+period — roman numerals in the domain and technical halves, `UX-`-prefixed in the UI half
+— so a project that renumbers or re-prefixes its series needs no change here.
+
+HTML comments are stripped first. The Sync Impact Report at the top of every constitution
+quotes principle headings while recording what a ratification changed, and counting those
+would report principles that are not in force.
+
+Usage:
+  aw-principles.py list --root <p> [--file <p> ...]
+      -> {files[], missing[], principles[{file, id, title, line}], count, titles_csv, ok}
+
+  Default files are the two halves `specify` loads — constitution.domain.md and
+  constitution.ui.md. The technical half is NOT a default: specify never loads it (a
+  spec is WHAT, not HOW), so a gate there could cite a principle the authoring agent was
+  never shown. A caller that loads it passes --file.
+"""
+
+import argparse
+import json
+import os
+import re
+import sys
+
+DEFAULT_FILES = (".appweaver/memory/constitution.domain.md",
+                 ".appweaver/memory/constitution.ui.md")
+
+# `### XXIII. Clinical Meaning is Bound, Never Free Text (NON-NEGOTIABLE)`
+# `### UX-I. Accessibility Floor (NON-NEGOTIABLE)`
+HEADING = re.compile(r"^###\s+([^.]+)\.\s+(.+?)\s*\(NON-NEGOTIABLE\)\s*$")
+COMMENT = re.compile(r"<!--.*?-->", re.S)
+
+
+def read(path):
+    try:
+        with open(path, encoding="utf-8") as fh:
+            return fh.read()
+    except Exception:
+        return None
+
+
+def principles_in(path, rel):
+    """[{file, id, title, line}] for one constitution half, in document order."""
+    text = read(path)
+    if text is None:
+        return None
+    # Blank the comments rather than deleting them, so reported line numbers still
+    # point at the heading in the file a reader opens.
+    text = COMMENT.sub(lambda m: "\n" * m.group(0).count("\n"), text)
+    out = []
+    for n, line in enumerate(text.split("\n"), 1):
+        m = HEADING.match(line)
+        if m:
+            out.append({"file": rel, "id": m.group(1).strip(),
+                        "title": m.group(2).strip(), "line": n})
+    return out
+
+
+def listing(root, files):
+    seen, missing, found = [], [], []
+    for rel in files:
+        path = rel if os.path.isabs(rel) else os.path.join(root, rel)
+        got = principles_in(path, rel)
+        if got is None:
+            missing.append(rel)
+            continue
+        seen.append(rel)
+        found.extend(got)
+    return {"files": seen, "missing": missing, "principles": found,
+            "count": len(found),
+            "titles_csv": "; ".join("%s (%s %s)" % (p["title"], os.path.basename(p["file"]),
+                                                    p["id"]) for p in found),
+            "ok": True}
+
+
+def main():
+    ap = argparse.ArgumentParser(description="enumerate ratified NON-NEGOTIABLE principles")
+    sub = ap.add_subparsers(dest="cmd", required=True)
+    p = sub.add_parser("list")
+    p.add_argument("--root", required=True)
+    p.add_argument("--file", action="append", default=[],
+                   help="a constitution half to scan (repeatable; defaults to domain + ui)")
+    args = ap.parse_args()
+
+    out = listing(args.root, args.file or list(DEFAULT_FILES))
+    sys.stdout.write(json.dumps(out) + "\n")
+
+
+if __name__ == "__main__":
+    main()

package/assets/.appweaver/scripts/python/aw-stack.py

@@ -917,6 +917,12 @@ def kind_block(repo, lanes, kind):
         kind + "_language": prof.get("language", ""),
         kind + "_ecosystem": prof.get("ecosystem", ""),
         kind + "_title": prof.get("title", "") or lane.get("stack", ""),
+        # Names this stack's AMBIENT scope already defines — C#'s implicit usings, the
+        # browser and TS globals, java.lang, typing. A domain noun that matches one is
+        # not a naming mistake (the plan's names are the ubiquitous language) but it does
+        # have to be written qualified, or the compiler cannot tell the two apart.
+        kind + "_reserved_names": prof.get("reserved_names", []),
+        kind + "_reserved_csv": ", ".join(prof.get("reserved_names", [])),
         kind + "_root": root,
         kind + "_source_path": root,
         kind + "_root_exists": root_on_disk(repo, root),

package/assets/.appweaver/scripts/python/aw-xref.py

@@ -749,6 +749,29 @@ def _referrer_closure(aggregate, bundle_abs):
     return sorted(seen)
 
 
+def _has_code(name, bundle_abs):
+    """Does this aggregate have code on disk yet?
+
+    "Depends on me" and "has code that could break" are different questions, and the
+    closure alone answers only the first. Edges come from the PLAN — a feature that has
+    been planned and not implemented is a genuine dependant with nothing to re-test, and
+    `record` stubs a used sibling's concept when it has none, so its name enters the
+    closure either way. `source_files` is the difference: a stub is written with it empty
+    and implement's concept-upsert fills it from what it generated.
+    """
+    path = _resolve_concept(name, bundle_abs)
+    if not path:
+        return False
+    fm, _ = _read_fm(_read(path))
+    files = fm.get("source_files")
+    if isinstance(files, list):
+        return any(str(f).strip() for f in files)
+    # The front-matter reader returns a BLOCK list as a list and anything else as the raw
+    # scalar, so the `source_files: []` a stub carries arrives as the STRING "[]" — which
+    # is empty, and truthy to anyone who does not look inside it.
+    return bool(str(files or "").strip(" \t[]"))
+
+
 def _concept_title(path):
     fm, _ = _read_fm(_read(path))
     t = fm.get("title") if isinstance(fm.get("title"), str) else ""
@@ -995,15 +1018,30 @@ def cmd_list(args):
     closure = []
     for agg in aggregates:
         closure.extend(c for c in _referrer_closure(agg, bundle_abs) if c not in closure)
+    # THE CLOSURE ANSWERS TWO QUESTIONS AND A CALLER USUALLY WANTS ONE. Edges are read off
+    # the PLAN, so a dependant can be fully planned and hold no code at all. A caller that
+    # re-runs TESTS over the blast radius wants `built`: an unbuilt dependant has nothing
+    # to run, and selecting it turns a fence into a failure over an empty test set. A
+    # caller reporting what this change reaches wants the whole closure, with `unbuilt`
+    # named so nobody reads its absence from a test run as "unaffected".
+    built = [c for c in closure if _has_code(c, bundle_abs)]
+    unbuilt = [c for c in closure if c not in built]
     print(f"[xref] {', '.join(aggregates)}: {len(users)} downstream user(s) "
-          f"— {', '.join(sorted({u['using'] for u in users})) or '(none)'}", file=sys.stderr)
+          f"— {', '.join(sorted({u['using'] for u in users})) or '(none)'}"
+          + (f"; {len(unbuilt)} planned but not implemented — {', '.join(unbuilt)}"
+             if unbuilt else ""), file=sys.stderr)
     _emit({"aggregate": aggregate, "aggregates": aggregates,
            "concept": _rel(path, root) if path else "",
            "users": users, "count": len(users), "impact_report": out_rel, "root": root,
            "referrers": direct, "referrers_csv": ",".join(direct),
            "referrer_closure": closure, "referrer_closure_csv": ",".join(closure),
            "referrer_count": len(direct), "referrer_closure_count": len(closure),
-           "indirect_count": max(0, len(closure) - len(direct))})
+           "indirect_count": max(0, len(closure) - len(direct)),
+           # The closure split by whether the dependant has code yet.
+           "built_closure": built, "built_closure_csv": ",".join(built),
+           "built_count": len(built),
+           "unbuilt_closure": unbuilt, "unbuilt_closure_csv": ",".join(unbuilt),
+           "unbuilt_count": len(unbuilt)})
     return 0
 
 
@@ -1229,15 +1267,39 @@ def cmd_concept_paths(args):
                 missing = [s for s in mapped if s not in existing]
                 scope = "feature"
 
+    # NARROWED TO ONE LANE'S SUBTREES. A concept spans every lane that realises the
+    # aggregate — on a fullstack feature that is the service files AND the web files in
+    # one list. A caller generating one lane must not be handed the other's: `implement`
+    # tells each lane to read the code it is about to extend, and a backend pass shown the
+    # UI's files is being invited to touch a subtree it is forbidden to write. Absent, the
+    # whole list stands, which is what every existing caller wants.
+    under = [u.strip().replace(os.sep, "/").lstrip("./") for u in (args.under or []) if u and u.strip()]
+    under = [u if u.endswith("/") else u + "/" for u in under]
+    scoped_out = 0
+    if under:
+        def inside(p):
+            q = p.replace(os.sep, "/").lstrip("./")
+            return any(q.startswith(u) for u in under)
+        before = len(existing)
+        existing = [p for p in existing if inside(p)]
+        declared = [p for p in declared if inside(p)]
+        missing = [p for p in missing if inside(p)]
+        scoped_out = before - len(existing)
+
     note = "" if path else " — no concept recorded yet"
     drift = f", {len(missing)} declared-but-missing" if missing else ""
-    print(f"[xref] concept-paths {aggregate}: {len(existing)} file(s) on disk{drift}{note}"
+    narrowed = f", {scoped_out} outside {' '.join(under)}" if scoped_out else ""
+    print(f"[xref] concept-paths {aggregate}: {len(existing)} file(s) on disk{drift}{narrowed}{note}"
           f" (scope: {scope})", file=sys.stderr)
     _emit({"aggregate": aggregate, "concept": _rel(path, root) if path else "",
            "found": bool(path), "scope": scope, "paths": existing, "count": len(existing),
            "csv": ",".join(existing), "declared": declared,
            "declared_count": len(declared), "missing": missing,
-           "missing_count": len(missing), "root": root})
+           "missing_count": len(missing), "under": under, "excluded_count": scoped_out,
+           # One block per line, for a prompt that lists what the lane already has.
+           "paths_text": "\n".join("  " + p for p in existing) if existing else
+           "  (none — nothing of this aggregate is on disk in this lane yet)",
+           "root": root})
     return 0
 
 
@@ -1418,6 +1480,70 @@ def _resolve_feature(fd, root):
             "shared_with": shared_with, "shared_with_csv": ", ".join(shared_with)}
 
 
+def _crstate():
+    """aw-crstate, loaded by path — it owns the readers for a change's own documents
+    (`**Aggregates touched**`, the model delta beside the master or in its archive) and
+    duplicating them here is how two answers to one question start to drift."""
+    import importlib.util
+    p = os.path.join(os.path.dirname(os.path.abspath(__file__)), "aw-crstate.py")
+    spec = importlib.util.spec_from_file_location("aw_crstate", p)
+    if not spec or not spec.loader:
+        return None
+    mod = importlib.util.module_from_spec(spec)
+    try:
+        spec.loader.exec_module(mod)
+    except Exception:
+        return None
+    return mod
+
+
+def cmd_co_owners(args):
+    """THE FEATURES THAT SHARE THIS CHANGE'S AGGREGATES — the half of a merge's blast
+    radius that referrer edges cannot see.
+
+    `list` answers "who DEPENDS on this aggregate": features that reach it through a
+    Cross-Reference edge, transitively. That is a real blast radius and it is not the whole
+    one. A feature that CO-OWNS the aggregate holds no edge to it at all — it is not a user
+    of `Encounter`, it is one of the capabilities Encounter is made of, and its code lives
+    in the very files this merge rewrites. `Encounter.cs` is extended by every feature that
+    claims Encounter, so a change to it can break a co-owner without touching one referrer.
+
+    SCOPED TO WHAT THE CHANGE TOUCHES, not to everything the feature owns. The delta's own
+    `**Aggregates touched**` header is the authority: a feature owning Encounter and
+    CareTeam whose change touches only Encounter must not drag CareTeam's co-owners through
+    a regression fence they cannot have been affected by. Where that header cannot be read
+    the feature's owned aggregates stand in — wider than needed, never narrower, and
+    `source` says which answer this is so a caller can report it honestly.
+    """
+    root = _root(args.root)
+    fd = args.feature_dir
+    fd_abs = fd if os.path.isabs(fd) else os.path.join(root, fd)
+    feature = _feature_from_dir(fd_abs)
+    ctx = args.context_dir or os.path.dirname(os.path.normpath(fd_abs))
+
+    touched, source = [], "delta"
+    cs = _crstate() if args.cr else None
+    if cs:
+        touched = sorted(cs.aggregates(cs.model_delta_of(ctx, args.cr)))
+    if not touched:
+        # No readable model delta: a spec-only change, or a header this cannot parse.
+        touched = _resolve_feature(fd_abs, root)["owned"]
+        source = "feature-owned"
+
+    own = {_key(a) for a in touched}
+    features = sorted({v["feature"] for v in _feature_index(root).values()
+                       if _key(v["feature"]) != _key(feature)
+                       and own & {_key(a) for a in v["claims"]}}, key=str.lower)
+
+    print(f"[xref] co-owners {feature}: {len(features)} feature(s) share "
+          f"{', '.join(touched) or '(no aggregate)'} (source: {source})", file=sys.stderr)
+    _emit({"feature": feature, "cr_id": args.cr, "source": source,
+           "aggregates": touched, "aggregates_csv": ", ".join(touched),
+           "features": features, "features_csv": ", ".join(features),
+           "count": len(features), "root": root})
+    return 0
+
+
 def cmd_feature_aggregates(args):
     """WHICH AGGREGATE(S) A FEATURE ACTS ON — the name every command that reads the
     bounded context's domain-model.md needs, because the model is organised by
@@ -1826,10 +1952,21 @@ def main(argv):
     cp = sub.add_parser("concept-paths", help="read-only: the slice's source_files (replaces design-paths)")
     cp.add_argument("--aggregate", default="")
     cp.add_argument("--feature-dir", dest="feature_dir", default="")
+    cp.add_argument("--under", action="append", default=[],
+                    help="keep only paths inside this subtree; repeatable. Omitted, every "
+                         "path the concept records is returned.")
     cp.add_argument("--root", default="")
     cp.add_argument("--bundle", default="knowledge")
     cp.set_defaults(func=cmd_concept_paths)
 
+    cw = sub.add_parser("co-owners", help="read-only: the features that SHARE this change's aggregates (no referrer edge, same files)")
+    cw.add_argument("--cr", default="", help="the change id; its **Aggregates touched** scopes the answer")
+    cw.add_argument("--feature-dir", dest="feature_dir", default="")
+    cw.add_argument("--context-dir", dest="context_dir", default="",
+                    help="the bounded context directory; defaults to the feature dir's parent")
+    cw.add_argument("--root", default="")
+    cw.set_defaults(func=cmd_co_owners)
+
     fa = sub.add_parser("feature-aggregates", help="read-only: the aggregate(s) a feature acts on — spec, then the boundary map, then the feature name")
     fa.add_argument("--feature-dir", dest="feature_dir", default="")
     fa.add_argument("--root", default="")

package/assets/.appweaver/stack-profiles/angular.json

@@ -12,5 +12,31 @@
   "prototype_run": "npm start --prefix prototype",
   "detect": [
     "web/angular.json"
+  ],
+  "reserved_names": [
+    "Array",
+    "Date",
+    "Document",
+    "Element",
+    "Error",
+    "Event",
+    "Headers",
+    "History",
+    "Image",
+    "Location",
+    "Map",
+    "Node",
+    "Notification",
+    "Object",
+    "Option",
+    "Range",
+    "Record",
+    "Request",
+    "Response",
+    "Selection",
+    "Set",
+    "Storage",
+    "Text",
+    "Worker"
   ]
 }

package/assets/.appweaver/stack-profiles/blazor-wasm.json

@@ -13,5 +13,43 @@
   "detect": [
     "web/**/*.csproj",
     "web/**/wwwroot/index.html"
+  ],
+  "reserved_names": [
+    "Activity",
+    "Array",
+    "Attribute",
+    "Buffer",
+    "Comparer",
+    "Convert",
+    "Delegate",
+    "Dictionary",
+    "Directory",
+    "Endpoint",
+    "Environment",
+    "Exception",
+    "File",
+    "Guid",
+    "Index",
+    "List",
+    "Lock",
+    "Math",
+    "Object",
+    "Path",
+    "Progress",
+    "Queue",
+    "Random",
+    "Range",
+    "Results",
+    "Route",
+    "Stack",
+    "Stream",
+    "String",
+    "Task",
+    "Thread",
+    "Timer",
+    "Tuple",
+    "Type",
+    "Uri",
+    "Version"
   ]
 }

package/assets/.appweaver/stack-profiles/dotnet-webapi.json

@@ -12,5 +12,43 @@
   "detect": [
     "*.sln",
     "src/**/*.csproj"
+  ],
+  "reserved_names": [
+    "Activity",
+    "Array",
+    "Attribute",
+    "Buffer",
+    "Comparer",
+    "Convert",
+    "Delegate",
+    "Dictionary",
+    "Directory",
+    "Endpoint",
+    "Environment",
+    "Exception",
+    "File",
+    "Guid",
+    "Index",
+    "List",
+    "Lock",
+    "Math",
+    "Object",
+    "Path",
+    "Progress",
+    "Queue",
+    "Random",
+    "Range",
+    "Results",
+    "Route",
+    "Stack",
+    "Stream",
+    "String",
+    "Task",
+    "Thread",
+    "Timer",
+    "Tuple",
+    "Type",
+    "Uri",
+    "Version"
   ]
 }