gsd-pi 2.76.0 → 2.77.0-dev.538325aea

package/src/resources/extensions/gsd/hook-emitter.ts

@@ -0,0 +1,188 @@
+// GSD Extension — Layer 2 Event Emitter Bridge
+//
+// Holds a module-scoped reference to the ExtensionAPI so deeply-nested code
+// (auto-loop, git-service callers, verification, budget) can emit Layer 2
+// events without having to thread `pi` through every function signature.
+//
+// Set once from `registerGsdExtension`. All emitters are best-effort — a
+// missing `pi` (e.g. in standalone unit tests) silently becomes a no-op.
+
+import type { ExtensionAPI } from "@gsd/pi-coding-agent";
+import type {
+  BeforeCommitEventResult,
+  BeforePrEventResult,
+  BeforePushEventResult,
+  BeforeVerifyEventResult,
+  BudgetThresholdEventResult,
+  VerifyFailure,
+} from "@gsd/pi-coding-agent";
+
+let _pi: ExtensionAPI | undefined;
+
+export function setHookEmitter(pi: ExtensionAPI): void {
+  _pi = pi;
+}
+
+export function clearHookEmitter(): void {
+  _pi = undefined;
+}
+
+// ─── Notification ──────────────────────────────────────────────────────────
+
+export async function emitNotification(
+  kind: "blocked" | "input_needed" | "milestone_ready" | "idle" | "error",
+  message: string,
+  details?: Record<string, unknown>,
+): Promise<void> {
+  if (!_pi) return;
+  await _pi.emitExtensionEvent({ type: "notification", kind, message, details });
+}
+
+// ─── Git Lifecycle ─────────────────────────────────────────────────────────
+
+export async function emitBeforeCommit(args: {
+  message: string;
+  files: string[];
+  cwd: string;
+  author?: string;
+}): Promise<BeforeCommitEventResult | undefined> {
+  if (!_pi) return undefined;
+  return (await _pi.emitExtensionEvent({
+    type: "before_commit",
+    ...args,
+  })) as BeforeCommitEventResult | undefined;
+}
+
+export async function emitCommit(args: {
+  sha: string;
+  message: string;
+  files: string[];
+  cwd: string;
+}): Promise<void> {
+  if (!_pi) return;
+  await _pi.emitExtensionEvent({ type: "commit", ...args });
+}
+
+export async function emitBeforePush(args: {
+  remote: string;
+  branch: string;
+  cwd: string;
+}): Promise<BeforePushEventResult | undefined> {
+  if (!_pi) return undefined;
+  return (await _pi.emitExtensionEvent({
+    type: "before_push",
+    ...args,
+  })) as BeforePushEventResult | undefined;
+}
+
+export async function emitPush(args: { remote: string; branch: string; cwd: string }): Promise<void> {
+  if (!_pi) return;
+  await _pi.emitExtensionEvent({ type: "push", ...args });
+}
+
+export async function emitBeforePr(args: {
+  branch: string;
+  targetBranch: string;
+  title: string;
+  body: string;
+  cwd: string;
+}): Promise<BeforePrEventResult | undefined> {
+  if (!_pi) return undefined;
+  return (await _pi.emitExtensionEvent({
+    type: "before_pr",
+    ...args,
+  })) as BeforePrEventResult | undefined;
+}
+
+export async function emitPrOpened(args: {
+  url: string;
+  branch: string;
+  targetBranch: string;
+  cwd: string;
+}): Promise<void> {
+  if (!_pi) return;
+  await _pi.emitExtensionEvent({ type: "pr_opened", ...args });
+}
+
+// ─── Verification ──────────────────────────────────────────────────────────
+
+export async function emitBeforeVerify(args: {
+  unitType?: string;
+  unitId?: string;
+  cwd: string;
+}): Promise<BeforeVerifyEventResult | undefined> {
+  if (!_pi) return undefined;
+  return (await _pi.emitExtensionEvent({
+    type: "before_verify",
+    ...args,
+  })) as BeforeVerifyEventResult | undefined;
+}
+
+export async function emitVerifyResult(args: {
+  passed: boolean;
+  failures: VerifyFailure[];
+  unitType?: string;
+  unitId?: string;
+  cwd: string;
+}): Promise<void> {
+  if (!_pi) return;
+  await _pi.emitExtensionEvent({ type: "verify_result", ...args });
+}
+
+// ─── Budget ────────────────────────────────────────────────────────────────
+
+export async function emitBudgetThreshold(args: {
+  fraction: number;
+  spent: number;
+  limit: number;
+}): Promise<BudgetThresholdEventResult | undefined> {
+  if (!_pi) return undefined;
+  return (await _pi.emitExtensionEvent({
+    type: "budget_threshold",
+    fraction: args.fraction,
+    spent: args.spent,
+    limit: args.limit,
+    currency: "USD",
+  })) as BudgetThresholdEventResult | undefined;
+}
+
+// ─── Orchestrator Boundaries ───────────────────────────────────────────────
+
+export async function emitMilestoneStart(args: {
+  milestoneId: string;
+  title?: string;
+  cwd: string;
+}): Promise<void> {
+  if (!_pi) return;
+  await _pi.emitExtensionEvent({ type: "milestone_start", ...args });
+}
+
+export async function emitMilestoneEnd(args: {
+  milestoneId: string;
+  status: "completed" | "failed" | "cancelled";
+  cwd: string;
+}): Promise<void> {
+  if (!_pi) return;
+  await _pi.emitExtensionEvent({ type: "milestone_end", ...args });
+}
+
+export async function emitUnitStart(args: {
+  unitType: string;
+  unitId: string;
+  milestoneId?: string;
+  cwd: string;
+}): Promise<void> {
+  if (!_pi) return;
+  await _pi.emitExtensionEvent({ type: "unit_start", ...args });
+}
+
+export async function emitUnitEnd(args: {
+  unitType: string;
+  unitId: string;
+  milestoneId?: string;
+  status: "completed" | "failed" | "cancelled" | "blocked";
+  cwd: string;
+}): Promise<void> {
+  if (!_pi) return;
+  await _pi.emitExtensionEvent({ type: "unit_end", ...args });
+}

