ultra-builder-pro-cli 0.25.1 → 0.26.1

package/docs/WORKFLOW-LIFECYCLE.md

@@ -1,230 +1,138 @@
 # Ultra Builder Pro workflow lifecycle
 
-Ultra is an adaptive capability graph, not an automatically chained pipeline. The
-current Skill inspects authority and recommends a next capability. The user explicitly
-starts that capability. Skills own semantic procedure; the seven-tool MCP kernel owns
-persistence and mechanical safety across Claude Code, Codex, OpenCode, Kimi Code, and
-Grok Build.
-
-## Capability graph
-
-```mermaid
-flowchart TD
-    START["Project"] --> INIT["ultra-init"]
-    INIT --> RESEARCH["ultra-research"]
-    RESEARCH --> THINK["ultra-think when a material decision remains"]
-    THINK --> RESEARCH
-    RESEARCH --> CHANGE["ultra-change"]
-    CHANGE --> ROUTE{"What does this Change actually need?"}
-    ROUTE -->|"Evidence gap"| CR["bounded ultra-research"]
-    CR --> ROUTE
-    ROUTE -->|"Implementation"| PLAN["ultra-plan"]
-    PLAN --> DEV["ultra-dev for one owned Task"]
-    DEV --> MORE{"More executable Tasks?"}
-    MORE -->|"Yes"| DEV
-    MORE -->|"No"| ASSESS{"What evidence is still warranted?"}
-    ROUTE -->|"No implementation; current evidence is sufficient"| ASSESS
-    ASSESS -->|"Risk-selected verification"| TEST["ultra-test"]
-    ASSESS -->|"Independent review"| REVIEW["ultra-review"]
-    ASSESS -->|"Caller accepts current packet and explicit omissions"| DELIVER["ultra-deliver"]
-    TEST -->|"implementation gap"| DEV
-    TEST -->|"review warranted"| REVIEW
-    TEST -->|"caller accepts evidence"| DELIVER
-    REVIEW -->|"implementation issue"| DEV
-    REVIEW -->|"contract issue"| PLAN
-    REVIEW -->|"accepted"| DELIVER
-    DELIVER --> CHANGE
-    STATUS["ultra-status"] -.-> INIT
-    STATUS -.-> CHANGE
-    DOCTOR["ultra-doctor"] -.-> INIT
-    DOCTOR -.-> CHANGE
-```
+Ultra v0.26 has no fixed runtime state machine. Skills define checkable entry and exit
+criteria; repository files record facts; the host model chooses the route.
 
-The graph is guidance, not database authorization. The host model selects the evidence
-needed by the actual Change route and records every deliberate omission in the delivery
-handoff. When implementation occurs, its Plan, Task contract, and Context remain
-mandatory execution authority; Research, Test, and Review are used according to the
-actual evidence and risk rather than as universal archive gates. `ultra-status` is
-read-only. `ultra-doctor` repairs mechanical authority only.
-
-## Shared command contract
-
-Every public Skill follows the same boundary:
-
-1. read the current `ultra.context`;
-2. inspect checkout/runtime facts directly;
-3. identify the smallest unresolved semantic choice;
-4. recommend a route and ask only when user intent is not already explicit;
-5. persist normalized facts through typed `ultra.record`;
-6. update the owning semantic/evidence files;
-7. save or accept the stage through `ultra.checkpoint`;
-8. read back current authority;
-9. report diagnostics and recommend, but do not launch, the next Skill.
-
-No command records ceremonial steps merely to satisfy SQLite.
-
-## Capability ownership
-
-| Skill | Semantic owner | Durable output |
-|---|---|---|
-| `ultra-init` | repository classification, scope, Git/runtime bootstrap | initialized local authority and empty/imported team checkpoint |
-| `ultra-research` | adaptive evidence coverage and accepted baseline | baseline specs, research evidence, Decision Records, baseline checkpoint |
-| `ultra-think` | one load-bearing owner decision or bounded diagnosis | normalized Decision Record and applied references |
-| `ultra-change` | feature/fix/refactor/incident contract | active Change intent, classification, delta and decision scope |
-| `ultra-plan` | Task contracts, topology, ownership, acceptance coverage | accepted Plan checkpoint, deterministic plan files, team checkpoint |
-| `ultra-dev` | one owned vertical Task implementation | Worker Packet output, task outcome, implementation evidence checkpoint |
-| `ultra-test` | risk-selected executable validation | test report and accepted test checkpoint |
-| `ultra-review` | independent spec fidelity and engineering quality | specialist artifacts, coordinated summary, accepted review checkpoint |
-| `ultra-deliver` | documentation/spec reconciliation and local archive | delivery evidence, converged baseline, immutable archive, team checkpoint |
-| `ultra-status` | current Context rendering | no state mutation |
-| `ultra-doctor` | mechanical health, migration, backup and repair | diagnostic/repair report; no product decision |
-
-## Context and decisions
-
-One canonical Context Envelope flows through Skill, Hook, Session, Agent, and compact
-recovery. Accepted Decision Records are always visible, including when no workflow is
-active. A new session therefore resumes from accepted intent rather than reconstructing
-it from conversation.
-
-Decision history is append-only through supersession:
+## Capability flow
 
 ```text
-proposed -> accepted -> superseded
-         -> rejected
-```
+ultra-init
+    ├─ unresolved external claims ─► ultra-research
+    └─ bounded requested outcome ──► ultra-change
 
