gsd-pi 2.19.0 → 2.20.0

package/dist/resources/extensions/gsd/post-unit-hooks.ts

@@ -1,7 +1,6 @@
 // GSD Extension — Hook Engine (Post-Unit, Pre-Dispatch, State Persistence)
 // Manages hook queue, cycle tracking, artifact verification, pre-dispatch
 // interception, and durable hook state for user-configured extensibility.
-// Copyright (c) 2026 Jeremy McSpadden <jeremy@fluxlabs.net>
 
 import type {
   PostUnitHookConfig,
@@ -412,6 +411,76 @@ export function getHookStatus(): HookStatusEntry[] {
   return entries;
 }
 
+/**
+ * Manually trigger a specific hook for a unit.
+ * This bypasses the normal flow and forces the hook to run even if its artifact exists.
+ * 
+ * @param hookName - The name of the hook to trigger (e.g., "code-review")
+ * @param unitType - The type of unit that triggered the hook (e.g., "execute-task")
+ * @param unitId - The unit ID (e.g., "M001/S01/T01")
+ * @param basePath - The project base path
+ * @returns The hook dispatch result or null if hook not found
+ */
+export function triggerHookManually(
+  hookName: string,
+  unitType: string,
+  unitId: string,
+  basePath: string,
+): HookDispatchResult | null {
+  // Find the hook configuration
+  const hook = resolvePostUnitHooks().find(h => h.name === hookName);
+  if (!hook) {
+    console.error(`[triggerHookManually] Hook "${hookName}" not found in post_unit_hooks`);
+    return null;
+  }
+
+  if (!hook.prompt || typeof hook.prompt !== 'string' || hook.prompt.trim().length === 0) {
+    console.error(`[triggerHookManually] Hook "${hookName}" has empty prompt`);
+    return null;
+  }
+
+  // Reset any active hook state to allow manual triggering
+  activeHook = {
+    hookName: hook.name,
+    triggerUnitType: unitType,
+    triggerUnitId: unitId,
+    cycle: 1,
+    pendingRetry: false,
+  };
+
+  // Build the hook queue with just this hook
+  hookQueue = [{
+    config: hook,
+    triggerUnitType: unitType,
+    triggerUnitId: unitId,
+  }];
+
+  // Set the cycle count for this specific hook+trigger
+  const cycleKey = `${hook.name}/${unitType}/${unitId}`;
+  const currentCycle = (cycleCounts.get(cycleKey) ?? 0) + 1;
+  cycleCounts.set(cycleKey, currentCycle);
+
+  // Update active hook with the cycle count
+  activeHook.cycle = currentCycle;
+
+  // Build the prompt with variable substitution
+  const [mid, sid, tid] = unitId.split("/");
+  const prompt = hook.prompt
+    .replace(/\{milestoneId\}/g, mid ?? "")
+    .replace(/\{sliceId\}/g, sid ?? "")
+    .replace(/\{taskId\}/g, tid ?? "");
+
+  console.log(`[triggerHookManually] Built prompt for ${hookName}, length: ${prompt.length}`);
+
+  return {
+    hookName: hook.name,
+    prompt,
+    model: hook.model,
+    unitType: `hook/${hook.name}`,
+    unitId,
+  };
+}
+
 /**
  * Format hook status for terminal display.
  */

package/dist/resources/extensions/gsd/preferences.ts

@@ -2,6 +2,7 @@ import { existsSync, readdirSync, readFileSync, statSync, writeFileSync } from "
 import { homedir } from "node:os";
 import { isAbsolute, join } from "node:path";
 import { getAgentDir } from "@gsd/pi-coding-agent";
+import { parse as parseYaml } from "yaml";
 import type { GitPreferences } from "./git-service.js";
 import type { PostUnitHookConfig, PreDispatchHookConfig, BudgetEnforcementMode, NotificationPreferences, TokenProfile, InlineLevel, PhaseSkipPreferences } from "./types.js";
 import type { DynamicRoutingConfig } from "./model-router.js";
@@ -17,9 +18,40 @@ const GLOBAL_PREFERENCES_PATH_UPPERCASE = join(homedir(), ".gsd", "PREFERENCES.m
 const PROJECT_PREFERENCES_PATH_UPPERCASE = join(process.cwd(), ".gsd", "PREFERENCES.md");
 const SKILL_ACTIONS = new Set(["use", "prefer", "avoid"]);
 
+// ─── Workflow Modes ──────────────────────────────────────────────────────────
+
+export type WorkflowMode = "solo" | "team";
+
+/** Default preference values for each workflow mode. */
+const MODE_DEFAULTS: Record<WorkflowMode, Partial<GSDPreferences>> = {
+  solo: {
+    git: {
+      auto_push: true,
+      push_branches: false,
+      pre_merge_check: false,
+      merge_strategy: "squash",
+      isolation: "worktree",
+      commit_docs: true,
+    },
+    unique_milestone_ids: false,
+  },
+  team: {
+    git: {
+      auto_push: false,
+      push_branches: true,
+      pre_merge_check: true,
+      merge_strategy: "squash",
+      isolation: "worktree",
+      commit_docs: true,
+    },
+    unique_milestone_ids: true,
+  },
+};
+
 /** All recognized top-level keys in GSDPreferences. Used to detect typos / stale config. */
 const KNOWN_PREFERENCE_KEYS = new Set<string>([
   "version",
+  "mode",
   "always_use_skills",
   "prefer_skills",
   "avoid_skills",
@@ -27,6 +59,7 @@ const KNOWN_PREFERENCE_KEYS = new Set<string>([
   "custom_instructions",
   "models",
   "skill_discovery",
+  "skill_staleness_days",
   "auto_supervisor",
   "uat_dispatch",
   "unique_milestone_ids",
@@ -106,7 +139,7 @@ export interface AutoSupervisorConfig {
 }
 
 export interface RemoteQuestionsConfig {
-  channel: "slack" | "discord";
+  channel: "slack" | "discord" | "telegram";
   channel_id: string | number;
   timeout_minutes?: number;        // clamped to 1-30
   poll_interval_seconds?: number;  // clamped to 2-30
@@ -114,6 +147,7 @@ export interface RemoteQuestionsConfig {
 
 export interface GSDPreferences {
   version?: number;
+  mode?: WorkflowMode;
   always_use_skills?: string[];
   prefer_skills?: string[];
   avoid_skills?: string[];
@@ -121,6 +155,7 @@ export interface GSDPreferences {
   custom_instructions?: string[];
   models?: GSDModelConfig | GSDModelConfigV2;
   skill_discovery?: SkillDiscoveryMode;
+  skill_staleness_days?: number;  // Skills unused for N days get deprioritized (#599). 0 = disabled. Default: 60.
   auto_supervisor?: AutoSupervisorConfig;
   uat_dispatch?: boolean;
   unique_milestone_ids?: boolean;
@@ -169,25 +204,49 @@ export function loadProjectGSDPreferences(): LoadedGSDPreferences | null {
     ?? loadPreferencesFile(PROJECT_PREFERENCES_PATH_UPPERCASE, "project");
 }
 
+/**
+ * Apply mode defaults as the lowest-priority layer.
+ * Mode defaults fill in undefined fields; any explicit user value wins.
+ */
+export function applyModeDefaults(mode: WorkflowMode, prefs: GSDPreferences): GSDPreferences {
+  const defaults = MODE_DEFAULTS[mode];
+  if (!defaults) return prefs;
+  return mergePreferences(defaults, prefs);
+}
+
 export function loadEffectiveGSDPreferences(): LoadedGSDPreferences | null {
   const globalPreferences = loadGlobalGSDPreferences();
   const projectPreferences = loadProjectGSDPreferences();
 
   if (!globalPreferences && !projectPreferences) return null;
-  if (!globalPreferences) return projectPreferences;
-  if (!projectPreferences) return globalPreferences;
 
-  const mergedWarnings = [
-    ...(globalPreferences.warnings ?? []),
-    ...(projectPreferences.warnings ?? []),
-  ];
+  let result: LoadedGSDPreferences;
+  if (!globalPreferences) {
+    result = projectPreferences!;
+  } else if (!projectPreferences) {
+    result = globalPreferences;
+  } else {
+    const mergedWarnings = [
+      ...(globalPreferences.warnings ?? []),
+      ...(projectPreferences.warnings ?? []),
+    ];
+    result = {
+      path: projectPreferences.path,
+      scope: "project",
+      preferences: mergePreferences(globalPreferences.preferences, projectPreferences.preferences),
+      ...(mergedWarnings.length > 0 ? { warnings: mergedWarnings } : {}),
+    };
+  }
 
-  return {
-    path: projectPreferences.path,
-    scope: "project",
-    preferences: mergePreferences(globalPreferences.preferences, projectPreferences.preferences),
-    ...(mergedWarnings.length > 0 ? { warnings: mergedWarnings } : {}),
-  };
+  // Apply mode defaults as the lowest-priority layer
+  if (result.preferences.mode) {
+    result = {
+      ...result,
+      preferences: applyModeDefaults(result.preferences.mode, result.preferences),
+    };
+  }
+
+  return result;
 }
 
 // ─── Skill Reference Resolution ───────────────────────────────────────────────
@@ -425,148 +484,27 @@ function loadPreferencesFile(path: string, scope: "global" | "project"): LoadedG
 
 /** @internal Exported for testing only */
 export function parsePreferencesMarkdown(content: string): GSDPreferences | null {
-  const match = content.match(/^---\r?\n([\s\S]*?)\r?\n---/);
-  if (!match) return null;
-  return parseFrontmatterBlock(match[1]);
+  // Use indexOf instead of [\s\S]*? regex to avoid backtracking (#468)
+  const startMarker = content.startsWith('---\r\n') ? '---\r\n' : '---\n';
+  if (!content.startsWith(startMarker)) return null;
+  const searchStart = startMarker.length;
+  const endIdx = content.indexOf('\n---', searchStart);
+  if (endIdx === -1) return null;
+  const block = content.slice(searchStart, endIdx);
+  return parseFrontmatterBlock(block.replace(/\r/g, ''));
 }
 
 function parseFrontmatterBlock(frontmatter: string): GSDPreferences {
-  const root: Record<string, unknown> = {};
-  const stack: Array<{ indent: number; value: Record<string, unknown> }> = [{ indent: -1, value: root }];
-
-  const lines = frontmatter.split(/\r?\n/);
-  for (let i = 0; i < lines.length; i++) {
-    const line = lines[i];
-    if (!line.trim()) continue;
-
-    const indent = line.match(/^\s*/)?.[0].length ?? 0;
-    const trimmed = line.trim();
-
-    // Skip comment lines (standalone YAML comments)
-    if (trimmed.startsWith("#")) continue;
-
-    while (stack.length > 1 && indent <= stack[stack.length - 1].indent) {
-      stack.pop();
+  try {
+    const parsed = parseYaml(frontmatter);
+    if (typeof parsed !== 'object' || parsed === null) {
+      return {} as GSDPreferences;
     }
-
-    const current = stack[stack.length - 1].value;
-    const keyMatch = trimmed.match(/^([A-Za-z0-9_]+):(.*)$/);
-    if (!keyMatch) continue;
-
-    const [, key, remainder] = keyMatch;
-    // Strip inline comments from the value portion
-    const valuePart = remainder.replace(/\s+#.*$/, "").trim();
-
-    if (valuePart === "") {
-      const nextLine = lines[i + 1] ?? "";
-      const nextTrimmed = nextLine.trim();
-      if (nextTrimmed.startsWith("- ")) {
-        const items: unknown[] = [];
-        let j = i + 1;
-        while (j < lines.length) {
-          const candidate = lines[j];
-          const candidateIndent = candidate.match(/^\s*/)?.[0].length ?? 0;
-          const candidateTrimmed = candidate.trim();
-          if (!candidateTrimmed) {
-            j++;
-            continue;
-          }
-          if (candidateIndent <= indent || !candidateTrimmed.startsWith("- ")) break;
-
-          const itemText = candidateTrimmed.slice(2).trim();
-          const nextCandidate = lines[j + 1] ?? "";
-          const nextCandidateIndent = nextCandidate.match(/^\s*/)?.[0].length ?? 0;
-          const nextCandidateTrimmed = nextCandidate.trim();
-
-          // Treat an array item as a structured object only when:
-          //   a) It looks like a YAML key-value pair (key starts with [A-Za-z0-9_]+:), OR
-          //   b) The next line is indented deeper (nested block under this item).
-          // Bare colons (e.g. "qwen/qwen3-coder:free") are NOT key-value pairs.
-          const looksLikeKeyValue = /^[A-Za-z0-9_]+:/.test(itemText);
-          if (looksLikeKeyValue || (nextCandidateTrimmed && nextCandidateIndent > candidateIndent)) {
-            const obj: Record<string, unknown> = {};
-            const firstMatch = itemText.match(/^([A-Za-z0-9_]+):(.*)$/);
-            if (firstMatch) {
-              obj[firstMatch[1]] = parseScalar(firstMatch[2].trim());
-            }
-            j++;
-            while (j < lines.length) {
-              const nested = lines[j];
-              const nestedIndent = nested.match(/^\s*/)?.[0].length ?? 0;
-              const nestedTrimmed = nested.trim();
-              if (!nestedTrimmed) {
-                j++;
-                continue;
-              }
-              if (nestedIndent <= candidateIndent) break;
-              const nestedMatch = nestedTrimmed.match(/^([A-Za-z0-9_]+):(.*)$/);
-              if (nestedMatch) {
-                const nestedValue = nestedMatch[2].trim();
-                if (nestedValue === "") {
-                  const nestedItems: string[] = [];
-                  j++;
-                  while (j < lines.length) {
-                    const nestedArrayLine = lines[j];
-                    const nestedArrayIndent = nestedArrayLine.match(/^\s*/)?.[0].length ?? 0;
-                    const nestedArrayTrimmed = nestedArrayLine.trim();
-                    if (!nestedArrayTrimmed) {
-                      j++;
-                      continue;
-                    }
-                    if (nestedArrayIndent <= nestedIndent || !nestedArrayTrimmed.startsWith("- ")) break;
-                    nestedItems.push(String(parseScalar(nestedArrayTrimmed.slice(2).trim())));
-                    j++;
-                  }
-                  obj[nestedMatch[1]] = nestedItems;
-                  continue;
-                }
-                obj[nestedMatch[1]] = parseScalar(nestedValue);
-              }
-              j++;
-            }
-            items.push(obj);
-            continue;
-          }
-
-          items.push(parseScalar(itemText));
-          j++;
-        }
-        current[key] = items;
-        i = j - 1;
-      } else {
-        const obj: Record<string, unknown> = {};
-        current[key] = obj;
-        stack.push({ indent, value: obj });
-      }
-      continue;
-    }
-
-    current[key] = parseScalar(valuePart);
-  }
-
-  return root as GSDPreferences;
-}
-
-function parseScalar(value: string): unknown {
-  // Strip inline YAML comments: " # comment" (# preceded by whitespace).
-  // Quoted strings are returned as-is (the comment is inside quotes).
-  const quoteMatch = value.match(/^(['"])(.*)(\1)$/);
-  if (quoteMatch) return quoteMatch[2];
-
-  const stripped = value.replace(/\s+#.*$/, "");
-  if (stripped === "true") return true;
-  if (stripped === "false") return false;
-  // Recognize empty array/object literals (with or without surrounding quotes)
-  const unquoted = stripped.replace(/^['\"]|['\"]$/g, "");
-  if (unquoted === "[]") return [];
-  if (unquoted === "{}") return {};
-  if (/^-?\d+$/.test(stripped)) {
-    const n = Number(stripped);
-    // Keep large integers (e.g. Discord channel IDs) as strings to avoid precision loss
-    if (Number.isSafeInteger(n)) return n;
-    return stripped;
+    return parsed as GSDPreferences;
+  } catch (e) {
+    console.error("[parseFrontmatterBlock] YAML parse error:", e);
+    return {} as GSDPreferences;
   }
-  return unquoted;
 }
 
 /**
@@ -578,6 +516,15 @@ export function resolveSkillDiscoveryMode(): SkillDiscoveryMode {
   return prefs?.preferences.skill_discovery ?? "suggest";
 }
 
+/**
+ * Resolve the skill staleness threshold in days.
+ * Returns 0 if disabled, default 60 if not configured.
+ */
+export function resolveSkillStalenessDays(): number {
+  const prefs = loadEffectiveGSDPreferences();
+  return prefs?.preferences.skill_staleness_days ?? 60;
+}
+
 /**
  * Resolve which model ID to use for a given auto-mode unit type.
  * Returns undefined if no model preference is set for this unit type.
@@ -776,6 +723,7 @@ export function resolveInlineLevel(): InlineLevel {
 function mergePreferences(base: GSDPreferences, override: GSDPreferences): GSDPreferences {
   return {
     version: override.version ?? base.version,
+    mode: override.mode ?? base.mode,
     always_use_skills: mergeStringLists(base.always_use_skills, override.always_use_skills),
     prefer_skills: mergeStringLists(base.prefer_skills, override.prefer_skills),
     avoid_skills: mergeStringLists(base.avoid_skills, override.avoid_skills),
@@ -783,6 +731,7 @@ function mergePreferences(base: GSDPreferences, override: GSDPreferences): GSDPr
     custom_instructions: mergeStringLists(base.custom_instructions, override.custom_instructions),
     models: { ...(base.models ?? {}), ...(override.models ?? {}) },
     skill_discovery: override.skill_discovery ?? base.skill_discovery,
+    skill_staleness_days: override.skill_staleness_days ?? base.skill_staleness_days,
     auto_supervisor: { ...(base.auto_supervisor ?? {}), ...(override.auto_supervisor ?? {}) },
     uat_dispatch: override.uat_dispatch ?? base.uat_dispatch,
     unique_milestone_ids: override.unique_milestone_ids ?? base.unique_milestone_ids,
@@ -834,6 +783,16 @@ export function validatePreferences(preferences: GSDPreferences): {
     }
   }
 
+  // ─── Workflow Mode ──────────────────────────────────────────────────
+  if (preferences.mode !== undefined) {
+    const validModes = new Set<string>(["solo", "team"]);
+    if (typeof preferences.mode === "string" && validModes.has(preferences.mode)) {
+      validated.mode = preferences.mode as WorkflowMode;
+    } else {
+      errors.push(`invalid mode "${preferences.mode}" — must be one of: solo, team`);
+    }
+  }
+
   const validDiscoveryModes = new Set(["auto", "suggest", "off"]);
   if (preferences.skill_discovery) {
     if (validDiscoveryModes.has(preferences.skill_discovery)) {
@@ -843,6 +802,15 @@ export function validatePreferences(preferences: GSDPreferences): {
     }
   }
 
+  if (preferences.skill_staleness_days !== undefined) {
+    const days = Number(preferences.skill_staleness_days);
+    if (Number.isFinite(days) && days >= 0) {
+      validated.skill_staleness_days = Math.floor(days);
+    } else {
+      errors.push(`invalid skill_staleness_days: must be a non-negative number`);
+    }
+  }
+
   validated.always_use_skills = normalizeStringList(preferences.always_use_skills);
   validated.prefer_skills = normalizeStringList(preferences.prefer_skills);
   validated.avoid_skills = normalizeStringList(preferences.avoid_skills);
@@ -1240,6 +1208,13 @@ export function validatePreferences(preferences: GSDPreferences): {
       if (typeof g.commit_docs === "boolean") git.commit_docs = g.commit_docs;
       else errors.push("git.commit_docs must be a boolean");
     }
+    if (g.worktree_post_create !== undefined) {
+      if (typeof g.worktree_post_create === "string" && g.worktree_post_create.trim()) {
+        git.worktree_post_create = g.worktree_post_create.trim();
+      } else {
+        errors.push("git.worktree_post_create must be a non-empty string (path to script)");
+      }
+    }
     // Deprecated: merge_to_main is ignored (branchless architecture).
     if (g.merge_to_main !== undefined) {
       warnings.push("git.merge_to_main is deprecated — milestone-level merge is now always used. Remove this setting.");

package/dist/resources/extensions/gsd/prompts/execute-task.md

@@ -43,7 +43,7 @@ Then:
 9. If the task plan includes an Observability Impact section, verify those signals directly. Skip this step if the task plan omits the section.
 10. **If execution is running long or verification fails:**
 
-    **Context budget:** If you've used most of your context and haven't finished all steps, stop implementing and prioritize writing the task summary with clear notes on what's done and what remains. A partial summary that enables clean resumption is more valuable than one more half-finished step with no documentation. Never sacrifice summary quality for one more implementation step.
+    **Context budget:** You have approximately **{{verificationBudget}}** reserved for verification context. If you've used most of your context and haven't finished all steps, stop implementing and prioritize writing the task summary with clear notes on what's done and what remains. A partial summary that enables clean resumption is more valuable than one more half-finished step with no documentation. Never sacrifice summary quality for one more implementation step.
 
     **Debugging discipline:** If a verification check fails or implementation hits unexpected behavior:
     - Form a hypothesis first. State what you think is wrong and why, then test that specific theory. Don't shotgun-fix.
@@ -53,9 +53,9 @@ Then:
     - Know when to stop. If you've tried 3+ fixes without progress, your mental model is probably wrong. Stop. List what you know for certain. List what you've ruled out. Form fresh hypotheses from there.
     - Don't fix symptoms. Understand *why* something fails before changing code. A test that passes after a change you don't understand is luck, not a fix.
 11. **Blocker discovery:** If execution reveals that the remaining slice plan is fundamentally invalid — not just a bug or minor deviation, but a plan-invalidating finding like a wrong API, missing capability, or architectural mismatch — set `blocker_discovered: true` in the task summary frontmatter and describe the blocker clearly in the summary narrative. Do NOT set `blocker_discovered: true` for ordinary debugging, minor deviations, or issues that can be fixed within the current task or the remaining plan. This flag triggers an automatic replan of the slice.
-12. If you made an architectural, pattern, library, or observability decision during this task that downstream work should know about, append it to `.gsd/DECISIONS.md` (use the **Decisions** output template from the inlined templates below if the file doesn't exist yet). Not every task produces decisions — only append when a meaningful choice was made.
+12. If you made an architectural, pattern, library, or observability decision during this task that downstream work should know about, append it to `.gsd/DECISIONS.md` (read the template at `~/.gsd/agent/extensions/gsd/templates/decisions.md` if the file doesn't exist yet). Not every task produces decisions — only append when a meaningful choice was made.
 13. If you discover a non-obvious rule, recurring gotcha, or useful pattern during execution, append it to `.gsd/KNOWLEDGE.md`. Only add entries that would save future agents from repeating your investigation. Don't add obvious things.
-14. Use the **Task Summary** output template from the inlined templates below
+14. Read the template at `~/.gsd/agent/extensions/gsd/templates/task-summary.md`
 15. Write `{{taskSummaryPath}}`
 16. Mark {{taskId}} done in `{{planPath}}` (change `[ ]` to `[x]`)
 17. Do not commit manually — the system auto-commits your changes after this unit completes.
@@ -65,6 +65,4 @@ All work stays in your working directory: `{{workingDirectory}}`.
 
 **You MUST mark {{taskId}} as `[x]` in `{{planPath}}` AND write `{{taskSummaryPath}}` before finishing.**
 
-{{inlinedTemplates}}
-
 When done, say: "Task {{taskId}} complete."

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

@@ -0,0 +1,45 @@
+## Skill Heal Analysis
+
+Analyze the just-completed unit ({{unitId}}) for skill drift.
+
+### Steps
+
+1. **Identify loaded skill**: Check which SKILL.md file was read during this unit by examining recent tool calls. If no skill was explicitly loaded (no `read` call to a SKILL.md path), write "No skill loaded — skipping heal analysis" to {{healArtifact}} and stop.
+
+2. **Read the skill**: Load the SKILL.md that was used during this unit.
+
+3. **Compare execution to skill guidance**: Review what the agent actually did vs what the skill recommended. Look for:
+   - API patterns the skill recommended that the agent did differently
+   - Error handling approaches the skill specified but the agent bypassed
+   - Conventions the skill documented that the agent ignored
+   - Outdated instructions in the skill that caused errors, retries, or workarounds
+   - Commands or tools the skill referenced that no longer exist or have changed
+
+4. **Assess drift severity**:
+   - **None**: Agent followed skill correctly → write "No drift detected" to {{healArtifact}} and stop
+   - **Minor**: Agent found a better approach but skill isn't wrong → append a note to `.gsd/KNOWLEDGE.md` and stop
+   - **Significant**: Skill has outdated or incorrect guidance → continue to step 5
+
+5. **If significant drift found**, append a heal suggestion to `.gsd/skill-review-queue.md`:
+
+```markdown
+### {{skillName}} (flagged {{date}})
+- **Unit:** {{unitId}}
+- **Issue:** {1-2 sentence description of what was wrong}
+- **Root cause:** {outdated API / incorrect pattern / missing context / etc.}
+- **Discovery method:** {how the agent discovered the skill was wrong — error message, trial and error, docs lookup, etc.}
+- **Proposed fix:**
+  - File: {relative path to the file in the skill directory}
+  - Section: {section heading or line range}
+  - Current: {quote the incorrect/outdated text}
+  - Suggested: {the corrected text}
+- **Action:** [ ] Reviewed [ ] Updated [ ] Dismissed
+```
+
+Then write a brief summary of the finding to {{healArtifact}}.
+
+**Critical rules:**
+- Do NOT modify any skill files directly. Only write to the review queue.
+- The SkillsBench research (Feb 2026) shows curated skills beat auto-generated ones by +16.2pp. Human review is what makes this valuable.
+- Keep the analysis focused — don't flag stylistic preferences, only genuine errors or outdated content.
+- If multiple issues found, write one entry per issue.

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

@@ -26,9 +26,13 @@ Narrate your decomposition reasoning — why you're grouping work this way, what
 
 **Right-size the plan.** If the slice is simple enough to be 1 task, plan 1 task. Don't split into multiple tasks just because you can identify sub-steps. Don't fill in sections with "None" when the section doesn't apply — omit them entirely. The plan's job is to guide execution, not to fill a template.
 
+{{executorContextConstraints}}
+
 Then:
 0. If `REQUIREMENTS.md` was preloaded above, identify which Active requirements the roadmap says this slice owns or supports. These are the requirements this plan must deliver — every owned requirement needs at least one task that directly advances it, and verification must prove the requirement is met.
-1. Use the **Slice Plan** and **Task Plan** output templates from the inlined context above
+1. Read the templates:
+   - `~/.gsd/agent/extensions/gsd/templates/plan.md`
+   - `~/.gsd/agent/extensions/gsd/templates/task-plan.md`
 2. If a `GSD Skill Preferences` block is present in system context, use it to decide which skills to load and follow during planning, without overriding required plan formatting
 3. Define slice-level verification — the objective stopping condition for this slice:
    - For non-trivial slices: plan actual test files with real assertions. Name the files.

package/dist/resources/extensions/gsd/prompts/quick-task.md

@@ -0,0 +1,48 @@
+You are executing a GSD quick task — a lightweight, focused unit of work outside the milestone/slice ceremony.
+
+## QUICK TASK: {{description}}
+
+**Task directory:** `{{taskDir}}`
+**Branch:** `{{branch}}`
+
+## Instructions
+
+1. Read the task description above carefully. This is a focused, self-contained task.
+2. If a `GSD Skill Preferences` block is present in system context, follow it.
+3. Read relevant code before modifying. Understand existing patterns.
+4. Execute the task completely:
+   - Build the real thing, not stubs or placeholders.
+   - Write or update tests where appropriate.
+   - Handle error cases and edge cases.
+5. Verify your work:
+   - Run tests if applicable.
+   - Verify both happy path and failure modes for non-trivial changes.
+6. Commit your changes atomically:
+   - Use conventional commit messages (feat:, fix:, refactor:, etc.)
+   - Stage only relevant files — never commit secrets or runtime files.
+   - Commit logical units separately if the task involves distinct changes.
+7. Write a brief summary to `{{summaryPath}}`:
+
+```markdown
+# Quick Task: {{description}}
+
+**Date:** {{date}}
+**Branch:** {{branch}}
+
+## What Changed
+- <concise list of changes>
+
+## Files Modified
+- <list of files>
+
+## Verification
+- <what was tested/verified>
+```
+
+8. Update `.gsd/STATE.md` — add or update the "Quick Tasks Completed" table:
+   - If the section doesn't exist, create it after "### Blockers/Concerns"
+   - Table format: `| # | Description | Date | Commit | Directory |`
+   - Add a row: `| {{taskNum}} | {{description}} | {{date}} | <commit-hash> | [{{taskNum}}-{{slug}}](./quick/{{taskNum}}-{{slug}}/) |`
+   - Update the "Last activity" line
+
+When done, say: "Quick task {{taskNum}} complete."

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

@@ -128,6 +128,7 @@ Templates showing the expected format for each artifact type are in:
 - `/gsd stop` - stop auto-mode
 - `/gsd status` - progress dashboard overlay
 - `/gsd queue` - queue future milestones (safe while auto-mode is running)
+- `/gsd quick <task>` - quick task with GSD guarantees (atomic commits, state tracking) but no milestone ceremony
 - `Ctrl+Alt+G` - toggle dashboard overlay
 - `Ctrl+Alt+B` - show shell processes
 
@@ -139,7 +140,7 @@ Templates showing the expected format for each artifact type are in:
 
 **File editing:** Always `read` a file before using `edit`. The `edit` tool requires exact text match — you need the real content, not a guess. Use `write` only for new files or complete rewrites.
 
-**Code navigation:** Use `lsp` for go-to-definition, find-references, and type info. Falls back gracefully if no server is available. Never `grep` for a symbol definition when `lsp` can resolve it semantically.
+**Code navigation:** Use `lsp` for definition, type_definition, implementation, references, incoming_calls, outgoing_calls, hover, signature, symbols, rename, code_actions, format, and diagnostics. Falls back gracefully if no server is available. Never `grep` for a symbol definition when `lsp` can resolve it semantically. Never shell out to prettier/rustfmt/gofmt when `lsp format` is available. After editing code, use `lsp diagnostics` to verify no type errors were introduced.
 
 **Codebase exploration:** Use `subagent` with `scout` for broad unfamiliar subsystem mapping. Use `rg` for text search across files. Use `lsp` for structural navigation. Never read files one-by-one to "explore" — search first, then read what's relevant.