gsd-pi 2.82.0-dev.ed17d078d → 3.0.0-dev.04f5ccf82

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

@@ -357,6 +357,11 @@ export function resolveGsdPathContract(
   };
 }
 
+export function gsdProjectionRoot(basePath: string): string {
+  const contract = resolveGsdPathContract(basePath);
+  return normalizeRealPath(contract.worktreeGsd ?? contract.projectGsd);
+}
+
 /**
  * Invalidate the gsdRoot cache.
  * Use ONLY at session-reset boundaries: workspace switch, process exit, or

package/src/resources/extensions/gsd/pending-auto-start.ts

@@ -0,0 +1,79 @@
+// GSD-2 — Pending auto-start handoff state.
+// Stores discuss-to-auto handoff entries keyed by project root.
+
+import type { ExtensionAPI, ExtensionCommandContext } from "@gsd/pi-coding-agent";
+import { createWorkspace, scopeMilestone, type MilestoneScope } from "./workspace.js";
+
+export interface PendingAutoStartEntry {
+  ctx: ExtensionCommandContext;
+  pi: ExtensionAPI;
+  basePath: string;
+  milestoneId: string;
+  step?: boolean;
+  createdAt: number;
+  readyRejectCount?: number;
+  scope: MilestoneScope;
+  planBlockedRecoveryCount: number;
+}
+
+export interface PendingAutoStartInput {
+  basePath: string;
+  milestoneId: string;
+  ctx: ExtensionCommandContext;
+  pi: ExtensionAPI;
+  step?: boolean;
+  createdAt?: number;
+}
+
+const pendingAutoStartMap = new Map<string, PendingAutoStartEntry>();
+
+export function getPendingAutoStart(basePath?: string): PendingAutoStartEntry | null {
+  if (basePath) return pendingAutoStartMap.get(basePath) ?? null;
+  if (pendingAutoStartMap.size === 1) return pendingAutoStartMap.values().next().value!;
+  return null;
+}
+
+export const _getPendingAutoStart = getPendingAutoStart;
+
+export function hasPendingAutoStart(basePath?: string): boolean {
+  if (basePath) return pendingAutoStartMap.has(basePath);
+  return pendingAutoStartMap.size > 0;
+}
+
+export function setPendingAutoStart(basePath: string, entry: PendingAutoStartInput): void {
+  if (!entry.ctx || !entry.pi) {
+    throw new Error("setPendingAutoStart requires ctx and pi");
+  }
+  const ws = createWorkspace(entry.basePath);
+  const scope = scopeMilestone(ws, entry.milestoneId);
+  pendingAutoStartMap.set(basePath, {
+    createdAt: Date.now(),
+    planBlockedRecoveryCount: 0,
+    ...entry,
+    scope,
+    ctx: entry.ctx,
+    pi: entry.pi,
+  });
+}
+
+export function deletePendingAutoStart(basePath: string): void {
+  pendingAutoStartMap.delete(basePath);
+}
+
+export function clearPendingAutoStart(basePath?: string): void {
+  if (basePath) {
+    pendingAutoStartMap.delete(basePath);
+  } else {
+    pendingAutoStartMap.clear();
+  }
+}
+
+export function getDiscussionMilestoneId(basePath?: string): string | null {
+  if (basePath) {
+    return pendingAutoStartMap.get(basePath)?.milestoneId ?? null;
+  }
+  if (pendingAutoStartMap.size === 1) {
+    return pendingAutoStartMap.values().next().value!.milestoneId;
+  }
+  return null;
+}

package/src/resources/extensions/gsd/planning-path-scope.ts

@@ -13,6 +13,10 @@ function isInsideBase(basePath: string, candidate: string): boolean {
   return rel === "" || (!!rel && !rel.startsWith("..") && !isAbsolute(rel));
 }
 
+function isInsideAnyBase(bases: string[], candidate: string): boolean {
+  return bases.some((base) => isInsideBase(base, candidate));
+}
+
 /**
  * Planning IO fields are execution contracts. Absolute paths are only safe when
  * they stay inside the active working directory; in worktree mode, an absolute
@@ -21,13 +25,17 @@ function isInsideBase(basePath: string, candidate: string): boolean {
 export function validatePlanningPathScope(
   basePath: string,
   fields: PlanningPathScopeField[],
+  allowedAbsoluteRoots?: string[],
 ): string | null {
+  const absoluteRoots = (allowedAbsoluteRoots && allowedAbsoluteRoots.length > 0)
+    ? allowedAbsoluteRoots
+    : [basePath];
   for (const { field, values } of fields) {
     for (const raw of values) {
       const candidate = normalizePlannedFileReference(raw);
       if (!isAbsolute(candidate)) continue;
-      if (isInsideBase(basePath, candidate)) continue;
-      return `${field} contains absolute path outside working directory: ${candidate}. Use a path relative to ${basePath}.`;
+      if (isInsideAnyBase(absoluteRoots, candidate)) continue;
+      return `${field} contains absolute path outside allowed repository roots: ${candidate}. Use a path relative to one of: ${absoluteRoots.join(", ")}.`;
     }
   }
 

package/src/resources/extensions/gsd/post-execution-checks.ts

@@ -46,6 +46,46 @@ export interface PostExecutionResult {
 
 // ─── Import Resolution Check ─────────────────────────────────────────────────
 
+/**
+ * Replace the contents of single- and double-quoted string literals on a single
+ * source line with spaces so import patterns do not match text inside strings.
+ * Template-literal spans are handled separately via the inTemplateLiteral flag.
+ */
+function stripStringLiterals(line: string): string {
+  let result = "";
+  let i = 0;
+
+  while (i < line.length) {
+    const ch = line[i];
+
+    if (ch === '"' || ch === "'") {
+      result += ch;
+      i++;
+
+      while (i < line.length) {
+        const c = line[i];
+
+        if (c === "\\" && i + 1 < line.length) {
+          result += "  ";
+          i += 2;
+        } else if (c === ch) {
+          result += ch;
+          i++;
+          break;
+        } else {
+          result += " ";
+          i++;
+        }
+      }
+    } else {
+      result += ch;
+      i++;
+    }
+  }
+
+  return result;
+}
+
 /**
  * Extract relative import paths from TypeScript/JavaScript source code.
  * Returns array of { importPath, lineNum } for relative imports.
@@ -62,14 +102,23 @@ export function extractRelativeImports(
   //   import './path'
   //   require('./path')
   //   require("../path")
-  const importPattern = /(?:import\s+(?:.*?\s+from\s+)?|require\s*\(\s*)(['"])(\.\.?\/[^'"]+)\1/g;
+  const importPattern = /(?:^|[;{}]\s*)import\s+(?:.*?\s+from\s+)?(['"])(\.\.?\/[^'"]+)\1/g;
+  const requirePattern = /require\s*\(\s*(['"])(\.\.?\/[^'"]+)\1/g;
 
   // Track if we're inside a block comment
   let inBlockComment = false;
+  let inTemplateLiteral = false;
 
   for (let i = 0; i < lines.length; i++) {
     const line = lines[i];
 
+    if (inTemplateLiteral) {
+      if ((line.match(/(?<!\\)`/g) ?? []).length % 2 === 1) {
+        inTemplateLiteral = false;
+      }
+      continue;
+    }
+
     // Handle block comment boundaries
     if (inBlockComment) {
       if (line.includes("*/")) {
