@gobing-ai/spur 0.3.99 → 0.4.0

package/plugins/sp/scripts/session-timeline.mjs

@@ -0,0 +1,234 @@
+#!/usr/bin/env node
+// @bun
+
+// plugins/sp/scripts/session-timeline.ts
+import { readFileSync } from "fs";
+
+// plugins/sp/lib/env.ts
+function getEnvVars() {
+  return process.env;
+}
+
+// plugins/sp/lib/transcript.ts
+import { existsSync, readdirSync } from "node:fs";
+import { homedir } from "node:os";
+import { join } from "node:path";
+var SESSION_ID = /^[A-Za-z0-9_-]+$/;
+var OPERATOR_TOOLS = new Set(["AskUserQuestion"]);
+var zeroTokens = () => ({ input: 0, cacheCreate: 0, cacheRead: 0, output: 0 });
+function formatDuration(ms) {
+  const s = Math.round(ms / 1000);
+  const h = Math.floor(s / 3600);
+  const m = Math.floor(s % 3600 / 60);
+  const ss = String(s % 60).padStart(2, "0");
+  return h > 0 ? `${h}:${String(m).padStart(2, "0")}:${ss}` : `${m}:${ss}`;
+}
+function formatTokens(n) {
+  if (n >= 999500)
+    return `${(n / 1e6).toFixed(1)}M`;
+  return n >= 1000 ? `${Math.round(n / 1000)}k` : String(n);
+}
+function formatTokenSplit(t) {
+  if (!t)
+    return "n/a";
+  const nonCached = t.input + t.cacheCreate + t.output;
+  return `${formatTokens(nonCached + t.cacheRead)} / ${formatTokens(nonCached)}`;
+}
+function promptText(row) {
+  if (row.type !== "user" || row.isMeta || row.isCompactSummary)
+    return;
+  const content = row.message?.content;
+  if (typeof content === "string")
+    return content;
+  if (!Array.isArray(content) || content.some((b) => b.type === "tool_result"))
+    return;
+  return content.find((b) => b.type === "text")?.text;
+}
+function sumTokens(all) {
+  const total = zeroTokens();
+  for (const t of all)
+    for (const k of Object.keys(total))
+      total[k] += t[k];
+  return total;
+}
+function sumSpans(spans) {
+  return {
+    workMs: spans.reduce((n, s) => n + s.workMs, 0),
+    waitMs: spans.reduce((n, s) => n + s.waitMs, 0),
+    toolCalls: spans.reduce((n, s) => n + s.toolCalls, 0),
+    tokens: sumTokens(spans.map((s) => s.tokens))
+  };
+}
+var newAcc = (ts) => ({
+  last: ts,
+  askMs: 0,
+  asks: new Map,
+  toolIds: new Set,
+  messages: new Map
+});
+function accumulate(acc, row, ts) {
+  acc.last = Math.max(acc.last, ts);
+  const blocks = Array.isArray(row.message?.content) ? row.message.content : [];
+  for (const b of blocks) {
+    if (b.type === "tool_use" && b.id) {
+      acc.toolIds.add(b.id);
+      if (b.name && OPERATOR_TOOLS.has(b.name))
+        acc.asks.set(b.id, ts);
+    } else if (b.type === "tool_result" && b.tool_use_id && acc.asks.has(b.tool_use_id)) {
+      acc.askMs += ts - (acc.asks.get(b.tool_use_id) ?? ts);
+    }
+  }
+  const u = row.message?.usage;
+  if (row.type === "assistant" && u && row.message?.id) {
+    acc.messages.set(row.message.id, {
+      input: u.input_tokens ?? 0,
+      cacheCreate: u.cache_creation_input_tokens ?? 0,
+      cacheRead: u.cache_read_input_tokens ?? 0,
+      output: u.output_tokens ?? 0
+    });
+  }
+}
+function parseRows(lines) {
+  const rows = [];
+  let skippedLines = 0;
+  for (const line of lines) {
+    if (!line.trim())
+      continue;
+    let row;
+    try {
+      row = JSON.parse(line);
+    } catch {
+      skippedLines++;
+      continue;
+    }
+    const ts = row.timestamp ? Date.parse(row.timestamp) : Number.NaN;
+    if (!Number.isNaN(ts))
+      rows.push([row, ts]);
+  }
+  return { rows, skippedLines };
+}
+function resolveTranscript(env, projectsRoot = join(homedir(), ".claude", "projects"), override) {
+  if (override)
+    return existsSync(override) ? { ok: true, path: override } : { ok: false, reason: "no transcript" };
+  const id = env.CLAUDE_CODE_SESSION_ID;
+  if (!id)
+    return { ok: false, reason: "no host session id (CLAUDE_CODE_SESSION_ID); pass --transcript <path>" };
+  if (!SESSION_ID.test(id))
+    return { ok: false, reason: "refusing a session id with path characters" };
+  if (!existsSync(projectsRoot))
+    return { ok: false, reason: `no transcript root ${projectsRoot}` };
+  for (const dir of readdirSync(projectsRoot)) {
+    const path = join(projectsRoot, dir, `${id}.jsonl`);
+    if (existsSync(path))
+      return { ok: true, path };
+  }
+  return { ok: false, reason: `no transcript for session ${id}` };
+}
+
+// plugins/sp/scripts/session-timeline.ts
+var PROMPT_EXCERPT = 80;
+var render = (span) => ({
+  ...span,
+  work: formatDuration(span.workMs),
+  wait: formatDuration(span.waitMs),
+  token: formatTokenSplit(span.tokens)
+});
+function parseGroups(spec, count) {
+  let next = 1;
+  return spec.split(",").map((part) => {
+    const [a = Number.NaN, b = a] = part.trim().split("-").map(Number);
+    if (!Number.isInteger(a) || !Number.isInteger(b) || a < next || b < a || b > count) {
+      throw new Error(`invalid --group "${part}" (segments 1-${count}, ascending, no overlap)`);
+    }
+    next = b + 1;
+    return [a, b];
+  });
+}
+function buildTimeline(lines, group) {
+  const open = [];
+  const { rows, skippedLines } = parseRows(lines);
+  for (const [row, ts] of rows) {
+    const prompt = promptText(row);
+    if (prompt !== undefined) {
+      open.push({ start: ts, prompt, ...newAcc(ts) });
+      continue;
+    }
+    const seg = open.at(-1);
+    if (seg)
+      accumulate(seg, row, ts);
+  }
+  const segments = open.map((seg, i) => {
+    const next = open[i + 1]?.start;
+    const idle = next === undefined ? 0 : Math.max(0, next - seg.last);
+    const oneLine = seg.prompt.replace(/\s+/g, " ").trim();
+    return render({
+      index: i + 1,
+      start: new Date(seg.start).toISOString(),
+      prompt: oneLine.length > PROMPT_EXCERPT ? `${oneLine.slice(0, PROMPT_EXCERPT)}\u2026` : oneLine,
+      workMs: seg.last - seg.start - seg.askMs,
+      waitMs: idle + seg.askMs,
+      toolCalls: seg.toolIds.size,
+      tokens: sumTokens([...seg.messages.values()])
+    });
+  });
+  const first = open[0];
+  const last = open.at(-1);
+  const elapsedMs = first && last ? last.last - first.start : 0;
+  const timeline = {
+    available: true,
+    segments,
+    totals: render({ ...sumSpans(segments), elapsedMs, elapsed: formatDuration(elapsedMs) }),
+    skippedLines
+  };
+  if (group) {
+    timeline.stages = parseGroups(group, segments.length).map(([a, b]) => render({ ...sumSpans(segments.slice(a - 1, b)), segments: a === b ? `${a}` : `${a}-${b}` }));
+  }
+  return timeline;
+}
+var SESSION_TIMELINE_USAGE = 'usage: session-timeline [--transcript <path>] [--group "1-3,4,..."]';
+function main(argv, env = getEnvVars(), write = (s) => process.stdout.write(s), projectsRoot, writeErr = (s) => process.stderr.write(s)) {
+  let transcript;
+  let group;
+  for (let i = 0;i < argv.length; i++) {
+    const arg = argv[i];
+    if (arg === "--transcript" && argv[i + 1])
+      transcript = argv[++i];
+    else if (arg === "--group" && argv[i + 1])
+      group = argv[++i];
+    else if (arg === "--spur-bin" && argv[i + 1])
+      i++;
+    else {
+      writeErr(`${SESSION_TIMELINE_USAGE}
+`);
+      return 2;
+    }
+  }
+  const resolved = resolveTranscript(env, projectsRoot, transcript);
+  if (!resolved.ok) {
+    write(`${JSON.stringify({ available: false, reason: resolved.reason })}
+`);
+    return 0;
+  }
+  try {
+    const timeline = buildTimeline(readFileSync(resolved.path, "utf8").split(`
+`), group);
+    write(`${JSON.stringify({ ...timeline, transcript: resolved.path })}
+`);
+    return 0;
+  } catch (error) {
+    writeErr(`session-timeline: ${error.message}
+`);
+    return 2;
+  }
+}
+process.exit(main(process.argv.slice(2)));
+export {
+  resolveTranscript,
+  parseGroups,
+  main,
+  formatTokens,
+  formatTokenSplit,
+  formatDuration,
+  buildTimeline,
+  SESSION_TIMELINE_USAGE
+};

