@gobing-ai/spur 0.4.16 → 0.4.17

package/.claude-plugin/marketplace.json

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

package/package.json

@@ -1,6 +1,6 @@
 {
     "name": "@gobing-ai/spur",
-    "version": "0.4.16",
+    "version": "0.4.17",
     "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",

package/plugins/sp/README.md

@@ -319,7 +319,7 @@ surface or run one workflow. All skills target the same five core platforms: `cl
 
 | Skill                       | Ver   | Domain                                                                                                                                                                                                                                     |
 | --------------------------- | ----- | ------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------ |
-| `spur-dev`                  | 1.1   | Thin orchestration spine — drives planning→execution, gates, HITL, and dispatches competencies; never inlines implementation/testing/decomposition/review                                                                                  |
+| `spur-dev`                  | 1.2   | Thin orchestration spine — drives planning→execution, gates, HITL, and dispatches competencies; never inlines implementation/testing/decomposition/review                                                                                  |
 | `spur-cli`                  | 1.0   | CLI facade — one reference per `spur` noun (`task`, `feature`, `rule`, `workflow`), each with verb tables, flag guides, `--json` shapes, and write-contract rules                                                                          |
 | `sys-architecture`          | 1.0   | Architecture / ADR judgment — module boundaries, data flow, transport/storage/auth choices, build-vs-extend decisions                                                                                                                      |
 | `spec-decomposition`        | 1.0   | Feature/spec → validated task-batch decomposition — scenario-to-task mapping, variant selection, granularity sizing, batch-JSON production                                                                                                 |
@@ -348,10 +348,10 @@ surface or run one workflow. All skills target the same five core platforms: `cl
 | `conflict-finding`          | 1.0   | Authority-aware semantic audit — four-pillar (source/task/feature/authority) conflict discovery, claim-specific authority resolution, reproducible evidence, confirmed owner-routed remediation; backs `/sp:dev-find-conflict`             |
 | `fleet-join`                | 1.0   | Guest fleet occupancy — join as a live guest occupant, loop `spur agent wait --inbox` to pull work, reply through `spur message reply`, then leave; G73 (task 1081)                                                                          |
 | `next-feature`              | 1.0   | Prompt-first feature frontier prioritizer — sync-first precondition, B3 actionability gate (cited, never restated), tiered rubric over measured signals, D1–D4 defect proposals conforming to the restructure map schema; backs `/sp:dev-find-next` |
-| `pr-reviewing`              | 1.0   | GitHub Codex PR review — PR prepare/reuse, `@codex review` request with per-HEAD dedupe, bounded polling, findings normalization, validated fix + re-review; direct `spur builder pr-status`/`pr-check`/`pr-open`/`pr-review` sequence; backs `/sp:dev-pr-review`     |
+| `pr-reviewing`              | 2.0.0 | GitHub Codex PR review — PR prepare/reuse, `@codex review` request with per-HEAD dedupe, bounded polling, findings normalization, validated fix + re-review; direct `spur builder pr-status`/`pr-check`/`pr-open`/`pr-review` sequence; backs `/sp:dev-pr-review`     |
 | `indexed-context`           | 1.0   | Cross-agent project context — anatomy/learnings/pitfalls/buglog/memory in `.spur/context/`; hook-tracked token-ledger; graceful degradation on agents without hooks                                                                        |
 | `history-anatomy`           | 1.0   | Diagnostic interpretation owner over already-imported history — daily/ad-hoc mode contract, closed finding taxonomy, twelve-section report contract, `enrich`/`validate` rubrics; no workflow launch, no JSONL fallback, no corpus mutation                                                                   |
-| `session-review`            | 1.1   | Inline review of the active coding-agent session — compact outcomes, evidence-backed resolved/open issue classification, proposal-only improvements, and next actions; no workflow, import, delegation, or mutation                                                                                           |
+| `session-review`            | 1.3.0 | Inline review of the active coding-agent session — compact outcomes, evidence-backed resolved/open issue classification, proposal-only improvements, and next actions; no workflow, import, delegation, or mutation                                                                                           |
 | `spur-composer`             | 1.0   | Cross-noun composition — workflow catalog selection, the ephemeral→project→shared ladder, ADR-115 budgets, trace-driven rule tuning; applies accepted `spur-doctor` proposals through `spur` verbs; never judges its own output and never runs a recurring loop                                              |
 | `spur-doctor`               | 1.0   | Cross-noun evaluation — read-only CLI evidence per noun (task/feature/rule/workflow/agent spec), reflection over `history-anatomy` findings through a closed action-class map, and a proposal table; writes nothing; diagnoses artifacts, not runtime environments (`spur agent doctor`'s job)                |
 | `spur-check`                | 1.0   | Two-tier check primitive (ADR-124) — light changed-scope checks during development, the full `spur self exec check` chain at the quality boundary, and the fingerprint-bound `<wbs>-check-receipt.json` with the `status` reuse rule; composes with `/sp:dev-fixall --gate-log`                                  |

package/plugins/sp/commands/dev-find-conflict.md

@@ -1,7 +1,7 @@
 ---
 description: "Authority-aware semantic audit across source, task files, feature files, and project authority files — discover conflicts, resolve claim-specific authority, collect reproducible evidence, and route confirmed repairs through owner surfaces. Triggers: find conflict, conflict audit, semantic conflict, authority mismatch, stale projection."
 role: reviewer
-argument-hint: "[<scope>] [--pillar <source|tasks|features|authority|all>] [--mode <adaptive|full>] [--resolve] [--agent <inline|auto|name>] [--json]"
+argument-hint: "[--tasks <selector> | --feature <id>[,<id>] | --scope <path>[,<path>]] [--pillar <source|tasks|features|authority|all>] [--mode <adaptive|full>] [--resolve] [--auto] [--agent <inline|auto|name>] [--json]"
 allowed-tools: ["Bash", "Read", "Write", "Grep", "Glob", "Skill"]
 ---
 
@@ -15,10 +15,14 @@ owner-routed remediation.
 
 | Flag                                                   | Description                                                                                                                              | Default         |
 | ------------------------------------------------------ | ---------------------------------------------------------------------------------------------------------------------------------------- | --------------- |
-| `<scope>`                                              | Optional path, WBS, feature ID, symbol, command, config key, or free-form subject to scope the audit.                                    | current project |
+| `--tasks <selector>`                                   | Audit a task set — batch selector grammar ([execution-batch.md § Step 1](../skills/spur-dev/references/execution-batch.md#step-1--selector-resolution-r1)): comma WBS list or `feature:<id>`. Resolved once and frozen; the tasks seed one audit (below).                        | —               |
+| `--feature <id>[,<id>]`                                | Sugar for the union of the `feature:<id>` sets plus the feature records themselves — resolved once, frozen, audited as one seed set.                                                                                                                                  | —               |
+| `--scope <path>[,<path>]`                              | Audit the tracked files under one or more paths: paths must exist (exit 2 otherwise), are normalized, duplicates dropped and nested paths collapse to the ancestor (`--scope apps,apps/cli` → `apps`).                                                                 | —               |
+| `[<wbs\|path>]`                                        | **Deprecated positional alias** (one release): a `^\d{4}$` token with a resolvable task → `--tasks <wbs>`; an existing path → `--scope <path>`; otherwise exit 2. Prints a deprecation warning naming the replacement.                                                 | —               |
 | `--pillar` `<source\|tasks\|features\|authority\|all>` | Limit the internal audit to one pillar; the minimum authorities needed to judge it still load.                                           | all             |
 | `--mode` `<adaptive\|full>`                            | Scan protocol — adaptive reuses fresh indexed context and discloses skipped areas; full forces a cold comprehensive scan.                | adaptive        |
 | `--resolve`                                            | Enable the proposal, confirmation, and owner-routed remediation workflow. Its absence guarantees no source/corpus/numbered-doc mutation. | off             |
+| `--auto`                                               | Under `--resolve`, pre-approve the eligible repair set instead of pausing at the confirmation gate (see the skill's Step 10). Authority decisions still pause. Requires `--resolve` (exit 2 otherwise).                                                            | off             |
 | `--agent` `<inline\|auto\|name>`                       | Who runs the model-bearing analysis.                                                                                                     | omit           |
 | `--json`                                               | Emit the same result envelope as Markdown as JSON.                                                                                       | off             |
 
@@ -28,13 +32,21 @@ For shared semantics, see the [flag glossary](../skills/spur-dev/references/flag
 
 ```
 /sp:dev-find-conflict
-/sp:dev-find-conflict docs/00_ADR.md
+/sp:dev-find-conflict --scope docs/00_ADR.md
 /sp:dev-find-conflict --pillar authority
-/sp:dev-find-conflict --pillar tasks --mode full
-/sp:dev-find-conflict 0486 --resolve
-/sp:dev-find-conflict "command surface" --json
+/sp:dev-find-conflict --tasks 0486,0487 --pillar tasks --mode full
+/sp:dev-find-conflict --feature H11,H12 --resolve
+/sp:dev-find-conflict --scope apps/cli,docs/design --resolve --auto --json
 ```
 
+Target selection: **at most one** of `--tasks`, `--feature`, `--scope` per invocation — more than
+one (a positional beside an explicit selector counts as a second kind) → exit 2 naming the
+conflicting selectors. None → the whole project (the audit's natural default, unlike `dev-review`).
+The target set is resolved once and frozen through the shared batch resolver — no find-conflict
+parser; status pseudo-lists and `ready` are rejected (they select work to do, not artifacts to
+audit). The frozen objects seed **one** audit, not one audit per object, so conflicts *between*
+selected objects (two tasks, a task and a feature) stay visible.
+
 Audit mode is read-only with respect to source, corpus, and numbered documentation. Findings are
 presented before any repair. Approved repairs route through the artifact owner's existing harness
 surface (`spur task` / `spur feature`, `sp:doc-evolve`, the Spur development lifecycle, or

package/plugins/sp/plugin.json

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

package/plugins/sp/skills/conflict-finding/SKILL.md

@@ -57,24 +57,29 @@ dependency, or dedicated subagent.
 - Code review — use `sp:code-review` / `sp:code-verification`.
 - General documentation drift maintenance — use `sp:doc-evolve`.
 - Performing repairs automatically — this skill only audits and (with `--resolve`) proposes
-  confirmed, owner-routed repairs; it never mutates without explicit confirmation.
+  confirmed, owner-routed repairs; it never mutates without explicit confirmation (interactive, or
+  the operator's explicit `--auto` pre-approval of eligible items).
 
 ## Arguments
 
 | Argument                                             | Description                                                                                                                                          | Default         |
 | ---------------------------------------------------- | ---------------------------------------------------------------------------------------------------------------------------------------------------- | --------------- |
-| `[scope]`                                            | Optional path, WBS, feature ID, symbol, command, config key, or free-form subject to scope the audit.                                                | current project |
+| `--tasks <selector>`                                 | Task set (comma WBS list or `feature:<id>`, batch selector grammar) seeding the audit.                                                                | —               |
+| `--feature <id>[,<id>]`                              | Union of the `feature:<id>` task sets plus the feature records themselves, seeding the audit.                                                        | —               |
+| `--scope <path>[,<path>]`                            | Tracked files under one or more existing paths, seeding the audit.                                                                                   | —               |
+| `[<wbs\|path>]`                                      | Deprecated positional alias for `--tasks <wbs>` / `--scope <path>` (one release).                                                                    | —               |
 | `--pillar <source\|tasks\|features\|authority\|all>` | Limit the internal audit to one pillar; the minimum authorities needed to judge it still load.                                                       | `all`           |
 | `--mode <adaptive\|full>`                            | Scan protocol — `adaptive` reuses fresh, provenance-verifiable indexed context and discloses skipped areas; `full` forces a cold comprehensive scan. | `adaptive`      |
 | `--resolve`                                          | Enable the proposal, confirmation, and owner-routed remediation workflow. Its absence guarantees no source/corpus/numbered-doc mutation.             | off             |
+| `--auto`                                             | Under `--resolve`, pre-approve the eligible repair set at the confirmation gate (Step 10). Requires `--resolve`.                                    | off             |
 | `--agent <inline\|auto\|name>`                       | Who runs the model-bearing analysis. `inline` is the default; `--agent auto`/a named executor isolates the analysis. Not a dedicated subagent.       | `inline`        |
 | `--json`                                             | Emit the same result envelope as Markdown as JSON. Never implies deterministic semantic reasoning.                                                   | off             |
 
 ## The 10-Step Audit Protocol
 
 ```
-scope + flags
-  → PARSE & GUARD     resolve scope/flags; confirm repository root; set audit-only vs resolve mode
+target + flags
+  → PARSE & GUARD     resolve + freeze the target set; confirm repository root; set audit-only vs resolve mode
   → DISCOVER AUTHORITY  read entry/process rules; build the claim-specific authority matrix
   → PREFLIGHT         git, rg, spur task/feature --json, relevant spur … check, doc-evolve audit
   → INVENTORY         four-pillar inventory: pillar, identity, path, anchor, freshness, scan status
@@ -84,13 +89,35 @@ scope + flags
   → CROSS-PILLAR      all six applicable boundaries
   → CLASSIFY          lifecycle, supersession, abstraction-level, intentional-deprecation challenges
   → REPORT            order by severity then confidence; coverage, unresolved authority, scan cost
-  → REMEDIATE         only with --resolve and explicit confirmation + freshness recheck
+  → REMEDIATE         only with --resolve and explicit (or --auto pre-) confirmation + freshness recheck
 ```
 
 ### Step 1 — Parse and guard
 
-Resolve `<scope>` and `--pillar`; confirm the repository root; establish **audit-only** versus
-`--resolve` mode. Without `--resolve`, the run is strictly read-only: no source, corpus, or
+Resolve the target and `--pillar`; confirm the repository root; establish **audit-only** versus
+`--resolve` mode.
+
+**Target selection.** At most one of `--tasks`, `--feature`, `--scope` (a deprecated positional
+beside an explicit selector counts as a second kind) — more than one refuses the audit naming the
+conflicting selectors. None → the whole project. Resolve the set **once** and freeze it:
+
+- `--tasks` / `--feature` go through the shared batch resolver
+  ([execution-batch.md § Step 1](../spur-dev/references/execution-batch.md#step-1--selector-resolution-r1));
+  `--feature <id>[,<id>]` is sugar for the union of the `feature:<id>` sets, and the feature records
+  join the seed set. Status pseudo-lists and `ready` are refused. An unresolvable WBS/feature refuses
+  the audit.
+- `--scope` paths must exist; normalize them, drop duplicates, collapse nested paths to the ancestor.
+- Deprecated positional: a `^\d{4}$` token with a resolvable task → `--tasks <wbs>`; an existing path
+  → `--scope <path>`; anything else refuses. Emit a deprecation warning naming the replacement.
+
+The frozen objects **seed one audit** — they are the starting nodes of the candidate graph (Step 5),
+not the boundary of what may be read: the authorities and counterpart artifacts needed to judge them
+still load. One audit, not one per object, so conflicts *between* selected objects stay visible.
+Every finding names the seed object(s) it traces to; `coverage` accounts per seed object.
+
+`--auto` without `--resolve` refuses the audit (it has no gate to skip in audit mode).
+
+Without `--resolve`, the run is strictly read-only: no source, corpus, or
 numbered-document mutation of any kind. With `--resolve`, no write happens until a repair set is
 presented, explicitly confirmed, and freshness-revalidated.
 
@@ -98,7 +125,7 @@ Validate every enum flag against the domain declared by the command surface
 (`plugins/sp/commands/dev-find-conflict.md`): `--pillar` ∈ `source|tasks|features|authority|all`,
 `--mode` ∈ `adaptive|full`, `--agent` ∈ `inline|auto|name`. An out-of-domain value **refuses** the
 audit before any discovery work — report the received value, the flag's valid domain, and stop;
-never silently coerce or ignore it. Only `<scope>` is free-form and exempt from this check.
+never silently coerce or ignore it.
 
 ### Step 2 — Discover local authority
 
@@ -157,8 +184,9 @@ findings, evidence, authority provenance, coverage, unresolved decisions, and re
 
 ### Step 10 — Remediate only when requested
 
-With `--resolve`: present the proposed repair set, obtain explicit confirmation, revalidate evidence
-freshness, then route each approved repair through its verified owner surface. Report the completed,
+With `--resolve`: present the proposed repair set, obtain explicit confirmation (or, under
+`--auto`, the pre-approval of the eligible subset — [remediation-routing.md §2.2a](references/remediation-routing.md#22a---auto-pre-approval)),
+revalidate evidence freshness, then route each approved repair through its verified owner surface. Report the completed,
 failed, and untouched sets; never silently roll forward past a partial failure. See
 [references/remediation-routing.md](references/remediation-routing.md).
 
@@ -173,7 +201,7 @@ items; no mutation.
 {
   "schema_version": 1,
   "command": "dev-find-conflict",
-  "scope": "docs/00_ADR.md",
+  "scope": "scope:docs/00_ADR.md",
   "mode": "adaptive",
   "pillars": ["authority"],
   "authority_map": {},
@@ -226,10 +254,10 @@ Thin wrapper: `Skill(skill="sp:conflict-finding", args="$ARGUMENTS")`.
 
 ```
 /sp:dev-find-conflict
-/sp:dev-find-conflict docs/00_ADR.md
-/sp:dev-find-conflict --pillar tasks --mode full
-/sp:dev-find-conflict 0486 --resolve
-/sp:dev-find-conflict "command surface" --json
+/sp:dev-find-conflict --scope docs/00_ADR.md
+/sp:dev-find-conflict --tasks 0486,0487 --pillar tasks --mode full
+/sp:dev-find-conflict --feature H11 --resolve
+/sp:dev-find-conflict --scope apps/cli --resolve --auto --json
 ```
 
 ## Common rationalizations
@@ -240,6 +268,7 @@ Thin wrapper: `Skill(skill="sp:conflict-finding", args="$ARGUMENTS")`.
 | "Lower-numbered docs always win."          | Authority is claim-specific; the constitution's precedence applies only within its stated boundary.                                                             |
 | "Code is always right."                    | Code is authoritative for what currently happens, not automatically for what should happen.                                                                     |
 | "`--resolve` authorizes automatic repair." | It opens the proposal/confirmation workflow; every repair still needs explicit confirmation and a freshness check, then the owner surface.                      |
+| "`--auto` approves everything."            | It pre-approves only eligible items (resolved authority, `high` confidence, verified owner surface); authority decisions still pause; freshness still applies. |
 | "Adaptive can reuse any context."          | Reuse requires freshness + verifiable provenance; absent/stale/unverifiable context degrades to a cold scan or an explicit incomplete-coverage result.          |
 
 ## Red flags
@@ -248,7 +277,8 @@ Thin wrapper: `Skill(skill="sp:conflict-finding", args="$ARGUMENTS")`.
 - Forcing an ambiguous/missing authority through a global ranking instead of an unresolved HITL item.
 - Silently omitting a selected pillar or a tool failure (no coverage accounting).
 - Claiming "comprehensive" when `coverage.complete` is false.
-- Any mutation in audit mode, or automatic mutation merely because `--resolve` is present.
+- Any mutation in audit mode, or automatic mutation merely because `--resolve` is present (without `--auto`).
+- Under `--auto`, applying an ineligible item or settling a `needs-authority-decision` item.
 - Editing a derived projection before correcting a defective authority, or changing a correct authority merely to repair its stale projection.
 - Adding a production analyzer, index/cache/database, dependency, or dedicated subagent in v1.
 

package/plugins/sp/skills/conflict-finding/references/comparison-protocol.md

@@ -76,8 +76,10 @@ Join keys, in priority order:
 
 Construction protocol:
 
-1. **Seed from scope.** If `<scope>` is a path/WBS/feature-id/symbol/command/config-key, seed the
-   graph with every artifact whose identity or content references that scope.
+1. **Seed from the frozen target.** Every object in the `--tasks` / `--feature` / `--scope` set is
+   a seed, plus every artifact whose identity or content references one of them (its WBS, feature
+   ID, or path). Multiple seeds share one graph, so edges between seeds are compared too. No
+   selector → the whole project is the seed set.
 2. **Grow by shared keys.** For each seed, add an edge to any artifact sharing one of the keys
    above for the _same subject_. A key matches only when it refers to the same subject, not merely
    the same string in an unrelated context (see normalize).

package/plugins/sp/skills/conflict-finding/references/finding-contract.md

@@ -218,7 +218,7 @@ inventory, findings, unresolved, coverage, cost, remediation, errors
 {
   "schema_version": 1,
   "command": "dev-find-conflict",
-  "scope": "docs/00_ADR.md",
+  "scope": "scope:docs/00_ADR.md",
   "mode": "adaptive",
   "pillars": ["authority"],
   "authority_map": {},
@@ -236,7 +236,7 @@ inventory, findings, unresolved, coverage, cost, remediation, errors
 | ---------------- | --------------------------------------------------------------------------------------------------------------------------------------------------------------------------- |
 | `schema_version` | integer, `1`. The envelope contract version — not a semantic-reasoning version.                                                                                             |
 | `command`        | string, `dev-find-conflict`.                                                                                                                                                |
-| `scope`          | string. The resolved audit scope (path, WBS, feature ID, symbol, command, or `"<project>"`).                                                                                |
+| `scope`          | string. The frozen target as `<kind>:<id>[,<id>]` — `tasks:0486,0487`, `feature:H11,H12`, `scope:apps,docs` — or `"<project>"` when no selector was given.               |
 | `mode`           | string, `adaptive` \| `full`.                                                                                                                                               |
 | `pillars`        | string[]. The pillars actually audited (subset of `source`, `tasks`, `features`, `authority`).                                                                              |
 | `authority_map`  | object. Claim-type → authoritative artifact/rule, with each precedence edge citing its project rule or fallback (see [./authority-resolution.md](authority-resolution.md)). |

package/plugins/sp/skills/conflict-finding/references/remediation-routing.md

@@ -13,7 +13,8 @@ opt-in, gated workflow. This file is the SSOT for *when a write is allowed*, *wh
 
 The governing rule, carried through everything below: **no mutation in audit mode, and no automatic
 mutation merely because `--resolve` is present.** Every write requires (a) a presented repair set,
-(b) explicit operator confirmation, (c) a freshness revalidation of the supporting evidence, and
+(b) explicit operator confirmation (interactive, or the explicit `--auto` pre-approval of eligible
+items — §2.2a), (c) a freshness revalidation of the supporting evidence, and
 (d) dispatch through the artifact owner's verified harness surface. Ambiguity or partial failure is
 reported, never silently continued.
 
@@ -23,7 +24,7 @@ reported, never silently continued.
 |-----------|-----------|
 | Audit mode is read-only | Without `--resolve`, no source, corpus (task/feature), or numbered-document mutation of any kind. |
 | `--resolve` is not a write | It only *opens* the proposal → confirmation → owner-routed workflow. It never authorizes automatic repair. |
-| Confirmation precedes every write | No repair executes until the operator explicitly approves the specific proposed repair set. |
+| Confirmation precedes every write | No repair executes until the operator explicitly approves the specific proposed repair set — interactively, or by `--auto` pre-approval of its eligible subset (§2.2a). |
 | Freshness precedes mutation | The supporting evidence anchors are re-read and compared against the finding's fingerprint before any write. |
 | Owner surface, not raw edits | Each approved repair routes through the artifact's owner (Spur CLI, `sp:doc-evolve`, Spur dev lifecycle, Superskill lifecycle) — never a direct file write where an owner surface exists. |
 | Idempotent and partial-failure aware | Already-matching artifacts resolve without a write; one repair's failure neither marks others successful nor silently rolls forward. |
@@ -93,6 +94,23 @@ is:
 A declined or deferred repair is left **untouched** and reported as such; it is not re-attempted
 implicitly in the same run.
 
+### 2.2a `--auto` pre-approval
+
+`--auto` (only valid with `--resolve`) is the operator's explicit, up-front confirmation of the
+**eligible** subset of the repair set — it replaces the interactive pause for that subset only. The
+repair set is still presented (§2.1) before anything is applied. An item is eligible only when all
+hold:
+
+- `status` is `open` — never `needs-authority-decision` (authority is resolved, not ambiguous/missing);
+- `confidence` is `high`;
+- `repair_owner` resolves to a verified owner surface in §3 (no manual/unknown owner).
+
+Ineligible items are the HITL that remains: authority decisions and medium/low-confidence repairs
+**still pause** for the operator, exactly as without `--auto`. In a non-interactive run (no operator
+to answer), they are recorded `deferred` and left untouched. The remediation report marks each
+approved item `approved_by: auto` or `approved_by: operator`, so the audit trail distinguishes the two.
+`--auto` never skips freshness revalidation (§2.3), owner routing (§3), or partial-failure handling (§5).
+
 ### 2.3 Revalidate evidence freshness
 
 Between the audit and any write, the world may have changed. Immediately before dispatching each
@@ -245,6 +263,7 @@ These are the explicit boundaries for remediation. Each is a hard violation, not
 | Anti-pattern | Why it is prohibited |
 |--------------|----------------------|
 | **Automatic mutation merely because `--resolve` is present** | `--resolve` only opens the workflow; it never authorizes automatic repair. Confirmation + freshness + owner surface are all required. |
+| **`--auto` beyond its eligible subset** | `--auto` pre-approves only §2.2a-eligible items; applying an authority decision or a medium/low-confidence repair under it is a violation. |
 | **Changing correct authority for projection drift** | A stale projection is repaired against its governing contract. Correct authority only when defective and authorized; then update affected projections. |
 | **Broad cleanup outside confirmed findings** | Only the artifacts named by confirmed, freshness-checked findings are touched. No opportunistic refactors or doc "improvements" while repairing. |
 | **Ambiguity silently resolved** | Ambiguous/missing authority stops for an operator decision; it is never forced through a global ranking or a guessed owner. |
@@ -260,7 +279,7 @@ Before dispatching any write, confirm each of the following:
 
 - [ ] Audit mode performed **no** governed mutation; the report is a pure envelope.
 - [ ] `--resolve` was present, and the **repair set was presented** (keyed by finding ID + fingerprint).
-- [ ] The operator **explicitly confirmed** the specific selected repair set.
+- [ ] The operator **explicitly confirmed** the specific selected repair set, or `--auto` pre-approved only §2.2a-eligible items.
 - [ ] Evidence **freshness revalidated** per finding at dispatch; `stale-evidence` items returned to audit.
 - [ ] Each approved repair routed through its **owner surface** (§3), never a raw write where an owner exists.
 - [ ] **Idempotent** already-matching items marked `resolved` without a write.

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

@@ -5,6 +5,8 @@ description: >-
   "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`.
+metadata:
+  version: "1.0"
 ---
 # fleet-join — a live session as a fleet guest (G73, task 1081)
 

package/plugins/sp/skills/spur-dev/references/cross-cutting.md

@@ -131,8 +131,9 @@ surface instead of spawning a subprocess; a subprocess fallback happens only whe
 
 **Interactive task pipelines invert control into the host session (ADR-047 amendment).**
 `dev-run --mode full` and sequential `dev-runall` with omitted `--agent` or explicit `--agent
-inline` interpret the existing `task-pipeline.yaml` in the host session; they do not launch `spur
-workflow run` and never redirect silently to `agent.default`. Interactive **omit** is
+inline` run the existing `task-pipeline.yaml` on the host executor — the engine loop above
+(`spur workflow run … executor=host` → work item → `spur workflow continue`), with no subprocess —
+and never redirect silently to `agent.default`. Interactive **omit** is
 **host-controlled and non-subprocess**, but no longer guarantees host-context execution for every
 model stage (task 0508): an eligible `agent.run` stage — pure-slash input, non-interactive state,
 native subagent with shared-worktree read/write/shell capability, and a task above the

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

@@ -156,7 +156,7 @@ must not be changed without updating the backing skill.
 ### 4. run
 
 - **Purpose:** Run a task through the execution pipeline (full) or execute a single pipeline step (implement).
-- **Inputs:** `<wbs>` (required). `--mode <full|implement>` selects the execution mode. `implement` invokes `sp:code-implementation` inline by default. Interactive `full` resolves the selector uniformly (task 0687): omit ≡ explicit `--agent inline`; full mode reads `task-pipeline.yaml` and drives its actions/guards in the host session — host-controlled and non-subprocess, with 0508 eligibility applying to the resolved-inline selector (eligible `agent.run` stages dispatch once to a native subagent, host fallback)). `--agent auto`, a name, or headless invocation launches the workflow subprocess. `--agent <inline|auto|name>` selects the execution surface (see [SSOT](cross-cutting.md#inline-default-execution-surface)). `--auto` skips the HITL approve gate / confirmations and propagates down the `--next` chain. `--next` controls chaining only and never changes the mode; a pipeline implement stage must invoke `/sp:dev-run <wbs> --mode implement`. On implement success with `--next`, transition `todo → wip → testing` through the FSM (guards honored — no `--no-lifecycle`) + chain to `/sp:dev-verify <wbs> --auto --next`. On a guard failure, stop as review-pending. **Partial-deliverable rule:** if the task ships only part of its requirements (e.g. an R1/R2 split with the rest in a follow-up task), the `## Solution` section must state that explicitly and the verify verdict will record the scope. `--worktree [<name>]` runs the full pipeline inside an isolated git worktree (create or reuse; FF-merge on success, retain on failure) — the batch lifecycle in [execution-batch.md § Worktree isolation](execution-batch.md#worktree-isolation---worktree-name) applied to a batch of one; rejected with `--mode implement`. `--no-summary` skips the [execution summary](#execution-summary) printed after a full-mode run. `--wrap` hands off to `/sp:dev-wrap <wbs>` after the main step; the `--agent` selector is preserved into that handoff when supplied (omission remains omission), and the wrap hop reports its own trigger-3 subprocess override per the wrap contract.
+- **Inputs:** `<wbs>` (required). `--mode <full|implement>` selects the execution mode. `implement` invokes `sp:code-implementation` inline by default. Interactive `full` resolves the selector uniformly (task 0687): omit ≡ explicit `--agent inline`; full mode runs `task-pipeline.yaml` on the host executor (`spur workflow run … executor=host` → work item → `spur workflow continue`) — host-controlled and non-subprocess, with 0508 eligibility applying to the resolved-inline selector (eligible `agent.run` stages dispatch once to a native subagent, host fallback)). `--agent auto`, a name, or headless invocation launches the workflow subprocess. `--agent <inline|auto|name>` selects the execution surface (see [SSOT](cross-cutting.md#inline-default-execution-surface)). `--auto` skips the HITL approve gate / confirmations and propagates down the `--next` chain. `--next` controls chaining only and never changes the mode; a pipeline implement stage must invoke `/sp:dev-run <wbs> --mode implement`. On implement success with `--next`, transition `todo → wip → testing` through the FSM (guards honored — no `--no-lifecycle`) + chain to `/sp:dev-verify <wbs> --auto --next`. On a guard failure, stop as review-pending. **Partial-deliverable rule:** if the task ships only part of its requirements (e.g. an R1/R2 split with the rest in a follow-up task), the `## Solution` section must state that explicitly and the verify verdict will record the scope. `--worktree [<name>]` runs the full pipeline inside an isolated git worktree (create or reuse; FF-merge on success, retain on failure) — the batch lifecycle in [execution-batch.md § Worktree isolation](execution-batch.md#worktree-isolation---worktree-name) applied to a batch of one; rejected with `--mode implement`. `--no-summary` skips the [execution summary](#execution-summary) printed after a full-mode run. `--wrap` hands off to `/sp:dev-wrap <wbs>` after the main step; the `--agent` selector is preserved into that handoff when supplied (omission remains omission), and the wrap hop reports its own trigger-3 subprocess override per the wrap contract.
 - **Backing:** `sp:spur-dev` skill — `run` operation for the full pipeline (the spine drives it); `sp:code-implementation` competency skill for the implement step (the spine dispatches to it).
 - **Modes:**
   - **`full`** (default): Drive the full pipeline — precheck → implement → gate ⇄ remediate → review → done, with the repair, stop and approval routes taken from decision rows ([decision-points.md](decision-points.md)). Interactive omit/inline runs `spur workflow run task-pipeline.yaml --vars '{"wbs":"<wbs>","executor":"host"}'` and performs each returned work item (eligible stages may use a native subagent); explicit/headless executor selection runs the same definition without the `executor` var (with `profile: auto` when `--auto`). Both monitor/surface HITL and preserve the YAML gates. `--next` never changes this mode.

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

@@ -219,8 +219,8 @@ or irreversible HITL gates.
 
 Scope the operation to all tasks under a feature id (`^[A-Z][1-9]*$`). On feature-advancing
 commands (`dev-wrapall`) it also advances the feature through legal lifecycle edges with guards
-honored. On `dev-review` it takes a comma list (`--feature <id>[,<id>]`) — sugar for the union of
-the `feature:<id>` sets, resolved once and frozen.
+honored. On `dev-review` and `dev-find-conflict` it takes a comma list (`--feature <id>[,<id>]`) —
+sugar for the union of the `feature:<id>` sets, resolved once and frozen.
 
 ### `--check <cmd>` — validation command for iterate-and-check loops
 
@@ -250,9 +250,10 @@ all dimensions.
 **Anchor:** `#flag-scope`.
 
 Limit the operation to a file or directory path (`dev-arch`, `dev-debug`, `dev-fixall`,
-`dev-gitmsg`, `dev-gtd`, `dev-refactor`, `dev-review`, `dev-simplify`) to bound the working set.
-On `dev-review` it takes a comma list of paths — normalized, nested and duplicate paths merged,
-one advisory sub-review per surviving path.
+`dev-find-conflict`, `dev-gitmsg`, `dev-gtd`, `dev-refactor`, `dev-review`, `dev-simplify`) to
+bound the working set. On `dev-review` and `dev-find-conflict` it takes a comma list of paths —
+normalized, nested and duplicate paths merged; `dev-review` runs one advisory sub-review per
+surviving path, `dev-find-conflict` seeds one audit with all of them.
 
 ### `--all` — widen the operation to everything in its domain
 
@@ -275,9 +276,9 @@ is the contract; divergence between `--dry-run` and the real run is a bug.
 
 **Anchor:** `#flag-tasks`.
 
-Batch operation (`dev-refineall`, `dev-review`, `dev-runall`, `dev-verifyall`). An
+Batch operation (`dev-find-conflict`, `dev-refineall`, `dev-review`, `dev-runall`, `dev-verifyall`). An
 explicit selector — WBS list, status pseudo-list (`todo`, `wip`), `feature:<id>`, or `ready` —
-resolving to the set the batch runs over. On `dev-review` the selector is restricted to the
+resolving to the set the batch runs over. On `dev-review` and `dev-find-conflict` the selector is restricted to the
 review-safe forms: comma WBS list and `feature:<id>` — status pseudo-lists and `ready` are
 rejected (they select work to do, not work to review). Required on `dev-runall` and
 `dev-verifyall`, where `--feature` is an optional restrictor. On `dev-refineall` it is instead

package/spur.js

@@ -146882,7 +146882,7 @@ import { createRequire as createRequire3 } from "module";
 var CLI_CONFIG = {
   binaryName: "spur",
   binaryLabel: "spur",
-  binaryVersion: "0.4.16",
+  binaryVersion: "0.4.17",
   configDir: ".spur",
   configFile: ".spur/config.yaml",
   databaseFile: ".spur/spur.db"
@@ -156730,7 +156730,7 @@ init_dist5();
 import { homedir as homedir17 } from "os";
 import { basename as basename20, join as join94, relative as relative19, resolve as resolve37 } from "path";
 // ../server/package.json
-var version3 = "0.4.16";
+var version3 = "0.4.17";
 
 // ../server/src/modules/health/index.ts
 var startedAt = Date.now();