gsd-pi 2.67.0-dev.46f9884 → 2.67.0-dev.509bd95

package/dist/resources/extensions/gsd/commands-codebase.js

@@ -8,10 +8,11 @@ import { generateCodebaseMap, updateCodebaseMap, writeCodebaseMap, getCodebaseMa
 import { loadEffectiveGSDPreferences } from "./preferences.js";
 const USAGE = "Usage: /gsd codebase [generate|update|stats]\n\n" +
     "  generate [--max-files N] [--collapse-threshold N]  — Generate or regenerate CODEBASE.md\n" +
-    "  update [--max-files N] [--collapse-threshold N]    — Incremental update (preserves descriptions)\n" +
+    "  update [--max-files N] [--collapse-threshold N]    — Refresh the CODEBASE.md cache immediately\n" +
     "  stats                                              — Show file count, coverage, and generation time\n" +
     "  help                                               — Show this help\n\n" +
-    "With no subcommand, shows stats if a map exists or help if not.\n\n" +
+    "With no subcommand, shows stats if a map exists or help if not.\n" +
+    "GSD also refreshes CODEBASE.md automatically before prompt injection and after completed units when tracked files change.\n\n" +
     "Configure defaults via preferences.md:\n" +
     "  codebase:\n" +
     "    exclude_patterns: [\"docs/\", \"fixtures/\"]\n" +
@@ -95,7 +96,7 @@ function showStats(basePath, ctx) {
         `  Undescribed: ${stats.undescribedCount}\n` +
         `  Generated: ${stats.generatedAt ?? "unknown"}\n\n` +
         (stats.undescribedCount > 0
-            ? `Tip: Run /gsd codebase update to refresh after file changes.`
+            ? `Tip: Auto-refresh keeps the cache current, but /gsd codebase update forces an immediate refresh.`
             : `Coverage is complete.`), "info");
 }
 /**

package/dist/resources/extensions/gsd/commands-prefs-wizard.js

@@ -137,7 +137,7 @@ export function buildCategorySummaries(prefs) {
     const models = prefs.models;
     let modelsSummary = "(not configured)";
     if (models && Object.keys(models).length > 0) {
-        const parts = Object.entries(models).map(([phase, model]) => `${phase}: ${model}`);
+        const parts = Object.entries(models).map(([phase, model]) => `${phase}: ${formatConfiguredModel(model)}`);
         modelsSummary = parts.join(", ");
     }
     // Timeouts
@@ -220,8 +220,39 @@ export function buildCategorySummaries(prefs) {
     };
 }
 // ─── Category configuration functions ────────────────────────────────────────
+export function formatConfiguredModel(config) {
+    if (typeof config === "string")
+        return config;
+    if (!config || typeof config !== "object")
+        return "(invalid)";
+    const maybeConfig = config;
+    if (typeof maybeConfig.model !== "string" || maybeConfig.model.trim() === "")
+        return "(invalid)";
+    if (typeof maybeConfig.provider === "string" && maybeConfig.provider && !maybeConfig.model.includes("/")) {
+        return `${maybeConfig.provider}/${maybeConfig.model}`;
+    }
+    return maybeConfig.model;
+}
+export function toPersistedModelId(provider, modelId) {
+    if (!provider.trim())
+        return modelId;
+    const normalizedProvider = provider.trim();
+    const normalizedModelId = modelId.trim();
+    return normalizedModelId.startsWith(`${normalizedProvider}/`)
+        ? normalizedModelId
+        : `${normalizedProvider}/${normalizedModelId}`;
+}
 async function configureModels(ctx, prefs) {
-    const modelPhases = ["research", "planning", "execution", "completion"];
+    const modelPhases = [
+        "research",
+        "planning",
+        "discuss",
+        "execution",
+        "execution_simple",
+        "completion",
+        "validation",
+        "subagent",
+    ];
     const models = prefs.models ?? {};
     const availableModels = ctx.modelRegistry.getAvailable();
     if (availableModels.length > 0) {
@@ -253,7 +284,7 @@ async function configureModels(ctx, prefs) {
         });
         providerOptions.push("(keep current)", "(clear)", "(type manually)");
         for (const phase of modelPhases) {
-            const current = models[phase] ?? "";
+            const current = formatConfiguredModel(models[phase]);
             const phaseLabel = `Model for ${phase} phase${current ? ` (current: ${current})` : ""}`;
             // Step 1: pick provider
             const providerChoice = await ctx.ui.select(`${phaseLabel} — choose provider:`, providerOptions);
@@ -285,14 +316,14 @@ async function configureModels(ctx, prefs) {
                     delete models[phase];
                 }
                 else {
-                    models[phase] = modelChoice;
+                    models[phase] = toPersistedModelId(providerName, modelChoice);
                 }
             }
         }
     }
     else {
         for (const phase of modelPhases) {
-            const current = models[phase] ?? "";
+            const current = formatConfiguredModel(models[phase]);
             const input = await ctx.ui.input(`Model for ${phase} phase${current ? ` (current: ${current})` : ""}:`, current || "e.g. claude-sonnet-4-20250514");
             if (input !== null && input !== undefined) {
                 const val = input.trim();
@@ -308,6 +339,9 @@ async function configureModels(ctx, prefs) {
     if (Object.keys(models).length > 0) {
         prefs.models = models;
     }
+    else {
+        delete prefs.models;
+    }
 }
 async function configureTimeouts(ctx, prefs) {
     const autoSup = prefs.auto_supervisor ?? {};

package/dist/resources/extensions/gsd/doctor-git-checks.js

@@ -8,7 +8,7 @@ import { deriveState, isMilestoneComplete } from "./state.js";
 import { listWorktrees, resolveGitDir, worktreesDir } from "./worktree-manager.js";
 import { abortAndReset } from "./git-self-heal.js";
 import { RUNTIME_EXCLUSION_PATHS, resolveMilestoneIntegrationBranch, writeIntegrationBranch } from "./git-service.js";
-import { nativeIsRepo, nativeWorktreeList, nativeWorktreeRemove, nativeBranchList, nativeBranchDelete, nativeLsFiles, nativeRmCached, nativeHasChanges, nativeLastCommitEpoch, nativeGetCurrentBranch, nativeAddTracked, nativeCommit } from "./native-git-bridge.js";
+import { nativeIsRepo, nativeWorktreeList, nativeWorktreeRemove, nativeBranchList, nativeBranchDelete, nativeLsFiles, nativeRmCached, nativeHasChanges, nativeLastCommitEpoch, nativeGetCurrentBranch, nativeAddAllWithExclusions, nativeCommit } from "./native-git-bridge.js";
 import { getAllWorktreeHealth } from "./worktree-health.js";
 import { loadEffectiveGSDPreferences } from "./preferences.js";
 /**
@@ -380,19 +380,19 @@ export async function checkGitHealth(basePath, issues, fixesApplied, shouldFix,
                         code: "stale_uncommitted_changes",
                         scope: "project",
                         unitId: "project",
-                        message: `Uncommitted changes detected with no commit in ${mins} minute${mins === 1 ? "" : "s"} (threshold: ${thresholdMinutes}m). Snapshotting tracked files.`,
+                        message: `Uncommitted changes detected with no commit in ${mins} minute${mins === 1 ? "" : "s"} (threshold: ${thresholdMinutes}m). Snapshotting uncommitted changes.`,
                         fixable: true,
                     });
                     if (shouldFix("stale_uncommitted_changes")) {
                         try {
-                            nativeAddTracked(basePath);
+                            nativeAddAllWithExclusions(basePath, RUNTIME_EXCLUSION_PATHS);
                             const commitMsg = `gsd snapshot: uncommitted changes after ${mins}m inactivity`;
                             const result = nativeCommit(basePath, commitMsg);
                             if (result) {
                                 fixesApplied.push(`created gsd snapshot after ${mins}m of uncommitted changes`);
                             }
                             else {
-                                fixesApplied.push("gsd snapshot skipped — nothing to commit after staging tracked files");
+                                fixesApplied.push("gsd snapshot skipped — nothing to commit after staging changes");
                             }
                         }
                         catch {

package/dist/resources/extensions/gsd/doctor-proactive.js

@@ -20,8 +20,8 @@ import { readCrashLock, isLockProcessAlive, clearLock } from "./crash-recovery.j
 import { abortAndReset } from "./git-self-heal.js";
 import { rebuildState } from "./doctor.js";
 import { deriveState } from "./state.js";
-import { resolveMilestoneIntegrationBranch } from "./git-service.js";
-import { nativeIsRepo, nativeHasChanges, nativeLastCommitEpoch, nativeGetCurrentBranch, nativeAddTracked, nativeCommit } from "./native-git-bridge.js";
+import { RUNTIME_EXCLUSION_PATHS, resolveMilestoneIntegrationBranch } from "./git-service.js";
+import { nativeIsRepo, nativeHasChanges, nativeLastCommitEpoch, nativeGetCurrentBranch, nativeAddAllWithExclusions, nativeCommit } from "./native-git-bridge.js";
 import { loadEffectiveGSDPreferences } from "./preferences.js";
 import { runEnvironmentChecks } from "./doctor-environment.js";
 /** In-memory health history for the current auto-mode session. */
@@ -247,7 +247,7 @@ export async function preDispatchHealthGate(basePath) {
                 if (minutesSinceCommit >= thresholdMinutes) {
                     const mins = Math.floor(minutesSinceCommit);
                     try {
-                        nativeAddTracked(basePath);
+                        nativeAddAllWithExclusions(basePath, RUNTIME_EXCLUSION_PATHS);
                         const commitMsg = `gsd snapshot: pre-dispatch, uncommitted changes after ${mins}m inactivity`;
                         const result = nativeCommit(basePath, commitMsg);
                         if (result) {

package/dist/resources/extensions/gsd/guided-flow.js

@@ -34,6 +34,7 @@ import { findMilestoneIds, nextMilestoneId, reserveMilestoneId, getReservedMiles
 import { parkMilestone, discardMilestone } from "./milestone-actions.js";
 import { selectAndApplyModel } from "./auto-model-selection.js";
 import { DISCUSS_TOOLS_ALLOWLIST } from "./constants.js";
+import { getWorkflowTransportSupportError, getRequiredWorkflowToolsForGuidedUnit, } from "./workflow-mcp.js";
 import { runPreparation, formatCodebaseBrief, formatPriorContextBrief, formatEcosystemBrief, } from "./preparation.js";
 // ─── Preparation result storage ─────────────────────────────────────────────
 // Stores the most recent preparation result for injection into discuss prompts.
@@ -259,6 +260,21 @@ async function dispatchWorkflow(pi, note, customType = "gsd-run", ctx, unitType)
                 routing: result.routing,
             });
         }
+        const compatibilityError = getWorkflowTransportSupportError(result.appliedModel?.provider ?? ctx.model?.provider, getRequiredWorkflowToolsForGuidedUnit(unitType), {
+            projectRoot: process.cwd(),
+            surface: "guided flow",
+            unitType,
+            authMode: result.appliedModel?.provider
+                ? ctx.modelRegistry.getProviderAuthMode(result.appliedModel.provider)
+                : ctx.model?.provider
+                    ? ctx.modelRegistry.getProviderAuthMode(ctx.model.provider)
+                    : undefined,
+            baseUrl: result.appliedModel?.baseUrl ?? ctx.model?.baseUrl,
+        });
+        if (compatibilityError) {
+            ctx.ui.notify(compatibilityError, "error");
+            return;
+        }
     }
     // Scope tools for discuss flows (#2949).
     // Providers with grammar-based constrained decoding (xAI/Grok) return

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

@@ -25,11 +25,11 @@ Then:
 4. If the slice plan includes observability/diagnostic surfaces, confirm they work. Skip this for simple slices that don't have observability sections.
 5. If the slice involved runtime behavior, fill the **Operational Readiness** section (Q8) in the slice summary: health signal, failure signal, recovery procedure, and monitoring gaps. Omit entirely for simple slices with no runtime concerns.
 6. If this slice produced evidence that a requirement changed status (Active → Validated, Active → Deferred, etc.), call `gsd_requirement_update` with the requirement ID, updated `status`, and `validation` evidence. Do NOT write `.gsd/REQUIREMENTS.md` directly — the engine renders it from the database.
-7. Write `{{sliceSummaryPath}}` (compress all task summaries).
-8. Write `{{sliceUatPath}}` — a concrete UAT script with real test cases derived from the slice plan and task summaries. Include preconditions, numbered steps with expected outcomes, and edge cases. This must NOT be a placeholder or generic template — tailor every test case to what this slice actually built.
+7. Prepare the slice completion content you will pass to `gsd_complete_slice` using the camelCase fields `milestoneId`, `sliceId`, `sliceTitle`, `oneLiner`, `narrative`, `verification`, and `uatContent`. Do **not** manually write `{{sliceSummaryPath}}`. Do **not** manually write `{{sliceUatPath}}` — the DB-backed tool is the canonical write path for both artifacts.
+8. Draft the UAT content you will pass as `uatContent` — a concrete UAT script with real test cases derived from the slice plan and task summaries. Include preconditions, numbered steps with expected outcomes, and edge cases. This must NOT be a placeholder or generic template — tailor every test case to what this slice actually built.
 9. Review task summaries for `key_decisions`. Append any significant decisions to `.gsd/DECISIONS.md` if missing.
 10. Review task summaries for patterns, gotchas, or non-obvious lessons learned. If any would save future agents from repeating investigation or hitting the same issues, append them to `.gsd/KNOWLEDGE.md`. Only add entries that are genuinely useful — don't pad with obvious observations.
-11. Call `gsd_complete_slice` with milestoneId, sliceId, the slice summary, and the UAT result. Do NOT manually mark the roadmap checkbox — the tool writes to the DB and renders the ROADMAP.md projection automatically.
+11. Call `gsd_complete_slice` with the camelCase fields `milestoneId`, `sliceId`, `sliceTitle`, `oneLiner`, `narrative`, `verification`, and `uatContent`, plus any optional enrichment fields you have. Do NOT manually mark the roadmap checkbox — the tool writes to the DB, renders `{{sliceSummaryPath}}` and `{{sliceUatPath}}`, and updates the ROADMAP.md projection automatically.
 12. Do not run git commands — the system commits your changes and handles any merge after this unit succeeds.
 13. Update `.gsd/PROJECT.md` if it exists — refresh current state if needed: use the `write` tool with `path: ".gsd/PROJECT.md"` and `content` containing the full updated document reflecting current project state. Do NOT use the `edit` tool for this — PROJECT.md is a full-document refresh.
 

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

@@ -69,14 +69,14 @@ Then:
 16. 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.
 17. 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.
 18. Read the template at `~/.gsd/agent/extensions/gsd/templates/task-summary.md`
-19. Write `{{taskSummaryPath}}`
-20. Call `gsd_complete_task` with milestoneId, sliceId, taskId, and a summary of what was accomplished. This is your final required step — do NOT manually edit PLAN.md checkboxes. The tool marks the task complete, updates the DB, and renders PLAN.md automatically.
+19. Use that template to prepare the completion content you will pass to `gsd_complete_task` using the camelCase fields `milestoneId`, `sliceId`, `taskId`, `oneLiner`, `narrative`, `verification`, and `verificationEvidence`. Do **not** manually write `{{taskSummaryPath}}` — the DB-backed tool is the canonical write path and renders the summary file for you.
+20. Call `gsd_complete_task` with milestoneId, sliceId, taskId, and the completion fields derived from the template. This is your final required step — do NOT manually edit PLAN.md checkboxes. The tool marks the task complete, updates the DB, renders `{{taskSummaryPath}}`, and updates PLAN.md automatically.
 21. Do not run git commands — the system reads your task summary after completion and creates a meaningful commit from it (type inferred from title, message from your one-liner, key files from frontmatter). Write a clear, specific one-liner in the summary — it becomes the commit message.
 
 All work stays in your working directory: `{{workingDirectory}}`.
 
 **Autonomous execution:** Do not call `ask_user_questions` or `secure_env_collect`. You are running in auto-mode — there is no human available to answer questions. Make reasonable assumptions and document them in the task summary. If a decision genuinely requires human input, note it in the summary and proceed with the best available option.
 
-**You MUST call `gsd_complete_task` AND write `{{taskSummaryPath}}` before finishing.**
+**You MUST call `gsd_complete_task` before finishing. Do not manually write `{{taskSummaryPath}}`.**
 
 When done, say: "Task {{taskId}} complete."

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

@@ -62,6 +62,7 @@ Titles live inside file content (headings, frontmatter), not in file or director
   REQUIREMENTS.md       (requirement contract - tracks active/validated/deferred/out-of-scope)
   DECISIONS.md          (append-only register of architectural and pattern decisions)
   KNOWLEDGE.md          (append-only register of project-specific rules, patterns, and lessons learned)
+  CODEBASE.md           (generated codebase map cache — auto-refreshed when tracked files change)
   OVERRIDES.md          (user-issued overrides that supersede plan content via /gsd steer)
   QUEUE.md              (append-only log of queued milestones via /gsd queue)
   STATE.md
@@ -104,6 +105,7 @@ In all modes, slices commit sequentially on the active branch; there are no per-
 - **REQUIREMENTS.md** tracks the requirement contract — requirements move between Active, Validated, Deferred, Blocked, and Out of Scope as slices prove or invalidate them. Update at slice completion when evidence supports a status change.
 - **DECISIONS.md** is an append-only register of architectural and pattern decisions - read it during planning/research, append to it during execution when a meaningful decision is made
 - **KNOWLEDGE.md** is an append-only register of project-specific rules, patterns, and lessons learned. Read it at the start of every unit. Append to it when you discover a recurring issue, a non-obvious pattern, or a rule that future agents should follow.
+- **CODEBASE.md** is a generated structural cache of the tracked repository. GSD auto-refreshes it when tracked files change and injects it into system context when available. Use `/gsd codebase update` only when you need to force an immediate refresh.
 - **CONTEXT.md** files (milestone or slice level) capture the brief — scope, goals, constraints, and key decisions from discussion. When present, they are the authoritative source for what a milestone or slice is trying to achieve. Read them before planning or executing.
 - **Milestones** are major project phases (M001, M002, ...)
 - **Slices** are demoable vertical increments (S01, S02, ...) ordered by risk. After each slice completes, the roadmap is reassessed before the next slice begins.
@@ -131,6 +133,7 @@ Templates showing the expected format for each artifact type are in:
 - `/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
+- `/gsd codebase [generate|update|stats]` - manage the `.gsd/CODEBASE.md` cache used for prompt context
 - `{{shortcutDashboard}}` - toggle dashboard overlay
 - `{{shortcutShell}}` - show shell processes
 

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

@@ -40,9 +40,9 @@ After all reviewers complete, aggregate their verdicts:
 - If any reviewer says NEEDS-ATTENTION → overall verdict: `needs-attention`
 - If any reviewer says FAIL → overall verdict: `needs-remediation`
 
-### Step 3 — Write VALIDATION File
+### Step 3 — Persist Validation
 
-Write to `{{validationPath}}`:
+Prepare the validation content you will pass to `gsd_validate_milestone`. Do **not** manually write `{{validationPath}}` — the DB-backed tool is the canonical write path and renders the validation file for you.
 
 ```markdown
 ---
@@ -69,13 +69,15 @@ reviewers: 3
 <if verdict is not pass: specific actions required>
 ```
 
+Call `gsd_validate_milestone` with the camelCase fields `milestoneId`, `verdict`, `remediationRound`, `successCriteriaChecklist`, `sliceDeliveryAudit`, `crossSliceIntegration`, `requirementCoverage`, `verdictRationale`, and `remediationPlan` when needed. If you include verification-class analysis, pass it in `verificationClasses`.
+
 **DB access safety:** Do NOT query `.gsd/gsd.db` directly via `sqlite3` or `node -e require('better-sqlite3')` — the engine owns the WAL connection. Use `gsd_milestone_status` to read milestone and slice state. All data you need is already inlined in the context above or accessible via the `gsd_*` tools. Direct DB access corrupts the WAL and bypasses tool-level validation.
 
 If verdict is `needs-remediation`:
-- Add new slices to `{{roadmapPath}}` with unchecked `[ ]` status
-- These slices will be planned and executed before validation re-runs
+- Use `gsd_reassess_roadmap` to add the remediation slices instead of editing `{{roadmapPath}}` manually
+- Those slices will be planned and executed before validation re-runs
 
-**You MUST write `{{validationPath}}` before finishing.**
+**You MUST call `gsd_validate_milestone` before finishing. Do not manually write `{{validationPath}}`.**
 
 **File system safety:** When scanning milestone directories for evidence, use `ls` or `find` to list directory contents first — never pass a directory path (e.g. `tasks/`, `slices/`) directly to the `read` tool. The `read` tool only accepts file paths, not directories.