gsd-pi 2.18.0 → 2.20.0

package/src/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/src/resources/extensions/gsd/prompts/reassess-roadmap.md

@@ -16,6 +16,12 @@ All relevant context has been preloaded below — the current roadmap, completed
 
 {{inlinedContext}}
 
+## Deferred Captures
+
+The following user thoughts were captured during execution and deferred to future slices during triage. Consider whether any should influence the remaining roadmap:
+
+{{deferredCaptures}}
+
 If a `GSD Skill Preferences` block is present in system context, use it to decide which skills to load and follow during reassessment, without relaxing required verification or artifact rules.
 
 Then assess whether the remaining roadmap still makes sense given what was just built.

package/src/resources/extensions/gsd/prompts/replan-slice.md

@@ -12,6 +12,14 @@ All relevant context has been preloaded below — the roadmap, current slice pla
 
 {{inlinedContext}}
 
+## Capture Context
+
+The following user-captured thoughts triggered or informed this replan:
+
+{{captureContext}}
+
+Consider these captures when rewriting the remaining tasks — they represent the user's real-time insights about what needs to change.
+
 ## Hard Constraints
 
 - **Do NOT renumber or remove completed tasks.** All `[x]` tasks and their IDs must remain exactly as they are in the plan.

package/src/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.
 

package/src/resources/extensions/gsd/prompts/triage-captures.md

@@ -0,0 +1,62 @@
+You are triaging user-captured thoughts during a GSD session.
+
+## UNIT: Triage Captures
+
+The user captured thoughts during execution using `/gsd capture`. Your job is to classify each capture, present your proposals, get user confirmation, and update CAPTURES.md with the final classifications.
+
+## Pending Captures
+
+{{pendingCaptures}}
+
+## Current Slice Plan
+
+{{currentPlan}}
+
+## Current Roadmap
+
+{{roadmapContext}}
+
+## Classification Criteria
+
+For each capture, classify it as one of:
+
+- **quick-task**: Small, self-contained, no downstream impact. Can be done in minutes without modifying the plan. Examples: fix a typo, add a missing import, tweak a config value.
+- **inject**: Belongs in the current slice but wasn't planned. Needs a new task added to the slice plan. Examples: add error handling to a module being built, add a missing test case for current work.
+- **defer**: Belongs in a future slice or milestone. Not urgent for current work. Examples: performance optimization, feature that depends on unbuilt infrastructure, nice-to-have enhancement.
+- **replan**: Changes the shape of remaining work in the current slice. Existing incomplete tasks may need rewriting. Examples: "the approach is wrong, we need to use X instead of Y", discovering a fundamental constraint.
+- **note**: Informational only. No action needed right now. Good context for future reference. Examples: "remember that the API has a rate limit", observations about code quality.
+
+## Decision Guidelines
+
+- Prefer **quick-task** when the work is clearly small and self-contained.
+- Prefer **inject** over **replan** when only a new task is needed, not rewriting existing ones.
+- Prefer **defer** over **inject** when the work doesn't belong in the current slice's scope.
+- Use **replan** only when remaining incomplete tasks need to change — not just for adding work.
+- Use **note** for observations that don't require action.
+- When unsure between quick-task and inject, consider: will this take more than 10 minutes? If yes, inject.
+
+## Instructions
+
+1. **Classify** each pending capture using the criteria above.
+
+2. **Present** your classifications to the user using `ask_user_questions`. For each capture, show:
+   - The capture text
+   - Your proposed classification
+   - Your rationale
+   - If applicable, which files would be affected
+   
+   For captures classified as **note** or **defer**, auto-confirm without asking — these are low-impact.
+   For captures classified as **quick-task**, **inject**, or **replan**, ask the user to confirm or choose a different classification.
+
+3. **Update** `.gsd/CAPTURES.md` — for each capture, update its section with the confirmed classification:
+   - Change `**Status:** pending` to `**Status:** resolved`
+   - Add `**Classification:** <type>`
+   - Add `**Resolution:** <brief description of what will happen>`
+   - Add `**Rationale:** <why this classification>`
+   - Add `**Resolved:** <current ISO timestamp>`
+
+4. **Summarize** what was triaged: how many captures, what classifications were assigned, and what actions are pending (e.g., "2 quick-tasks ready for execution, 1 deferred to S03").
+
+**Important:** Do NOT execute any resolutions. Only classify and update CAPTURES.md. Resolution execution happens separately (in auto-mode dispatch or manually by the user).
+
+When done, say: "Triage complete."

package/src/resources/extensions/gsd/quick.ts

@@ -0,0 +1,156 @@
+/**
+ * GSD Quick Mode — /gsd quick <task>
+ * Copyright (c) 2026 Jeremy McSpadden <jeremy@fluxlabs.net>
+ *
+ * Lightweight task execution with GSD guarantees (atomic commits, state
+ * tracking) but without the full milestone/slice ceremony.
+ *
+ * Quick tasks live in `.gsd/quick/` and are tracked in STATE.md's
+ * "Quick Tasks Completed" table.
+ */
+
+import type { ExtensionAPI, ExtensionCommandContext } from "@gsd/pi-coding-agent";
+import { existsSync, mkdirSync, readdirSync } from "node:fs";
+import { join } from "node:path";
+import { loadPrompt } from "./prompt-loader.js";
+import { gsdRoot } from "./paths.js";
+import { GitServiceImpl, runGit } from "./git-service.js";
+import { loadEffectiveGSDPreferences } from "./preferences.js";
+
+// ─── Quick Task Helpers ───────────────────────────────────────────────────────
+
+/**
+ * Generate a URL-friendly slug from a description.
+ * Lowercase, hyphens, max 40 chars.
+ */
+function slugify(text: string): string {
+  return text
+    .toLowerCase()
+    .replace(/[^a-z0-9]+/g, "-")
+    .replace(/^-|-$/g, "")
+    .slice(0, 40)
+    .replace(/-$/, "");
+}
+
+/**
+ * Determine the next quick task number by scanning existing directories.
+ */
+function getNextTaskNum(quickDir: string): number {
+  if (!existsSync(quickDir)) return 1;
+  try {
+    const entries = readdirSync(quickDir, { withFileTypes: true });
+    let max = 0;
+    for (const entry of entries) {
+      if (!entry.isDirectory()) continue;
+      const match = entry.name.match(/^(\d+)-/);
+      if (match) {
+        const num = parseInt(match[1], 10);
+        if (num > max) max = num;
+      }
+    }
+    return max + 1;
+  } catch {
+    return 1;
+  }
+}
+
+/**
+ * Ensure the quick task directory structure exists.
+ * Returns the task directory path.
+ */
+function ensureQuickDir(basePath: string, taskNum: number, slug: string): string {
+  const quickDir = join(gsdRoot(basePath), "quick");
+  const taskDir = join(quickDir, `${taskNum}-${slug}`);
+  mkdirSync(taskDir, { recursive: true });
+  return taskDir;
+}
+
+// ─── Main Handler ─────────────────────────────────────────────────────────────
+
+export async function handleQuick(
+  args: string,
+  ctx: ExtensionCommandContext,
+  pi: ExtensionAPI,
+): Promise<void> {
+  const basePath = process.cwd();
+  const root = gsdRoot(basePath);
+
+  // Validate: .gsd/ must exist
+  if (!existsSync(root)) {
+    ctx.ui.notify(
+      "No .gsd/ directory found. Run /gsd to initialize a project first.",
+      "error",
+    );
+    return;
+  }
+
+  // Parse description from args
+  let description = args.trim();
+  if (!description) {
+    ctx.ui.notify(
+      "Usage: /gsd quick <task description>\n\nExample: /gsd quick fix login button not responding on mobile",
+      "info",
+    );
+    return;
+  }
+
+  // Setup
+  const quickDir = join(root, "quick");
+  const taskNum = getNextTaskNum(quickDir);
+  const slug = slugify(description);
+  const taskDir = ensureQuickDir(basePath, taskNum, slug);
+  const taskDirRel = `.gsd/quick/${taskNum}-${slug}`;
+  const date = new Date().toISOString().split("T")[0];
+
+  // Create git branch for the quick task
+  const gitPrefs = loadEffectiveGSDPreferences()?.preferences?.git ?? {};
+  const git = new GitServiceImpl(basePath, gitPrefs);
+  const branchName = `gsd/quick/${taskNum}-${slug}`;
+
+  let branchCreated = false;
+  try {
+    const current = git.getCurrentBranch();
+    if (current !== branchName) {
+      // Auto-commit any dirty state before switching
+      try {
+        git.autoCommit("quick-task", `Q${taskNum}`, []);
+      } catch { /* nothing to commit — fine */ }
+
+      runGit(basePath, ["checkout", "-b", branchName]);
+      branchCreated = true;
+    }
+  } catch (err) {
+    // Branch creation failed — continue on current branch
+    const message = err instanceof Error ? err.message : String(err);
+    ctx.ui.notify(`Could not create branch ${branchName}: ${message}. Working on current branch.`, "warning");
+  }
+
+  const actualBranch = branchCreated ? branchName : git.getCurrentBranch();
+
+  // Notify user
+  ctx.ui.notify(
+    `Quick task ${taskNum}: ${description}\nDirectory: ${taskDirRel}\nBranch: ${actualBranch}`,
+    "info",
+  );
+
+  // Build and dispatch the quick task prompt
+  const summaryPath = `${taskDirRel}/${taskNum}-SUMMARY.md`;
+  const prompt = loadPrompt("quick-task", {
+    description,
+    taskDir: taskDirRel,
+    branch: actualBranch,
+    summaryPath,
+    date,
+    taskNum: String(taskNum),
+    slug,
+  });
+
+  pi.sendMessage(
+    {
+      customType: "gsd-quick-task",
+      content: prompt,
+      display: false,
+    },
+    { triggerTurn: true },
+  );
+}

package/src/resources/extensions/gsd/skill-discovery.ts

@@ -110,10 +110,12 @@ function listSkillDirs(): string[] {
 function parseSkillFrontmatter(path: string): { name?: string; description?: string } | null {
   try {
     const content = readFileSync(path, "utf-8");
-    const match = content.match(/^---\n([\s\S]*?)\n---/);
-    if (!match) return null;
+    // Use indexOf instead of [\s\S]*? regex to avoid backtracking (#468)
+    if (!content.startsWith('---\n')) return null;
+    const endIdx = content.indexOf('\n---', 4);
+    if (endIdx === -1) return null;
 
-    const fm = match[1];
+    const fm = content.slice(4, endIdx);
     const result: { name?: string; description?: string } = {};
 
     const nameMatch = fm.match(/^name:\s*(.+)$/m);