gsd-pi 2.76.0 → 2.77.0-dev.1594b263e

package/dist/resources/extensions/gsd/git-self-heal.js

@@ -9,12 +9,25 @@
  * what actions were taken. `formatGitError` maps raw git errors to
  * user-friendly messages suggesting `/gsd doctor`.
  */
+import { execFileSync } from "node:child_process";
 import { existsSync, unlinkSync } from "node:fs";
 import { join } from "node:path";
 import { MergeConflictError } from "./git-service.js";
 import { nativeMergeAbort, nativeRebaseAbort, nativeResetHard } from "./native-git-bridge.js";
 // Re-export for consumers
 export { MergeConflictError };
+function hasWorkingTreeChanges(cwd) {
+    try {
+        return execFileSync("git", ["status", "--porcelain"], {
+            cwd,
+            stdio: ["ignore", "pipe", "pipe"],
+            encoding: "utf-8",
+        }).trim().length > 0;
+    }
+    catch {
+        return true;
+    }
+}
 /**
  * Detect and clean up leftover merge/rebase state, then hard-reset.
  *
@@ -60,6 +73,20 @@ export function abortAndReset(cwd) {
             cleaned.push("rebase abort attempted (may have failed)");
         }
     }
+    // Preserve any staged or untracked user work before the hard reset.
+    // Reset --hard discards staged changes (reflog only covers committed
+    // state), so a labeled stash gives the user a recovery handle if their
+    // in-flight inspection work would otherwise be silently lost.
+    // (Issue #4980 HIGH-5)
+    if (hasWorkingTreeChanges(cwd)) {
+        try {
+            execFileSync("git", ["stash", "push", "--include-untracked", "-m", `gsd: pre-self-heal-reset ${new Date().toISOString()}`], { cwd, stdio: ["ignore", "pipe", "pipe"], encoding: "utf-8" });
+            cleaned.push("stashed working tree before reset");
+        }
+        catch {
+            /* nothing to stash, or stash refused (e.g. unresolved conflicts) — proceed */
+        }
+    }
     // Always hard-reset to HEAD
     try {
         nativeResetHard(cwd);

package/dist/resources/extensions/gsd/git-service.js

@@ -7,7 +7,7 @@
  * This module centralizes the GitPreferences interface, runtime exclusion
  * paths, commit type inference, and the runGit shell helper.
  */
-import { execFileSync, execSync } from "node:child_process";
+import { execFileSync } from "node:child_process";
 import { existsSync, mkdirSync, readFileSync, readdirSync, writeFileSync } from "node:fs";
 import { join } from "node:path";
 import { gsdRoot } from "./paths.js";
@@ -84,6 +84,7 @@ export class MergeConflictError extends GSDError {
  */
 export const RUNTIME_EXCLUSION_PATHS = [
     ".gsd/activity/",
+    ".gsd/audit/",
     ".gsd/forensics/",
     ".gsd/runtime/",
     ".gsd/worktrees/",
@@ -242,6 +243,107 @@ export function resolveMilestoneIntegrationBranch(basePath, milestoneId, prefs =
         reason: `Recorded integration branch "${recordedBranch}" for milestone ${milestoneId} no longer exists, and no safe fallback branch could be determined.`,
     };
 }
+// ─── Pre-Merge Command Tokenizer ──────────────────────────────────────────
+/**
+ * Tokenize a user-supplied pre-merge command string into argv form, with
+ * minimal support for double- and single-quoted strings. Designed to be
+ * sufficient for typical commands ("npm test", `npm run lint:ci`,
+ * `pnpm run tsc --noEmit`) without spawning a shell.
+ *
+ * Returns [] when the input is empty or whitespace-only.
+ * Throws when quoting is malformed.
+ *
+ * Used by GitServiceImpl.runPreMergeCheck to eliminate the shell-injection
+ * surface that running an arbitrary user string through a shell would create.
+ * (Issue #4980 HIGH-2)
+ */
+export function tokenizePreMergeCommand(input) {
+    const tokens = [];
+    let current = "";
+    let i = 0;
+    let quote = "";
+    let hasContent = false;
+    while (i < input.length) {
+        const ch = input[i];
+        if (quote) {
+            if (ch === quote) {
+                quote = "";
+            }
+            else if (ch === "\\" && quote === '"' && i + 1 < input.length) {
+                current += input[i + 1];
+                i += 2;
+                continue;
+            }
+            else {
+                current += ch;
+            }
+            i++;
+            continue;
+        }
+        if (ch === '"' || ch === "'") {
+            quote = ch;
+            hasContent = true;
+            i++;
+            continue;
+        }
+        if (ch === " " || ch === "\t") {
+            if (hasContent) {
+                tokens.push(current);
+                current = "";
+                hasContent = false;
+            }
+            i++;
+            continue;
+        }
+        if (ch === "\\" && i + 1 < input.length) {
+            current += input[i + 1];
+            i += 2;
+            hasContent = true;
+            continue;
+        }
+        current += ch;
+        hasContent = true;
+        i++;
+    }
+    if (quote) {
+        throw new Error(`Unterminated ${quote === '"' ? "double" : "single"} quote in pre-merge command`);
+    }
+    if (hasContent)
+        tokens.push(current);
+    return tokens;
+}
+function containsUnquotedShellControl(input) {
+    let i = 0;
+    let quote = "";
+    while (i < input.length) {
+        const ch = input[i];
+        if (quote) {
+            if (ch === quote) {
+                quote = "";
+            }
+            else if (ch === "\\" && quote === '"' && i + 1 < input.length) {
+                i += 2;
+                continue;
+            }
+            i++;
+            continue;
+        }
+        if (ch === '"' || ch === "'") {
+            quote = ch;
+            i++;
+            continue;
+        }
+        if (ch === "\\" && i + 1 < input.length) {
+            i += 2;
+            continue;
+        }
+        if (ch === ";" || ch === "&" || ch === "|" || ch === "`" || ch === "$" || ch === "<" || ch === ">") {
+            return true;
+        }
+        i++;
+    }
+    return false;
+}
 // ─── Git Helper ────────────────────────────────────────────────────────────
 /**
  * Strip git-svn noise from error messages.
@@ -600,8 +702,31 @@ export class GitServiceImpl {
                 return { passed: true, skipped: true };
             }
         }
+        // Tokenize and run via execFileSync (no shell). Shell metacharacters in
+        // user-supplied prefs.pre_merge_check would otherwise be interpreted as
+        // chaining/redirection (e.g. `;`, `&&`, `|`, backticks) — a privesc
+        // surface in repos with a checked-in `.gsd/PREFERENCES.md`.
+        // (Issue #4980 HIGH-2)
+        if (containsUnquotedShellControl(command)) {
+            return {
+                passed: false,
+                skipped: false,
+                command,
+                error: "pre_merge_check contains shell metacharacters (;, &&, |, $, backticks, redirects). " +
+                    "Put complex commands in a script file (e.g. './scripts/pre-merge.sh') and reference the script path instead.",
+            };
+        }
+        const tokens = tokenizePreMergeCommand(command);
+        if (tokens.length === 0) {
+            return { passed: true, skipped: true };
+        }
         try {
-            execSync(command, { cwd: this.basePath, stdio: "pipe", encoding: "utf-8" });
+            execFileSync(tokens[0], tokens.slice(1), {
+                cwd: this.basePath,
+                stdio: "pipe",
+                encoding: "utf-8",
+                env: GIT_NO_PROMPT_ENV,
+            });
             return { passed: true, skipped: false, command };
         }
         catch (err) {

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

@@ -24,6 +24,7 @@ import { GIT_NO_PROMPT_ENV } from "./git-constants.js";
  */
 const GSD_RUNTIME_PATTERNS = [
     ".gsd/activity/",
+    ".gsd/audit/",
     ".gsd/forensics/",
     ".gsd/runtime/",
     ".gsd/worktrees/",
@@ -45,6 +46,7 @@ const BASELINE_PATTERNS = [
     // ── GSD state directory (symlink to external storage) ──
     ".gsd",
     ".gsd-id",
+    ".mcp.json",
     ".bg-shell/",
     // ── OS junk ──
     ".DS_Store",

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

@@ -135,7 +135,7 @@ function openRawDb(path) {
     const Database = providerModule;
     return new Database(path);
 }
-const SCHEMA_VERSION = 20;
+export const SCHEMA_VERSION = 22;
 function indexExists(db, name) {
     return !!db.prepare("SELECT 1 as present FROM sqlite_master WHERE type = 'index' AND name = ?").get(name);
 }
@@ -234,7 +234,8 @@ function initSchema(db, fileBacked) {
         superseded_by TEXT DEFAULT NULL,
         hit_count INTEGER NOT NULL DEFAULT 0,
         scope TEXT NOT NULL DEFAULT 'project',
-        tags TEXT NOT NULL DEFAULT '[]'
+        tags TEXT NOT NULL DEFAULT '[]',
+        structured_fields TEXT DEFAULT NULL
       )
     `);
         db.exec(`
@@ -490,11 +491,6 @@ function initSchema(db, fileBacked) {
       )
     `);
         db.exec("CREATE INDEX IF NOT EXISTS idx_memories_active ON memories(superseded_by)");
-        db.exec("CREATE INDEX IF NOT EXISTS idx_memories_scope ON memories(scope)");
-        db.exec("CREATE INDEX IF NOT EXISTS idx_memory_sources_kind ON memory_sources(kind)");
-        db.exec("CREATE INDEX IF NOT EXISTS idx_memory_sources_scope ON memory_sources(scope)");
-        db.exec("CREATE INDEX IF NOT EXISTS idx_memory_relations_from ON memory_relations(from_id)");
-        db.exec("CREATE INDEX IF NOT EXISTS idx_memory_relations_to ON memory_relations(to_id)");
         db.exec("CREATE INDEX IF NOT EXISTS idx_replan_history_milestone ON replan_history(milestone_id, created_at)");
         // v13 indexes — hot-path dispatch queries
         db.exec("CREATE INDEX IF NOT EXISTS idx_tasks_active ON tasks(milestone_id, slice_id, status)");
@@ -510,14 +506,21 @@ function initSchema(db, fileBacked) {
         db.exec("CREATE INDEX IF NOT EXISTS idx_turn_git_tx_turn ON turn_git_transactions(trace_id, turn_id)");
         db.exec("CREATE INDEX IF NOT EXISTS idx_audit_events_trace ON audit_events(trace_id, ts)");
         db.exec("CREATE INDEX IF NOT EXISTS idx_audit_events_turn ON audit_events(trace_id, turn_id, ts)");
-        // ADR-011 Phase 2 — also created by the v17 migration; fresh installs
-        // skip migrations so the index must be created here too.
-        db.exec("CREATE INDEX IF NOT EXISTS idx_tasks_escalation_pending ON tasks(milestone_id, slice_id, escalation_pending)");
         db.exec(`CREATE VIEW IF NOT EXISTS active_decisions AS SELECT * FROM decisions WHERE superseded_by IS NULL`);
         db.exec(`CREATE VIEW IF NOT EXISTS active_requirements AS SELECT * FROM requirements WHERE superseded_by IS NULL`);
         db.exec(`CREATE VIEW IF NOT EXISTS active_memories AS SELECT * FROM memories WHERE superseded_by IS NULL`);
         const existing = db.prepare("SELECT count(*) as cnt FROM schema_version").get();
         if (existing && existing["cnt"] === 0) {
+            // Fresh install — all tables are created above with the full current schema,
+            // so it is safe to create all migration-specific indexes here.  For existing
+            // databases these indexes are created inside the individual migration guards
+            // in migrateSchema() after the corresponding columns have been added.
+            db.exec("CREATE INDEX IF NOT EXISTS idx_tasks_escalation_pending ON tasks(milestone_id, slice_id, escalation_pending)");
+            db.exec("CREATE INDEX IF NOT EXISTS idx_memories_scope ON memories(scope)");
+            db.exec("CREATE INDEX IF NOT EXISTS idx_memory_sources_kind ON memory_sources(kind)");
+            db.exec("CREATE INDEX IF NOT EXISTS idx_memory_sources_scope ON memory_sources(scope)");
+            db.exec("CREATE INDEX IF NOT EXISTS idx_memory_relations_from ON memory_relations(from_id)");
+            db.exec("CREATE INDEX IF NOT EXISTS idx_memory_relations_to ON memory_relations(to_id)");
             db.prepare("INSERT INTO schema_version (version, applied_at) VALUES (:version, :applied_at)").run({
                 ":version": SCHEMA_VERSION,
                 ":applied_at": new Date().toISOString(),
@@ -842,19 +845,24 @@ function migrateSchema(db) {
             });
         }
         if (currentVersion < 12) {
+            // NOTE: The original DDL used COALESCE(task_id, '') in the PRIMARY KEY
+            // expression, which is invalid SQLite syntax and causes startup errors on
+            // DBs that migrate through v12. The corrected DDL uses
+            // task_id TEXT NOT NULL DEFAULT '' with a plain column list PK. DBs that
+            // were created with the broken DDL are repaired by the v22 migration below.
             db.exec(`
         CREATE TABLE IF NOT EXISTS quality_gates (
           milestone_id TEXT NOT NULL,
           slice_id TEXT NOT NULL,
           gate_id TEXT NOT NULL,
           scope TEXT NOT NULL DEFAULT 'slice',
-          task_id TEXT DEFAULT NULL,
+          task_id TEXT NOT NULL DEFAULT '',
           status TEXT NOT NULL DEFAULT 'pending',
           verdict TEXT NOT NULL DEFAULT '',
           rationale TEXT NOT NULL DEFAULT '',
           findings TEXT NOT NULL DEFAULT '',
           evaluated_at TEXT DEFAULT NULL,
-          PRIMARY KEY (milestone_id, slice_id, gate_id, COALESCE(task_id, '')),
+          PRIMARY KEY (milestone_id, slice_id, gate_id, task_id),
           FOREIGN KEY (milestone_id, slice_id) REFERENCES slices(milestone_id, id)
         )
       `);
@@ -1006,6 +1014,10 @@ function migrateSchema(db) {
           tags TEXT NOT NULL DEFAULT '[]'
         )
       `);
+            // If memory_sources already existed before v18 (created by an earlier
+            // version of initSchema that lacked scope/tags), add the missing columns.
+            ensureColumn(db, "memory_sources", "scope", `ALTER TABLE memory_sources ADD COLUMN scope TEXT NOT NULL DEFAULT 'project'`);
+            ensureColumn(db, "memory_sources", "tags", `ALTER TABLE memory_sources ADD COLUMN tags TEXT NOT NULL DEFAULT '[]'`);
             db.exec("CREATE INDEX IF NOT EXISTS idx_memories_scope ON memories(scope)");
             db.exec("CREATE INDEX IF NOT EXISTS idx_memory_sources_kind ON memory_sources(kind)");
             db.exec("CREATE INDEX IF NOT EXISTS idx_memory_sources_scope ON memory_sources(scope)");
@@ -1059,6 +1071,65 @@ function migrateSchema(db) {
                 ":applied_at": new Date().toISOString(),
             });
         }
+        if (currentVersion < 21) {
+            // ADR-013 Step 2: preserve structured fields (gsd_save_decision's
+            // scope/decision/choice/rationale/made_by/revisable) on memories rows so
+            // the eventual decisions->memories cutover does not lose schema fidelity.
+            // Nullable JSON column — existing rows stay NULL until backfilled in Step 5.
+            // Use ensureColumn for race-safety (matches v15-v18 pattern; bare ALTER
+            // throws "duplicate column" on the loser of a concurrent open race even
+            // though the transaction wrapper protects the schema_version row).
+            ensureColumn(db, "memories", "structured_fields", "ALTER TABLE memories ADD COLUMN structured_fields TEXT DEFAULT NULL");
+            db.prepare("INSERT INTO schema_version (version, applied_at) VALUES (:version, :applied_at)").run({
+                ":version": 21,
+                ":applied_at": new Date().toISOString(),
+            });
+        }
+        if (currentVersion < 22) {
+            // v22: Repair quality_gates tables that were created by the broken v12
+            // migration (which used COALESCE(task_id, '') as a PK expression — invalid
+            // SQLite DDL). Those DBs have task_id nullable (dflt_value NULL, notnull 0).
+            // Rebuild the table with the correct schema, migrating existing rows via
+            // COALESCE so no data is lost.
+            const qgInfo = db.prepare("PRAGMA table_info(quality_gates)").all();
+            const taskIdCol = qgInfo.find((r) => r["name"] === "task_id");
+            const needsRepair = taskIdCol && (taskIdCol["notnull"] === 0 || taskIdCol["notnull"] === "0");
+            if (needsRepair) {
+                db.exec(`
+          CREATE TABLE quality_gates_new (
+            milestone_id TEXT NOT NULL,
+            slice_id TEXT NOT NULL,
+            gate_id TEXT NOT NULL,
+            scope TEXT NOT NULL DEFAULT 'slice',
+            task_id TEXT NOT NULL DEFAULT '',
+            status TEXT NOT NULL DEFAULT 'pending',
+            verdict TEXT NOT NULL DEFAULT '',
+            rationale TEXT NOT NULL DEFAULT '',
+            findings TEXT NOT NULL DEFAULT '',
+            evaluated_at TEXT DEFAULT NULL,
+            PRIMARY KEY (milestone_id, slice_id, gate_id, task_id),
+            FOREIGN KEY (milestone_id, slice_id) REFERENCES slices(milestone_id, id)
+          )
+        `);
+                db.exec(`
+          INSERT OR IGNORE INTO quality_gates_new
+            (milestone_id, slice_id, gate_id, scope, task_id, status, verdict, rationale, findings, evaluated_at)
+          SELECT milestone_id, slice_id, gate_id, scope, COALESCE(task_id, ''), status, verdict, rationale, findings, evaluated_at
+          FROM quality_gates
+        `);
+                db.exec("DROP TABLE quality_gates");
+                db.exec("ALTER TABLE quality_gates_new RENAME TO quality_gates");
+                db.exec("CREATE INDEX IF NOT EXISTS idx_quality_gates_pending ON quality_gates(milestone_id, slice_id, status)");
+            }
+            // Ensure scope column exists on quality_gates and assessments (guard
+            // against DBs that somehow lack it after a partial migration).
+            ensureColumn(db, "quality_gates", "scope", "ALTER TABLE quality_gates ADD COLUMN scope TEXT NOT NULL DEFAULT 'slice'");
+            ensureColumn(db, "assessments", "scope", "ALTER TABLE assessments ADD COLUMN scope TEXT NOT NULL DEFAULT ''");
+            db.prepare("INSERT INTO schema_version (version, applied_at) VALUES (:version, :applied_at)").run({
+                ":version": 22,
+                ":applied_at": new Date().toISOString(),
+            });
+        }
         db.exec("COMMIT");
     }
     catch (err) {
@@ -1071,6 +1142,8 @@ let currentPath = null;
 let currentPid = 0;
 let _exitHandlerRegistered = false;
 let _dbOpenAttempted = false;
+let _lastDbError = null;
+let _lastDbPhase = null;
 export function getDbProvider() {
     loadProvider();
     return providerName;
@@ -1087,13 +1160,54 @@ export function isDbAvailable() {
 export function wasDbOpenAttempted() {
     return _dbOpenAttempted;
 }
+export function getDbStatus() {
+    loadProvider();
+    return {
+        available: currentDb !== null,
+        provider: providerName,
+        attempted: _dbOpenAttempted,
+        lastError: _lastDbError,
+        lastPhase: _lastDbPhase,
+    };
+}
 export function openDatabase(path) {
     _dbOpenAttempted = true;
     if (currentDb && currentPath !== path)
         closeDatabase();
     if (currentDb && currentPath === path)
         return true;
-    const rawDb = openRawDb(path);
+    // Reset error state only when a new open attempt is actually going to run.
+    _lastDbError = null;
+    _lastDbPhase = null;
+    let rawDb;
+    let fallbackProvider = null;
+    let fallbackModule = null;
+    try {
+        rawDb = openRawDb(path);
+    }
+    catch (primaryErr) {
+        _lastDbPhase = "open";
+        _lastDbError = primaryErr instanceof Error ? primaryErr : new Error(String(primaryErr));
+        // node:sqlite loaded but failed to open this file — try better-sqlite3 as fallback.
+        if (providerName === "node:sqlite") {
+            try {
+                const mod = _require("better-sqlite3");
+                const Db = (mod && mod.default) ? mod.default : mod;
+                if (typeof Db === "function") {
+                    rawDb = new Db(path);
+                    fallbackProvider = "better-sqlite3";
+                    fallbackModule = Db;
+                    _lastDbError = null;
+                    _lastDbPhase = null;
+                }
+            }
+            catch {
+                // fallback unavailable; surface original error
+            }
+        }
+        if (!rawDb)
+            throw primaryErr;
+    }
     if (!rawDb)
         return false;
     const adapter = createAdapter(rawDb);
@@ -1111,6 +1225,8 @@ export function openDatabase(path) {
                 process.stderr.write("gsd-db: recovered corrupt database via VACUUM\n");
             }
             catch (retryErr) {
+                _lastDbPhase = "vacuum-recovery";
+                _lastDbError = retryErr instanceof Error ? retryErr : new Error(String(retryErr));
                 try {
                     adapter.close();
                 }
@@ -1121,15 +1237,22 @@ export function openDatabase(path) {
             }
         }
         else {
+            _lastDbPhase = "initSchema";
+            _lastDbError = err instanceof Error ? err : new Error(String(err));
             try {
                 adapter.close();
             }
             catch (e) {
-                logWarning("db", `close after VACUUM failed: ${e.message}`);
+                logWarning("db", `close after initSchema failed: ${e.message}`);
             }
             throw err;
         }
     }
+    // Commit fallback provider switch only after open + schema both succeeded.
+    if (fallbackProvider) {
+        providerName = fallbackProvider;
+        providerModule = fallbackModule;
+    }
     currentDb = adapter;
     currentPath = path;
     currentPid = process.pid;
@@ -1168,8 +1291,12 @@ export function closeDatabase() {
         currentDb = null;
         currentPath = null;
         currentPid = 0;
-        _dbOpenAttempted = false;
     }
+    // Reset session-scoped state unconditionally so stale error info from a
+    // failed open doesn't persist into the next open attempt or status check.
+    _dbOpenAttempted = false;
+    _lastDbError = null;
+    _lastDbPhase = null;
 }
 /** Run a full VACUUM — call sparingly (e.g. after milestone completion). */
 export function vacuumDatabase() {
@@ -2269,7 +2396,10 @@ export function reconcileWorktreeDb(mainDbPath, worktreeDbPath) {
           SELECT path, artifact_type, milestone_id, slice_id, task_id, full_content, imported_at
           FROM wt.artifacts
         `).run());
-                // Merge milestones — worktree may have updated status/planning fields
+                // Merge milestones — worktree may have updated status/planning fields.
+                // Never downgrade status: complete > active > pre-planning (#4372).
+                // A stale worktree may carry an older 'active' status for a milestone
+                // that the main DB has already marked 'complete'; preserve the higher status.
                 merged.milestones = countChanges(adapter.prepare(`
           INSERT OR REPLACE INTO milestones (
             id, title, status, depends_on, created_at, completed_at,
@@ -2277,11 +2407,25 @@ export function reconcileWorktreeDb(mainDbPath, worktreeDbPath) {
             verification_contract, verification_integration, verification_operational, verification_uat,
             definition_of_done, requirement_coverage, boundary_map_markdown
           )
-          SELECT id, title, status, depends_on, created_at, completed_at,
-                 vision, success_criteria, key_risks, proof_strategy,
-                 verification_contract, verification_integration, verification_operational, verification_uat,
-                 definition_of_done, requirement_coverage, boundary_map_markdown
-          FROM wt.milestones
+          SELECT w.id, w.title,
+                 CASE
+                   WHEN m.status IN ('complete', 'done') AND w.status NOT IN ('complete', 'done')
+                   THEN m.status ELSE w.status
+                 END,
+                 w.depends_on,
+                 CASE
+                   WHEN m.status IN ('complete', 'done') AND w.status NOT IN ('complete', 'done')
+                   THEN m.created_at ELSE w.created_at
+                 END,
+                 CASE
+                   WHEN m.status IN ('complete', 'done') AND w.status NOT IN ('complete', 'done')
+                   THEN m.completed_at ELSE w.completed_at
+                 END,
+                 w.vision, w.success_criteria, w.key_risks, w.proof_strategy,
+                 w.verification_contract, w.verification_integration, w.verification_operational, w.verification_uat,
+                 w.definition_of_done, w.requirement_coverage, w.boundary_map_markdown
+          FROM wt.milestones w
+          LEFT JOIN milestones m ON m.id = w.id
         `).run());
                 // Merge slices — preserve worktree progress but never downgrade completed status (#2558).
                 // ADR-011 Phase 1: carry is_sketch + sketch_scope so reconcile doesn't
@@ -2412,6 +2556,9 @@ export function insertReplanHistory(entry) {
 export function insertAssessment(entry) {
     if (!currentDb)
         throw new GSDError(GSD_STALE_STATE, "gsd-db: No database open");
+    // Idempotent: PRIMARY KEY is `path`, which is deterministic given (milestone_id, scope) per
+    // the artifact-path resolver. Retrying the same reassess-roadmap silently overwrites the row
+    // instead of accumulating duplicates.
     currentDb.prepare(`INSERT OR REPLACE INTO assessments (path, milestone_id, slice_id, task_id, status, scope, full_content, created_at)
      VALUES (:path, :milestone_id, :slice_id, :task_id, :status, :scope, :full_content, :created_at)`).run({
         ":path": entry.path,
@@ -2511,7 +2658,7 @@ function rowToGate(row) {
         scope: row["scope"],
         task_id: row["task_id"] ?? "",
         status: row["status"],
-        verdict: row["verdict"] || "",
+        verdict: row["status"] === "pending" ? null : row["verdict"],
         rationale: row["rationale"] || "",
         findings: row["findings"] || "",
         evaluated_at: row["evaluated_at"] ?? null,
@@ -2595,7 +2742,7 @@ export function getGateResults(milestoneId, sliceId, scope) {
 export function markAllGatesOmitted(milestoneId, sliceId) {
     if (!currentDb)
         return;
-    currentDb.prepare(`UPDATE quality_gates SET status = 'omitted', verdict = 'omitted', evaluated_at = :now
+    currentDb.prepare(`UPDATE quality_gates SET status = 'complete', verdict = 'omitted', evaluated_at = :now
      WHERE milestone_id = :mid AND slice_id = :sid AND status = 'pending'`).run({
         ":mid": milestoneId,
         ":sid": sliceId,
@@ -2948,8 +3095,8 @@ export function bulkInsertLegacyHierarchy(payload) {
 export function insertMemoryRow(args) {
     if (!currentDb)
         throw new GSDError(GSD_STALE_STATE, "gsd-db: No database open");
-    currentDb.prepare(`INSERT INTO memories (id, category, content, confidence, source_unit_type, source_unit_id, created_at, updated_at, scope, tags)
-     VALUES (:id, :category, :content, :confidence, :source_unit_type, :source_unit_id, :created_at, :updated_at, :scope, :tags)`).run({
+    currentDb.prepare(`INSERT INTO memories (id, category, content, confidence, source_unit_type, source_unit_id, created_at, updated_at, scope, tags, structured_fields)
+     VALUES (:id, :category, :content, :confidence, :source_unit_type, :source_unit_id, :created_at, :updated_at, :scope, :tags, :structured_fields)`).run({
         ":id": args.id,
         ":category": args.category,
         ":content": args.content,
@@ -2960,6 +3107,7 @@ export function insertMemoryRow(args) {
         ":updated_at": args.updatedAt,
         ":scope": args.scope ?? "project",
         ":tags": JSON.stringify(args.tags ?? []),
+        ":structured_fields": args.structuredFields == null ? null : JSON.stringify(args.structuredFields),
     });
 }
 export function insertMemorySourceRow(args) {

package/dist/resources/extensions/gsd/guided-flow-queue.js

@@ -13,6 +13,7 @@ import { deriveState } from "./state.js";
 import { invalidateAllCaches } from "./cache.js";
 import { gsdRoot, resolveMilestoneFile, resolveGsdRootFile, relGsdRootFile, } from "./paths.js";
 import { readFileSync, writeFileSync, existsSync } from "node:fs";
+import { atomicWriteSync } from "./atomic-write.js";
 import { nativeAddPaths, nativeCommit } from "./native-git-bridge.js";
 import { loadEffectiveGSDPreferences } from "./preferences.js";
 import { saveQueueOrder } from "./queue-order.js";
@@ -361,5 +362,7 @@ function syncProjectMdSequence(basePath, registry, newOrder) {
     const separatorLine = lines[tableStart + 1];
     const newTable = [headerLine, separatorLine, ...newRows];
     lines.splice(tableStart, tableEnd - tableStart, ...newTable);
-    writeFileSync(projectPath, lines.join("\n"), "utf-8");
+    // Atomic write: tmp+rename avoids a torn PROJECT.md appearing dirty in
+    // another worktree's working tree during a concurrent /gsd auto merge.
+    atomicWriteSync(projectPath, lines.join("\n"), "utf-8");
 }