gsd-pi 2.58.0-dev.778d6ac → 2.58.0-dev.d63175c

package/src/resources/extensions/gsd/error-classifier.ts

@@ -48,7 +48,7 @@ const NETWORK_RE = /network|ECONNRESET|ETIMEDOUT|ECONNREFUSED|socket hang up|fet
 const SERVER_RE = /internal server error|500|502|503|overloaded|server_error|api_error|service.?unavailable/i;
 // ECONNRESET/ECONNREFUSED are in NETWORK_RE (same-model retry first).
 const CONNECTION_RE = /terminated|connection.?refused|other side closed|EPIPE|network.?(?:is\s+)?unavailable|stream_exhausted(?:_without_result)?/i;
-const STREAM_RE = /Unexpected end of JSON|Unexpected token.*JSON|Expected.*in JSON|Unterminated.*in JSON|SyntaxError.*JSON/i;
+const STREAM_RE = /Unexpected end of JSON|Unexpected token.*JSON|Expected double-quoted property name|SyntaxError.*JSON/i;
 const RESET_DELAY_RE = /reset in (\d+)s/i;
 
 /**
@@ -58,9 +58,9 @@ const RESET_DELAY_RE = /reset in (\d+)s/i;
  *  1. Permanent (auth/billing/quota) — unless also rate-limited
  *  2. Rate limit (429, rate.?limit, too many requests)
  *  3. Network (ECONNRESET, ETIMEDOUT, socket hang up, fetch failed, dns)
- *  4. Stream truncation (malformed JSON from mid-stream cut)
- *  5. Server (500/502/503, overloaded, server_error)
- *  6. Connection (terminated, ECONNREFUSED, EPIPE, other side closed)
+ *  4. Server (500/502/503, overloaded, server_error)
+ *  5. Connection (terminated, ECONNREFUSED, EPIPE, other side closed)
+ *  6. Stream truncation (malformed JSON from mid-stream cut)
  *  7. Unknown
  */
 export function classifyError(errorMsg: string, retryAfterMs?: number): ErrorClass {
@@ -90,24 +90,21 @@ export function classifyError(errorMsg: string, retryAfterMs?: number): ErrorCla
     return { kind: "network", retryAfterMs: retryAfterMs ?? 3_000 };
   }
 
-  // 4. Stream truncation — downstream symptom of connection drop
-  //    Checked before server/connection because JSON parse errors can contain
-  //    substrings like "position 500" (matches SERVER_RE) or "Unterminated"
-  //    (matches CONNECTION_RE's "terminated" pattern).
-  if (STREAM_RE.test(errorMsg)) {
-    return { kind: "stream", retryAfterMs: retryAfterMs ?? 15_000 };
-  }
-
-  // 5. Server errors — try fallback model
+  // 4. Server errors — try fallback model
   if (SERVER_RE.test(errorMsg)) {
     return { kind: "server", retryAfterMs: retryAfterMs ?? 30_000 };
   }
 
-  // 6. Connection errors — try fallback model
+  // 5. Connection errors — try fallback model
   if (CONNECTION_RE.test(errorMsg)) {
     return { kind: "connection", retryAfterMs: retryAfterMs ?? 15_000 };
   }
 
+  // 6. Stream truncation — downstream symptom of connection drop
+  if (STREAM_RE.test(errorMsg)) {
+    return { kind: "stream", retryAfterMs: retryAfterMs ?? 15_000 };
+  }
+
   // 7. Unknown
   return { kind: "unknown" };
 }

package/src/resources/extensions/gsd/extension-manifest.json

@@ -12,22 +12,7 @@
       "gsd_requirement_update", "gsd_milestone_generate_id"
     ],
     "commands": ["gsd", "kill", "worktree", "exit"],
-    "hooks": [
-      "session_start",
-      "session_switch",
-      "bash_transform",
-      "session_fork",
-      "before_agent_start",
-      "agent_end",
-      "session_before_compact",
-      "session_shutdown",
-      "tool_call",
-      "tool_result",
-      "tool_execution_start",
-      "tool_execution_end",
-      "model_select",
-      "before_provider_request"
-    ],
+    "hooks": ["session_start", "session_switch"],
     "shortcuts": ["Ctrl+Alt+G"]
   }
 }

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