package/plugins/sp/scripts/session-timeline.ts

@@ -0,0 +1,152 @@
+#!/usr/bin/env bun
+/**
+ * session-timeline — measured time and token evidence for the sp:session-review Time breakdown.
+ * The visible conversation carries no timestamps or usage (so the table read `n/a`); the host
+ * transcript carries both. Reads the active Claude Code JSONL read-only
+ * (`~/.claude/projects/<slug>/<CLAUDE_CODE_SESSION_ID>.jsonl`, or `--transcript`), one segment per
+ * operator prompt: work = prompt → last activity; wait = idle until the next prompt plus time spent
+ * answering an AskUserQuestion; tokens counted once per message id and rendered `<total> /
+ * <non-cached>`. `--group "1-3,4"` sums segments into stages. No transcript → `{available:false}`,
+ * exit 0, and the review renders `n/a` instead of guessing. Node builtins only (standalone plugin).
+ */
+import { readFileSync } from 'node:fs';
+import { getEnvVars } from '../lib/env';
+import {
+    type Acc,
+    accumulate,
+    formatDuration,
+    formatTokenSplit,
+    newAcc,
+    parseRows,
+    promptText,
+    resolveTranscript,
+    type Span,
+    sumSpans,
+    sumTokens,
+} from '../lib/transcript';
+
+export { formatDuration, formatTokenSplit, formatTokens, resolveTranscript } from '../lib/transcript';
+
+/** A span plus its `M:SS` / `H:MM:SS` and token renderings, so the review table needs no arithmetic. */
+export type Rendered<T> = T & { work: string; wait: string; token: string };
+
+export interface Timeline {
+    available: true;
+    transcript?: string;
+    segments: Rendered<Span & { index: number; start: string; prompt: string }>[];
+    stages?: Rendered<Span & { segments: string }>[];
+    totals: Rendered<Span & { elapsedMs: number; elapsed: string }>;
+    skippedLines: number;
+}
+
+const PROMPT_EXCERPT = 80;
+
+const render = <T extends Span>(span: T): Rendered<T> => ({
+    ...span,
+    work: formatDuration(span.workMs),
+    wait: formatDuration(span.waitMs),
+    token: formatTokenSplit(span.tokens),
+});
+
+/** "1-3,4" → [[1,3],[4,4]]; 1-based, ascending, in range, non-overlapping. */
+export function parseGroups(spec: string, count: number): [number, number][] {
+    let next = 1;
+    return spec.split(',').map((part) => {
+        const [a = Number.NaN, b = a] = part.trim().split('-').map(Number);
+        if (!Number.isInteger(a) || !Number.isInteger(b) || a < next || b < a || b > count) {
+            throw new Error(`invalid --group "${part}" (segments 1-${count}, ascending, no overlap)`);
+        }
+        next = b + 1;
+        return [a, b] as [number, number];
+    });
+}
+
+interface Open extends Acc {
+    start: number;
+    prompt: string;
+}
+
+export function buildTimeline(lines: string[], group?: string): Timeline {
+    const open: Open[] = [];
+    const { rows, skippedLines } = parseRows(lines);
+
+    for (const [row, ts] of rows) {
+        const prompt = promptText(row);
+        if (prompt !== undefined) {
+            open.push({ start: ts, prompt, ...newAcc(ts) });
+            continue;
+        }
+        const seg = open.at(-1);
+        if (seg) accumulate(seg, row, ts); // rows before the first prompt are session preamble
+    }
+
+    const segments = open.map((seg, i) => {
+        const next = open[i + 1]?.start;
+        const idle = next === undefined ? 0 : Math.max(0, next - seg.last);
+        const oneLine = seg.prompt.replace(/\s+/g, ' ').trim();
+        return render({
+            index: i + 1,
+            start: new Date(seg.start).toISOString(),
+            prompt: oneLine.length > PROMPT_EXCERPT ? `${oneLine.slice(0, PROMPT_EXCERPT)}…` : oneLine,
+            workMs: seg.last - seg.start - seg.askMs,
+            waitMs: idle + seg.askMs,
+            toolCalls: seg.toolIds.size,
+            tokens: sumTokens([...seg.messages.values()]),
+        });
+    });
+
+    const first = open[0];
+    const last = open.at(-1);
+    const elapsedMs = first && last ? last.last - first.start : 0;
+    const timeline: Timeline = {
+        available: true,
+        segments,
+        totals: render({ ...sumSpans(segments), elapsedMs, elapsed: formatDuration(elapsedMs) }),
+        skippedLines,
+    };
+    if (group) {
+        timeline.stages = parseGroups(group, segments.length).map(([a, b]) =>
+            render({ ...sumSpans(segments.slice(a - 1, b)), segments: a === b ? `${a}` : `${a}-${b}` }),
+        );
+    }
+    return timeline;
+}
+
+export const SESSION_TIMELINE_USAGE = 'usage: session-timeline [--transcript <path>] [--group "1-3,4,..."]';
+
+export function main(
+    argv: string[],
+    env: Record<string, string | undefined> = getEnvVars(),
+    write: (s: string) => void = (s) => process.stdout.write(s),
+    projectsRoot?: string,
+    writeErr: (s: string) => void = (s) => process.stderr.write(s),
+): number {
+    let transcript: string | undefined;
+    let group: string | undefined;
+    for (let i = 0; i < argv.length; i++) {
+        const arg = argv[i];
+        if (arg === '--transcript' && argv[i + 1]) transcript = argv[++i];
+        else if (arg === '--group' && argv[i + 1]) group = argv[++i];
+        else if (arg === '--spur-bin' && argv[i + 1])
+            i++; // 0482 R2: accepted, unused (no spur calls)
+        else {
+            writeErr(`${SESSION_TIMELINE_USAGE}\n`);
+            return 2;
+        }
+    }
+    const resolved = resolveTranscript(env, projectsRoot, transcript);
+    if (!resolved.ok) {
+        write(`${JSON.stringify({ available: false, reason: resolved.reason })}\n`);
+        return 0;
+    }
+    try {
+        const timeline = buildTimeline(readFileSync(resolved.path, 'utf8').split('\n'), group);
+        write(`${JSON.stringify({ ...timeline, transcript: resolved.path })}\n`);
+        return 0;
+    } catch (error) {
+        writeErr(`session-timeline: ${(error as Error).message}\n`);
+        return 2;
+    }
+}
+
+if (import.meta.main) process.exit(main(process.argv.slice(2)));

