ultra-builder-pro-cli 0.10.0 → 0.12.1

package/hooks/context_spine.py

@@ -2,6 +2,7 @@
 """Read and render the compact DB-derived Ultra Context Spine breadcrumb."""
 
 import json
+import hashlib
 import sqlite3
 import subprocess
 from pathlib import Path
@@ -13,6 +14,12 @@ CONTEXT_COLUMNS = {
     "role", "gate", "next_action", "readiness", "blockers_json",
     "context_json", "manifest_path", "manifest_hash", "git_head", "task_id",
 }
+ADVISORY_CONTEXT_CODES = {
+    "CONTEXT_FILE_BUDGET_EXCEEDED",
+    "CONTEXT_TOKEN_BUDGET_EXCEEDED",
+    "EXECUTION_CONTEXT_BUDGET_EXCEEDED",
+    "EXECUTION_CONTEXT_BUDGET_ADVISORY",
+}
 
 
 def find_root(start: Path):
@@ -49,8 +56,57 @@ def git_head(root: Path):
     return result.stdout.strip() if result.returncode == 0 else None
 
 
-def _next_action(change, task, tasks, role, readiness, stored, state_changed):
+def baseline_health(conn, root: Path):
+    row = conn.execute(
+        """SELECT id, mode, status, repository_revision, spec_refs_json
+           FROM baselines WHERE status != 'superseded'
+           ORDER BY updated_at DESC, rowid DESC LIMIT 1"""
+    ).fetchone()
+    if row is None:
+        return {"status": "fail", "blockers": ["BASELINE_MISSING"], "warnings": [], "baseline": None}
+    baseline = dict(row)
+    blockers = []
+    warnings = []
+    if baseline["status"] != "ready":
+        blockers.append(f"BASELINE_NOT_READY:{baseline['status']}")
+    elif baseline["mode"] == "migrated":
+        warnings.append("BASELINE_MIGRATION_REVIEW_RECOMMENDED")
+    else:
+        for spec in safe_json(baseline.get("spec_refs_json"), []):
+            ref = spec.get("path") if isinstance(spec, dict) else None
+            expected = spec.get("digest") if isinstance(spec, dict) else None
+            if not isinstance(ref, str) or not ref or Path(ref).is_absolute():
+                blockers.append(f"BASELINE_SPEC_INVALID:{ref}")
+                continue
+            candidate = (root / ref).resolve()
+            try:
+                candidate.relative_to(root.resolve())
+            except ValueError:
+                blockers.append(f"BASELINE_SPEC_INVALID:{ref}")
+                continue
+            if not candidate.is_file():
+                blockers.append(f"BASELINE_SPEC_MISSING:{ref}")
+                continue
+            digest = hashlib.sha256(candidate.read_bytes()).hexdigest()
+            if not expected or digest != expected:
+                blockers.append(f"BASELINE_SPEC_STALE:{ref}")
+        head = git_head(root)
+        revision = baseline.get("repository_revision")
+        if head and revision and not str(revision).startswith("workspace:") and head != revision:
+            blockers.append("BASELINE_HEAD_STALE")
+    baseline.pop("spec_refs_json", None)
+    return {
+        "status": "fail" if blockers else "pass",
+        "blockers": blockers,
+        "warnings": warnings,
+        "baseline": baseline,
+    }
+
+
+def _next_action(change, task, tasks, role, readiness, stored, state_changed, blockers=None):
     if readiness != "ready":
+        if any(str(item).startswith("BASELINE_") for item in (blockers or [])):
+            return "Complete or refresh the Ultra project baseline through ultra-init."
         return "Resolve the context readiness blockers, then recompile change.context."
     if not state_changed and isinstance(stored, str) and stored.strip():
         return stored.strip()
@@ -77,7 +133,7 @@ def _next_action(change, task, tasks, role, readiness, stored, state_changed):
     return f"Create the first fresh-context tracer-bullet task for change {change['id']}."
 
 
-def _route(change, task, tasks, readiness):
+def _route(change, task, tasks, readiness, blockers=None):
     if readiness != "ready" or change["status"] == "blocked":
         return "ultra-change"
     if change["status"] == "ready":
@@ -99,15 +155,39 @@ def read_breadcrumb(root: Path):
             row[0]
             for row in conn.execute("SELECT name FROM sqlite_master WHERE type='table'")
         }
