sequant 2.2.0 → 2.3.0

package/templates/skills/setup/SKILL.md

@@ -190,6 +190,12 @@ Create `.sequant/settings.json` with sensible defaults:
 }
 ```
 
+> **Note:** `agents.model` is currently **inert** per
+> [anthropics/claude-code#43869](https://github.com/anthropics/claude-code/issues/43869).
+> Subagents inherit the parent session's model regardless of this value. The
+> field is kept for forward compatibility so existing settings.json files
+> continue to parse without error.
+
 Use the Write tool to create `.sequant/settings.json` with the above content.
 
 ### 5. Detect Package Manager

package/templates/skills/spec/SKILL.md

@@ -86,6 +86,7 @@ Mark tier in HTML comment for downstream parsing: `<!-- SEQUANT_SPEC_TIER: [tier
    | Unmeasurable | "fast", "performant" | No threshold defined |
    | Incomplete | "handle errors", "edge cases" | Scenarios not enumerated |
    | Open-ended | "etc.", "and more" | Scope undefined |
+   | Title/body tension | doc-noun title ("note", "comment", "snippet") + runtime-imperative body ("execute", "trigger", "capture", incl. inflections like `triggered`/`captured`, `run /<cmd>`); separators `.`/`\n`/`:`/`—` | Two different verification bars |
 
 3. **Scope Assessment** (unless `--skip-scope-check`): Use `performScopeAssessment` from `./src/lib/scope/index.ts` with settings from `getSettings()`. Verdicts: SCOPE_OK (green), SCOPE_WARNING (yellow, auto-enables quality loop), SCOPE_SPLIT_RECOMMENDED (red). Store results in state.
 
@@ -142,6 +143,57 @@ Check for explicit dependencies: `gh issue view <issue> --json body,labels`. If
 
 Check issue body/labels for feature branch references (`feature/`, `based on`, epic labels). If found, recommend `--base feature/<branch>` in the plan.
 
+### Sibling-site Scan (Conditional)
+
+**When to apply:** Focused AC + a localized fix where the same root-cause pattern likely exists at sibling sites in the same file (≥3 instances of the affected pattern in the same file — e.g. the regex blocks in `pre-tool.sh`).
+
+**During planning**, scan the same file/module for sibling code matching the bug's root cause. If sibling sites are found, surface them as either: **(a)** an Open Question (in `## Open Questions`) proposing scope expansion (only when trivially co-located), or **(b)** a recommended follow-up issue (in `## Implementation Plan` or as a separate plan step). When findings mix trivial and non-trivial sites, surface each separately. **Don't silently widen scope — the user decides.**
+
+This operationalizes the principle in `feedback_qa_second_look.md` (structured analysis biases positive on the literal AC; an adversarial re-read of adjacent code surfaces hidden scope) — `/spec` is the front line, `/qa` the safety net, so catching siblings here is strictly cheaper than at QA. Don't automate via grep — false-positive risk; this is a "look at adjacent code" planner prompt.
+
+### Rule Touchpoints (Conditional)
+
+**When to apply:** Any AC whose description matches the behavior-rule heuristic — i.e. >= 2 distinct keywords from `default | always | never | rule | behavior | skip` (case-insensitive), OR an explicit pattern like `always X unless Y` / `never X unless Y` / `default X when Y`.
+
+**Why:** Behavior-rule ACs are routinely implemented at multiple touchpoints — typically a skill prompt (LLM-interpreted) AND runtime TypeScript that duplicates the same rule. Without this check, edits land at one site and the other goes stale. Motivating miss: issue #533 (default /assess spec phase ON) where the runtime CLI's `BUG_LABELS`/`DOCS_LABELS` short-circuit survived the SKILL.md edit and was caught only by manual user follow-up. See [behavior-rule-detection.md](../_shared/references/behavior-rule-detection.md).
+
+**During context gathering**, run the detector on every AC. For each AC that triggers, list its touchpoints under a new `## Rule Touchpoints` section in the plan output.
+
+```bash
+# Per-AC touchpoint enumeration. Run once per AC in the issue body.
+# Skip entirely when no AC triggers (cheap short-circuit).
+SPEC_AC_ID="AC-1" \
+SPEC_AC_TEXT="<verbatim AC description from the issue body>" \
+npx tsx -e '
+(async () => {
+  const m = await import("./src/lib/heuristics/behavior-rule-detector.ts");
+  const ac = {
+    id: process.env.SPEC_AC_ID,
+    description: process.env.SPEC_AC_TEXT,
+    verificationMethod: "manual",
+    status: "pending",
+  };
+  const detection = m.detectBehaviorRule(ac);
+  if (!detection.triggered) { console.log(JSON.stringify({ triggered: false })); return; }
+  const touchpoints = m.findTouchpoints(ac, process.cwd());
+  console.log(JSON.stringify({ triggered: true, keywords: detection.keywords, touchpoints }));
+})();
+'
+```
+
+**If any AC triggers and `touchpoints` is non-empty**, add this section to the plan output (between **Implementation Plan** and **Design Review**):
+
+```markdown
+## Rule Touchpoints
+
+| AC | Touchpoint | Snippet |
+|----|------------|---------|
+| AC-N | path/to/file.ts:LINE | `<one-line snippet>` |
+```
+
+**If every AC short-circuits** (`triggered: false`) **or `touchpoints` is empty**, omit the section entirely — keeps cost cheap per the Performance budget in the reference doc.
+
+
 ## Verification Method Decision Framework
 
 Use this table when assigning verification methods to each AC:

package/templates/skills/spec/references/parallel-groups.md

@@ -25,6 +25,13 @@ When the implementation involves 3+ independent tasks that could be parallelized
 
 ## Model Selection
 
+> **Note:** Per anthropics/claude-code#43869, the `[model: ...]` annotation
+> below and the `model=` parameter `/exec` passes to `Agent(...)` are currently
+> ignored — every spawned subagent inherits the parent session's model. The
+> guidance here reflects the *intended* tier for each task once upstream fixes
+> ship; the parser in `exec/SKILL.md` is kept intact so it reactivates
+> automatically.
+
 Include a `[model: haiku]` or `[model: sonnet]` annotation at the end of each task line:
 
 | Task Type | Recommended Model |

package/templates/skills/spec/references/recommended-workflow.md

@@ -14,16 +14,18 @@ This document shows the expected output format for the `## Recommended Workflow`
 
 ## Examples
 
-### Simple Bug Fix
+### Simple Bug Fix (spec confirms straightforward scope)
 
 ```markdown
 ## Recommended Workflow
 
 **Phases:** exec → qa
 **Quality Loop:** disabled
-**Reasoning:** Straightforward bug fix with clear root cause. No planning needed.
+**Reasoning:** This spec pass confirmed a clear root cause and narrow scope — no testgen or additional phases required; proceed to exec.
 ```
 
+*Note:* Since #533, spec always runs by default. `**Phases:**` lists phases **after** spec — use `exec → qa` here to indicate "spec is done; only exec and qa remain."
+
 ### Standard Feature
 
 ```markdown

package/templates/skills/testgen/SKILL.md

@@ -39,9 +39,16 @@ When invoked as `/testgen <issue-number>`, your job is to:
 - `/testgen 123` - Generate test stubs for issue #123 based on /spec comment
 - `/testgen` - Generate stubs for the most recently discussed issue in conversation
 
-## Token Optimization with Haiku Sub-Agents
+## Sub-Agent Delegation for Stub Generation
 
-**Purpose:** Test stub generation is highly mechanical and benefits from using haiku sub-agents to minimize token cost.
+**Purpose:** Test stub generation is highly mechanical and is delegated to `sequant-testgen` so the main agent focuses on orchestration.
+
+> **Upstream caveat:** `sequant-testgen` declares `model: haiku`, but per
+> anthropics/claude-code#43869 that declaration is currently ignored — the
+> subagent inherits the parent session's model. Older versions of this doc
+> claimed concrete token-cost savings from haiku. Those numbers are not
+> achievable until the upstream fix ships; treat the haiku claim as the
+> *intended* tier, not the runtime one.
 
 **Pattern:** Use `Agent(subagent_type="sequant-testgen")` for:
 1. Parsing verification criteria from /spec comments
@@ -49,13 +56,12 @@ When invoked as `/testgen <issue-number>`, your job is to:
 3. Writing test file content
 
 **Benefits:**
-- 90% token cost reduction for mechanical generation
-- Faster execution for templated operations
-- Main agent focuses on orchestration and decisions
+- Main agent focuses on orchestration and decisions, not stub templating
+- Designated tier (`haiku`) will yield token savings once anthropics/claude-code#43869 is fixed; today subagents inherit the parent's model
 
 ### Sub-Agent Usage
 
-**Step 1: Parse Verification Criteria (use haiku)**
+**Step 1: Parse Verification Criteria (designated haiku — currently inert per anthropics/claude-code#43869)**
 
 ```javascript
 Agent(subagent_type="sequant-testgen", prompt=`
@@ -87,7 +93,7 @@ ${specComment}
 `)
 ```
 
-**Step 2: Generate Test Stubs (use haiku for each AC)**
+**Step 2: Generate Test Stubs (designated haiku — currently inert per anthropics/claude-code#43869)**
 
 ```javascript
 // For each AC with Unit Test or Integration Test verification method
@@ -122,16 +128,16 @@ The main agent handles file operations to ensure proper coordination:
 
 | Task | Agent | Reasoning |
 |------|-------|-----------|
-| Parse /spec comment | haiku | Mechanical text extraction |
-| Generate test stub code | haiku | Templated generation |
-| Identify failure scenarios | haiku | Pattern matching |
+| Parse /spec comment | `sequant-testgen` (declared haiku, inert per #43869) | Mechanical text extraction |
+| Generate test stub code | `sequant-testgen` (declared haiku, inert per #43869) | Templated generation |
+| Identify failure scenarios | `sequant-testgen` (declared haiku, inert per #43869) | Pattern matching |
 | Decide file locations | main | Requires codebase context |
 | Write files | main | File system coordination |
 | Post GitHub comment | main | Session context needed |
 
 ### Parallel Sub-Agent Execution
 
-When multiple ACs need test stubs, spawn haiku agents in parallel:
+When multiple ACs need test stubs, spawn `sequant-testgen` agents in parallel (declared haiku tier, currently inert per anthropics/claude-code#43869):
 
 ```javascript
 // Spawn all stub generation agents in a single message
@@ -143,11 +149,12 @@ const stubPromises = criteria
 // Main agent writes all files
 ```
 
-**Cost savings example:**
-- 5 AC items with Unit Test verification
-- Without haiku: ~50K tokens (main agent generates all)
-- With haiku: ~5K tokens (main orchestrates, haiku generates)
-- Savings: ~90%
+**Cost savings (when upstream lands):**
+Once anthropics/claude-code#43869 is fixed and the declared haiku tier takes
+effect, delegating mechanical stub generation to `sequant-testgen` will
+substantially reduce token cost vs. having the main agent generate every stub.
+Concrete savings are not measured here because the declaration is currently
+inert.
 
 ## Workflow
 
@@ -626,7 +633,7 @@ Cannot generate test files - no feature worktree exists for Issue #<N>.
 
 **Options:**
 1. Run `/exec <issue>` first (creates worktree automatically)
-2. Create worktree manually: `./scripts/dev/new-feature.sh <issue>`
+2. Create worktree manually: `./scripts/new-feature.sh <issue>`
 3. Use the browser/manual test scenarios from this comment
 ```