@@ -101,10 +150,22 @@ export function extractRelativeImports(
 
     // Reset lastIndex for each line
     importPattern.lastIndex = 0;
+    requirePattern.lastIndex = 0;
+
+    const strippedLine = stripStringLiterals(line);
 
     while ((match = importPattern.exec(line)) !== null) {
+      const importOffset = match[0].indexOf("import");
+      const importStart = match.index + importOffset;
+      if (
+        strippedLine.slice(importStart, importStart + "import".length) !==
+        "import"
+      ) {
+        continue;
+      }
+
       // Check if this match is after a // comment marker on the same line
-      const beforeMatch = line.substring(0, match.index);
+      const beforeMatch = strippedLine.substring(0, match.index);
       if (beforeMatch.includes("//")) {
         continue;
       }
@@ -114,6 +175,30 @@ export function extractRelativeImports(
         lineNum: i + 1,
       });
     }
+
+    while ((match = requirePattern.exec(line)) !== null) {
+      if (
+        strippedLine.slice(match.index, match.index + "require".length) !==
+        "require"
+      ) {
+        continue;
+      }
+
+      // Check if this match is after a // comment marker on the same line
+      const beforeMatch = strippedLine.substring(0, match.index);
+      if (beforeMatch.includes("//")) {
+        continue;
+      }
+
+      imports.push({
+        importPath: match[2],
+        lineNum: i + 1,
+      });
+    }
+
+    if ((strippedLine.match(/(?<!\\)`/g) ?? []).length % 2 === 1) {
+      inTemplateLiteral = true;
+    }
   }
 
   return imports;
@@ -159,16 +244,6 @@ export function resolveImportPath(
       ".woff", ".woff2", ".ttf", ".otf", ".eot",
     ]);
     const runtimeFallbackExtensions = new Set([".js", ".jsx", ".mjs", ".cjs"]);
-    const dottedStemFallbackExtensions = new Set([".server", ".client", ".webhook"]);
-
-    if (
-      explicitExt !== "" &&
-      !runtimeFallbackExtensions.has(explicitExt) &&
-      !nonFallbackExtensions.has(explicitExt) &&
-      !dottedStemFallbackExtensions.has(explicitExt)
-    ) {
-      return { exists: false, resolvedPath: null };
-    }
 
     if (nonFallbackExtensions.has(explicitExt) && !runtimeFallbackExtensions.has(explicitExt)) {
       return { exists: false, resolvedPath: null };

package/src/resources/extensions/gsd/pre-execution-checks.ts

@@ -20,9 +20,10 @@
 import { existsSync } from "node:fs";
 import { spawn } from "node:child_process";
 import { homedir } from "node:os";
-import { resolve } from "node:path";
+import { isAbsolute, relative, resolve } from "node:path";
 import type { TaskRow } from "./db-task-slice-rows.js";
 import type { PreExecutionCheckJSON } from "./verification-evidence.ts";
+import { validateVerificationCommand } from "./verification-gate.js";
 
 const NPM_COMMAND = process.platform === "win32" ? "npm.cmd" : "npm";
 
@@ -37,6 +38,39 @@ export interface PreExecutionResult {
   durationMs: number;
 }
 
+export interface PreExecutionCheckContext {
+  additionalRoots?: string[];
+}
+
+export function checkVerificationCommands(tasks: TaskRow[]): PreExecutionCheckJSON[] {
+  const results: PreExecutionCheckJSON[] = [];
+
+  for (const task of tasks) {
+    const verify = task.verify.trim();
+    if (!verify) continue;
+
+    const commands = verify
+      .split("&&")
+      .map((command) => command.trim())
+      .filter(Boolean);
+
+    for (const command of commands) {
+      const validation = validateVerificationCommand(command);
+      if (!validation.ok) {
+        results.push({
+          category: "tool",
+          target: `${task.id} Verify`,
+          passed: false,
+          message: `Unsafe or non-runnable Verify command: ${command} (${validation.reason})`,
+          blocking: true,
+        });
+      }
+    }
+  }
+
+  return results;
+}
+
 // ─── Package Existence Check ─────────────────────────────────────────────────
 
 /**
@@ -105,7 +139,7 @@ export function extractPackageReferences(description: string): string[] {
   while ((importMatch = importPattern.exec(description)) !== null) {
     // Skip relative imports and node builtins
     const pkg = importMatch[1];
-    if (!pkg.startsWith(".") && !pkg.startsWith("node:")) {
+    if (!pkg.startsWith(".") && !pkg.startsWith("node:") && !pkg.startsWith("@/")) {
       packages.add(normalizePackageName(pkg));
     }
   }
@@ -341,7 +375,7 @@ function extractPathFromAnnotation(raw: string): string {
     return quoteMatch[2].trim();
   }
 
-  const annotatedMatch = trimmed.match(/^(.+?)\s+[—–-]\s+.+$/);
+  const annotatedMatch = trimmed.match(/^(.+?)(?:\s+[—–-]\s+.+|\s+\([^()]+\))$/);
   if (annotatedMatch) {
     const prefix = annotatedMatch[1].trim();
     const prefixBacktickMatch = prefix.match(/`([^`]+)`/);
@@ -415,6 +449,14 @@ function containsGlobPattern(candidate: string): boolean {
   return ["*", "?", "[", "]", "{", "}"].some((char) => candidate.includes(char));
 }
 
+function toComparisonPath(filePath: string, basePath: string): string {
+  const normalized = normalizeFilePath(filePath);
+  if (!isAbsolute(normalized)) return normalized;
+  const normalizedBasePath = normalizeFilePath(basePath);
+  const rel = normalizeFilePath(relative(normalizedBasePath, normalized));
+  return rel && !rel.startsWith("..") && rel !== "." ? rel : normalized;
+}
+
 /**
  * Build a set of files that will be created by tasks up to (but not including) taskIndex.
  * Also includes outputs of completed tasks at any position — a completed task has already
@@ -450,9 +492,11 @@ function getExpectedOutputsUpTo(tasks: TaskRow[], taskIndex: number): Set<string
  */
 export function checkFilePathConsistency(
   tasks: TaskRow[],
-  basePath: string
+  basePath: string,
+  context?: PreExecutionCheckContext,
 ): PreExecutionCheckJSON[] {
   const results: PreExecutionCheckJSON[] = [];
+  const resolutionRoots = [basePath, ...(context?.additionalRoots ?? [])];
 
   // Build a set of all files created by any task at any position (normalized).
   // Used to suppress consistency errors for files that will be caught with a
@@ -460,14 +504,16 @@ export function checkFilePathConsistency(
   const allTaskOutputs = new Set<string>();
   for (const t of tasks) {
     for (const f of t.expected_output) {
-      allTaskOutputs.add(normalizeFilePath(f));
+      allTaskOutputs.add(toComparisonPath(f, basePath));
     }
   }
 
   for (let i = 0; i < tasks.length; i++) {
     const task = tasks[i];
-    const priorOutputs = getExpectedOutputsUpTo(tasks, i);
-    const ownOutputs = new Set<string>(task.expected_output.map(normalizeFilePath));
+    const priorOutputs = new Set<string>(
+      Array.from(getExpectedOutputsUpTo(tasks, i), (filePath) => toComparisonPath(filePath, basePath)),
+    );
+    const ownOutputs = new Set<string>(task.expected_output.map((filePath) => toComparisonPath(filePath, basePath)));
     const filesToCheck = [...task.inputs];
 
     for (const file of filesToCheck) {
@@ -476,12 +522,11 @@ export function checkFilePathConsistency(
       if (!shouldValidateInputAsPath(file)) continue;
 
       // Normalize path for consistent comparison
-      const normalizedFile = normalizeFilePath(file);
+      const normalizedFile = toComparisonPath(file, basePath);
       if (containsGlobPattern(normalizedFile)) continue;
 
       // Check if file exists on disk
-      const absolutePath = resolve(basePath, normalizedFile);
-      const existsOnDisk = existsSync(absolutePath);
+      const existsOnDisk = resolutionRoots.some((root) => existsSync(resolve(root, normalizedFile)));
 
       // Check if file is in prior expected outputs (priorOutputs already normalized)
       const inPriorOutputs = priorOutputs.has(normalizedFile);
@@ -527,16 +572,18 @@ export function checkFilePathConsistency(
  */
 export function checkTaskOrdering(
   tasks: TaskRow[],
-  basePath: string
+  basePath: string,
+  context?: PreExecutionCheckContext,
 ): PreExecutionCheckJSON[] {
   const results: PreExecutionCheckJSON[] = [];
+  const resolutionRoots = [basePath, ...(context?.additionalRoots ?? [])];
 
   // Build map: normalized file → task index that creates it
   const fileCreators = new Map<string, { taskId: string; index: number; originalPath: string; completed: boolean }>();
   for (let i = 0; i < tasks.length; i++) {
     const task = tasks[i];
     for (const file of task.expected_output) {
-      const normalizedFile = normalizeFilePath(file);
+      const normalizedFile = toComparisonPath(file, basePath);
       const existing = fileCreators.get(normalizedFile);
       if (!existing || (!existing.completed && task.status === "completed")) {
         fileCreators.set(normalizedFile, {
@@ -560,15 +607,14 @@ export function checkTaskOrdering(
       if (isRuntimeOnlyInput(file)) continue;
       if (!shouldValidateInputAsPath(file)) continue;
 
-      const normalizedFile = normalizeFilePath(file);
+      const normalizedFile = toComparisonPath(file, basePath);
       if (containsGlobPattern(normalizedFile)) continue;
       // A directory reference like `artifacts/M009-S03/` is never a concrete
       // read-before-create dependency: the fileCreators map is keyed by leaf
       // files, and a same-task output under the directory satisfies it.
       if (isDirectoryReference(file)) continue;
       const creator = fileCreators.get(normalizedFile);
-      const absolutePath = resolve(basePath, normalizedFile);
-      const existsOnDisk = existsSync(absolutePath);
+      const existsOnDisk = resolutionRoots.some((root) => existsSync(resolve(root, normalizedFile)));
       // Skip if the creating task has already completed — its output is available
       // regardless of disk state (e.g. file was a temp artifact cleaned up after
       // the task ran, or a replan introduced a new earlier-sequence task that
@@ -748,17 +794,19 @@ export function checkInterfaceContracts(
  */
 export async function runPreExecutionChecks(
   tasks: TaskRow[],
-  basePath: string
+  basePath: string,
+  context?: PreExecutionCheckContext,
 ): Promise<PreExecutionResult> {
   const startTime = Date.now();
   const allChecks: PreExecutionCheckJSON[] = [];
 
   // Run sync checks first
-  const fileChecks = checkFilePathConsistency(tasks, basePath);
-  const orderingChecks = checkTaskOrdering(tasks, basePath);
+  const fileChecks = checkFilePathConsistency(tasks, basePath, context);
+  const orderingChecks = checkTaskOrdering(tasks, basePath, context);
   const contractChecks = checkInterfaceContracts(tasks, basePath);
+  const verificationChecks = checkVerificationCommands(tasks);
 
-  allChecks.push(...fileChecks, ...orderingChecks, ...contractChecks);
+  allChecks.push(...fileChecks, ...orderingChecks, ...contractChecks, ...verificationChecks);
 
   // Run async package checks
   const packageChecks = await checkPackageExistence(tasks, basePath);

package/src/resources/extensions/gsd/preferences-mcp.ts

@@ -0,0 +1,27 @@
+import type { ClaudeCodeMcpConfig, ClaudeCodeMcpPerModelEntry } from "./preferences-types.js";
+
+/**
+ * Resolve MCP server config for a given model ID using longest-prefix-wins matching.
+ *
+ * Keys in config.per_model are model-ID prefixes. When modelId.startsWith(key),
+ * the key is a candidate; the longest matching key wins. Returns undefined when
+ * no key matches or per_model is empty.
+ */
+export function resolveModelMcpConfig(
+  modelId: string,
+  config: ClaudeCodeMcpConfig,
+): ClaudeCodeMcpPerModelEntry | undefined {
+  let bestKey: string | undefined;
+
+  const perModel = config.per_model ?? {};
+
+  for (const key of Object.keys(perModel)) {
+    if (modelId.startsWith(key)) {
+      if (bestKey === undefined || key.length > bestKey.length) {
+        bestKey = key;
+      }
+    }
+  }
+
+  return bestKey !== undefined ? perModel[bestKey] : undefined;
+}

package/src/resources/extensions/gsd/preferences-models.ts

@@ -46,8 +46,9 @@ export function resolveModelForUnit(unitType: string): string | undefined {
  */
 export function resolveModelWithFallbacksForUnit(unitType: string): ResolvedModelConfig | undefined {
   const prefs = loadEffectiveGSDPreferences(undefined, { availableModelIds: [] });
-  if (!prefs?.preferences.models) return undefined;
-  const m = prefs.preferences.models as GSDModelConfigV2;
+  const models = prefs?.preferences?.models;
+  if (!models) return undefined;
+  const m = models as GSDModelConfigV2;
 
   let phaseConfig: string | GSDPhaseModelConfig | undefined;
   switch (unitType) {
@@ -151,9 +152,10 @@ export function resolveDefaultSessionModel(
   sessionProvider?: string,
 ): { provider: string; id: string } | undefined {
   const prefs = loadEffectiveGSDPreferences(undefined, { availableModelIds: [] });
-  if (!prefs?.preferences.models) return undefined;
+  const models = prefs?.preferences?.models;
+  if (!models) return undefined;
 
-  const m = prefs.preferences.models as GSDModelConfigV2;
+  const m = models as GSDModelConfigV2;
 
   // Priority: execution → planning → first configured value
   const candidates: Array<string | GSDPhaseModelConfig | undefined> = [

package/src/resources/extensions/gsd/preferences-types.ts

@@ -124,6 +124,7 @@ export const KNOWN_PREFERENCE_KEYS = new Set<string>([
   "verification_commands",
   "verification_auto_fix",
   "verification_max_retries",
+  "per_unit_cost_cap_usd",
   "search_provider",
   "context_selection",
   "widget_mode",
@@ -152,6 +153,8 @@ export const KNOWN_PREFERENCE_KEYS = new Set<string>([
   "context_window_override",
   "context_mode",
   "planning_depth",
+  "claude_code_mcp",
+  "workspace",
 ]);
 
 /**
@@ -320,6 +323,33 @@ export interface CodebaseMapPreferences {
   collapse_threshold?: number;
 }
 
+/** Per-model MCP server allow/block lists for a single model prefix. */
+export interface ClaudeCodeMcpPerModelEntry {
+  allowed_servers?: string[];
+  blocked_servers?: string[];
+}
+
+/** Top-level claude_code_mcp preference: maps model-ID prefixes to server filter lists. */
+export interface ClaudeCodeMcpConfig {
+  per_model?: Record<string, ClaudeCodeMcpPerModelEntry>;
+}
+
+export interface WorkspaceRepositoryPreference {
+  /** Child repository path; relative paths resolve from the project root. */
+  path: string;
+  /** Optional human-oriented role label (for prompts/reporting). */
+  role?: string;
+  /** Optional default verification commands for this repository. */
+  verification?: string[];
+  /** Optional per-repository commit execution policy for auto-mode turn commits. */
+  commit_policy?: "auto" | "skip";
+}
+
+export interface WorkspacePreferences {
+  /** Parent-workspace uses one parent .gsd coordinating child repos. */
+  mode?: "project" | "parent";
+  repositories?: Record<string, WorkspaceRepositoryPreference>;
+}
 export interface GSDPreferences {
   version?: number;
   mode?: WorkflowMode;
@@ -381,6 +411,7 @@ export interface GSDPreferences {
   verification_commands?: string[];
   verification_auto_fix?: boolean;
   verification_max_retries?: number;
+  per_unit_cost_cap_usd?: number;
   /** Search provider preference. "brave"/"tavily"/"ollama" force that backend and disable native Anthropic search. "native" forces native only. "auto" = current default behavior. */
   search_provider?: "brave" | "tavily" | "ollama" | "native" | "auto";
   /** Context selection mode for file inlining. "full" inlines entire files, "smart" uses semantic chunking. Default derived from token profile. */
@@ -415,6 +446,8 @@ export interface GSDPreferences {
   experimental?: ExperimentalPreferences;
   /** Configuration for the codebase map generator (/gsd codebase). */
   codebase?: CodebaseMapPreferences;
+  /** Multi-repository parent workspace configuration. */
+  workspace?: WorkspacePreferences;
   /** Slice-level parallelism within a milestone. Disabled by default. */
   slice_parallel?: { enabled?: boolean; max_workers?: number };
   /** LLM safety harness configuration. Monitors, validates, and constrains LLM behavior during auto-mode. Enabled by default with warn-and-continue policy. */
@@ -499,6 +532,8 @@ export interface GSDPreferences {
    * (e.g. "Chinese", "zh", "German", "de", "日本語"). Persists across /clear.
    */
   language?: string;
+  /** Per-model MCP server filtering configuration. Uses longest-prefix-wins matching. */
+  claude_code_mcp?: ClaudeCodeMcpConfig;
 }
 
 export interface LoadedGSDPreferences {