@blxzer/cursor-trellis 0.4.2 → 0.4.3

package/dist/templates/trellis/scripts/common/task_gates.py

@@ -26,6 +26,7 @@ from .task_map import (
     validate_child_archive_state,
     validate_parent_children_complete,
 )
+from .full_quality import full_quality_archive_errors, rigor_from_required_controls
 
 SCHEMA_VERSION = 1
 BASELINE_GATE = "baseline-check"
@@ -182,13 +183,45 @@ def normalize_result(result: str) -> str:
     return result.strip().upper()
 
 
+def wave_c_stop_read_confirmed(start: Path | None = None) -> bool:
+    """Return True after ``cstl update`` wrote the Wave C confirm flag.
+
+    Unconfirmed projects keep leftover dual-read. Missing ``.cstl`` is
+    unconfirmed (unit fixtures without a repo root stay dual-read).
+    """
+    from .paths import DIR_WORKFLOW, get_repo_root
+
+    root = get_repo_root(start)
+    path = root / DIR_WORKFLOW / ".p36-wave-c.json"
+    if not path.is_file():
+        return False
+    try:
+        parsed = json.loads(path.read_text(encoding="utf-8"))
+    except (OSError, json.JSONDecodeError):
+        return False
+    return isinstance(parsed, dict) and parsed.get("confirmed") is True
+
+
 def task_closeout_profile(task_dir: Path, task_data: dict | None = None) -> str:
-    """Return lite, full, or parent closeout profile."""
+    """Return lite, full, or parent closeout profile.
+
+    New Tasks use persisted ``required_controls`` / Topology only. Missing
+    contract is explicit Lite. File existence and ``children[]`` are not
+    used to infer Rigor or Parent. Leftover kind/mode/classification are
+    dual-read only until Wave C is confirmed.
+    """
     data = task_data or {}
-    child_names = data.get("children")
-    if isinstance(child_names, list) and any(isinstance(name, str) for name in child_names):
+    topology = data.get("topology") if isinstance(data.get("topology"), dict) else {}
+    if topology.get("kind") == "parent-child":
         return "parent"
 
+    persisted = rigor_from_required_controls(data)
+    if persisted in ("lite", "full"):
+        return persisted
+
+    if wave_c_stop_read_confirmed(task_dir):
+        return "lite"
+
     meta = data.get("meta") if isinstance(data.get("meta"), dict) else {}
     candidates = [
         data.get("task_kind"),
@@ -200,8 +233,6 @@ def task_closeout_profile(task_dir: Path, task_data: dict | None = None) -> str:
         meta.get("classification"),
         meta.get("mode"),
     ]
-
-    explicit_lite = False
     for value in candidates:
         if not isinstance(value, str):
             continue
@@ -211,13 +242,8 @@ def task_closeout_profile(task_dir: Path, task_data: dict | None = None) -> str:
         if "full" in normalized:
             return "full"
         if "lite" in normalized:
-            explicit_lite = True
-
-    if explicit_lite:
-        return "lite"
+            return "lite"
 
-    if (task_dir / "design.md").is_file() and (task_dir / "implement.md").is_file():
-        return "full"
     return "lite"
 
 
