hyperweave 0.3.5__tar.gz → 0.3.6__tar.gz

{hyperweave-0.3.5 → hyperweave-0.3.6}/CHANGELOG.md

@@ -5,6 +5,29 @@ All notable changes to HyperWeave are documented in this file.
 The format is based on [Keep a Changelog](https://keepachangelog.com/en/1.1.0/),
 and this project adheres to [Semantic Versioning](https://semver.org/spec/v2.0.0.html).
 
+## [0.3.6] - 2026-05-18
+
+Receipt active-duration sources from per-turn compute when the runtime emits it; long-running sessions no longer inflate via stage-span summation. Codex hooks migrate to the wrapped-matcher GA layout shipped in the Codex CLI v0.129 release. The `data-hw-genome` root attribute reflects the resolved genome ID instead of raw spec input.
+
+### Added
+
+- **`just tag VERSION MESSAGE`** — annotated tag plus automatic `_version.py` refresh so the `doctor` banner and metadata version stay in sync after release.
+- **`just version-refresh`** — standalone recipe to rebuild `_version.py` from the current git tag.
+
+### Changed
+
+- **Receipt active-duration** — Claude Code sessions source from `system.turn_duration` events; Codex and mocked fixtures fall back to the prior `min(stage-span sum, wall-clock span)` formula.
+- **Session contract** — new `turn_duration_minutes` field surfaces the parser's per-turn compute sum; null when the runtime emits no per-turn signal.
+- **Codex hooks file** — `install-hook` writes the wrapped-matcher GA format (Codex CLI v0.129+). Existing flat installs are migrated on next install.
+- **Hooks feature flag** — `codex_hooks` renames to `hooks` to match Codex's GA terminology; the legacy name continues to work for one release.
+- **`hyperweave doctor`** — traverses both the new wrapped format and the legacy flat layout, surfacing a migration prompt when a flat config is detected.
+- **Genome root attribute** — `data-hw-genome` reflects the resolved genome ID instead of raw spec input, so variants and auto-resolved genomes never emit empty.
+
+### Notes
+
+- Codex sessions hit the active-duration fallback because the runtime emits no per-turn duration signal.
+- `_version.py` refreshes automatically when tagging through `just tag`.
+
 ## [0.3.5] - 2026-05-17
 
 Receipt hero reads `token volume · $cost` with a four-cell decomposition strip below (IN / OUT / CACHED / WRITTEN), making the asymmetric cache-token math legible at a glance. Codex receipts now price tokens against the OpenAI rate card; figures previously inflated ~2× drop to actual GPT rates.

{hyperweave-0.3.5 → hyperweave-0.3.6}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: hyperweave
-Version: 0.3.5
+Version: 0.3.6
 Summary: Headless visual output layer for AI agents. One API call → self-contained SVG.
 Project-URL: Repository, https://github.com/InnerAura/hyperweave
 Project-URL: Issues, https://github.com/InnerAura/hyperweave/issues

{hyperweave-0.3.5 → hyperweave-0.3.6}/justfile

@@ -48,3 +48,13 @@ docs:
 
 build:
     uv build
+
+version-refresh:
+    uv pip install -e . --force-reinstall --no-deps --quiet
+    @uv run python -c "import hyperweave; print(f'_version.py refreshed to {hyperweave.__version__}')"
+
+tag VERSION MESSAGE:
+    git tag -a {{VERSION}} -m "{{MESSAGE}}"
+    just version-refresh
+    @echo ""
+    @echo "Tagged {{VERSION}}. Push with: git push --follow-tags"

{hyperweave-0.3.5 → hyperweave-0.3.6}/src/hyperweave/_version.py

@@ -18,7 +18,7 @@ version_tuple: tuple[int | str, ...]
 commit_id: str | None
 __commit_id__: str | None
 
-__version__ = version = '0.3.5'
-__version_tuple__ = version_tuple = (0, 3, 5)
+__version__ = version = '0.3.6'
+__version_tuple__ = version_tuple = (0, 3, 6)
 
 __commit_id__ = commit_id = None

{hyperweave-0.3.5 → hyperweave-0.3.6}/src/hyperweave/cli.py

@@ -567,8 +567,45 @@ def _install_claude_code_hook(hook_command: str, full_slug: str) -> None:
     typer.echo(f"Installed SessionEnd hook in {settings_path}{pinned}")
 
 
+# Codex hook event names (v0.129.0 GA). Used by ``_install_codex_hook`` and
+# ``_doctor_runtime_status`` to detect pre-GA flat-format event keys sitting
+# at the top of ``hooks.json`` and lift them under the canonical ``hooks``
+# wrapper introduced when hooks went GA.
+_CODEX_HOOK_EVENTS = frozenset(
+    {
+        "SessionStart",
+        "PreToolUse",
+        "PermissionRequest",
+        "PostToolUse",
+        "UserPromptSubmit",
+        "Stop",
+    }
+)
+
+
+def _wrap_legacy_codex_hook_entry(entry: object) -> object:
+    """Lift a pre-GA bare-command hook entry into the GA matcher+hooks group.
+
+    Codex v0.129 (hooks GA) changed each event-array entry from a bare
+    ``{type, command, timeout}`` to a matcher group
+    ``{matcher, hooks: [{type, command, timeout}]}``. Idempotent: an entry
+    already carrying a list-valued ``hooks`` key is returned unchanged so
+    repeated migrations stay stable. Bare-command entries are wrapped under
+    a universal ``"*"`` matcher; the matcher is parsed-but-ignored for Stop
+    today per the spec, but we use ``"*"`` for forward-compat against any
+    future Codex release that begins to honor it on Stop.
+    """
+    if not isinstance(entry, dict):
+        return entry
+    if isinstance(entry.get("hooks"), list):
+        return entry  # already in GA shape
+    if entry.get("type") == "command":
+        return {"matcher": "*", "hooks": [entry]}
+    return entry  # unknown shape — preserve as-is
+
+
 def _install_codex_hook(hook_command: str, full_slug: str) -> None:
-    """Write a Stop hook to ``~/.codex/hooks.json`` + enable codex_hooks feature.
+    """Write a Stop hook to ``~/.codex/hooks.json`` + enable hooks feature.
 
     Per developers.openai.com/codex/hooks, Codex CLI fires Stop hooks
     PER-TURN (after every assistant response). The receipt rewrites the
@@ -579,9 +616,21 @@ def _install_codex_hook(hook_command: str, full_slug: str) -> None:
     will lean into live-receipt consumers (file watchers, dashboards)
     rather than collapse it back to a single session-end event.
 
-    Also writes ``[features] codex_hooks = true`` to ``~/.codex/config.toml``
-    (preserving any other keys); the feature flag is required for the
-    hook system to fire.
+    Codex v0.129.0 (2026-05-07) took hooks GA with two shape changes the
+    installer handles via migration-on-write:
+
+    * ``hooks.json`` moved from flat ``{Stop: [{type, command, timeout}]}``
+      to wrapped ``{hooks: {Stop: [{matcher, hooks: [{type, command,
+      timeout}]}]}}``. Any pre-GA event keys at the top level are lifted
+      under the new wrapper; each bare-command entry is wrapped under a
+      universal ``"*"`` matcher group.
+    * ``[features].codex_hooks`` was aliased as ``[features].hooks``. The
+      installer strips any legacy ``codex_hooks`` entry and writes the
+      canonical ``hooks = true``.
+
+    Both migrations are idempotent — re-running install-hook over any
+    combination of pre-GA, partially-migrated, or GA configs converges to
+    the canonical GA shape with exactly one hyperweave entry.
     """
     import json
 
@@ -590,48 +639,99 @@ def _install_codex_hook(hook_command: str, full_slug: str) -> None:
     config_path = codex_dir / "config.toml"
     codex_dir.mkdir(parents=True, exist_ok=True)
 
-    # ── Update hooks.json: remove prior hyperweave Stop entries, append new one ──
+    # ── Update hooks.json: lift any pre-GA flat keys into the wrapper, then
+    # operate on hooks.Stop as the canonical GA structure ──
     config: dict[str, object] = {}
     if hooks_path.exists():
-        config = json.loads(hooks_path.read_text())
-
-    raw_stop = config.setdefault("Stop", [])
-    stop_hooks: list[object] = raw_stop if isinstance(raw_stop, list) else []
-    if not isinstance(raw_stop, list):
-        config["Stop"] = stop_hooks
+        loaded = json.loads(hooks_path.read_text())
+        if isinstance(loaded, dict):
+            config = loaded
+
+    # GA wrapper: hooks lives under config["hooks"]. Pre-GA configs may not
+    # have it yet; create it (or reset if it's the wrong shape).
+    wrapper_raw = config.setdefault("hooks", {})
+    hooks_wrapper: dict[str, object]
+    if isinstance(wrapper_raw, dict):
+        hooks_wrapper = wrapper_raw
+    else:
+        hooks_wrapper = {}
+        config["hooks"] = hooks_wrapper
+
+    # Lift any pre-GA top-level event keys (Stop, PreToolUse, etc.) into the
+    # wrapper, wrapping bare-command entries with a universal matcher group.
+    # Iterate over a snapshot of keys since we mutate during traversal.
+    for legacy_event in list(config.keys()):
+        if legacy_event == "hooks" or legacy_event not in _CODEX_HOOK_EVENTS:
+            continue
+        legacy_value = config.pop(legacy_event)
+        if not isinstance(legacy_value, list):
+            continue
+        target_raw = hooks_wrapper.setdefault(legacy_event, [])
+        target: list[object]
+        if isinstance(target_raw, list):
+            target = target_raw
+        else:
+            target = []
+            hooks_wrapper[legacy_event] = target
+        for entry in legacy_value:
+            target.append(_wrap_legacy_codex_hook_entry(entry))
+
+    # Now drop any prior hyperweave matcher groups under hooks.Stop and
+    # append the fresh one. A hyperweave group is identified by ANY inner
+    # handler whose command mentions "hyperweave session".
+    raw_stop = hooks_wrapper.setdefault("Stop", [])
+    stop_groups: list[object]
+    if isinstance(raw_stop, list):
+        stop_groups = raw_stop
+    else:
+        stop_groups = []
+        hooks_wrapper["Stop"] = stop_groups
 
-    cleaned = []
-    for entry in stop_hooks:
-        if not isinstance(entry, dict):
-            cleaned.append(entry)
+    cleaned: list[object] = []
+    for group in stop_groups:
+        if not isinstance(group, dict):
+            cleaned.append(group)
             continue
-        cmd = str(entry.get("command", ""))
-        if "hyperweave session" in cmd:
-            continue  # drop prior hyperweave hook
-        cleaned.append(entry)
-    cleaned.append({"type": "command", "command": hook_command, "timeout": 10})
-    config["Stop"] = cleaned
+        inner_hooks = group.get("hooks", [])
+        if isinstance(inner_hooks, list) and any(
+            isinstance(h, dict) and "hyperweave session" in str(h.get("command", "")) for h in inner_hooks
+        ):
+            continue  # drop the whole matcher group — owned by hyperweave
+        cleaned.append(group)
+    cleaned.append(
+        {
+            "matcher": "*",
+            "hooks": [{"type": "command", "command": hook_command, "timeout": 10}],
+        }
+    )
+    hooks_wrapper["Stop"] = cleaned
     hooks_path.write_text(json.dumps(config, indent=2) + "\n")
 
-    # ── Update config.toml: ensure [features] codex_hooks = true (preserve other keys) ──
+    # ── Update config.toml: ensure [features] hooks = true (preserve other keys) ──
+    # Codex v0.130.0 renamed the gate from `codex_hooks` to `hooks`; strip any
+    # legacy key on the way in so re-running install-hook over an older config
+    # upgrades cleanly instead of leaving a dead key. Key detection is exact-
+    # match (split-on-=, strip), not prefix, so `hooks_*` lookalikes can't
+    # spoof a hit.
     config_lines: list[str] = []
     if config_path.exists():
         config_lines = config_path.read_text().splitlines()
+    config_lines = [line for line in config_lines if line.split("=", 1)[0].strip() != "codex_hooks"]
     has_features_section = any(line.strip() == "[features]" for line in config_lines)
-    has_codex_hooks_key = any(line.strip().startswith("codex_hooks") for line in config_lines)
+    has_hooks_key = any("=" in line and line.split("=", 1)[0].strip() == "hooks" for line in config_lines)
     if not has_features_section:
-        config_lines.extend(["", "[features]", "codex_hooks = true"])
-    elif not has_codex_hooks_key:
-        # Insert codex_hooks = true right after [features] header
+        config_lines.extend(["", "[features]", "hooks = true"])
+    elif not has_hooks_key:
+        # Insert hooks = true right after [features] header
         for i, line in enumerate(config_lines):
             if line.strip() == "[features]":
-                config_lines.insert(i + 1, "codex_hooks = true")
+                config_lines.insert(i + 1, "hooks = true")
                 break
     config_path.write_text("\n".join(config_lines) + "\n")
 
     pinned = f" (pinned to {full_slug})" if full_slug else " (auto-detect skin)"
     typer.echo(f"Installed Stop hook in {hooks_path}{pinned}")
-    typer.echo(f"Set [features] codex_hooks = true in {config_path}")
+    typer.echo(f"Set [features] hooks = true in {config_path}")
     typer.echo(
         "Note: Codex Stop fires per-turn — the receipt file refreshes live as the "
         "session progresses, always reflecting current cumulative state.",
@@ -702,7 +802,7 @@ def install_hook(
                 "auto-detects installed runtimes (~/.claude, ~/.codex, or 'claude'/"
                 "'codex' on PATH) and registers for each present. 'claude-code' "
                 "writes a SessionEnd hook to ~/.claude/settings.json. 'codex' writes "
-                "a Stop hook to ~/.codex/hooks.json plus [features] codex_hooks in "
+                "a Stop hook to ~/.codex/hooks.json plus [features] hooks in "
                 "~/.codex/config.toml. 'all' forces both regardless of detection."
             ),
         ),
@@ -771,8 +871,8 @@ def _doctor_runtime_status(runtime: str, home_dir: Path) -> str:
     Returns ``✓`` when the hyperweave hook is wired correctly, ``✗`` when
     the runtime is initialized but no hyperweave hook is registered, or
     ``⚠`` when the wiring is partial (malformed config; codex missing the
-    [features] codex_hooks flag). The string is rendered verbatim by
-    ``doctor``.
+    [features] hooks flag — renamed from ``codex_hooks`` in Codex v0.130.0).
+    The string is rendered verbatim by ``doctor``.
     """
     import json
 
@@ -802,24 +902,56 @@ def _doctor_runtime_status(runtime: str, home_dir: Path) -> str:
         hooks_path = home_dir / "hooks.json"
         config_path = home_dir / "config.toml"
         registered_cmd: str | None = None
+        legacy_flat_cmd: str | None = None
         if hooks_path.exists():
             try:
                 hooks = json.loads(hooks_path.read_text())
             except json.JSONDecodeError:
                 return f"⚠ {runtime}: ~/.codex/hooks.json is malformed"
-            for entry in hooks.get("Stop", []) or []:
-                if not isinstance(entry, dict):
-                    continue
-                cmd = str(entry.get("command", ""))
-                if "hyperweave session" in cmd:
-                    registered_cmd = cmd
-                    break
+            # GA traversal (Codex v0.129+):
+            #   hooks["hooks"]["Stop"][group].hooks[handler].command
+            wrapper = hooks.get("hooks") if isinstance(hooks, dict) else None
+            if isinstance(wrapper, dict):
+                for group in wrapper.get("Stop") or []:
+                    if not isinstance(group, dict):
+                        continue
+                    for handler in group.get("hooks") or []:
+                        if not isinstance(handler, dict):
+                            continue
+                        cmd = str(handler.get("command", ""))
+                        if "hyperweave session" in cmd:
+                            registered_cmd = cmd
+                            break
+                    if registered_cmd:
+                        break
+            # Pre-GA flat fallback (kept for one release): hooks["Stop"][entry]
+            # with command directly on the entry. Detected separately so a
+            # legacy install surfaces as ⚠ with an upgrade pointer instead of
+            # silently misreporting the hook as missing.
+            if not registered_cmd and isinstance(hooks, dict):
+                for entry in hooks.get("Stop") or []:
+                    if not isinstance(entry, dict):
+                        continue
+                    cmd = str(entry.get("command", ""))
+                    if "hyperweave session" in cmd:
+                        legacy_flat_cmd = cmd
+                        break
+        if legacy_flat_cmd and not registered_cmd:
+            return (
+                f"⚠ {runtime}: hook registered in legacy pre-GA flat format — "
+                f"re-run 'hyperweave install-hook --runtime {runtime}' to lift "
+                f"it to the GA wrapped structure (Codex v0.129+)"
+            )
         if not registered_cmd:
             return (
                 f"✗ {runtime}: initialized but no hyperweave hook — run 'hyperweave install-hook --runtime {runtime}'"
             )
-        # [features] codex_hooks = true must be present for the hook to fire;
-        # the install command writes it, but a hand-edited config could miss it.
+        # [features] hooks = true must be present for the hook to fire; the
+        # install command writes it, but a hand-edited config could miss it.
+        # Codex v0.130.0 renamed the gate from `codex_hooks` to `hooks`; key
+        # detection is exact-match within the [features] section so a stale
+        # `codex_hooks = true` left over from older installs is not mistaken
+        # for the live gate (and so `hooks_*` lookalikes can't spoof a hit).
         feature_ok = False
         if config_path.exists():
             in_features = False
@@ -831,12 +963,14 @@ def _doctor_runtime_status(runtime: str, home_dir: Path) -> str:
                 if in_features and stripped.startswith("["):
                     in_features = False
                     continue
-                if in_features and stripped.startswith("codex_hooks") and "true" in stripped:
-                    feature_ok = True
-                    break
+                if in_features and "=" in stripped:
+                    key, _, value = stripped.partition("=")
+                    if key.strip() == "hooks" and "true" in value:
+                        feature_ok = True
+                        break
         if not feature_ok:
             return (
-                f"⚠ {runtime}: hook registered but [features] codex_hooks = true "
+                f"⚠ {runtime}: hook registered but [features] hooks = true "
                 f"is missing — re-run 'hyperweave install-hook --runtime {runtime}'"
             )
         return f"✓ {runtime}: hook registered — {registered_cmd}"

{hyperweave-0.3.5 → hyperweave-0.3.6}/src/hyperweave/compose/context.py

@@ -181,7 +181,7 @@ def _base_context(
         "artifact_id": artifact_id,
         "contract_id": artifact_id,
         "frame_type": spec.type,
-        "genome_id": spec.genome_id,
+        "genome_id": resolved.genome.get("id", spec.genome_id),
         "genome_category": resolved.genome.get("category", "dark"),
         # v0.3.2: variant + substrate_kind plumbed through to templates.
         # substrate_kind drives the brutalist split-template dispatcher

{hyperweave-0.3.5 → hyperweave-0.3.6}/src/hyperweave/compose/resolver.py

@@ -1872,44 +1872,65 @@ def _format_model_label(model: str) -> str:
     return label
 
 
-def _active_window_minutes(stages: list[dict[str, Any]], fallback_m: float) -> float:
-    """Active work duration in minutes, bounded by both sum and wall-clock.
-
-    Returns ``min(sum_of_stage_durations, wall_clock_first_to_last)``:
-      * Sum_of_stages handles idle gaps — sessions left open across multiple
-        bursts over days resolve to actual work hours, not wall-clock days.
-      * Wall-clock cap handles overlapping/async stages — when stage end
-        timestamps extend past the last visible session message (async tool
-        completion), the sum can exceed the wall-clock first→last span.
-        Without the cap, the chart axis disagrees with the hero subline.
-
-    Both are stage-derived, so the chart and hero see the same number from
-    the same primary source (stage timestamps) — never from the parser's
-    ``duration_minutes`` which can be unreliable.
+def _active_window_minutes(
+    stages: list[dict[str, Any]],
+    fallback_m: float,
+    turn_duration_m: float | None = None,
+) -> float:
+    """Active work duration in minutes.
+
+    Primary source is ``turn_duration_m`` — the parser's sum of per-turn
+    compute durations from ``system.turn_duration`` events (Claude Code).
+    This measures agent compute time directly and never absorbs idle gaps
+    that the stage detector failed to break on (a multi-hour break inside
+    a same-class working stretch silently inflates a stage's span).
+
+    Fallback is ``min(sum_of_stage_durations, wall_clock_first_to_last)``
+    when the runtime emits no per-turn duration events (Codex) or when
+    stages lack ISO timestamps (mock fixtures):
+      * Sum_of_stages collapses inter-stage idle in sessions left open
+        across multiple bursts over days.
+      * Wall-clock cap defends against any future stage detector that
+        produces overlapping spans (today's partition algorithm cannot,
+        but the cap costs nothing).
+
+    The wall-clock cap applies to the turn-duration source too — defensive
+    against malformed turn_duration values exceeding the session span.
 
     Returns ``fallback_m`` when stages lack ISO timestamps (mock data) or
     when parsing fails.
     """
     if not stages:
+        if turn_duration_m is not None and turn_duration_m > 0:
+            return max(turn_duration_m, 1.0)
         return fallback_m
-    durations: list[float] = []
     starts: list[datetime] = []
     ends: list[datetime] = []
+    durations: list[float] = []
     for s in stages:
         start = s.get("start")
         end = s.get("end")
         if not start or not end:
+            if turn_duration_m is not None and turn_duration_m > 0:
+                return max(turn_duration_m, 1.0)
             return fallback_m
         try:
             t0 = datetime.fromisoformat(start)
             t_end = datetime.fromisoformat(end)
         except (ValueError, TypeError):
+            if turn_duration_m is not None and turn_duration_m > 0:
+                return max(turn_duration_m, 1.0)
             return fallback_m
         starts.append(t0)
         ends.append(t_end)
         durations.append((t_end - t0).total_seconds() / 60.0)
-    sum_m = sum(durations)
     wall_clock_m = (max(ends) - min(starts)).total_seconds() / 60.0
+    if turn_duration_m is not None and turn_duration_m > 0:
+        # Cap defensively at wall-clock so a runtime emitting impossibly
+        # large turn_duration values can't make the chart disagree with
+        # itself; in practice turn_duration_m << wall_clock_m always.
+        return max(min(turn_duration_m, wall_clock_m), 1.0)
+    sum_m = sum(durations)
     return max(min(sum_m, wall_clock_m), 1.0)
 
 
@@ -2009,10 +2030,17 @@ def resolve_receipt(
         )
     ]
     duration_m = session.get("duration_minutes", 0)
-    # Active window: bounded by both sum-of-stages (collapses idle gaps) and
-    # wall-clock span (caps overlapping/async stages). Same value drives the
+    turn_duration_m = session.get("turn_duration_minutes")
+    # Active window: prefers the parser's per-turn compute sum (Claude
+    # Code's `system.turn_duration` events) and falls back to
+    # min(stage-span sum, wall-clock) when the runtime emits no per-turn
+    # signal (Codex) or stages lack timestamps. Same value drives the
     # chart geometry AND the hero subline, so they always agree.
-    active_duration_m = _active_window_minutes(stages, float(duration_m))
+    active_duration_m = _active_window_minutes(
+        stages,
+        float(duration_m),
+        float(turn_duration_m) if turn_duration_m is not None else None,
+    )
     wall_clock_m = _wall_clock_minutes(stages, float(duration_m))
     # ``total`` for the divergence flag: max of parser-reported duration and
     # the stage-derived wall-clock. The parser may overstate (idle tail) or

{hyperweave-0.3.5 → hyperweave-0.3.6}/src/hyperweave/telemetry/codex_parser.py

@@ -373,6 +373,10 @@ def parse_transcript(transcript_path: str | Path) -> SessionTelemetry:
             n_assistant_msgs += 1
 
     # ── Compute timestamps + duration ──
+    # Codex emits no per-turn duration events analogous to Claude Code's
+    # `system.turn_duration`, so `turn_duration_minutes` stays None and the
+    # receipt's active-duration line falls back to min(stage-span sum,
+    # wall-clock span). Wall-clock is the only signal available here.
     timestamps = [_parse_timestamp(line.get("timestamp")) for line in raw_lines if line.get("timestamp")]
     session_start = min(timestamps) if timestamps else datetime.now()
     session_end = max(timestamps) if timestamps else session_start
@@ -431,6 +435,7 @@ def parse_transcript(transcript_path: str | Path) -> SessionTelemetry:
         runtime=_REGISTRY.runtime,
         timestamp=session_start,
         duration_minutes=round(duration_minutes, 2),
+        turn_duration_minutes=None,  # Codex has no per-turn duration events
         tool_calls=all_tool_calls,
         stages=[],  # populated by stages.detect_stages
         agents=[],  # Codex has no Task-style subagent dispatch

{hyperweave-0.3.5 → hyperweave-0.3.6}/src/hyperweave/telemetry/contract.py

@@ -108,6 +108,11 @@ def _assemble(t: SessionTelemetry, cost: float) -> dict[str, Any]:
             "start": t.timestamp.isoformat(),
             "end": end,
             "duration_minutes": t.duration_minutes,
+            # Per-turn compute sum when the runtime emits it (Claude Code's
+            # `system.turn_duration` events). None for Codex and any runtime
+            # without per-turn duration signal; the resolver falls back to
+            # min(stage-span sum, wall-clock) in that case.
+            "turn_duration_minutes": t.turn_duration_minutes,
             "model": t.model or "",
             "git_branch": t.git_branch or "",
             "project_path": t.project_path or "",

{hyperweave-0.3.5 → hyperweave-0.3.6}/src/hyperweave/telemetry/models.py

@@ -271,6 +271,18 @@ class SessionTelemetry(BaseModel):
     )
     timestamp: datetime = Field(description="Session start time")
     duration_minutes: float = Field(default=0.0, description="Wall-clock duration")
+    turn_duration_minutes: float | None = Field(
+        default=None,
+        description=(
+            "Sum of per-turn compute durations when the runtime emits them. "
+            "Claude Code emits `system.turn_duration` events and the parser "
+            "sums them here; Codex has no equivalent and leaves this None. "
+            "Receipts prefer this over stage-span sums because it counts "
+            "agent compute time directly and never absorbs idle gaps that "
+            "the stage detector failed to break on. None signals the "
+            "fallback path (min of stage-span sum and wall-clock span)."
+        ),
+    )
     tool_calls: list[ToolCall] = Field(
         default_factory=list,
         description="Flat ordered list of all tool calls",

{hyperweave-0.3.5 → hyperweave-0.3.6}/src/hyperweave/telemetry/parser.py

@@ -368,10 +368,15 @@ def parse_transcript(transcript_path: str | Path) -> SessionTelemetry:
     session_start = min(timestamps) if timestamps else datetime.now()
     session_end = max(timestamps) if timestamps else session_start
 
+    # turn_duration_minutes is the receipt's primary "active" source when present —
+    # it measures per-turn compute time and ignores idle gaps the stage detector
+    # silently absorbs into a stage span. None signals the fallback path.
     if total_duration_ms > 0:
         duration_minutes = total_duration_ms / 60_000
+        turn_duration_minutes: float | None = duration_minutes
     else:
         duration_minutes = (session_end - session_start).total_seconds() / 60
+        turn_duration_minutes = None
 
     # -- Extract unique file paths (ordered) --
     files_accessed: list[str] = []
@@ -437,6 +442,7 @@ def parse_transcript(transcript_path: str | Path) -> SessionTelemetry:
         runtime=_REGISTRY.runtime,
         timestamp=session_start,
         duration_minutes=round(duration_minutes, 2),
+        turn_duration_minutes=(round(turn_duration_minutes, 2) if turn_duration_minutes is not None else None),
         tool_calls=all_tool_calls,
         stages=[],
         agents=agents,

{hyperweave-0.3.5 → hyperweave-0.3.6}/tests/test_doctor.py

@@ -45,14 +45,37 @@ def _write_codex_hook(
     *,
     with_feature_flag: bool = True,
 ) -> None:
+    """Write a Codex hook in the GA wrapped+matcher format (Codex v0.129+)."""
     codex_dir = home / ".codex"
     codex_dir.mkdir(parents=True, exist_ok=True)
-    hooks = {"Stop": [{"type": "command", "command": command, "timeout": 10}]}
+    hooks = {
+        "hooks": {
+            "Stop": [
+                {
+                    "matcher": "*",
+                    "hooks": [{"type": "command", "command": command, "timeout": 10}],
+                }
+            ]
+        }
+    }
     (codex_dir / "hooks.json").write_text(json.dumps(hooks, indent=2))
-    config_lines = ["[features]", "codex_hooks = true"] if with_feature_flag else ["[other]", "key = 1"]
+    config_lines = ["[features]", "hooks = true"] if with_feature_flag else ["[other]", "key = 1"]
     (codex_dir / "config.toml").write_text("\n".join(config_lines) + "\n")
 
 
+def _write_codex_hook_legacy_flat(home: Path, command: str) -> None:
+    """Write a Codex hook in the pre-GA flat shape (no wrapper, bare entries).
+
+    Used to drive the doctor's legacy-detection path so a stale install
+    surfaces as ⚠ with an upgrade pointer.
+    """
+    codex_dir = home / ".codex"
+    codex_dir.mkdir(parents=True, exist_ok=True)
+    hooks = {"Stop": [{"type": "command", "command": command, "timeout": 10}]}
+    (codex_dir / "hooks.json").write_text(json.dumps(hooks, indent=2))
+    (codex_dir / "config.toml").write_text("[features]\nhooks = true\n")
+
+
 # ─────────────────────────────────────────────────────────────────────────────
 # Doctor — runtime detection states
 # ─────────────────────────────────────────────────────────────────────────────
@@ -98,8 +121,34 @@ def test_doctor_codex_initialized_but_no_hook(monkeypatch: MonkeyPatch, tmp_path
     assert "hyperweave install-hook --runtime codex" in result.stdout
 
 
+def test_doctor_codex_hook_in_legacy_flat_format_surfaces_warning(monkeypatch: MonkeyPatch, tmp_path: Path) -> None:
+    """Pre-GA flat hooks.json surfaces as ⚠ with an upgrade pointer, not ✗.
+
+    Codex v0.129.0 took hooks GA and changed hooks.json from flat
+    ``{Stop: [{type, command, timeout}]}`` to wrapped
+    ``{hooks: {Stop: [{matcher, hooks: [{type, command, timeout}]}]}}``.
+    A user with a stale install — hyperweave entry written in the flat
+    shape — would otherwise look like "no hyperweave hook" to doctor and
+    leave the silent symptom (Codex ignores the file, no receipt fires)
+    undiagnosed. The legacy-detection branch flips that to ⚠ with a
+    re-install pointer.
+    """
+    _patch_home(monkeypatch, tmp_path)
+    _patch_which(monkeypatch, {"claude": None, "codex": None})
+    _write_codex_hook_legacy_flat(tmp_path, "hyperweave session receipt --genome telemetry-codex")
+    monkeypatch.chdir(tmp_path)
+
+    runner = CliRunner()
+    result = runner.invoke(app, ["doctor"])
+    assert result.exit_code == 0
+    assert "⚠ codex" in result.stdout
+    assert "legacy pre-GA flat format" in result.stdout
+    assert "hyperweave install-hook --runtime codex" in result.stdout
+
+
 def test_doctor_codex_hook_registered_but_feature_flag_missing(monkeypatch: MonkeyPatch, tmp_path: Path) -> None:
-    """Codex Stop hook only fires when [features] codex_hooks = true is set."""
+    """Codex Stop hook only fires when [features] hooks = true is set (renamed
+    from codex_hooks in Codex v0.130.0)."""
     _patch_home(monkeypatch, tmp_path)
     _patch_which(monkeypatch, {"claude": None, "codex": None})
     _write_codex_hook(tmp_path, "hyperweave session receipt", with_feature_flag=False)
@@ -109,7 +158,7 @@ def test_doctor_codex_hook_registered_but_feature_flag_missing(monkeypatch: Monk
     result = runner.invoke(app, ["doctor"])
     assert result.exit_code == 0
     assert "⚠ codex" in result.stdout
-    assert "codex_hooks" in result.stdout
+    assert "[features] hooks = true" in result.stdout
 
 
 def test_doctor_codex_binary_only_state(monkeypatch: MonkeyPatch, tmp_path: Path) -> None: