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

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

@@ -312,6 +312,8 @@ export function scoreEligibleModels(
 
 /**
  * Return all models eligible for a given tier, sorted cheapest first.
+ * A runtime preferred model (the user's selected/session model) is returned
+ * first when it is available and satisfies the requested tier.
  * If routingConfig.tier_models[tier] is set and available, returns only that
  * model. Otherwise filters availableModelIds by tier from MODEL_CAPABILITY_TIER.
  */
@@ -319,6 +321,7 @@ export function getEligibleModels(
   tier: ComplexityTier,
   availableModelIds: string[],
   routingConfig: DynamicRoutingConfig,
+  preferredModelId?: string,
 ): string[] {
   // 1. Check explicit tier_models config
   const explicitModel = routingConfig.tier_models?.[tier];
@@ -332,13 +335,17 @@ export function getEligibleModels(
   }
 
   // 2. Auto-detect: filter by tier, sort cheapest first
-  return availableModelIds
+  const tierMatches = availableModelIds
     .filter(id => getModelTier(id) === tier)
     .sort((a, b) => {
       const costA = getModelCost(a);
       const costB = getModelCost(b);
       return costA - costB;
     });
+
+  const preferred = findPreferredModelForTier(tier, availableModelIds, preferredModelId);
+  if (!preferred) return tierMatches;
+  return [preferred, ...tierMatches.filter(id => id !== preferred)];
 }
 
 /**
@@ -398,6 +405,7 @@ export function resolveModelForComplexity(
   unitType?: string,
   taskMetadata?: TaskMetadata,
   capabilityOverrides?: Record<string, Partial<ModelCapabilities>>,
+  preferredModelId?: string,
 ): RoutingDecision {
   // If no phase config or routing disabled, pass through
   if (!phaseConfig || !routingConfig.enabled) {
@@ -453,6 +461,7 @@ export function resolveModelForComplexity(
       routingConfig,
       availableModelIds,
       routingConfig.cross_provider !== false,
+      preferredModelId,
     );
 
     return {
@@ -470,7 +479,7 @@ export function resolveModelForComplexity(
   }
 
   // STEP 1: Get all eligible models for the requested tier
-  const eligible = getEligibleModels(requestedTier, availableModelIds, routingConfig);
+  const eligible = getEligibleModels(requestedTier, availableModelIds, routingConfig, preferredModelId);
 
   if (eligible.length === 0) {
     // No suitable model found — use configured primary
@@ -484,6 +493,19 @@ export function resolveModelForComplexity(
     };
   }
 
+  const preferred = findPreferredModelForTier(requestedTier, availableModelIds, preferredModelId);
+  if (preferred && eligible.includes(preferred)) {
+    const fallbacks = buildFallbackChain(preferred, phaseConfig);
+    return {
+      modelId: preferred,
+      fallbacks,
+      tier: requestedTier,
+      wasDowngraded: !isModelAvailable(configuredPrimary, [preferred]),
+      reason: `preferred session model ${preferred} satisfies ${requestedTier} tier`,
+      selectionMethod: "tier-only",
+    };
+  }
+
   // STEP 2: Capability scoring (when enabled and multiple eligible models exist)
   if (routingConfig.capability_routing !== false && eligible.length > 1 && unitType) {
     const requirements = computeTaskRequirements(unitType, taskMetadata);
@@ -551,15 +573,15 @@ export function defaultRoutingConfig(): DynamicRoutingConfig {
 // ─── Tier-Based Model Resolution (for profile defaults) ─────────────────────
 
 /**
- * Fallback-only canonical model IDs per tier. Returned when the
+ * Fallback-only canonical model IDs per tier. Returned only when the
  * available-model list is empty (e.g., preferences are loaded before the
- * model registry is populated at bootstrap), or when a non-empty registry has
- * no model at the requested tier.
+ * model registry is populated at bootstrap).
  *
  * Precedence (resolveModelForTier):
  *   1. configured `tier_models[tier]` (via getEligibleModels) — exact/bare match
- *   2. cheapest available model whose tier matches `tier`
- *   3. CANONICAL_TIER_MODELS[tier] as last-resort fallback
+ *   2. preferred/session model when it is available and satisfies `tier`
+ *   3. cheapest available model whose tier matches `tier`
+ *   4. CANONICAL_TIER_MODELS[tier] when the registry is empty
  */
 const CANONICAL_TIER_MODELS: Record<ComplexityTier, string> = {
   light: "claude-haiku-4-5",
@@ -573,9 +595,10 @@ export function canonicalModelForTier(tier: ComplexityTier): string {
 
 /**
  * Single source of truth for tier-based model selection.
- * Returns the cheapest available model whose capability tier matches `tier`,
- * honoring `routingConfig.tier_models[tier]` when set. Returns undefined when
- * no available model matches the tier.
+ * Returns the preferred/session model when it satisfies `tier`, otherwise the
+ * cheapest available model whose capability tier matches `tier`, honoring
+ * `routingConfig.tier_models[tier]` when set. Returns undefined when no
+ * available model satisfies the tier.
  *
  * `crossProvider`: when false, restricts the search to models that share the
  * canonical (Anthropic) provider for the tier. When true, any provider is
@@ -586,8 +609,9 @@ function findModelForTier(
   routingConfig: DynamicRoutingConfig,
   availableModelIds: string[],
   crossProvider: boolean,
+  preferredModelId?: string,
 ): string | undefined {
-  const eligible = getEligibleModels(tier, availableModelIds, routingConfig);
+  const eligible = getEligibleModels(tier, availableModelIds, routingConfig, preferredModelId);
   if (eligible.length === 0) return undefined;
 
   if (crossProvider) {
@@ -600,6 +624,13 @@ function findModelForTier(
     const bare = bareModelId(id);
     return MODEL_CAPABILITY_TIER[bare] === tier && bare.startsWith("claude-");
   });
+
+  // Honor the preferred/session model only when it is itself a same-provider
+  // (Anthropic/Claude) model. A non-Anthropic session model must not bypass
+  // the cross_provider:false restriction.
+  const preferred = findPreferredModelForTier(tier, availableModelIds, preferredModelId);
+  if (preferred && sameProvider.includes(preferred)) return preferred;
+
   return sameProvider[0];
 }
 
@@ -610,9 +641,11 @@ function findModelForTier(
  *
  * Precedence:
  *   1. configured `tier_models[tier]`, if provided and available
- *   2. tier-matching model from any provider in `availableModelIds`
- *   3. canonical Anthropic ID as a fallback only when nothing else matches
- *      (or `availableModelIds` is empty, e.g., during early bootstrap)
+ *   2. preferred/session model when available and satisfying the tier
+ *   3. tier-matching model from any provider in `availableModelIds`
+ *   4. preferred/session model, then first available model, when the registry
+ *      is non-empty but has no tier match
+ *   5. canonical Anthropic ID only when `availableModelIds` is empty
  *
  * @param tier              The capability tier to resolve
  * @param availableModelIds List of available model IDs (REQUIRED for
@@ -620,6 +653,7 @@ function findModelForTier(
  *                          the model registry is genuinely unavailable)
  * @param routingConfig     Optional routing config, or legacy crossProvider boolean
  * @param crossProvider     Whether to consider models from other providers
+ * @param preferredModelId  Optional selected/session model ID to prefer
  */
 export function resolveModelForTier(
   tier: ComplexityTier,
@@ -631,12 +665,14 @@ export function resolveModelForTier(
   availableModelIds: string[],
   routingConfig?: DynamicRoutingConfig,
   crossProvider?: boolean,
+  preferredModelId?: string,
 ): string;
 export function resolveModelForTier(
   tier: ComplexityTier,
   availableModelIds: string[],
   routingConfigOrCrossProvider: DynamicRoutingConfig | boolean = defaultRoutingConfig(),
   crossProvider?: boolean,
+  preferredModelId?: string,
 ): string {
   const routingConfig = typeof routingConfigOrCrossProvider === "boolean"
     ? defaultRoutingConfig()
@@ -645,24 +681,68 @@ export function resolveModelForTier(
     ? routingConfigOrCrossProvider
     : crossProvider ?? routingConfig.cross_provider !== false;
 
-  // No available models known — return canonical fallback
+  // No available models known — prefer the session model when provided, else canonical
   if (availableModelIds.length === 0) {
+    if (preferredModelId) {
+      return normalizeResolvedTierModelId(preferredModelId, tier, routingConfig);
+    }
     incrementLegacyTelemetry("legacy.providerDefaultUsed");
     return canonicalModelForTier(tier);
   }
 
   // Cross-provider tier search
-  const resolved = findModelForTier(tier, routingConfig, availableModelIds, allowCrossProvider);
+  const resolved = findModelForTier(tier, routingConfig, availableModelIds, allowCrossProvider, preferredModelId);
   if (resolved) {
     return normalizeResolvedTierModelId(resolved, tier, routingConfig);
   }
 
-  incrementLegacyTelemetry("legacy.providerDefaultUsed");
-  return canonicalModelForTier(tier);
+  const providerLocalFallback = findAvailableModelId(preferredModelId, availableModelIds)
+    ?? availableModelIds[0]
+    ?? canonicalModelForTier(tier);
+  return normalizeResolvedTierModelId(providerLocalFallback, tier, routingConfig);
 }
 
 // ─── Internal ────────────────────────────────────────────────────────────────
 
+function modelProvider(modelId: string): string | undefined {
+  const slash = modelId.indexOf("/");
+  return slash > 0 ? modelId.slice(0, slash) : undefined;
+}
+
+function findAvailableModelId(
+  preferredModelId: string | undefined,
+  availableModelIds: string[],
+): string | undefined {
+  if (!preferredModelId) return undefined;
+  if (availableModelIds.includes(preferredModelId)) return preferredModelId;
+
+  const preferredBare = bareModelId(preferredModelId);
+  if (!preferredBare) return undefined;
+  const preferredProvider = modelProvider(preferredModelId)?.toLowerCase();
+  if (preferredProvider) {
+    const providerMatch = availableModelIds.find(id =>
+      modelProvider(id)?.toLowerCase() === preferredProvider && bareModelId(id) === preferredBare
+    );
+    if (providerMatch) return providerMatch;
+  }
+
+  return availableModelIds.find(id => bareModelId(id) === preferredBare);
+}
+
+function modelSatisfiesTier(modelId: string, tier: ComplexityTier): boolean {
+  return tierOrdinal(getModelTier(modelId)) >= tierOrdinal(tier);
+}
+
+function findPreferredModelForTier(
+  tier: ComplexityTier,
+  availableModelIds: string[],
+  preferredModelId: string | undefined,
+): string | undefined {
+  const preferred = findAvailableModelId(preferredModelId, availableModelIds);
+  if (!preferred) return undefined;
+  return modelSatisfiesTier(preferred, tier) ? preferred : undefined;
+}
+
 /**
  * Check whether a model ID is present in the available models list.
  * Handles bare IDs ("claude-opus-4-6") and provider-prefixed IDs ("anthropic/claude-opus-4-6").

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

@@ -310,40 +310,29 @@ function _atomicWrite(basePath: string, content: string): void {
 /**
  * Acquire an exclusive lockfile for rewrite operations.
  * Uses O_CREAT|O_EXCL for atomic creation — if the file exists, another
- * process holds the lock. Retries briefly, then proceeds anyway (best-effort)
- * to avoid deadlocking the UI on a stale lock.
+ * process holds the lock. Clears stale locks, then proceeds anyway
+ * (best-effort) to avoid blocking the UI.
  */
 function _withLock<T>(basePath: string, fn: () => T): T {
   const lockPath = join(basePath, ".gsd", LOCKFILE);
   let fd: number | null = null;
-  const maxAttempts = 5;
-  const retryMs = 20;
 
-  for (let i = 0; i < maxAttempts; i++) {
-    try {
-      mkdirSync(join(basePath, ".gsd"), { recursive: true });
-      fd = openSync(lockPath, "wx");
-      break;
-    } catch (err: any) {
-      if (err?.code === "EEXIST") {
-        // Check if lock is stale (older than 5s)
-        try {
-          const stat = readFileSync(lockPath, "utf-8");
-          const lockTime = parseInt(stat, 10);
-          if (Date.now() - lockTime > 5000) {
-            try { unlinkSync(lockPath); } catch { /* race ok */ }
-            continue;
-          }
-        } catch { /* can't read lock, retry */ }
-
-        // Wait and retry
-        const start = Date.now();
-        while (Date.now() - start < retryMs) { /* spin */ }
-        continue;
-      }
-      // Other error — proceed without lock
-      break;
+  try {
+    mkdirSync(join(basePath, ".gsd"), { recursive: true });
+    fd = openSync(lockPath, "wx");
+  } catch (err: any) {
+    if (err?.code === "EEXIST") {
+      // Check if lock is stale (older than 5s)
+      try {
+        const stat = readFileSync(lockPath, "utf-8");
+        const lockTime = parseInt(stat, 10);
+        if (Date.now() - lockTime > 5000) {
+          try { unlinkSync(lockPath); } catch { /* race ok */ }
+          try { fd = openSync(lockPath, "wx"); } catch { /* race ok */ }
+        }
+      } catch { /* proceed without lock */ }
     }
+    // Any lock acquisition error leaves fd null; proceed without lock.
   }
 
   // Best-effort: mutation runs regardless of lock status (idempotent overwrites).

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

@@ -1,7 +1,9 @@
 // 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 type { NotificationPreferences } from "./types.js";
 import { loadEffectiveGSDPreferences } from "./preferences.js";
 import { sendRemoteNotification as _sendRemoteNotification } from "../remote-questions/notify.js";
@@ -25,6 +27,8 @@ interface BellStream {
   write(chunk: string): unknown;
 }
 
+const executablePathCache = new Map<string, string | null>();
+
 /**
  * Send a native desktop notification. Non-blocking, non-fatal.
  * macOS: osascript, Linux: notify-send, Windows: skipped.
@@ -73,13 +77,26 @@ export function sendDesktopNotification(
     try {
       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: NotificationCommand): void {
+  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: NotificationKind,
   preferences: NotificationPreferences | undefined = loadEffectiveGSDPreferences()?.preferences.notifications,
@@ -194,11 +211,25 @@ function escapeAppleScript(s: string): string {
  * Non-fatal — returns null on any error.
  */
 function findExecutable(name: string): string | null {
-  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: string | null = 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(): BellStream | null {

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/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 */ }
   }
 }