@gobing-ai/spur 0.4.1 → 0.4.2

package/.claude-plugin/marketplace.json

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

package/config/config.global.yaml

@@ -157,8 +157,10 @@ workflows:
 # project-relative); the first layer wins per file basename (ADR-113 style).
 # `maker` selects the default DecisionMaker for every decision point, and
 # `makers` overrides it per decision id. Built-in makers: typesafe, fm-local,
-# laya-local (laya-local needs Apple Silicon). An unregistered name is a config
-# error, never a silent fallback. Inspect the effective choice with
+# laya-local (laya-local needs Apple Silicon) and clef (hosted Cloudflare
+# Workers AI, registered only when CLOUDFLARE_ACCOUNT_ID and
+# CLOUDFLARE_AUTH_TOKEN are both set). An unregistered name is a config error,
+# never a silent fallback. Inspect the effective choice with
 # `spur decision status`. `init` never overwrites this file — until you add the
 # keys, the shipped catalog's maker applies (see `status`).
 decisions:

package/config/templates/AGENTS.md

@@ -36,7 +36,7 @@ All product development work goes through the harness by default.
 | ------ | ---------- | -------- |
 | Plan a feature (intake → AC → tasks) | `/sp:dev-plan`, `/sp:dev-idea` | Freeform feature files without gates |
 | Drive one task end-to-end | `/sp:dev-run <wbs>` or **`sp:super-planner`** | Implement with no task / no pipeline |
-| Batch or parallel task runs | `/sp:dev-runall` (host sequential; **`sp:super-planner`** explicit/parallel), `/sp:dev-parallel` | Unordered multi-task thrash |
+| Batch or parallel task runs | `/sp:dev-runall` (host sequential; `--mode parallel\|auto` → **`sp:super-planner`**) | Unordered multi-task thrash |
 | Batch-refine tasks under a feature | `/sp:dev-refineall --feature <id> --auto` | Hand-looping `/sp:dev-refine` per WBS |
 | Multi-step corpus CLI (tasks/features/rules/workflows) | **`sp:expert-spur`** | Raw Write/Edit on corpus files |
 | Look up `spur` verbs / flags / `--json` | Skill **`sp:spur-cli`** | Inventing flags from memory |

package/config/workflows/wrapup-pipeline.yaml

@@ -382,7 +382,7 @@ states:
           command: >-
             mkdir -p .spur/run &&
             R=".spur/run/$__runId-wrapup-repair.status" &&
-            V="$(cat .spur/run/$__runId-wrapup-learnings.status 2>/dev/null)" &&
+            V="$(cat .spur/run/$__runId-wrapup-learnings.status 2>/dev/null || true)" &&
             if [ "$V" = invalid-learnings-shape ]; then printf 'invalid-learnings-shape: narration-only learnings capture — append skipped, repair recorded (0986)\n' > "$R";
             else printf 'contract-violation: doc-sync learnings capture missed its declared contract — repair skipped re-dispatch (ADR-118 pilot)\n' > "$R";
             fi &&

package/package.json