-        if not {"changes", "tasks", "context_snapshots"}.issubset(tables):
+        if not {"baselines", "changes", "tasks", "context_snapshots"}.issubset(tables):
             return None
+        baseline = baseline_health(conn, root)
         change = conn.execute(
             """SELECT id, status FROM changes
                WHERE status IN ('active', 'blocked', 'ready')
                ORDER BY updated_at DESC LIMIT 1"""
         ).fetchone()
         if change is None:
-            return None
+            current = baseline["baseline"]
+            if baseline["status"] == "pass":
+                next_action = "Start daily work with ultra-change."
+                route = "ultra-change"
+                readiness = "ready"
+            else:
+                next_action = "Initialize or complete project baseline adoption through ultra-init."
+                route = "ultra-init"
+                readiness = "blocked"
+            return {
+                "change_id": None,
+                "task_id": None,
+                "role": "plan",
+                "gate": "alignment",
+                "readiness": readiness,
+                "blockers": baseline["blockers"],
+                "warnings": baseline["warnings"],
+                "next_action": next_action,
+                "recommended_workflow": route,
+                "context_manifest_path": None,
+                "context_manifest_hash": None,
+                "git_head": git_head(root),
+                "baseline": current,
+            }
         tasks = list(conn.execute(
             "SELECT id, status, session_id FROM tasks WHERE change_id = ? ORDER BY created_at ASC",
             (change["id"],),
@@ -145,6 +225,7 @@ def read_breadcrumb(root: Path):
             not isinstance(context.get("resume"), dict)
             or not isinstance(context.get("context"), dict)
             or not isinstance(context.get("readiness"), dict)
+            or "baseline" not in context
         )
     )
     stored_status = context.get("resume", {}).get("task_status")
@@ -152,6 +233,7 @@ def read_breadcrumb(root: Path):
     state_changed = stored_status is not None and stored_status != current_status
     stored_action = snapshot["next_action"] if snapshot else None
     blockers = []
+    warnings = list(dict.fromkeys([*baseline["blockers"], *baseline["warnings"]]))
     if snapshot_missing:
         blockers.append("CONTEXT_NOT_COMPILED")
     else:
@@ -162,8 +244,14 @@ def read_breadcrumb(root: Path):
         if state_changed:
             blockers.append("CONTEXT_TASK_STATE_STALE")
         for blocker in safe_json(snapshot["blockers_json"], []):
-            if blocker not in blockers:
+            if blocker in ADVISORY_CONTEXT_CODES or str(blocker).startswith("BASELINE_"):
+                if blocker not in warnings:
+                    warnings.append(blocker)
+            elif blocker not in blockers:
                 blockers.append(blocker)
+        for warning in context.get("readiness", {}).get("warnings", []):
+            if warning not in warnings:
+                warnings.append(warning)
     readiness = "blocked" if blockers else snapshot["readiness"]
     if snapshot_missing:
         next_action = f"Compile change.context for change {change['id']} before continuing."
@@ -174,7 +262,9 @@ def read_breadcrumb(root: Path):
     elif state_changed:
         next_action = "Task state changed after context compilation; recompile change.context."
     else:
-        next_action = _next_action(change, task, tasks, role, readiness, stored_action, False)
+        next_action = _next_action(
+            change, task, tasks, role, readiness, stored_action, False, blockers
+        )
     return {
         "change_id": change["id"],
         "change_status": change["status"],
@@ -185,28 +275,42 @@ def read_breadcrumb(root: Path):
         "gate": gate,
         "readiness": readiness,
         "blockers": blockers,
+        "warnings": warnings,
         "next_action": next_action,
-        "recommended_workflow": _route(change, task, tasks, readiness),
+        "recommended_workflow": _route(change, task, tasks, readiness, blockers),
         "context_manifest_path": snapshot["manifest_path"] if snapshot else None,
         "context_manifest_hash": snapshot["manifest_hash"] if snapshot else None,
         "git_head": current_head,
+        "baseline": baseline["baseline"],
     }
 
 
 def render_breadcrumb(root: Path, breadcrumb: dict) -> str:
     task = breadcrumb.get("task_id") or "none"
     task_status = breadcrumb.get("task_status") or "none"