package/plugins/sp/skills/code-verification/SKILL.md

@@ -315,6 +315,11 @@ node "$RESIDUAL" fold <wbs>
 > for each dropped MET-matched scenario key and when the new rows match no feature scenario —
 > treat those warnings as a re-key instruction, not noise.
 
+> **Keying rule for feature-linked tasks (1086/1089 re-audits).** Key AC rows by the exact feature
+> scenario title (`R1 — …`): feature `Scenario:` titles are declared identities and satisfy L4
+> scenario matching directly. Bare `AC1` fails `ac-identity` on Gherkin AC sections, and checklist
+> labels truncate at the first colon (a `(req: …)` suffix), so the task's own AC title may not resolve.
+
 > **Do not write `## Review` directly, ever.** The `## Review` section is owned by the
 > `review` coordinator (`/sp:dev-review` → `sp:super-reviewer`), which merges
 > `functional-review` + `code-verification` review mode + `code-improvement` fragments. The

package/plugins/sp/skills/fleet-join/SKILL.md

@@ -0,0 +1,63 @@
+---
+name: fleet-join
+description: >-
+  Join a project fleet as a guest occupant and pull its work. Use when the operator asks to
+  "join the fleet", "become a fleet guest", "pull fleet inbox work in this session", or when a
+  session should receive fleet messages without being supervised. Runs `spur agent join`, then
+  loops `spur agent wait --inbox`, and releases the lease with `spur agent leave`.
+---
+# fleet-join — a live session as a fleet guest (G73, task 1081)
+
+A guest is a session that **pulls** work: it is neither supervised nor restarted, it is addressed
+by concrete id only, and it never receives a stage (`requiresCapabilities` stages can never route
+to it — a guest carries no attestation). Joining registers an occupant row plus a heartbeat lease;
+leaving (or an expired lease) releases it and returns any claimed messages to `pending`.
+
+## Join
+
+```bash
+spur agent join --role reviewer --json      # id defaults to <role>-g<n>
+spur agent join --role coder --id my-session --json
+```
+
+Pick the role whose work this session can actually do. `--session-id` defaults to
+`CLAUDE_CODE_SESSION_ID`, which is what the Stop hook matches against — without it the hook cannot
+find this session, though the `wait --inbox` loop still works.
+
+## Pull loop
+
+`spur agent wait --inbox <id> --timeout 540000` returns **0** the moment queued work exists and
+**1** on timeout. Each call heartbeats the lease, so a looping session stays joined. The Bash tool's
+own ~10-minute limit is why the timeout stays under it: one bounded call per turn, re-armed after
+the work is done.
+
+1. `spur agent wait --inbox <id> --timeout 540000 --json` → exit 0 means work is waiting.
+2. `spur message inbox --agent <id> --json` → read the messages.
+3. Do the work the message asks for.
+4. `spur message reply <msgId> "<result>"` → reply to each one.
+5. Re-arm: go back to step 1 while the operator wants this session in the fleet.
+
+## Leave
+
+```bash
+spur agent leave --json                     # the guest joined by this session
+spur agent leave my-session --json           # an explicit id
+```
+
+Leaving releases the lease immediately. If the session dies without leaving, the lease expires and
+the reconciler pass retires the guest — pending work is never lost, it returns to `queued`.
+
+## Stop-hook delivery (opportunistic)
+
+When the host fires a `Stop` hook and the host supports the block contract, the
+`fleet-guest-stop` plugin hook delivers pending messages at turn end by replying
+`{"decision":"block","reason":"Pending fleet messages: …"}` — only for a session whose id matches a
+joined guest, never twice in one continued turn, and always fail-open. Claude Code supports this;
+Codex `exec` on 0.160.0 does not deliver `Stop` at all (`docs/plans/2026-10-05-codex-guest-spike.md`),
+so the pull loop above — not the hook — is what makes a guest work anywhere.
+
+## Boundaries
+
+- Guests are **not** supervised: do not expect restart, pid ownership, or `--drain` injection.
+- Never dispatch a stage to a guest id: `spur agent run --spec <guest-id>` is refused on purpose.
+- Never hold the write slot through a guest: the guest lease is the only heartbeat (R5).