package/src/resources/extensions/gsd/init-wizard.ts

@@ -10,7 +10,7 @@ import type { ExtensionAPI, ExtensionCommandContext } from "@gsd/pi-coding-agent
 import { existsSync, mkdirSync, writeFileSync, readFileSync } from "node:fs";
 import { join } from "node:path";
 import { showNextAction } from "../shared/tui.js";
-import { nativeIsRepo, nativeInit } from "./native-git-bridge.js";
+import { nativeIsRepo, nativeInit, nativeAddAll, nativeCommit } from "./native-git-bridge.js";
 import { ensureGitignore, untrackRuntimeFiles } from "./gitignore.js";
 import { gsdRoot } from "./paths.js";
 import { assertSafeDirectory } from "./validate-directory.js";
@@ -74,6 +74,7 @@ export async function showProjectInit(
   }
 
   // ── Step 2: Git setup ──────────────────────────────────────────────────────
+  let didInitGit = false;
   if (!signals.isGitRepo) {
     const gitChoice = await showNextAction(ctx, {
       title: "GSD — Project Setup",
@@ -89,6 +90,7 @@ export async function showProjectInit(
 
     if (gitChoice === "init_git") {
       nativeInit(basePath, prefs.mainBranch);
+      didInitGit = true;
     }
   } else {
     // Auto-detect main branch from existing repo
@@ -295,6 +297,18 @@ export async function showProjectInit(
   ensureGitignore(basePath);
   untrackRuntimeFiles(basePath);
 
+  // Create initial commit so git log and git worktree work immediately (#4530).
+  // Without this, the branch is "unborn" (zero commits) and downstream operations
+  // like `git log` and `git worktree add` fail.
+  if (didInitGit) {
+    try {
+      nativeAddAll(basePath);
+      nativeCommit(basePath, "chore: init project");
+    } catch {
+      // Non-fatal — user can commit manually; don't block project init
+    }
+  }
+
   // Auto-generate codebase map for instant agent orientation
   try {
     const result = generateCodebaseMap(basePath);

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

@@ -39,7 +39,8 @@ export type JournalEventType =
   | "worktree-create-failed"
   | "worktree-skip"
   | "worktree-merge-start"
-  | "worktree-merge-failed";
+  | "worktree-merge-failed"
+  | "artifact-verification-retry";
 
 /** A single structured event in the journal. */
 export interface JournalEntry {

package/src/resources/extensions/gsd/key-manager.ts

@@ -35,6 +35,12 @@ export interface ProviderInfo {
 export const PROVIDER_REGISTRY: ProviderInfo[] = [
   // LLM Providers
   { id: "anthropic",        label: "Anthropic (Claude)",      category: "llm", envVar: "ANTHROPIC_API_KEY",      prefixes: ["sk-ant-"], hasOAuth: true, dashboardUrl: "console.anthropic.com" },
+  // Claude Code CLI: routes through the local `claude` binary — no API key,
+  // authentication is handled by the CLI's own OAuth flow.
+  // Referenced by doctor-providers.ts, auto-model-selection.ts, and others;
+  // must be in the canonical registry so all consumers see the same catalog.
+  // See: https://github.com/gsd-build/gsd-2/issues/4541
+  { id: "claude-code",      label: "Claude Code CLI",         category: "llm",                                   hasOAuth: true },
   { id: "openai",           label: "OpenAI",                  category: "llm", envVar: "OPENAI_API_KEY",         prefixes: ["sk-"],     dashboardUrl: "platform.openai.com/api-keys" },
   { id: "github-copilot",   label: "GitHub Copilot",          category: "llm", envVar: "GITHUB_TOKEN",           hasOAuth: true },
   { id: "openai-codex",     label: "ChatGPT Plus/Pro (Codex)",category: "llm",                                   hasOAuth: true },
@@ -45,6 +51,8 @@ export const PROVIDER_REGISTRY: ProviderInfo[] = [
   { id: "xai",              label: "xAI (Grok)",              category: "llm", envVar: "XAI_API_KEY",            dashboardUrl: "console.x.ai" },
   { id: "openrouter",       label: "OpenRouter",              category: "llm", envVar: "OPENROUTER_API_KEY",     dashboardUrl: "openrouter.ai/keys" },
   { id: "mistral",          label: "Mistral",                 category: "llm", envVar: "MISTRAL_API_KEY",        dashboardUrl: "console.mistral.ai" },
+  { id: "minimax",          label: "MiniMax",                 category: "llm", envVar: "MINIMAX_API_KEY",        dashboardUrl: "platform.minimax.io" },
+  { id: "minimax-cn",       label: "MiniMax CN",              category: "llm", envVar: "MINIMAX_CN_API_KEY",     dashboardUrl: "platform.minimax.io" },
   { id: "ollama-cloud",     label: "Ollama Cloud",            category: "llm", envVar: "OLLAMA_API_KEY" },
   { id: "custom-openai",    label: "Custom (OpenAI-compat)",  category: "llm", envVar: "CUSTOM_OPENAI_API_KEY" },
   { id: "cerebras",         label: "Cerebras",                category: "llm", envVar: "CEREBRAS_API_KEY" },
@@ -480,6 +488,26 @@ const TEST_ENDPOINTS: Record<string, { url: string; method?: string; headers?: (
     url: "https://api.mistral.ai/v1/models",
     headers: (key) => ({ Authorization: `Bearer ${key}` }),
   },
+  minimax: {
+    url: "https://api.minimax.io/anthropic/v1/messages",
+    method: "POST",
+    headers: (key) => ({
+      "x-api-key": key,
+      "anthropic-version": "2023-06-01",
+      "content-type": "application/json",
+    }),
+    body: JSON.stringify({ model: "MiniMax-M2.7", max_tokens: 1, messages: [{ role: "user", content: "hi" }] }),
+  },
+  "minimax-cn": {
+    url: "https://api.minimaxi.com/anthropic/v1/messages",
+    method: "POST",
+    headers: (key) => ({
+      "x-api-key": key,
+      "anthropic-version": "2023-06-01",
+      "content-type": "application/json",
+    }),
+    body: JSON.stringify({ model: "MiniMax-M2.7", max_tokens: 1, messages: [{ role: "user", content: "hi" }] }),
+  },
   openrouter: {
     url: "https://openrouter.ai/api/v1/models",
     headers: (key) => ({ Authorization: `Bearer ${key}` }),

package/src/resources/extensions/gsd/memory-backfill.ts

@@ -0,0 +1,140 @@
+// GSD2 — Decisions -> memories backfill (ADR-013 step 5)
+//
+// Idempotent one-shot migration that copies every active decisions row into
+// the memories table with category="architecture" and a structured_fields
+// payload preserving the original gsd_save_decision schema (when_context,
+// scope, decision, choice, rationale, made_by, revisable, sourceDecisionId).
+//
+// The backfill exists so the cutover in ADR-013 step 6 can drop the
+// decisions table without losing schema fidelity. Idempotency is enforced
+// by tagging each backfilled memory with structured_fields.sourceDecisionId
+// and skipping any decision whose ID already appears in the memories table.
+//
+// Triggered opportunistically by buildBeforeAgentStartResult so the cost
+// only ever fires once per project. Costs O(N) inserts on first run where
+// N is the active-decisions count; subsequent runs are an O(N) lookup that
+// finds existing markers and exits.
+
+import { isDbAvailable, _getAdapter } from "./gsd-db.js";
+import { createMemory } from "./memory-store.js";
+import { logWarning } from "./workflow-logger.js";
+
+interface DecisionRow {
+  id: string;
+  when_context: string;
+  scope: string;
+  decision: string;
+  choice: string;
+  rationale: string;
+  made_by: string;
+  revisable: string;
+  superseded_by: string | null;
+}
+
+/**
+ * Backfill active decisions rows into the memories table.
+ *
+ * - Idempotent (per-row): every row written carries
+ *   `structured_fields.sourceDecisionId = "<decisionId>"`. Each candidate
+ *   decision is checked individually; only decisions whose id is already
+ *   present in the memory store are skipped. A user-authored memory with
+ *   their own `sourceDecisionId` does NOT abort the backfill.
+ * - Best-effort: never throws. Logs and returns 0 on failure so a broken
+ *   backfill cannot block agent startup.
+ * - Active-only: skips rows where `superseded_by IS NOT NULL`. Superseded
+ *   decisions are historical record; the memory store is for active
+ *   knowledge.
+ *
+ * Returns the number of memories written (0 when already backfilled or
+ * when the DB has no decisions). Callers can log the result or surface it
+ * to the user.
+ */
+export function backfillDecisionsToMemories(): number {
+  if (!isDbAvailable()) return 0;
+  const adapter = _getAdapter();
+  if (!adapter) return 0;
+
+  try {
+    const decisions = adapter
+      .prepare("SELECT id, when_context, scope, decision, choice, rationale, made_by, revisable, superseded_by FROM decisions WHERE superseded_by IS NULL")
+      .all() as Array<Record<string, unknown>>;
+
+    if (decisions.length === 0) return 0;
+
+    // Per-row idempotency: each memory backfilled from a decision carries
+    // structured_fields.sourceDecisionId="<decisionId>". Skipping is decided
+    // per row by matching that exact id, NOT by a global sentinel — a global
+    // sentinel would silently abort the backfill if a user manually called
+    // capture_thought with their own structuredFields.sourceDecisionId.
+    const checkExisting = adapter.prepare(
+      "SELECT 1 FROM memories WHERE structured_fields LIKE :pattern LIMIT 1",
+    );
+
+    let written = 0;
+    for (const raw of decisions) {
+      const row: DecisionRow = {
+        id: String(raw["id"] ?? ""),
+        when_context: String(raw["when_context"] ?? ""),
+        scope: String(raw["scope"] ?? ""),
+        decision: String(raw["decision"] ?? ""),
+        choice: String(raw["choice"] ?? ""),
+        rationale: String(raw["rationale"] ?? ""),
+        made_by: String(raw["made_by"] ?? "agent"),
+        revisable: String(raw["revisable"] ?? ""),
+        superseded_by: raw["superseded_by"] == null ? null : String(raw["superseded_by"]),
+      };
+      if (!row.id) continue;
+
+      // Pattern is anchored to the JSON-stringified shape and the exact
+      // decision id to avoid prefix collisions (e.g. "D1" vs "D10").
+      if (checkExisting.get({ ":pattern": `%"sourceDecisionId":"${row.id}"%` })) continue;
+
+      const content = synthesizeContent(row);
+      const id = createMemory({
+        category: "architecture",
+        content,
+        scope: row.scope || "project",
+        confidence: 0.85,
+        structuredFields: {
+          sourceDecisionId: row.id,
+          when_context: row.when_context,
+          scope: row.scope,
+          decision: row.decision,
+          choice: row.choice,
+          rationale: row.rationale,
+          made_by: row.made_by,
+          revisable: row.revisable,
+        },
+      });
+      if (id) written += 1;
+    }
+
+    return written;
+  } catch (e) {
+    logWarning("memory-backfill", `decisions->memories backfill failed: ${(e as Error).message}`);
+    return 0;
+  }
+}
+
+/**
+ * Combine the decision's structured fields into a 1-3 sentence content
+ * string suitable for keyword retrieval and human review.
+ *
+ * Format: "<decision> Chose: <choice>. Rationale: <rationale>."
+ * Truncates each field to keep the synthesized line under ~600 chars so
+ * memory_query rendering stays readable.
+ */
+function synthesizeContent(row: DecisionRow): string {
+  const trim = (value: string, max: number): string => {
+    const cleaned = value.replace(/\s+/g, " ").trim();
+    return cleaned.length > max ? cleaned.slice(0, max - 1) + "\u2026" : cleaned;
+  };
+  const parts: string[] = [];
+  const decision = trim(row.decision, 240);
+  const choice = trim(row.choice, 200);
+  const rationale = trim(row.rationale, 200);
+  if (decision) parts.push(decision);
+  if (choice) parts.push(`Chose: ${choice}.`);
+  if (rationale) parts.push(`Rationale: ${rationale}.`);
+  return parts.join(" ");
+}

package/src/resources/extensions/gsd/memory-store.ts

@@ -36,6 +36,12 @@ export interface Memory {
   hit_count: number;
   scope: string;
   tags: string[];
+  /**
+   * ADR-013 Step 2: optional structured payload. NULL for memories captured
+   * via plain capture_thought. Populated on memories backfilled from the
+   * decisions table (Step 5) with the original scope/decision/choice/etc.
+   */
+  structured_fields: Record<string, unknown> | null;
 }
 
 export type MemoryActionCreate = {
@@ -45,6 +51,7 @@ export type MemoryActionCreate = {
   confidence?: number;
   scope?: string;
   tags?: string[];
+  structuredFields?: Record<string, unknown> | null;
 };
 
 export type MemoryActionUpdate = {
@@ -108,9 +115,22 @@ function rowToMemory(row: Record<string, unknown>): Memory {
     hit_count: row['hit_count'] as number,
     scope: (row['scope'] as string) ?? 'project',
     tags: parseTags(row['tags']),
+    structured_fields: parseStructuredFields(row['structured_fields']),
   };
 }
 
+function parseStructuredFields(raw: unknown): Record<string, unknown> | null {
+  if (typeof raw !== 'string' || raw.length === 0) return null;
+  try {
+    const parsed = JSON.parse(raw);
+    return parsed && typeof parsed === 'object' && !Array.isArray(parsed)
+      ? (parsed as Record<string, unknown>)
+      : null;
+  } catch {
+    return null;
+  }
+}
+
 function parseTags(raw: unknown): string[] {
   if (typeof raw !== 'string' || raw.length === 0) return [];
   try {
@@ -477,6 +497,7 @@ export function createMemory(fields: {
   source_unit_id?: string;
   scope?: string;
   tags?: string[];
+  structuredFields?: Record<string, unknown> | null;
 }): string | null {
   if (!isDbAvailable()) return null;
   const adapter = _getAdapter();
@@ -497,6 +518,7 @@ export function createMemory(fields: {
       updatedAt: now,
       scope: fields.scope ?? 'project',
       tags: fields.tags ?? [],
+      structuredFields: fields.structuredFields ?? null,
     });
     // Derive the real ID from the assigned seq (SELECT is still fine via adapter)
     const row = adapter.prepare('SELECT seq FROM memories WHERE id = :id').get({ ':id': placeholder });
@@ -684,6 +706,10 @@ export function applyMemoryActions(
               source_unit_id: unitId,
               scope: action.scope,
               tags: action.tags,
+              // ADR-013: forward structured payload through the action layer so
+              // bulk applyMemoryActions callers (extraction, ingestion) don't
+              // silently drop it.
+              structuredFields: action.structuredFields ?? null,
             });
             break;
           case 'UPDATE':

package/src/resources/extensions/gsd/model-router.ts

@@ -561,6 +561,23 @@ function bareModelId(modelId: string): string {
   return modelId.includes("/") ? modelId.split("/").pop()! : modelId;
 }
 
+// ─── Provider-specific Tool Limits ─────────────────────────────────────────
+
+/**
+ * Groq enforces a hard limit of 128 tools per request.
+ * Requests exceeding this limit receive a 400 error:
+ * "maximum number of items is 128"
+ * @see https://console.groq.com/docs/tool-use
+ */
+export const GROQ_MAX_TOOLS = 128;
+
+/**
+ * Provider IDs that map to the Groq API backend.
+ * Used to detect Groq at the GSD routing layer where only the provider string
+ * is available (the pi-ai openai-completions adapter is shared across providers).
+ */
+const GROQ_PROVIDER_IDS = new Set(["groq"]);
+
 // ─── Tool Compatibility Filter (ADR-005 Phase 3) ───────────────────────────
 
 /**
@@ -588,10 +605,17 @@ export function isToolCompatibleWithProvider(
 /**
  * Filter a list of tool names to only those compatible with a provider.
  * Used by the routing pipeline to adjust tool sets when switching providers.
+ *
+ * @param toolNames - The full list of active tool names to filter.
+ * @param providerApi - The pi-ai API string (e.g. "openai-completions").
+ * @param provider - Optional provider ID (e.g. "groq"). Used to apply
+ *   provider-specific limits that can't be expressed as API-level capabilities
+ *   (e.g. Groq's 128-tool hard limit on the shared openai-completions adapter).
  */
 export function filterToolsForProvider(
   toolNames: string[],
   providerApi: string,
+  provider?: string,
 ): { compatible: string[]; filtered: string[] } {
   const providerCaps = getProviderCapabilities(providerApi);
 
@@ -611,6 +635,17 @@ export function filterToolsForProvider(
     }
   }
 
+  // Groq enforces a hard limit of 128 tools per request (#4376).
+  // Trim the compatible list to GROQ_MAX_TOOLS and move the excess to filtered.
+  if (provider && GROQ_PROVIDER_IDS.has(provider) && compatible.length > GROQ_MAX_TOOLS) {
+    const trimmed = compatible.splice(GROQ_MAX_TOOLS);
+    filtered.push(...trimmed);
+    console.warn(
+      `[gsd] Groq tool limit: ${compatible.length + trimmed.length} tools active but Groq allows at most ${GROQ_MAX_TOOLS}. ` +
+        `Trimming to the first ${GROQ_MAX_TOOLS} tools. Removed: ${trimmed.join(", ")}`,
+    );
+  }
+
   return { compatible, filtered };
 }
 
@@ -620,11 +655,17 @@ export function filterToolsForProvider(
  *
  * This is a hard filter only — it removes tools that would fail at the
  * provider level. It does NOT remove tools based on soft heuristics.
+ *
+ * @param activeToolNames - The full list of currently active tool names.
+ * @param selectedModelApi - The pi-ai API string for the selected model.
+ * @param provider - Optional provider ID (e.g. "groq") for provider-specific
+ *   limits beyond what the API-level capability profile expresses.
  */
 export function adjustToolSet(
   activeToolNames: string[],
   selectedModelApi: string,
+  provider?: string,
 ): { toolNames: string[]; removedTools: string[] } {
-  const { compatible, filtered } = filterToolsForProvider(activeToolNames, selectedModelApi);
+  const { compatible, filtered } = filterToolsForProvider(activeToolNames, selectedModelApi, provider);
   return { toolNames: compatible, removedTools: filtered };
 }

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

@@ -91,8 +91,13 @@ export function extractPackageReferences(description: string): string[] {
     }
   }
 
-  // require('pkg') or import from 'pkg' in code blocks
-  const importPattern = /(?:require\s*\(\s*['"]|from\s+['"])([a-zA-Z0-9@/_-]+)['"\)]/g;
+  // require('pkg') or `import ... from 'pkg'` in code blocks.
+  // The `from\s+['"]` branch MUST be preceded by an `import` keyword so that
+  // natural-language prose like `from "What's Next"` or `from 'master'` does
+  // not produce false package-existence failures.  Requiring the leading import
+  // keyword anchors the match to JavaScript/TypeScript syntax.
+  // See: https://github.com/gsd-build/gsd-2/issues/4388
+  const importPattern = /(?:require\s*\(\s*['"]|import\b[\s\S]*?\bfrom\s+['"])([a-zA-Z0-9@/_-]+)['"\)]/g;
   let importMatch: RegExpExecArray | null;
   while ((importMatch = importPattern.exec(description)) !== null) {
     // Skip relative imports and node builtins
@@ -323,9 +328,24 @@ function extractPathFromAnnotation(raw: string): string {
     return backtickMatch[2].trim();
   }
 
+  // Strip leading/trailing double or single quotes wrapping the whole value.
+  // Plan documents sometimes emit `"src/foo.ts"` or `'src/bar.ts'` as input
+  // annotations. Stripping the wrapper allows the inner path to be checked
+  // correctly instead of producing a false-positive "file not found" error
+  // for a literal string with quote characters in it (#3747).
+  const quoteMatch = trimmed.match(/^(["'])([^"']+)\1$/);
+  if (quoteMatch) {
+    return quoteMatch[2].trim();
+  }
+
   const annotatedMatch = trimmed.match(/^(.+?)\s+[—–-]\s+.+$/);
   if (annotatedMatch) {
-    return annotatedMatch[1].trim();
+    const prefix = annotatedMatch[1].trim();
+    const prefixBacktickMatch = prefix.match(/`([^`]+)`/);
+    if (prefixBacktickMatch && looksLikePathOrUrl(prefixBacktickMatch[1].trim())) {
+      return prefixBacktickMatch[1].trim();
+    }
+    return prefix.replace(/`/g, "").trim();
   }
 
   // Fallback: scan all backticked tokens and return the first one that looks
@@ -388,13 +408,19 @@ function containsGlobPattern(candidate: string): boolean {
 
 /**
  * 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
+ * run and its outputs are available regardless of sequence position or disk state (#4071).
  * All paths are normalized for consistent comparison.
  */
 function getExpectedOutputsUpTo(tasks: TaskRow[], taskIndex: number): Set<string> {
   const outputs = new Set<string>();
-  for (let i = 0; i < taskIndex; i++) {
-    for (const file of tasks[i].expected_output) {
-      outputs.add(normalizeFilePath(file));
+  for (let i = 0; i < tasks.length; i++) {
+    const task = tasks[i];
+    // Include prior tasks (i < taskIndex) OR completed tasks at any position
+    if (i < taskIndex || task.status === "completed") {
+      for (const file of task.expected_output) {
+        outputs.add(normalizeFilePath(file));
+      }
     }
   }
   return outputs;
@@ -481,13 +507,19 @@ export function checkTaskOrdering(
   const results: PreExecutionCheckJSON[] = [];
 
   // Build map: normalized file → task index that creates it
-  const fileCreators = new Map<string, { taskId: string; index: number; originalPath: string }>();
+  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);
-      if (!fileCreators.has(normalizedFile)) {
-        fileCreators.set(normalizedFile, { taskId: task.id, index: i, originalPath: file });
+      const existing = fileCreators.get(normalizedFile);
+      if (!existing || (!existing.completed && task.status === "completed")) {
+        fileCreators.set(normalizedFile, {
+          taskId: task.id,
+          index: i,
+          originalPath: file,
+          completed: task.status === "completed",
+        });
       }
     }
   }
@@ -511,7 +543,11 @@ export function checkTaskOrdering(
       const creator = fileCreators.get(normalizedFile);
       const absolutePath = resolve(basePath, normalizedFile);
       const existsOnDisk = existsSync(absolutePath);
-      if (creator && creator.index > i && !existsOnDisk) {
+      // 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
+      // reads this pre-execution output). (#4071)
+      if (creator && creator.index > i && !existsOnDisk && !creator.completed) {
         // Task reads file that is created later — impossible ordering
         results.push({
           category: "file",