@gobing-ai/spur 0.3.70 → 0.3.72

package/plugins/sp/scripts/daily-summary/daily-summary.ts

@@ -59,6 +59,30 @@ export interface UserAnnotations {
     pending: string;
 }
 
+export interface HistoryLoopFinding {
+    toolName: string;
+    argsDigest: string;
+    repeats: number;
+    sessionId: string;
+    fromSeq?: number;
+    toSeq?: number;
+    wastedTokens: number;
+}
+
+export interface HistoryHealthSummary {
+    toolCalls: number;
+    toolErrors: number;
+    errorRatePct: number;
+    loops: HistoryLoopFinding[];
+    redundantCalls: number;
+    wastedTokens: number;
+    remediationProposals: Array<{
+        key: string;
+        title: string;
+        command: string;
+    }>;
+}
+
 export interface DailySummary {
     date: string;
     platforms: string[];
@@ -77,6 +101,8 @@ export interface DailySummary {
     };
     commits: GitCommit[];
     annotations: UserAnnotations;
+    /** Health metrics and loop findings from Spur history analytics. */
+    historyHealth?: HistoryHealthSummary;
     /** Path to the newest history report artifact (R7), resolved from the
      * `.spur/reports/history/latest.json` pointer. Omitted when no report exists. */
     historyReportPath?: string;
@@ -257,6 +283,122 @@ export async function getCcusageData(date: string): Promise<CcusageData | null>
     }
 }
 
+// ─── Spur History Health Integration ──────────────────────────────────────────
+
+export async function getSpurHistoryHealth(
+    date: string,
+    dbPath = '.spur/spur.db',
+): Promise<HistoryHealthSummary | null> {
+    try {
+        const resolvedPath = resolve(process.cwd(), dbPath);
+        if (!existsSync(resolvedPath)) {
+            return null;
+        }
+
+        const { Database } = await import('bun:sqlite');
+        const db = new Database(resolvedPath, { readonly: true });
+
+        try {
+            // 1. Query execution loop findings
+            const loopTable = db
+                .query<{ name: string }, [string]>("SELECT name FROM sqlite_master WHERE type = 'table' AND name = ?")
+                .get('history_board_loop_findings');
+
+            let loops: HistoryLoopFinding[] = [];
+            if (loopTable) {
+                const rows = db
+                    .query<
+                        {
+                            tool_name: string;
+                            args_digest: string;
+                            repeats: number;
+                            session_id: string;
+                            first_seq: number;
+                            last_seq: number;
+                            started_at: string | null;
+                        },
+                        [string]
+                    >(
+                        `SELECT tool_name, args_digest, repeats, session_id, first_seq, last_seq, started_at
+                         FROM history_board_loop_findings
+                         WHERE started_at IS NULL OR started_at LIKE ?
+                         ORDER BY repeats DESC
+                         LIMIT 20`,
+                    )
+                    .all(`${date}%`);
+
+                loops = rows.map((r) => ({
+                    toolName: r.tool_name,
+                    argsDigest: r.args_digest || 'repeated execution',
+                    repeats: r.repeats,
+                    sessionId: r.session_id,
+                    fromSeq: r.first_seq,
+                    toSeq: r.last_seq,
+                    wastedTokens: r.repeats * 250,
+                }));
+            }
+
+            // 2. Query tool calls and errors
+            let toolCalls = 0;
+            let toolErrors = 0;
+            const toolTable = db
+                .query<{ name: string }, [string]>("SELECT name FROM sqlite_master WHERE type = 'table' AND name = ?")
+                .get('history_board_tool_5m');
+
+            if (toolTable) {
+                const stats = db
+                    .query<{ calls: number | null; errors: number | null }, [string]>(
+                        `SELECT SUM(calls) AS calls, SUM(errors) AS errors
+                         FROM history_board_tool_5m
+                         WHERE bucket_start LIKE ?`,
+                    )
+                    .get(`${date}%`);
+
+                toolCalls = stats?.calls ?? 0;
+                toolErrors = stats?.errors ?? 0;
+            }
+
+            const redundantCalls = loops.reduce((acc, l) => acc + Math.max(0, l.repeats - 1), 0);
+            const wastedTokens = loops.reduce((acc, l) => acc + l.wastedTokens, 0);
+            const errorRatePct = toolCalls > 0 ? (toolErrors / toolCalls) * 100 : 0;
+
+            // 3. Generate auto-healing remediation proposals
+            const remediationProposals: Array<{ key: string; title: string; command: string }> = [];
+
+            for (const lp of loops.slice(0, 5)) {
+                const cleanTool = lp.toolName.replace(/[^a-zA-Z0-9_-]/g, '_');
+                const key = `repetition:${cleanTool}:${lp.argsDigest.slice(0, 16)}`;
+                const title = `Break execution loop in ${lp.toolName} (${lp.repeats} repeats)`;
+                const body = `Finding: ${key}\\nObserved ${lp.repeats} redundant invocations in session ${lp.sessionId} (steps #${lp.fromSeq ?? 1}→#${lp.toSeq ?? lp.repeats}). Wasted tokens: ~${lp.wastedTokens}.`;
+                const command = `spur task create --section "Fix ${cleanTool} repetition loop" --body "${body}"`;
+                remediationProposals.push({ key, title, command });
+            }
+
+            if (toolCalls > 0 && errorRatePct > 10) {
+                const key = 'reliability:tooling:high-error-rate';
+                const title = `Investigate high tool error rate (${errorRatePct.toFixed(1)}%)`;
+                const body = `Finding: ${key}\\nObserved ${toolErrors} errors across ${toolCalls} tool calls (${errorRatePct.toFixed(1)}% error rate) on ${date}.`;
+                const command = `spur task create --section "Investigate tool error rate spikes" --body "${body}"`;
+                remediationProposals.push({ key, title, command });
+            }
+
+            return {
+                toolCalls,
+                toolErrors,
+                errorRatePct,
+                loops,
+                redundantCalls,
+                wastedTokens,
+                remediationProposals,
+            };
+        } finally {
+            db.close();
+        }
+    } catch {
+        return null;
+    }
+}
+
 // ─── Git Integration ─────────────────────────────────────────────────────────
 
 export async function getGitCommits(date: string): Promise<GitCommit[]> {
@@ -477,6 +619,61 @@ export function generateMarkdown(summary: DailySummary): string {
         lines.push('');
     }
 
+    // Execution Loops & Health Findings
+    if (summary.historyHealth) {
+        const hh = summary.historyHealth;
+        lines.push('## Execution Loops & Health Findings');
+        lines.push('');
+
+        if (hh.loops.length === 0 && hh.toolCalls === 0) {
+            lines.push('- **Status:** ✅ Clean — No execution loops or tool calls recorded for this date.');
+            lines.push('');
+        } else {
+            lines.push('| Metric | Value |');
+            lines.push('|--------|-------|');
+            lines.push(`| Tool Invocations | ${hh.toolCalls.toLocaleString()} |`);
+            lines.push(`| Tool Errors | ${hh.toolErrors.toLocaleString()} (${hh.errorRatePct.toFixed(1)}%) |`);
+            lines.push(`| Detected Loops (Repeats ≥ 3) | ${hh.loops.length} |`);
+            lines.push(`| Redundant Invocations | ${hh.redundantCalls.toLocaleString()} |`);
+            lines.push(`| Estimated Wasted Tokens | ${hh.wastedTokens.toLocaleString()} |`);
+            lines.push('');
+
+            if (hh.loops.length > 0) {
+                lines.push('### Detected Execution Loops');
+                lines.push('');
+                for (const lp of hh.loops.slice(0, 10)) {
+                    const seqInfo = lp.fromSeq && lp.toSeq ? ` (steps #${lp.fromSeq} → #${lp.toSeq})` : '';
+                    const argsHint =
+                        lp.argsDigest === '74234e98afe7498fb5daf1f36ac2d78acc339464f950703b8c019892f982b90b'
+                            ? 'empty/unrecorded arguments'
+                            : lp.argsDigest.length > 28
+                              ? `${lp.argsDigest.slice(0, 24)}...`
+                              : lp.argsDigest;
+                    lines.push(
+                        `- \`${lp.toolName || 'unknown'}\` × **${lp.repeats} repeats** in session \`${lp.sessionId}\`${seqInfo}`,
+                    );
+                    lines.push(`  - *Args hint:* \`${argsHint}\` (~${lp.wastedTokens.toLocaleString()} wasted tokens)`);
+                }
+                lines.push('');
+            }
+
+            if (hh.remediationProposals.length > 0) {
+                lines.push('### Auto-Healing Remediation Proposals');
+                lines.push('');
+                lines.push('To remediate root causes and prevent recurring token waste, execute:');
+                lines.push('');
+                lines.push('```bash');
+                for (const prop of hh.remediationProposals) {
+                    lines.push(`# ${prop.title} [${prop.key}]`);
+                    lines.push(prop.command);
+                    lines.push('');
+                }
+                lines.push('```');
+                lines.push('');
+            }
+        }
+    }
+
     // History report path (R7 — surfaces the newest nightly-run artifact).
     if (summary.historyReportPath) {
         lines.push('## History Report');
@@ -598,6 +795,13 @@ export async function buildDailySummary(options: CliOptions): Promise<DailySumma
         result.gitActivity = gitActivity;
     }
 
+    // Query Spur history health (loops, tool errors, and auto-healing proposals)
+    const historyHealth = await getSpurHistoryHealth(options.date);
+    if (historyHealth && (historyHealth.loops.length > 0 || historyHealth.toolCalls > 0)) {
+        result.historyHealth = historyHealth;
+        platforms.push('Spur History');
+    }
+
     return result;
 }
 

