aw-spec-cli 0.1.23 → 0.1.25

package/assets/.appweaver/scripts/python/aw-rev-constitution.py

@@ -8,52 +8,50 @@ reverse-engineers that tier from what the code itself evidences, so forward
 development of the SAME codebase runs governed exactly like greenfield (Change
 Requests through the CR delta loop).
 
-CALLER (2026-07-29 onward): the standalone `/appweaver rev-constitution` workflow
-is RETIRED — do not expect that command to exist. The phase now lives in:
-  * `/appweaver onboard` — up front, over the WHOLE repo, before any slice is
-    adopted. It is the ONLY caller of this core (workflow `scripts:` ref, both
-    shells). At onboard time nothing is adopted yet, so `list-adopted` legitimately
-    returns slice_count 0 and draws its context from the OKF bundle instead.
-  * `/appweaver adopt` — per slice, reconciling each provisional principle
-    against that slice's real spec.md/design.md evidence. Adopt does NOT call this
-    core; it reconciles in its own steps.
-
-This core survived the retirement unchanged because it is the MODEL-FREE half: it
-enumerates whatever slices ARE adopted and scaffolds the
-`guardrails/projects/brf-<domain>/` project directory; the calling workflow's authoring
-agents fill its rule files + the split constitution. Governance stance is AS-BUILT
-(the constitution reflects what the code does, not an aspiration — a separate
-modernization/migration workflow drains the debt later).
+CALLER: `/appweaver onboard` is the only caller of this core (workflow `scripts:` ref,
+both shells). The first context to onboard authors the project tier; every later one
+amends it additively from its own code. The standalone
+`/appweaver rev-constitution` workflow is retired, and adopt reconciles in its own
+steps without calling this core.
+
+This core is the MODEL-FREE half: it gathers the project framing the OKF bundle holds
+and scaffolds the `guardrails/projects/brf-<domain>/` project directory; the calling
+workflow's authoring agents fill its rule files + the split constitution. Governance
+stance is AS-BUILT (the constitution reflects what the code does, not an aspiration).
 
 Two subcommands, each printing a single JSON object as the LAST stdout line (so
 the orchestrator's execute_script can bind it); human-readable summaries go to
 STDERR so they never corrupt the JSON contract:
 
-  list-adopted [--root <dir>] [--specs <dir>] [--bundle <dir>]
-      -> the union of adopted artifacts to reverse-engineer FROM. Returns
-         {slices[], slice_count, reverse_count, spec_context[], design_context[],
-          all_context[], project_context[], project_name, overview, platform,
-          backlog, root}. *_context arrays are workspace-relative paths ready for a
-          build_context `context_from:`. The technology (design) side carries the
-          designs + OKF overview + platform note + migration backlog + the per-slice
-          source-maps (the code-coordinate bridge) so the TECHNICAL half is derived from
-          what the code evidences AND cites real code files/types, not the template —
-          including the shared-infra gaps (platform Open Questions) and the as-built debt
-          sink to route unmet template ideals to. Stays domain-agnostic by the author's
-          prompt (cite code paths, ignore the source-map's domain spec-ids / entity names).
+  project-context [--root <dir>] [--bundle <dir>]
+      -> the OKF bundle's project framing. Returns
+         {project_context[], technical_context[], project_name, overview, platform,
+          root}. The *_context arrays are workspace-relative paths ready for a
+          build_context `context_from:`. project_context is the domain side (overview +
+          aggregate index + platform note + bundle index); technical_context is the
+          domain-free side (overview + platform note). Neither carries a feature's
+          spec, model, plan or source-map: onboard's single oracle is the code, and a
+          feature adopted before the tier is authored must not steer project-wide
+          rules. `list-adopted` is the older name for the same subcommand and still
+          works; it answers with this framing and no longer lists features.
 
   project-setup --name <domain> [--fallback <name>] [--root <dir>]
       -> slugify + `brf-` prefix the domain, create guardrails/projects/<slug>/ with its
-         service/ frontend/ domain/ subfolders (guard: refuses to clobber a project that
-         already holds .md files anywhere). Returns
-         {domain_slug, pack_dir, domain_rule_bindings, domain_constitution_source,
-          pack_present}. Both maps sit at the project root; every rule file, the
-          domain charter included, sits in one of the three subfolders.
-          pack_present is the STRING "true"/"false" (so verify_context
-          require_value/condition can gate the anti-clobber guard).
+         service/ frontend/ domain/ subfolders when the project does not exist yet.
+         Without --name, an ACTIVE `brf-` project (.appweaver/domain.json) that already
+         holds rule files wins over the fallback name, so every later context amends the
+         project the first one created even if the bundle's project name has drifted.
+         Returns {domain_slug, pack_dir, domain_rule_bindings, domain_constitution_source,
+          pack_present, domain_present, service_present, frontend_present,
+          domain_files[], service_files[], frontend_files[]}. Both maps sit at the project
+          root; every rule file, the domain charter included, sits in one of the three
+          subfolders. The *_present flags are STRINGS "true"/"false" (so a workflow
+          condition can compare them): pack_present = the project holds any .md file,
+          and each tier flag = that subfolder does. The *_files arrays are the tier's
+          rule files, workspace-relative, ready for a build_context `context_from:`.
          `pack-setup` is the older name for the same subcommand and still works.
 
-Usage: aw-rev-constitution.py <list-adopted|project-setup> [options]
+Usage: aw-rev-constitution.py <project-context|project-setup> [options]
 """
 
 import argparse
@@ -80,8 +78,7 @@ def _emit(obj):
 
 
 def _uniq(seq):
-    """Order-preserving de-dup (context arrays are concatenated from overlapping
-    sources — the OKF overview belongs to several of them)."""
+    """Order-preserving de-dup (a context array can name the same bundle file twice)."""
     seen, out = set(), []
     for x in seq:
         if x and x not in seen:
@@ -109,52 +106,12 @@ def _project_name(overview_abs):
     return b.group(1).strip() if b else ""
 
 
-# ─────────────────────────────── list-adopted ──────────────────────────────
-def cmd_list_adopted(args):
+# ────────────────────────────── project-context ────────────────────────────
+def cmd_project_context(args):
     root = _root(args.root)
-    specs_dir = os.path.join(root, args.specs)
     bundle_dir = os.path.join(root, args.bundle)
 
-    slices = []
-    spec_context = []
-    design_context = []
-    source_maps = []
-    reverse_count = 0
-
-    if os.path.isdir(specs_dir):
-        for name in sorted(os.listdir(specs_dir)):
-            sdir = os.path.join(specs_dir, name)
-            if not os.path.isdir(sdir):
-                continue
-            spec = os.path.join(sdir, "spec.md")
-            design = os.path.join(sdir, "design.md")
-            # A slice is adoptable-governance input only when BOTH docs exist.
-            if not (os.path.isfile(spec) and os.path.isfile(design)):
-                continue
-            smap = os.path.join(sdir, "source-map.md")
-            is_reverse = False
-            try:
-                with open(spec, "r", encoding="utf-8", errors="replace") as fh:
-                    head = fh.read(4096)
-                if re.search(r"reverse-engineered", head, re.IGNORECASE):
-                    is_reverse = True
-            except OSError:
-                pass
-            if is_reverse:
-                reverse_count += 1
-            slices.append({
-                "name": name,
-                "spec": _rel(spec, root),
-                "design": _rel(design, root),
-                "source_map": _rel(smap, root) if os.path.isfile(smap) else "",
-                "origin": "reverse-engineered" if is_reverse else "unknown",
-            })
-            spec_context.append(_rel(spec, root))
-            design_context.append(_rel(design, root))
-            if os.path.isfile(smap):
-                source_maps.append(_rel(smap, root))
-
-    # The OKF architecture overview names the actual tech stack (technology half input).
+    # The OKF architecture overview names the actual tech stack.
     overview = ""
     overview_abs = ""
     for cand in ("architecture/overview.md", "architecture/architecture.md"):
@@ -164,26 +121,18 @@ def cmd_list_adopted(args):
             overview_abs = p
             break
 
-    # TECHNICAL evidence beyond the overview, both domain-free: the shared-platform note
-    # (cross-cutting persistence / tenancy / concurrency reality — incl. its Open Questions,
-    # e.g. tenancy may be inactive) and the migration backlog (the as-built DEBT SINK the
-    # technical author routes any unmet template ideal / stub to, instead of asserting it).
-    # These feed the DESIGN side so the technical half is EVIDENCE-FIRST, not template-first.
+    # The shared-platform note: cross-cutting persistence / tenancy / concurrency as
+    # built, including its Open Questions (tenancy may be inactive). Domain-free, so it
+    # is technical evidence as well as project framing.
     platform_ref = ""
     p = os.path.join(bundle_dir, "architecture/platform.md")
     if os.path.isfile(p):
         platform_ref = _rel(p, root)
-    backlog_ref = ""
-    p = os.path.join(bundle_dir, "migration-backlog.md")
-    if os.path.isfile(p):
-        backlog_ref = _rel(p, root)
-
-    # Project-level OKF framing — the PROJECT AS A WHOLE, not just one adopted slice:
-    # the overview (mission + aggregate map + external refs + stack), the aggregate
-    # index (bounded-context map), and the shared-platform note. These are what let the
-    # DOMAIN author write a project charter instead of a single-aggregate spec. The
-    # technical half deliberately does NOT get the aggregate index or specs (stays
-    # domain-free); it DOES get platform.md + the backlog as technical evidence (below).
+
+    # The PROJECT AS A WHOLE: the overview (mission + aggregate map + external refs +
+    # stack), the aggregate index (bounded-context map), the shared-platform note and
+    # the bundle index. This is what lets the DOMAIN author write a project charter
+    # instead of a single-aggregate spec.
     project_context = [overview] if overview else []
     for cand in ("aggregates/index.md", "architecture/platform.md", "index.md"):
         p = os.path.join(bundle_dir, cand)
@@ -191,51 +140,28 @@ def cmd_list_adopted(args):
             project_context.append(_rel(p, root))
     project_context = _uniq(project_context)
 
+    # The technical half gets the stack and the platform note and nothing domain-bearing:
+    # no aggregate index, so it stays domain-agnostic.
+    technical_context = _uniq([overview, platform_ref])
+
     # The display name of the whole project the governance tier governs (from the OKF
     # overview), so the project + constitution are named + titled after the PROJECT — not the
     # outer tooling folder the CWD-basename fallback would pick.
     project_name = _project_name(overview_abs)
 
-    # spec side = domain input (specs + source-maps + PROJECT framing); design side =
-    # technology input (designs + OKF stack overview + shared-platform note + as-built
-    # backlog + the per-slice source-maps — the code-coordinate bridge, so the TECHNICAL
-    # half anchors each principle to a real code file/type, not just a design section;
-    # kept domain-agnostic by the author's prompt discipline, not by starving it of the
-    # code map — rich enough to DERIVE the principle set from evidence and route unmet
-    # ideals to debt); all = the rule-set author's full picture.
-    spec_side = _uniq(spec_context + source_maps + project_context)
-    design_side = _uniq(
-        design_context
-        + source_maps
-        + ([overview] if overview else [])
-        + ([platform_ref] if platform_ref else [])
-        + ([backlog_ref] if backlog_ref else [])
-    )
-    all_context = _uniq(spec_context + design_context + source_maps + project_context)
-
     result = {
-        "slices": slices,
-        "slice_count": len(slices),
-        "reverse_count": reverse_count,
-        "spec_context": spec_side,
-        "design_context": design_side,
-        "all_context": all_context,
         "project_context": project_context,
+        "technical_context": technical_context,
         "project_name": project_name,
         "overview": overview,
         "platform": platform_ref,
-        "backlog": backlog_ref,
         "root": root,
     }
 
-    names = ", ".join(s["name"] for s in slices) or "(none)"
     print(
-        f"[govern-backward] adopted slices: {len(slices)} "
-        f"({reverse_count} reverse-engineered) — {names}\n"
-        f"                   project: {project_name or '(unknown — no OKF overview)'}  "
-        f"overview: {overview or '(none — no OKF bundle)'}\n"
-        f"                   technical evidence: platform={platform_ref or '(none)'}  "
-        f"backlog={backlog_ref or '(none)'}",
+        f"[govern-backward] project: {project_name or '(unknown — no OKF overview)'}  "
+        f"overview: {overview or '(none — no OKF bundle)'}  "
+        f"platform: {platform_ref or '(none)'}",
         file=sys.stderr,
     )
     _emit(result)
@@ -250,9 +176,34 @@ def _slugify(name):
     return s
 
 
+def _md_files(d, root):
+    """The .md files under one tier folder, workspace-relative and sorted."""
+    out = []
+    if os.path.isdir(d):
+        for dp, _, fs in os.walk(d):
+            out.extend(_rel(os.path.join(dp, f), root) for f in fs if f.endswith(".md"))
+    return sorted(out)
+
+
+def _active_brf_project(root):
+    """The active project from .appweaver/domain.json when it is a brownfield (`brf-`)
+    project that already holds rule files, else "". A greenfield project the workspace
+    happens to be bound to is never taken over."""
+    try:
+        with open(os.path.join(root, ".appweaver", "domain.json"), encoding="utf-8") as fh:
+            name = (json.load(fh).get("domain") or "").strip()
+    except (OSError, ValueError, AttributeError):
+        return ""
+    if not name.startswith("brf-"):
+        return ""
+    d = os.path.join(root, "guardrails", "projects", name)
+    return name if _md_files(d, root) else ""
+
+
 def cmd_pack_setup(args):
     root = _root(args.root)
-    raw = args.name if (args.name and args.name.strip()) else args.fallback
+    active = "" if (args.name and args.name.strip()) else _active_brf_project(root)
+    raw = args.name if (args.name and args.name.strip()) else (active or args.fallback)
     if not raw or not raw.strip():
         # Last-resort fallback: the component/repo directory name.
         raw = os.path.basename(root.rstrip(os.sep)) or "domain"
@@ -264,16 +215,17 @@ def cmd_pack_setup(args):
     domain_slug = "brf-" + slug
 
     pack_dir = os.path.join(root, "guardrails", "projects", domain_slug)
-    # Anti-clobber guard: a project that already holds curated .md files is not ours
-    # to overwrite (mirrors inventory's bundle_guard). pack_present drives the gate.
-    # The walk covers the whole subtree, because a project's rule files live in its
-    # service/ frontend/ domain/ subfolders and only the two maps sit at its root.
-    present = False
-    if os.path.isdir(pack_dir):
-        present = any(f.endswith(".md") for _, _, fs in os.walk(pack_dir) for f in fs)
-    if not present:
-        for sub in ("service", "frontend", "domain"):
-            os.makedirs(os.path.join(pack_dir, sub), exist_ok=True)
+    # A project that already holds .md files was authored by an earlier context: the
+    # calling workflow AMENDS it rather than authoring it again. The walk covers the
+    # whole subtree, because a project's rule files live in its service/ frontend/
+    # domain/ subfolders and only the two maps sit at its root. Each tier is reported
+    # on its own, so a lane declared after the first onboard is authored in full while
+    # the tiers that exist are amended.
+    tiers = {sub: _md_files(os.path.join(pack_dir, sub), root)
+             for sub in ("domain", "service", "frontend")}
+    present = bool(_md_files(pack_dir, root))
+    for sub in ("service", "frontend", "domain"):
+        os.makedirs(os.path.join(pack_dir, sub), exist_ok=True)
 
     result = {
         "domain_slug": domain_slug,
@@ -287,11 +239,17 @@ def cmd_pack_setup(args):
             os.path.join(pack_dir, "domain", "domain-constitution.md"), root
         ),
         "pack_present": "true" if present else "false",
+        "domain_present": "true" if tiers["domain"] else "false",
+        "service_present": "true" if tiers["service"] else "false",
+        "frontend_present": "true" if tiers["frontend"] else "false",
+        "domain_files": tiers["domain"],
+        "service_files": tiers["service"],
+        "frontend_files": tiers["frontend"],
         "root": root,
     }
     print(
         f"[govern-backward] project: guardrails/projects/{domain_slug}/ "
-        f"({'EXISTS — guarded' if present else 'created'})",
+        f"({'EXISTS — ' + ', '.join(f'{k} {len(v)}' for k, v in tiers.items()) if present else 'created'})",
         file=sys.stderr,
     )
     _emit(result)
@@ -302,11 +260,14 @@ def main(argv):
     ap = argparse.ArgumentParser(prog="aw-rev-constitution.py", add_help=True)
     sub = ap.add_subparsers(dest="cmd")
 
-    la = sub.add_parser("list-adopted", help="enumerate adopted slices to reverse-engineer from")
-    la.add_argument("--root", default="")
-    la.add_argument("--specs", default="specs")
-    la.add_argument("--bundle", default="knowledge")
-    la.set_defaults(func=cmd_list_adopted)
+    # `list-adopted` is the older name, kept so a caller written against it still runs.
+    # It also still accepts `--specs`, which nothing reads now.
+    for name in ("project-context", "list-adopted"):
+        pc = sub.add_parser(name, help="the OKF bundle's project framing for the governance authors")
+        pc.add_argument("--root", default="")
+        pc.add_argument("--bundle", default="knowledge")
+        pc.add_argument("--specs", default="specs", help=argparse.SUPPRESS)
+        pc.set_defaults(func=cmd_project_context)
 
     # `pack-setup` is the name this subcommand shipped under and is kept as an alias:
     # the folder it creates is a PROJECT, so the primary name says so, and a caller

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

@@ -9,7 +9,8 @@ powershell twin so the two stay in parity by construction rather than by review:
     detect    match the repo's own files against those profiles — the BROWNFIELD
               candidate list, since an existing repo already answered the question
     declare   upsert a lane into .appweaver/stacks.json — THE SOLE WRITER
-    resolve   read .appweaver/stacks.json — for every downstream reader
+    resolve   read .appweaver/stacks.json — for every downstream reader; with
+              --feature-dir, narrowed to the lanes that feature has a surface in
     verify    is the declaration USABLE for the phase about to run — the gate
     run-phase run a phase's command for EVERY declared lane, not just the first
     probe     is there evidence of a lane of this kind — read-only, never fatal
@@ -964,8 +965,47 @@ def lane_options(repo, lanes):
     return out
 
 
+def feature_lanes(repo, feature_dir):
+    """The lane kinds a FEATURE has a surface in, or None when it records none.
+
+    A repo declares its lanes once, in stacks.json; a feature inside it may still own no
+    part of one lane's surface — a job-only or shared-kernel slice in a repo that also has
+    a UI. adopt records that fact as `lanes` in the feature's active_version.json (written
+    by `feature-lanes`), and this reads it back. None — no feature named, no file, or no
+    record — means the feature follows every declared lane, which is the ordinary case.
+    """
+    if not feature_dir:
+        return None
+    fd = feature_dir if os.path.isabs(feature_dir) else os.path.join(repo, feature_dir)
+    try:
+        with open(os.path.join(fd, "active_version.json"), encoding="utf-8") as fh:
+            recorded = json.load(fh).get("lanes")
+    except (OSError, ValueError, AttributeError):
+        return None
+    if not isinstance(recorded, list) or not recorded:
+        return None
+    return [k for k in ("backend", "frontend") if k in recorded]
+
+
+def apply_feature_lanes(payload, kinds):
+    """Narrow the per-kind `<kind>_declared` flags to the lanes a feature has a surface in.
+
+    Only the per-kind flags move. `declared`, `lanes` and `kinds` stay the REPO's answer, so
+    a gate that asks "is anything declared at all" still reads stacks.json, while every
+    step that plans, gates or builds one lane reads the flag and skips a lane this feature
+    does not own. `<kind>_feature_excluded` says which case a false flag is.
+    """
+    payload["feature_lanes"] = list(kinds or [])
+    for kind in ("backend", "frontend"):
+        excluded = bool(kinds is not None and payload.get(kind + "_declared") and kind not in kinds)
+        payload[kind + "_feature_excluded"] = excluded
+        if excluded:
+            payload[kind + "_declared"] = False
+
+
 def cmd_resolve(args):
     data = read_stacks(args.repo)
+    fl = feature_lanes(args.repo, getattr(args, "feature_dir", ""))
 
     # Absence is a valid state for READING, never a failure: `resolve` reports what
     # is there and lets the caller decide. It is `verify` that turns an absent or
@@ -982,6 +1022,7 @@ def cmd_resolve(args):
         }
         payload.update(kind_block(args.repo, [], "backend"))
         payload.update(kind_block(args.repo, [], "frontend"))
+        apply_feature_lanes(payload, fl)
         emit(payload)
         return
 
@@ -1022,6 +1063,7 @@ def cmd_resolve(args):
     }
     payload.update(kind_block(args.repo, lanes, "backend"))
     payload.update(kind_block(args.repo, lanes, "frontend"))
+    apply_feature_lanes(payload, fl)
     emit(payload)
 
 
@@ -1447,6 +1489,8 @@ def main():
     p = sub.add_parser("resolve", help="read stacks.json")
     p.add_argument("--kind", choices=["backend", "frontend"])
     p.add_argument("--id")
+    p.add_argument("--feature-dir", dest="feature_dir", default="",
+                   help="report a lane this feature records no surface in as not declared")
     p.set_defaults(func=cmd_resolve)
 
     p = sub.add_parser("verify", help="is the declaration usable for the phase about to run")

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

@@ -451,7 +451,7 @@ def _read_fm(text):
 
 def _render_fm(fm):
     order = ["type", "title", "description", "origin", "bounded_context", "features",
-             "source_files", "ui_source_files"]
+             "adopted_features", "source_files", "ui_source_files"]
     keys = [k for k in order if k in fm] + [k for k in fm if k not in order]
     out = ["---"]
     for k in keys:
@@ -1544,6 +1544,66 @@ def cmd_co_owners(args):
     return 0
 
 
+def _map_features(root):
+    """(features, commit) from the confirmed boundary map — ([], "") where there is none."""
+    try:
+        with open(os.path.join(root, ".appweaver", "inventory", "feature-map.json"),
+                  encoding="utf-8") as fh:
+            m = json.load(fh)
+    except (OSError, ValueError):
+        return [], ""
+    return (m.get("features") or []), (m.get("commit") or "")
+
+
+def _operation_scope(root, feature, siblings):
+    """The operations the boundary map gives this feature, and the ones it gives ONLY to a
+    sibling feature over the same aggregate.
+
+    A feature is a capability scope the developer confirmed in the map, and two features
+    over one aggregate share its code: every file of Encounter serves RecordEncounter and
+    AmendEncounter alike. The operation list is what tells their scopes apart. A read both
+    features call (GetEncounter) is in both lists, so it is this feature's too and never a
+    sibling's alone."""
+    mapped, commit = _map_features(root)
+    by = {_key(f.get("feature")): [o for o in dict.fromkeys(f.get("operations") or []) if o]
+          for f in mapped}
+    mine = by.get(_key(feature), [])
+    others = {}
+    for s in siblings:
+        only = [o for o in by.get(_key(s), []) if o not in mine]
+        if only:
+            others[s] = only
+    return mine, others, commit
+
+
+def _operations_note(mine, others):
+    """One prompt-ready line: this feature's operations and the ones that are not its own."""
+    if not mine:
+        return ("The boundary map records no operation list for this feature: scope its user "
+                "stories by the feature itself, and treat an operation whose folder or name "
+                "belongs to another feature as that feature's.")
+    line = "This feature's operations (the confirmed boundary map): %s." % ", ".join(mine)
+    if others:
+        line += (" Operations that belong ONLY to another feature over the same aggregate — "
+                 "not this feature's: %s." % "; ".join(
+                     "%s → %s" % (s, ", ".join(ops)) for s, ops in others.items()))
+    else:
+        line += " No other feature over the same aggregate owns an operation of its own."
+    return line
+
+
+def _commit_time(root, commit):
+    """The ISO commit time of the inventory's baseline, or "" when git cannot resolve it."""
+    if not commit:
+        return ""
+    try:
+        r = subprocess.run(["git", "-C", root, "show", "-s", "--format=%cI", commit],
+                           capture_output=True, text=True, timeout=10)
+    except (OSError, subprocess.SubprocessError):
+        return ""
+    return r.stdout.strip() if r.returncode == 0 else ""
+
+
 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
@@ -1572,6 +1632,12 @@ def cmd_feature_aggregates(args):
     those aggregates — the 1:1 case, even where the spec also names an aggregate it
     merely touches — and otherwise every aggregate it names.
 
+    It also carries what adopt needs to scope a reverse to the feature rather than to its
+    aggregate: `operations` (this feature's, from the boundary map), `sibling_operations`
+    (those only another feature over the same aggregate owns), `operations_note` (both as
+    one prompt-ready line), and the inventory baseline the map was drawn at
+    (`baseline_commit`, `baseline_time` — "" where git cannot resolve it).
+
     STRICTLY READ-ONLY and never empty: source 3 always answers, so a caller never has
     to branch on a missing result."""
     root = _root(args.root)
@@ -1580,8 +1646,13 @@ def cmd_feature_aggregates(args):
         _emit({"error": "feature-dir-required", "root": root})
         return 2
     r = _resolve_feature(args.feature_dir, root)
+    mine, others, commit = _operation_scope(root, r["feature"], r["shared_with"])
+    r.update({"operations": mine, "operations_csv": ", ".join(mine),
+              "sibling_operations": others,
+              "operations_note": _operations_note(mine, others),
+              "baseline_commit": commit, "baseline_time": _commit_time(root, commit)})
     print(f"[xref] feature-aggregates {r['feature']}: acts on {r['aggregates_csv']} "
-          f"(from {r['source']}); owns {r['owned_csv']}", file=sys.stderr)
+          f"(from {r['source']}); owns {r['owned_csv']}; {len(mine)} operation(s)", file=sys.stderr)
     r["root"] = root
     _emit(r)
     return 0

package/assets/.appweaver/scripts/python/validate_okf.py

@@ -14,7 +14,9 @@ ERRORS (bundle is non-conformant):
       - log.md date headings not in ISO 8601 YYYY-MM-DD form (§7)
   E4  log.md date block missing a required `Commit: \\`<sha>\\`` line, or
       the line is present but not a valid hex commit SHA. This is an
-      ERROR because /speckit.okf.update depends on it to resume.
+      ERROR because the commit is what anchors each journal entry to the
+      code it describes (OKF §7) — an entry without one cannot be dated
+      against the history.
 
 WARNINGS (consumers must tolerate; reported for quality):
   W0  PyYAML not installed — using the lenient fallback parser.
@@ -23,11 +25,13 @@ WARNINGS (consumers must tolerate; reported for quality):
   W3  Directory containing concepts but no index.md.
   W4  Concept body is empty.
   W5  Possible secret-looking string in a file.
-  W6  A `source_files` / `ui_source_files` entry does not exist on disk (may be pending
-      reconciliation by /speckit.okf.update).
+  W6  A `source_files` / `ui_source_files` entry does not exist on disk (the code
+      moved or was removed since the concept was written; analyze-slice reports it
+      as stale_source_files, and nothing removes it for you — edit the concept).
   W7  Possible duplicate concept: another file shares the same
       `type` + `title`.
-  W8  Concept has unresolved `open_questions` (run /speckit.okf.clarify).
+  W8  Concept has unresolved `open_questions` (/appweaver adopt resolves the
+      ones its reverse answers; the rest are answered by hand).
 
 Usage: validate_okf.py <bundle_dir> [--config PATH] [--exclude GLOB]...
                         [--repo-root PATH] [--json]
@@ -169,7 +173,8 @@ def check_open_questions(data: dict, rel: str):
         n = len(pending)
         warnings.append(
             f"W8 {rel}: {n} unresolved open question{'s' if n != 1 else ''} "
-            f"— run /speckit.okf.clarify"
+            f"— /appweaver adopt of a feature acting on it resolves those its "
+            f"reverse answers; answer the rest by hand"
         )
 
 

package/assets/.appweaver/templates/okf-concept-template.md

@@ -5,14 +5,19 @@ description: [one line — what this aggregate is and the invariant/boundary it
 origin: greenfield
 bounded_context:
 features:
+adopted_features:
 source_files:
 ui_source_files:
 ---
 
 <!--
   OKF CONCEPT  —  one aggregate's node in the shared knowledge bundle.
-  Canonical home: knowledge/<slug>/<slug>.md  (dir also holds an index.md; the bundle
-  root holds index.md with okf_version + an optional log.md change journal).
+  Where it lives: implement and adopt create a new concept at knowledge/<slug>/<slug>.md
+  (the dir also holds an index.md); onboard writes a bounded context's concepts under
+  knowledge/aggregates/, beside the aggregates/index.md context map. Every reader finds a
+  concept by walking the bundle for its `type` + `title`, never by its folder, so a
+  concept is never moved to match either layout. The bundle root holds index.md with
+  okf_version + an optional log.md change journal.
 
   This single bundle is the OKF knowledge tier for BOTH pipelines:
     • greenfield — `implement` authors this concept (frontmatter + Overview + Depends-On)
@@ -23,6 +28,9 @@ ui_source_files:
   developer chose; it may act on several aggregates, and several features may act on
   one. `features:` lists every feature known to act on this aggregate — implement and
   adopt add their feature, and a feature is never removed from it by a later write.
+  `adopted_features:` lists the ones among them that `adopt` has deep-reversed from the
+  code; a feature in `features:` and not here is still only the discovery stub onboard
+  wrote. Empty on a greenfield concept, where nothing was reversed.
   `bounded_context:` names the context the aggregate belongs to.
 
   WHO WRITES WHAT (do not cross these lanes):