gsd-pi 2.20.0 → 2.22.0

package/dist/resources/extensions/gsd/auto-dashboard.ts

@@ -340,7 +340,8 @@ export function updateProgressWidget(
             let meta = theme.fg("dim", `${done}/${total} slices`);
 
             if (activeSliceTasks && activeSliceTasks.total > 0) {
-              meta += theme.fg("dim", `  ·  task ${activeSliceTasks.done + 1}/${activeSliceTasks.total}`);
+              const taskNum = Math.min(activeSliceTasks.done + 1, activeSliceTasks.total);
+              meta += theme.fg("dim", `  ·  task ${taskNum}/${activeSliceTasks.total}`);
             }
 
             lines.push(truncateToWidth(`${pad}${bar}  ${meta}`, width));

package/dist/resources/extensions/gsd/auto-prompts.ts

@@ -15,11 +15,41 @@ import {
   relMilestoneFile, relSliceFile, relSlicePath, relMilestonePath,
   resolveGsdRootFile, relGsdRootFile,
 } from "./paths.js";
-import { resolveSkillDiscoveryMode, resolveInlineLevel } from "./preferences.js";
+import { resolveSkillDiscoveryMode, resolveInlineLevel, loadEffectiveGSDPreferences } from "./preferences.js";
 import type { GSDState, InlineLevel } from "./types.js";
 import type { GSDPreferences } from "./preferences.js";
 import { join } from "node:path";
 import { existsSync } from "node:fs";
+import { computeBudgets, resolveExecutorContextWindow } from "./context-budget.js";
+
+// ─── Executor Constraints ─────────────────────────────────────────────────────
+
+/**
+ * Format executor context constraints for injection into the plan-slice prompt.
+ * Uses the budget engine to compute task count ranges and inline context budgets
+ * based on the configured executor model's context window.
+ */
+function formatExecutorConstraints(): string {
+  let windowTokens: number;
+  try {
+    const prefs = loadEffectiveGSDPreferences();
+    windowTokens = resolveExecutorContextWindow(undefined, prefs?.preferences);
+  } catch {
+    windowTokens = 200_000; // safe default
+  }
+  const budgets = computeBudgets(windowTokens);
+  const { min, max } = budgets.taskCountRange;
+  const execWindowK = Math.round(windowTokens / 1000);
+  const perTaskBudgetK = Math.round(budgets.inlineContextBudgetChars / 1000);
+  return [
+    `## Executor Context Constraints`,
+    ``,
+    `The agent that executes each task has a **${execWindowK}K token** context window.`,
+    `- Recommended task count for this slice: **${min}–${max} tasks**`,
+    `- Each task gets ~${perTaskBudgetK}K chars of inline context (plans, code, decisions)`,
+    `- Keep individual tasks completable within a single context window — if a task needs more context than fits, split it`,
+  ].join("\n");
+}
 
 // ─── Inline Helpers ───────────────────────────────────────────────────────
 
@@ -603,6 +633,9 @@ export async function buildPlanSlicePrompt(
 
   const inlinedContext = `## Inlined Context (preloaded — do not re-read these files)\n\n${inlined.join("\n\n---\n\n")}`;
 
+  // Build executor context constraints from the budget engine
+  const executorContextConstraints = formatExecutorConstraints();
+
   const outputRelPath = relSliceFile(base, mid, sid, "PLAN");
   return loadPrompt("plan-slice", {
     workingDirectory: base,
@@ -613,6 +646,7 @@ export async function buildPlanSlicePrompt(
     outputPath: join(base, outputRelPath),
     inlinedContext,
     dependencySummaries: depContent,
+    executorContextConstraints,
   });
 }
 
@@ -682,6 +716,12 @@ export async function buildExecuteTaskPrompt(
   const activeOverrides = await loadActiveOverrides(base);
   const overridesSection = formatOverridesSection(activeOverrides);
 
+  // Compute verification budget for the executor's context window (issue #707)
+  const prefs = loadEffectiveGSDPreferences();
+  const contextWindow = resolveExecutorContextWindow(undefined, prefs?.preferences);
+  const budgets = computeBudgets(contextWindow);
+  const verificationBudget = `~${Math.round(budgets.verificationBudgetChars / 1000)}K chars`;
+
   return loadPrompt("execute-task", {
     overridesSection,
     workingDirectory: base,
@@ -696,6 +736,7 @@ export async function buildExecuteTaskPrompt(
     priorTaskLines: priorLines,
     taskSummaryPath,
     inlinedTemplates,
+    verificationBudget,
   });
 }
 

package/dist/resources/extensions/gsd/auto-worktree.ts

@@ -264,11 +264,29 @@ export function isInAutoWorktree(basePath: string): boolean {
 }
 
 /**
- * Get the filesystem path for an auto-worktree, or null if it doesn't exist.
+ * Get the filesystem path for an auto-worktree, or null if it doesn't exist
+ * or is not a valid git worktree.
+ *
+ * Validates that the path is a real git worktree (has a .git file with a
+ * gitdir: pointer) rather than just a stray directory. This prevents
+ * mis-detection of leftover directories as active worktrees (#695).
  */
 export function getAutoWorktreePath(basePath: string, milestoneId: string): string | null {
   const p = worktreePath(basePath, milestoneId);
-  return existsSync(p) ? p : null;
+  if (!existsSync(p)) return null;
+
+  // Validate this is a real git worktree, not a stray directory.
+  // A git worktree has a .git *file* (not directory) containing "gitdir: <path>".
+  const gitPath = join(p, ".git");
+  if (!existsSync(gitPath)) return null;
+  try {
+    const content = readFileSync(gitPath, "utf8").trim();
+    if (!content.startsWith("gitdir: ")) return null;
+  } catch {
+    return null;
+  }
+
+  return p;
 }
 
 /**
@@ -283,6 +301,21 @@ export function enterAutoWorktree(basePath: string, milestoneId: string): string
     throw new Error(`Auto-worktree for ${milestoneId} does not exist at ${p}`);
   }
 
+  // Validate this is a real git worktree, not a stray directory (#695)
+  const gitPath = join(p, ".git");
+  if (!existsSync(gitPath)) {
+    throw new Error(`Auto-worktree path ${p} exists but is not a git worktree (no .git)`);
+  }
+  try {
+    const content = readFileSync(gitPath, "utf8").trim();
+    if (!content.startsWith("gitdir: ")) {
+      throw new Error(`Auto-worktree path ${p} has a .git but it is not a worktree gitdir pointer`);
+    }
+  } catch (err) {
+    if (err instanceof Error && err.message.includes("worktree")) throw err;
+    throw new Error(`Auto-worktree path ${p} exists but .git is unreadable`);
+  }
+
   const previousCwd = process.cwd();
 
   try {

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

@@ -40,7 +40,7 @@ import {
   readUnitRuntimeRecord,
   writeUnitRuntimeRecord,
 } from "./unit-runtime.js";
-import { resolveAutoSupervisorConfig, resolveModelWithFallbacksForUnit, loadEffectiveGSDPreferences, resolveSkillDiscoveryMode, resolveDynamicRoutingConfig } from "./preferences.js";
+import { resolveAutoSupervisorConfig, resolveModelWithFallbacksForUnit, loadEffectiveGSDPreferences, resolveSkillDiscoveryMode, resolveDynamicRoutingConfig, getIsolationMode } from "./preferences.js";
 import { sendDesktopNotification } from "./notifications.js";
 import type { GSDPreferences } from "./preferences.js";
 import { classifyUnitComplexity, tierLabel } from "./complexity-classifier.js";
@@ -82,7 +82,7 @@ import {
 import { join } from "node:path";
 import { sep as pathSep } from "node:path";
 import { homedir } from "node:os";
-import { readdirSync, readFileSync, existsSync, mkdirSync, writeFileSync, unlinkSync, statSync } from "node:fs";
+import { readdirSync, readFileSync, existsSync, mkdirSync, writeFileSync, unlinkSync, statSync, cpSync } from "node:fs";
 import { nativeIsRepo, nativeInit, nativeAddPaths, nativeCommit } from "./native-git-bridge.js";
 import {
   autoCommitCurrentBranch,
@@ -146,6 +146,45 @@ import {
 import { isDbAvailable } from "./gsd-db.js";
 import { hasPendingCaptures, loadPendingCaptures, countPendingCaptures } from "./captures.js";
 
+// ─── Worktree → Project Root State Sync ───────────────────────────────────────
+// When running in an auto-worktree, dispatch state (.gsd/ metadata) diverges
+// between the worktree (where work happens) and the project root (where
+// startAutoMode reads initial state on restart). Without syncing, restarting
+// auto-mode reads stale state from the project root and re-dispatches
+// already-completed units.
+
+/**
+ * Sync dispatch-critical .gsd/ state files from worktree to project root.
+ * Only runs when inside an auto-worktree (worktreePath differs from projectRoot).
+ * Copies: STATE.md + active milestone directory (roadmap, slice plans, task summaries).
+ * Non-fatal — sync failure should never block dispatch.
+ */
+function syncStateToProjectRoot(worktreePath: string, projectRoot: string, milestoneId: string | null): void {
+  if (!worktreePath || !projectRoot || worktreePath === projectRoot) return;
+  if (!milestoneId) return;
+
+  const wtGsd = join(worktreePath, ".gsd");
+  const prGsd = join(projectRoot, ".gsd");
+
+  // 1. STATE.md — the quick-glance status used by initial deriveState()
+  try {
+    const src = join(wtGsd, "STATE.md");
+    const dst = join(prGsd, "STATE.md");
+    if (existsSync(src)) cpSync(src, dst, { force: true });
+  } catch { /* non-fatal */ }
+
+  // 2. Milestone directory — ROADMAP, slice PLANs, task summaries
+  // Copy the entire milestone .gsd subtree so deriveState reads current checkboxes
+  try {
+    const srcMilestone = join(wtGsd, "milestones", milestoneId);
+    const dstMilestone = join(prGsd, "milestones", milestoneId);
+    if (existsSync(srcMilestone)) {
+      mkdirSync(dstMilestone, { recursive: true });
+      cpSync(srcMilestone, dstMilestone, { recursive: true, force: true });
+    }
+  } catch { /* non-fatal */ }
+}
+
 // ─── State ────────────────────────────────────────────────────────────────────
 
 let active = false;
@@ -204,12 +243,15 @@ function checkResourcesStale(): string | null {
 
 /**
  * Resolve whether auto-mode should use worktree isolation.
- * Returns true for worktree mode (default), false for branch mode.
+ * Returns true for worktree mode (default), false for branch and none modes.
  * Branch mode works directly in the project root — useful for repos
  * with git submodules where worktrees don't work well (#531).
+ * None mode skips all worktree and milestone-branch logic — commits
+ * land on the current branch with no isolation (#M001-S02).
  */
-function shouldUseWorktreeIsolation(): boolean {
+export function shouldUseWorktreeIsolation(): boolean {
   const prefs = loadEffectiveGSDPreferences()?.preferences?.git;
+  if (prefs?.isolation === "none") return false;
   if (prefs?.isolation === "branch") return false;
   return true; // default: worktree
 }
@@ -244,6 +286,9 @@ function escapeStaleWorktree(base: string): string {
 /** Crash recovery prompt — set by startAuto, consumed by first dispatchNextUnit */
 let pendingCrashRecovery: string | null = null;
 
+/** Session file path captured at pause — used to synthesize recovery briefing on resume */
+let pausedSessionFile: string | null = null;
+
 /** Dashboard tracking */
 let autoStartTime: number = 0;
 let completedUnits: { type: string; id: string; startedAt: number; finishedAt: number }[] = [];
@@ -588,6 +633,7 @@ export async function stopAuto(ctx?: ExtensionContext, pi?: ExtensionAPI): Promi
   clearActivityLogState();
   resetProactiveHealing();
   pendingCrashRecovery = null;
+  pausedSessionFile = null;
   _handlingAgentEnd = false;
   ctx?.ui.setStatus("gsd-auto", undefined);
   ctx?.ui.setWidget("gsd-progress", undefined);
@@ -612,6 +658,11 @@ export async function stopAuto(ctx?: ExtensionContext, pi?: ExtensionAPI): Promi
 export async function pauseAuto(ctx?: ExtensionContext, _pi?: ExtensionAPI): Promise<void> {
   if (!active) return;
   clearUnitTimeout();
+
+  // Capture the current session file before clearing state — used for
+  // recovery briefing on resume so the next agent knows what already happened.
+  pausedSessionFile = ctx?.sessionManager?.getSessionFile() ?? null;
+
   if (lockBase()) clearLock(lockBase());
 
   // Remove SIGTERM handler registered at auto-mode start
@@ -666,7 +717,7 @@ export async function startAuto(
 
     // ── Auto-worktree: re-enter worktree on resume if not already inside ──
     // Skip if already inside a worktree (manual /worktree) to prevent nesting.
-    // Skip entirely in branch isolation mode (#531).
+    // Skip entirely in branch or none isolation mode (#531).
     if (currentMilestoneId && shouldUseWorktreeIsolation() && originalBasePath && !isInAutoWorktree(basePath) && !detectWorktreeName(basePath) && !detectWorktreeName(originalBasePath)) {
       try {
         const existingWtPath = getAutoWorktreePath(originalBasePath, currentMilestoneId);
@@ -709,11 +760,33 @@ export async function startAuto(
     // Self-heal: clear stale runtime records where artifacts already exist
     await selfHealRuntimeRecords(basePath, ctx, completedKeySet);
     invalidateAllCaches();
+
+    // Synthesize recovery briefing from the paused session so the next agent
+    // knows what already happened (reuses crash recovery infrastructure).
+    if (pausedSessionFile) {
+      const activityDir = join(gsdRoot(basePath), "activity");
+      const recovery = synthesizeCrashRecovery(
+        basePath,
+        currentUnit?.type ?? "unknown",
+        currentUnit?.id ?? "unknown",
+        pausedSessionFile,
+        activityDir,
+      );
+      if (recovery && recovery.trace.toolCallCount > 0) {
+        pendingCrashRecovery = recovery.prompt;
+        ctx.ui.notify(
+          `Recovered ${recovery.trace.toolCallCount} tool calls from paused session. Resuming with context.`,
+          "info",
+        );
+      }
+      pausedSessionFile = null;
+    }
+
     await dispatchNextUnit(ctx, pi);
     return;
   }
 
-  // Ensure git repo exists — GSD needs it for worktree isolation
+  // Ensure git repo exists — GSD needs it for commits and state tracking
   if (!nativeIsRepo(base)) {
     const mainBranch = loadEffectiveGSDPreferences()?.preferences?.git?.main_branch || "main";
     nativeInit(base, mainBranch);
@@ -793,6 +866,23 @@ export async function startAuto(
 
   let state = await deriveState(base);
 
+  // ── Stale worktree state recovery (#654) ─────────────────────────────────
+  // When auto-mode was previously stopped and restarted, the project root's
+  // .gsd/ directory may have stale metadata (completed units showing as
+  // incomplete). If an auto-worktree exists for the active milestone, it has
+  // the current state — re-derive from there to avoid re-dispatching
+  // finished work.
+  if (
+    state.activeMilestone &&
+    shouldUseWorktreeIsolation() &&
+    !detectWorktreeName(base)
+  ) {
+    const wtPath = getAutoWorktreePath(base, state.activeMilestone.id);
+    if (wtPath) {
+      state = await deriveState(wtPath);
+    }
+  }
+
   // ── Milestone branch recovery (#601) ─────────────────────────────────────
   // When auto-mode was previously stopped, the milestone branch is preserved
   // but the worktree is removed. The project root (integration branch) may
@@ -921,7 +1011,9 @@ export async function startAuto(
   // of the repo's default (main/master). Idempotent when the branch is the
   // same; updates the record when started from a different branch (#300).
   if (currentMilestoneId) {
-    captureIntegrationBranch(base, currentMilestoneId, { commitDocs });
+    if (getIsolationMode() !== "none") {
+      captureIntegrationBranch(base, currentMilestoneId, { commitDocs });
+    }
     setActiveMilestoneId(base, currentMilestoneId);
   }
 
@@ -1183,6 +1275,17 @@ export async function handleAgentEnd(
       // Non-fatal
     }
 
+    // ── Sync worktree state back to project root ──────────────────────────
+    // Ensures that if auto-mode restarts, deriveState(projectRoot) reads
+    // current milestone progress instead of stale pre-worktree state (#654).
+    if (originalBasePath && originalBasePath !== basePath) {
+      try {
+        syncStateToProjectRoot(basePath, originalBasePath, currentMilestoneId);
+      } catch {
+        // Non-fatal — stale state is the existing behavior, sync is an improvement
+      }
+    }
+
     // ── Rewrite-docs completion: resolve overrides and reset circuit breaker ──
     if (currentUnit.type === "rewrite-docs") {
       try {
@@ -1752,8 +1855,11 @@ async function dispatchNextUnit(
         }
       }
     } else {
-      // Not in worktree — just capture integration branch for the new milestone
-      captureIntegrationBranch(originalBasePath || basePath, mid, { commitDocs: loadEffectiveGSDPreferences()?.preferences?.git?.commit_docs });
+      // Not in worktree — capture integration branch for the new milestone (branch mode only).
+      // In none mode there's no milestone branch to merge back to, so skip.
+      if (getIsolationMode() !== "none") {
+        captureIntegrationBranch(originalBasePath || basePath, mid, { commitDocs: loadEffectiveGSDPreferences()?.preferences?.git?.commit_docs });
+      }
     }
 
     // Prune completed milestone from queue order file
@@ -1849,7 +1955,7 @@ async function dispatchNextUnit(
           try { process.chdir(basePath); } catch { /* best-effort */ }
         }
       }
-    } else if (currentMilestoneId && !isInAutoWorktree(basePath)) {
+    } else if (currentMilestoneId && !isInAutoWorktree(basePath) && getIsolationMode() !== "none") {
       // Branch isolation mode (#603): no worktree, but we may be on a milestone/* branch.
       // Squash-merge back to the integration branch (or main) before stopping.
       try {