@opengsd/gsd-pi 1.2.0-dev.fbdca60b → 1.3.0-dev.65546769

package/dist/resources/extensions/gsd/notifications.js

@@ -1,12 +1,15 @@
 // GSD Extension — Desktop Notification Helper
 // Cross-platform desktop notifications for auto-mode events.
-import { execFileSync } from "node:child_process";
+import childProcess from "node:child_process";
+import { accessSync, constants } from "node:fs";
+import { delimiter, resolve } from "node:path";
 import { loadEffectiveGSDPreferences } from "./preferences.js";
 import { sendRemoteNotification as _sendRemoteNotification } from "../remote-questions/notify.js";
 /** Swappable dispatcher for remote notifications — exported so tests can mock it. */
 export const remoteNotificationDispatcher = {
     send: _sendRemoteNotification,
 };
+const executablePathCache = new Map();
 /**
  * Send a native desktop notification. Non-blocking, non-fatal.
  * macOS: osascript, Linux: notify-send, Windows: skipped.
@@ -49,13 +52,26 @@ export function sendDesktopNotification(title, message, level = "info", kind = "
             const command = buildDesktopNotificationCommand(process.platform, title, message, level);
             if (!command)
                 return;
-            execFileSync(command.file, command.args, { timeout: 3000, stdio: "ignore" });
+            launchDesktopNotification(command);
         }
         catch {
             // Non-fatal — desktop notifications are best-effort
         }
     }).catch(() => { });
 }
+export function launchDesktopNotification(command) {
+    try {
+        const child = childProcess.spawn(command.file, command.args, {
+            detached: true,
+            stdio: "ignore",
+        });
+        child.on("error", () => { });
+        child.unref();
+    }
+    catch {
+        // Non-fatal — desktop notifications are best-effort
+    }
+}
 export function shouldSendDesktopNotification(kind, preferences = loadEffectiveGSDPreferences()?.preferences.notifications) {
     if (preferences?.enabled === false)
         return false;
@@ -149,12 +165,25 @@ function escapeAppleScript(s) {
  * Non-fatal — returns null on any error.
  */
 function findExecutable(name) {
-    try {
-        return execFileSync("which", [name], { timeout: 2000, stdio: ["ignore", "pipe", "ignore"] }).toString().trim() || null;
-    }
-    catch {
-        return null;
+    if (executablePathCache.has(name))
+        return executablePathCache.get(name) ?? null;
+    let resolved = null;
+    const path = process.env.PATH;
+    if (path) {
+        for (const dir of path.split(delimiter)) {
+            const candidate = resolve(dir || ".", name);
+            try {
+                accessSync(candidate, constants.X_OK);
+                resolved = candidate;
+                break;
+            }
+            catch {
+                // keep searching PATH
+            }
+        }
     }
+    executablePathCache.set(name, resolved);
+    return resolved;
 }
 function resolveBellStream() {
     if (process.stderr?.isTTY)

package/dist/resources/extensions/gsd/observability-validator.js

@@ -361,12 +361,16 @@ export async function validatePlanBoundary(basePath, milestoneId, sliceId) {
     }
     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));
     }
@@ -392,12 +396,16 @@ export async function validateCompleteBoundary(basePath, milestoneId, sliceId) {
     const issues = [];
     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/dist/resources/extensions/gsd/parallel-monitor-overlay.js

@@ -2,14 +2,19 @@
 // File Purpose: Parallel worker monitor overlay with width-safe operations-console rendering.
 import { existsSync, statSync, readFileSync, openSync, readSync, closeSync, readdirSync } from "node:fs";
 import { join } from "node:path";
-import { spawnSync } from "node:child_process";
 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, renderDialogFrame, renderKeyHints, renderProgressBar, safeLine, statusGlyph, } from "./tui/render-kit.js";
+const ndjsonCostCache = new Map();
+const NDJSON_COST_READ_CHUNK_BYTES = 64 * 1024;
 // ─── Data Helpers ─────────────────────────────────────────────────────────
+function ndjsonFileKey(stat) {
+    return `${stat.dev}:${stat.ino}`;
+}
 function readJsonSafe(filePath) {
     try {
         return JSON.parse(readFileSync(filePath, "utf-8"));
@@ -74,45 +79,125 @@ function querySliceProgress(basePath, mid, workRoot = worktreePathFor(basePath,
     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) {
+    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) {
+    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, start, length, initialTotal, initialPendingLine) {
+    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, mid) {
     const stdoutPath = join(basePath, ".gsd", "parallel", `${mid}.stdout.log`);
-    if (!existsSync(stdoutPath))
+    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;
     }
 }
 function queryRecentCompletions(basePath, mid) {
@@ -120,20 +205,33 @@ function queryRecentCompletions(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 */ }
+    }
 }
 function collectWorkerData(basePath) {
     const mids = discoverWorkers(basePath);

package/dist/resources/extensions/gsd/parsers-legacy.js

@@ -200,17 +200,22 @@ function _parsePlanImpl(content) {
     const demo = extractBoldField(body, 'Demo') || '';
     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 = [];
     // Parse task entries from a set of lines, appending to `tasks`.
     const parseTaskLines = (lines, knownIds) => {
         let currentTask = 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*(.+)/)
@@ -222,15 +227,28 @@ function _parsePlanImpl(content) {
                     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',
                         estimate,
@@ -265,7 +283,7 @@ function _parsePlanImpl(content) {
                     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
@@ -277,13 +295,21 @@ function _parsePlanImpl(content) {
         if (currentTask)
             tasks.push(currentTask);
     };
+    const knownTaskIds = new Set();
     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) : [];
     const result = { id, title, goal, demo, mustHaves, tasks, filesLikelyTouched };