@blxzer/cursor-trellis 0.3.5 → 0.4.0

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

@@ -1,4 +1,4 @@
-#!/usr/bin/env python3
+#!/usr/bin/env python
 """
 Task quality gate helpers.
 
@@ -15,6 +15,11 @@ from dataclasses import dataclass, field
 from datetime import datetime, timezone
 from pathlib import Path
 
+from .task_dependencies import (
+    describe_dependencies,
+    read_depends_mode,
+    scope_children_for_task,
+)
 from .task_map import (
     get_child_state,
     load_task_map,
@@ -144,6 +149,7 @@ STABLE_TASK_KEYS = (
     "kind",
     "mode",
     "contract_epoch",
+    "depends_on",
 )
 
 
@@ -161,6 +167,7 @@ class GateGuardResult:
     is_full_task: bool = False
     closeout_profile: str = "lite"
     auto_gate_records: dict[str, dict] = field(default_factory=dict)
+    deps_blocking_summary: list[str] = field(default_factory=list)
 
 
 def utc_now() -> str:
@@ -610,8 +617,19 @@ def validate_start_execution(
     task_dir: Path,
     task_data: dict | None,
     approved: bool,
+    *,
+    ignore_deps: bool = False,
+    enforce_deps_block: bool = False,
 ) -> GateGuardResult:
-    """Validate start-execution readiness."""
+    """Validate start-execution readiness.
+
+    Dependency policy (Plan B, per adjudication 05 §3.1/§3.2):
+    - enforce_deps_block=True is passed ONLY by the mutating `--approved` path.
+      mode=block + unmet deps then fail unless ignore_deps=True.
+    - mode=off silences dependency warnings entirely.
+    - every other path (--check, warn mode) keeps Plan A semantics: deps are
+      warnings that never fail the guard.
+    """
     errors: list[str] = []
     if task_data is None:
         return GateGuardResult(ok=False, errors=["task.json"])
@@ -691,6 +709,29 @@ def validate_start_execution(
     if not approved:
         errors.append("--approved is required for mutation")
 
+    warnings: list[str] = []
+    deps_blocking_summary: list[str] = []
+    if task_data is not None:
+        scope = scope_children_for_task(task_dir, task_data)
+        report = describe_dependencies(
+            task_dir,
+            task_data,
+            scope_children=scope,
+        )
+        depends_mode = read_depends_mode(task_data)
+        if enforce_deps_block and depends_mode == "block":
+            deps_blocking_summary = report.blocking_errors()
+            if ignore_deps:
+                warnings.extend(report.warnings())
+            else:
+                errors.extend(deps_blocking_summary)
+        elif depends_mode != "off":
+            warnings.extend(report.warnings())
+            if depends_mode == "block" and not enforce_deps_block:
+                warnings.append(
+                    "dependency policy mode=block: --approved would fail unless --ignore-deps"
+                )
+
     baseline_record = None
     if not errors:
         baseline_record = make_baseline_record(
@@ -700,12 +741,14 @@ def validate_start_execution(
     return GateGuardResult(
         ok=not errors,
         errors=errors,
+        warnings=warnings,
         contract_fingerprint=contract_fingerprint,
         artifact_fingerprints=artifact_fingerprints,
         required_gates=required_gates,
         baseline_record=baseline_record,
         is_full_task=full_task,
         auto_gate_records=auto_gate_records,
+        deps_blocking_summary=deps_blocking_summary,
     )
 
 
@@ -737,9 +780,19 @@ def validate_start_execution_check(
     task_dir: Path,
     task_data: dict | None,
 ) -> GateGuardResult:
-    """Validate start-execution preflight without requiring approval."""
-    result = validate_start_execution(task_dir, task_data, approved=True)
-    return result
+    """Validate start-execution preflight without requiring approval.
+
+    NOTE (adjudication 05 §3.1 trap): the check path deliberately passes
+    enforce_deps_block=False — even when the task is in mode=block, --check
+    must never fail on dependencies; it only surfaces warnings. Only the
+    mutating --approved path may set enforce_deps_block=True.
+    """
+    return validate_start_execution(
+        task_dir,
+        task_data,
+        approved=True,
+        enforce_deps_block=False,
+    )
 
 
 def validate_transition_readiness(

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

@@ -127,6 +127,37 @@ def remove_child_from_task_map(
     write_task_map(parent_dir, data, body, f"Unlinked Child `{child_name}`.")
 
 
+def resolve_child_map_id(
+    parent_data: dict,
+    child_dir: Path,
+    child_data: dict | None = None,
+) -> str:
+    """Resolve task-map child id for a child directory (nested slash slugs)."""
+    structural = parent_data.get("children", [])
+    if not isinstance(structural, list):
+        structural = []
+
+    leaf = child_dir.name
+    if leaf in structural:
+        return leaf
+
+    if child_data:
+        for key in ("name", "id"):
+            value = child_data.get(key)
+            if isinstance(value, str) and value in structural:
+                return value
+
+    suffix_matches = [
+        cid
+        for cid in structural
+        if isinstance(cid, str) and (cid == leaf or cid.endswith(f"/{leaf}"))
+    ]
+    if len(suffix_matches) == 1:
+        return suffix_matches[0]
+
+    return leaf
+
+
 def set_child_state(
     parent_dir: Path,
     parent_data: dict,
@@ -183,7 +214,7 @@ def validate_parent_child_integration(
 ) -> list[str]:
     """Validate a Parent-controlled Child integration state transition."""
     errors: list[str] = []
-    child_name = child_dir.name
+    child_name = resolve_child_map_id(parent_data, child_dir, child_data)
     if state not in PARENT_CONTROLLED_STATES:
         errors.append(f"state is not Parent-controlled: {state}")
     if not _short_text(evidence):
@@ -295,10 +326,11 @@ def set_parent_child_integration_state(
     if errors:
         return False, errors
 
+    child_name = resolve_child_map_id(parent_data, child_dir, child_data)
     data = ensure_task_map(parent_dir, parent_data, list(parent_data.get("children", [])))
-    child = get_child_entry(data, child_dir.name)
+    child = get_child_entry(data, child_name)
     if child is None:
-        return False, [f"child missing from task-map.md: {child_dir.name}"]
+        return False, [f"child missing from task-map.md: {child_name}"]
 
     child["state"] = state
     child["evidence"] = evidence
@@ -316,12 +348,12 @@ def set_parent_child_integration_state(
         queue = []
         data["integration_queue"] = queue
     if state == "integrating":
-        if child_dir.name not in queue:
-            queue.append(child_dir.name)
-    elif child_dir.name in queue:
-        data["integration_queue"] = [item for item in queue if item != child_dir.name]
+        if child_name not in queue:
+            queue.append(child_name)
+    elif child_name in queue:
+        data["integration_queue"] = [item for item in queue if item != child_name]
 
-    event = f"Parent set Child `{child_dir.name}` integration state to `{state}`. Evidence: {evidence}."
+    event = f"Parent set Child `{child_name}` integration state to `{state}`. Evidence: {evidence}."
     if ref:
         event = f"{event} Ref: {ref}."
     if merge_ref: