specweave 1.0.579 → 1.0.581

package/dist/src/types/skill-signals.d.ts

@@ -0,0 +1,200 @@
+/**
+ * Skill Signals v2 — discriminated-union schema for .specweave/state/skill-signals.json
+ *
+ * v1 (legacy) was a generation-only store produced by SignalCollector
+ * (see src/core/skill-gen/types.ts). v2 adds refinement signals emitted by
+ * closure gates (judge-llm, rubric, code-reviewer) and keeps generation
+ * signals bit-identical except for an added `type: "generation"` discriminator.
+ *
+ * Migration is lazy: the reader detects a v1 file and returns a v2 view in
+ * memory; the next writer call persists v2 to disk.
+ *
+ * @module types/skill-signals
+ */
+import { z } from 'zod';
+export type SignalSource = 'judge-llm' | 'rubric' | 'code-reviewer';
+export type SignalSeverity = 'low' | 'medium' | 'high';
+export declare const SIGNAL_SOURCES: readonly SignalSource[];
+export declare const SIGNAL_SEVERITIES: readonly SignalSeverity[];
+/**
+ * Legacy generation signal produced by SignalCollector. All v1 fields are
+ * preserved; `type: "generation"` is added during migration.
+ */
+export interface GenerationSignal {
+    type: 'generation';
+    id: string;
+    pattern: string;
+    category: string;
+    description: string;
+    incrementIds: string[];
+    firstSeen: string;
+    lastSeen: string;
+    confidence: number;
+    evidence: string[];
+    suggested: boolean;
+    declined: boolean;
+    generated: boolean;
+    uniqueSourceFiles?: string[];
+}
+export declare const GenerationSignalSchema: z.ZodObject<{
+    type: z.ZodLiteral<"generation">;
+    id: z.ZodString;
+    pattern: z.ZodString;
+    category: z.ZodString;
+    description: z.ZodString;
+    incrementIds: z.ZodArray<z.ZodString>;
+    firstSeen: z.ZodString;
+    lastSeen: z.ZodString;
+    confidence: z.ZodNumber;
+    evidence: z.ZodArray<z.ZodString>;
+    suggested: z.ZodBoolean;
+    declined: z.ZodBoolean;
+    generated: z.ZodBoolean;
+    uniqueSourceFiles: z.ZodOptional<z.ZodArray<z.ZodString>>;
+}, z.core.$strip>;
+/**
+ * Refinement signal emitted by a closure gate when a gate failure traces
+ * to a specific skill's instructions.
+ */
+export interface RefinementSignal {
+    type: 'refinement';
+    id: string;
+    source: SignalSource;
+    targetSkill: string;
+    severity: SignalSeverity;
+    incrementId: string;
+    evidence: string;
+    detectedAt: string;
+    consumedBy: string | null;
+}
+export declare const RefinementSignalSchema: z.ZodObject<{
+    type: z.ZodLiteral<"refinement">;
+    id: z.ZodString;
+    source: z.ZodEnum<{
+        "judge-llm": "judge-llm";
+        rubric: "rubric";
+        "code-reviewer": "code-reviewer";
+    }>;
+    targetSkill: z.ZodString;
+    severity: z.ZodEnum<{
+        low: "low";
+        medium: "medium";
+        high: "high";
+    }>;
+    incrementId: z.ZodString;
+    evidence: z.ZodString;
+    detectedAt: z.ZodString;
+    consumedBy: z.ZodNullable<z.ZodString>;
+}, z.core.$strip>;
+export type SkillSignal = GenerationSignal | RefinementSignal;
+export declare const SkillSignalSchema: z.ZodDiscriminatedUnion<[z.ZodObject<{
+    type: z.ZodLiteral<"generation">;
+    id: z.ZodString;
+    pattern: z.ZodString;
+    category: z.ZodString;
+    description: z.ZodString;
+    incrementIds: z.ZodArray<z.ZodString>;
+    firstSeen: z.ZodString;
+    lastSeen: z.ZodString;
+    confidence: z.ZodNumber;
+    evidence: z.ZodArray<z.ZodString>;
+    suggested: z.ZodBoolean;
+    declined: z.ZodBoolean;
+    generated: z.ZodBoolean;
+    uniqueSourceFiles: z.ZodOptional<z.ZodArray<z.ZodString>>;
+}, z.core.$strip>, z.ZodObject<{
+    type: z.ZodLiteral<"refinement">;
+    id: z.ZodString;
+    source: z.ZodEnum<{
+        "judge-llm": "judge-llm";
+        rubric: "rubric";
+        "code-reviewer": "code-reviewer";
+    }>;
+    targetSkill: z.ZodString;
+    severity: z.ZodEnum<{
+        low: "low";
+        medium: "medium";
+        high: "high";
+    }>;
+    incrementId: z.ZodString;
+    evidence: z.ZodString;
+    detectedAt: z.ZodString;
+    consumedBy: z.ZodNullable<z.ZodString>;
+}, z.core.$strip>], "type">;
+/**
+ * v2 on-disk envelope for `.specweave/state/skill-signals.json`.
+ */
+export interface SignalFile {
+    schemaVersion: 2;
+    signals: SkillSignal[];
+}
+export declare const SignalFileSchema: z.ZodObject<{
+    schemaVersion: z.ZodLiteral<2>;
+    signals: z.ZodArray<z.ZodDiscriminatedUnion<[z.ZodObject<{
+        type: z.ZodLiteral<"generation">;
+        id: z.ZodString;
+        pattern: z.ZodString;
+        category: z.ZodString;
+        description: z.ZodString;
+        incrementIds: z.ZodArray<z.ZodString>;
+        firstSeen: z.ZodString;
+        lastSeen: z.ZodString;
+        confidence: z.ZodNumber;
+        evidence: z.ZodArray<z.ZodString>;
+        suggested: z.ZodBoolean;
+        declined: z.ZodBoolean;
+        generated: z.ZodBoolean;
+        uniqueSourceFiles: z.ZodOptional<z.ZodArray<z.ZodString>>;
+    }, z.core.$strip>, z.ZodObject<{
+        type: z.ZodLiteral<"refinement">;
+        id: z.ZodString;
+        source: z.ZodEnum<{
+            "judge-llm": "judge-llm";
+            rubric: "rubric";
+            "code-reviewer": "code-reviewer";
+        }>;
+        targetSkill: z.ZodString;
+        severity: z.ZodEnum<{
+            low: "low";
+            medium: "medium";
+            high: "high";
+        }>;
+        incrementId: z.ZodString;
+        evidence: z.ZodString;
+        detectedAt: z.ZodString;
+        consumedBy: z.ZodNullable<z.ZodString>;
+    }, z.core.$strip>], "type">>;
+}, z.core.$strip>;
+export declare const EMPTY_SIGNAL_FILE: SignalFile;
+interface V1SignalEntry {
+    id: string;
+    pattern: string;
+    category: string;
+    description: string;
+    incrementIds: string[];
+    firstSeen: string;
+    lastSeen: string;
+    confidence: number;
+    evidence: string[];
+    suggested: boolean;
+    declined: boolean;
+    generated: boolean;
+    uniqueSourceFiles?: string[];
+}
+interface V1SignalStore {
+    version: string;
+    signals: V1SignalEntry[];
+}
+/**
+ * Returns true when `raw` conforms to the v1 on-disk shape.
+ * v1 is identified by a string `version` field (e.g. "1.0") and absent
+ * `schemaVersion`. v2 uses a numeric `schemaVersion: 2`.
+ */
+export declare function isV1(raw: unknown): raw is V1SignalStore;
+/**
+ * Migrate a v1 store to v2 without data loss. Adds `type: "generation"`
+ * to every existing entry; all other fields are preserved verbatim.
+ */
+export declare function migrateV1toV2(v1: V1SignalStore): SignalFile;
+export {};
+//# sourceMappingURL=skill-signals.d.ts.map