@@ -28,8 +28,6 @@ import { deriveState } from "./state.js";
 import { isAutoActive } from "./auto.js";
 import { loadPrompt } from "./prompt-loader.js";
 import { gsdRoot } from "./paths.js";
-import { isDbAvailable, getAllMilestones, getMilestoneSlices, getSliceTasks } from "./gsd-db.js";
-import { isClosedStatus } from "./status-guards.js";
 import { formatDuration } from "../shared/format-utils.js";
 import { getAutoWorktreePath } from "./auto-worktree.js";
 import { loadEffectiveGSDPreferences, loadGlobalGSDPreferences, getGlobalGSDPreferencesPath } from "./preferences.js";
@@ -87,15 +85,6 @@ interface JournalSummary {
   fileCount: number;
 }
 
-interface DbCompletionCounts {
-  milestones: number;
-  milestonesTotal: number;
-  slices: number;
-  slicesTotal: number;
-  tasks: number;
-  tasksTotal: number;
-}
-
 interface ForensicReport {
   gsdVersion: string;
   timestamp: string;
@@ -106,7 +95,6 @@ interface ForensicReport {
   unitTraces: UnitTrace[];
   metrics: MetricsLedger | null;
   completedKeys: string[];
-  dbCompletionCounts: DbCompletionCounts | null;
   crashLock: LockData | null;
   doctorIssues: DoctorIssue[];
   anomalies: ForensicAnomaly[];
@@ -118,15 +106,13 @@ interface ForensicReport {
 // ─── Duplicate Detection ──────────────────────────────────────────────────────
 
 const DEDUP_PROMPT_SECTION = `
-## Pre-Investigation: Duplicate Check (REQUIRED)
+## Duplicate Detection (REQUIRED before issue creation)
 
-Before reading GSD source code or performing deep analysis, you MUST search for existing issues and PRs that may already address this bug. This avoids wasting tokens on already-fixed bugs.
+Before offering to create a GitHub issue, you MUST search for existing issues and PRs that may already address this bug. This step uses the user's AI tokens for analysis.
 
 ### Search Steps
 
-Use keywords from the user's problem description and the anomaly summaries in the forensic report above.
-
-1. **Search closed issues** for similar keywords:
+1. **Search closed issues** for similar keywords from your diagnosis:
    \`\`\`
    gh issue list --repo gsd-build/gsd-2 --state closed --search "<keywords from root cause>" --limit 20
    \`\`\`
@@ -143,16 +129,20 @@ Use keywords from the user's problem description and the anomaly summaries in th
 
 ### Analysis
 
-For each result, compare it against the user's reported symptoms and the forensic anomalies:
+For each result, compare it against your root-cause diagnosis:
 - Does the issue describe the same code path or file?
-- Does the PR modify the area related to the reported symptoms?
+- Does the PR modify the same file:line you identified?
 - Is the symptom description semantically similar even if keywords differ?
 
-### Decision Gate
+### Present Findings
+
+If you find potential matches, present them to the user:
 
-- **Merged PR clearly fixes the described symptom** → Report "Already fixed by PR #X" with brief explanation. Skip full investigation.
-- **Open issue matches** → Report "Existing issue #Y covers this." Offer to add forensic evidence. Skip full investigation unless user asks for deeper analysis.
-- **No matches** → Proceed to full investigation below.
+1. **"Already fixed by PR #X — skip issue creation"** — when a merged PR or closed issue clearly addresses the same root cause. Explain why you believe it matches.
+2. **"Add my findings to existing issue #Y"** — when an open issue exists for the same bug. Use \`gh issue comment #Y --repo gsd-build/gsd-2\` to add forensic evidence.
+3. **"Create new issue anyway"** — when existing results do not cover this specific failure.
+
+Only proceed to issue creation if no matches were found OR the user explicitly chooses "Create new issue anyway".
 `;
 
 async function writeForensicsDedupPref(ctx: ExtensionCommandContext, enabled: boolean): Promise<void> {
@@ -260,9 +250,6 @@ export async function handleForensics(
     { customType: "gsd-forensics", content, display: false },
     { triggerTurn: true },
   );
-
-  // Persist forensics context so follow-up turns can re-inject it (#2941)
-  writeForensicsMarker(basePath, savedPath, content);
 }
 
 // ─── Report Builder ───────────────────────────────────────────────────────────
@@ -288,9 +275,8 @@ export async function buildForensicReport(basePath: string): Promise<ForensicRep
   // 3. Load metrics
   const metrics = loadLedgerFromDisk(basePath);
 
-  // 4. Load completed keys (legacy) and DB completion counts
+  // 4. Load completed keys
   const completedKeys = loadCompletedKeys(basePath);
-  const dbCompletionCounts = getDbCompletionCounts();
 
   // 5. Check crash lock
   const crashLock = readCrashLock(basePath);
@@ -349,7 +335,6 @@ export async function buildForensicReport(basePath: string): Promise<ForensicRep
     unitTraces,
     metrics,
     completedKeys,
-    dbCompletionCounts,
     crashLock,
     doctorIssues,
     anomalies,
@@ -600,44 +585,6 @@ function loadCompletedKeys(basePath: string): string[] {
   return [];
 }
 
-// ─── DB Completion Counts ────────────────────────────────────────────────────
-
-function getDbCompletionCounts(): DbCompletionCounts | null {
-  if (!isDbAvailable()) return null;
-
-  const milestones = getAllMilestones();
-  let completedMilestones = 0;
-  let totalSlices = 0;
-  let completedSlices = 0;
-  let totalTasks = 0;
-  let completedTasks = 0;
-
-  for (const m of milestones) {
-    if (isClosedStatus(m.status)) completedMilestones++;
-
-    const slices = getMilestoneSlices(m.id);
-    for (const s of slices) {
-      totalSlices++;
-      if (isClosedStatus(s.status)) completedSlices++;
-
-      const tasks = getSliceTasks(m.id, s.id);
-      for (const t of tasks) {
-        totalTasks++;
-        if (isClosedStatus(t.status)) completedTasks++;
-      }
-    }
-  }
-
-  return {
-    milestones: completedMilestones,
-    milestonesTotal: milestones.length,
-    slices: completedSlices,
-    slicesTotal: totalSlices,
-    tasks: completedTasks,
-    tasksTotal: totalTasks,
-  };
-}
-
 // ─── Anomaly Detectors ───────────────────────────────────────────────────────
 
 function detectStuckLoops(units: UnitMetrics[], anomalies: ForensicAnomaly[]): void {
@@ -702,42 +649,15 @@ function detectTimeouts(traces: UnitTrace[], anomalies: ForensicAnomaly[]): void
   }
 }
 
-/**
- * Parse a completed-unit key into its unitType and unitId.
- *
- * Hook units use a compound slash-delimited type ("hook/<hookName>"), so a
- * naive `key.indexOf("/")` would split "hook/telegram-progress/M007/S01" into
- * unitType="hook" (wrong) instead of "hook/telegram-progress".
- *
- * Returns `null` for malformed keys that cannot be split.
- */
-export function splitCompletedKey(key: string): { unitType: string; unitId: string } | null {
-  if (key.startsWith("hook/")) {
-    // Hook unit types are two segments: "hook/<hookName>/<unitId...>"
-    const secondSlash = key.indexOf("/", 5); // skip past "hook/"
-    if (secondSlash === -1) return null;     // malformed — no unitId after hook name
-    return {
-      unitType: key.slice(0, secondSlash),
-      unitId: key.slice(secondSlash + 1),
-    };
-  }
-
-  const slashIdx = key.indexOf("/");
-  if (slashIdx === -1) return null;
-  return {
-    unitType: key.slice(0, slashIdx),
-    unitId: key.slice(slashIdx + 1),
-  };
-}
-
 function detectMissingArtifacts(completedKeys: string[], basePath: string, activeMilestone: string | null, anomalies: ForensicAnomaly[]): void {
   // Also check the worktree path for artifacts — they may exist there but not at root
   const wtBasePath = activeMilestone ? getAutoWorktreePath(basePath, activeMilestone) : null;
 
   for (const key of completedKeys) {
-    const parsed = splitCompletedKey(key);
-    if (!parsed) continue;
-    const { unitType, unitId } = parsed;
+    const slashIdx = key.indexOf("/");
+    if (slashIdx === -1) continue;
+    const unitType = key.slice(0, slashIdx);
+    const unitId = key.slice(slashIdx + 1);
 
     const rootHasArtifact = verifyExpectedArtifact(unitType, unitId, basePath);
     const wtHasArtifact = wtBasePath ? verifyExpectedArtifact(unitType, unitId, wtBasePath) : false;
@@ -976,42 +896,6 @@ function saveForensicReport(basePath: string, report: ForensicReport, problemDes
   return filePath;
 }
 
-// ─── Forensics Session Marker ────────────────────────────────────────────────
-
-export interface ForensicsMarker {
-  reportPath: string;
-  promptContent: string;
-  createdAt: string;
-}
-
-/**
- * Write a marker file so that buildBeforeAgentStartResult() can re-inject
- * the forensics prompt on follow-up turns.  (#2941)
- */
-export function writeForensicsMarker(basePath: string, reportPath: string, promptContent: string): void {
-  const dir = join(gsdRoot(basePath), "runtime");
-  mkdirSync(dir, { recursive: true });
-  const marker: ForensicsMarker = {
-    reportPath,
-    promptContent,
-    createdAt: new Date().toISOString(),
-  };
-  writeFileSync(join(dir, "active-forensics.json"), JSON.stringify(marker), "utf-8");
-}
-
-/**
- * Read the active forensics marker, or null if none exists.
- */
-export function readForensicsMarker(basePath: string): ForensicsMarker | null {
-  const markerPath = join(gsdRoot(basePath), "runtime", "active-forensics.json");
-  if (!existsSync(markerPath)) return null;
-  try {
-    return JSON.parse(readFileSync(markerPath, "utf-8")) as ForensicsMarker;
-  } catch {
-    return null;
-  }
-}
-
 // ─── Prompt Formatter ─────────────────────────────────────────────────────────
 
 function formatReportForPrompt(report: ForensicReport): string {
@@ -1124,16 +1008,8 @@ function formatReportForPrompt(report: ForensicReport): string {
     sections.push("");
   }
 
-  // Completion status — prefer DB counts, fall back to legacy completed-units.json
-  if (report.dbCompletionCounts) {
-    const c = report.dbCompletionCounts;
-    sections.push(`### Completion Status (from DB)`);
-    sections.push(`- ${c.milestones}/${c.milestonesTotal} milestones complete`);
-    sections.push(`- ${c.slices}/${c.slicesTotal} slices complete`);
-    sections.push(`- ${c.tasks}/${c.tasksTotal} tasks complete`);
-  } else {
-    sections.push(`### Completed Keys: ${report.completedKeys.length}`);
-  }
+  // Completed keys count
+  sections.push(`### Completed Keys: ${report.completedKeys.length}`);
   sections.push(`### GSD Version: ${report.gsdVersion}`);
   sections.push(`### Active Milestone: ${report.activeMilestone ?? "none"}`);
   sections.push(`### Active Slice: ${report.activeSlice ?? "none"}`);

package/src/resources/extensions/gsd/git-service.ts

@@ -9,7 +9,7 @@
  */
 
 import { execFileSync, execSync } from "node:child_process";
-import { existsSync, mkdirSync, readFileSync, readdirSync, writeFileSync } from "node:fs";
+import { existsSync, mkdirSync, readFileSync, writeFileSync } from "node:fs";
 import { join } from "node:path";
 import { gsdRoot } from "./paths.js";
 import { GIT_NO_PROMPT_ENV } from "./git-constants.js";
@@ -50,9 +50,9 @@ export interface GitPreferences {
   main_branch?: string;
   merge_strategy?: "squash" | "merge";
   /** Controls auto-mode git isolation strategy.
-   *  - "worktree": creates a milestone worktree for isolated work
+   *  - "worktree": (default) creates a milestone worktree for isolated work
    *  - "branch": works directly in the project root (for submodule-heavy repos)
-   *  - "none": (default) no git isolation — commits land on the user's current branch directly
+   *  - "none": no git isolation — commits land on the user's current branch directly
    */
   isolation?: "worktree" | "branch" | "none";
   /** When false, GSD will not modify .gitignore at all — no baseline patterns
@@ -488,29 +488,6 @@ export class GitServiceImpl {
     // If .gsd/ IS in .gitignore (the default for external state projects),
     // git add -A already skips it and the exclusions are harmless no-ops.
     const allExclusions = [...RUNTIME_EXCLUSION_PATHS, ...extraExclusions];
-
-    // ── Parallel worker milestone scope (#1991) ──
-    // When GSD_MILESTONE_LOCK is set, this process is a parallel worker that
-    // must only commit files belonging to its own milestone. Exclude all other
-    // milestone directories from staging to prevent cross-milestone pollution
-    // (e.g., an M033 worker fabricating M032 artifacts in the same commit).
-    const milestoneLock = process.env.GSD_MILESTONE_LOCK;
-    if (milestoneLock) {
-      const msDir = join(gsdRoot(this.basePath), "milestones");
-      if (existsSync(msDir)) {
-        try {
-          const entries = readdirSync(msDir, { withFileTypes: true });
-          for (const entry of entries) {
-            if (entry.isDirectory() && entry.name !== milestoneLock) {
-              allExclusions.push(`.gsd/milestones/${entry.name}/`);
-            }
-          }
-        } catch {
-          // Best-effort — if we can't read the milestones dir, proceed without scoping
-        }
-      }
-    }
-
     nativeAddAllWithExclusions(this.basePath, allExclusions);
   }
 

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

@@ -41,7 +41,6 @@ const GSD_RUNTIME_PATTERNS = [
 const BASELINE_PATTERNS = [
   // ── GSD state directory (symlink to external storage) ──
   ".gsd",
-  ".gsd-id",
 
   // ── OS junk ──
   ".DS_Store",
@@ -85,38 +84,6 @@ const BASELINE_PATTERNS = [
   "tmp/",
 ];
 
-/**
- * Check whether `.gsd` is covered by the project's `.gitignore`.
- *
- * Uses `git check-ignore` for accurate evaluation — this respects nested
- * .gitignore files, global gitignore, and negation patterns. Returns true
- * only when git would actually ignore `.gsd/`.
- *
- * Returns false (not ignored) if:
- *   - No `.gitignore` exists
- *   - `.gsd` is not listed in any active ignore rule
- *   - Not a git repo or git is unavailable
- */
-export function isGsdGitignored(basePath: string): boolean {
-  // Check both `.gsd` and `.gsd/` because `.gsd/` in .gitignore (trailing
-  // slash = directory-only pattern) only matches the directory form. Using
-  // both paths covers all gitignore pattern variants.
-  for (const path of [".gsd", ".gsd/"]) {
-    try {
-      // git check-ignore exits 0 when the path IS ignored, 1 when it is NOT.
-      execFileSync("git", ["check-ignore", "-q", path], {
-        cwd: basePath,
-        stdio: "pipe",
-        env: GIT_NO_PROMPT_ENV,
-      });
-      return true; // exit 0 → .gsd is ignored
-    } catch {
-      // exit 1 → this form is NOT ignored, try the other
-    }
-  }
-  return false; // neither form is ignored (or git unavailable)
-}
-
 /**
  * Check whether `.gsd/` contains files tracked by git.
  * If so, the project intentionally keeps `.gsd/` in version control

package/src/resources/extensions/gsd/gsd-db.ts

@@ -10,7 +10,6 @@ import { existsSync, copyFileSync, mkdirSync, realpathSync } from "node:fs";
 import { dirname } from "node:path";
 import type { Decision, Requirement, GateRow, GateId, GateScope, GateStatus, GateVerdict } from "./types.js";
 import { GSDError, GSD_STALE_STATE } from "./errors.js";
-import { logError } from "./workflow-logger.js";
 
 const _require = createRequire(import.meta.url);
 
@@ -779,21 +778,8 @@ export function openDatabase(path: string): boolean {
   try {
     initSchema(adapter, fileBacked);
   } catch (err) {
-    // Corrupt freelist: DDL fails with "malformed" but VACUUM can rebuild.
-    // Attempt VACUUM recovery before giving up (see #2519).
-    if (fileBacked && err instanceof Error && err.message?.includes("malformed")) {
-      try {
-        adapter.exec("VACUUM");
-        initSchema(adapter, fileBacked);
-        process.stderr.write("gsd-db: recovered corrupt database via VACUUM\n");
-      } catch (retryErr) {
-        try { adapter.close(); } catch { /* swallow */ }
-        throw retryErr;
-      }
-    } else {
-      try { adapter.close(); } catch { /* swallow */ }
-      throw err;
-    }
+    try { adapter.close(); } catch { /* swallow */ }
+    throw err;
   }
 
   currentDb = adapter;
@@ -1138,11 +1124,10 @@ export function insertMilestone(m: {
   });
 }
 
-export function upsertMilestonePlanning(milestoneId: string, planning: Partial<MilestonePlanningRecord>, title?: string): void {
+export function upsertMilestonePlanning(milestoneId: string, planning: Partial<MilestonePlanningRecord>): void {
   if (!currentDb) throw new GSDError(GSD_STALE_STATE, "gsd-db: No database open");
   currentDb.prepare(
     `UPDATE milestones SET
-      title = COALESCE(:title, title),
       vision = COALESCE(:vision, vision),
       success_criteria = COALESCE(:success_criteria, success_criteria),
       key_risks = COALESCE(:key_risks, key_risks),
@@ -1157,7 +1142,6 @@ export function upsertMilestonePlanning(milestoneId: string, planning: Partial<M
      WHERE id = :id`,
   ).run({
     ":id": milestoneId,
-    ":title": title ?? null,
     ":vision": planning.vision ?? null,
     ":success_criteria": planning.successCriteria ? JSON.stringify(planning.successCriteria) : null,
     ":key_risks": planning.keyRisks ? JSON.stringify(planning.keyRisks) : null,
@@ -1535,26 +1519,6 @@ export function insertVerificationEvidence(e: {
   });
 }
 
-export interface VerificationEvidenceRow {
-  id: number;
-  task_id: string;
-  slice_id: string;
-  milestone_id: string;
-  command: string;
-  exit_code: number;
-  verdict: string;
-  duration_ms: number;
-  created_at: string;
-}
-
-export function getVerificationEvidence(milestoneId: string, sliceId: string, taskId: string): VerificationEvidenceRow[] {
-  if (!currentDb) return [];
-  const rows = currentDb.prepare(
-    "SELECT * FROM verification_evidence WHERE milestone_id = :mid AND slice_id = :sid AND task_id = :tid ORDER BY id",
-  ).all({ ":mid": milestoneId, ":sid": sliceId, ":tid": taskId });
-  return rows as unknown as VerificationEvidenceRow[];
-}
-
 export interface MilestoneRow {
   id: string;
   title: string;
@@ -1774,7 +1738,7 @@ export function copyWorktreeDb(srcDbPath: string, destDbPath: string): boolean {
     copyFileSync(srcDbPath, destDbPath);
     return true;
   } catch (err) {
-    logError("db", "failed to copy DB to worktree", { error: (err as Error).message });
+    process.stderr.write(`gsd-db: failed to copy DB to worktree: ${(err as Error).message}\n`);
     return false;
   }
 }
@@ -1806,13 +1770,13 @@ export function reconcileWorktreeDb(
   // ATTACH DATABASE doesn't support parameterized paths in all providers,
   // so we use strict allowlist validation instead.
   if (/['";\x00]/.test(worktreeDbPath)) {
-    logError("db", "worktree DB reconciliation failed: path contains unsafe characters");
+    process.stderr.write("gsd-db: worktree DB reconciliation failed: path contains unsafe characters\n");
     return zero;
   }
   if (!currentDb) {
     const opened = openDatabase(mainDbPath);
     if (!opened) {
-      logError("db", "worktree DB reconciliation failed: cannot open main DB");
+      process.stderr.write("gsd-db: worktree DB reconciliation failed: cannot open main DB\n");
       return zero;
     }
   }
@@ -1946,7 +1910,7 @@ export function reconcileWorktreeDb(
       try { adapter.exec("DETACH DATABASE wt"); } catch { /* best effort */ }
     }
   } catch (err) {
-    logError("db", "worktree DB reconciliation failed", { error: (err as Error).message });
+    process.stderr.write(`gsd-db: worktree DB reconciliation failed: ${(err as Error).message}\n`);
     return { ...zero, conflicts };
   }
 }