package/plugins/sp/skills/session-review/SKILL.md

@@ -1,8 +1,8 @@
 ---
 name: session-review
-description: "Review the active coding-agent session: separate resolved from open issues with evidence, propose bounded improvements. With --triage, apply pure-doc / 1–2-line fixes inline and file the rest as one or more tasks. Triggers: review this session, wrap-up, triage findings."
+description: "Review the active coding-agent session: separate resolved from open issues with evidence, propose bounded improvements. With --fix auto (alias --triage), apply pure-doc / 1–2-line fixes inline and file the rest as tasks; with --fix all, fix every actionable finding inline and file none. Triggers: review this session, wrap-up, triage findings."
 license: Apache-2.0
-version: 1.1.0
+version: 1.2.0
 metadata:
   author: spur
   platforms: "claude-code,codex,openclaw,opencode,antigravity,pi"
@@ -31,7 +31,8 @@ cross-agent windows, recurrence, trends, or quantitative performance forensics.
 | Argument | Description | Default |
 | --- | --- | --- |
 | `[focus]` | Question or operation to emphasize. It changes ordering, not evidence collection. | full active session |
-| `--triage` | Opt into bounded remediation after the report: apply direct fixes (pure docs / one-to-two-line fixes) inline, then file all remaining actionable findings as one or more implement-ready tasks via the CLI-gated corpus surface. | off (report-only) |
+| `--fix <none\|auto\|all>` | Remediation after the report. `none`: report-only. `auto`: apply direct fixes (pure docs / one-to-two-line fixes) inline, then file all remaining actionable findings as one or more implement-ready tasks via the CLI-gated corpus surface. `all`: fix every actionable finding inline and file no task. | `none` |
+| `--triage` | `--triage` is an alias of `--fix auto`; an explicit `--fix` wins when both are passed. | off |
 
 ## Evidence boundary
 
