checkpoint

⚒️ Generated with [Fabro](https://fabro.sh)

stages/004-preflight_lint@1/output.log

@@ -0,0 +1 @@
+blob://sha256/12ae32cb1ec02d01eda3581b127c1fee3b0dc53572ed6baf239721a03d82e126

stages/004-preflight_lint@1/script_timing.json

@@ -0,0 +1,8 @@
+{
+  "output": "blob://sha256/12ae32cb1ec02d01eda3581b127c1fee3b0dc53572ed6baf239721a03d82e126",
+  "exit_code": 0,
+  "duration_ms": 138940,
+  "termination": "exited",
+  "output_bytes": 0,
+  "live_streaming": false
+}

stages/004-preflight_lint@1/status.json

@@ -0,0 +1,6 @@
+{
+  "outcome": "succeeded",
+  "notes": "Script completed: cargo +nightly-2026-04-14 clippy -q --workspace --all-targets -- -D warnings 2>&1",
+  "failure_reason": null,
+  "timestamp": "2026-05-21T18:48:35.791443Z"
+}

stages/005-implement@1/prompt.md

@@ -0,0 +1,179 @@
+Goal: ---
+title: "feat: Wall and active time metrics"
+type: feature
+status: active
+date: 2026-05-21
+---
+
+# feat: Wall and active time metrics
+
+## Summary
+
+Rename runtime duration concepts from ambiguous duration/runtime/elapsed fields
+to explicit wall-time fields, then add first-class active timing.
+
+Definitions:
+
+- `wall_time_ms`: elapsed clock time from start to finish.
+- `inference_time_ms`: Fabro-observed LLM request/stream elapsed time.
+- `tool_time_ms`: tool or command execution elapsed time.
+- `active_time_ms`: `inference_time_ms + tool_time_ms`.
+
+This is greenfield API churn. Do not preserve old public run/stage timing
+fields, aliases, or compatibility shims for `duration_ms`, `runtime_secs`, or
+`elapsed_secs` on run/stage runtime surfaces.
+
+Run-level active time is total work performed: sum active timing across stage
+visits. Parallel work is summed, so run active time can exceed run wall time.
+
+## Key Changes
+
+- Add a shared timing value object in `fabro-types` for stage/run active timing:
+  - `wall_time_ms`
+  - `inference_time_ms`
+  - `tool_time_ms`
+  - derived or stored `active_time_ms`
+- Replace run/stage public timing fields:
+  - stage/run terminal event props use `wall_time_ms` plus the active timing
+    breakdown.
+  - `StageProjection` stores the timing breakdown instead of stage
+    `duration_ms`.
+  - `RunTimestamps` keeps timestamps only; move elapsed values into a separate
+    run timing object.
+  - `/runs/{id}/stages` and `/runs/{id}/billing` expose timing in milliseconds,
+    not `runtime_secs`.
+- Keep `duration_ms` only for unrelated subsystem-specific operational events
+  where the name is still local and unambiguous, such as sandbox setup,
+  metadata snapshot, devcontainer lifecycle, and hook execution. The cleanup
+  target is public run/stage runtime semantics.
+- Update OpenAPI and regenerate the Rust and TypeScript API clients after
+  schema edits.
+
+## Timing Behavior
+
+- `prompt` nodes:
+  - inference = elapsed time spent in the one-shot LLM backend call.
+  - tool = 0.
+- native `agent` nodes:
+  - inference = sum of elapsed time spent opening/consuming LLM streams for new
+    turns in the stage.
+  - tool = sum of elapsed time spent executing agent tool calls.
+  - retry backoff and waiting for steering are wall time, not active time.
+- opaque external/ACP agent nodes:
+  - inference = 0 for v1 because Fabro cannot reliably separate model time from
+    process runtime.
+  - tool = external agent process wall time.
+- `command` nodes:
+  - inference = 0.
+  - tool = command wall time from the sandbox command result.
+- `human`, `wait`, `conditional`, `fan-in`, `start`, and `exit`:
+  - inference = 0.
+  - tool = 0.
+- `parallel` container nodes:
+  - active = 0 on the container stage.
+  - child/branch stages carry work timing so rollups do not double count.
+
+## Implementation
+
+- In `fabro-types`, introduce the timing structs and replace the relevant fields
+  in `Outcome`, `NodeResult` consumers, `StageProjection`, `Conclusion`,
+  `RunTimestamps`, `RunCompletedProps`, `RunFailedProps`,
+  `StageCompletedProps`, `StageFailedProps`, `RunBillingStage`, and
+  `RunBillingTotals`.
+- In `fabro-workflow`, rename run/stage execution fields from `duration_ms` to
+  `wall_time_ms` and thread timing through lifecycle events, terminal events,
+  conclusion building, pull request summaries, timeline/billing rollups, and
+  test support fixtures.
+- In `fabro-agent`, add timing data to agent events or session results so
+  `fabro-workflow` can aggregate:
+  - LLM stream/request elapsed time per assistant response.
+  - tool call elapsed time per tool completion.
+  - preserve token billing behavior separately from timing.
+- In `fabro-store`, update event projection to write stage `started_at`, timing
+  breakdowns, and run summary timing from the new event props.
+- In `fabro-server`, replace runtime billing aggregation with a timing rollup
+  owned by workflow/projection code. Billing endpoints may include timing, but
+  billing logic should not define timing semantics.
+- In `apps/fabro-web`, update run list/detail/stages/billing views and tests to
+  render wall time and active time from the new fields.
+- Remove all run/stage public API references to old timing names from
+  `docs/public/api-reference/fabro-api.yaml` and regenerated clients.
+
+## Test Plan
+
+- `fabro-types`:
+  - run and stage event round trips serialize the new timing payloads.
+  - old public run/stage timing properties are absent from serialized fixtures.
+  - API-facing timing structs round trip through generated schemas.
+- `fabro-store`:
+  - `stage.started` records `started_at`.
+  - stage terminal events store `wall_time_ms` and active breakdowns.
+  - run summaries expose timestamp fields and run timing without
+    `elapsed_secs`.
+  - retried stages reset per-attempt live wall-time state correctly.
+- `fabro-workflow`:
+  - prompt stages report inference-only active timing.
+  - command stages report tool-only active timing.
+  - native agent stages sum LLM turn timing and tool timing.
+  - human/wait/conditional/fan-in/start/exit stages report zero active timing.
+  - parallel stage rollups sum child active work and avoid container double
+    counting.
+  - repeated node visits sum timing by node in rollups.
+- `fabro-server`:
+  - `/runs/{id}/stages`, `/runs/{id}/billing`, run detail, and run list return
+    new timing fields only.
+  - aggregate billing/timing totals sum active work across completed runs.
+  - OpenAPI conformance passes after regeneration.
+- `apps/fabro-web`:
+  - run list/detail/billing/stages render wall time and active time.
+  - in-flight wall-time ticking still uses `started_at`.
+  - no UI code reads `runtime_secs`, `elapsed_secs`, or run/stage
+    `duration_ms`.
+
+## Validation
+
+Run focused checks first:
+
+```bash
+cargo nextest run -p fabro-types -p fabro-store -p fabro-workflow -p fabro-server
+cd apps/fabro-web && bun test && bun run typecheck
+```
+
+Then run full workspace checks before merging:
+
+```bash
+cargo build --workspace
+cargo nextest run --workspace
+cargo +nightly-2026-04-14 fmt --check --all
+cargo +nightly-2026-04-14 clippy --workspace --all-targets -- -D warnings
+git diff --check
+```
+
+## Assumptions
+
+- Inference time is Fabro-observed LLM request/stream elapsed time, not
+  provider-reported model-only compute time.
+- LLM retry backoff, queueing outside a request/stream, human waits, steering
+  waits, and scheduler gaps are wall time but not active time.
+- Active timing is finalized-event based in v1; live active-time ticking can be
+  added later if it becomes necessary.
+- No compatibility layer is required for existing API clients or stored run
+  event data.
+
+
+## Completed stages
+- **toolchain**: succeeded
+  - Script: `command -v cargo >/dev/null || { curl --proto '=https' --tlsv1.2 -sSf https://sh.rustup.rs | sh -s -- -y && sudo ln -sf $HOME/.cargo/bin/* /usr/local/bin/; }; cargo --version 2>&1`
+  - Output:
+    ```
+    cargo 1.95.0 (f2d3ce0bd 2026-03-21)
+    ```
+- **preflight_compile**: succeeded
+  - Script: `cargo check -q --workspace 2>&1`
+  - Output: (empty)
+- **preflight_lint**: succeeded
+  - Script: `cargo +nightly-2026-04-14 clippy -q --workspace --all-targets -- -D warnings 2>&1`
+  - Output: (empty)
+
+
+Read the plan file referenced in the goal and implement every step. Make all the code changes described in the plan. Use red/green TDD.

stages/005-implement@1/provider_used.json

@@ -0,0 +1,5 @@
+{
+  "mode": "agent",
+  "provider": "anthropic",
+  "model": "claude-opus-4-7"
+}

stages/005-implement@1/response.md

@@ -0,0 +1,69 @@
+Let me give a final summary:
+
+## Summary
+
+Implemented the full **Wall and active time metrics** plan with red/green testing throughout.
+
+### Changes by crate
+
+**`fabro-types`** (new types + field renames)
+- Added `timing` module with `StageTiming` and `RunTiming` value objects (fields: `wall_time_ms`, `inference_time_ms`, `tool_time_ms`, `active_time_ms` — all `u64` ms; `active_time_ms` derived from inference + tool).
+- Replaced `Outcome.duration_ms` with `Outcome.timing: Option<StageTiming>`.
+- Replaced `NodeResult.duration: Duration` with `wall_time` + `inference_time` + `tool_time` Durations.
+- Replaced `StageProjection.duration_ms` with `timing: Option<StageTiming>`; renamed `runtime_secs()` to `live_wall_time_ms()`.
+- Replaced `Conclusion.duration_ms` with `timing: RunTiming`.
+- Replaced `StageSummary.duration_ms` with `timing: StageTiming`.
+- Removed `RunTimestamps.{duration_ms, elapsed_secs}`; added `Run.timing: Option<RunTiming>` as a sibling of `timestamps`.
+- Replaced `duration_ms` with `timing` on `RunCompletedProps`, `RunFailedProps`, `StageCompletedProps`, `StageFailedProps`.
+
+**`fabro-core`** (NodeResult constructor + executor helper)
+- 6-arg `NodeResult::new(outcome, wall_time, inference_time, tool_time, attempts, max_attempts)`.
+- Executor now harvests inference/tool from `outcome.timing` when handlers populate it.
+
+**`fabro-workflow`** (rename + thread timing)
+- Renamed event/duration helpers to `extract_stage_timings_by_stage_id` / `total_stage_timing_by_node` / `latest_stage_timing_by_node`.
+- `ProjectionBillingStage.duration_ms` → `timing: StageTiming`; `ProjectionBillingRollup.runtime_ms` → `timing: StageTiming` (sums work across visits).
+- `Event::WorkflowRunCompleted/Failed` + `Event::StageCompleted/Failed` now carry `timing` instead of `duration_ms`.
+- `Executed.duration_ms` → `wall_time_ms`.
+- `build_terminal_event` and `workflow_run_failed_from_error` take `RunTiming`.
+- PR body and lifecycle emitters thread timing through.
+
+**`fabro-store`**
+- Projection populates `stage.timing`, `Run.timing`, and `Conclusion.timing` from new event props.
+- Removed `elapsed_secs(duration_ms)` helper.
+
+**`fabro-server`**
+- Billing handler exposes `RunBillingStage.timing` and `RunBillingTotals.timing` (was `runtime_secs`).
+- `AggregateBillingTotals.timing` replaces `runtime_secs`.
+- `RunStage.wall_time_ms` (was `duration_secs`).
+- `BillingAccumulator.total_runtime_secs` → `total_timing: StageTiming`.
+
+**OpenAPI** (`docs/public/api-reference/fabro-api.yaml`)
+- New `StageTiming` and `RunTiming` schemas.
+- `RunBillingStage.runtime_secs`, `RunBillingTotals.runtime_secs`, `AggregateBillingTotals.runtime_secs` → `timing`.
+- `RunTimestamps.{duration_ms, elapsed_secs}` removed; `Run.timing` added.
+- `StageProjection.duration_ms`, `StageSummary.duration_ms`, `Conclusion.duration_ms` → `timing`.
+- `RunStage.duration_secs`, `CheckRun.duration_secs` → `wall_time_ms`.
+- `RunTimings.elapsed_secs` → `wall_time_ms`.
+
+**Generated clients** (Rust + TypeScript regenerated)
+- `fabro-api` build.rs now reuses `fabro_types::{StageTiming, RunTiming}` via `with_replacement`.
+- TS client regenerated under `lib/packages/fabro-api-client/src/models/`.
+
+**`apps/fabro-web`**
+- `runs.ts` reads `item.timing.wall_time_ms` (was `item.timestamps.elapsed_secs`).
+- `stage-sidebar.ts` reads `stage.wall_time_ms` (was `stage.duration_secs`).
+- `run-billing.tsx` operates entirely on `timing.wall_time_ms` (renamed `runtimeSecs` → `wallTimeMs`, `liveRuntimeSecs` → `liveWallTimeMs`, etc).
+- All tests updated and pass.
+
+**Subsystem `duration_ms` preserved** for sandbox setup/snapshot/ready/stop, devcontainer lifecycle, metadata snapshot, hook/interview/parallel branch/parallel completed/ACP completed-cancelled-timeout/command completed events (per plan).
+
+### Test results
+
+- **Workspace tests**: 5932/5932 pass, 180 skipped.
+- **Web tests**: 408/408 pass, typecheck clean.
+- **Focused tests (per plan)**: 2065/2065 pass across `fabro-types`, `fabro-store`, `fabro-workflow`, `fabro-server`.
+- `cargo build --workspace` clean.
+- `cargo +nightly-2026-04-14 fmt --check --all` clean.
+- `cargo +nightly-2026-04-14 clippy --workspace --all-targets -- -D warnings` clean.
+- `git diff --check` clean.