@@ -478,7 +504,12 @@ def make_baseline_record(
 
 
 def write_gate_record(task_data: dict, transition: str, gate: str, record: dict) -> None:
-    """Write a gate record into task_data in-place."""
+    """Write a gate record into task_data in-place.
+
+    This mutates memory only. Stage 2 persists `quality_gate_results` as a
+    Kernel Command projection (same command as `record-gate` / start / archive).
+    Do not treat this helper as an independent `task.json` writer.
+    """
     qgr = task_data.get("quality_gate_results")
     if not isinstance(qgr, dict):
         qgr = {}
@@ -499,6 +530,35 @@ def write_gate_record(task_data: dict, transition: str, gate: str, record: dict)
     transition_records[gate] = record
 
 
+KERNEL_PROJECTION_EXTRA_KEYS = (
+    "quality_gate_results",
+    "execution_approval",
+    "required_controls",
+    "ac_evidence_ledger",
+    "independent_check",
+    "topology",
+    "dependency_graph",
+    "ondemand_modules",
+    "depends_on",
+    "dependency_satisfied",
+    "decompose_proposal",
+    "profile_health",
+    "event_bridge",
+    "middleware_providers",
+    "capability_router",
+    "required_capabilities",
+)
+
+
+def collect_kernel_projection_extras(task_data: dict) -> dict:
+    """Non-canonical task.json fields owned by the same Kernel Command."""
+    extras: dict = {}
+    for key in KERNEL_PROJECTION_EXTRA_KEYS:
+        if key in task_data:
+            extras[key] = task_data[key]
+    return extras
+
+
 def build_reviewer_gate_record(
     task_dir: Path,
     task_data: dict,
@@ -998,6 +1058,7 @@ def validate_archive(
 
     errors.extend(_required_file_errors(task_dir, ["verify.md"]))
     errors.extend(_verify_evidence_errors(task_dir, task_data))
+    errors.extend(full_quality_archive_errors(task_dir, task_data))
 
     parent_name = task_data.get("parent")
     if isinstance(parent_name, str) and parent_name:

package/dist/templates/trellis/scripts/common/task_map.py

@@ -2,8 +2,10 @@
 """
 Parent/Child task-map helpers.
 
-task-map.md is the Parent Supervisor's orchestration authority. This module
-parses and writes only the small YAML frontmatter subset generated here.
+task-map.md is a projection of the Kernel Topology / Dependency Graph plus
+Parent orchestration fields (child worker state, event log). Graph authority
+is Kernel extras (`topology`, `dependency_graph`); this module may render,
+not invent, typed edges.
 """
 
 from __future__ import annotations
@@ -75,7 +77,7 @@ def ensure_task_map(
         data = {
             "parent_id": parent_data.get("id") or parent_dir.name,
             "contract_epoch": 1,
-            "execution_topology": "serial",
+            "execution_topology": "parallel",
             "merge_limit": 1,
             "children": [],
             "stages": [],
@@ -85,7 +87,7 @@ def ensure_task_map(
 
     data.setdefault("parent_id", parent_data.get("id") or parent_dir.name)
     data.setdefault("contract_epoch", 1)
-    data.setdefault("execution_topology", "serial")
+    data.setdefault("execution_topology", "parallel")
     data.setdefault("merge_limit", 1)
     data.setdefault("children", [])
     data.setdefault("stages", [])
@@ -102,6 +104,16 @@ def ensure_task_map(
             data["children"].append(child)
             existing[child_name] = child
 
+    extras = {
+        key: parent_data[key]
+        for key in ("topology", "dependency_graph")
+        if key in parent_data
+    }
+    if extras:
+        from .ondemand_topology import apply_kernel_graph_projection
+
+        apply_kernel_graph_projection(data, extras)
+
     write_task_map(parent_dir, data, body, event)
     return data
 
@@ -492,12 +504,21 @@ def _default_body() -> str:
     return (
         "# Task Map\n\n"
         "## Orchestration notes\n\n"
-        "- `execution_topology: parallel` — children with empty `depends_on` may run concurrently; "
-        "Parent integrates serially up to `merge_limit`.\n"
+        "- **parallel-first:** Prefer Cursor Multitask / Build in Parallel / Agent `Task` / native "
+        "worktree. Trellis does not schedule workers or replace Multitask.\n"
+        "- `execution_topology: parallel` — default when ≥2 children have empty `depends_on`. "
+        "Parent `integrate-child`, HITL, `start-execution --approved`, and reviewer gates stay "
+        "serial (`merge_limit`).\n"
+        "- `serial_reason` — required when topology is `serial`. One of: shared write-set / "
+        "HITL or reviewer gate / `depends_on` unmet / user asked serial / conflict surface "
+        "cannot isolate.\n"
+        "- `stages:` (or `parallel_groups`) — concurrently runnable child id groups.\n"
+        "- `merge_points` — where serial join happens (usually `integrate-child` + gates). "
+        "Default `merge_limit: 1`.\n"
+        "- `touches` (or `conflict_surface`) — write-sets that can collide; declare before dispatch.\n"
         "- Child-reported states: `open` → `working` → `blocked` | `review`.\n"
         "- Parent-controlled states: `review` → `changes` | `accepted` → `integrating` → "
         "`integrated` | `cancelled`.\n"
-        "- Declare `touches` per child before dispatch to reduce merge conflicts.\n"
         "- `isolation: git-worktree` — run `prepare-child-worktree` from the **git package root** "
         "(not a non-git harness root).\n\n"
         "## Event Log\n\n"
@@ -594,10 +615,22 @@ def _format_frontmatter(data: dict) -> str:
     lines = [
         f"parent_id: {_format_value(data.get('parent_id'))}",
         f"contract_epoch: {_format_value(data.get('contract_epoch', 1))}",
-        f"execution_topology: {_format_value(data.get('execution_topology', 'serial'))}",
+        f"execution_topology: {_format_value(data.get('execution_topology', 'parallel'))}",
         f"merge_limit: {_format_value(data.get('merge_limit', 1))}",
-        "children:",
     ]
+    if data.get("serial_reason"):
+        lines.append(f"serial_reason: {_format_value(data.get('serial_reason'))}")
+    if data.get("parallel_groups"):
+        lines.append(f"parallel_groups: {_format_value(data.get('parallel_groups'))}")
+    if data.get("merge_points"):
+        lines.append(f"merge_points: {_format_value(data.get('merge_points'))}")
+    if data.get("conflict_surface"):
+        lines.append(f"conflict_surface: {_format_value(data.get('conflict_surface'))}")
+    if data.get("graph_authority"):
+        lines.append(f"graph_authority: {_format_value(data.get('graph_authority'))}")
+    if data.get("topology_kind"):
+        lines.append(f"topology_kind: {_format_value(data.get('topology_kind'))}")
+    lines.append("children:")
     children = data.get("children", [])
     if isinstance(children, list):
         for child in children: