@opengsd/gsd-pi 1.3.0 → 1.4.0

package/dist/resources/extensions/gsd/compat/planning-compat.js

@@ -0,0 +1,142 @@
+// Project/App: gsd-pi
+// File Purpose: `.planning/` compat helpers — layout capture and projection sha
+// recording. Parallel to the .gsd/ write-time flush in markdown-renderer.ts.
+import { existsSync, readFileSync, readdirSync } from "node:fs";
+import { join } from "node:path";
+import { computeProjectionSha, readCompatMarker, writeCompatMarker, } from "./compat-marker.js";
+import { logWarning } from "../workflow-logger.js";
+export function isPlanningPassthroughRelPath(relPath) {
+    if (relPath.startsWith("codebase/") || relPath.startsWith("research/"))
+        return true;
+    if (relPath === "config.json")
+        return true;
+    const name = relPath.split("/").pop() ?? relPath;
+    if (name === "PATTERNS.md" || name === "REVIEWS.md")
+        return true;
+    if (name.endsWith("-DISCUSSION-LOG.md"))
+        return true;
+    if (name.endsWith("-RESEARCH.md") && !name.endsWith("-PLAN.md"))
+        return true;
+    return false;
+}
+// Files that gsd-pi creates in .gsd/ at startup and that do not constitute
+// markdown content written by gsd-core. Excluded from the content check so a
+// .planning/-only project that already has a gsd.db (but no milestone markdown)
+// is not mistakenly treated as a coexistence project.
+const KNOWN_NON_CONTENT_FILES = new Set([
+    "gsd.db",
+    "gsd.db-wal",
+    "gsd.db-shm",
+    "completed-units.json",
+]);
+export function gsdTreeHasContent(basePath) {
+    const gsdDir = join(basePath, ".gsd");
+    return (existsSync(gsdDir) &&
+        readdirSync(gsdDir).some((name) => !name.startsWith(".") && !KNOWN_NON_CONTENT_FILES.has(name)));
+}
+export function walkPlanningRelPaths(planningDir, prefix = "") {
+    const paths = [];
+    let entries;
+    try {
+        entries = readdirSync(join(planningDir, prefix), { withFileTypes: true });
+    }
+    catch {
+        return paths;
+    }
+    for (const entry of entries) {
+        const rel = prefix ? `${prefix}/${entry.name}` : entry.name;
+        if (entry.isDirectory()) {
+            if (entry.name === "workstreams")
+                continue;
+            paths.push(...walkPlanningRelPaths(planningDir, rel));
+        }
+        else {
+            paths.push(rel);
+        }
+    }
+    return paths;
+}
+/**
+ * Record freshly written `.planning/` projection files in the compat marker.
+ */
+export function applyPlanningProjectionWrites(basePath, writes) {
+    if (writes.length === 0)
+        return;
+    const marker = readCompatMarker(basePath);
+    if (!marker.planning) {
+        marker.planning = { active: true, layout: null, projections: {}, passthrough: {} };
+    }
+    marker.planning.active = true;
+    for (const write of writes) {
+        const abs = join(basePath, ".planning", write.relPath);
+        if (!existsSync(abs))
+            continue;
+        const entry = {
+            sha: computeProjectionSha(readFileSync(abs, "utf-8")),
+            entities: write.entities,
+        };
+        const map = write.passthrough ? marker.planning.passthrough : marker.planning.projections;
+        map[write.relPath] = entry;
+    }
+    marker.lastWriter = "gsd-pi";
+    marker.lastProjectedAt = new Date().toISOString();
+    writeCompatMarker(basePath, marker);
+}
+/**
+ * Capture-on-first-read: infer `.planning/` layout from disk, import content
+ * into the DB so gsd-pi's projection reflects gsd-core's tree instead of
+ * overwriting it, then activate the compat marker. Projection shas are seeded
+ * by drift repair / write-time hooks — not from raw disk here.
+ *
+ * Must only be called when !dryRun — it writes both the DB and the marker.
+ */
+export async function capturePlanningCompatIfNeeded(basePath, options) {
+    if (options?.dryRun)
+        return;
+    const planningDir = join(basePath, ".planning");
+    if (!existsSync(planningDir))
+        return;
+    const marker = readCompatMarker(basePath);
+    if (marker.planning?.active && marker.planning.layout)
+        return;
+    // First encounter: parse layout, import content into the DB, then activate the
+    // marker. When `.gsd/` already exists (coexistence), import from disk via
+    // migrateHierarchyToDb and do not call writeGSDDirectory — reconcile runs
+    // external-markdown-edit before external-planning-edit and must not destroy
+    // gsd-core `.gsd/` edits before that pipeline can see them. Planning-only
+    // projects materialize `.gsd/` from the parsed tree first, then import.
+    const { parsePlanningDirectory } = await import("../migrate/parser.js");
+    const { detectPlanningLayout } = await import("../migrate/layout-detect.js");
+    const parsed = await parsePlanningDirectory(planningDir);
+    const layout = detectPlanningLayout(parsed);
+    if (!layout)
+        return;
+    // Import into the DB. Dynamic imports break the module-init cycle
+    // (planning-compat ← reconcile ← state ← md-importer). Matches the import
+    // pattern in repairExternalPlanningEdit.
+    try {
+        const { migrateHierarchyToDb } = await import("../md-importer.js");
+        const { invalidateStateCache } = await import("../state.js");
+        if (!gsdTreeHasContent(basePath)) {
+            const { transformToGSD } = await import("../migrate/transformer.js");
+            const { writeGSDDirectory } = await import("../migrate/writer.js");
+            const gsdProject = transformToGSD(parsed);
+            await writeGSDDirectory(gsdProject, basePath);
+        }
+        migrateHierarchyToDb(basePath);
+        invalidateStateCache();
+    }
+    catch (e) {
+        logWarning("reconcile", `planning DB import failed on initial capture — reconcile may overwrite gsd-core content: ${e.message}`);
+    }
+    // Activate the marker. Leave projections/passthrough empty: the next
+    // writePlanningDirectory → applyPlanningProjectionWrites call will seed
+    // accurate SHAs from the normalized output rather than the raw gsd-core files.
+    const freshMarker = readCompatMarker(basePath);
+    if (!freshMarker.planning) {
+        freshMarker.planning = { active: false, layout: null, projections: {}, passthrough: {} };
+    }
+    freshMarker.planning.active = true;
+    freshMarker.planning.layout = layout;
+    writeCompatMarker(basePath, freshMarker);
+}