-The status of a proposal never grants execution authority. The accepted record, its
-digest, applied references, and the owning checkpoint do.
+ultra-change ─► ultra-plan ─► ultra-dev (per task) ─► ultra-test ─► ultra-deliver
+                     ▲                 │                    │
+                     └── replan ◄──────┘                    └── findings return to owner/model
 
-## Checkpoints, not fixed steps
+ultra-status    read-only router at any point
+ultra-delegate  orthogonal bounded execution on another CLI
+```
 
-Stage authority is revisioned:
+Arrows are recommendations, not automatic invocation. The owner explicitly selects
+each public workflow.
 
-```text
-draft revision N
-  -> accepted revision N
-  -> accepted revision N+1 supersedes N
-```
+## Common entry contract
 
-Semantic diagnostics remain recorded but do not reject the model's explicit
-checkpoint conclusion. A structural, digest, path, publication, or concurrency
-conflict keeps the same draft mutable. Plan export is part of Plan checkpoint
-publication, so changing a Task contract before acceptance cannot invalidate an
-already-recorded “export step.” There is no locked intermediate run to cancel or
-manually repair.
+Every user-invoked Skill reads, in order:
 
-Accepted checkpoints are immutable evidence. New facts create a replacement draft.
-Only archive history is terminal; subsequent product work opens a new Change.
+1. `.ultra/tasks.json`;
+2. the unfinished task's `context_file` and closing `## Resume Note`;
+3. `CONTEXT.md` and relevant `.ultra/decisions/`;
+4. the active Change, specifications, evidence, and Git state relevant to its scope.
 
-## Change lifecycle
+Missing files produce a precise recovery or initialization recommendation. They do not
+cause the Skill to invent a state transition.
 
-Live v0.24 writes only:
+## Initialization
 
-```text
-active -> archived
-   |
-   -> cancelled
-```
+`ultra-init` distinguishes owner authorization from claims requiring evidence. It
+creates the file skeleton, preserves unknowns as `[NEEDS CLARIFICATION]`, initializes
+Git when absent, and records only repository-observable brownfield facts. It does not
+perform research or launch another workflow.
 
-`blocked`, `ready`, and `needs_attention` are derived diagnostics, not absorbing Change
-states. An active Change may be revised. The Deliver Skill inspects the relevant Task,
-Context, test, review, documentation, and delivery evidence, decides semantic
-sufficiency, and records deliberate omissions. Archive validates the explicit handoff,
-current authority, reconciliation structure, and safe recoverable filesystem/DB
-transaction without enforcing a fixed stage sequence. Archived bytes remain immutable.
+## Research
 
-Older `ready` or `blocked` rows are readable migration history. They do not authorize
-new work until migration/revalidation derives current checkpoint authority.
+`ultra-research` maps unresolved claims to the smallest useful subset of seventeen
+focused references. Reports are written immediately. Three material checkpoints can
+change later scope; the owner resolves those checkpoints. The final distillate records
+Git blob hashes of the specifications it summarizes.
 
-## Task and Session lifecycle
+## Change reconciliation
 
-Task durable outcomes remain portable:
+`ultra-change` first compares requested behavior with product truth and current code.
+It classifies changes by the resulting commitments:
 