package/dist/src/types/skill-signals.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"skill-signals.d.ts","sourceRoot":"","sources":["../../../src/types/skill-signals.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;GAYG;AAEH,OAAO,EAAE,CAAC,EAAE,MAAM,KAAK,CAAC;AAIxB,MAAM,MAAM,YAAY,GAAG,WAAW,GAAG,QAAQ,GAAG,eAAe,CAAC;AACpE,MAAM,MAAM,cAAc,GAAG,KAAK,GAAG,QAAQ,GAAG,MAAM,CAAC;AAEvD,eAAO,MAAM,cAAc,EAAE,SAAS,YAAY,EAIjD,CAAC;AACF,eAAO,MAAM,iBAAiB,EAAE,SAAS,cAAc,EAA8B,CAAC;AAItF;;;GAGG;AACH,MAAM,WAAW,gBAAgB;IAC/B,IAAI,EAAE,YAAY,CAAC;IACnB,EAAE,EAAE,MAAM,CAAC;IACX,OAAO,EAAE,MAAM,CAAC;IAChB,QAAQ,EAAE,MAAM,CAAC;IACjB,WAAW,EAAE,MAAM,CAAC;IACpB,YAAY,EAAE,MAAM,EAAE,CAAC;IACvB,SAAS,EAAE,MAAM,CAAC;IAClB,QAAQ,EAAE,MAAM,CAAC;IACjB,UAAU,EAAE,MAAM,CAAC;IACnB,QAAQ,EAAE,MAAM,EAAE,CAAC;IACnB,SAAS,EAAE,OAAO,CAAC;IACnB,QAAQ,EAAE,OAAO,CAAC;IAClB,SAAS,EAAE,OAAO,CAAC;IACnB,iBAAiB,CAAC,EAAE,MAAM,EAAE,CAAC;CAC9B;AAED,eAAO,MAAM,sBAAsB;;;;;;;;;;;;;;;iBAejC,CAAC;AAIH;;;GAGG;AACH,MAAM,WAAW,gBAAgB;IAC/B,IAAI,EAAE,YAAY,CAAC;IACnB,EAAE,EAAE,MAAM,CAAC;IACX,MAAM,EAAE,YAAY,CAAC;IACrB,WAAW,EAAE,MAAM,CAAC;IACpB,QAAQ,EAAE,cAAc,CAAC;IACzB,WAAW,EAAE,MAAM,CAAC;IACpB,QAAQ,EAAE,MAAM,CAAC;IACjB,UAAU,EAAE,MAAM,CAAC;IACnB,UAAU,EAAE,MAAM,GAAG,IAAI,CAAC;CAC3B;AAED,eAAO,MAAM,sBAAsB;;;;;;;;;;;;;;;;;;iBAUjC,CAAC;AAIH,MAAM,MAAM,WAAW,GAAG,gBAAgB,GAAG,gBAAgB,CAAC;AAE9D,eAAO,MAAM,iBAAiB;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;2BAG5B,CAAC;AAEH;;GAEG;AACH,MAAM,WAAW,UAAU;IACzB,aAAa,EAAE,CAAC,CAAC;IACjB,OAAO,EAAE,WAAW,EAAE,CAAC;CACxB;AAED,eAAO,MAAM,gBAAgB;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;iBAG3B,CAAC;AAEH,eAAO,MAAM,iBAAiB,EAAE,UAG/B,CAAC;AAIF,UAAU,aAAa;IACrB,EAAE,EAAE,MAAM,CAAC;IACX,OAAO,EAAE,MAAM,CAAC;IAChB,QAAQ,EAAE,MAAM,CAAC;IACjB,WAAW,EAAE,MAAM,CAAC;IACpB,YAAY,EAAE,MAAM,EAAE,CAAC;IACvB,SAAS,EAAE,MAAM,CAAC;IAClB,QAAQ,EAAE,MAAM,CAAC;IACjB,UAAU,EAAE,MAAM,CAAC;IACnB,QAAQ,EAAE,MAAM,EAAE,CAAC;IACnB,SAAS,EAAE,OAAO,CAAC;IACnB,QAAQ,EAAE,OAAO,CAAC;IAClB,SAAS,EAAE,OAAO,CAAC;IACnB,iBAAiB,CAAC,EAAE,MAAM,EAAE,CAAC;CAC9B;AAED,UAAU,aAAa;IACrB,OAAO,EAAE,MAAM,CAAC;IAChB,OAAO,EAAE,aAAa,EAAE,CAAC;CAC1B;AAyBD;;;;GAIG;AACH,wBAAgB,IAAI,CAAC,GAAG,EAAE,OAAO,GAAG,GAAG,IAAI,aAAa,CAEvD;AAED;;;GAGG;AACH,wBAAgB,aAAa,CAAC,EAAE,EAAE,aAAa,GAAG,UAAU,CAsB3D"}