@@ -46,14 +47,16 @@ cross-agent windows, recurrence, trends, or quantitative performance forensics.
   name the confirmation needed.
 - State `not available` when compaction or missing output removed evidence. Never reconstruct it from
   memory or claim a verification that did not run.
-- Derive timing only from timestamps and tool-call records visible in the active session. Use
-  non-overlapping stages whose durations sum to elapsed time; render unavailable duration or call
-  counts as `n/a` instead of estimating them.
+- Derive timing and tokens only from the host transcript measurement (Protocol step 1): the visible
+  conversation carries no timestamps or usage, so never estimate them from it. Use non-overlapping
+  stages whose durations sum to elapsed time; render a value as `n/a` only when the measurement
+  reports `available: false` or omits it.
 
-## Triage mode (`--triage`)
+## Fix modes (`--fix auto|all`)
 
-Report-only stays the default. With `--triage`, run the same evidence pass, then remediate in
-three buckets — never skip triage and start fixing from the raw findings list.
+Report-only stays the default. With `--fix auto` or `--fix all`, run the same
+evidence pass, then remediate in three buckets — never skip triage and start fixing from the raw
+findings list. Steps 1–4 below are `--fix auto`; `--fix all` differs only as stated after them.
 
 1. **Triage every finding into exactly one bucket:**
    - **Direct fix** — pure documentation work, or a one-to-two-line fix with obvious, local,
