@opengsd/gsd-pi 1.3.0 → 1.4.0

package/src/resources/extensions/gsd/observability-validator.ts

@@ -396,11 +396,15 @@ export async function validatePlanBoundary(basePath: string, milestoneId: string
 
   const tasksDir = resolveTasksDir(basePath, milestoneId, sliceId);
   const taskPlans = tasksDir ? resolveTaskFiles(tasksDir, "PLAN") : [];
-  for (const file of taskPlans) {
+  const taskPlanPaths = taskPlans.flatMap(file => {
     const taskId = file.split("-")[0];
     const taskPlan = resolveTaskFile(basePath, milestoneId, sliceId, taskId, "PLAN");
+    return taskPlan ? [taskPlan] : [];
+  });
+  const taskPlanContents = await Promise.all(taskPlanPaths.map(loadFile));
+  for (const [index, content] of taskPlanContents.entries()) {
+    const taskPlan = taskPlanPaths[index];
     if (!taskPlan) continue;
-    const content = await loadFile(taskPlan);
     if (content) issues.push(...validateTaskPlanContent(taskPlan, content));
   }
 
@@ -428,11 +432,15 @@ export async function validateCompleteBoundary(basePath: string, milestoneId: st
   const issues: ValidationIssue[] = [];
   const tasksDir = resolveTasksDir(basePath, milestoneId, sliceId);
   const taskSummaries = tasksDir ? resolveTaskFiles(tasksDir, "SUMMARY") : [];
-  for (const file of taskSummaries) {
+  const taskSummaryPaths = taskSummaries.flatMap(file => {
     const taskId = file.split("-")[0];
     const taskSummary = resolveTaskFile(basePath, milestoneId, sliceId, taskId, "SUMMARY");
+    return taskSummary ? [taskSummary] : [];
+  });
+  const taskSummaryContents = await Promise.all(taskSummaryPaths.map(loadFile));
+  for (const [index, content] of taskSummaryContents.entries()) {
+    const taskSummary = taskSummaryPaths[index];
     if (!taskSummary) continue;
-    const content = await loadFile(taskSummary);
     if (content) issues.push(...validateTaskSummaryContent(taskSummary, content));
   }
 

package/src/resources/extensions/gsd/orphan-stash-audit.ts

@@ -33,16 +33,87 @@ function _isAlreadyRestoredApplyError(err: unknown): boolean {
 
 export { _isAlreadyRestoredApplyError };
 
+function gitOutput(basePath: string, args: string[]): string {
+  return execFileSync("git", args, {
+    cwd: basePath,
+    stdio: ["ignore", "pipe", "pipe"],
+    encoding: "utf-8",
+    env: GIT_NO_PROMPT_ENV,
+  });
+}
+
+function listStashUntrackedPaths(basePath: string, stashRef: string): string[] | null {
+  try {
+    return gitOutput(basePath, ["ls-tree", "-r", "-z", "--name-only", `${stashRef}^3`]).split("\0").filter(Boolean);
+  } catch {
+    return null;
+  }
+}
+
+function listStashTrackedPaths(basePath: string, stashRef: string): string[] | null {
+  try {
+    return gitOutput(basePath, ["diff", "--name-only", "-z", `${stashRef}^1`, stashRef]).split("\0").filter(Boolean);
+  } catch {
+    return null;
+  }
+}
+
+interface PorcelainEntry {
+  code: string;
+  path: string;
+}
+
+function readWorkingTreeStatus(basePath: string): PorcelainEntry[] | null {
+  try {
+    return gitOutput(basePath, ["status", "--porcelain", "-z", "--untracked-files=all"])
+      .split("\0")
+      .filter(Boolean)
+      .map((entry) => ({ code: entry.slice(0, 2), path: entry.slice(3) }));
+  } catch {
+    return null;
+  }
+}
+
+function isAlreadyRestoredUntrackedStatus(basePath: string, stashRef: string, statusEntries: PorcelainEntry[]): boolean {
+  if (statusEntries.length === 0 || statusEntries.some((entry) => entry.code !== "??")) return false;
+  const stashTrackedPaths = listStashTrackedPaths(basePath, stashRef);
+  if (!stashTrackedPaths || stashTrackedPaths.length > 0) return false;
+  const stashUntrackedPaths = listStashUntrackedPaths(basePath, stashRef);
+  if (!stashUntrackedPaths || stashUntrackedPaths.length === 0) return false;
+  const stashUntrackedPathSet = new Set(stashUntrackedPaths);
+  const workingTreeUntrackedPathSet = new Set(statusEntries.map((entry) => entry.path));
+  // "Already restored" requires the working tree's untracked paths to match the
+  // stash's untracked paths exactly, in BOTH directions:
+  //   1. every current untracked path comes from the stash (no unexplained user
+  //      work that an apply would clobber), AND
+  //   2. every stash untracked path is already present in the working tree.
+  // Without (2), a partial restore (where only some stash files were recovered)
+  // would be misread as fully restored: the audit would no-op without applying
+  // or warning, leaving the remaining pre-merge files missing.
+  return (
+    statusEntries.every((entry) => stashUntrackedPathSet.has(entry.path)) &&
+    stashUntrackedPaths.every((path) => workingTreeUntrackedPathSet.has(path))
+  );
+}
+
+function manualApplyWarning(stashRef: string, milestoneId: string, reason: string): string {
+  return (
+    `Pre-merge stash ${stashRef} for milestone ${milestoneId} not auto-applied: ${reason}; ` +
+    `run \`git stash apply ${stashRef}\` manually to restore your pre-merge changes.`
+  );
+}
+
 /**
  * Audit `git stash list` for orphaned `gsd-preflight-stash:M00x:*` entries.
  *
  * The matching merge code in `phases.ts` previously skipped the postflight
  * pop whenever `mergeAndExit` threw, leaking the user's pre-merge working
- * tree into the stash list. For every preflight-stash entry whose milestone
- * is now complete (per the supplied callback), `git stash apply` is invoked —
+ * tree into the stash list. Completed-milestone stashes are only auto-applied
+ * when the working tree is clean and the stash does not modify tracked files.
+ * Dirty trees and tracked-file stashes are left untouched with a manual
+ * recovery warning. When auto-apply is safe, `git stash apply` is invoked —
  * NOT `pop`. The stash entry stays in the list so the user retains a backup
- * if the apply produces unexpected merge results. Idempotent across repeated
- * startup runs.
+ * if the apply produces unexpected merge results.
  *
  * Failures are best-effort: a list error (no repo, git unavailable) returns
  * an empty result. An apply error becomes a warning the user sees alongside
@@ -56,16 +127,7 @@ export function auditOrphanedPreflightStashes(
 
   let listOutput: string;
   try {
-    listOutput = execFileSync(
-      "git",
-      ["stash", "list", "--format=%gd%x00%s"],
-      {
-        cwd: basePath,
-        stdio: ["ignore", "pipe", "pipe"],
-        encoding: "utf-8",
-        env: GIT_NO_PROMPT_ENV,
-      },
-    );
+    listOutput = gitOutput(basePath, ["stash", "list", "--format=%gd%x00%s"]);
   } catch {
     return result;
   }
@@ -93,13 +155,39 @@ export function auditOrphanedPreflightStashes(
     }
     if (!complete) continue;
 
+    const statusEntries = readWorkingTreeStatus(basePath);
+    if (!statusEntries) {
+      result.warnings.push(
+        manualApplyWarning(ref, milestoneId, "could not verify working tree status"),
+      );
+      continue;
+    }
+    if (statusEntries.length > 0) {
+      if (isAlreadyRestoredUntrackedStatus(basePath, ref, statusEntries)) continue;
+      result.warnings.push(manualApplyWarning(ref, milestoneId, "working tree not clean"));
+      continue;
+    }
+
+    const trackedPaths = listStashTrackedPaths(basePath, ref);
+    if (trackedPaths === null) {
+      result.warnings.push(
+        manualApplyWarning(ref, milestoneId, "could not inspect tracked paths in stash"),
+      );
+      continue;
+    }
+    if (trackedPaths.length > 0) {
+      // A retained tracked-file stash has no durable marker showing whether a
+      // clean tree needs first recovery or would be re-mutated by an old backup.
+      const preview = trackedPaths.slice(0, 5).join(", ");
+      const suffix = trackedPaths.length > 5 ? `, and ${trackedPaths.length - 5} more` : "";
+      result.warnings.push(
+        manualApplyWarning(ref, milestoneId, `stash modifies tracked files (${preview}${suffix})`),
+      );
+      continue;
+    }
+
     try {
-      execFileSync("git", ["stash", "apply", "--quiet", ref], {
-        cwd: basePath,
-        stdio: ["ignore", "pipe", "pipe"],
-        encoding: "utf-8",
-        env: GIT_NO_PROMPT_ENV,
-      });
+      gitOutput(basePath, ["stash", "apply", "--quiet", ref]);
       result.applied.push({ milestoneId, stashRef: ref });
     } catch (err) {
       // Idempotent steady state: stash was already applied in a prior audit

package/src/resources/extensions/gsd/parallel-monitor-overlay.ts

@@ -1,9 +1,8 @@
 // Project/App: gsd-pi
 // File Purpose: Parallel worker monitor overlay with width-safe operations-console rendering.
 
-import { existsSync, statSync, readFileSync, openSync, readSync, closeSync, readdirSync } from "node:fs";
+import { existsSync, statSync, readFileSync, openSync, readSync, closeSync, readdirSync, type Stats } from "node:fs";
 import { join } from "node:path";
-import { spawnSync } from "node:child_process";
 
 import type { Theme } from "@gsd/pi-coding-agent";
 import { matchesKey, Key } from "@gsd/pi-tui";
@@ -11,6 +10,7 @@ import { matchesKey, Key } from "@gsd/pi-tui";
 import { formatDuration } from "../shared/mod.js";
 import { formattedShortcutPair } from "./shortcut-defs.js";
 import { resolveGsdPathContract } from "./paths.js";
+import { openWorkflowDatabaseIsolated } from "./db-workspace.js";
 import { worktreePathFor, worktreesDirs } from "./worktree-placement.js";
 import {
   renderBar,
@@ -48,6 +48,14 @@ interface SliceProgress {
   done: number;
 }
 
+interface NdjsonCostCacheEntry {
+  size: number;
+  mtimeMs: number;
+  fileKey: string;
+  total: number;
+  pendingLine: string;
+}
+
 interface WorkerView {
   mid: string;
   pid: number;
@@ -67,8 +75,15 @@ interface WorkerView {
   errors: string[];
 }
 
+const ndjsonCostCache = new Map<string, NdjsonCostCacheEntry>();
+const NDJSON_COST_READ_CHUNK_BYTES = 64 * 1024;
+
 // ─── Data Helpers ─────────────────────────────────────────────────────────
 
+function ndjsonFileKey(stat: Stats): string {
+  return `${stat.dev}:${stat.ino}`;
+}
+
 function readJsonSafe<T>(filePath: string): T | null {
   try {
     return JSON.parse(readFileSync(filePath, "utf-8")) as T;
@@ -132,39 +147,132 @@ function querySliceProgress(basePath: string, mid: string, workRoot: string = wo
   const dbPath = resolveGsdPathContract(workRoot, basePath).projectDb;
   if (!existsSync(dbPath)) return [];
 
+  const db = openWorkflowDatabaseIsolated(dbPath);
+  if (!db) return [];
   try {
-    const sql = `SELECT s.id, s.status, COUNT(t.id), SUM(CASE WHEN t.status='complete' THEN 1 ELSE 0 END) FROM slices s LEFT JOIN tasks t ON s.milestone_id=t.milestone_id AND s.id=t.slice_id WHERE s.milestone_id='${mid}' GROUP BY s.id ORDER BY s.id`;
-    const result = spawnSync("sqlite3", [dbPath, sql], { timeout: 3000, encoding: "utf-8" });
-    const out = (result.stdout || "").trim();
-    if (!out || result.status !== 0) return [];
-    return out.split("\n").map((line) => {
-      const [id, status, total, done] = line.split("|");
-      return { id, status, total: parseInt(total, 10), done: parseInt(done || "0", 10) };
-    });
+    const rows = db.prepare(
+      `SELECT
+         s.id AS id,
+         s.status AS status,
+         COUNT(t.id) AS total,
+         COALESCE(SUM(CASE WHEN t.status='complete' THEN 1 ELSE 0 END), 0) AS done
+       FROM slices s
+       LEFT JOIN tasks t ON s.milestone_id=t.milestone_id AND s.id=t.slice_id
+       WHERE s.milestone_id=:mid
+       GROUP BY s.id
+       ORDER BY s.id`,
+    ).all({ ":mid": mid });
+    return rows.map((row) => ({
+      id: String(row["id"] ?? ""),
+      status: String(row["status"] ?? ""),
+      total: Number(row["total"] ?? 0),
+      done: Number(row["done"] ?? 0),
+    }));
   } catch {
     return [];
+  } finally {
+    try { db.close(); } catch { /* ignore */ }
+  }
+}
+
+function costFromNdjsonLine(line: string): number {
+  if (!line.includes("message_end")) return 0;
+  try {
+    const obj = JSON.parse(line);
+    if (obj.type !== "message_end") return 0;
+    const cost = obj.message?.usage?.cost?.total;
+    return typeof cost === "number" ? cost : 0;
+  } catch {
+    return 0;
+  }
+}
+
+function consumePendingNdjsonLine(line: string): { consumed: boolean; cost: number } {
+  const trimmed = line.trim();
+  if (!trimmed) return { consumed: true, cost: 0 };
+  try {
+    const obj = JSON.parse(trimmed);
+    if (obj.type !== "message_end") return { consumed: true, cost: 0 };
+    const cost = obj.message?.usage?.cost?.total;
+    return { consumed: true, cost: typeof cost === "number" ? cost : 0 };
+  } catch {
+    return { consumed: false, cost: 0 };
   }
 }
 
+function readNdjsonCostRange(
+  filePath: string,
+  start: number,
+  length: number,
+  initialTotal: number,
+  initialPendingLine: string,
+): { total: number; pendingLine: string } {
+  const fd = openSync(filePath, "r");
+  let total = initialTotal;
+  let pendingLine = initialPendingLine;
+
+  try {
+    let offset = start;
+    let remaining = length;
+    while (remaining > 0) {
+      const readSize = Math.min(remaining, NDJSON_COST_READ_CHUNK_BYTES);
+      const buf = Buffer.alloc(readSize);
+      const bytesRead = readSync(fd, buf, 0, readSize, offset);
+      if (bytesRead <= 0) break;
+
+      offset += bytesRead;
+      remaining -= bytesRead;
+
+      const content = pendingLine + buf.subarray(0, bytesRead).toString("utf-8");
+      const lines = content.split("\n");
+      pendingLine = lines.pop() ?? "";
+      for (const line of lines) total += costFromNdjsonLine(line);
+    }
+  } finally {
+    closeSync(fd);
+  }
+
+  return { total, pendingLine };
+}
+
 function extractCostFromNdjson(basePath: string, mid: string): number {
   const stdoutPath = join(basePath, ".gsd", "parallel", `${mid}.stdout.log`);
-  if (!existsSync(stdoutPath)) return 0;
+  if (!existsSync(stdoutPath)) {
+    ndjsonCostCache.delete(stdoutPath);
+    return 0;
+  }
+
   try {
-    const content = readFileSync(stdoutPath, "utf-8");
-    let total = 0;
-    for (const line of content.split("\n")) {
-      if (!line.includes("message_end")) continue;
-      try {
-        const obj = JSON.parse(line);
-        if (obj.type === "message_end") {
-          const cost = obj.message?.usage?.cost?.total;
-          if (typeof cost === "number") total += cost;
-        }
-      } catch { /* skip */ }
-    }
-    return total;
+    const stat = statSync(stdoutPath);
+    const cached = ndjsonCostCache.get(stdoutPath);
+    if (cached && cached.size === stat.size && cached.mtimeMs === stat.mtimeMs) return cached.total;
+
+    const isAppendOnly = cached !== undefined
+      && stat.size > cached.size
+      && ndjsonFileKey(stat) === cached.fileKey;
+    const start = isAppendOnly ? cached.size : 0;
+    const initialTotal = isAppendOnly ? cached.total : 0;
+    const initialPendingLine = isAppendOnly ? cached.pendingLine : "";
+    const { total, pendingLine } = readNdjsonCostRange(
+      stdoutPath,
+      start,
+      stat.size - start,
+      initialTotal,
+      initialPendingLine,
+    );
+    const pending = consumePendingNdjsonLine(pendingLine);
+    const nextPendingLine = pending.consumed ? "" : pendingLine;
+    const nextTotal = total + pending.cost;
+    ndjsonCostCache.set(stdoutPath, {
+      size: stat.size,
+      mtimeMs: stat.mtimeMs,
+      fileKey: ndjsonFileKey(stat),
+      total: nextTotal,
+      pendingLine: nextPendingLine,
+    });
+    return nextTotal;
   } catch {
-    return 0;
+    return ndjsonCostCache.get(stdoutPath)?.total ?? 0;
   }
 }
 
@@ -172,17 +280,29 @@ function queryRecentCompletions(basePath: string, mid: string): string[] {
   const workRoot = worktreePathFor(basePath, mid);
   const dbPath = resolveGsdPathContract(workRoot, basePath).projectDb;
   if (!existsSync(dbPath)) return [];
+
+  const db = openWorkflowDatabaseIsolated(dbPath);
+  if (!db) return [];
   try {
-    const sql = `SELECT id, slice_id, one_liner FROM tasks WHERE milestone_id='${mid}' AND status='complete' AND completed_at IS NOT NULL ORDER BY completed_at DESC LIMIT 5`;
-    const result = spawnSync("sqlite3", [dbPath, sql], { timeout: 3000, encoding: "utf-8" });
-    const out = (result.stdout || "").trim();
-    if (!out || result.status !== 0) return [];
-    return out.split("\n").map((line) => {
-      const [taskId, sliceId, oneLiner] = line.split("|");
+    const rows = db.prepare(
+      `SELECT id, slice_id, one_liner
+       FROM tasks
+       WHERE milestone_id=:mid
+         AND status='complete'
+         AND completed_at IS NOT NULL
+       ORDER BY completed_at DESC
+       LIMIT 5`,
+    ).all({ ":mid": mid });
+    return rows.map((row) => {
+      const taskId = String(row["id"] ?? "");
+      const sliceId = String(row["slice_id"] ?? "");
+      const oneLiner = String(row["one_liner"] ?? "");
       return `✓ ${mid}/${sliceId}/${taskId}${oneLiner ? ": " + oneLiner : ""}`;
     });
   } catch {
     return [];
+  } finally {
+    try { db.close(); } catch { /* ignore */ }
   }
 }
 

package/src/resources/extensions/gsd/parsers-legacy.ts

@@ -228,11 +228,12 @@ function _parsePlanImpl(content: string): SlicePlan {
   const mhSection = extractSection(body, 'Must-Haves');
   const mustHaves = mhSection ? parseBullets(mhSection) : [];
 
-  // Parse tasks from ## Tasks section first, then scan the full body for any
-  // task checkboxes that were missed. Multi-task plans can interleave T01 detail
-  // headings (## Steps, ## Must-Haves) before T02's checkbox, which causes
-  // extractSection("Tasks") to stop at the first ## heading and miss T02+ (#3105).
+  // Parse tasks from ## Tasks section or <tasks> XML block, then scan the full
+  // body for any task checkboxes that were missed.
   const tasksSection = extractSection(body, 'Tasks');
+  // Flat-phase: extract <tasks>...</tasks> block content
+  const tasksBlockMatch = body.match(/<tasks>([\s\S]*?)<\/tasks>/);
+  const tasksBlock = tasksBlockMatch ? tasksBlockMatch[1] : null;
   const tasks: TaskPlanEntry[] = [];
 
   // Parse task entries from a set of lines, appending to `tasks`.
@@ -240,7 +241,11 @@ function _parsePlanImpl(content: string): SlicePlan {
     let currentTask: TaskPlanEntry | null = null;
 
     for (const line of lines) {
-      const cbMatch = line.match(/^-\s+\[([ xX])\]\s+\*\*([\w.]+):\s+(.+?)\*\*\s*(.*)/);
+      // Match both formats:
+      //   Legacy:  - [x] **T01: Title** `est:30m`
+      //   Flat-phase: - [x] **T01**: Title _(30m)_
+      const cbMatch = line.match(/^-\s+\[([ xX])\]\s+\*\*([\w.]+):\s+(.+?)\*\*\s*(.*)/)
+        || line.match(/^-\s+\[([ xX])\]\s+\*\*([\w.]+)\*\*:\s+(.+?)\s*(?:_\(([^)]*)\)_\s*)?$/);
       // Heading-style: ### T01 -- Title, ### T01: Title, ### T01 — Title
       const hdMatch = !cbMatch
         ? line.match(/^#{2,4}\s+([A-Z]+\d+(?:\.[A-Z]+\d+)*)\s*(?:--|—|:)\s*(.+)/)
@@ -252,18 +257,31 @@ function _parsePlanImpl(content: string): SlicePlan {
           currentTask = null;
           continue;
         }
+        knownIds.add(taskId);
         if (currentTask) tasks.push(currentTask);
 
         if (cbMatch) {
-          const rest = cbMatch[4] || '';
-          const estMatch = rest.match(/`est:([^`]+)`/);
-          const estimate = estMatch ? estMatch[1] : '';
+          // Two regex alternatives — distinguish by the shape of group 4.
+          // Legacy: group 4 = trailing text (may contain `est:X`). Title in group 3.
+          // Flat-phase: group 4 = estimate value directly (e.g. "30m"). Title in group 3.
+          const group4 = cbMatch[4] || '';
+          const title = (cbMatch[3] || '').trim();
+          let estimate = '';
+
+          // Legacy `est:X` tag
+          const estMatch = group4.match(/`est:([^`]+)`/);
+          if (estMatch) {
+            estimate = estMatch[1]!;
+          } else if (group4) {
+            // Flat-phase: the estimate value was captured directly
+            estimate = group4;
+          }
 
           currentTask = {
             id: cbMatch[2],
-            title: cbMatch[3],
+            title,
             description: '',
-            done: cbMatch[1].toLowerCase() === 'x',
+            done: cbMatch[1]!.toLowerCase() === 'x',
             estimate,
           };
         } else {
@@ -293,7 +311,7 @@ function _parsePlanImpl(content: string): SlicePlan {
         if (verifyMatch) {
           currentTask.verify = verifyMatch[1].trim();
         }
-      } else if (currentTask && line.trim() && !line.startsWith('#')) {
+      } else if (currentTask && line.trim() && !line.startsWith('#') && !line.match(/<\/?tasks>/) && !line.match(/^\s*-\s+(Files|Verify):/)) {
         const desc = line.trim();
         if (desc) {
           currentTask.description = currentTask.description
@@ -305,14 +323,23 @@ function _parsePlanImpl(content: string): SlicePlan {
     if (currentTask) tasks.push(currentTask);
   };
 
+  const knownTaskIds = new Set<string>();
   if (tasksSection) {
-    parseTaskLines(tasksSection.split('\n'), new Set());
+    parseTaskLines(tasksSection.split('\n'), knownTaskIds);
+  }
+
+  // Flat-phase: parse <tasks> block
+  if (tasksBlock) {
+    parseTaskLines(tasksBlock.split('\n'), knownTaskIds);
   }
 
   // Second pass: scan the full body for task checkboxes outside ## Tasks.
-  // This handles interleaved plans where T02+ appear after T01's detail headings.
-  const foundIds = new Set(tasks.map(t => t.id));
-  parseTaskLines(body.split('\n'), foundIds);
+  // Only do this for legacy plans (no <tasks> block) — flat-phase plans
+  // have all tasks inside <tasks> and the second pass would pick up noise.
+  if (!tasksBlock && !tasksSection) {
+    const foundIds = new Set(tasks.map(t => t.id));
+    parseTaskLines(body.split('\n'), foundIds);
+  }
 
   const filesSection = extractSection(body, 'Files Likely Touched');
   const filesLikelyTouched = filesSection ? parseBullets(filesSection) : [];