package/dist/src/types/skill-signals.js

@@ -0,0 +1,115 @@
+/**
+ * Skill Signals v2 — discriminated-union schema for .specweave/state/skill-signals.json
+ *
+ * v1 (legacy) was a generation-only store produced by SignalCollector
+ * (see src/core/skill-gen/types.ts). v2 adds refinement signals emitted by
+ * closure gates (judge-llm, rubric, code-reviewer) and keeps generation
+ * signals bit-identical except for an added `type: "generation"` discriminator.
+ *
+ * Migration is lazy: the reader detects a v1 file and returns a v2 view in
+ * memory; the next writer call persists v2 to disk.
+ *
+ * @module types/skill-signals
+ */
+import { z } from 'zod';
+export const SIGNAL_SOURCES = [
+    'judge-llm',
+    'rubric',
+    'code-reviewer',
+];
+export const SIGNAL_SEVERITIES = ['low', 'medium', 'high'];
+export const GenerationSignalSchema = z.object({
+    type: z.literal('generation'),
+    id: z.string(),
+    pattern: z.string(),
+    category: z.string(),
+    description: z.string(),
+    incrementIds: z.array(z.string()),
+    firstSeen: z.string(),
+    lastSeen: z.string(),
+    confidence: z.number(),
+    evidence: z.array(z.string()),
+    suggested: z.boolean(),
+    declined: z.boolean(),
+    generated: z.boolean(),
+    uniqueSourceFiles: z.array(z.string()).optional(),
+});
+export const RefinementSignalSchema = z.object({
+    type: z.literal('refinement'),
+    id: z.string(),
+    source: z.enum(['judge-llm', 'rubric', 'code-reviewer']),
+    targetSkill: z.string(),
+    severity: z.enum(['low', 'medium', 'high']),
+    incrementId: z.string(),
+    evidence: z.string(),
+    detectedAt: z.string(),
+    consumedBy: z.string().nullable(),
+});
+export const SkillSignalSchema = z.discriminatedUnion('type', [
+    GenerationSignalSchema,
+    RefinementSignalSchema,
+]);
+export const SignalFileSchema = z.object({
+    schemaVersion: z.literal(2),
+    signals: z.array(SkillSignalSchema),
+});
+export const EMPTY_SIGNAL_FILE = {
+    schemaVersion: 2,
+    signals: [],
+};
+const V1SignalEntrySchema = z.object({
+    id: z.string(),
+    pattern: z.string(),
+    category: z.string(),
+    description: z.string(),
+    incrementIds: z.array(z.string()),
+    firstSeen: z.string(),
+    lastSeen: z.string(),
+    confidence: z.number(),
+    evidence: z.array(z.string()),
+    suggested: z.boolean(),
+    declined: z.boolean(),
+    generated: z.boolean(),
+    uniqueSourceFiles: z.array(z.string()).optional(),
+});
+const V1SignalStoreSchema = z.object({
+    version: z.string(),
+    signals: z.array(V1SignalEntrySchema),
+});
+// ── Migration ────────────────────────────────────────────────────────
+/**
+ * Returns true when `raw` conforms to the v1 on-disk shape.
+ * v1 is identified by a string `version` field (e.g. "1.0") and absent
+ * `schemaVersion`. v2 uses a numeric `schemaVersion: 2`.
+ */
+export function isV1(raw) {
+    return V1SignalStoreSchema.safeParse(raw).success;
+}
+/**
+ * Migrate a v1 store to v2 without data loss. Adds `type: "generation"`
+ * to every existing entry; all other fields are preserved verbatim.
+ */
+export function migrateV1toV2(v1) {
+    return {
+        schemaVersion: 2,
+        signals: v1.signals.map((entry) => ({
+            type: 'generation',
+            id: entry.id,
+            pattern: entry.pattern,
+            category: entry.category,
+            description: entry.description,
+            incrementIds: [...entry.incrementIds],
+            firstSeen: entry.firstSeen,
+            lastSeen: entry.lastSeen,
+            confidence: entry.confidence,
+            evidence: [...entry.evidence],
+            suggested: entry.suggested,
+            declined: entry.declined,
+            generated: entry.generated,
+            ...(entry.uniqueSourceFiles !== undefined
+                ? { uniqueSourceFiles: [...entry.uniqueSourceFiles] }
+                : {}),
+        })),
+    };
+}
+//# sourceMappingURL=skill-signals.js.map