@@ -74,10 +77,22 @@ three buckets — never skip triage and start fixing from the raw findings list.
 4. **Report** — add a Triage section: applied fixes (path + one-line what + verification) and
    each created task WBS. The Resolved/Open tables keep their evidence rules unchanged.
 
+**`--fix all` (defer nothing).** Triage still runs, but the Task bucket is fixed inline instead of
+filed, so the mode creates no task. Fix in dependency order with the same surgical-diff and
+per-fix re-verification rule as direct fixes, then run the project gate once at the end. A finding
+that needs a design or operator decision is asked through the host question tool, never deferred;
+one that still cannot be fixed (failed re-verification, blocked by the environment) stays in Open
+issues with its evidence. Notes stay report-only.
+
 ## Protocol
 
 1. **Resolve scope.** Review the active session from the operator's initiating request through the
-   latest result. Use `[focus]` only to rank relevant material.
+   latest result. Use `[focus]` only to rank relevant material. Measure it with
+   `node "$(superskill script path sp session-timeline.mjs)" --group "<ranges>"`: one segment per
+   operator prompt, read-only from the host transcript. Run it once without `--group` to list the
+   segments, then map them to stages (`"1-3,4,5-6"`). It splits each segment into `work` and
+   operator `wait` (idle before the next prompt plus AskUserQuestion answer time) and counts tokens
+   once per message id.
 2. **Inventory outcomes.** List requested outcomes and classify each as completed, partial, blocked,
    or not attempted. Collapse repeated attempts into one outcome.
 3. **Classify issues.** For every material issue, distinguish resolved, open, or attempted. Record
@@ -108,26 +123,32 @@ State the overall result in one to three sentences, including partial or blocked
 Summarize elapsed time and, when supported by evidence, productive work, avoidable setup/recovery,
 and operator wait time. Then render non-overlapping stages:
 
-| Stage | Time | Tool calls | Assessment |
-| --- | ---: | ---: | --- |
+| Stage | Time | Wait | Tool calls | Token | Assessment |
+| --- | ---: | ---: | ---: | ---: | --- |
 
 Format durations as `M:SS` below one hour and `H:MM:SS` at one hour or above (`1:44`, not `1m44s`;
 `0:33`, not `33s`). Include a `Total` row when elapsed time is available. Keep operator approval
