@gobing-ai/spur 0.4.26 → 0.4.27

package/.claude-plugin/marketplace.json

@@ -7,7 +7,7 @@
     "plugins": [
         {
             "name": "sp",
-            "version": "0.4.26",
+            "version": "0.4.27",
             "source": "./plugins/sp"
         }
     ]

package/config/rules/boundary/dao-boundary.yaml

@@ -88,6 +88,8 @@ rules:
     exclude:
       # the CLI migration journal — 43 DDL statements (verified load-bearing)
       - "packages/domain/src/migrations.ts"
+      # 0037's embedded mirror, generated verbatim from released drizzle SQL (task 1312)
+      - "packages/domain/src/migration-sql.generated.ts"
 
   - id: raw-sql-only-in-domain
     description: >

package/config/rules/structure/test-location.yaml

@@ -44,6 +44,8 @@ rules:
       - "**/schema/**"
       - "**/schema.ts"
       - "**/migrations.ts"
+      # generated migration SQL; scripts/commands/emit-migration-sql.test.ts pins it (task 1312)
+      - "packages/domain/src/migration-sql.generated.ts"
       - "**/db.ts"
       ## Entity declarations — contracts are transport DTOs tested by the single contract.test.ts
       - "packages/contracts/src/**"

package/package.json

@@ -1,6 +1,6 @@
 {
     "name": "@gobing-ai/spur",
-    "version": "0.4.26",
+    "version": "0.4.27",
     "description": "Spur CLI — local-first harness for mainstream coding agents: constraint checking, workflow orchestration, agent health, and history analytics. Bun-native; exposes the `spur` command.",
     "keywords": [
         "spur",
@@ -50,7 +50,7 @@
         "dev": "bun run src/index.ts",
         "build": "bun run ../../scripts/spur-dev.ts build-cli",
         "build:binaries": "bun run ../../scripts/spur-dev.ts build-binaries",
-        "build:bundle": "bun run ../../scripts/spur-dev.ts bundle-web && bun run ../../scripts/spur-dev.ts emit-board-types && bun build src/index.ts --target=bun --outfile spur.js --external @johnhenry/backend-webgpu && bun run ../../scripts/spur-dev.ts bundle-config config && bun run ../../scripts/spur-dev.ts bundle-laya-worker && bun run ../../scripts/spur-dev.ts bundle-plugins",
+        "build:bundle": "bun run ../../scripts/spur-dev.ts bundle-web && bun run ../../scripts/spur-dev.ts emit-board-types && bun run ../../scripts/spur-dev.ts emit-migration-sql && bun build src/index.ts --target=bun --outfile spur.js --external @johnhenry/backend-webgpu && bun run ../../scripts/spur-dev.ts bundle-config config && bun run ../../scripts/spur-dev.ts bundle-laya-worker && bun run ../../scripts/spur-dev.ts bundle-plugins",
         "test": "bun test tests --coverage --coverage-dir=../../.coverage --pass-with-no-tests",
         "typecheck": "tsc --noEmit",
         "prepack": "bun run build:bundle",

package/plugins/sp/commands/dev-runall.md

@@ -17,9 +17,9 @@ Wraps the **sp:spur-dev** skill.
 | `--tasks` `<selector>` | Task selector to run. | required |
 | `--feature` `<id>` | Restrict to a feature. | omitted |
 | `--mode` `<sequential\|parallel\|auto>` | Batch execution order. `auto` computes the frozen batch's dependency waves and runs parallel only when a wave holds ≥2 independent tasks (see below). | sequential |
-| `--keep-going` | Continue past per-task failures. | off |
-| `--auto` | Skip objective HITL gates. | off |
-| `--agent` `<inline\|auto\|name>` | Who runs each task's pipeline stages. Interactive sequential omit/`inline` uses the host-session driver with unified inline semantics (task 0687 — see below). `auto`, a name, parallel mode, and headless invocation use subprocesses. The opt-in `fleet` selector (0942) maps each task run to `executor: 'fleet'` so `agent.run` stages dispatch through the fleet control plane (ADR-126) instead of a subprocess. | omit |
+| `--keep-going` | Continue past per-task failures (implied by `--auto`). | off |
+| `--auto` | Skip objective HITL gates, and treat the batch as unattended: `--auto` implies `--keep-going` (a failed task is `failed`, its in-batch dependents `skipped`, independents keep running). | off |
+| `--agent` `<inline\|auto\|name>` | Who runs each task's pipeline stages. Interactive sequential omit/`inline` uses the host-session driver with unified inline semantics (task 0687 — see below). `auto`, a name, parallel mode, and headless invocation use subprocesses; `auto` is resolved **once per batch** — the first run's implement `result.executor` is pinned for every later task, and only a `failed-agent` ending re-resolves it, exactly once (1318 R2/R3). The opt-in `fleet` selector (0942) maps each task run to `executor: 'fleet'` so `agent.run` stages dispatch through the fleet control plane (ADR-126) instead of a subprocess. | omit |
 | `--json` | Emit structured JSON. | off |
 | `--wrap` | Run the wrap hop **once for the batch** over the `done` subset only (Step 6 of execution-batch.md): `vars.feature` is passed only when every frozen task is `done`/`cancelled`; an empty done subset skips the wrap with a reason. The `--agent` selector is preserved into the `/sp:dev-wrap` handoff when supplied; omission remains omission. | off |
 | `--next` | Chain-to-completion via the next-router. | off |
@@ -50,8 +50,9 @@ see `execution-parallel-isolation.md`; `auto` picks one per batch — see below)
 (parallel-mode worker bound — at most <n> task pipelines at once, default 2; a dependent task starts
 only after its in-set dependencies are **integrated** onto the base ref), `--keep-going`
 (batch failure policy — skip a failed task's in-batch dependents, continue independents; default
-halts on first failure), `--auto`
-(sets `profile=auto` on each per-task run, skipping the HITL approve gate), `--agent <inline|auto|name>`
+halts on first failure, and `--auto` implies `--keep-going`), `--auto`
+(sets `profile=auto` on each per-task run, skipping the HITL approve gate; makes the batch
+unattended, so it also implies `--keep-going`), `--agent <inline|auto|name>`
 (names who runs the pipeline's stages — interactive sequential omit/`inline` uses the host driver;
 `auto` or a name is merged into each per-task `vars.agent` and `vars.implementAgent`; `fleet` maps each task run to `executor: 'fleet'` instead (fleet dispatch, 0942); parallel mode
 retains isolated subprocesses, ADR-047), `--json` (emit the

package/plugins/sp/plugin.json

@@ -1,5 +1,5 @@
 {
     "name": "sp",
-    "version": "0.4.26",
+    "version": "0.4.27",
     "description": "Spur — a local-first harness engineering toolkit that wraps mainstream coding agents with constraint checking, workflow orchestration, and history analytics."
 }

package/plugins/sp/skills/spur-dev/references/dev-operations.md

@@ -481,7 +481,7 @@ gate commands, pending questions and approval requirements.>
 ### 13. runall
 
 - **Purpose:** Run a batch of tasks through their pipelines in dependency-correct order — resolve a set, topo-sort, run each via `task-pipeline.yaml`, inspect verdicts, apply the failure policy, emit a batch report.
-- **Inputs:** `--tasks <selector>` (required — explicit WBS list, status pseudo-list, `feature:<id>`, or `ready`). `--mode <sequential|parallel>` (default `sequential`; `parallel` fans out a proven-independent subset per `execution-batch.md` § Parallel Execution). `--keep-going` skips a failed task's in-batch dependents and continues independents (default halts on first failure). `--auto` sets `profile=auto` on each per-task run (skips the HITL approve gate). `--feature <id>` is sugar for `--tasks feature:<id>`; when the effective selector is feature-derived, the batch runs `spur feature check <id> --fix --json` then `spur feature check <id> --strict --json` **once** before task resolution — a non-zero strict check aborts with verdict `aborted`, zero attempted tasks, and the structured findings (task 0510 R2); scoped: `L4.scenario-unverified` and `L4.verifying-incomplete-tasks` (expected pre-run states of a not-yet-run or reopened feature) are reported verbatim but do not abort — the non-aborting set is `NON_ABORTING_PREFLIGHT_CODES` behind `spur task preflight --classify-feature` and `--fix` repairs are listed under `autoRepairs` — any other strict error aborts. Explicit WBS/status/`ready` selectors add no feature check. The orchestrator loop itself continues in this session; interactive sequential omit/`inline` uses the host driver — host-controlled with eligible `agent.run` stages dispatching once to a native subagent and host fallback (task 0508) — while `--agent auto`/a name, parallel mode, and headless invocation keep the isolated per-task workflow subprocess boundary. `--agent <inline|auto|name>` pins the executor for the per-task stages (see [SSOT](cross-cutting.md#inline-default-execution-surface)); the value crosses into per-task `vars.agent`, not the orchestrator. `--json` emits the report as JSON. `--wrap` triggers `wrapup-pipeline.yaml` **once for the batch** over the `done` subset only (execution-batch.md Step 6: `vars.feature` only when every frozen task is `done`/`cancelled`; empty done subset skips with a reason), `--next` chains each task to terminal status then runs the same batch-once wrap, `--continue` resumes from checkpoint. `--no-summary` skips the [execution summary](#execution-summary) printed after the batch report (one row per attempted run).
+- **Inputs:** `--tasks <selector>` (required — explicit WBS list, status pseudo-list, `feature:<id>`, or `ready`). `--mode <sequential|parallel>` (default `sequential`; `parallel` fans out a proven-independent subset per `execution-batch.md` § Parallel Execution). `--keep-going` skips a failed task's in-batch dependents and continues independents (default off; `--auto` implies `--keep-going`, so an unattended batch never stops for a human — 1318 R1). `--auto` sets `profile=auto` on each per-task run (skips the HITL approve gate). `--feature <id>` is sugar for `--tasks feature:<id>`; when the effective selector is feature-derived, the batch runs `spur feature check <id> --fix --json` then `spur feature check <id> --strict --json` **once** before task resolution — a non-zero strict check aborts with verdict `aborted`, zero attempted tasks, and the structured findings (task 0510 R2); scoped: `L4.scenario-unverified` and `L4.verifying-incomplete-tasks` (expected pre-run states of a not-yet-run or reopened feature) are reported verbatim but do not abort — the non-aborting set is `NON_ABORTING_PREFLIGHT_CODES` behind `spur task preflight --classify-feature` and `--fix` repairs are listed under `autoRepairs` — any other strict error aborts. Explicit WBS/status/`ready` selectors add no feature check. The orchestrator loop itself continues in this session; interactive sequential omit/`inline` uses the host driver — host-controlled with eligible `agent.run` stages dispatching once to a native subagent and host fallback (task 0508) — while `--agent auto`/a name, parallel mode, and headless invocation keep the isolated per-task workflow subprocess boundary. `--agent <inline|auto|name>` pins the executor for the per-task stages (see [SSOT](cross-cutting.md#inline-default-execution-surface)); the value crosses into per-task `vars.agent`, not the orchestrator. `--json` emits the report as JSON. `--wrap` triggers `wrapup-pipeline.yaml` **once for the batch** over the `done` subset only (execution-batch.md Step 6: `vars.feature` only when every frozen task is `done`/`cancelled`; empty done subset skips with a reason), `--next` chains each task to terminal status then runs the same batch-once wrap, `--continue` resumes from checkpoint. `--no-summary` skips the [execution summary](#execution-summary) printed after the batch report (one row per attempted run).
 - **Three orthogonal axes (do not confuse):** `--keep-going` = batch failure policy (halt vs skip dependents); `--continue` = resume from checkpoint against the batch's original frozen identity (execution-batch.md § Batch continuation, task 0919); `--next` = per-task lifecycle chaining (advance status on a verdict — `dev-verify`/`dev-verifyall` only). `routing-table.md` offers `--continue` and `--next` as competing options for the same situation only when the batch was interrupted mid-run; otherwise they address different problems.
 - **Backing:** `sp:spur-dev` skill, `runall` operation → delegates the driver loop to the **`sp:super-planner`** agent (the batch orchestrator).
 - **Behavior:** The orchestrator reads [execution-batch.md](execution-batch.md) and drives: resolve selector → freeze set → topo-sort by `dependencies[]` (Kahn, WBS-ascending tie-break; cycle aborts) → resolve out-of-set deps by status (done → allow, else → block subtree) → run each task via `spur workflow run task-pipeline.yaml --async` + `spur workflow trace` polling → inspect terminal state + `.spur/run/<wbs>-verdict.json` → stop-the-batch default or `--keep-going` subtree skip → emit batch report. Per-task pipeline is invoked **verbatim** — no new FSM, no step edits. `--auto`/`--agent` are the only flags that cross the orchestrator→pipeline boundary (both into per-task `--vars`).

package/plugins/sp/skills/spur-dev/references/execution-batch-report.md

@@ -20,21 +20,29 @@ results). A `paused` task is non-terminal — the report marks it `paused` (neve
 the resume command. Unless `--no-summary`, follow it with the measured
 [execution summary](dev-operations.md#execution-summary), one `--progress <wbs>=<file>` per attempted run.
 
+Under `--auto` the report's mode field reads `Mode: --auto (keep-going)`, and `--auto` implies `--keep-going`:
+an unattended batch never stops for a human (1318 R1). For an `--agent auto` or
+`--agent <name>` batch, print the header `Executor pin: <name> (from <wbs>|--agent)` and fill the
+per-task `Executor` column with the pinned executor, or `A → B (failed-agent)` for a run that was
+re-dispatched once on a new executor (1318 R2–R4). Leave that line and column out for host-inline
+runs, which have no executor to pin.
+
 ```
 ## Batch Report — <selector>
 
 **Selector:** <value>
 **Plan:** <n> tasks (ordered: <wbs-list>) · <m> blocked · <p> not-attempted
-**Mode:** stop-the-batch | --keep-going | --auto
+**Mode:** stop-the-batch | --keep-going | --auto (keep-going)
+**Executor pin:** <name> (from <wbs>|--agent)   ← `--agent auto`/`--agent <name>` runs only
 **Verdict:** clean | halted | aborted
 
-| WBS | Status | Reason |
-|-----|--------|--------|
-| 0040 | done | — |
-| 0042 | failed | verify verdict PARTIAL (see .spur/run/0042-verdict.json) |
-| 0050 | not-attempted | batch halted after 0042 (stop-the-batch) |
-| 0051 | skipped | dependency 0040 failed (--keep-going) |
-| 0060 | blocked | unmet out-of-set dep: 0099 is wip |
+| WBS | Status | Executor | Reason |
+|-----|--------|----------|--------|
+| 0040 | done | claude | — |
+| 0042 | failed | codex-a → codex-b (failed-agent) | verify verdict PARTIAL (see .spur/run/0042-verdict.json) |
+| 0050 | not-attempted | — | batch halted after 0042 (stop-the-batch) |
+| 0051 | skipped | — | dependency 0040 failed (--keep-going) |
+| 0060 | blocked | — | unmet out-of-set dep: 0099 is wip |
 
 **Next:** <one-line action — pick up halted run / resolve 0099 / all green, feature H1 complete>
 

package/plugins/sp/skills/spur-dev/references/execution-batch.md

@@ -23,6 +23,9 @@ see_also:
   [execution-batch-continuation.md](execution-batch-continuation.md) for `--continue`.
 - **Never re-derive the plan** — the frozen plan is the persisted report; a new selector match is
   `not-admitted`, not a plan change.
+- **Fresh session per segment** — when host context nears its limit, stop after a task terminal and
+  resume in a new session with `--continue`; the persisted report and markers carry the state. A
+  near-full context slows every later turn and degrades judgment.
 
 ## What this file owns
 
@@ -146,6 +149,13 @@ recorded in the batch report, and independent tasks keep running. The batch does
 - **without `--auto`:** unchanged halt behavior — the batch stops on the failing task (`--keep-going`
 still skips only its in-batch dependents).
 
+**`--auto` implies `--keep-going` (1318 R1).** An unattended batch never stops for a human: under
+`--auto` every per-task failure follows §4.2 whether or not the flag is passed — a failed,
+cancelled, `stale-evidence` or worker-lost (1317) task is recorded `failed`, its in-batch
+dependents are `skipped` with `dependency <wbs> failed`, and independent tasks keep running. The
+refine pass above is only the extra step before that, not an exception. Without `--auto` the §4.1
+stop-the-batch default is unchanged. No new flag.
+
 `--tasks <value>` (or the effective value after normalization) resolves to a frozen set of task WBS numbers. Resolution happens **once, at
 kickoff** — the driver never re-queries `spur task list` to recompute membership mid-batch (R2.1).
 
@@ -408,6 +418,18 @@ The host session remains the orchestrator for interactive sequential omit/inline
 owns explicit-executor and parallel paths; there the flag pins the per-task step executor, not the
 orchestrator.
 
+**Executor pin (1318 R2/R3).** `--agent auto` is resolved **once per batch**, not once per task:
+after the first task run, read the resolved implement executor from that run's implement `agent.run`
+trace event — `spur workflow trace <run> --json` → `.events[] | select(.node=="implement" and
+.actionKind=="agent.run") | .result.executor` — and dispatch every later task with
+`--agent <that executor>`. The report's header records `Executor pin: <name> (from <wbs>)`; an
+explicit `--agent <name>` records `(from --agent)` and needs no resolution. A task whose run ends
+with `terminalReason == "failed-agent"` is re-dispatched **exactly once** with `--agent auto`; a
+different resolved executor then becomes the pin for the remaining tasks, and a second
+`failed-agent` records the task `failed` under the failure policy with the pin kept. No other terminal reason
+is ever retried on a new executor. `--agent inline` (host driver) has no executor
+to pin, so R2/R3 do not apply.
+
 ### 3.3 Terminal-state inspection
 
 Each pipeline run ends in one of two terminal states:
@@ -525,10 +547,11 @@ belongs to a subagent or the operator, not to the batch controller's report loop
 
 ## Step 4 — Failure policy (R3)
 
-### 4.1 Stop-the-batch (default) (R3.1)
+### 4.1 Stop-the-batch (default unless `--auto`) (R3.1)
 
-By default, the **first** pipeline failure halts the batch. Remaining tasks in the plan are reported
-as `not-attempted`. The report lists succeeded, failed, and not-attempted tasks.
+By default — i.e. without `--auto` (1318 R1) — the **first** pipeline failure halts the batch.
+Remaining tasks in the plan are reported as `not-attempted`. The report lists succeeded, failed,
+and not-attempted tasks.
 
 **Run-failed / task-done (observed 2026-10-19, feature P1).** A run can fail *after* the task is
 already finished: the `done` state's close commands run last, and a lint or anchor rule can refuse
@@ -540,9 +563,10 @@ contract, not to a run whose last recorded state was superseded. Surface it in t
 way (never silently continue), and never re-run the pipeline just to flip a run row from `failed` to
 `done` — a second run re-executes model stages for a task that is already closed.
 
-### 4.2 `--keep-going` (R3.2)
+### 4.2 `--keep-going` (R3.2), or implied by `--auto`
 
-With `--keep-going`, a failed task does **not** halt the batch. Instead:
+With `--keep-going` — passed explicitly, or implied by `--auto` (1318 R1) — a failed task does
+**not** halt the batch. Instead:
 
 - The failed task's **in-batch dependents** (tasks in the plan that transitively depend on it) are
   marked `skipped` with the failed dependency as the reason — they cannot run because their dep did

package/plugins/sp/skills/spur-dev/references/flag-glossary.md

@@ -138,6 +138,11 @@ Only declared where the command already has at least one HITL gate the flag can
 taste gates (idea-eval, design-approval) — every gate there is reversible corpus writes. A gate
 without an actionable recommendation (missing eval recommendation, FAIL design check) still pauses.
 
+**Batch policy** (`dev-runall`): `--auto` implies `--keep-going` — an unattended batch never stops
+for a human. With `--agent auto` the driver also pins ONE executor for the batch — `Executor pin:
+<name>`, read from the first run's implement `result.executor` — and only a `failed-agent` ending
+re-resolves it, exactly once (1318 R1–R3).
+
 ### `--keep-going` — batch failure policy: skip dependents, continue independents
 
 **Anchor:** `#flag-keep-going`.
@@ -146,6 +151,10 @@ Batch operation only (`dev-refineall`, `dev-runall`). When a task in the batch
 fails, skip its in-batch dependents and continue the independent ones, instead of the default
 halt-on-first-failure. Never silently retried; the failure is still reported.
 
+**Default:** off, except under `--auto` — `--auto` implies `--keep-going` (1318 R1), because an
+unattended batch that stops to wait for a human is the defect it was supposed to avoid. To stop at
+the first failure, run without `--auto`.
+
 ### `--defer-gate` — opt-in parallel-batch gate policy (task 1111 / H15)
 
 **Applies to:** `/sp-dev-runall --mode parallel`, and `--mode auto` when it resolves to parallel.

package/spur.js

@@ -45392,6 +45392,32 @@ var init_forensic_query = __esm(() => {
 END`;
 });
 
+// ../../packages/domain/src/analytics/selector-time-range.ts
+function buildTimeRangeClauses(range, target) {
+  if (!COLUMN.test(target.column))
+    throw new Error(`invalid time-range column: ${target.column}`);
+  const bound = BOUND_SQL[target.grain];
+  const clauses = [];
+  const params = [];
+  if (range.since !== null) {
+    clauses.push(`${target.column} >= ${bound}`);
+    params.push(range.since);
+  }
+  if (range.until !== null) {
+    clauses.push(`${target.column} <= ${bound}`);
+    params.push(range.until);
+  }
+  return { clauses, params };
+}
+var BOUND_SQL, COLUMN;
+var init_selector_time_range = __esm(() => {
+  BOUND_SQL = {
+    day: "DATE(?)",
+    timestamp: "strftime('%Y-%m-%dT%H:%M:%SZ', ?)"
+  };
+  COLUMN = /^[A-Za-z_][A-Za-z0-9_]*(\.[A-Za-z_][A-Za-z0-9_]*)?$/;
+});
+
 // ../../packages/domain/src/analytics/history-board-marts.ts
 function resolveSummaryReadPath(input) {
   if (!input.fresh)
@@ -45544,17 +45570,7 @@ async function deriveDimensionMarts(db, days) {
   await db.batch(deriveDimensionMartsOps(days));
 }
 function dayClauses(sel) {
-  const clauses = [];
-  const params = [];
-  if (sel.since !== null) {
-    clauses.push("d.day >= DATE(?)");
-    params.push(sel.since);
-  }
-  if (sel.until !== null) {
-    clauses.push("d.day <= DATE(?)");
-    params.push(sel.until);
-  }
-  return { clauses, params };
+  return buildTimeRangeClauses(sel, { column: "d.day", grain: "day" });
 }
 function dimensionKeyClauses(sel, dimension) {
   let values = null;
@@ -45771,6 +45787,7 @@ async function historyBoardSummaryFromMart(db, sel, dimension) {
 }
 var MART_DIMENSIONS, MART_MIN_RANGE_DAYS = 7, MEASURE_COLS = "messages, tool_calls, skill_calls, fresh_input_tokens, cache_read_tokens, cache_write_tokens, output_tokens, duration_ms, duration_samples", MART_INSERT_COLS, MSG_DAY_PRED = "(m.bucket_start >= ? AND m.bucket_start < DATE(?, '+1 day'))", TOOL_DAY_PRED = "(t.bucket_start >= ? AND t.bucket_start < DATE(?, '+1 day'))", SKILL_DAY_PRED = "(s.bucket_start >= ? AND s.bucket_start < DATE(?, '+1 day'))", KPI_RANGE_KEY = "trend";
 var init_history_board_marts = __esm(() => {
+  init_selector_time_range();
   MART_DIMENSIONS = ["model", "source", "tool", "skill"];
   MART_INSERT_COLS = `${MEASURE_COLS}, errors`;
 });
@@ -46201,16 +46218,10 @@ function appendRankedSteps(operations, kind, rows) {
   });
 }
 function buildRollupWhere(sel, alias, options) {
-  const clauses = [];
-  const params = [];
-  if (sel.since !== null) {
-    clauses.push(`${alias}.${options.timestamp} >= ${options.dateOnly ? "DATE(?)" : "strftime('%Y-%m-%dT%H:%M:%SZ', ?)"}`);
-    params.push(sel.since);
-  }
-  if (sel.until !== null) {
-    clauses.push(`${alias}.${options.timestamp} <= ${options.dateOnly ? "DATE(?)" : "strftime('%Y-%m-%dT%H:%M:%SZ', ?)"}`);
-    params.push(sel.until);
-  }
+  const { clauses, params } = buildTimeRangeClauses(sel, {
+    column: `${alias}.${options.timestamp}`,
+    grain: options.dateOnly ? "day" : "timestamp"
+  });
   if (sel.sources !== null && sel.sources.length > 0) {
     clauses.push(`${alias}.source IN (${sel.sources.map(() => "?").join(", ")})`);
     params.push(...sel.sources);
@@ -47363,6 +47374,7 @@ var init_history_board_rollup = __esm(() => {
   init_forensic_query();
   init_history_board_marts();
   init_rollup_watermark();
+  init_selector_time_range();
   init_tool_alias();
   init_tool_name_sql();
   init_tool_name_sql();
@@ -58119,7 +58131,7 @@ var init_run_dao = __esm(() => {
              LIMIT ?6`, filter.workflow ?? null, filter.status ?? null, filter.since ?? null, filter.before?.started_at ?? null, filter.before?.id ?? null, filter.limit);
     }
     traceRowById(runId) {
-      return this.adapter.queryFirst("SELECT id, workflow_name, mode, status, agent, started_at, completed_at, terminal_reason, metadata_json FROM runs WHERE id = ?", runId);
+      return this.adapter.queryFirst("SELECT id, workflow_name, mode, status, agent, started_at, completed_at, terminal_reason, metadata_json, pid FROM runs WHERE id = ?", runId);
     }
     mergeMetadata(runId, patch) {
       return this.adapter.run(`UPDATE runs
@@ -58132,6 +58144,17 @@ var init_run_dao = __esm(() => {
     stampMetadata(runId, metadata) {
       return this.mergeMetadata(runId, metadata);
     }
+    mergeMetadataIfStatus(runId, patch, statuses) {
+      if (statuses.length === 0)
+        return Promise.resolve();
+      const placeholders = statuses.map((_, i) => `?${i + 3}`).join(", ");
+      return this.adapter.run(`UPDATE runs
+             SET metadata_json = json_patch(
+                 COALESCE(NULLIF(metadata_json, ''), '{}'),
+                 ?1
+             )
+             WHERE id = ?2 AND status IN (${placeholders})`, JSON.stringify(patch), runId, ...statuses);
+    }
     stampRunIdentity(runId, definitionDigest, workflowVersion, source) {
       const sourceSet = source === undefined ? "" : `,
                  '$.definitionSource.path', ?4,
@@ -72279,6 +72302,64 @@ var init_dist11 = __esm(() => {
   init_types3();
 });
 
+// ../../packages/domain/src/migration-sql.generated.ts
+var HISTORY_DIMENSION_MARTS_SCHEMA_SQL = `-- 0743: Dimension marts (task 0743).
+-- Two day-grain mart tables carrying the ADR-106 nine-measure additive vector for the
+-- four materialized Summary dimensions. Every measure column is nullable for exactly one
+-- reason: ADR-106 records a measure that is not well defined at a dimension as NULL, never
+-- as a zero that would be indistinguishable from a measured absence of activity.
+--
+--   - tool  dimension: skill_calls is not applicable -> NULL
+--   - skill dimension: tool_calls is not applicable -> NULL
+--   - source dimension: duration_ms / duration_samples are not applicable -> NULL
+--
+-- history_board_kpi_window stores the current and previous aggregate window KPIs for a
+-- named range window. All statements are idempotent (CREATE TABLE IF NOT EXISTS).
+
+CREATE TABLE IF NOT EXISTS history_board_dimension_daily (
+    dimension           TEXT NOT NULL,
+    dimension_key       TEXT NOT NULL,
+    day                 TEXT NOT NULL,
+    -- ADR-106 nine-member additive measure vector. NULLABLE, never a NOT NULL column with a
+    -- zero default: a not-applicable measure is stored as NULL.
+    messages            INTEGER,
+    tool_calls          INTEGER,
+    skill_calls         INTEGER,
+    fresh_input_tokens  REAL,
+    cache_read_tokens   REAL,
+    cache_write_tokens  REAL,
+    output_tokens       REAL,
+    duration_ms         INTEGER,
+    duration_samples    INTEGER,
+    -- Per-(dimension, key, day) tool-error count (not part of the ADR-106 additive vector but
+    -- needed by the top-tools error-rate projection. NULLABLE like every other scalar.
+    errors              INTEGER,
+    PRIMARY KEY (dimension, dimension_key, day)
+);
+
+CREATE TABLE IF NOT EXISTS history_board_kpi_window (
+    range_key           TEXT NOT NULL,
+    window_kind         TEXT NOT NULL CHECK (window_kind IN ('current', 'previous')),
+    -- ADR-106 nine-member additive measure vector, plus the non-additive totals the KPI
+    -- projection needs (sessions and tool_errors are counts, never summed as means).
+    messages            INTEGER,
+    tool_calls          INTEGER,
+    skill_calls         INTEGER,
+    fresh_input_tokens  REAL,
+    cache_read_tokens   REAL,
+    cache_write_tokens  REAL,
+    output_tokens       REAL,
+    duration_ms         INTEGER,
+    duration_samples    INTEGER,
+    sessions            INTEGER,
+    tool_errors         INTEGER,
+    PRIMARY KEY (range_key, window_kind)
+);
+
+CREATE INDEX IF NOT EXISTS idx_history_board_dimension_daily_day
+    ON history_board_dimension_daily (dimension, day);
+`;
+
 // ../../packages/domain/src/schema/inbox-messages.ts
 var inboxMessagesTable, inboxMessages4, INBOX_MESSAGES_TABLE_SQL;
 var init_inbox_messages3 = __esm(() => {
@@ -73224,49 +73305,6 @@ CREATE TABLE IF NOT EXISTS history_board_rollup_bucket (
 
 CREATE INDEX IF NOT EXISTS idx_history_message_imported_at
     ON history_message (imported_at);
-`, HISTORY_DIMENSION_MARTS_SCHEMA_SQL = `
-CREATE TABLE IF NOT EXISTS history_board_dimension_daily (
-    dimension           TEXT NOT NULL,
-    dimension_key       TEXT NOT NULL,
-    day                 TEXT NOT NULL,
-    -- ADR-106 nine-member additive measure vector. NULLABLE, never a NOT NULL column with a
-    -- zero default: a not-applicable measure is stored as NULL.
-    messages            INTEGER,
-    tool_calls          INTEGER,
-    skill_calls         INTEGER,
-    fresh_input_tokens  REAL,
-    cache_read_tokens   REAL,
-    cache_write_tokens  REAL,
-    output_tokens       REAL,
-    duration_ms         INTEGER,
-    duration_samples    INTEGER,
-    -- Per-(dimension, key, day) tool-error count (not part of the ADR-106 additive vector but
-    -- needed by the top-tools error-rate projection. NULLABLE like every other scalar.
-    errors              INTEGER,
-    PRIMARY KEY (dimension, dimension_key, day)
-);
-
-CREATE TABLE IF NOT EXISTS history_board_kpi_window (
-    range_key           TEXT NOT NULL,
-    window_kind         TEXT NOT NULL CHECK (window_kind IN ('current', 'previous')),
-    -- ADR-106 nine-member additive measure vector, plus the non-additive totals the KPI
-    -- projection needs (sessions and tool_errors are counts, never summed as means).
-    messages            INTEGER,
-    tool_calls          INTEGER,
-    skill_calls         INTEGER,
-    fresh_input_tokens  REAL,
-    cache_read_tokens   REAL,
-    cache_write_tokens  REAL,
-    output_tokens       REAL,
-    duration_ms         INTEGER,
-    duration_samples    INTEGER,
-    sessions            INTEGER,
-    tool_errors         INTEGER,
-    PRIMARY KEY (range_key, window_kind)
-);
-
-CREATE INDEX IF NOT EXISTS idx_history_board_dimension_daily_day
-    ON history_board_dimension_daily (dimension, day);
 `, RETENTION_COMPACTION_META_SCHEMA_SQL = `
 CREATE TABLE IF NOT EXISTS spur_retention_meta (
     kind    TEXT NOT NULL,
@@ -100265,6 +100303,31 @@ import {
   writeSync as writeSync2
 } from "fs";
 import { dirname as dirname8, join as join18 } from "path";
+function writeStateFile(statePath, state) {
+  const temp = `${statePath}.tmp`;
+  try {
+    writeFileSync3(temp, `${JSON.stringify(state, null, 2)}
+`);
+    renameSync3(temp, statePath);
+  } catch {
+    try {
+      unlinkSync2(temp);
+    } catch {}
+  }
+}
+function projectRunStateStatus(dir, runId, status, at) {
+  const statePath = join18(dir, `${runId}.state.json`);
+  let prior;
+  try {
+    const parsed = JSON.parse(readFileSync5(statePath, "utf8"));
+    if (parsed === null || typeof parsed !== "object" || Array.isArray(parsed))
+      return;
+    prior = parsed;
+  } catch {
+    return;
+  }
+  writeStateFile(statePath, { ...prior, status, updatedAt: at, finalizedAt: at });
+}
 
 class WorkflowRunLogSink {
   filePath;
@@ -100404,16 +100467,7 @@ class WorkflowRunLogSink {
       ...this.lineage?.startState !== undefined ? { startState: this.lineage.startState } : {},
       ...this.lineage?.continuedFrom !== undefined ? { continuedFrom: this.lineage.continuedFrom } : {}
     };
-    const temp = `${this.statePath}.tmp`;
-    try {
-      writeFileSync3(temp, `${JSON.stringify(state, null, 2)}
-`);
-      renameSync3(temp, this.statePath);
-    } catch {
-      try {
-        unlinkSync2(temp);
-      } catch {}
-    }
+    writeStateFile(this.statePath, state);
   }
   onSteering(ack) {
     const note = ack.note === undefined ? "" : ` \xB7 ${bounded3(ack.note, MAX_STEERING_NOTE_CHARS)}`;
@@ -131099,6 +131153,32 @@ var init_workflow_catalog_scan = __esm(() => {
 import { realpathSync as realpathSync8, statSync as statSync12 } from "fs";
 import { readdir as readdir3, rm as rm2 } from "fs/promises";
 import { dirname as dirname32, join as join58, relative as relative14, resolve as resolve21, sep as sep11 } from "path";
+async function reapRun(db, engine, run, reasons, cwd) {
+  const dao = new RunDao(db);
+  const interrupted = run.status === "running" ? await engine.interruptRun(run.id, "interrupted") : undefined;
+  if (interrupted === undefined) {
+    await dao.finalizeStale(run.id, reasons.finalized);
+  } else {
+    await dao.mergeMetadataIfStatus(run.id, { staleReason: reasons.interrupted }, ["interrupted"]);
+  }
+  projectRunStateStatus(runStoragePaths(cwd).recordsDir, run.id, interrupted === undefined ? "failed" : "interrupted", new Date().toISOString());
+  return interrupted === undefined ? "failed" : "interrupted";
+}
+async function reapIfWorkerLost(db, cwd, runId) {
+  const dao = new RunDao(db);
+  const row = await dao.traceRowById(runId);
+  if (row === undefined)
+    return { row, reaped: false };
+  if (row.status !== "running" && row.status !== "pending")
+    return { row, reaped: false };
+  const pid = row.pid;
+  if (pid === null || isPidAlive(pid))
+    return { row, reaped: false };
+  const reason = `worker-lost: pid ${pid} not alive`;
+  const engine = new WorkflowService(createDefaultWorkflowEngineHost({}), new DbWorkflowPersistenceAdapter(db));
+  await reapRun(db, engine, row, { interrupted: reason, finalized: reason }, cwd);
+  return { row, reaped: true };
+}
 
 class WorkflowCleanOps {
   ctx;
@@ -131113,14 +131193,10 @@ class WorkflowCleanOps {
     if (!dryRun) {
       const engine = new WorkflowService(createDefaultWorkflowEngineHost({}), new DbWorkflowPersistenceAdapter(db));
       for (const run of stale) {
-        const interrupted = run.status === "running" ? await engine.interruptRun(run.id, "interrupted") : undefined;
-        if (interrupted === undefined) {
-          await dao.finalizeStale(run.id, `stale: non-terminal > ${olderThanMinutes}m (spur workflow clean)`);
-        } else {
-          await dao.mergeMetadata(run.id, {
-            staleReason: `stale: owner lost > ${olderThanMinutes}m (spur workflow clean)`
-          });
-        }
+        await reapRun(db, engine, run, {
+          interrupted: `stale: owner lost > ${olderThanMinutes}m (spur workflow clean)`,
+          finalized: `stale: non-terminal > ${olderThanMinutes}m (spur workflow clean)`
+        }, this.ctx.cwd);
       }
     }
     return {
@@ -131337,7 +131413,9 @@ var init_workflow_clean_ops = __esm(() => {
   init_src2();
   init_dist9();
   init_dist5();
+  init_workflow_run_log_sink();
   init_checkpoint_contract();
+  init_project_process();
   init_run_storage();
   init_workflow_catalog_scan();
 });
@@ -135113,6 +135191,8 @@ function rowToTraceEntry(row, cwd) {
     isDryRun = meta.dryRun === true;
     if (typeof meta.failureReason === "string" && meta.failureReason !== "") {
       failureReason = meta.failureReason;
+    } else if (typeof meta.staleReason === "string" && meta.staleReason !== "") {
+      failureReason = meta.staleReason;
     }
     if ("workflowVersion" in meta && (typeof meta.workflowVersion === "string" || meta.workflowVersion === null)) {
       version = meta.workflowVersion;
@@ -135483,9 +135563,9 @@ class WorkflowInspectOps {
       total: rows.length
     };
   }
-  async traceRun(db, runId) {
+  async traceRun(db, runId, preloadedRow) {
     const runDao = new RunDao(db);
-    const row = await runDao.traceRowById(runId);
+    const row = preloadedRow ?? await runDao.traceRowById(runId);
     if (!row)
       throw new Error(`Run not found: ${runId}`);
     const run = rowToTraceEntry(row, this.ctx.cwd);
@@ -136636,8 +136716,10 @@ class WorkflowRunOps {
     await dao.cancelRun(runId);
     const after = await dao.traceRowById(runId);
     const finalized = after?.status === "failed" && isNonTerminal;
-    if (finalized)
+    if (finalized) {
+      projectRunStateStatus(runStoragePaths(this.ctx.cwd).recordsDir, runId, "failed", new Date().toISOString());
       await releaseWorktreeRunLease(db, this.ctx.cwd, runId);
+    }
     return { runId, finalized, status: after?.status ?? "not_found", killed };
   }
   async stampFailureReason(runId, result) {
@@ -136657,11 +136739,13 @@ var init_workflow_run_ops = __esm(() => {
   init_src2();
   init_dist9();
   init_dist5();
+  init_workflow_run_log_sink();
   init_composition_baseline();
   init_host_executor();
   init_start_state();
   init_workflow_resolver();
   init_event_bridge();
+  init_run_storage();
   init_workflow_run_recording();
   init_workflow_run_vars();
   init_workflow_worktree_lease();
@@ -136722,7 +136806,8 @@ class WorkflowAppService {
   async trace(runIdOrFilter) {
     const db = await this.ctx.getDb();
     if (typeof runIdOrFilter === "string") {
-      return this.inspectOps.traceRun(db, runIdOrFilter);
+      const probe = await reapIfWorkerLost(db, this.ctx.cwd, runIdOrFilter);
+      return this.inspectOps.traceRun(db, runIdOrFilter, probe.reaped ? undefined : probe.row);
     }
     return this.inspectOps.traceList(db, runIdOrFilter ?? {});
   }
@@ -138263,6 +138348,7 @@ var init_src4 = __esm(() => {
   init_token_ledger_watcher();
   init_verify_answer_lint();
   init_warm_turn_dispatch();
+  init_workflow_clean_ops();
   init_workflow_service();
   init_worktree_persist();
   init_write_slot_service();
@@ -164625,7 +164711,7 @@ init_src2();
 var CLI_CONFIG = {
   binaryName: "spur",
   binaryLabel: "spur",
-  binaryVersion: "0.4.26",
+  binaryVersion: "0.4.27",
   configDir: ".spur",
   configFile: ".spur/config.yaml",
   databaseFile: ".spur/spur.db"
@@ -172364,7 +172450,7 @@ init_dist5();
 import { homedir as homedir17 } from "os";
 import { basename as basename23, join as join95, relative as relative19, resolve as resolve37 } from "path";
 // ../server/package.json
-var version4 = "0.4.26";
+var version4 = "0.4.27";
 
 // ../server/src/modules/health/index.ts
 var startedAt = Date.now();
@@ -178537,8 +178623,10 @@ function formatWorkflowProgress(projection) {
 }
 function registerWorkflowProgressCommand(workflow, context) {
   workflow.command("progress").description("Project the structured progress of a workflow run: current state, per-action attempts, and candidate next transitions.").argument("<run-id>", "Run id to project").option(...SHARED_OPTIONS.jsonSupported).option(...SHARED_OPTIONS.jsonEnvelope).action(async (runId, options) => {
+    const db = await context.getDb();
+    await reapIfWorkerLost(db, context.cwd, runId);
     const projection = await projectWorkflowProgress(runId, {
-      db: await context.getDb(),
+      db,
       projectRoot: context.cwd
     });
     if (projection.diagnostics.some((diagnostic) => diagnostic.code === "orphan-row")) {
@@ -179238,6 +179326,14 @@ function formatTimelineEvent(event) {
 function followDeadlineLine(runId, elapsedMs, status) {
   return `Follow timed out after ${elapsedMs}ms: run ${runId} status=${status} \u2014 run continues; resume with spur workflow trace ${runId} --follow`;
 }
+function followFinalizedLine(timeline) {
+  const run = timeline.run;
+  const reason = run.failureReason ? ` \u2014 ${run.failureReason}` : "";
+  const duration = run.durationMs === null ? "unavailable" : `${run.durationMs}ms`;
+  const next = run.nextAction === undefined ? "" : `
+Next: ${run.nextAction.label} \u2014 ${run.nextAction.value}`;
+  return `Run finalized: ${run.status}${reason} \u2014 outcome=${run.outcome} duration=${duration}${next}`;
+}
 async function followTrace(service, runId, pollMs, write, wait = (ms) => sleep7(ms), now = Date.now, deadlineMs) {
   const start = now();
   const deadline = deadlineMs === undefined ? Number.POSITIVE_INFINITY : start + deadlineMs;
@@ -179260,8 +179356,10 @@ async function followTrace(service, runId, pollMs, write, wait = (ms) => sleep7(
   }
   write(formatTraceTimeline(timeline));
   const seen = new Set(timeline.events.map((event) => JSON.stringify(event)));
-  if (isTerminalTraceStatus(timeline.run.status))
+  if (isTerminalTraceStatus(timeline.run.status)) {
+    write(followFinalizedLine(timeline));
     return false;
+  }
   while (true) {
     await wait(pollMs);
     const next = await service.trace(runId);
@@ -179273,12 +179371,7 @@ async function followTrace(service, runId, pollMs, write, wait = (ms) => sleep7(
       write(formatTimelineEvent(event));
     }
     if (isTerminalTraceStatus(next.run.status)) {
-      const reason = next.run.failureReason ? ` \u2014 ${next.run.failureReason}` : "";
-      const duration = next.run.durationMs === null ? "unavailable" : `${next.run.durationMs}ms`;
-      write(`Run finalized: ${next.run.status}${reason} \u2014 outcome=${next.run.outcome} duration=${duration}`);
-      if (next.run.nextAction !== undefined) {
-        write(`Next: ${next.run.nextAction.label} \u2014 ${next.run.nextAction.value}`);
-      }
+      write(followFinalizedLine(next));
       return false;
     }
     const at = now();