-```text
-pending -> in_progress -> completed
-   |          |              |
-   |          -> blocked     -> in_progress (explicit reopen)
-   -> blocked
-   -> cancelled
-```
+- expansion and correction may proceed inside accepted intent;
+- a reduction waits for explicit owner authority.
+
+The output is one active Change intent with observable outcome, acceptance, seams,
+non-goals, and trace anchors.
 
-`in_progress`, Worker ownership, leases, PIDs, heartbeats, worktrees, and completion
-commit backfill are checkout-local. They are not published to Git.
-Reopening a completed Task clears the local completion/session fields, preserves the
-prior completion commit in an append-only `task_reopened` event, and requires a new
-durable outcome before it can be completed again.
+## Planning
 
-`ultra.session acquire` atomically:
+`ultra-plan` confirms the scope posture and public seams, then writes a task graph and
+one context file per task. Feature tasks are tracer bullets. A contract task precedes
+cross-process or cross-top-level-boundary implementations; integration checkpoints
+appear after several slices. Cycles and broken trace paths are repaired before handoff.
 
-1. checks a real lease/CAS conflict;
-2. compiles or reuses the exact Context Envelope;
-3. creates an immutable Worker Packet;
-4. allocates the lease/worktree;
-5. returns packet path/digest and exact execution boundary.
+## Task development
 
-A missing semantic detail is diagnostic, not a transport failure. A genuine lease,
-digest, unsafe path, or concurrent authority conflict fails closed. Optional
-orchestration can dispatch only a Change-owned Task with an accepted Plan checkpoint
-and assigned Worker Packet.
+`ultra-dev` writes the implementation plan into the task context before code. It uses
+`ultra-tdd` on confirmed seams, records six evidence dimensions, and keeps ledger and
+context status synchronized. The closing Resume Note is rewritten even when work stops
+early.
 
-## Team sync
+Task review uses six independent lenses. Findings move through stable JSON artifacts,
+not intermediate worker chatter. Refactoring happens after the evidence makes real
+duplication or coupling visible.
 
-`.ultra/tasks/tasks.json` is a tracked, digest-chained team checkpoint. It carries
-portable baseline, Change, Decision summary/reference, accepted Stage Checkpoint, Task
-contract, dependency, and durable outcome records. It excludes local execution state.
+## Whole-system audit
 
-`ultra.sync` supports:
+`ultra-test` runs once after the ledger is complete. It checks anti-patterns, coverage,
+wiring, E2E behavior, performance, and security. It names the exact Git commit and
+never turns an orphan, failed command, stub, or omission into permission to alter scope.
 
-- `inspect`: side-effect-free condition and migration advice;
-- `migrate`: exact-byte backup-first legacy conversion;
-- `import`: schema/digest/ancestry/CAS validation and clean fast-forward;
-- `publish`: reconcile incoming Git authority, then publish one new generation.
+## Delivery
 
-Same-record concurrent edits return a typed conflict. Ultra does not silently choose
-one intent. Imported accepted baseline authority requires checkout-local source/spec
-revalidation before descendant publication.
+`ultra-deliver` reconciles actual outcome, specifications, documentation, current test
+report, aggregate review, build, version impact, omissions, and rollback. It archives
+the Change with `git mv` after local reconciliation.
 
-Metadata-only Ultra commits do not make a baseline stale. Source or specification
-drift remains visible and may require revalidation.
+Commit, push, tag, publication, release, and deployment are independent external
+effects. Readiness grants none automatically.
 
-## Hook lifecycle
+## Status routing
 
-Hooks do not drive the capability graph. They:
+`ultra-status` infers the smallest next route from observable files:
 
-- inject a bounded Context Envelope where the host consumes it;
-- protect the team checkpoint and generated projections from direct writes;
-- save/restore minimal compact recovery state;
-- record minimal lifecycle identifiers;
-- return advisory Stop context.
+- no healthy skeleton → init;
+- unresolved evidence-bearing claim → research;
+- requested outcome without active Change → change;
+- active Change without executable ledger → plan;
+- pending or in-progress task → dev;
+- completed ledger without current report → test;
+- current report and unarchived Change → deliver.
 