package/dist/resources/extensions/gsd/config-overlay.js

@@ -15,7 +15,7 @@ function collectConfigSections(options) {
     const globalPrefs = loadGlobalGSDPreferences();
     const projectPrefs = loadProjectGSDPreferences(options?.basePath);
     const loadOpts = options?.availableModelIds
-        ? { availableModelIds: options.availableModelIds }
+        ? { availableModelIds: options.availableModelIds, preferredModelId: options.preferredModelId }
         : undefined;
     const effective = loadEffectiveGSDPreferences(options?.basePath, loadOpts);
     const prefs = effective?.preferences;
@@ -46,7 +46,7 @@ function collectConfigSections(options) {
     ];
     const modelRows = [];
     for (const [label, unitType] of unitTypes) {
-        const resolved = resolveModelWithFallbacksForUnit(unitType, options?.basePath, options?.availableModelIds);
+        const resolved = resolveModelWithFallbacksForUnit(unitType, options?.basePath, options?.availableModelIds, options?.preferredModelId);
         if (resolved) {
             let val = resolved.primary;
             if (resolved.fallbacks.length > 0) {

package/dist/resources/extensions/gsd/consent-question.js

@@ -170,6 +170,9 @@ export function classifyQuestion(input) {
 /**
  * THE single policy point for whether a question's answer counts as answered.
  *
+ * - timed_out rounds → "timeout" for every kind (host elicitation expired
+ *   before the user answered; fail-closed, but the caller pauses-and-waits
+ *   instead of re-asking into the same timeout loop, #852).
  * - cancelled rounds → "cancelled" for every kind.
  * - gate: delegates to evaluateGateAnswer in the consent-verdict leaf — the
  *   same verdict engine write-gate's applyAskUserQuestionsGateResult consumes;
@@ -181,6 +184,8 @@ export function classifyQuestion(input) {
  */
 export function evaluateAnswer(options) {
     const { question, details } = options;
+    if (details.timed_out)
+        return "timeout";
     if (details.cancelled)
         return "cancelled";
     const { kind } = classifyQuestion({ id: question.id, options: question.options });
@@ -203,6 +208,7 @@ export function evaluateAnswer(options) {
 }
 const OUTCOME_PRECEDENCE = [
     "cancelled",
+    "timeout",
     "waiting",
     "declined",
     "verified",
@@ -217,6 +223,12 @@ const OUTCOME_PRECEDENCE = [
  * a no-op, so it reports "answered" here.
  */
 export function evaluateAskUserQuestionsRound(questions, details) {
+    // timed_out is checked before cancelled: a host elicitation timeout is a
+    // more specific signal than the deliberate-dismissal cancelled it is also
+    // marked with, and callers must pause-and-wait instead of treating it as a
+    // re-ask-able cancel (#852).
+    if (details.timed_out)
+        return "timeout";
     if (details.cancelled)
         return "cancelled";
     let worst = "answered";

package/dist/resources/extensions/gsd/consent-verdict.js

@@ -44,13 +44,23 @@ export function hasNotesValue(notes) {
 /**
  * THE per-question verdict for gate questions (fail-closed):
  *
+ * - timed_out rounds → "timeout" (host elicitation expired before the user
+ *   answered; fail-closed — the gate stays pending — but the caller pauses
+ *   instead of re-asking into the same timeout loop, #852).
  * - cancelled rounds → "cancelled".
  * - the confirmation option (structural match) → "verified".
  * - any other real selection → "declined".
  * - empty/missing selection → "waiting" — an empty answer is NEVER an answer,
  *   so notes can never satisfy a gate either.
+ *
+ * `timed_out` is checked first: the handler marks a timed-out round with both
+ * `cancelled: true` and `timed_out: true` (see
+ * `askUserQuestionsHandler`), so the timeout must win to avoid the cancelled
+ * branch's re-ask semantics.
  */
 export function evaluateGateAnswer(question, details) {
+    if (details.timed_out)
+        return "timeout";
     if (details.cancelled)
         return "cancelled";
     const questionId = typeof question.id === "string" ? question.id : "";

package/dist/resources/extensions/gsd/dashboard-overlay.js

@@ -12,14 +12,16 @@ import { loadFile } from "./files.js";
 import { isDbAvailable, getMilestoneSlices, getSliceTasks } from "./gsd-db.js";
 import { resolveMilestoneFile } from "./paths.js";
 import { getAutoDashboardData } from "./auto.js";
+import { getAutoRuntimeSnapshot } from "./auto-runtime-state.js";
 import { getLedger, getProjectTotals, aggregateByPhase, aggregateBySlice, aggregateByModel, aggregateCacheHitRate, formatCost, formatTokenCount, formatCostProjection, getPromptSizeStats, } from "./metrics.js";
 import { loadEffectiveGSDPreferences } from "./preferences.js";
+import { countPendingCaptures } from "./captures.js";
 import { getActiveWorktreeName } from "./worktree-session-state.js";
 import { getWorkerBatches, hasActiveWorkers } from "../subagent/worker-registry.js";
 import { formatDuration, padRight, joinColumns, centerLine, fitColumns, STATUS_GLYPH, STATUS_COLOR } from "../shared/mod.js";
 import { estimateTimeRemaining } from "./auto-dashboard.js";
 import { computeProgressScore } from "./progress-score.js";
-import { runEnvironmentChecks } from "./doctor-environment.js";
+import { runEnvironmentChecksAsync } from "./doctor-environment.js";
 import { formattedShortcutPair } from "./shortcut-defs.js";
 import { renderDialogFrame, renderKeyHints } from "./tui/render-kit.js";
 export function unitLabel(type) {
@@ -60,6 +62,9 @@ export class GSDDashboardOverlay {
     loading = true;
     loadedDashboardIdentity;
     refreshInFlight = null;
+    envRefreshInFlight = null;
+    cachedEnvBasePath;
+    cachedEnvIssues = [];
     disposed = false;
     resizeHandler = null;
     cachedMetrics = null;
@@ -102,28 +107,89 @@ export class GSDDashboardOverlay {
             currentUnit,
         ].join("|");
     }
+    refreshVolatileDashboardData(snapshot = getAutoRuntimeSnapshot()) {
+        let pendingCaptureCount = this.dashData.pendingCaptureCount;
+        try {
+            if (snapshot.basePath) {
+                pendingCaptureCount = countPendingCaptures(snapshot.basePath);
+            }
+        }
+        catch {
+            // Non-fatal — keep last known value
+        }
+        this.dashData = {
+            ...this.dashData,
+            active: snapshot.active,
+            paused: snapshot.paused,
+            currentUnit: snapshot.currentUnit
+                ? {
+                    type: snapshot.currentUnit.type,
+                    id: snapshot.currentUnit.id,
+                    startedAt: snapshot.currentUnit.startedAt,
+                }
+                : null,
+            basePath: snapshot.basePath,
+            elapsed: snapshot.active || snapshot.paused
+                ? (this.dashData.startTime > 0 ? Date.now() - this.dashData.startTime : 0)
+                : 0,
+            toolSurface: snapshot.toolSurface,
+            pendingCaptureCount,
+        };
+    }
     async refreshDashboard(initial = false) {
         if (this.disposed)
             return;
-        this.dashData = getAutoDashboardData();
-        const nextIdentity = this.computeDashboardIdentity(this.dashData);
+        const runtimeSnapshot = getAutoRuntimeSnapshot();
+        const nextIdentity = this.computeDashboardIdentity(runtimeSnapshot);
         const identityChanged = initial || nextIdentity !== this.loadedDashboardIdentity;
         if (identityChanged) {
+            this.dashData = getAutoDashboardData();
+            const loadedIdentity = this.computeDashboardIdentity(this.dashData);
             const loaded = await this.loadData();
             if (this.disposed)
                 return;
             if (loaded) {
-                this.loadedDashboardIdentity = nextIdentity;
+                this.loadedDashboardIdentity = loadedIdentity;
             }
         }
+        else {
+            this.refreshVolatileDashboardData(runtimeSnapshot);
+        }
         if (initial) {
             this.loading = false;
         }
+        this.scheduleEnvironmentRefresh(this.dashData.basePath || process.cwd());
         if (identityChanged) {
             this.invalidate();
         }
         this.tui.requestRender();
     }
+    scheduleEnvironmentRefresh(basePath) {
+        if (this.cachedEnvBasePath !== basePath) {
+            this.cachedEnvBasePath = basePath;
+            this.cachedEnvIssues = [];
+            this.invalidate();
+        }
+        if (this.envRefreshInFlight || this.disposed)
+            return;
+        this.envRefreshInFlight = this.refreshEnvironmentHealth(basePath)
+            .finally(() => {
+            this.envRefreshInFlight = null;
+        });
+    }
+    async refreshEnvironmentHealth(basePath) {
+        try {
+            const envResults = await runEnvironmentChecksAsync(basePath);
+            if (this.disposed || this.cachedEnvBasePath !== basePath)
+                return;
+            this.cachedEnvIssues = envResults.filter(r => r.status !== "ok");
+            this.invalidate();
+            this.tui.requestRender();
+        }
+        catch {
+            // Non-fatal — keep last known environment issues
+        }
+    }
     async loadData() {
         const base = this.dashData.basePath || process.cwd();
         try {
@@ -504,8 +570,7 @@ export class GSDDashboardOverlay {
             }
         }
         // Environment health section (#1221) — only show issues
-        const envResults = runEnvironmentChecks(this.dashData.basePath || process.cwd());
-        const envIssues = envResults.filter(r => r.status !== "ok");
+        const envIssues = this.cachedEnvIssues;
         if (envIssues.length > 0) {
             lines.push(blank());
             lines.push(hr());

package/dist/resources/extensions/gsd/db/engine.js

@@ -19,7 +19,7 @@ import { createCoordinationTablesV24 } from "../db-coordination-schema.js";
 import { createDbConnectionCache } from "../db-connection-cache.js";
 import { backupDatabaseBeforeMigration, isMigrationBackupError } from "../db-migration-backup.js";
 import { applyMigrationV2Artifacts, applyMigrationV3Memories, applyMigrationV4DecisionMadeBy, applyMigrationV5HierarchyTables, applyMigrationV6SliceSummaries, applyMigrationV7Dependencies, applyMigrationV8PlanningFields, applyMigrationV9Ordering, applyMigrationV10ReplanTrigger, applyMigrationV11TaskPlanning, applyMigrationV12QualityGates, applyMigrationV13HotPathIndexes, applyMigrationV14SliceDependencies, applyMigrationV15AuditTables, applyMigrationV16EscalationSource, applyMigrationV17TaskEscalation, applyMigrationV18MemorySources, applyMigrationV19MemoryFts, applyMigrationV20MemoryRelations, applyMigrationV21StructuredMemories, applyMigrationV22QualityGateRepair, applyMigrationV23MilestoneQueue, applyMigrationV26MilestoneCommitAttributions, applyMigrationV27ArtifactHash, applyMigrationV28MemoryLastHitAt, applyMigrationV29RepositoryTargets, } from "../db-migration-steps.js";
-import { isMemoriesFtsAvailableSchema, tryCreateMemoriesFtsSchema } from "../db-memory-fts-schema.js";
+import { isMemoriesFtsAvailableSchema, rebuildMemoriesFtsSchemaOnce, tryCreateMemoriesFtsSchema, } from "../db-memory-fts-schema.js";
 import { createDbOpenState } from "../db-open-state.js";
 import { createRuntimeKvTableV25 } from "../db-runtime-kv-schema.js";
 import { getCurrentSchemaVersion, recordSchemaVersion } from "../db-schema-metadata.js";
@@ -101,6 +101,9 @@ function initSchema(db, fileBacked, dbPath) {
         throw err;
     }
     migrateSchema(db, dbPath);
+    rebuildMemoriesFtsSchemaOnce(db, {
+        onRebuildFailed: (message) => logWarning("db", message),
+    });
 }
 export function _isLikelyWslDrvFsPathForTest(dbPath) {
     if (!dbPath || process.platform !== "linux")
@@ -615,6 +618,33 @@ export function closeDatabase() {
     // failed open doesn't persist into the next open attempt or status check.
     _dbOpenState.reset();
 }
+/**
+ * Open an isolated database connection that does NOT touch the process-wide
+ * `currentDb` singleton. Intended for background observers (e.g. the parallel
+ * monitor overlay) that must read a database without displacing an active
+ * workflow session connection.
+ *
+ * The caller MUST call `adapter.close()` when done. Schema migrations are NOT
+ * run — the database must already exist and be fully migrated by the primary
+ * connection. Returns null if the connection cannot be opened.
+ */
+export function openIsolatedDatabase(path) {
+    try {
+        const rawDb = providerLoader.openRaw(path);
+        if (!rawDb)
+            return null;
+        const adapter = createDbAdapter(rawDb);
+        // Minimal pragmas for a short-lived read-only observer connection.
+        // WAL mode is already set file-wide by the primary connection; repeating
+        // it here is a no-op on an existing WAL file and safe to issue.
+        adapter.exec("PRAGMA journal_mode=WAL");
+        adapter.exec("PRAGMA busy_timeout = 5000");
+        return adapter;
+    }
+    catch {
+        return null;
+    }
+}
 /**
  * Re-open the active database connection from disk.
  *

package/dist/resources/extensions/gsd/db/queries.js

@@ -12,6 +12,7 @@ import { rowToActiveDecision, rowToActiveRequirement, rowToDecision, rowToRequir
 import { rowToGate } from "../db-gate-rows.js";
 import { rowToArtifact, rowToMilestone } from "../db-milestone-artifact-rows.js";
 import { rowToSlice, rowToTask } from "../db-task-slice-rows.js";
+import { TERMINAL_STATUS_SQL } from "./sql-constants.js";
 function parseStringArrayColumn(raw) {
     if (Array.isArray(raw))
         return raw.filter((entry) => typeof entry === "string");
@@ -35,6 +36,44 @@ function parseStringArrayColumn(raw) {
 function normalizeRepoPath(file) {
     return file.trim().replace(/\\/g, "/").replace(/^\.\/+/, "");
 }
+function numberColumn(row, column) {
+    const value = row?.[column];
+    if (typeof value === "number")
+        return value;
+    if (typeof value === "bigint")
+        return Number(value);
+    if (typeof value === "string") {
+        const parsed = Number(value);
+        return Number.isFinite(parsed) ? parsed : 0;
+    }
+    return 0;
+}
+function getCompletionCount(table) {
+    const row = getDbOrNull().prepare(`SELECT
+       COUNT(*) AS total,
+       COALESCE(SUM(CASE WHEN status IN (${TERMINAL_STATUS_SQL}) THEN 1 ELSE 0 END), 0) AS completed
+     FROM ${table}`).get();
+    return {
+        completed: numberColumn(row, "completed"),
+        total: numberColumn(row, "total"),
+    };
+}
+export function getHierarchyCompletionCounts() {
+    if (!getDbOrNull()) {
+        return { milestones: 0, milestonesTotal: 0, slices: 0, slicesTotal: 0, tasks: 0, tasksTotal: 0 };
+    }
+    const milestones = getCompletionCount("milestones");
+    const slices = getCompletionCount("slices");
+    const tasks = getCompletionCount("tasks");
+    return {
+        milestones: milestones.completed,
+        milestonesTotal: milestones.total,
+        slices: slices.completed,
+        slicesTotal: slices.total,
+        tasks: tasks.completed,
+        tasksTotal: tasks.total,
+    };
+}
 export function getDecisionById(id) {
     if (!getDbOrNull())
         return null;
@@ -218,6 +257,46 @@ export function getMilestoneSlices(milestoneId) {
     const rows = getDbOrNull().prepare("SELECT * FROM slices WHERE milestone_id = :mid ORDER BY sequence, id").all({ ":mid": milestoneId });
     return rows.map(rowToSlice);
 }
+export function getParallelMonitorSliceProgress(milestoneId) {
+    const db = getDbOrNull();
+    if (!db)
+        return [];
+    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": milestoneId });
+    return rows.map((row) => ({
+        id: String(row["id"] ?? ""),
+        status: String(row["status"] ?? ""),
+        total: Number(row["total"] ?? 0),
+        done: Number(row["done"] ?? 0),
+    }));
+}
+export function getParallelMonitorRecentCompletions(milestoneId, limit = 5) {
+    const db = getDbOrNull();
+    if (!db)
+        return [];
+    const numericLimit = Number.isFinite(limit) ? Math.floor(limit) : 5;
+    const safeLimit = Math.max(1, Math.min(50, numericLimit));
+    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 ${safeLimit}`).all({ ":mid": milestoneId });
+    return rows.map((row) => ({
+        taskId: String(row["id"] ?? ""),
+        sliceId: String(row["slice_id"] ?? ""),
+        oneLiner: String(row["one_liner"] ?? ""),
+    }));
+}
 /**
  * Load slices for many milestones in a single query. Returns a Map keyed by
  * milestone_id, preserving `ORDER BY sequence, id` within each bucket.
@@ -281,6 +360,20 @@ export function getArtifact(path) {
         return null;
     return rowToArtifact(row);
 }
+/** Milestone-level artifacts (CONTEXT, RESEARCH, VALIDATION, etc.) from the artifacts table. */
+export function getMilestoneScopedArtifacts(milestoneId) {
+    if (!getDbOrNull())
+        return [];
+    const rows = getDbOrNull().prepare("SELECT * FROM artifacts WHERE milestone_id = :mid AND slice_id IS NULL AND task_id IS NULL ORDER BY path").all({ ":mid": milestoneId });
+    return rows.map(rowToArtifact);
+}
+/** Slice-level artifacts (CONTEXT, RESEARCH, CONTINUE, etc.) from the artifacts table. */
+export function getSliceScopedArtifacts(milestoneId, sliceId) {
+    if (!getDbOrNull())
+        return [];
+    const rows = getDbOrNull().prepare("SELECT * FROM artifacts WHERE milestone_id = :mid AND slice_id = :sid AND task_id IS NULL ORDER BY path").all({ ":mid": milestoneId, ":sid": sliceId });
+    return rows.map(rowToArtifact);
+}
 /** Fast milestone status check — avoids deserializing JSON planning fields. */
 export function getActiveMilestoneIdFromDb() {
     if (!getDbOrNull())
@@ -337,6 +430,27 @@ export function getAssessment(path) {
     const row = getDbOrNull().prepare(`SELECT * FROM assessments WHERE path = :path`).get({ ":path": path });
     return row ?? null;
 }
+/**
+ * Look up a slice's `run-uat` assessment by (milestoneId, sliceId) identity,
+ * independent of the artifact `path`. Used as a DB fallback by the UAT
+ * closeout gate when a path migration orphans the ASSESSMENT markdown from its
+ * canonical expected path (ADR-017: DB-authoritative UAT sign-off).
+ *
+ * `status` holds the normalized verdict (`pass`/`fail`/…) written by
+ * `executeUatResultSave`; `fullContent` carries the ASSESSMENT body so callers
+ * can derive `uatType` without re-reading a file that may not exist.
+ */
+export function getSliceRunUatAssessment(milestoneId, sliceId) {
+    if (!getDbOrNull())
+        return null;
+    const row = getDbOrNull().prepare(`SELECT status, full_content AS fullContent FROM assessments
+      WHERE milestone_id = :mid AND slice_id = :sid AND scope = 'run-uat'
+      ORDER BY created_at DESC, ROWID DESC
+      LIMIT 1`).get({ ":mid": milestoneId, ":sid": sliceId });
+    if (!row)
+        return null;
+    return { status: String(row["status"] ?? ""), fullContent: String(row["fullContent"] ?? "") };
+}
 export function getLatestAssessmentByScope(milestoneId, scope) {
     if (!getDbOrNull())
         return null;

package/dist/resources/extensions/gsd/db/unit-dispatches.js

@@ -387,10 +387,31 @@ export function getRecentUnitKeysForWorker(workerId, limit = 20) {
     // Reverse so callers consume oldest-first (sliding-window semantics).
     return rows.reverse().map((r) => ({ key: r.unit_id }));
 }
-export function getRecentUnitKeysForProjectRoot(projectRootRealpath, limit = 20) {
+export function getRecentUnitKeysForProjectRoot(projectRootRealpath, limit = 20, traceId) {
     if (!isDbAvailable())
         return [];
     const db = _getAdapter();
+    // When a trace_id is provided, scope the window to the current session so
+    // stale finalize-retry entries from PREVIOUS sessions don't fire detectStuck
+    // Rule 1 on the first iteration of a new session — killing auto-mode before
+    // any new dispatch runs. Without this, a project that had two consecutive
+    // finalize-retry failures in a prior session is permanently stuck: every
+    // fresh session loads those stale errors and immediately declares stuck.
+    if (traceId) {
+        const rows = db.prepare(`SELECT ud.unit_type, ud.unit_id
+       FROM unit_dispatches ud
+       INNER JOIN workers w ON w.worker_id = ud.worker_id
+       WHERE w.project_root_realpath = :project_root_realpath
+         AND w.status != 'crashed'
+         AND ud.trace_id = :trace_id
+       ORDER BY ud.started_at DESC, ud.id DESC
+       LIMIT :limit`).all({
+            ":project_root_realpath": projectRootRealpath,
+            ":trace_id": traceId,
+            ":limit": limit,
+        });
+        return rows.reverse().map((r) => ({ key: `${r.unit_type}/${r.unit_id}` }));
+    }
     const rows = db.prepare(`SELECT ud.unit_type, ud.unit_id
      FROM unit_dispatches ud
      INNER JOIN workers w ON w.worker_id = ud.worker_id

package/dist/resources/extensions/gsd/db-memory-fts-schema.js

@@ -1,5 +1,7 @@
 // Project/App: gsd-pi
 // File Purpose: Memory FTS5 SQLite schema helpers for the GSD database facade.
+import { createRuntimeKvTableV25 } from "./db-runtime-kv-schema.js";
+export const MEMORIES_FTS_REBUILT_KEY = "memories_fts_rebuilt_at";
 function formatFtsUnavailableError(err) {
     const message = err instanceof Error ? err.message : String(err);
     return message.replace(/\bmoduel\s*:\s*/gi, "module: ");
@@ -54,3 +56,35 @@ export function isMemoriesFtsAvailableSchema(db) {
         return false;
     }
 }
+export function rebuildMemoriesFtsSchemaOnce(db, options = {}) {
+    if (!isMemoriesFtsAvailableSchema(db))
+        return;
+    createRuntimeKvTableV25(db);
+    const marker = db.prepare("SELECT 1 as present FROM runtime_kv WHERE scope = 'global' AND scope_id = '' AND key = :key").get({ ":key": MEMORIES_FTS_REBUILT_KEY });
+    if (marker)
+        return;
+    const now = new Date().toISOString();
+    try {
+        db.exec("BEGIN");
+        db.exec("INSERT INTO memories_fts(memories_fts) VALUES('rebuild')");
+        db.prepare(`INSERT INTO runtime_kv (scope, scope_id, key, value_json, updated_at)
+       VALUES ('global', '', :key, :value_json, :updated_at)
+       ON CONFLICT (scope, scope_id, key) DO UPDATE SET
+         value_json = excluded.value_json,
+         updated_at = excluded.updated_at`).run({
+            ":key": MEMORIES_FTS_REBUILT_KEY,
+            ":value_json": JSON.stringify(now),
+            ":updated_at": now,
+        });
+        db.exec("COMMIT");
+    }
+    catch (err) {
+        try {
+            db.exec("ROLLBACK");
+        }
+        catch {
+            // Best effort: leave startup alive and retry the rebuild on next open.
+        }
+        options.onRebuildFailed?.(`FTS5 rebuild failed: ${err.message}`);
+    }
+}