package/plugins/sp/scripts/verify-answer-lint.ts

@@ -245,15 +245,24 @@ function sectionBetween(text: string, heading: string): string {
 function extractRequirementIds(taskContent: string): string[] {
     const section = sectionBetween(taskContent, 'Requirements');
     const ids = new Set<string>();
-    for (const m of section.matchAll(/\*\*(R\d+(?:\.\d+)*)\s*\./g)) ids.add(m[1] ?? '');
-    for (const m of section.matchAll(/\*\*(R\d+(?:\.\d+)*)\*\*/g)) ids.add(m[1] ?? '');
+    // Corpus forms: bold-wrapped (`**R1. Title.**`, bare `**R1**`); right after a list
+    // marker with optional checkbox (`- [ ] R1.` — the dominant corpus form, `- R1. Title.`,
+    // `- R1:`) or a bare checkbox with the marker omitted (`[x] R1.`); line-start (`R1:`).
+    // The marker and the checkbox are never both optional — that would match bare prose
+    // (`R1 is …`) and fabricate declarations. Sub-IDs (`R1.1`) match in every form.
+    for (const m of section.matchAll(/\*\*(R\d+(?:\.\d+)*)\b/g)) ids.add(m[1] ?? '');
+    for (const m of section.matchAll(/^(?:[-*]\s+(?:\[[ xX]\]\s+)?|\[[ xX]\]\s+)(R\d+(?:\.\d+)*)/gm))
+        ids.add(m[1] ?? '');
+    for (const m of section.matchAll(/^(R\d+(?:\.\d+)*)\s*[.:]/gm)) ids.add(m[1] ?? '');
     return [...ids];
 }
 
 function extractAcIdentities(taskContent: string, featureContent: string | null): string[] {
     const identities = new Set<string>();
     const section = sectionBetween(taskContent, 'Acceptance Criteria');
-    for (const m of section.matchAll(/^[-*]\s+\[[ x]\]\s+(.+?)\s*(?::|$)/gm)) {
+    // Checkbox labels (`- [x] AC1 (R1): …`, 0726) and plain bullets (`- AC1: Given …`,
+    // 0713/0727) both yield the label text up to `:` plus its leading token.
+    for (const m of section.matchAll(/^[-*]\s+(?:\[[ xX]\]\s+)?(.+?)\s*(?::|$)/gm)) {
         const label = (m[1] ?? '').trim();
         if (!label) continue;
         identities.add(label);

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

@@ -81,7 +81,7 @@ surfaces is what keeps that gate quiet.
 ## Implement scope: do not run the project quality gate
 
 During implement, the pipeline's `test` hop runs `${vars.qualityGateCmd}` (the full project gate:
-`bun run format && bun run spur-check`) immediately after this step and is the gate that actually
+`bun run spur-check`) immediately after this step and is the gate that actually
 decides pass/fail. Running it inside implement is pure redundancy — it cannot change the outcome and
 only burns wall clock and context budget.
 

package/plugins/sp/skills/spec-decomposition/SKILL.md

@@ -57,7 +57,7 @@ granularity knobs (min/target/force-split hours), and parent/umbrella-task conve
 spur task batch-create --file decomposition.json   # bare JSON array; atomic, all-or-nothing
 ```
 
-Validate locally against `apps/cli/schemas/task-batch.schema.json` (runtime SSOT: the Zod
+Validate locally against `task-batch.schema.json` (runtime SSOT: the Zod
 `taskBatchSchema`) before invoking the CLI — a single violation rejects the entire batch. The gate is
 the only proof the decomposition is well-formed; never hand-write task files to bypass it.
 

package/plugins/sp/skills/spur-cli/references/history.md

@@ -29,9 +29,9 @@ Every JSON-capable verb also advertises `--json-envelope`; use the facade's mach
 ## `import` - isolated fan-out
 
 ```bash
-bun run apps/cli/src/index.ts history import --source all --dry-run --json
-bun run apps/cli/src/index.ts history import --source codex --mode incremental --json
-bun run apps/cli/src/index.ts history import --source codex --file session.jsonl --mode force-file --json
+spur history import --source all --dry-run --json
+spur history import --source codex --mode incremental --json
+spur history import --source codex --file session.jsonl --mode force-file --json
 ```
 
 - `--source all` and a single source use the same per-source fan-out path. A failed/timed-out source
@@ -39,9 +39,10 @@ bun run apps/cli/src/index.ts history import --source codex --file session.jsonl
 - Modes are `incremental`, `full`, and `force-file`. `--file` with the default `all` source is a
   usage error. `--file --mode full` requires `--dry-run`; use `force-file` for a real single-file
   write.
-- JSON contains `entries`, `warnings`, `exitCode`, and CLI/importer `provenance`. For real-data
-  validation, invoke the source-local CLI and record that provenance; never trust a bare global
-  `spur` that may be stale.
+- JSON contains `entries`, `warnings`, `exitCode`, and CLI/importer `provenance`. Record that
+  provenance for any real-data validation. **When developing Spur itself**, invoke the source-local
+  CLI (`bun run apps/cli/src/index.ts history import …`) instead of a global `spur` that may be a
+  stale published bundle; in every other project the installed `spur` is the CLI.
 - Exit `0` when every source is clean/empty, `2` for a mixed failure or any degraded source, and `1`
   when all sources fail. CLI usage guards also exit `1` on this noun.
 

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

@@ -463,8 +463,8 @@ is the procedure. The backing is a combination of git CLI, `spur` CLI, and agent
   6. Run `bun run test`. Collect all failures.
   7. If tests are green, done.
   8. **Test fix loop:** for each failure, diagnose (test bug vs implementation bug), apply the fix, re-run the **failing test only** (`bun test <file> --test-name-pattern "<test>"`). Do NOT re-run the full suite per fix — it is the dominant loop cost (task 0436 R2).
-  9. **Confirming run (at most once).** After all fixes, run `bun run format && bun run lint && bun run test` **at most once** to confirm. If it passes, the hop is done.
-  10. **Pipeline-awareness (R4, task 0483).** When `/sp:dev-fixall` is invoked from the pipeline's `test-fix` hop, `test-recheck` runs the full `${vars.qualityGateCmd}` gate immediately after this hop returns — that is the **deciding** run that writes PASS to `.spur/run/<wbs>-test-gate.status`. Do NOT re-run the full gate beyond the single confirming run in step 9; the deciding run belongs to `test-recheck`. If your confirming run already passed, return immediately — a second or third gate run inside this hop is pure redundancy (0482 ran the gate 3× plus a standalone `bun run test`; all four were followed by `test-recheck` running it a 5th time). If your confirming run failed and you fixed more, re-run the full gate once more within `--max-retry` budget, then return — let `test-recheck` judge.
+  9. **Confirming run — standalone invocation only (at most once).** After all fixes, run `bun run format && bun run lint && bun run test` **at most once** to confirm. If it passes, the hop is done. **Skip this step entirely when `--gate-log` is set** (see step 10) — under the pipeline nothing consumes its verdict.
+  10. **Pipeline-awareness (R4, task 0483; confirming run dropped 2026-08-31).** `--gate-log` is set only by the pipeline's `test-fix` hop, so treat it as the pipeline signal. There, `test-recheck` runs the full `${vars.qualityGateCmd}` gate immediately after this hop returns — that is the **deciding** run, the only one that writes PASS to `.spur/run/<wbs>-test-gate.status`. A confirming run inside this hop decides nothing and costs a second full gate (~105 s here) to answer a question `test-recheck` is about to answer anyway. So under `--gate-log`: **run no full gate at all.** Your self-check is what step 8 already gives you — the failing tests you re-ran individually — plus **one `bun run lint`** (~7 s: Biome + typecheck) to catch type or lint breakage your fixes introduced. Then return and let `test-recheck` judge. `test-recheck` opens with the same cheap `${vars.gateProbeCmd}` probe, so a still-red tree is caught in seconds rather than by a full suite. Historical anti-pattern this replaces: 0482 ran the gate 3× plus a standalone `bun run test`, and `test-recheck` then ran it a 5th time.
   11. Report: list what was fixed (file + one-line summary per fix). If any error could not be resolved, report it explicitly — do not suppress.
 - **Invariants:** Never bypass with `--no-verify`, `--force`, or new `biome-ignore`/`eslint-disable` suppressions. Never skip or `.skip` a test to make the suite green. Fix the root cause, not the symptom. Never claim green on `bun run lint` alone — a formatter-only diff passes `lint` but fails the formatter; run `bun run format` (or assert it produces no diff) before declaring the gate clean. **Never re-run the full gate more than once per confirming pass** (R4) — use targeted probes during the fix loops and let the pipeline's `test-recheck` state be the deciding run.
 - **MANDATORY Exit Condition.** The ONLY way to complete successfully:

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

@@ -46,7 +46,7 @@ one thing and yields, so the **pipeline (not the agent) owns the loop**.
 | Stage | Operation | Defined in |
 | ------- | ----------- | ------------ |
 | `implement` | `/sp:dev-run --mode implement <wbs>` — write the code that satisfies the task; author `## Solution`. | [dev-operations.md §4 run](dev-operations.md) → `sp:code-implementation` |
-| `test` → (`test-fix` ↔ `test-recheck`) → `review` \| `failed` | **Project quality gate** (not `/sp:dev-unit`). Soft shell probe of `${vars.qualityGateCmd}` (default `bun run autofix && bun run spur-check`) — green path pays **one** full gate run. On FAIL: bounded `/sp:dev-fixall` loop (`qualityGateMaxFixAttempts`, default 2) with soft recheck; exhausted attempts route to pipeline `failed`. `/sp:dev-unit` remains **coverage gap-fill** (router C3/C5 / standalone). | [dev-operations.md §10 fixall](dev-operations.md); unit op still §1 |
+| `test` → (`test-fix` ↔ `test-recheck`) → `review` \| `failed` | **Project quality gate** (not `/sp:dev-unit`). Soft shell probe of `${vars.qualityGateCmd}` (default `bun run spur-check`) — green path pays **one** full gate run. On FAIL: bounded `/sp:dev-fixall` loop (`qualityGateMaxFixAttempts`, default 2) with soft recheck; exhausted attempts route to pipeline `failed`. `/sp:dev-unit` remains **coverage gap-fill** (router C3/C5 / standalone). | [dev-operations.md §10 fixall](dev-operations.md); unit op still §1 |
 | `review` | `/sp:dev-review <wbs>` — SECUA-framework review of the diff. | [dev-operations.md §2 review](dev-operations.md) |
 | `verify` | `sp:code-verification` — requirements traceability + verdict. | [dev-operations.md §3 verify](dev-operations.md) |
 
@@ -97,6 +97,7 @@ cache-conservation discipline (`plugins/sp/skills/dogfood-testing/references/mon
 ## Step 2: Pipeline run
 
 > **Pre-launch size-gate pre-check (R1 / 0478).** Before launching `spur workflow run task-pipeline.yaml`, probe the task's `## Plan` checklist item count (`spur task show <wbs> --json`). The default cap is 8 items (`maxImplementPlanItems: 8`). If the plan item count exceeds 8:
+>
 > - Without `--auto`: warn the operator before calling `spur workflow run` and prompt for confirmation or a plan-item override via `--vars '{"maxImplementPlanItems":"<count>"}'`.
 > - With `--auto`: automatically append `"maxImplementPlanItems": "<count>"` to `--vars` and log a single-line notice (e.g. `Notice: task <wbs> has N plan items (>8 default cap); injecting maxImplementPlanItems override`).
 
@@ -313,6 +314,12 @@ the partial work still in the working tree. The failure output names the partial
    [`done-housekeeping.md`](done-housekeeping.md) F6 — it carries the provenance obligations
    (honest `done_reason`, verdict regeneration).
 
+   **Inline path (task 0727).** There is no `<runId>-implement-partial.md` artifact on the inline
+   driver path — it is written only by the subprocess `agent.run` action. The inline equivalent is
+   the dispatch-timeout contract in [`inline-pipeline-driver.md`](inline-pipeline-driver.md):
+   resume from the partial tree, never restart the stage inline; the partial working tree is the
+   recovery input.
+
 **3. Match the executor to the size (task 0487 R3).** Size and executor capability are one
 decision, not two. **≥ 6 requirements or ≥ 9 Plan items → a `reviewer`-role executor (the
 `reviewer` row of [`roles.md`](../../../references/roles.md) declares the floor), or split the

package/plugins/sp/skills/spur-dev/references/gate-checklists.md

@@ -52,7 +52,7 @@ Entered before `spur task batch-create --file <json>` (idea-pipeline `batch-crea
 decomposition gate `/sp:dev-plan` also routes through since D5-K).
 
 - [ ] The batch JSON is a bare array (not an object with a `tasks` key).
-- [ ] Each entry validates locally against `apps/cli/schemas/task-batch.schema.json` (`additionalProperties: false` — no unknown keys).
+- [ ] Each entry validates locally against `task-batch.schema.json` (`additionalProperties: false` — no unknown keys).
 - [ ] Each entry has a non-empty `name` (required).
 - [ ] `feature_id` matches an existing feature (or is intentionally deferred with operator awareness).
 - [ ] `parent_wbs` is set when the task is a child of a decomposition parent.

package/plugins/sp/skills/spur-dev/references/inline-pipeline-driver.md

@@ -41,6 +41,12 @@ command, skill, script, or second workflow.
      the YAML parsed in step 1, shown only for the active state.
    - **Refresh cadence** = stage boundaries only (when the current state changes after a transition),
      never per action.
+   - **Transition reconciliation (task 0727)** = at every stage boundary the host must
+     **mark the finished stage completed and the next stage in_progress** in the host todo list.
+     This reconciliation is **host-owned and execution-surface-independent**: it fires identically
+     whether the stage ran via native subagent, host-inline execution, or the post-dispatch host
+     fallback, so a run can never terminate with earlier stages stuck `in_progress` (task 0726
+     ended 0/11 with precheck and implement still open).
    - **Source of truth** = the CLI projection for layer 1; the YAML parsed in step 1 for layer 2.
      Never hand-copy or hand-derive the state list into the driver, a command, a skill, or a script.
 5. For task execution only, record lifecycle provenance before entering the FSM:
@@ -119,6 +125,19 @@ before the subagent starts, log the reason and use host fallback. If a started s
 leaves invalid artifacts, do **not** replay the stage in the host — follow the YAML error policy so
 partial mutations are not duplicated.
 
+**Timeout boundary (task 0727):** a dispatched subagent is governed by
+**the host platform's subagent limit, not the YAML timeoutMs** — `timeoutMs` stays not-applicable
+for host execution only — and before dispatch the driver must
+**record the governing timeout boundary and its source before dispatch** in the run log
+(e.g. `host timeout <ms> (<platform subagent limit|yaml timeoutMs>)`). If the dispatch reaches that
+boundary, **a dispatch timeout is a started-subagent failure**: the no-replay rule above and the
+stage's declared YAML error policy govern (implement's default `fail` policy routes the run to
+`failed`); it is never a host re-execution. Recovery follows the
+[timed-out implement runbook](execution-workflow.md)'s inline-path equivalent:
+**resume from the partial tree, never restart the stage inline** — no
+`<runId>-implement-partial.md` artifact is written on this path, so the partial working tree
+itself is the recovery input.
+
 **Host-owned interaction:** the host alone executes operator-confirmation actions, owns
 `pause: true`, and surfaces approve/taste/ask decisions. A subagent that discovers missing authority
 or an operator decision returns a blocker; the host pauses at the current state and presents it. The
@@ -129,6 +148,12 @@ subagent form above) to `.spur/run/<run-id>.log`, where `<id>` is the current YA
 log start/failure and the ignored timeout value so an inline run remains auditable without
 fabricating an `AgentRunTracedResult`.
 
+Run-log stamps (task 0727): every appended line is prefixed with an **ISO-8601 UTC** timestamp
+(`YYYY-MM-DDTHH:MM:SSZ`, e.g. `2026-08-31T17:51:11Z`); the exact-template provenance lines above
+keep their exact content after the stamp prefix. This normalization is contractual:
+**bare local-clock stamps are prohibited** — a hand-appended `[stage 12:31]` form mixes timezones
+in one file and makes the run unauditable (task 0726 mixed both forms).
+
 Transition guards are not advisory. Execute the declared guard exactly, in order, with the same
 resolved variables and artifacts. `--no-lifecycle` remains bookkeeping only; the YAML's task checks,
 verdict gate, record step, and done guard all remain authoritative.

package/schemas/spur-config.schema.json

@@ -92,6 +92,41 @@
                         "enabled": {
                             "type": "boolean",
                             "description": "Enable the scheduled-task runner. OFF by default for CLI (run-once)."
+                        },
+                        "jobs": {
+                            "type": "array",
+                            "description": "Declarative scheduled commands (task 0734). Each entry registers one scheduler tick that enqueues a `scheduler.custom` queue job running `command` through `/bin/sh -c`. Normalized and validated by @gobing-ai/ts-infra runNodeApplication before the server starts.",
+                            "items": {
+                                "type": "object",
+                                "required": ["name", "command"],
+                                "properties": {
+                                    "name": {
+                                        "type": "string",
+                                        "minLength": 1,
+                                        "description": "Job name, unique across the list after trimming. Reported as the `scheduler.custom:<name>` display name on scheduler.job.executed."
+                                    },
+                                    "command": {
+                                        "type": "string",
+                                        "minLength": 1,
+                                        "description": "Shell command run by `/bin/sh -c` with the project root as cwd. Trusted operator input \u2014 never logged."
+                                    },
+                                    "intervalMinutes": {
+                                        "type": "integer",
+                                        "minimum": 1,
+                                        "maximum": 35791,
+                                        "description": "Fixed interval in minutes. Mutually exclusive with `cron`. The upper bound is the Node timer ceiling (2147483647 ms)."
+                                    },
+                                    "cron": {
+                                        "type": "string",
+                                        "minLength": 1,
+                                        "description": "Five-field cron expression (minute hour day-of-month month day-of-week) evaluated in local time. Mutually exclusive with `intervalMinutes`."
+                                    }
+                                },
+                                "oneOf": [
+                                    { "required": ["intervalMinutes"], "not": { "required": ["cron"] } },
+                                    { "required": ["cron"], "not": { "required": ["intervalMinutes"] } }
+                                ]
+                            }
                         }
                     }
                 }