-When a host ignores Hook stdout, the adapter records health/events only and every Skill
-reads `ultra.context` explicitly. Hook limitations are never presented as successful
-context injection.
+It also checks installation provenance, stale reports, old in-progress work, and
+unresolved markers. It does not mutate artifacts.
 
-## Recovery
+## Artifact closure
 
-Use `ultra.context` first; legacy input must return a discoverable migration action
-instead of blocking diagnosis. Use `ultra.sync migrate` for semantic conversion and
-`ultra.doctor { repair: true }` for mechanical backup/recovery.
+Every durable output has a later reader:
 
-Migration supports v4.4/v4.5 projections and v0.22/v0.23 database/ledger authority.
-It is exact-byte backup-first, transactional, and fail-closed on conflict. Legacy
-workflow/dialogue rows survive as history but do not authorize current work.
+- init's north star and specification skeletons are read by all later workflows;
+- research reports are traced into specifications, Change reconciliation, planning,
+  and delivery;
+- Change intent is consumed through planning, development, audit, review, status, and
+  delivery;
+- task ledger and contexts are the common resume input, while task evidence feeds
+  review, whole-system audit, and delivery;
+- the current test report is consumed by status and delivery;
+- delivery moves with the Change into archive and remains historical evidence.
 
-Repair never invents a product choice, edits a semantic artifact to make it pass, or
-asks the user to hand-edit SQLite.
+`ultra-status` intentionally writes nothing. Review, Hook, compact, and delegation
+files are derived observations with explicit rebuild or rerun paths. No route creates
+an unowned drift log, Change plan, technical-debt report, or second delivery summary.
 
-## Hard-error boundary
+## Interruption and cross-host continuation
 
-Only these classes fail the tool call:
+Before stopping, the active task context records current facts, exact verification,
+open questions, Completion, and a closing Resume Note. The next session or host repeats
+the common entry contract and compares the working tree with those claims.
 
-- database/schema corruption;
-- unsafe path, symlink, or identity swap;
-- actual digest, CAS, or lease concurrency conflict;
-- missing/incompatible native runtime;
-- permission failure;
-- archive/publish/deploy or another irreversible external-effect failure.
+This path remains valid when hooks and `ubp` are disabled. A compact snapshot may be
+used as a hint, then checked against canonical files and Git.
 