@@ -1,6 +1,6 @@
 {
     "name": "@gobing-ai/spur",
-    "version": "0.4.1",
+    "version": "0.4.2",
     "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",
@@ -49,7 +49,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/commands/bundle-plugin-lib.ts && 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 && bun run ../../scripts/spur-dev.ts bundle-config config && bun run ../../scripts/spur-dev.ts bundle-plugins",
+        "build:bundle": "bun run ../../scripts/commands/bundle-plugin-lib.ts && 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-plugins",
         "test": "bun test tests --coverage --coverage-dir=../../.coverage --pass-with-no-tests",
         "typecheck": "tsc --noEmit",
         "prepack": "bun run build:bundle",
@@ -57,14 +57,14 @@
     },
     "devDependencies": {
         "@commander-js/extra-typings": "^14.0.0",
-        "@gobing-ai/ts-db": "^0.5.21",
-        "@gobing-ai/ts-ai-runner": "^0.5.21",
-        "@gobing-ai/ts-dual-workflow-engine": "^0.5.21",
-        "@gobing-ai/ts-infra": "^0.5.21",
-        "@gobing-ai/ts-llm-jsonl-importer": "^0.5.21",
-        "@gobing-ai/ts-rule-engine": "^0.5.21",
-        "@gobing-ai/ts-runtime": "^0.5.21",
-        "@gobing-ai/ts-utils": "^0.5.21",
+        "@gobing-ai/ts-db": "^0.5.22",
+        "@gobing-ai/ts-ai-runner": "^0.5.22",
+        "@gobing-ai/ts-dual-workflow-engine": "^0.5.22",
+        "@gobing-ai/ts-infra": "^0.5.22",
+        "@gobing-ai/ts-llm-jsonl-importer": "^0.5.22",
+        "@gobing-ai/ts-rule-engine": "^0.5.22",
+        "@gobing-ai/ts-runtime": "^0.5.22",
+        "@gobing-ai/ts-utils": "^0.5.22",
         "@types/bun": "1.3.14",
         "@types/figlet": "^1.7.0",
         "@types/node-notifier": "8.0.5",

package/plugins/sp/README.md

@@ -120,7 +120,6 @@ list this README is checked against.
 | Command         | What it does                                                                                                                                                           |
 | --------------- | ---------------------------------------------------------------------------------------------------------------------------------------------------------------------- |
 | `dev-runall`    | Run a batch of tasks through their pipelines in dependency-correct order — resolve a set, topo-sort, run each via task-pipeline.yaml, emit a batch report              |
-| `dev-parallel`  | Fan out independent tasks or investigations in parallel via subagents — choose the right pattern and synthesize results                                                |
 | `dev-refineall` | Batch-refine tasks (feature or selector) — planning-half bulk fill of Background/Requirements/AC/Design/Plan before runall; `--depth ready` audits, corrects, freezes and promotes each task |
 | `dev-verifyall` | Batch-verify tasks against requirements and AC — resolves a set, runs per-task verification, produces consolidated PASS/PARTIAL/FAIL summary report                    |
 | `dev-wrapall`   | Wrap up a batch of completed tasks — learnings, metrics, doc-sync, feature transition, optional branch cleanup                                                         |
@@ -333,7 +332,7 @@ surface or run one workflow. All skills target the same five core platforms: `cl
 | `source-driven-development` | 1.0   | Source-first verification — verify framework/API/library facts against primary sources before generating code; separates "the API exists" from "used correctly under its contract"                                                         |
 | `dogfood-testing`           | 1.2   | Dogfood backbone — drives a testee end-to-end with bounded auto-fix, a live monitor ledger, and a structured report; @1.2 adds footer-mandatory reports, 7-check finalize-or-abort, and the `validate-report` CLI; backs `/sp:dev-dogfood` |
 | `next-router`               | 1.0   | Status→command router — resolve a task WBS or feature frontier, TABLE A/B/C lookup with light-gate short-circuit, single dispatch or HITL stop; backs `/sp:dev-next`                                                                       |
-| `parallel-execution`        | 1.0   | Fan-out decision framework — when to parallelize, four proven fan-out patterns, and result synthesis; backs `/sp:dev-parallel`                                                                                                             |
+| `parallel-execution`        | 1.0   | Fan-out decision framework — when to parallelize, four proven fan-out patterns, and result synthesis; backs `/sp:dev-runall --mode parallel\|auto`                                                                                                           |
 | `sys-debugging`             | 1.0   | Structured debugging protocol — reproduce→isolate→root cause→fix→regression test; "ask the debugger before the LLM" principle                                                                                                              |
 | `branch-workflow`           | 1.0   | Branch-lifecycle discipline — create→worktree→commit→self-review→merge→cleanup; git worktree patterns for parallel branches                                                                                                                |
 | `test-driven-development`   | 1.0.0 | TDD workflow companion — red-green-refactor cycle, behavior-first test design, AAA structure, data builders, mock-at-boundary anti-patterns                                                                                                |

package/plugins/sp/agents/super-planner.md

@@ -1,7 +1,7 @@
 ---
 name: super-planner
 description: |
-  Use PROACTIVELY for "run this task end to end", "drive the batch", "execute the todo set", "/sp:dev-runall", or "/sp:dev-parallel". Planning and execution orchestration: owns the product/project management framing (intake, scope, sequencing) and drives the batch driver loop in sp:spur-dev/references/execution-batch.md — resolve+freeze -> topo-sort -> per-task run -> verdict inspect -> continue/halt -> batch report, with optional parallel fan-out. For a one-off verb, /sp:dev-run <wbs> is lighter; for "what single step next?", prefer /sp:dev-next — NOT this agent's job.
+  Use PROACTIVELY for "run this task end to end", "drive the batch", "execute the todo set", "/sp:dev-runall", or "fan out these tasks". Planning and execution orchestration: owns the product/project management framing (intake, scope, sequencing) and drives the batch driver loop in sp:spur-dev/references/execution-batch.md — resolve+freeze -> topo-sort -> per-task run -> verdict inspect -> continue/halt -> batch report, with optional parallel fan-out. For a one-off verb, /sp:dev-run <wbs> is lighter; for "what single step next?", prefer /sp:dev-next — NOT this agent's job.
 
   <example>
   Context: Batch execution of a feature's tasks
@@ -72,7 +72,6 @@ You own the spaces **between** task runs:
 - **Resolve + freeze** the task set:
   - from `--tasks <selector>`, or
   - from the convenience `--feature <id>` (normalized by the command layer / resolver to `feature:<id>` per execution-batch.md Step 1).
-  (See also dev-runall and dev-parallel which now both accept `--feature`.)
 - **Topologically order** the frozen set by `dependencies[]` (Step 2). Abort on cycle; pre-block
   unmet out-of-set deps.
 - **Preflight (Step 2.5 / 3.0)** - before each pipeline launch, evaluate TABLE A STOP rows
@@ -110,7 +109,7 @@ You explicitly do **NOT** own step-level execution:
 
 ## When to use
 
-- `/sp:dev-runall --feature <id>` (or `--tasks feature:<id>`), `/sp:dev-parallel --feature <id>`, or equivalent is invoked.
+- `/sp:dev-runall --feature <id>` (or `--tasks feature:<id>`, with any `--mode`), or equivalent is invoked.
 - The operator asks to "run all tasks", "run the batch", "execute the todo set", "runall ready", or "fan out tasks for feature X".
 - A feature's task batch is decomposed and ready for end-to-end (sequential or parallel) execution.
 
@@ -121,7 +120,7 @@ routes to you. On other platforms, invoke this agent directly when the batch dri
 
 | Platform | Invocation |
 | ---------- | ----------- |
-| Claude Code | Spawned by `/sp:dev-runall --feature <id>` (or `--tasks ...`) -> `Skill(skill="sp:spur-dev", args="runall $ARGUMENTS")` -> this agent (also handles parallel via dev-parallel) |
+| Claude Code | Spawned by `/sp:dev-runall --feature <id>` (or `--tasks ...`) -> `Skill(skill="sp:spur-dev", args="runall $ARGUMENTS")` -> this agent (also handles `--mode parallel` and parallel `--mode auto` resolutions) |
 | Other platforms | Spawn this agent directly; read execution-batch.md and drive the loop |
 
 ## Decision autonomy
@@ -173,8 +172,8 @@ When you fan out or dispatch a subagent, apply the four disciplines the SSOT
       cardinality is 1. Never loop recovery until done.
 - [ ] Emit the batch report at completion (clean / halted / aborted), including preflight skips.
 - [ ] Default to sequential execution. Enter parallel mode only when explicitly requested
-      (`--mode parallel` or `/sp:dev-parallel`) and the `sp:parallel-execution` decision framework
-      clears dependency, file-overlap, and token-budget checks.
+      (`--mode parallel`, or `--mode auto` resolved to parallel by the § 2.4a schedule) and the
+      `sp:parallel-execution` decision framework clears dependency, file-overlap, and token-budget checks.
 - [ ] To resolve a deferred `feature_id` under operator-chosen strict rigor, use the sp:spur-dev
       feature-link helper (single-task or sweep) - never invoke it automatically from within a
       batch run; surface it only when the operator explicitly requests strict traceability.

package/plugins/sp/commands/dev-review-session.md

@@ -18,7 +18,8 @@ work time, operator wait, tool calls and tokens (total / non-cached) per stage,
 `session-timeline.mjs` — with durations in `M:SS` or `H:MM:SS` form and `n/a` only when that
 measurement is unavailable. The transcript resolves from `--transcript`, else
 `CLAUDE_CODE_SESSION_ID`, else `PI_SESSION_FILE` (the pi host sets it and no Claude session id); a
-skill-injected `<skill name="…">` body counts as activity in `injectedPrompts`, never as a segment.
+pi `<skill name="…">` wrapper row is the operator's `/skill` invocation and opens a segment
+rendered `/<name> <args>` (or `/<name>` argument-less), never an injected body.
 
 ## Argument Flags
 

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

@@ -1,7 +1,7 @@
 ---
 description: Run a batch of tasks through their pipelines in dependency-correct order — resolve a set, topo-sort, run each via task-pipeline.yaml, emit a batch report
 role: planner
-argument-hint: "--tasks <selector> [--feature <id>] [--mode <sequential|parallel>] [--keep-going] [--auto] [--agent <inline|auto|name>] [--json] [--wrap] [--next] [--continue] [--worktree [<name>]] [--no-summary] [--defer-gate]"
+argument-hint: "--tasks <selector> [--feature <id>] [--mode <sequential|parallel|auto>] [--concurrency <n>] [--keep-going] [--auto] [--agent <inline|auto|name>] [--json] [--wrap] [--next] [--continue] [--worktree [<name>]] [--no-summary] [--defer-gate]"
 allowed-tools: ["Bash", "Read", "Skill"]
 ---
 
@@ -15,10 +15,10 @@ Wraps the **sp:spur-dev** skill.
 | --- | --- | --- |
 | `--tasks` `<selector>` | Task selector to run. | required |
 | `--feature` `<id>` | Restrict to a feature. | omitted |
-| `--mode` `<sequential\|parallel>` | Batch execution order. | sequential |
+| `--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 |
+| `--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 |
 | `--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 |
@@ -26,14 +26,14 @@ Wraps the **sp:spur-dev** skill.
 | `--worktree` `[<name>]` | Run the batch in an isolated git worktree; FF-merge on success, retain on failure. Bare `--worktree` creates a fresh tree; `--worktree <name>` adopts an existing worktree by name/path/branch. | off |
 | `--no-summary` | Skip the measured execution summary (one row per task run: time, wait, tool calls, total / non-cached tokens) printed after the batch report. | off (summary printed) |
 | `--concurrency` `<n>` | Parallel-mode worker bound: at most `<n>` task pipelines run at once (task 0931); a dependent starts only after its in-set dependencies are integrated onto the base ref. No-op in sequential mode (ignored). | 2 |
-| `--defer-gate` | Opt-in parallel-batch gate policy (task 1111): each task's `test` hop runs the light tier and writes `DEFERRED`; the batch runs one integrated full gate on the base ref before the feature sync. Requires `--mode parallel`; default off. | off |
+| `--defer-gate` | Opt-in parallel-batch gate policy (task 1111): each task's `test` hop runs the light tier and writes `DEFERRED`; the batch runs one integrated full gate on the base ref before the feature sync. Requires `--mode parallel`, or `--mode auto` resolved to parallel (dropped with a note otherwise); default off. | off |
 
 For shared semantics, see the [flag glossary](../skills/spur-dev/references/flag-glossary.md).
 
 ## Usage
 
 ```
-/sp:dev-runall --tasks <selector> [--feature <id>] [--mode <sequential|parallel>] [--keep-going] [--auto] [--agent <inline|auto|name>] [--json] [--wrap] [--next] [--continue] [--worktree [<name>]] [--no-summary] [--defer-gate]
+/sp:dev-runall --tasks <selector> [--feature <id>] [--mode <sequential|parallel|auto>] [--concurrency <n>] [--keep-going] [--auto] [--agent <inline|auto|name>] [--json] [--wrap] [--next] [--continue] [--worktree [<name>]] [--no-summary] [--defer-gate]
 ```
 
 Flags: `--tasks <selector>` (required — explicit WBS list, status pseudo-list, `feature:<id>`,
@@ -44,8 +44,8 @@ structured findings, before any task pipeline action, task 0510 R2; scoped: `L4.
 (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` in `plugins/sp/scripts/batch-preflight.ts`; `--fix` repairs land in the report's `autoRepairs`) —
 any other strict error aborts), `--mode`
-`<sequential|parallel>` (default `sequential`; `parallel` fans out a proven-independent subset —
-see `execution-parallel-isolation.md`), `--concurrency <n>`
+`<sequential|parallel|auto>` (default `sequential`; `parallel` fans out a proven-independent subset —
+see `execution-parallel-isolation.md`; `auto` picks one per batch — see below), `--concurrency <n>`
 (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
@@ -62,6 +62,15 @@ FF-merge onto the base ref on full success, retain intact on any failure/halt/no
 creates a fresh tree, `<name>` form adopts an existing worktree by name/path/branch; see
 `execution-worktree-setup.md` + `execution-worktree-landing.md`).
 
+**`--mode auto` (smart scheduling).** Ordering is always dependency-correct — every mode
+topo-sorts the frozen set with `batch-plan.mjs order` (deterministic, never hand-sorted). `auto`
+additionally reads that schedule's dependency waves (tasks declaring the same file are serialized)
+and decides once, before the first task: `parallel` when some wave holds ≥2 independent tasks and
+`--concurrency` ≥2; otherwise `sequential` in the host session. `--worktree` or explicit
+`--agent inline` pins `sequential`. The batch report records `mode: auto → <resolved>` and why.
+Default stays `sequential`: parallel costs ~N× tokens, worktree setup and subprocess executors, which
+a dependency chain never pays back. Rules: execution-batch.md § 2.4a.
+
 **`--worktree` and parallel mode.** `--worktree --mode parallel` is **rejected** — parallel mode
 already isolates each task in its own worktree (see `execution-parallel-isolation.md`), and
 reuse mode (`--worktree <name>`) has no per-task meaning. Run parallel batches without
@@ -98,7 +107,7 @@ full distinction.
   § 2.7 Visible batch plan.
 - Apply the [inline-default execution-surface contract](../skills/spur-dev/references/cross-cutting.md#inline-default-execution-surface). Interactive sequential omit/`inline` keeps the orchestrator in the host session through the [inline pipeline driver](../skills/spur-dev/references/inline-pipeline-driver.md); the resolved selector applies uniformly — eligible `agent.run` stages dispatch once to a native subagent with host fallback (0508). `--agent auto`, a name, or parallel mode retains the isolated per-task workflow boundary.
 - Apply the [shared startup contract](../skills/spur-dev/references/cross-cutting.md#shared-startup-contract-task-0814-r1r3r4r6r7r8) — publish the generated plan first, quick readiness before isolation, digest binding, comprehensive checks at owning boundaries (task 0814 R1/R3/R4/R7/R8; 1105 R1).
-- Interactive sequential omit/inline: `Skill(skill="sp:spur-dev", args="runall-inline $ARGUMENTS")`.
-- Explicit executor or parallel mode: `Skill(skill="sp:spur-dev", args="runall $ARGUMENTS")` → `sp:super-planner` agent.
+- Interactive sequential omit/inline, and `--mode auto` without an explicit executor: `Skill(skill="sp:spur-dev", args="runall-inline $ARGUMENTS")` — auto resolves in the host after freeze/order (§ 2.4a) and hands a parallel resolution to the `runall` path with the frozen explicit WBS list.
+- Explicit executor (any mode, including `auto`) or parallel mode: `Skill(skill="sp:spur-dev", args="runall $ARGUMENTS")` → `sp:super-planner` agent.
 - After the batch report, print the [execution summary](../skills/spur-dev/references/dev-operations.md#execution-summary) over every attempted run unless
   `--no-summary`.

package/plugins/sp/hooks/context-owner.ts

@@ -0,0 +1,56 @@
+/**
+ * context-owner — host-native session ownership identity shared by the indexed-context hooks
+ * (task 1159).
+ *
+ * Extracted from `context-session-start`/`context-session-stop` so the Claude stdin-payload →
+ * owner derivation is a pure, importable function. A hook's `if (import.meta.main)` entrypoint runs
+ * in a subprocess whose body Bun's coverage never attributes, so any real logic left there is
+ * untestable; this module keeps that logic where a unit test can reach it.
+ *
+ * Standalone-safe (sp-plugin-standalone): no imports, so a hook bundles it as a relative path and
+ * `context-session-stop` stays free of the session-start module's heavier dependency surface.
+ */
+
+/**
+ * Who owns a session ledger pointer (task 1159): the host that opened the session plus that host's
+ * own native session id — Claude's hook payload `session_id`, Pi's `ctx.sessionManager.getSessionId()`.
+ * Deliberately **not** the ledger id (shared by every nested run), `process.pid` (a fresh hook process
+ * per event) or `SPUR_RUN_ID` (present on nested children too): none of those separate owner from
+ * child, so none may gate teardown; the host-native id can.
+ */
+export interface SessionOwner {
+    host: 'claude' | 'pi';
+    sessionId: string;
+}
+
+/**
+ * Claude hook identity (task 1159): the payload's `session_id`, falling back to
+ * `CLAUDE_CODE_SESSION_ID` only when the payload id is absent or empty (some Claude hook payloads
+ * omit `session_id`). Returns null when neither yields a nonempty id — the pointer is then written
+ * ownerless, so a later shutdown cannot prove ownership of it (bounded legacy policy in
+ * context-session-stop).
+ */
+export function claudeSessionOwner(payload: unknown, env: NodeJS.ProcessEnv): SessionOwner | null {
+    const raw = payload && typeof payload === 'object' ? (payload as { session_id?: unknown }).session_id : undefined;
+    const fromPayload = typeof raw === 'string' ? raw.trim() : '';
+    const fromEnv = (env.CLAUDE_CODE_SESSION_ID ?? '').trim();
+    const sessionId = fromPayload.length > 0 ? fromPayload : fromEnv;
+    return sessionId.length > 0 ? { host: 'claude', sessionId } : null;
+}
+
+/**
+ * Derive the Claude owner from a raw hook stdin payload (task 1159).
+ *
+ * Malformed or empty stdin carries no payload identity, so it degrades to the env-only fallback
+ * rather than throwing — both hooks keep their fail-open contract. Behaviour is identical to the
+ * former inline `JSON.parse(await Bun.stdin.text())` try/catch in each entrypoint.
+ */
+export function claudeHookOwnerFromPayloadText(text: string, env: NodeJS.ProcessEnv): SessionOwner | null {
+    let payload: unknown;
+    try {
+        payload = JSON.parse(text) as unknown;
+    } catch {
+        payload = undefined;
+    }
+    return claudeSessionOwner(payload, env);
+}

package/plugins/sp/hooks/context-post-tool.ts

@@ -72,6 +72,29 @@ export function estimateTokens(text: string): number {
 /** Scrub secret-like patterns without size capping. */
 export function scrubSecrets(text: string): string {
     let s = text;
+    // Quoted JSON fields first (task 1158): in `{"password": "…"}` the key is itself
+    // quoted, so the bare `key=value` pass below never sees a separator directly after
+    // the key and would persist the value verbatim. Match the quoted sensitive key, keep
+    // it, and replace the entire value. The key may be spelled three ways in real Bash:
+    // `"key"`, `'key'`, and the shell-escaped `\"key\"` inside a double-quoted argument
+    // (`curl -d "{\"password\":\"…\"}"`); the value may be quoted the same way or left
+    // unquoted (`{"password": 12345}`). Escape-aware: a `\"` or `\\` inside a value is
+    // content, never a terminator, and an unterminated value (including a trailing lone
+    // backslash) is redacted through end-of-input so a truncated command cannot leak a
+    // suffix. In the shell-escaped opener form the JSON quote shows up in three raw
+    // spellings: a terminator `\"`, a JSON-level escaped quote `\\\"` (escaped
+    // backslash + escaped quote) that is value content, and a bare `"` that is neither.
+    // That form gets a dedicated alternative whose body consumes `\\\"` as content and
+    // stops only at a clean `\"` terminator; when no clean terminator follows it fails
+    // closed and redacts through end-of-input, so a bare `"` cannot end the value early
+    // and leak its suffix. Runs before
+    // Bearer/`key=` passes so the whole value is replaced, not prefixed. The key must end
+    // on a sensitive word, so `token_count`, `tokens`, `tokenizer` and
+    // `authorization_header` stay readable.
+    s = s.replace(
+        /((\\?(["']))(?:[A-Za-z0-9]+[_-])*(?:api[_-]?key|password|passwd|secret|token|access[_-]?key|private[_-]?key|authorization)\2\s*:\s*)(?:\\\3(?:[^"\\]|\\\\(?:\\\3)|\\[^"])*(?:\\\3|[\s\S]*$)|"(?:[^"\\]|\\.)*(?:"|\\?$)|'(?:[^'\\]|\\.)*(?:'|\\?$)|[^\s,}\][{"']+)/gi,
+        '$1"***"',
+    );
     // Bearer / API key prefixes first (before generic key=value)
     s = s.replace(/\bBearer\s+[A-Za-z0-9._\-+=/]+/gi, 'Bearer ***');
     // `sk-` keys. Segments may be hyphen-separated (`sk-ant-api03-…`), so match the

package/plugins/sp/hooks/context-session-start.ts

@@ -4,8 +4,10 @@
  * context-session-start — SessionStart hook for indexed-context.
  *
  * Generates a session ID, writes `.spur/context/.session.json` (tracking the current session
- * for PostToolUse and Stop hooks), and appends a `session_start` event to
- * `token-ledger.jsonl`. Task 0246: best-effort agent/model hints on session file + event.
+ * for PostToolUse and Stop hooks), and appends a `session_start` event to `token-ledger.jsonl`.
+ * Task 0246: best-effort agent/model hints on session file + event. Task 1159: the pointer records
+ * the host-native {@link SessionOwner} that created it, so a nested child can reuse the ledger for
+ * tool recording without being able to tear it down.
  *
  * **Fail-open contract:** every error path exits 0 with no output.
  *
@@ -13,13 +15,19 @@
  */
 
 import { execSync } from 'node:child_process';
+import { randomUUID } from 'node:crypto';
 import { appendFileSync, mkdirSync, readFileSync, writeFileSync } from 'node:fs';
 import { join } from 'node:path';
 import { getEnvVar, getEnvVars } from '../lib/env';
 import { resolveAgentHint, resolveModelHint } from './agent-hint';
+import { claudeHookOwnerFromPayloadText, type SessionOwner } from './context-owner';
 import { checkContextFreshness } from './context-post-tool';
 
 export { resolveAgentHint, resolveModelHint } from './agent-hint';
+export type { SessionOwner } from './context-owner';
+// Owner identity + Claude payload derivation live in ./context-owner (pure, unit-testable);
+// re-exported here because this module stays the hook surface consumers reach for.
+export { claudeHookOwnerFromPayloadText, claudeSessionOwner } from './context-owner';
 
 /**
  * Ancestor-run marker exported by `@gobing-ai/ts-ai-runner` ≥ 0.4.15 (`AGENT_RUN_ID_ENV`).
@@ -64,38 +72,29 @@ interface SessionFileBody {
  * Return the id of the session already in flight, or null when a new one should be minted.
  *
  * **Why this exists (0398 R3).** `SessionStart` fires in every nested `agent.run` subprocess, not
- * once per host session. Each firing used to mint a fresh `session-<date>-<HHMM>` id, append a
+ * once per host session. Each firing used to mint a fresh `session-<date>-<HHMM>` id (now
+ * seconds-plus-random, 1166), append a
  * `session_start` row, and overwrite the `.session.json` pointer that `context-post-tool` reads —
  * so a single pipeline run registered as dozens of sessions and orphaned the parent's event
  * stream. The H6 corpus shows the signature: 332 `session_start` against 157 `session_end` over
  * 18 days, 298 distinct ids, 39 starts in a 2-day window that held a handful of real sessions.
  *
- * **Two signals, in precedence order.**
- *
- * 1. {@link AGENT_RUN_ID_ENV} present → this process is a descendant of an agent run, definitively.
- *    Reuse the recorded session with no time bound: a pipeline step legitimately runs for the full
- *    `implementTimeoutMs` (45 min) and longer batches run for hours, so any wall-clock window would
- *    eventually split a run that is demonstrably still in flight.
- * 2. No marker → fall back to the {@link SESSION_REUSE_IDLE_MS} window on the `started` stamp, for
- *    hosts that nest without propagating a correlation.
- *
- * A crashed session leaves a stale `.session.json`; on path 2 the idle window retires it. On path 1
- * a stale file is only reachable from inside a live agent run, where reusing it is the correct
- * answer anyway.
+ * **Two signals, in precedence order.** (1) {@link AGENT_RUN_ID_ENV} present → definitively a
+ * descendant of an agent run: reuse the recorded session with no time bound, because a pipeline step
+ * legitimately runs for the full `implementTimeoutMs` (45 min) and longer batches for hours, so any
+ * wall-clock window would eventually split a run that is still in flight. (2) No marker → fall back
+ * to the {@link SESSION_REUSE_IDLE_MS} window on the `started` stamp, for hosts that nest without
+ * propagating a correlation. A crashed session leaves a stale `.session.json`: on (2) the idle window
+ * retires it, on (1) a stale file is only reachable from inside a live agent run, where reusing it is
+ * the correct answer anyway.
  */
 export function resolveActiveSession(dir: string, now: Date, env: NodeJS.ProcessEnv = getEnvVars()): string | null {
-    let raw: string;
-    try {
-        raw = readFileSync(join(dir, '.session.json'), 'utf-8');
-    } catch {
-        return null; // no in-flight session (or unreadable) → mint a new one
-    }
-
     let body: SessionFileBody;
     try {
-        body = JSON.parse(raw) as SessionFileBody;
+        // No in-flight session, unreadable file or corrupt pointer → mint a new one.
+        body = JSON.parse(readFileSync(join(dir, '.session.json'), 'utf-8')) as SessionFileBody;
     } catch {
-        return null; // corrupt pointer → mint a new one
+        return null;
     }
 
     if (typeof body.session !== 'string' || body.session.length === 0) return null;
@@ -121,12 +120,17 @@ export function resolveActiveSession(dir: string, now: Date, env: NodeJS.Process
  *
  * Idempotent per in-flight session (0398 R3): when `resolveActiveSession` finds one, this returns
  * that id and writes nothing — no ledger row, no pointer rewrite.
+ *
+ * Ownership (task 1159): a **new** pointer records a valid `owner` only; a reused start never
+ * rewrites the pointer, so a nested child cannot take ownership from the parent that opened it,
+ * and only the recorded owner's shutdown can finalize the ledger.
  */
 export function recordSessionStart(
     dir: string,
     env: NodeJS.ProcessEnv = getEnvVars(),
     now: () => Date = () => new Date(),
     agentFallback?: string,
+    owner?: SessionOwner,
 ): string | null {
     try {
         mkdirSync(dir, { recursive: true });
@@ -139,7 +143,11 @@ export function recordSessionStart(
     const active = resolveActiveSession(dir, at, env);
     if (active !== null) return active;
     const pad = (n: number) => String(n).padStart(2, '0');
-    const sessionId = `session-${at.toISOString().slice(0, 10)}-${pad(at.getHours())}${pad(at.getMinutes())}`;
+    // Uniqueness suffix (1166): minute-granular ids collided when a session started in the same
+    // minute an earlier one ended, and the frozen end algorithm then suppressed the new session's
+    // `session_end` row as a duplicate. Seconds + a random suffix make collisions practically
+    // impossible; the id stays an opaque ledger key everywhere else.
+    const sessionId = `session-${at.toISOString().slice(0, 10)}-${pad(at.getHours())}${pad(at.getMinutes())}${pad(at.getSeconds())}-${randomUUID().slice(0, 8)}`;
     const ts = at.toISOString();
     const agent = resolveAgentHint(env, agentFallback);
     const model = resolveModelHint(env);
@@ -153,6 +161,9 @@ export function recordSessionStart(
     };
     if (agent) sessionBody.agent = agent;
     if (model) sessionBody.model = model;
+    const ownerId = typeof owner?.sessionId === 'string' ? owner.sessionId.trim() : '';
+    const host = owner?.host;
+    if (ownerId !== '' && (host === 'claude' || host === 'pi')) sessionBody.owner = { host, sessionId: ownerId };
 
     const sessionFile = join(dir, '.session.json');
     try {
@@ -194,10 +205,21 @@ export function recordSessionStart(
     return sessionId;
 }
 
-// Entrypoint — kept minimal so unit coverage focuses on pure helpers above.
+/**
+ * Open (or reuse) the session for a raw Claude stdin payload (task 1159, testable half).
+ *
+ * Malformed/absent text still opens the session ownerless (legacy policy); the dir resolution lives
+ * here rather than in the entrypoint so the untestable subprocess body stays a few lines.
+ */
+export function recordSessionStartFromPayloadText(text: string, env: NodeJS.ProcessEnv = getEnvVars()): string | null {
+    const dir = join(getEnvVar('CLAUDE_PROJECT_DIR') ?? process.cwd(), '.spur', 'context');
+    return recordSessionStart(dir, env, undefined, undefined, claudeHookOwnerFromPayloadText(text, env) ?? undefined);
+}
+
+// Entrypoint — thin stdin adapter; logic lives in the exported helpers above (task 1159 coverage).
 if (import.meta.main) {
     try {
-        recordSessionStart(join(getEnvVar('CLAUDE_PROJECT_DIR') ?? process.cwd(), '.spur', 'context'));
+        recordSessionStartFromPayloadText(await Bun.stdin.text());
     } catch {
         /* fail-open */
     }