package/dist/src/types/skill-signals.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"skill-signals.js","sourceRoot":"","sources":["../../../src/types/skill-signals.ts"],"names":[],"mappings":"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"}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "specweave",
-  "version": "1.0.579",
+  "version": "1.0.581",
   "description": "100+ domain-expert AI skills — PM, Architect, Frontend, QA, Security and more. Skills learn your team's patterns permanently. Spec-first planning, autonomous execution, multi-agent teams, synced to GitHub/JIRA. Claude Code, Cursor, Copilot & more.",
   "type": "module",
   "main": "dist/index.js",
@@ -91,7 +91,7 @@
     "LICENSE"
   ],
   "dependencies": {
-    "@anthropic-ai/sdk": "^0.88.0",
+    "@anthropic-ai/sdk": "^0.90.0",
     "@inquirer/prompts": "^8.1.0",
     "@octokit/rest": "^22.0.1",
     "@types/handlebars": "^4.0.40",

package/plugins/specweave/commands/reflect.md

@@ -133,8 +133,17 @@ RECENT LEARNINGS
   - [devops] LSP requires ENABLE_LSP_TOOL=1 env var
   - [frontend] Use shadcn/ui Button component
   - [backend] Return 404 for missing resources
+
+## Skill Refinement Suggestions
+  Skill            Signals (J/R/C)   Severity   Last seen         Command
+  sw:architect     5 (3/1/1)         high       2026-04-19 18:22  sw:skill-refine sw:architect
+  sw:pm            3 (2/1/0)         medium     2026-04-18 09:07  sw:skill-refine sw:pm
 ```
 
+Introduced in **increment 0671 — skill refinement loop**. Skills with ≥3 negative signals in `.specweave/state/skill-signals.json` (`type: "refinement"`) are ranked by severity × recency. Entries with `<3` signals are omitted from the list; the whole section is omitted when no skills qualify.
+
+Signal sources (J/R/C = judge-llm / rubric / code-reviewer) come from closure gates. See [`sw:skill-refine`](./skill-refine.md) for flags, attribution heuristics, and the four red-line ADRs.
+
 ### `--clear` - Remove Learnings
 
 Remove specific learnings from CLAUDE.md Skill Memories section.
@@ -149,6 +158,44 @@ sw:reflect --clear --all              # Clear ALL learnings (requires confirmati
 2. Show confirmation with what will be deleted
 3. Edit CLAUDE.md to remove matching learnings on confirmation
 
+## Session-end Nudge
+
+Added in increment 0671. When `/sw:done` closes an increment, the reflect stop-hook checks whether the session accumulated either:
+
+- ≥1 high-confidence learning (eligible for CLAUDE.md persistence), or
+- ≥1 refinement signal in `.specweave/state/skill-signals.json` attributed to an existing skill.
+
+If so, a **single-line** prompt is printed at closure time:
+
+```
+Detected: 2 signals for sw:architect — run sw:skill-refine sw:architect? (y/N)
+```
+
+or, for a learning nudge:
+
+```
+Detected: 1 high-confidence learning — run sw:reflect? (y/N)
+```
+
+**The nudge never auto-executes a command.** The user must explicitly run the suggested command. Declining (N or no input within 5s) logs no penalty; signals remain in `skill-signals.json` for later invocation.
+
+Performance: the nudge check adds <100ms to `/sw:done` close time.
+
+### Disabling the nudge
+
+Set `reflect.autoNudge: false` in `.specweave/config.json`:
+
+```json
+{
+  "reflect": {
+    "enabled": true,
+    "autoNudge": false
+  }
+}
+```
+
+When `autoNudge` is false, no nudge is printed at close; `sw:reflect` and `sw:skill-refine` remain manually invocable.
+
 ## Configuration
 
 In `.specweave/config.json`:
@@ -168,6 +215,7 @@ In `.specweave/config.json`:
 | `enabled` | `true` | Master switch for reflection |
 | `model` | `"haiku"` | LLM model for extraction |
 | `maxLearningsPerSession` | `3` | Limit per session |
+| `autoNudge` | `true` | Session-end nudge when learnings or refinement signals are detected (0671) |
 
 ## Skill Categories
 

package/plugins/specweave/skills/code-reviewer/SKILL.md

@@ -511,6 +511,10 @@ Write structured JSON with all findings, metadata, and reviewer statuses.
 
 The `summary` object reflects post-validation counts. The completion-validator only reads `summary.*` fields -- all new fields are additive and backward-compatible.
 
+### Refinement Signal Emission (0671)
+
+When the completion-validator parses `code-review-report.json`, it iterates `findings[]` and, for each CRITICAL or HIGH finding whose evidence references a specific skill slug (e.g. `sw:architect`) or matches a ≥6-word phrase from a `SKILL.md` under `plugins/specweave/skills/`, appends a refinement signal to `.specweave/state/skill-signals.json` (best-effort, never blocks closure). Source is `"code-reviewer"` and severity is always `"high"`. Reviewers do not need to do anything extra — include the offending skill slug or the SKILL.md-quoted instruction in the finding's `description`/`recommendation` and attribution is automatic. Signals are consumed later by `sw:skill-refine`.
+
 ---
 
 ## 5. Cross-Repo Mode

package/plugins/specweave/skills/judge-llm/SKILL.md

@@ -215,6 +215,10 @@ After evaluation (including consent-denied fallback), you **MUST** write a JSON
 
 A `WAIVED` verdict is accepted by the CLI — does not block closure.
 
+## Refinement Signal Emission (0671)
+
+When the verdict is `REJECTED` or `CONCERNS` and a finding references a specific skill slug (e.g. `sw:architect` in `concerns`, `recommendations`, or `summary`), `SkillJudge.writeReport` appends a refinement signal to `.specweave/state/skill-signals.json` (best-effort, never blocks the gate). `REJECTED` → severity `high`; `CONCERNS` → `medium`. Signals are consumed later by `sw:skill-refine`.
+
 ## Visibility & Stuck Detection
 
 Progress logged to `.specweave/logs/judge-llm.log`. Default timeout 60s aborts if stuck (`timedOut: true`).

package/plugins/specweave/skills/skill-gen/SKILL.md

@@ -7,6 +7,14 @@ model: opus
 
 # sw:skill-gen — Project-Specific Skill Generation
 
+## Model Selection
+
+This skill does not call an LLM directly — it delegates to Anthropic's `skill-creator` plugin, which runs inside the current Claude Code session and inherits its model. Skill generation is a structured-output task where description wording drives auto-activation for every future invocation, so quality matters more than cost.
+
+- **Default (recommended)**: run the session on the newest Opus. If you are in Claude Code, switch with `/model opus` before starting. The frontmatter above declares `model: opus` so nested invocations prefer it when supported. "Newest Opus" is forward-compatible: today that is Opus 4.7, and the recommendation follows whichever Opus is current.
+- **BYO path (GPT-5, Gemini 3, OpenRouter, LM Studio, Ollama)**: start `npx anymodel proxy --model <model> --port <port>` in a separate shell, then `export ANTHROPIC_BASE_URL=http://localhost:<port>` before launching Claude Code. This only affects downstream tools that honor `ANTHROPIC_BASE_URL` — Claude Code's own chat model is controlled via `/model`.
+- **Rationale & registry**: see ADR `0676-01-skill-gen-model-selection.md`. The authoritative model registry lives in `vskill-platform` (`src/lib/eval/model-registry.ts`); update it there when a newer Opus ships.
+
 ## Project Overrides
 
 **Skill Memories**: If `.specweave/skill-memories/skill-gen.md` exists, read and apply its learnings.

package/plugins/specweave/skills/skill-refine/SKILL.md

@@ -0,0 +1,96 @@
+---
+description: "Refine an existing skill's SKILL.md against accumulated gate-failure signals. Use when saying 'sw:skill-refine', 'refine skill', 'improve skill', 'skill refinement', or responding to a session-end nudge suggesting refinement. One skill per invocation; user approval required; never runs during an active /sw:do or /sw:done session (ADR-0671-01)."
+argument-hint: "<skill-slug> [--dry-run] [--show-signals] [--scope project|user] [--last-n N]"
+allowed-tools: Read, Bash
+context: fork
+model: opus
+---
+
+# sw:skill-refine — Targeted Skill Refinement Loop
+
+Propose and apply minimal, auditable edits to an existing `SKILL.md` using evidence collected by the closure gates (`sw:judge-llm`, `rubric`, `sw:code-reviewer`).
+
+**Inputs:** `<skill-slug>` (e.g. `sw:architect`) + refinement signals under `.specweave/state/skill-signals.json`.
+**Output:** a reviewed git commit on the local branch (never pushed) plus a ledger entry at `.specweave/state/skill-refinements.json`.
+
+## Red lines (inherited from ADR-0671-01..04)
+
+1. **No runtime mutation.** This skill refuses to run when `SPECWEAVE_SESSION_ACTIVE` is set or `.specweave/state/active-session.lock` exists. Refinements happen *between* sessions, as an explicit human action.
+2. **No auto-apply.** Every diff requires explicit approve / reject / edit from the human at the terminal. There is no `--yes` flag and none will be added.
+3. **One skill per invocation.** `sw:skill-refine sw:a sw:b` is a usage error. Refinements must stay scoped.
+4. **Never pushes.** `git commit` only — reviewing the commit and pushing stays with the user.
+
+## Usage
+
+```bash
+# Inspect signals without proposing a diff (no LLM call)
+sw:skill-refine sw:architect --show-signals
+
+# Propose a diff, print it, do not write anything
+sw:skill-refine sw:architect --dry-run
+
+# Full interactive flow: aggregate → Haiku diff → approve/reject/edit → commit + ledger
+sw:skill-refine sw:architect
+
+# Refine a user-scoped skill at ~/.claude/skills/<dir>/SKILL.md
+sw:skill-refine my-skill --scope user
+
+# Override default N=5 increment window
+sw:skill-refine sw:architect --last-n 3
+```
+
+## Workflow
+
+1. **Parse flags** — `<skill-slug>` (required), `--dry-run`, `--show-signals`, `--scope project|user`, `--last-n N`. Exactly one skill per invocation.
+2. **Session-lock guard** — refuse if in an active `/sw:do` or `/sw:done` session. See ADR-0671-01.
+3. **Resolve SKILL.md path** — `project` ⇒ `.claude/skills/<slug-dir>/SKILL.md`; `user` ⇒ `~/.claude/skills/<slug-dir>/SKILL.md`. Slug `sw:foo` maps to directory `sw-foo` (flat-dir convention).
+4. **Aggregate signals** — read `.specweave/state/skill-signals.json`, filter to refinements targeting the given skill within the last N increments (default 5). Break down by source + severity.
+5. **`--show-signals` short-circuit** — pretty-print the aggregate and exit; no LLM call.
+6. **Haiku diff proposal** — call `claude-haiku-4-5-20251001` at `temperature=0` with `(current SKILL.md, signal aggregate)`. Return `{ diff, rationale }`. Determinism: repeat runs with identical inputs produce byte-identical output (AC-US2-02).
+7. **`--dry-run` short-circuit** — print diff + rationale; exit. No ledger entry, no commit.
+8. **Interactive approval** — show diff + rationale, prompt `approve / reject / edit`. Edit loops at most 3 times before auto-reject.
+9. **On approve** — `git apply` the patch, `git add -- <SKILL.md>`, `git commit -m "refine(<skill>): <rationale>"`. Record the commit SHA in `.specweave/state/skill-refinements.json` with `status: "applied"`. Never pushes.
+10. **On reject** — write a rejection ledger entry with the user's reason. SKILL.md is untouched.
+
+## Signals
+
+Refinement signals are emitted by the closure gates when a gate failure traces to a specific skill's instructions:
+
+| Source | Emitted when |
+|---|---|
+| `judge-llm` | `judge-llm-report.json` finding cites a skill slug as the root cause |
+| `rubric` | A rubric criterion fails and the rationale traces to a skill-directed behavior |
+| `code-reviewer` | A critical finding is attributable to skill-directed behavior |
+
+Attribution is intentionally high-precision / low-recall — a missing signal is better than a wrongly-blamed skill.
+
+## Files
+
+- `plugins/specweave/skills/skill-refine/SKILL.md` — this file (the user-facing skill definition)
+- `src/skills/skill-refine.ts` — CLI entry point (`runSkillRefine`)
+- `src/core/skill-refine/aggregator.ts` — signal aggregation + breakdown
+- `src/core/skill-refine/haiku-diff.ts` — Haiku-backed diff proposal (temperature 0, deterministic)
+- `src/core/skill-refine/approval.ts` — interactive approve/reject/edit (via `@inquirer/prompts`)
+- `src/core/skill-refine/apply.ts` — write + `git apply` + `git commit` + ledger append
+- `src/core/skill-refine/ledger.ts` — append-only `.specweave/state/skill-refinements.json` writer
+- `src/types/skill-refinements.ts` — ledger types + zod schema
+
+## When this skill activates
+
+- User says `sw:skill-refine`, `refine skill`, `improve skill`, `skill refinement`.
+- User responds to a session-end nudge (see `sw:reflect`) that suggests refining a specific skill.
+
+## ADRs
+
+- [ADR-0671-01](../../../../.specweave/docs/internal/architecture/adr/0671-01-no-runtime-skill-mutation.md) — No runtime mutation of active skills.
+- [ADR-0671-02](../../../../.specweave/docs/internal/architecture/adr/0671-02-registry-version-immutability.md) — Registry version immutability.
+- [ADR-0671-03](../../../../.specweave/docs/internal/architecture/adr/0671-03-no-self-improving-marketing.md) — No "self-improving" marketing.
+- [ADR-0671-04](../../../../.specweave/docs/internal/architecture/adr/0671-04-no-goodhart-loop.md) — No Goodhart loop on gate signals.
+
+## Error handling
+
+- Missing SKILL.md → print the resolved path, exit with `no-diff` status.
+- Zero signals → print "no signals for `<skill>` in the last N increments", exit cleanly.
+- Haiku returns malformed JSON → surface the raw output, abort; the ledger is not touched.
+- `git apply` fails → SKILL.md is restored from the pre-call snapshot, no commit, no ledger entry.
+- `ANTHROPIC_API_KEY` unset → clear error before any prompt or write.