-    lines = [
-        "[Ultra context spine]",
-        f"Project: {root}",
-        f"Change: {breadcrumb['change_id']} ({breadcrumb.get('change_status', 'active')})",
-        f"Task: {task} ({task_status})",
-        f"Role: {breadcrumb.get('role', 'plan')}",
-        f"Gate: {breadcrumb.get('gate', 'alignment')}",
-        f"Readiness: {breadcrumb.get('readiness', 'ready')}",
-    ]
+    baseline = breadcrumb.get("baseline") or {}
+    if breadcrumb.get("change_id"):
+        lines = [
+            "[Ultra context spine]",
+            f"Project: {root}",
+            f"Baseline: {baseline.get('id', 'unknown')} ({baseline.get('mode', 'unknown')}/{baseline.get('status', 'unknown')})",
+            f"Change: {breadcrumb['change_id']} ({breadcrumb.get('change_status', 'active')})",
+            f"Task: {task} ({task_status})",
+            f"Role: {breadcrumb.get('role', 'plan')}",
+            f"Gate: {breadcrumb.get('gate', 'alignment')}",
+            f"Readiness: {breadcrumb.get('readiness', 'ready')}",
+        ]
+    else:
+        lines = [
+            "[Ultra baseline]",
+            f"Project: {root}",
+            f"Baseline: {baseline.get('id', 'missing')} ({baseline.get('mode', 'unknown')}/{baseline.get('status', 'missing')})",
+            f"Readiness: {breadcrumb.get('readiness', 'blocked')}",
+        ]
     if breadcrumb.get("blockers"):
         lines.append("Blockers: " + ", ".join(breadcrumb["blockers"]))
+    if breadcrumb.get("warnings"):
+        lines.append("Warnings: " + ", ".join(breadcrumb["warnings"]))
     lines.extend([
         f"Next: {breadcrumb.get('next_action', 'Inspect Ultra status.')}",
         f"Route: {breadcrumb.get('recommended_workflow', 'ultra-change')}",

package/hooks/health_check.py

@@ -6,8 +6,11 @@ import sqlite3
 import sys
 from pathlib import Path
 
+from context_spine import baseline_health
+
 
 REQUIRED_TABLES = {
+    "baselines",
     "tasks", "events", "sessions", "schema_version", "migration_history",
     "telemetry", "specs_refs", "circuit_breaker", "changes", "artifacts",
     "context_snapshots", "spec_learning_candidates", "trace_links", "incidents", "projection_jobs",
@@ -48,6 +51,7 @@ def inspect(root: Path) -> dict:
     try:
         uri = f"file:{db_path}?mode=ro"
         with sqlite3.connect(uri, uri=True, timeout=1) as conn:
+            conn.row_factory = sqlite3.Row
             quick = conn.execute("PRAGMA quick_check").fetchone()[0]
             tables = {
                 row[0] for row in conn.execute(
@@ -66,6 +70,13 @@ def inspect(root: Path) -> dict:
                 report["status"] = "degraded"
                 return report
 
+            baseline = baseline_health(conn, root)
+            report["checks"]["baseline"] = {
+                **baseline,
+                "readiness": baseline["status"],
+                "status": "pass" if baseline["status"] == "pass" else "warning",
+            }
+
             incidents = [
                 {"id": row[0], "code": row[1], "severity": row[2], "retryable": bool(row[3])}
                 for row in conn.execute(

package/hooks/pre_stop_check.py

@@ -1,5 +1,5 @@
 #!/usr/bin/env python3
-"""Block stop only when the active Ultra workflow itself is incomplete."""
+"""Report unfinished Ultra workflow position without trapping session stop."""
 
 import sys
 import json
@@ -12,8 +12,9 @@ def allow_stop() -> None:
     print(json.dumps({}))
 
 
-def block_stop(reason: str) -> None:
-    print(json.dumps({"decision": "block", "reason": reason}))
+def advise_stop(reason: str) -> None:
+    print(f"[Ultra stop advisory] {reason}", file=sys.stderr)
+    allow_stop()
 
 
 def main():
@@ -41,12 +42,12 @@ def main():
         if not isinstance(state, dict) or state.get("status") in TERMINAL:
             allow_stop()
             return
-        block_stop(
+        advise_stop(
             "Active Ultra workflow is incomplete: "
             f"command={state.get('command', 'unknown')}, "
             f"task={state.get('task_id', state.get('task', 'unknown'))}, "
             f"step={state.get('step', 'unknown')}, status={state.get('status', 'active')}. "
-            "Complete or explicitly cancel the Ultra workflow before stopping."
+            "Resume or explicitly cancel it in a later session; stop is allowed."
         )
         return
     allow_stop()