-waits separate from execution bottlenecks. Use `n/a` for any value not supported by the active
-session evidence.
+waits separate from execution bottlenecks. Time is the stage `work` and Wait its operator `wait`.
+Token renders `<total> / <non-cached>` in compact units (`28.7M / 717k`) — the measurement's
+`token` field: total = input + cache creation + cache read + output; non-cached = total minus cache
+read (fresh input, cache writes and output). These are measured session counts, not the 0912 baseline token/USD claims that
+step 4 excludes. Use `n/a` for any value not supported by the measurement.
 
 ### Resolved issues
 
-| Issue | Root cause | Resolution | Evidence |
-| --- | --- | --- | --- |
+| Issue | Root cause | Resolution | Evidence | Confidence |
+| --- | --- | --- | --- | --- |
 
 Evidence names the tool result, verification command, or concrete repository state visible in the
-session. Do not list ordinary implementation steps as issues.
+session. Do not list ordinary implementation steps as issues. **Confidence** is `HIGH`, `MEDIUM`, or
+`LOW` for that row's claim, with its grounds in the cell (a level without grounds is not
+verification); any API/library statement in a row cites the installed source as `path:line` or a URL,
+and a claim the session could not ground is written `LOW` with the missing evidence named.
 
 ### Open issues and risks
 
-| Issue or risk | State | Evidence or confirmation needed |
-| --- | --- | --- |
+| Issue or risk | State | Evidence or confirmation needed | Confidence |
+| --- | --- | --- | --- |
 
 ### Process and environment improvements
 
@@ -137,13 +158,13 @@ observation adopted from the 0912 workflow baseline cites its anchor
 (`docs/reports/i31/0912-workflow-baseline.md`) and owner handoff, and carries no unsupported
 performance claim.
 
-### Triage (only when `--triage` was passed)
+### Triage (only with `--fix auto|all`)
 
 | Applied fix / created task | Bucket | What + verification |
 | --- | --- | --- |
 
-One row per applied fix and one per created task (with its WBS). Omit the section entirely when
-`--triage` was not passed.
+One row per applied fix and one per created task (with its WBS; `--fix all` has none). Omit the
+section entirely under `--fix none`.
 
 ### Next actions
 
@@ -157,8 +178,9 @@ improvement. Use `None` when the session is complete and no follow-up is justifi
   comparison or recurrence classification, or emit a twelve-section forensic report; those belong
   to imported-history analysis.
 - Report-only by default: do not create or update corpus items or edit files. The single exception
-  is `--triage` mode, which permits exactly two mutation classes — direct fixes from the triage
-  bucket, and the triage tasks. Anything beyond that stays a proposal.
+  is `--fix auto|all`: `auto` permits exactly two mutation classes — direct fixes from the triage
+  bucket, and the triage tasks; `all` permits one — inline fixes of actionable findings. Anything
+  beyond that stays a proposal.
 - Do not turn a single low-impact observation into a new policy. Report it as a candidate until it
   recurs or demonstrates a high-impact contract violation.
 

package/plugins/sp/skills/spur-cli/SKILL.md

@@ -49,6 +49,7 @@ Pick the noun, read its reference. Each Tier A and Tier B reference owns that no
 | **Tier B** | **self** | Self-management verbs: scaffold (`init`), database maintenance (`maintain`), schema migrations (`migrate`), local web server (`serve`), status overview (`status`); `self init` runs post-scaffold validation probes & layout classification | [references/self.md](references/self.md) |
 | **Tier B** | **history** | Import agent histories, aggregate forensic artifacts, render reports, and run the checkpoint-resumed daily pipeline | [references/history.md](references/history.md) |
 | **Tier B** | **projects** | Manage the local multi-project registry and start/stop project servers | [references/projects.md](references/projects.md) |
+| **Tier B** | **decision** | Decision-catalog transport: list visible decisions, show a served contract, run a decision to a served outcome, audit catalog health | [references/decision.md](references/decision.md) |
 | **Tier C** | **help** | Commander-generated help command; not a Spur noun | Generated `--help` |
 
 **Execute-First Contract:** Load the noun reference first and execute Tier A or Tier B commands