-Evidence gaps, incomplete exploration, stale optional context, missing reports, or
-other semantic insufficiency are structured diagnostics. The model remains responsible
-for investigating, revising, accepting, or explicitly recording an omission.
+An authenticated Claude-to-Codex continuation using this path passed on 2026-08-03;
+the exact scope, provenance, results, and limitations are recorded in the
+[runtime compatibility matrix](RUNTIME-COMPAT-MATRIX.md#authenticated-cross-host-continuation-evidence).

package/hooks/README.md

@@ -1,42 +1,24 @@
-# Ultra Builder Pro workflow hooks
+# Ultra Builder Pro hooks
 
-These Hooks observe only Ultra-owned state. Session health/context recognizes an
-initialized `.ultra/.runtime/state.db` and reads the canonical Context Envelope.
-Direct writes to the MCP-owned Git checkpoint and checkout-local projections remain
-blocked; context, compact, stop, and agent lifecycle behavior is recovery-oriented and
-does not turn semantic diagnostics into refusal gates.
+Ultra ships five small file-first hooks. Every hook first looks for a `.ultra/`
+directory and exits silently when the workflow is not active.
 
-| Lifecycle | Hook | Purpose |
+| Hook | Lifecycle | Purpose |
 |---|---|---|
-| Session start | `health_check.py` | Read-only integrity, incident, projection, session, and change-artifact checks |
-| Shared helper | `context_envelope.py` | Read the same bounded Context Envelope used by MCP, Skills, Sessions, and Workers |
-| Session start | `workflow_context.py` | Inject the compact envelope with accepted intent, never raw interaction or provider payloads |
-| Before edit | `active_task_context.py` | Protect `.ultra/tasks/tasks.json` (Git team checkpoint) and `.ultra/.runtime/projections/tasks.json` (local view), then restate the same DB-derived task breadcrumb |
-| Before compact | `workflow_checkpoint.py` | Validate and atomically save a minimal workflow checkpoint |
-| After compact/resume | `workflow_resume.py` | Prefer the DB breadcrumb; restore the minimal file checkpoint only when no active change owns recovery |
-| Stop | `pre_stop_check.py` | Report an incomplete workflow boundary and allow stop |
-| Subagent lifecycle | `subagent_tracker.py` | Append minimal start/stop metadata to the authoritative DB event stream |
+| `session_context.py` | Session start | Inject the one-line north star and current acceptance criteria |
+| `mid_workflow_recall.py` | Before source reads or edits | Restate current acceptance only |
+| `compact_context.py` | Before/after compaction | Save and restore a disposable snapshot derived from files and Git |
+| `post_edit_guard.py` | After edits | Record mechanical evidence observations without deciding completion |
+| `block_dangerous_commands.py` | Before shell execution | Advise on additive protected-branch publication; block history rewrites and a narrow destructive set until the exact command is owner-authorized |
 
-The plugin deliberately does not capture prompts, tool observations, transcripts, summaries, general
-conversational memory, or code-graph payloads. It does retain project-local Ultra workflow memory in
-`.ultra/`. Generic command blocking and post-edit policy are user/repository governance. General
-memory and graph content belongs to separately installed providers.
+`_common.py` is a shared library, not a lifecycle registration. Compact snapshots and
+progress observations live under ignored `.ultra/.runtime/` or `.ultra/progress/`; the
+canonical semantic facts remain the owner-readable files and Git.
 
-`subagent_tracker.py` passes only agent id/type and the host session id to the bundled
-`hook-event.cjs` helper. The helper binds the current change/task and appends
-`subagent_started` or `subagent_stopped` to `state.db`; it never stores transcript
-paths, messages, or a parallel JSONL lifecycle log.
-
-`context_envelope.py` is an imported library, not an additional lifecycle registration.
-Registering it separately would duplicate hook execution. The checkpoint is a recovery artifact, not a second authority. A valid newer
-live workflow wins; a newer valid checkpoint may restore a missing or older
-live file; corrupt, non-object, or terminal checkpoints are ignored.
-
-Runtime wiring:
-
-- Claude Code: native `hooks/hooks.json` with `${CLAUDE_PLUGIN_ROOT}` paths.
-- Codex: native `hooks/hooks.json` through `hooks/adapters/codex.py` for wire normalization.
-- OpenCode: native JavaScript plugin events; the Python hook suite is not copied.
-- Kimi Code: native lifecycle events through its wire adapter.
-- Grok Build: camelCase lifecycle events; ignored stdout channels are used for
-  observation only, and every Skill rereads authoritative Context at entry.
+Claude Code runs the hooks directly. Codex, Kimi Code, and Grok Build use the small
+wire adapters under `hooks/adapters/`. OpenCode calls the same scripts from its native
+JavaScript plugin. A hook failure is advisory except for the explicitly classified
+destructive effects in `block_dangerous_commands.py`, whose denial includes a reachable
+SHA-256-scoped authorization path. Additive protected-branch publication stays advisory
+because portable hooks cannot consume every host's trusted owner-approval receipt;
+history rewrites and branch deletion remain guarded.

package/hooks/_common.py

@@ -0,0 +1,113 @@
+"""Small file-first helpers shared by Ultra hooks."""
+
+from __future__ import annotations
+
+import json
+import os
+import re
+import sys
+from pathlib import Path
+from typing import Any
+
+
+def read_payload() -> dict[str, Any]:
+    try:
+        value = json.loads(sys.stdin.read() or "{}")
+    except json.JSONDecodeError:
+        return {}
+    return value if isinstance(value, dict) else {}
+
+
+def project_root(payload: dict[str, Any]) -> Path | None:
+    candidate = payload.get("cwd") or payload.get("workspace_root") or os.getcwd()
+    path = Path(str(candidate)).resolve()
+    if path.is_file():
+        path = path.parent
+    for current in (path, *path.parents):
+        if (current / ".ultra").is_dir():
+            return current
+    return None
+
+
+def markdown_section(text: str, heading: str) -> str:
+    pattern = re.compile(
+        rf"^##\s+{re.escape(heading)}\s*$\n(?P<body>.*?)(?=^##\s+|\Z)",
+        re.MULTILINE | re.DOTALL | re.IGNORECASE,
+    )
+    match = pattern.search(text)
+    return match.group("body").strip() if match else ""
+
+
+def read_tasks(root: Path) -> list[dict[str, Any]]:
+    try:
+        value = json.loads((root / ".ultra" / "tasks.json").read_text(encoding="utf-8"))
+    except (OSError, json.JSONDecodeError):
+        return []
+    tasks = value.get("tasks", []) if isinstance(value, dict) else value
+    return [item for item in tasks if isinstance(item, dict)] if isinstance(tasks, list) else []
+
+
+def current_task(root: Path) -> dict[str, Any] | None:
+    tasks = read_tasks(root)
+    for status in ("in_progress", "pending"):
+        for task in tasks:
+            if task.get("status") == status:
+                return task
+    return None
+
+
+def project_file(root: Path, value: str, *, ultra_default: bool = False) -> Path | None:
+    relative = Path(value)
+    if relative.is_absolute():
+        return None
+    ultra_shorthands = {"changes", "contexts", "decisions", "evidence", "progress", "reviews", "specs"}
+    first = relative.parts[0] if relative.parts else ""
+    if first == ".ultra":
+        base = root
+    elif ultra_default and first in ultra_shorthands:
+        base = root / ".ultra"
+    else:
+        base = root
+    candidate = (base / relative).resolve()
+    try:
+        candidate.relative_to(root.resolve())
+    except ValueError:
+        return None
+    return candidate
+
+
+def context_path(root: Path, task: dict[str, Any]) -> Path | None:
+    value = task.get("context_file")
+    if not isinstance(value, str) or not value:
+        return None
+    return project_file(root, value, ultra_default=True)
+
+
+def task_sections(root: Path, task: dict[str, Any]) -> dict[str, str]:
+    file = context_path(root, task)
+    try:
+        text = file.read_text(encoding="utf-8") if file else ""
+    except OSError:
+        text = ""
+    return {
+        "acceptance": markdown_section(text, "Acceptance Criteria"),
+        "resume": markdown_section(text, "Resume Note"),
+    }
+
+
+def emit_context(event: str, text: str) -> None:
+    if not text.strip():
+        return
+    print(json.dumps({
+        "hookSpecificOutput": {
+            "hookEventName": event,
+            "additionalContext": text.strip(),
+        }
+    }))
+
+
+def write_json_atomic(file: Path, payload: dict[str, Any]) -> None:
+    file.parent.mkdir(parents=True, exist_ok=True)
+    temporary = file.with_suffix(f"{file.suffix}.tmp-{os.getpid()}")
+    temporary.write_text(f"{json.dumps(payload, indent=2)}\n", encoding="utf-8")
+    temporary.replace(file)

package/hooks/adapters/codex.py

@@ -1,11 +1,11 @@
 #!/usr/bin/env python3
-"""Codex wire adapter for Ultra Builder Pro hooks.
+"""Codex wire adapter for Ultra Builder Pro's five file-first hooks.
 
 Codex and Claude Code share the JSON-on-stdin command-hook shape, but differ
 at three important boundaries:
 
 - Codex emits ``apply_patch`` with the patch text in ``tool_input.command``;
-  legacy Ultra edit hooks expect one ``Edit`` event per ``file_path``.
+  the post-edit sensor expects one ``Edit`` event per ``file_path``.
 - Codex rejects ``permissionDecision: ask`` in PreToolUse output. Ultra warning
   decisions therefore become advisory ``systemMessage`` values.
 - Each event has a strict output schema. This adapter removes foreign fields
@@ -30,13 +30,11 @@ from typing import Any
 
 HOOK_ROOT = Path(__file__).resolve().parent.parent
 ALLOWED_FEATURES = {
-    "active_task_context.py",
-    "health_check.py",
-    "pre_stop_check.py",
-    "subagent_tracker.py",
-    "workflow_checkpoint.py",
-    "workflow_context.py",
-    "workflow_resume.py",
+    "block_dangerous_commands.py",
+    "compact_context.py",
+    "mid_workflow_recall.py",
+    "post_edit_guard.py",
+    "session_context.py",
 }
 UNIVERSAL_OUTPUT_FIELDS = {"continue", "stopReason", "suppressOutput", "systemMessage"}
 PATCH_FILE_RE = re.compile(r"^\*\*\* (?:Add|Update|Delete) File: (.+?)\s*$", re.MULTILINE)
@@ -58,7 +56,7 @@ def _patch_paths(tool_input: Any) -> list[str]:
 
 
 def normalize_inputs(payload: dict[str, Any]) -> list[dict[str, Any]]:
-    """Return legacy-compatible input(s) for one Codex hook payload."""
+    """Return file-first hook input(s) for one Codex hook payload."""
     normalized = copy.deepcopy(payload)
     if normalized.get("tool_response") is not None and normalized.get("tool_output") is None:
         normalized["tool_output"] = normalized["tool_response"]
@@ -90,7 +88,7 @@ def _universal(output: dict[str, Any]) -> dict[str, Any]:
 
 
 def adapt_output(output: dict[str, Any], event: str) -> dict[str, Any]:
-    """Convert a legacy hook result to the strict Codex event output schema."""
+    """Convert a shared hook result to the strict Codex event output schema."""
     if not isinstance(output, dict):
         return {}
     result = _universal(output)
@@ -239,11 +237,6 @@ def run_feature(feature: str, payload: dict[str, Any], feature_args: list[str])
         return {"systemMessage": f"Ultra hook feature is missing: {feature}"}
 
     event = str(payload.get("hook_event_name") or "")
-    if feature == "workflow_resume.py" and event == "PostCompact":
-        payload = dict(payload)
-        payload["hook_event_name"] = "SessionStart"
-        payload["source"] = "compact"
-
     env = os.environ.copy()
     env["UBP_HOOK_RUNTIME"] = "codex"
     plugin_data = env.get("PLUGIN_DATA") or env.get("CLAUDE_PLUGIN_DATA")

package/hooks/adapters/grok.py

@@ -14,11 +14,11 @@ from typing import Any
 
 HOOK_ROOT = Path(__file__).resolve().parent.parent
 ALLOWED_FEATURES = {
-    "active_task_context.py",
-    "health_check.py",
-    "pre_stop_check.py",
-    "subagent_tracker.py",
-    "workflow_checkpoint.py",
+    "block_dangerous_commands.py",
+    "compact_context.py",
+    "mid_workflow_recall.py",
+    "post_edit_guard.py",
+    "session_context.py",
 }
 
 

package/hooks/adapters/kimi.py

@@ -1,7 +1,7 @@
 #!/usr/bin/env python3
-"""Kimi Code wire adapter for Ultra Builder Pro lifecycle hooks.
+"""Kimi Code wire adapter for Ultra Builder Pro's five file-first hooks.
 
-Kimi 0.26 uses snake_case JSON input compatible with the workflow hooks, but
+Kimi uses snake_case JSON input compatible with the shared hooks, but
 its output contract accepts only ``message`` plus an optional structured deny.
 This adapter preserves explicit projection denials and optional Stop decisions, converts foreign context
 fields into Kimi messages, and fails open with diagnostic evidence.
@@ -20,18 +20,16 @@ from typing import Any
 
 HOOK_ROOT = Path(__file__).resolve().parent.parent
 ALLOWED_FEATURES = {
-    "active_task_context.py",
-    "health_check.py",
-    "pre_stop_check.py",
-    "subagent_tracker.py",
-    "workflow_checkpoint.py",
-    "workflow_context.py",
-    "workflow_resume.py",
+    "block_dangerous_commands.py",
+    "compact_context.py",
+    "mid_workflow_recall.py",
+    "post_edit_guard.py",
+    "session_context.py",
 }
 
 
 def normalize_input(payload: dict[str, Any]) -> dict[str, Any]:
-    """Add only the legacy aliases required by the shared workflow hooks."""
+    """Add only aliases required by the shared file-first hooks."""
     normalized = copy.deepcopy(payload)
     agent_name = normalized.get("agent_name")
     if isinstance(agent_name, str) and agent_name:
@@ -101,10 +99,6 @@ def run_feature(feature: str, payload: dict[str, Any], feature_args: list[str])
 
     event = str(payload.get("hook_event_name") or "")
     normalized = normalize_input(payload)
-    if feature == "workflow_resume.py" and event == "PostCompact":
-        normalized["hook_event_name"] = "SessionStart"
-        normalized["source"] = "compact"
-
     env = os.environ.copy()
     env["UBP_HOOK_RUNTIME"] = "kimi"
     plugin_data = env.get("PLUGIN_DATA") or env.get("KIMI_PLUGIN_ROOT")