gsd-pi 2.77.0 → 2.78.0-dev.aeeb2ca00

package/dist/resources/extensions/gsd/notifications.js

@@ -2,7 +2,6 @@
 // Cross-platform desktop notifications for auto-mode events.
 import { execFileSync } from "node:child_process";
 import { loadEffectiveGSDPreferences } from "./preferences.js";
-import { CmuxClient, emitOsc777Notification, resolveCmuxConfig } from "../cmux/index.js";
 import { sendRemoteNotification } from "../remote-questions/notify.js";
 /**
  * Send a native desktop notification. Non-blocking, non-fatal.
@@ -20,22 +19,37 @@ export function sendDesktopNotification(title, message, level = "info", kind = "
     void sendRemoteNotification(title, message).catch(() => { });
     if (!shouldSendDesktopNotification(kind, loaded?.notifications))
         return;
-    const cmux = resolveCmuxConfig(loaded);
-    if (cmux.notifications) {
-        const delivered = CmuxClient.fromPreferences(loaded).notify(title, message);
-        if (delivered)
-            return;
-        emitOsc777Notification(title, message);
-    }
-    try {
-        const command = buildDesktopNotificationCommand(process.platform, title, message, level);
-        if (!command)
+    // cmux delivery and desktop delivery are independent — if cmux import or
+    // delivery fails, we must still attempt the native desktop notification.
+    const runCmux = async () => {
+        try {
+            const { CmuxClient, emitOsc777Notification, resolveCmuxConfig } = await import("../cmux/index.js");
+            const cmux = resolveCmuxConfig(loaded);
+            if (cmux.notifications) {
+                const delivered = CmuxClient.fromPreferences(loaded).notify(title, message);
+                if (delivered)
+                    return true;
+                emitOsc777Notification(title, message);
+            }
+        }
+        catch {
+            // cmux unavailable — fall through to desktop notification
+        }
+        return false;
+    };
+    void runCmux().then((deliveredByCmux) => {
+        if (deliveredByCmux)
             return;
-        execFileSync(command.file, command.args, { timeout: 3000, stdio: "ignore" });
-    }
-    catch {
-        // Non-fatal — desktop notifications are best-effort
-    }
+        try {
+            const command = buildDesktopNotificationCommand(process.platform, title, message, level);
+            if (!command)
+                return;
+            execFileSync(command.file, command.args, { timeout: 3000, stdio: "ignore" });
+        }
+        catch {
+            // Non-fatal — desktop notifications are best-effort
+        }
+    }).catch(() => { });
 }
 export function shouldSendDesktopNotification(kind, preferences = loadEffectiveGSDPreferences()?.preferences.notifications) {
     if (preferences?.enabled === false)

package/dist/resources/extensions/gsd/preferences-validation.js

@@ -1031,6 +1031,29 @@ export function validatePreferences(preferences) {
         if (g.merge_to_main !== undefined) {
             warnings.push("git.merge_to_main is deprecated — milestone-level merge is now always used. Remove this setting.");
         }
+        // #4765 — collapse cadence + milestone resquash
+        if (g.collapse_cadence !== undefined) {
+            const validCadence = new Set(["milestone", "slice"]);
+            if (typeof g.collapse_cadence === "string" && validCadence.has(g.collapse_cadence)) {
+                git.collapse_cadence = g.collapse_cadence;
+            }
+            else {
+                errors.push("git.collapse_cadence must be one of: milestone, slice");
+            }
+        }
+        if (g.milestone_resquash !== undefined) {
+            if (typeof g.milestone_resquash === "boolean") {
+                git.milestone_resquash = g.milestone_resquash;
+                const cadence = git.collapse_cadence
+                    ?? (typeof g.collapse_cadence === "string" ? g.collapse_cadence : undefined);
+                if (cadence !== "slice") {
+                    warnings.push('git.milestone_resquash is ignored unless git.collapse_cadence is "slice"');
+                }
+            }
+            else {
+                errors.push("git.milestone_resquash must be a boolean");
+            }
+        }
         if (Object.keys(git).length > 0) {
             validated.git = git;
         }

package/dist/resources/extensions/gsd/prompt-cache-optimizer.js

@@ -24,6 +24,10 @@ const SEMI_STATIC_LABELS = new Set([
     "prior-summaries",
     "project-context",
     "overrides",
+    // KNOWLEDGE is milestone-scoped (stable within a session), so it belongs
+    // in the cacheable prefix. See issue #4719.
+    "knowledge",
+    "project-knowledge",
 ]);
 /** Labels that change per-task */
 const DYNAMIC_LABELS = new Set([

package/dist/resources/extensions/gsd/prompts/complete-milestone.md

@@ -10,14 +10,18 @@ Your working directory is `{{workingDirectory}}`. All file reads, writes, and sh
 
 All slices are done. You are closing out the milestone — verifying that the assembled work actually delivers the promised outcome, writing the milestone summary, and updating project state. The milestone summary is the final record. After you finish, the system merges the worktree back to the integration branch. If there are queued milestones, the next one starts its own research → plan → execute cycle from a clean slate — the milestone summary is how it learns what was already built.
 
-All relevant context has been preloaded below — the roadmap, all slice summaries, requirements, decisions, and project context are inlined. Start working immediately without re-reading these files.
+Preloaded context below — the roadmap, compact slice-summary excerpts, requirements, decisions, and project context. **Slice summaries are excerpts, not full files.** They include frontmatter fields, section heads (deviations, known limitations, follow-ups), and short narrative only. When drafting LEARNINGS, the Decision Re-evaluation table, or cross-slice narrative, Read the full slice SUMMARY.md files listed under "On-demand Slice Summaries" — do that selectively as needed, not preemptively.
+
+Start with what the excerpts give you. Read full files when the section heads signal richer context you need.
+
+**On-demand Read ordering:** Complete all slice SUMMARY Reads you need for cross-slice synthesis, the Decision Re-evaluation table, and LEARNINGS **before** calling `gsd_complete_milestone` (step 10). Once that tool runs, the milestone is marked complete in the DB — running out of tool budget between step 10 and the LEARNINGS write (step 12) leaves the milestone committed without its LEARNINGS artifact.
 
 {{inlinedContext}}
 
 Then:
 1. Use the **Milestone Summary** output template from the inlined context above
 2. {{skillActivation}}
-3. **Verify code changes exist.** Run `git diff --stat HEAD $(git merge-base HEAD main) -- ':!.gsd/'` (or the equivalent for the integration branch). If no non-`.gsd/` files appear in the diff, the milestone produced only planning artifacts and no actual code. Record this as a **verification failure**.
+3. **Verify code changes exist.** Compare the milestone against its integration branch (usually `main`, `master`, or the recorded integration branch), using the merge-base as the older revision and `HEAD` as the newer revision. If that branch diff lists non-`.gsd/` files, code-change verification passes. If `HEAD` is already the same commit as the integration branch/merge-base (a retry-on-main self-diff), do **not** treat the empty branch diff as proof of missing code. Instead, inspect milestone-scoped commit evidence such as recent commits with `GSD-Unit: {{milestoneId}}` or production `GSD-Task: Sxx/Tyy` trailers whose diff also touches `.gsd/milestones/{{milestoneId}}/`, then check those commits for non-`.gsd/` files. Only record a **verification failure** when neither the branch diff nor milestone-scoped commit evidence shows implementation files.
 4. Verify each **success criterion** from the milestone definition in `{{roadmapPath}}`. For each criterion, confirm it was met with specific evidence from slice summaries, test results, or observable behavior. Record any criterion that was NOT met as a **verification failure**.
 5. Verify the milestone's **definition of done** — all slices are `[x]`, all slice summaries exist, and any cross-slice integration points work correctly. Record any unmet items as a **verification failure**.
 6. If the roadmap includes a **Horizontal Checklist**, verify each item was addressed during the milestone. Note unchecked items in the milestone summary.

package/dist/resources/extensions/gsd/prompts/discuss-headless.md

@@ -164,9 +164,18 @@ Preserve the specification's exact terminology, emphasis, and specific framing.
 
 ### Ready-phrase pre-condition (NON-BYPASSABLE)
 
-Before emitting the ready phrase, verify in the CURRENT turn that you have written `.gsd/PROJECT.md`, `.gsd/REQUIREMENTS.md`, `{{contextPath}}`, and called `gsd_plan_milestone`. If any is missing, **STOP** — emit the missing tool calls in this same turn. The system rejects premature ready signals and retries are capped.
+Before emitting the ready phrase, verify in the CURRENT turn that you have:
 
-After writing the files, say exactly: "Milestone {{milestoneId}} ready." — nothing else. Auto-mode will start automatically.
+- [ ] Written `.gsd/PROJECT.md` (step 2)
+- [ ] Written `.gsd/REQUIREMENTS.md` (step 3)
+- [ ] Written `{{contextPath}}` (step 4)
+- [ ] Called `gsd_plan_milestone` (step 5)
+
+If ANY box is unchecked, **STOP**. Do NOT emit the ready phrase. Emit the missing tool calls in this same turn. The system detects missing artifacts and will reject premature ready signals — you will be asked again and retries are capped.
+
+Do not announce the ready phrase as something you are "about to" do. Do not narrate "now writing the files" as a substitute for actually writing them. The ready phrase is a post-write signal, not an intent signal.
+
+After completing steps 1–7 above, say exactly: "Milestone {{milestoneId}} ready." — nothing else. Auto-mode will start automatically.
 
 ### Multi-Milestone
 
@@ -240,9 +249,19 @@ For single-milestone projects, do NOT write this file.
 
 ### Ready-phrase pre-condition (NON-BYPASSABLE)
 
-Before emitting the ready phrase, verify in the CURRENT turn that you have written `.gsd/PROJECT.md`, `.gsd/REQUIREMENTS.md`, the primary `CONTEXT.md`, called `gsd_plan_milestone` for the primary milestone, and written `.gsd/DISCUSSION-MANIFEST.json` with `gates_completed === total`. If any is missing, **STOP** — emit the missing tool calls in this same turn. The system rejects premature ready signals and retries are capped.
+Before emitting the ready phrase, verify in the CURRENT turn that you have:
+
+- [ ] Written `.gsd/PROJECT.md`
+- [ ] Written `.gsd/REQUIREMENTS.md`
+- [ ] Written the primary milestone `CONTEXT.md`
+- [ ] Called `gsd_plan_milestone` for the primary milestone
+- [ ] Written `.gsd/DISCUSSION-MANIFEST.json` with `gates_completed === total`
+
+If ANY box is unchecked, **STOP**. Do NOT emit the ready phrase. Emit the missing tool calls in this same turn. The system detects missing artifacts and will reject premature ready signals — you will be asked again and retries are capped.
+
+Do not announce the ready phrase as something you are "about to" do. Do not narrate "now writing the files" as a substitute for actually writing them. The ready phrase is a post-write signal, not an intent signal.
 
-After writing the files, say exactly: "Milestone {{milestoneId}} ready." — nothing else. Auto-mode will start automatically.
+After completing every step above, say exactly: "Milestone {{milestoneId}} ready." — nothing else. Auto-mode will start automatically.
 
 ## Critical Rules
 

package/dist/resources/extensions/gsd/prompts/doctor-heal.md

@@ -7,9 +7,10 @@ Rules:
 2. Read before edit.
 3. Prefer fixing authoritative artifacts over masking warnings.
 4. For missing summaries or UAT files, generate the real artifact from existing slice/task context when possible — do not leave placeholders if you can reconstruct the real content.
-5. After each repair cluster, verify the relevant invariant directly from disk.
-6. When done, rerun `/gsd doctor {{doctorCommandSuffix}}` mentally by ensuring the remaining issue set for this scope is reduced or cleared.
-7. Do NOT query `.gsd/gsd.db` directly via `sqlite3` or `node -e require('better-sqlite3')` — use `gsd_milestone_status` to inspect DB state. Direct access bypasses the WAL connection owned by the engine and can corrupt in-flight writes.
+5. For a missing milestone `CONTEXT.md` when the milestone is already past `pre-planning` (phase is `executing`, `summarizing`, `validating-milestone`, or `completing-milestone`): the artifact was skipped during bootstrap and must be reconstructed before execution can resume. Read `PROJECT.md`, `REQUIREMENTS.md`, the milestone's `ROADMAP.md`, and any slice-level context on disk, then write `.gsd/milestones/<milestone-id>/<milestone-id>-CONTEXT.md` with the real context for the scoped milestone. Do not leave a stub — the plan gate will reject it on the next cycle.
+6. After each repair cluster, verify the relevant invariant directly from disk.
+7. When done, rerun `/gsd doctor {{doctorCommandSuffix}}` mentally by ensuring the remaining issue set for this scope is reduced or cleared.
+8. Do NOT query `.gsd/gsd.db` directly via `sqlite3` or `node -e require('better-sqlite3')` — use `gsd_milestone_status` to inspect DB state. Direct access bypasses the WAL connection owned by the engine and can corrupt in-flight writes.
 
 ## Doctor Summary
 
@@ -27,4 +28,4 @@ Then:
 - Repair the unresolved issues in scope
 - Keep changes minimal and targeted
 - If unresolved issues remain outside scope, leave them untouched and mention them briefly
-- End with: "GSD doctor heal complete."
+- End with: "GSD doctor heal complete."

package/dist/resources/extensions/gsd/prompts/plan-slice.md

@@ -20,9 +20,22 @@ Pay particular attention to **Forward Intelligence** sections — they contain h
 
 You have full tool access. Before decomposing, explore the relevant code to ground your plan in reality.
 
-### Verify Roadmap Assumptions
+### Verify Roadmap Assumptions (JIT Reassessment — ADR-003 §4)
 
-Check prior slice summaries (inlined above as dependency summaries, if present). If prior slices discovered constraints, changed approaches, or flagged fragility, adjust your plan accordingly. The roadmap description may be stale — verify it against the current codebase state.
+Before planning this slice, verify that the roadmap's assumptions still hold given prior slice summaries. Check inlined dependency summaries (below) for discovered constraints, changed approaches, or flagged fragility.
+
+**If the remaining roadmap needs adjustment, modify it before proceeding:**
+
+- If a downstream slice's title/demo/dependencies are now wrong, call `gsd_reassess_roadmap` with the corrected `sliceChanges.modified` entry.
+- If new work surfaced that deserves its own slice, add it via `sliceChanges.added`.
+- If a downstream slice is now redundant or out of scope, remove it via `sliceChanges.removed`.
+- **Bias strongly toward "roadmap is fine."** Most slice completions produce no structural change. Only adjust when there is concrete evidence a downstream slice is wrong — not speculative concern. Over-reassessment is costlier than a later mid-slice replan.
+
+Completed slices are immutable: never modify or remove a slice whose status is complete.
+
+Then proceed with planning this slice against the (possibly updated) roadmap.
+
+The roadmap description may be stale — verify it against the current codebase state.
 
 ### Explore Slice Scope
 

package/dist/resources/extensions/gsd/prompts/system.md

@@ -213,6 +213,7 @@ Fix the root cause, not symptoms. When applying a temporary mitigation, label it
 - State uncertainty plainly: "Not sure this handles X - testing it." No performed confidence, no hedging paragraphs.
 - All user-visible narration must be grammatical English. Do not emit compressed planner notes like "Need inspect X" or "Maybe read Y first". If it would look acceptable in a commit comment or standup note, it's acceptable here.
 - When debugging, stay curious. Problems are puzzles. Say what's interesting about the failure before reaching for fixes.
+- After completing a task, give a brief completion summary and present 2-4 contextual next-step options as a numbered list (the last option is always "Other"). This reduces cognitive load by letting the user pick rather than formulate what's next. Omit the numbered list when the response must follow a strict output format (JSON, patches, commit messages, structured data).
 
 Good narration: "Three existing handlers follow a middleware pattern - using that instead of a custom wrapper."
 Good narration: "Tests pass. Running slice-level verification."

package/dist/resources/extensions/gsd/reports.js

@@ -13,8 +13,9 @@
  * Auto-triggered: after each milestone completion (when auto_report: true).
  * Manual: /gsd export --html
  */
-import { writeFileSync, readFileSync, mkdirSync, existsSync } from 'node:fs';
+import { readFileSync, mkdirSync, existsSync } from 'node:fs';
 import { join } from 'node:path';
+import { atomicWriteSync } from './atomic-write.js';
 import { gsdRoot } from './paths.js';
 import { formatCost, formatTokenCount } from './metrics.js';
 import { formatDateShort, formatDuration } from '../shared/format-utils.js';
@@ -43,7 +44,7 @@ export function loadReportsIndex(basePath) {
 function saveReportsIndex(basePath, index) {
     const dir = reportsDir(basePath);
     mkdirSync(dir, { recursive: true });
-    writeFileSync(reportsIndexPath(basePath), JSON.stringify(index, null, 2) + '\n', 'utf-8');
+    atomicWriteSync(reportsIndexPath(basePath), JSON.stringify(index, null, 2) + '\n', 'utf-8');
 }
 /**
  * Write a report snapshot to .gsd/reports/, update reports.json, regenerate index.html.
@@ -56,7 +57,7 @@ export function writeReportSnapshot(args) {
     const prefix = args.milestoneId === 'final' ? 'final' : args.milestoneId;
     const filename = `${prefix}-${timestamp}.html`;
     const filePath = join(dir, filename);
-    writeFileSync(filePath, args.html, 'utf-8');
+    atomicWriteSync(filePath, args.html, 'utf-8');
     // Load or init registry
     const existing = loadReportsIndex(args.basePath);
     const index = existing ?? {
@@ -97,7 +98,7 @@ export function writeReportSnapshot(args) {
 // ─── HTML Index Generator ─────────────────────────────────────────────────────
 export function regenerateHtmlIndex(basePath, index) {
     const html = buildIndexHtml(index);
-    writeFileSync(reportsHtmlIndexPath(basePath), html, 'utf-8');
+    atomicWriteSync(reportsHtmlIndexPath(basePath), html, 'utf-8');
 }
 function buildIndexHtml(index) {
     const { projectName, projectPath, gsdVersion, entries } = index;

package/dist/resources/extensions/gsd/safety/git-checkpoint.js

@@ -58,6 +58,17 @@ export function rollbackToCheckpoint(basePath, unitId, sha) {
             logWarning("safety", "rollback: detached HEAD state, cannot rollback");
             return false;
         }
+        // Preserve any staged or untracked user work before the hard reset.
+        // The user may have a partial fix staged that they wanted to inspect;
+        // reset --hard wipes both staged and unstaged changes (reflog only
+        // covers committed state). Push a labeled stash first so recovery
+        // is possible. (Issue #4980 HIGH-4)
+        try {
+            execFileSync("git", ["stash", "push", "--include-untracked", "-m", `gsd: pre-rollback-stash ${unitId} ${new Date().toISOString()}`], { cwd: basePath, stdio: ["ignore", "pipe", "pipe"], encoding: "utf-8" });
+        }
+        catch {
+            /* nothing to stash, or stash refused — proceed with reset */
+        }
         // Reset branch pointer and working tree to checkpoint SHA in one step.
         // Using `git reset --hard <sha>` works on the currently checked-out branch
         // (unlike `git branch -f` which is rejected for checked-out branches).

package/dist/resources/extensions/gsd/service-tier.js

@@ -2,8 +2,8 @@
  * Service Tier — gating, status formatting, icon resolution, and
  * the /gsd fast command handler.
  *
- * Service tiers (priority/flex) are an OpenAI feature that only applies
- * to gpt-5.4 variants. This module centralizes the model-gating logic
+ * Service tiers (priority/flex) are an OpenAI feature that currently only
+ * applies to gpt-5.4 variants in GSD. This module centralizes the model-gating logic
  * so that icons, preferences, and the before_provider_request hook all
  * use a single source of truth.
  */
@@ -21,6 +21,9 @@ const SERVICE_TIER_SCOPE_NOTE = "Only affects gpt-5.4 models, regardless of prov
  * (set via CAPABILITY_PATCHES in packages/pi-ai/src/models.ts). When callers
  * have access to the full Model object, prefer reading capabilities directly.
  *
+ * GPT-5.5 is intentionally excluded until we verify its provider payload
+ * contract instead of assuming `service_tier` support.
+ *
  * See: https://github.com/gsd-build/gsd-2/issues/2546
  */
 const SERVICE_TIER_MODEL_PREFIXES = ["gpt-5.4"];

package/dist/resources/extensions/gsd/session-lock.js

@@ -138,15 +138,16 @@ function ensureExitHandler(_gsdDir) {
         // Lock files accumulate across main project .gsd/, worktree .gsd/,
         // and projects registry paths — cleanup must cover all of them.
         for (const dir of _lockDirRegistry) {
+            const lockFile = join(dir, LOCK_FILE);
+            const ownsRegisteredLock = isLockFileOwnedByCurrentProcess(lockFile);
             try {
-                const lockFile = join(dir, LOCK_FILE);
-                if (existsSync(lockFile))
+                if (ownsRegisteredLock && existsSync(lockFile))
                     unlinkSync(lockFile);
             }
             catch { /* best-effort */ }
             try {
                 const lockDir = join(dir + ".lock");
-                if (existsSync(lockDir))
+                if (ownsRegisteredLock && existsSync(lockDir))
                     rmSync(lockDir, { recursive: true, force: true });
             }
             catch { /* best-effort */ }
@@ -447,10 +448,13 @@ export function releaseSessionLock(basePath) {
         }
         _releaseFunction = null;
     }
-    // Remove the lock file at the current path
+    // Remove the lock file at the current path only if it still belongs to us.
+    // Lost-lock cleanup can run after another process has taken ownership; in
+    // that case deleting auto.lock would erase the newer owner's evidence.
     const lp = lockPath(basePath);
+    const ownsPrimaryLock = isLockFileOwnedByCurrentProcess(lp);
     try {
-        if (existsSync(lp))
+        if (ownsPrimaryLock && existsSync(lp))
             unlinkSync(lp);
     }
     catch {
@@ -462,14 +466,14 @@ export function releaseSessionLock(basePath) {
     const lockTarget = effectiveLockTarget(gsdDir);
     try {
         const lockDir = join(lockTarget + ".lock");
-        if (existsSync(lockDir))
+        if (ownsPrimaryLock && existsSync(lockDir))
             rmSync(lockDir, { recursive: true, force: true });
     }
     catch {
         // Non-fatal
     }
     // Also clean the per-milestone parallel directory itself if it exists
-    if (lockTarget !== gsdDir) {
+    if (ownsPrimaryLock && lockTarget !== gsdDir) {
         try {
             if (existsSync(lockTarget))
                 rmSync(lockTarget, { recursive: true, force: true });
@@ -481,15 +485,16 @@ export function releaseSessionLock(basePath) {
     // Clean ALL registered lock paths (#1578) — lock files accumulate across
     // main project .gsd/, worktree .gsd/, and projects registry paths.
     for (const dir of _lockDirRegistry) {
+        const lockFile = join(dir, LOCK_FILE);
+        const ownsRegisteredLock = isLockFileOwnedByCurrentProcess(lockFile);
         try {
-            const lockFile = join(dir, LOCK_FILE);
-            if (existsSync(lockFile))
+            if (ownsRegisteredLock && existsSync(lockFile))
                 unlinkSync(lockFile);
         }
         catch { /* best-effort */ }
         try {
             const lockDir = join(dir + ".lock");
-            if (existsSync(lockDir))
+            if (ownsRegisteredLock && existsSync(lockDir))
                 rmSync(lockDir, { recursive: true, force: true });
         }
         catch { /* best-effort */ }
@@ -541,6 +546,10 @@ function readExistingLockData(lp) {
         return null;
     }
 }
+function isLockFileOwnedByCurrentProcess(lp) {
+    const existing = readExistingLockData(lp);
+    return existing?.pid === process.pid;
+}
 export function readExistingLockDataWithRetry(lp, options) {
     const maxAttempts = options?.maxAttempts ?? 3;
     const delayMs = options?.delayMs ?? 200;

package/dist/resources/extensions/gsd/skill-manifest.js

@@ -0,0 +1,168 @@
+// GSD2 + skill-manifest — per-unit-type skill allowlist resolver (RFC #4779)
+//
+// Each auto-mode unit type can declare which skills are relevant to it. This
+// trims the set of skills considered for activation in the per-unit prompt,
+// reducing prompt token bloat and sharpening model focus.
+//
+// Contract:
+//   - Unknown unit types fall through to "all skills" (current behavior).
+//   - A manifest entry referencing a skill that is not installed is a silent
+//     no-op at filter time — the filter passes through installed skills only.
+//   - The allowlist is an inclusion list: only skills whose normalized name
+//     appears in the allowlist are retained. Order is not preserved.
+//
+// Phase 1 scope: seed manifests for a small number of unit types as proof.
+// Additional unit types can be added incrementally; each addition is a pure
+// data change with no wiring cost.
+import { logWarning } from "./workflow-logger.js";
+/** Normalize a skill reference the same way callers do (lowercase, trim). */
+function normalize(name) {
+    return name.trim().toLowerCase();
+}
+/**
+ * Allowlist per unit type. Keys match unit type identifiers used by auto-mode
+ * dispatch. Values are normalized skill names.
+ *
+ * Wildcard semantics: a unit type absent from this map resolves to `null`
+ * (wildcard) — meaning "all installed skills are eligible". Prefer absence
+ * over an exhaustive list when uncertain.
+ */
+const UNIT_TYPE_SKILL_MANIFEST = {
+    // Milestone-level planning / meta flows — predictable skill sets.
+    "research-milestone": [
+        "write-docs",
+        "write-milestone-brief",
+        "decompose-into-slices",
+        "grill-me",
+        "design-an-interface",
+        "api-design",
+        "observability",
+    ],
+    "plan-milestone": [
+        "write-milestone-brief",
+        "decompose-into-slices",
+        "design-an-interface",
+        "grill-me",
+        "write-docs",
+        "api-design",
+        "tdd",
+        "verify-before-complete",
+    ],
+    "complete-milestone": [
+        "verify-before-complete",
+        "write-docs",
+        "handoff",
+        "forensics",
+        "observability",
+        "security-review",
+    ],
+    "validate-milestone": [
+        "verify-before-complete",
+        "review",
+        "test",
+        "lint",
+        "security-review",
+        "accessibility",
+        "forensics",
+        "observability",
+    ],
+    "reassess-roadmap": [
+        "decompose-into-slices",
+        "grill-me",
+        "write-milestone-brief",
+        "write-docs",
+        "forensics",
+    ],
+    // Slice-level research / planning.
+    "research-slice": [
+        "write-docs",
+        "decompose-into-slices",
+        "design-an-interface",
+        "grill-me",
+        "api-design",
+        "observability",
+    ],
+    "plan-slice": [
+        "decompose-into-slices",
+        "design-an-interface",
+        "grill-me",
+        "write-docs",
+        "api-design",
+        "tdd",
+        "verify-before-complete",
+    ],
+    "refine-slice": [
+        "decompose-into-slices",
+        "design-an-interface",
+        "grill-me",
+        "write-docs",
+        "api-design",
+        "tdd",
+        "verify-before-complete",
+    ],
+    "replan-slice": [
+        "decompose-into-slices",
+        "grill-me",
+        "design-an-interface",
+        "write-docs",
+        "api-design",
+    ],
+    "run-uat": [
+        "verify-before-complete",
+        "test",
+        "review",
+        "accessibility",
+    ],
+    // `execute-task` intentionally omitted — implementation hot path covers a
+    // wide surface of technologies; wildcard fallback preserves today's
+    // behavior until per-task skill hints can be derived from task-plan
+    // frontmatter. See RFC #4779.
+};
+/**
+ * Resolve the skill allowlist for a unit type.
+ *
+ * @returns Array of normalized skill names when an entry exists, or `null`
+ *   when the unit type is unknown (wildcard — caller should not filter).
+ */
+export function resolveSkillManifest(unitType) {
+    if (!unitType)
+        return null;
+    const entry = UNIT_TYPE_SKILL_MANIFEST[unitType];
+    if (!entry)
+        return null;
+    return entry.map(normalize);
+}
+/**
+ * Filter a skill list by the manifest for `unitType`. Pass-through when the
+ * manifest is wildcard (unknown unit type) or `unitType` is undefined.
+ */
+export function filterSkillsByManifest(skills, unitType) {
+    const allowlist = resolveSkillManifest(unitType);
+    if (allowlist === null)
+        return skills;
+    const allowed = new Set(allowlist);
+    return skills.filter(skill => allowed.has(normalize(skill.name)));
+}
+/**
+ * Dev-mode guard: warn once per process if a manifest entry references a name
+ * that is not currently installed. Silent in production.
+ */
+const warnedMissing = new Set();
+export function warnIfManifestHasMissingSkills(unitType, installedNames) {
+    // Strict mode is intentionally opt-in via exactly "1"; values like "0" or
+    // "false" must preserve the normal silent manifest behavior.
+    if (process.env.GSD_SKILL_MANIFEST_STRICT !== "1")
+        return;
+    const allowlist = resolveSkillManifest(unitType);
+    if (!allowlist)
+        return;
+    for (const name of allowlist) {
+        const key = `${unitType}:${name}`;
+        if (warnedMissing.has(key))
+            continue;
+        if (!installedNames.has(name)) {
+            warnedMissing.add(key);
+            logWarning("prompt", `skill-manifest: references uninstalled skill '${name}' for unit '${unitType}'`);
+        }
+    }
+}