@opengsd/gsd-core 1.6.0-rc.2 → 1.6.0-rc.3

package/gsd-core/bin/lib/surface.cjs

@@ -270,17 +270,49 @@ function applySurface(runtimeConfigDir, layout, manifest, clusterMap, registry)
     // module's deep seam (ADR-1508 / #1511 Phase 2) — no attribution resolver
     // needed here (proven: Co-Authored-By never appears in staged content; see
     // brief PROVEN KEY FACT). No getInstallExports() call required.
-    for (const kind of layout.kinds) {
-        const staged = kind.stage(resolved);
-        if (kind.kind === 'skills') {
-            runtimeArtifactConversion.rewriteStagedSkillBodies(staged, {
-                runtime: layout.runtime,
-                configDir: layout.configDir,
-                scope: layout.scope ?? 'global',
-            });
+    // #1615 adversarial review (PR #1622): commands kind was previously skipped,
+    // leaving raw @~/.claude/... references in Windsurf workflow bodies after a
+    // /gsd-surface profile change. Same gap affected any runtime with commands
+    // kinds (windsurf, opencode, kilo, cursor, augment, codebuddy, gemini).
+    //
+    // Asymmetry note: rewriteStagedSkillBodies mutates in place (returns void),
+    // but rewriteStagedCommandBodies copies to a fresh mkdtemp dir and returns
+    // its path (commands .md files are flat; mutating the staged source would
+    // corrupt the package source on full-profile runs). Caller MUST sync from
+    // the returned dir and clean it up.
+    const tempDirsToClean = [];
+    try {
+        for (const kind of layout.kinds) {
+            let staged = kind.stage(resolved);
+            if (kind.kind === 'skills') {
+                runtimeArtifactConversion.rewriteStagedSkillBodies(staged, {
+                    runtime: layout.runtime,
+                    configDir: layout.configDir,
+                    scope: layout.scope ?? 'global',
+                });
+            }
+            else if (kind.kind === 'commands') {
+                const rewritten = runtimeArtifactConversion.rewriteStagedCommandBodies(staged, {
+                    runtime: layout.runtime,
+                    configDir: layout.configDir,
+                    scope: layout.scope ?? 'global',
+                });
+                if (rewritten && rewritten !== staged) {
+                    staged = rewritten;
+                    tempDirsToClean.push(rewritten);
+                }
+            }
+            const dest = node_path_1.default.join(layout.configDir, kind.destSubpath);
+            _syncGsdDir(staged, dest, kind, skillManifest);
+        }
+    }
+    finally {
+        for (const dir of tempDirsToClean) {
+            try {
+                node_fs_1.default.rmSync(dir, { recursive: true, force: true });
+            }
+            catch { /* best-effort cleanup */ }
         }
-        const dest = node_path_1.default.join(layout.configDir, kind.destSubpath);
-        _syncGsdDir(staged, dest, kind, skillManifest);
     }
     return resolved;
 }

package/gsd-core/bin/lib/update-context.cjs

@@ -31,8 +31,8 @@ exports.RUNTIME_DIRS = [
     ['antigravity', '.gemini/antigravity'],
     ['antigravity', '.agents'], // local Antigravity install dir canonical (#791; bin/install.js getDirName('antigravity'))
     ['antigravity', '.agent'], // local Antigravity install dir legacy (#503; backward-compat with pre-#791 installs)
-    ['windsurf', '.devin'], // local Windsurf/Devin Desktop install dir canonical (#1085; bin/install.js getDirName('windsurf'))
-    ['windsurf', '.windsurf'], // local Windsurf install dir legacy (#1085; backward-compat with pre-#1085 installs)
+    ['windsurf', '.windsurf'], // local Windsurf workflow dir canonical (#1615; bin/install.js getDirName('windsurf'))
+    ['windsurf', '.devin'], // local Devin Desktop install dir legacy (#1085; backward-compat)
     ['gemini', '.gemini'],
     ['kilo', '.config/kilo'],
     ['kilo', '.kilo'],

package/gsd-core/references/planner-guidance.md

@@ -184,3 +184,69 @@ Execute: `/gsd:execute-phase {phase} --gaps-only`
 ## Checkpoint Reached / Revision Complete
 
 Follow templates in checkpoints and revision_mode sections respectively.
+
+---
+
+## Goal-Backward Worked Example
+
+### Step 2: Derive Observable Truths
+
+For "working chat interface":
+- User can see existing messages
+- User can type a new message
+- User can send the message
+- Sent message appears in the list
+- Messages persist across page refresh
+
+**Test:** Each truth verifiable by a human using the application.
+
+### Step 3: Derive Required Artifacts
+
+"User can see existing messages" requires:
+- Message list component (renders Message[])
+- Messages state (loaded from somewhere)
+- API route or data source (provides messages)
+- Message type definition (shapes the data)
+
+**Test:** Each artifact = a specific file or database object.
+
+### Step 4: Derive Required Wiring
+
+Message list component wiring:
+- Imports Message type (not using `any`)
+- Receives messages prop or fetches from API
+- Maps over messages to render (not hardcoded)
+- Handles empty state (not just crashes)
+
+### Step 5: Identify Key Links
+
+"Where is this most likely to break?" Key links = critical connections where breakage causes cascading failures.
+
+### Must-Haves Output Format
+
+```yaml
+must_haves:
+  truths:
+    - "User can see existing messages"
+    - "User can send a message"
+    - "Messages persist across refresh"
+  artifacts:
+    - path: "src/components/Chat.tsx"
+      provides: "Message list rendering"
+      min_lines: 30
+    - path: "src/app/api/chat/route.ts"
+      provides: "Message CRUD operations"
+      exports: ["GET", "POST"]
+    - path: "prisma/schema.prisma"
+      provides: "Message model"
+      contains: "model Message"
+  key_links:
+    - from: "src/components/Chat.tsx"
+      to: "src/app/api/chat/route.ts"
+      via: "fetch in useEffect — calls /api/chat endpoint"
+      pattern: "fetch.*api/chat"
+    - from: "src/app/api/chat/route.ts"
+      to: "prisma/schema.prisma"
+      via: "database query via prisma.message"
+      pattern: "prisma\\.message\\.(find|create)"
+```

package/gsd-core/references/planning-config.md

@@ -275,8 +275,8 @@ Set via `workflow.*` namespace in config.json (e.g., `"workflow": { "research":
 | `workflow.code_review_depth` | string | `"standard"` | `"light"`, `"standard"`, `"deep"` | Depth level for code review analysis in the ship workflow |
 | `workflow._auto_chain_active` | boolean | `false` | `true`, `false` | Internal: tracks whether autonomous chaining is active |
 | `workflow.security_enforcement` | boolean | `true` | `true`, `false` | Enable threat-model-anchored security verification via `/gsd:secure-phase`. When `false`, security checks are skipped entirely |
-| `workflow.security_asvs_level` | number | `1` | `1`, `2`, `3` | OWASP ASVS verification level. Level 1 = opportunistic, Level 2 = standard, Level 3 = comprehensive |
-| `workflow.security_block_on` | string | `"high"` | `"high"`, `"medium"`, `"low"` | Minimum severity that blocks phase advancement |
+| `workflow.security_asvs_level` | number | `1` | `1`, `2`, `3` | OWASP ASVS verification level. Level 1 = opportunistic, Level 2 = standard, Level 3 = comprehensive. Scales both planner threat-disposition rigor (which threats must be mitigated vs. accepted) and auditor verification depth (grep-level → boundary-placement check → full data-flow trace). See `gsd-core/references/security-asvs-levels.md`. |
+| `workflow.security_block_on` | string | `"high"` | `"critical"`, `"high"`, `"medium"`, `"low"`, `"none"` | Minimum threat severity that blocks phase advancement. The auditor counts only open threats at or above this severity toward the blocking gate (SECURITY.md `threats_open`); `none` disables severity blocking. |
 | `workflow.post_planning_gaps` | boolean | `true` | `true`, `false` | Post-planning gap report (#2493). After plans are generated, scans REQUIREMENTS.md and CONTEXT.md `<decisions>` against all PLAN.md files and emits a unified `Source \| Item \| Status` table. Non-blocking. Set to `false` to skip Step 13e of plan-phase. _Alias:_ `post_planning_gaps` is the flat-key form used in `CONFIG_DEFAULTS`; `workflow.post_planning_gaps` is the canonical namespaced form. |
 
 ### Ship Fields

package/gsd-core/references/security-asvs-levels.md

@@ -0,0 +1,27 @@
+# Security ASVS Levels
+
+GSD threat modeling maps OWASP ASVS levels to planner disposition rigor and auditor verification depth. Higher levels are supersets of lower — L3 includes all L2 and L1 requirements.
+
+## L1 — Opportunistic (default)
+
+**Scope:** Cover threats on primary trust boundaries and high-impact components.
+
+**Planner disposition:** `mitigate` critical/high-severity threats. `mitigate` medium-severity threats if they occur on a primary trust boundary; otherwise `accept` with documented rationale explaining the specific risk tolerance. `accept` low-risk threats with a rationale statement. `transfer` when threat is third-party responsibility.
+
+**Auditor verification depth:** Verify each declared mitigation is PRESENT in the cited file (grep-level check — find the pattern, confirm the call exists).
+
+## L2 — Standard
+
+**Scope:** Map ALL applicable STRIDE categories for every in-scope component.
+
+**Planner disposition:** `mitigate` medium-severity-and-above threats. Every `accept` MUST have explicit documented rationale explaining why the risk is tolerable for this specific context.
+
+**Auditor verification depth:** Verify the mitigation ACTUALLY ADDRESSES the threat vector (not just that some pattern is present) and is placed at the correct trust boundary. A login check in the wrong layer does not close the threat.
+
+## L3 — Comprehensive
+
+**Scope:** Exhaustive STRIDE × all components; defense-in-depth for critical threats.
+
+**Planner disposition:** `mitigate` all threats except those explicitly accepted with documented sign-off. Defense-in-depth layers required for critical threats (multiple independent controls).
+
+**Auditor verification depth:** Deep verification — trace data flow end-to-end, check edge cases and ordering, confirm the mitigation cannot be bypassed via alternate code paths or parameter manipulation.

package/gsd-core/templates/SECURITY.md

@@ -2,6 +2,7 @@
 phase: {N}
 slug: {phase-slug}
 status: draft
+# threats_open = count of OPEN threats at or above workflow.security_block_on severity (the blocking gate)
 threats_open: 0
 asvs_level: 1
 created: {date}
@@ -23,11 +24,12 @@ created: {date}
 
 ## Threat Register
 
-| Threat ID | Category | Component | Disposition | Mitigation | Status |
-|-----------|----------|-----------|-------------|------------|--------|
-| T-{N}-01 | {STRIDE category} | {component} | {mitigate / accept / transfer} | {control or reference} | open |
+| Threat ID | Category | Component | Severity | Disposition | Mitigation | Status |
+|-----------|----------|-----------|----------|-------------|------------|--------|
+| T-{N}-01 | {STRIDE category} | {component} | {critical / high / medium / low} | {mitigate / accept / transfer} | {control or reference} | open |
 
-*Status: open · closed*
+*Status: open · closed · open — below {block_on} threshold (non-blocking)*
+*Severity: critical > high > medium > low — only open threats at or above workflow.security_block_on count toward threats_open*
 *Disposition: mitigate (implementation required) · accept (documented risk) · transfer (third-party)*
 
 ---

package/gsd-core/templates/summary-complex.md

@@ -19,6 +19,10 @@ key-decisions:
   - "Decision 1"
 patterns-established:
   - "Pattern 1: description"
+# coverage: (#1602) optional per-deliverable UAT-routing block — see templates/summary.md <coverage_guidance>.
+#   Add live `coverage:` entries (id/description/verification[]/human_judgment[/rationale]) to enable
+#   deterministic UAT routing in verify-work; OMIT for legacy prose-only SUMMARYs. When coverage is
+#   uncertain, default human_judgment: true with a rationale — never auto-skip the human.
 duration: Xmin
 completed: YYYY-MM-DD
 status: complete

package/gsd-core/templates/summary-minimal.md

@@ -13,6 +13,9 @@ key-files:
   created: [important files created]
   modified: [important files modified]
 key-decisions: []
+# coverage: (#1602) optional per-deliverable UAT-routing block — see templates/summary.md <coverage_guidance>.
+#   Add live `coverage:` entries to enable deterministic UAT routing in verify-work; OMIT for legacy
+#   prose-only SUMMARYs. When coverage is uncertain, default human_judgment: true — never auto-skip the human.
 duration: Xmin
 completed: YYYY-MM-DD
 status: complete

package/gsd-core/templates/summary-standard.md

@@ -14,6 +14,10 @@ key-files:
   modified: [important files modified]
 key-decisions:
   - "Decision 1"
+# coverage: (#1602) optional per-deliverable UAT-routing block — see templates/summary.md <coverage_guidance>.
+#   Add live `coverage:` entries (id/description/verification[]/human_judgment[/rationale]) to enable
+#   deterministic UAT routing in verify-work; OMIT for legacy prose-only SUMMARYs. When coverage is
+#   uncertain, default human_judgment: true with a rationale — never auto-skip the human.
 duration: Xmin
 completed: YYYY-MM-DD
 status: complete

package/gsd-core/templates/summary.md

@@ -40,6 +40,24 @@ patterns-established:
 
 requirements-completed: []  # REQUIRED — Copy ALL requirement IDs from this plan's `requirements` frontmatter field.
 
+# Coverage metadata (#1602) — one entry per shipped deliverable. Drives DETERMINISTIC UAT routing in verify-work.
+# OMIT this whole block for legacy/prose-only SUMMARYs — verify-work then falls back to the ## Accomplishments bullets
+# (byte-identical behavior for un-migrated phases). See <coverage_guidance> below for the contract.
+coverage:
+  - id: D1
+    description: "[deliverable in human-readable form — what would have been a prose ## Accomplishments bullet]"
+    requirement: "[REQ-ID from this plan's `requirements`, or omit if none]"
+    verification:
+      - kind: unit            # unit | integration | e2e | automated_ui | manual_procedural | other
+        ref: "[tests/path.test.ts#test name | playwright:shot.png | command invocation]"
+        status: pass          # pass | fail | unknown — from the latest run
+    human_judgment: false     # REQUIRED boolean. false => may auto-pass IF every verification status is `pass`.
+  - id: D2
+    description: "[a deliverable that needs a human to sign off]"
+    verification: []
+    human_judgment: true
+    rationale: "[REQUIRED when human_judgment: true — why automation is insufficient]"
+
 # Metrics
 duration: Xmin
 completed: YYYY-MM-DD
@@ -148,6 +166,29 @@ None - no external service configuration required.
 **Population:** Frontmatter is populated during summary creation in execute-plan.md. See `<step name="create_summary">` for field-by-field guidance.
 </frontmatter_guidance>
 
+<coverage_guidance>
+**Purpose (#1602):** The `coverage:` block is a per-deliverable Requirements Traceability Matrix. It lets `verify-work`'s `extract_tests` step route deliverables DETERMINISTICALLY — auto-passing those proven by passing tests and reserving human UAT for genuine judgment — instead of re-deriving coverage from prose. Consumed via `gsd-tools uat classify-coverage --summary <SUMMARY>`.
+
+**Field semantics:**
+
+| Field | Purpose |
+|---|---|
+| `id` | Stable identifier (`D1`, `D2`…) for cross-referencing from UAT.md and audit reports. Must be unique within the SUMMARY. |
+| `description` | The deliverable in human-readable form — what would have been a prose bullet. |
+| `requirement` | Links back to a REQUIREMENTS.md REQ-ID (joins `requirements-completed`). Optional. |
+| `verification[].kind` | Enum: `unit \| integration \| e2e \| automated_ui \| manual_procedural \| other`. |
+| `verification[].ref` | Test path + descriptor (`file#test name`), Playwright screenshot ref, or command invocation. Required per entry. |
+| `verification[].status` | `pass \| fail \| unknown` — populated from the latest test run. |
+| `human_judgment` | Explicit boolean; REQUIRED. `true` always routes to a human. |
+| `rationale` | REQUIRED when `human_judgment: true`. The audit trail for why automation is insufficient. |
+
+**Deterministic contract (what the classifier does):**
+- A deliverable auto-passes (no human prompt) **only** when `human_judgment: false` AND `verification` is non-empty AND every `verification[].status` is `pass`. This is the narrow, fully-proven case.
+- **Everything else is presented to a human** — `human_judgment: true`, an empty `verification:`, any non-`pass`/`unknown` status, or any schema error. A false-negative is a redundant prompt (the status quo); a false-positive ships a bug UAT existed to catch.
+- **Fail-safe default:** if you cannot determine coverage for a deliverable, you MUST set `human_judgment: true` with `rationale: "Coverage not determined at authoring time — verifier must classify"`. Never leave a deliverable's `human_judgment` empty, and never set it `false` just to skip the prompt — auto-pass additionally requires a passing `verification` entry, so the flag alone cannot skip the human.
+- `coverage: []` means "no deliverables to classify" (the single-confirmation path). OMITTING the block entirely means "legacy" — `verify-work` falls back to prose `## Accomplishments` extraction unchanged.
+</coverage_guidance>
+
 <one_liner_rules>
 The one-liner MUST be substantive:
 

package/gsd-core/workflows/execute-plan.md

@@ -377,6 +377,11 @@ Create `{phase}-{plan}-SUMMARY.md` at `.planning/phases/XX-name/`. Use `~/.claud
 
 **Frontmatter:** phase, plan, subsystem, tags | requires/provides/affects | tech-stack.added/patterns | key-files.created/modified | key-decisions | requirements-completed (**MUST** copy `requirements` array from PLAN.md frontmatter verbatim) | duration ($DURATION), completed ($PLAN_END_TIME date).
 
+**Coverage block (#1602):** Populate the `coverage:` frontmatter block — one entry per shipped deliverable (the structured form of each `## Accomplishments` bullet). For each deliverable, aggregate the task-level `<verify>` results and tests:
+- A task whose `<verify>` command passed or whose matching test passed → a `verification` entry with `kind` + `ref` (`tests/path#name`, Playwright screenshot ref, or command) + `status: pass`, and `human_judgment: false`.
+- A judgment-dependent deliverable (UX adequacy, external/multi-session behavior, anything no test asserts) → `human_judgment: true` with a `rationale`.
+- **Every deliverable MUST be classified.** If you cannot determine coverage, default to `human_judgment: true` with `rationale: "Coverage not determined at authoring time — verifier must classify"`. Never set `human_judgment: false` without a non-empty all-`pass` `verification` — `verify-work` auto-passes (skips the human) ONLY on that proof, so an unproven `false` still routes to the human but loses the audit trail. Omit the whole block only for a genuinely prose-only SUMMARY (verify-work then uses the legacy `## Accomplishments` path). The block is validated downstream by `gsd-tools uat classify-coverage`.
+
 Title: `# Phase [X] Plan [Y]: [Name] Summary`
 
 One-liner SUBSTANTIVE: "JWT auth with refresh rotation using jose library" not "Authentication implemented"

package/gsd-core/workflows/new-project.md

@@ -109,9 +109,9 @@ elif [ -n "$OPENCODE_CONFIG_DIR" ] || [ -n "$OPENCODE_CONFIG" ]; then RUNTIME="o
 else RUNTIME="claude"; fi
 ```
 
-Set the instruction file variable:
+Set the instruction file variable via the shared runtime-name policy adapter (`gsd-tools query project-instruction-file`, backed by `getProjectInstructionFile` in `runtime-name-policy.cjs` — the single source of truth shared with `profile-output.cjs`):
 ```bash
-if [ "$RUNTIME" = "codex" ]; then INSTRUCTION_FILE="AGENTS.md"; else INSTRUCTION_FILE=".claude/CLAUDE.md"; fi
+INSTRUCTION_FILE=$(gsd_run query project-instruction-file --runtime "$RUNTIME")
 ```
 
 All subsequent references to the project instruction file use `$INSTRUCTION_FILE`.
@@ -1533,7 +1533,7 @@ PHASE1_HAS_UI=$(echo "$PHASE1_SECTION" | grep -qi "UI hint.*yes" && echo "true"
 - `.planning/REQUIREMENTS.md`
 - `.planning/ROADMAP.md`
 - `.planning/STATE.md`
-- `$INSTRUCTION_FILE` (`AGENTS.md` for Codex, `.claude/CLAUDE.md` for all other runtimes)
+- `$INSTRUCTION_FILE` (runtime-derived via the shared `getProjectInstructionFile` policy: `AGENTS.md` for codex/opencode/kilo/kimi, `.github/copilot-instructions.md` for copilot, `GEMINI.md` for gemini/antigravity, `.claude/CLAUDE.md` for claude)
 
 </output>
 
@@ -1555,7 +1555,7 @@ PHASE1_HAS_UI=$(echo "$PHASE1_SECTION" | grep -qi "UI hint.*yes" && echo "true"
 - [ ] ROADMAP.md created with phases, requirement mappings, success criteria
 - [ ] STATE.md initialized
 - [ ] REQUIREMENTS.md traceability updated
-- [ ] `$INSTRUCTION_FILE` generated with GSD workflow guidance (AGENTS.md for Codex, `.claude/CLAUDE.md` otherwise; an existing hand-crafted file without GSD markers is left untouched unless `--force`)
+- [ ] `$INSTRUCTION_FILE` generated with GSD workflow guidance (runtime-derived via the shared `getProjectInstructionFile` policy — `AGENTS.md` for codex/opencode/kilo/kimi, `.github/copilot-instructions.md` for copilot, `GEMINI.md` for gemini/antigravity, `.claude/CLAUDE.md` for claude; an existing hand-crafted file without GSD markers is left untouched unless `--force`)
 - [ ] User knows next step is `/gsd:discuss-phase 1`
 
 **Atomic commits:** Each phase commits its artifacts immediately. If context is lost, artifacts persist.

package/gsd-core/workflows/plan-phase.md

@@ -693,6 +693,21 @@ Also available:
 
 **Exit the plan-phase workflow. Do not continue.**
 
+## 5.65. Codebase Map Freshness Pre-Check (drift plan:pre gate)
+
+If `activeHooks` (from `PLAN_PRE_HOOKS_JSON`, §5.6) has a `kind == "gate"`, `capId == "drift"`,
+`check.query == "verify.codebase-drift"` entry (`workflow.plan_drift_precheck` on), run the same check the
+execute gate uses; otherwise skip to step 6:
+
+```bash
+DRIFT=$(gsd_run verify codebase-drift 2>/dev/null || echo '{"skipped":true}')
+```
+
+This gate is **non-blocking** and **never blocks, never spawns** the mapper at plan time. If `skipped` or
+`action_required` is false, continue silently to step 6. If `action_required` is true, print `message`
+verbatim (it ends with a `/gsd:map-codebase` pointer) and continue — planning proceeds whether or not the
+map is refreshed first. (`drift_action: auto-remap` stays at `execute:wave:post`.)
+
 ## 6. Check Existing Plans
 
 ```bash

package/gsd-core/workflows/secure-phase.md

@@ -27,6 +27,8 @@ Parse: `phase_dir`, `phase_number`, `phase_name`, `phase_slug`, `padded_phase`.
 ```bash
 AUDITOR_MODEL=$(gsd_run query resolve-model gsd-security-auditor --raw)
 VERIFY_POST_HOOKS_JSON=$(gsd_run loop render-hooks verify:post --raw)
+SECURITY_ASVS=$(gsd_run query config-get workflow.security_asvs_level --raw 2>/dev/null || echo "1")
+SECURITY_BLOCK_ON=$(gsd_run query config-get workflow.security_block_on --raw 2>/dev/null || echo "high")
 ```
 
 Resolve active step hooks from `VERIFY_POST_HOOKS_JSON` where `kind == "step"` and `ref.skill == "secure-phase"`.
@@ -51,7 +53,7 @@ SUMMARY_FILES=$(ls "${PHASE_DIR}"/*-SUMMARY.md 2>/dev/null)
 
 ### 2a. Read Phase Artifacts
 
-Read PLAN.md — extract `<threat_model>` block: trust boundaries, STRIDE register (`threat_id`, `category`, `component`, `disposition`, `mitigation_plan`).
+Read PLAN.md — extract `<threat_model>` block: trust boundaries, STRIDE register (`threat_id`, `category`, `component`, `severity`, `disposition`, `mitigation_plan`).
 
 ### 2b. Read Summary Threat Flags
 
@@ -59,7 +61,7 @@ Read SUMMARY.md — extract `## Threat Flags` entries.
 
 ### 2c. Build Threat Register
 
-Per threat: `{ threat_id, category, component, disposition, mitigation_pattern, files_to_check }`
+Per threat: `{ threat_id, category, component, severity, disposition, mitigation_pattern, files_to_check }`
 
 Also set `register_authored_at_plan_time: true` if **at least one** PLAN file contained a parseable `<threat_model>` block; `false` if no PLAN files had any `<threat_model>` block (legacy phase authored before formal threat modelling was standard).
 
@@ -72,10 +74,11 @@ Classify each threat:
 | CLOSED | mitigation found OR accepted risk documented in SECURITY.md OR transfer documented |
 | OPEN | none of the above |
 
-Build: `{ threat_id, category, component, disposition, status, evidence }`
+Build: `{ threat_id, category, component, severity, disposition, status, evidence }`
 
 **Short-circuit rule:**
-- If `threats_open: 0 AND register_authored_at_plan_time: true` → skip to Step 6 directly. All plan-time threats are verified CLOSED.
+- If `threats_open: 0 AND register_authored_at_plan_time: true AND asvs_level == 1` → skip to Step 6 directly. No open threats at or above the block threshold remain (threats_open: 0); below-threshold open threats may remain and are non-blocking. L1 grep-depth is sufficient; no deeper verification required.
+- If `threats_open: 0 AND register_authored_at_plan_time: true AND asvs_level >= 2` → **do NOT skip**. The preliminary threat classification is grep-level (L1 depth) and is insufficient for L2/L3. Proceed to Step 5 (spawn the auditor) so that L2 boundary-placement checks and L3 end-to-end trace checks are performed. Skipping the auditor here would defeat ASVS level scaling for "clean" phases.
 - If `threats_open: 0 AND register_authored_at_plan_time: false` → **do NOT skip**. Empty-by-no-planning must not rubber-stamp a clean SECURITY.md. Proceed to Step 5 in **retroactive-STRIDE mode** — the auditor builds a register from implementation files first, then verifies mitigations.
 - If `threats_open > 0` → proceed to Step 4 (present threat plan to user).
 
@@ -95,6 +98,8 @@ Call AskUserQuestion with threat table and options:
 - `register_authored_at_plan_time: true` — **Verify mitigations exist** — do not scan for new threats. The register is complete; verify each threat's mitigation is present in the implementation.
 - `register_authored_at_plan_time: false` (retroactive-STRIDE mode) — **Retroactive-STRIDE: build a STRIDE register from implementation files first, then verify mitigations.** The phase was authored before formal threat modelling; the auditor must construct the register from scratch before verifying.
 
+Substitute `{SECURITY_ASVS}` with the value of `$SECURITY_ASVS` and `{SECURITY_BLOCK_ON}` with the value of `$SECURITY_BLOCK_ON` resolved in Step 0 via `config-get`.
+
 Print: `◆ Spawning security auditor... (runs in a subagent — no output until it returns, ~1–5 min; expected, not a freeze)`
 
 ```
@@ -141,7 +146,7 @@ Handle return:
 
 ```
 GSD > PHASE {N} SECURITY BLOCKED
-{K} threats open — phase advancement blocked until threats_open: 0
+{K} blocking threats open — phase advancement blocked until threats_open: 0
 ▶ Fix mitigations then re-run: /gsd:secure-phase {N}
 ▶ Or document accepted risks in SECURITY.md and re-run.
 ```
@@ -159,7 +164,7 @@ gsd_run query commit "docs(phase-${PHASE}): add/update security threat verificat
 **Secured (threats_open: 0):**
 ```
 GSD > PHASE {N} THREAT-SECURE
-threats_open: 0 — all threats have dispositions.
+threats_open: 0 — no blocking threats remain (threats_open: 0).
 ▶ /gsd:validate-phase {N}    validate test coverage
 ▶ /gsd:verify-work {N}       run UAT
 ```
@@ -173,7 +178,8 @@ Display `/clear` reminder.
 - [ ] Input state detected (A/B/C) — state C exits cleanly
 - [ ] PLAN.md threat model parsed, register built
 - [ ] SUMMARY.md threat flags incorporated
-- [ ] threats_open: 0 AND register_authored_at_plan_time: true → skip directly to Step 6
+- [ ] threats_open: 0 AND register_authored_at_plan_time: true AND asvs_level == 1 → skip directly to Step 6 (L1 grep-depth sufficient)
+- [ ] threats_open: 0 AND register_authored_at_plan_time: true AND asvs_level >= 2 → do NOT skip; auditor spawned for L2/L3 deep verification
 - [ ] threats_open: 0 AND register_authored_at_plan_time: false → retroactive-STRIDE mode (Step 5), not skipped
 - [ ] User gate with threat table presented
 - [ ] Auditor spawned with complete context

package/gsd-core/workflows/verify-work.md

@@ -178,7 +178,24 @@ fi
 
 The verb owns the canonical regex `/^As a .+, I want to .+, so that .+\.$/` and returns slot extractions plus per-error guidance when invalid. Halt UAT generation on failure — never attempt to derive user-flow steps from a non-User-Story goal (low-quality UAT).
 
-**Extract testable deliverables from SUMMARY.md:**
+**Coverage-aware deterministic classification (#1602).** Before deriving checkpoints from prose, classify each SUMMARY's structured `coverage:` block. For each `*-SUMMARY.md`:
+
+```bash
+COVERAGE=$(gsd_run query uat.classify-coverage --summary "$SUMMARY_FILE")
+```
+
+Read the JSON result (`mode`, `total`, `all_auto_covered`, `auto_passed[]`, `present[]`, `errors[]`):
+
+- **`mode: legacy`** (no `coverage:` block, OR a malformed block that could not be parsed) → **fall through** to the prose-based extraction below. Behavior is byte-identical to pre-#1602 for un-migrated SUMMARYs; do NOT auto-pass anything. If `errors[]` is non-empty (a `malformed_block`), note the broken coverage block to the user before proceeding so the SUMMARY can be fixed.
+- **`mode: coverage`** →
+  - Each `auto_passed[]` entry is recorded in UAT.md as `result: pass`, `source: automated` (see `create_uat_file`) — **do not present it as a checkpoint.** It is deterministically covered by the passing tests in its `verification` refs.
+  - Each `present[]` entry becomes a human UAT checkpoint: use its `description` as the test and carry its `rationale` into the checkpoint context. The `reason` (`human_judgment` / `no_verification` / `verification_not_passing` / `validation_failed`) explains why a human is needed.
+  - If `all_auto_covered` is `true` (every entry auto-passed, including the `coverage: []` case) → do NOT generate zero checkpoints; present a **single confirmation summary** listing the auto-covered deliverables with their covering tests and ask the user to confirm.
+  - Surface any `errors[]` to the user (malformed coverage block) but still treat their entries as human checkpoints — **never drop a deliverable** (fail-safe).
+
+The cold-start smoke test injection below still applies in `coverage` mode.
+
+**Extract testable deliverables from SUMMARY.md (legacy fallback — used when `mode: legacy`):**
 
 Parse for:
 1. **Accomplishments** - Features/functionality added
@@ -252,6 +269,18 @@ result: [pending]
 
 ...
 
+**Coverage auto-passed entries (#1602):** for each `auto_passed[]` entry from `uat classify-coverage`, write a Tests entry pre-resolved as automated — these are NOT presented to the user:
+
+```
+### N. [coverage description]
+expected: [coverage description]
+result: pass
+source: automated
+coverage_id: [D-id]
+```
+
+The `source: automated` marker is additive — existing consumers that read only `result:` are unaffected.
+
 ## Summary
 
 total: [N]

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@opengsd/gsd-core",
-  "version": "1.6.0-rc.2",
+  "version": "1.6.0-rc.3",
   "description": "GSD Core is a meta-prompting, context engineering, and spec-driven development system for AI coding agents.",
   "bin": {
     "gsd-core": "bin/install.js",
@@ -10,6 +10,7 @@
   "files": [
     "bin",
     "commands",
+    "skills",
     "gsd-core",
     "assets",
     "agents",
@@ -78,11 +79,12 @@
     "check:alias-drift": "node scripts/check-alias-drift.cjs",
     "check:identity-drift": "node scripts/lint-package-identity-drift.cjs",
     "check:integrity": "node scripts/check-npm-integrity.cjs",
-    "build": "npm run generate:identity && npm run build:lib && npm run gen:loop-host-contract && npm run gen:capability-registry && npm run build:hooks",
+    "build": "npm run generate:identity && npm run build:lib && npm run gen:plugin-skills && npm run gen:loop-host-contract && npm run gen:capability-registry && npm run build:hooks",
     "build:hooks": "node scripts/build-hooks.js",
     "build:lib": "tsc -p tsconfig.build.json",
     "generate:identity": "node scripts/generate-package-identity.cjs",
     "gen:loop-host-contract": "node scripts/gen-loop-host-contract.cjs --write",
+    "gen:plugin-skills": "node scripts/gen-plugin-skills.cjs --write",
     "gen:capability-registry": "node scripts/gen-capability-registry.cjs --write",
     "prepack": "npm run build:lib",
     "prepare": "npm run build:lib",

package/scripts/gen-plugin-skills.cjs

@@ -0,0 +1,117 @@
+#!/usr/bin/env node
+'use strict';
+
+/**
+ * gen-plugin-skills.cjs — generates skills/gsd-<stem>/SKILL.md from
+ * commands/gsd/*.md using convertClaudeCommandToClaudeSkill.
+ *
+ * Usage:
+ *   node scripts/gen-plugin-skills.cjs              # print summary to stdout
+ *   node scripts/gen-plugin-skills.cjs --write      # write skills/ dir
+ *   node scripts/gen-plugin-skills.cjs --check      # exit 1 if committed skills/ is stale
+ *
+ * #1596 Phase B-provide. The Claude Code plugin contract discovers skills from
+ * a skills/ directory (plugins-reference). GSD's source-of-truth commands live
+ * in commands/gsd/*.md (command frontmatter); this script converts each to
+ * skill format using the same convertClaudeCommandToClaudeSkill the file-copy
+ * installer uses, producing a build-generated skills/ dir that ships in the
+ * npm package and serves plugin-only installs.
+ *
+ * Depends on: gsd-core/bin/lib/runtime-artifact-conversion.cjs (compiled from
+ * src/runtime-artifact-conversion.cts by `npm run build:lib`). Must run AFTER
+ * build:lib in the build chain.
+ */
+
+const fs = require('node:fs');
+const path = require('node:path');
+const { ExitError, runMain } = require('./lib/cli-exit.cjs');
+
+const ROOT = path.resolve(__dirname, '..');
+const COMMANDS_DIR = path.join(ROOT, 'commands', 'gsd');
+const SKILLS_DIR = path.join(ROOT, 'skills');
+const CONVERSION_MODULE = path.join(ROOT, 'gsd-core', 'bin', 'lib', 'runtime-artifact-conversion.cjs');
+const PREFIX = 'gsd-';
+const RUNTIME = 'claude';
+
+function generateSkills(conversion) {
+  const cmdNames = conversion.readGsdCommandNames();
+  const files = fs.readdirSync(COMMANDS_DIR).filter(f => f.endsWith('.md'));
+  const results = [];
+  for (const file of files) {
+    const stem = file.slice(0, -3);
+    const skillName = PREFIX + stem;
+    const src = fs.readFileSync(path.join(COMMANDS_DIR, file), 'utf8');
+    const converted = conversion.convertClaudeCommandToClaudeSkill(src, skillName, RUNTIME, cmdNames, true);
+    results.push({ skillName, content: converted });
+  }
+  return results;
+}
+
+function main() {
+  const args = new Set(process.argv.slice(2));
+  const WRITE = args.has('--write');
+  const CHECK = args.has('--check');
+
+  if (!fs.existsSync(CONVERSION_MODULE)) {
+    throw new ExitError(
+      1,
+      `gen-plugin-skills: ${path.relative(ROOT, CONVERSION_MODULE)} not found.\n` +
+      'Run `npm run build:lib` first (this script depends on the compiled converter).'
+    );
+  }
+  const conversion = require(CONVERSION_MODULE);
+  const results = generateSkills(conversion);
+
+  if (WRITE) {
+    fs.rmSync(SKILLS_DIR, { recursive: true, force: true });
+    fs.mkdirSync(SKILLS_DIR, { recursive: true });
+    for (const { skillName, content } of results) {
+      const skillDir = path.join(SKILLS_DIR, skillName);
+      fs.mkdirSync(skillDir, { recursive: true });
+      fs.writeFileSync(path.join(skillDir, 'SKILL.md'), content);
+    }
+    process.stdout.write(`gen-plugin-skills: wrote ${results.length} skills to ${path.relative(ROOT, SKILLS_DIR)}/\n`);
+    return 0;
+  }
+
+  if (CHECK) {
+    if (!fs.existsSync(SKILLS_DIR)) {
+      throw new ExitError(1, 'gen-plugin-skills: skills/ missing. Run: npm run gen:plugin-skills -- --write');
+    }
+    let stale = 0;
+    const expectedNames = new Set(results.map(r => r.skillName));
+    for (const { skillName, content } of results) {
+      const skillMd = path.join(SKILLS_DIR, skillName, 'SKILL.md');
+      if (!fs.existsSync(skillMd)) {
+        process.stderr.write(`gen-plugin-skills: missing ${path.relative(ROOT, skillMd)}\n`);
+        stale++;
+        continue;
+      }
+      if (fs.readFileSync(skillMd, 'utf8') !== content) {
+        process.stderr.write(`gen-plugin-skills: stale ${path.relative(ROOT, skillMd)}\n`);
+        stale++;
+      }
+    }
+    const existingDirs = fs.readdirSync(SKILLS_DIR, { withFileTypes: true })
+      .filter(e => e.isDirectory() && e.name.startsWith(PREFIX));
+    for (const dir of existingDirs) {
+      if (!expectedNames.has(dir.name)) {
+        process.stderr.write(`gen-plugin-skills: stale (no source) ${path.relative(ROOT, path.join(SKILLS_DIR, dir.name))}\n`);
+        stale++;
+      }
+    }
+    if (stale > 0) {
+      throw new ExitError(1, `gen-plugin-skills: ${stale} stale skill(s). Run: npm run gen:plugin-skills -- --write`);
+    }
+    process.stdout.write(`gen-plugin-skills: ${results.length} skills up to date\n`);
+    return 0;
+  }
+
+  process.stdout.write(
+    `gen-plugin-skills: would write ${results.length} skills to ${path.relative(ROOT, SKILLS_DIR)}/\n` +
+    '  (use --write to generate, --check to verify staleness)\n'
+  );
+  return 0;
+}
+
+runMain(main);