gsd-pi 2.80.0-dev.4ea7d80e7 → 2.80.0-dev.7582bf37a

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

@@ -21,7 +21,7 @@ import { estimateTimeRemaining } from "./auto-dashboard.js";
 import { computeProgressScore } from "./progress-score.js";
 import { runEnvironmentChecks } from "./doctor-environment.js";
 import { formattedShortcutPair } from "./shortcut-defs.js";
-function unitLabel(type) {
+export function unitLabel(type) {
     switch (type) {
         case "discuss-milestone":
         case "discuss-slice": return "Discuss";

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

@@ -26,6 +26,58 @@ function isAlreadyActiveConstraintError(err) {
     }
     return /\bUNIQUE\b|\bconstraint failed\b/i.test(msg);
 }
+function settleStaleActiveDispatchForUnit(input, now) {
+    const db = _getAdapter();
+    const active = db.prepare(`SELECT id, status, worker_id, milestone_lease_token
+     FROM unit_dispatches
+     WHERE unit_id = :unit_id
+       AND status IN ('claimed','running')
+     ORDER BY id DESC
+     LIMIT 1`).get({ ":unit_id": input.unitId });
+    if (!active)
+        return;
+    if (active.worker_id === input.workerId &&
+        active.milestone_lease_token === input.milestoneLeaseToken) {
+        return;
+    }
+    const reason = "stale-dispatch-lease-takeover";
+    const result = db.prepare(`UPDATE unit_dispatches
+     SET status = 'canceled',
+         ended_at = :ended_at,
+         exit_reason = :reason
+     WHERE id = :id
+       AND status IN ('claimed','running')
+       AND (worker_id != :worker_id OR milestone_lease_token != :token)`).run({
+        ":id": active.id,
+        ":ended_at": now,
+        ":reason": reason,
+        ":worker_id": input.workerId,
+        ":token": input.milestoneLeaseToken,
+    });
+    const changes = typeof result.changes === "number"
+        ? result.changes
+        : 0;
+    if (changes < 1)
+        return;
+    insertAuditEvent({
+        eventId: randomUUID(),
+        traceId: input.traceId,
+        turnId: input.turnId ?? undefined,
+        category: "orchestration",
+        type: "dispatch-stale-canceled",
+        ts: now,
+        payload: {
+            dispatchId: active.id,
+            unitId: input.unitId,
+            priorStatus: active.status,
+            priorWorkerId: active.worker_id,
+            priorMilestoneLeaseToken: active.milestone_lease_token,
+            takeoverWorkerId: input.workerId,
+            takeoverMilestoneLeaseToken: input.milestoneLeaseToken,
+            reason,
+        },
+    });
+}
 /**
  * Insert a new dispatch row in `claimed` state. Atomic guard against
  * double-claim (B2): the partial unique index
@@ -58,6 +110,7 @@ export function recordDispatchClaim(input) {
                 milestoneLeaseToken: input.milestoneLeaseToken,
             };
         }
+        settleStaleActiveDispatchForUnit(input, now);
         try {
             const result = db.prepare(`INSERT INTO unit_dispatches (
           trace_id, turn_id, worker_id, milestone_lease_token,
@@ -253,6 +306,45 @@ export function markCanceled(dispatchId, reason) {
      SET status = 'canceled', ended_at = :ended_at, exit_reason = :reason
      WHERE id = :id AND status IN ('pending','claimed','running')`).run({ ":id": dispatchId, ":ended_at": now, ":reason": reason });
 }
+/**
+ * Best-effort signal/crash cleanup: cancel the latest active dispatch owned by
+ * a worker when the process is exiting before the normal loop can settle it.
+ */
+export function markLatestActiveForWorkerCanceled(workerId, reason) {
+    if (!isDbAvailable())
+        return false;
+    const now = new Date().toISOString();
+    const db = _getAdapter();
+    const result = transaction(() => {
+        return db.prepare(`UPDATE unit_dispatches
+       SET status = 'canceled', ended_at = :ended_at, exit_reason = :reason
+       WHERE id = (
+         SELECT id FROM unit_dispatches
+         WHERE worker_id = :worker_id
+           AND status IN ('pending','claimed','running')
+         ORDER BY id DESC
+         LIMIT 1
+       )`).run({
+            ":ended_at": now,
+            ":reason": reason,
+            ":worker_id": workerId,
+        });
+    });
+    const changes = typeof result.changes === "number"
+        ? result.changes
+        : 0;
+    if (changes <= 0)
+        return false;
+    insertAuditEvent({
+        eventId: randomUUID(),
+        traceId: workerId,
+        category: "orchestration",
+        type: "dispatch-canceled",
+        ts: now,
+        payload: { workerId, reason },
+    });
+    return true;
+}
 /**
  * Fetch the most recent N dispatches for a unit. Used by recordDispatchClaim
  * callers to compute attempt_n and by detect-stuck.ts (B3) to consult

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

@@ -46,7 +46,8 @@ export function createBaseSchemaObjects(db, hooks) {
       slice_id TEXT DEFAULT NULL,
       task_id TEXT DEFAULT NULL,
       full_content TEXT NOT NULL DEFAULT '',
-      imported_at TEXT NOT NULL DEFAULT ''
+      imported_at TEXT NOT NULL DEFAULT '',
+      content_hash TEXT DEFAULT NULL
     )
   `);
     db.exec(`
@@ -64,7 +65,8 @@ export function createBaseSchemaObjects(db, hooks) {
       hit_count INTEGER NOT NULL DEFAULT 0,
       scope TEXT NOT NULL DEFAULT 'project',
       tags TEXT NOT NULL DEFAULT '[]',
-      structured_fields TEXT DEFAULT NULL
+      structured_fields TEXT DEFAULT NULL,
+      last_hit_at TEXT DEFAULT NULL
     )
   `);
     db.exec(`

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

@@ -379,6 +379,12 @@ export function applyMigrationV26MilestoneCommitAttributions(db) {
   `);
     db.exec("CREATE INDEX IF NOT EXISTS idx_milestone_commit_attr_milestone ON milestone_commit_attributions(milestone_id)");
 }
+export function applyMigrationV27ArtifactHash(db) {
+    ensureColumn(db, "artifacts", "content_hash", "ALTER TABLE artifacts ADD COLUMN content_hash TEXT DEFAULT NULL");
+}
+export function applyMigrationV28MemoryLastHitAt(db) {
+    ensureColumn(db, "memories", "last_hit_at", "ALTER TABLE memories ADD COLUMN last_hit_at TEXT DEFAULT NULL");
+}
 export function applyMigrationV22QualityGateRepair(db, hooks) {
     const qgInfo = db.prepare("PRAGMA table_info(quality_gates)").all();
     const taskIdCol = qgInfo.find((r) => r["name"] === "task_id");

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

@@ -5,6 +5,7 @@
  * Used by init-wizard.ts and guided-flow.ts to determine what onboarding
  * flow to show when entering a project directory.
  */
+import { execFileSync } from "node:child_process";
 import { existsSync, openSync, readSync, closeSync, readdirSync, readFileSync, statSync } from "node:fs";
 import { dirname, join, parse as parsePath } from "node:path";
 import { homedir } from "node:os";
@@ -171,6 +172,7 @@ const TEST_MARKERS = [
 const RECURSIVE_SCAN_IGNORED_DIRS = new Set([
     ".git",
     ".gsd",
+    ".bg-shell",
     ".planning",
     ".plans",
     ".claude",
@@ -194,6 +196,7 @@ const RECURSIVE_SCAN_IGNORED_DIRS = new Set([
     "DerivedData",
     "out",
 ]);
+const PROJECT_CONTENT_EXCLUDE_DIRS = RECURSIVE_SCAN_IGNORED_DIRS;
 /** Project file markers safe to detect recursively via suffix matching. */
 const ROOT_ONLY_PROJECT_FILES = new Set([
     ".github/workflows",
@@ -429,6 +432,109 @@ export function detectProjectSignals(basePath) {
         verificationCommands,
     };
 }
+function normalizeGitPath(file) {
+    return file.replaceAll("\\", "/").replace(/^\.\//, "");
+}
+function isProjectContentFile(file) {
+    const normalized = normalizeGitPath(file);
+    if (!normalized || normalized.endsWith("/"))
+        return false;
+    if (normalized === ".gitignore" || normalized === ".gitattributes")
+        return false;
+    const parts = normalized.split("/");
+    if (parts.some((part) => PROJECT_CONTENT_EXCLUDE_DIRS.has(part)))
+        return false;
+    if (normalized.endsWith(".DS_Store"))
+        return false;
+    return true;
+}
+function runGitLines(basePath, args) {
+    try {
+        const output = execFileSync("git", args, {
+            cwd: basePath,
+            stdio: ["ignore", "pipe", "ignore"],
+            encoding: "utf-8",
+        }).trim();
+        return output ? output.split("\n").map((line) => line.trim()).filter(Boolean) : [];
+    }
+    catch {
+        return [];
+    }
+}
+function listTrackedProjectFiles(basePath) {
+    return runGitLines(basePath, ["ls-files"])
+        .map(normalizeGitPath)
+        .filter(isProjectContentFile);
+}
+function listUntrackedProjectFiles(basePath) {
+    return runGitLines(basePath, ["ls-files", "--others", "--exclude-standard"])
+        .map(normalizeGitPath)
+        .filter(isProjectContentFile);
+}
+function hasKnownProjectMarkers(basePath, signals) {
+    if (signals.detectedFiles.length > 0)
+        return true;
+    if (signals.xcodePlatforms.length > 0)
+        return true;
+    return false;
+}
+/**
+ * Classify repo presence separately from ecosystem/tooling markers.
+ *
+ * Known project files identify tooling. Git-tracked/non-ignored content
+ * identifies whether this is an existing project at all. This keeps small
+ * static or documentation repos from being mislabeled as greenfield.
+ */
+export function classifyProject(basePath) {
+    const signals = detectProjectSignals(basePath);
+    const markers = [...signals.detectedFiles];
+    if (!signals.isGitRepo) {
+        return {
+            kind: "invalid-repo",
+            signals,
+            trackedFiles: [],
+            untrackedFiles: [],
+            contentFiles: [],
+            markers,
+            reason: "missing .git",
+        };
+    }
+    const trackedFiles = listTrackedProjectFiles(basePath);
+    const untrackedFiles = listUntrackedProjectFiles(basePath);
+    const contentFiles = [...new Set([...trackedFiles, ...untrackedFiles])];
+    const hasMarkers = hasKnownProjectMarkers(basePath, signals);
+    if (hasMarkers) {
+        return {
+            kind: "typed-existing",
+            signals,
+            trackedFiles,
+            untrackedFiles,
+            contentFiles,
+            markers,
+            reason: markers.length > 0 ? `detected markers: ${markers.join(", ")}` : "detected project structure",
+        };
+    }
+    if (contentFiles.length > 0) {
+        return {
+            kind: "untyped-existing",
+            signals,
+            trackedFiles,
+            untrackedFiles,
+            contentFiles,
+            markers,
+            reason: "project content exists but no recognized tooling markers were found",
+        };
+    }
+    return {
+        kind: "greenfield",
+        signals,
+        trackedFiles,
+        untrackedFiles,
+        contentFiles,
+        markers,
+        reason: "no tracked or non-ignored project content",
+    };
+}
 // ─── Xcode Platform Detection ───────────────────────────────────────────────────
 /** Known SDKROOT values → canonical platform names. */
 const SDKROOT_MAP = {

package/dist/resources/extensions/gsd/ecosystem/gsd-extension-api.js

@@ -127,6 +127,8 @@ export function createGSDExtensionAPI(pi, sharedHandlers) {
         getActiveTools: () => pi.getActiveTools(),
         getAllTools: () => pi.getAllTools(),
         setActiveTools: (...args) => pi.setActiveTools(...args),
+        getVisibleSkills: () => pi.getVisibleSkills(),
+        setVisibleSkills: (...args) => pi.setVisibleSkills(...args),
         getCommands: () => pi.getCommands(),
         // ── Model & thinking ───────────────────────────────────────────────
         setModel: (...args) => pi.setModel(...args),

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

@@ -1,3 +1,5 @@
+// Project/App: GSD-2
+// File Purpose: Git operations, commit-message formatting, and turn git actions.
 /**
  * GSD Git Service
  *
@@ -13,6 +15,7 @@ import { isAbsolute, join, normalize, relative, resolve, sep } from "node:path";
 import { gsdRoot } from "./paths.js";
 import { GIT_NO_PROMPT_ENV } from "./git-constants.js";
 import { loadEffectiveGSDPreferences } from "./preferences.js";
+import { logWarning } from "./workflow-logger.js";
 import { detectWorktreeName, } from "./worktree.js";
 import { SLICE_BRANCH_RE, QUICK_BRANCH_RE, WORKFLOW_BRANCH_RE } from "./branch-patterns.js";
 import { nativeGetCurrentBranch, nativeDetectMainBranch, nativeBranchExists, nativeHasChanges, nativeAddAllWithExclusions, nativeHasStagedChanges, nativeCommit, nativeRmCached, nativeUpdateRef, nativeAddPaths, nativeResetSoft, nativeCommitSubject, _resetHasChangesCache, } from "./native-git-bridge.js";
@@ -48,6 +51,10 @@ export function buildTaskCommitMessage(ctx) {
             .join("\n");
         bodyParts.push(fileLines);
     }
+    const contextLines = buildTaskCommitContextLines(ctx);
+    if (contextLines.length > 0) {
+        bodyParts.push(`GSD context:\n${contextLines.join("\n")}`);
+    }
     // Trailers: GSD-Task first, then Resolves
     bodyParts.push(`GSD-Task: ${ctx.taskId}`);
     if (ctx.issueNumber) {
@@ -55,6 +62,31 @@ export function buildTaskCommitMessage(ctx) {
     }
     return `${subject}\n\n${bodyParts.join("\n\n")}`;
 }
+function buildTaskCommitContextLines(ctx) {
+    const lines = [];
+    const milestone = formatNamedContext(ctx.milestoneId, ctx.milestoneTitle);
+    const slice = formatNamedContext(ctx.sliceId, ctx.sliceTitle);
+    const taskId = ctx.taskDisplayId ?? ctx.taskId.split("/").pop();
+    const task = formatNamedContext(taskId, ctx.taskTitle);
+    if (milestone)
+        lines.push(`- Milestone: ${milestone}`);
+    if (slice)
+        lines.push(`- Slice: ${slice}`);
+    if (task)
+        lines.push(`- Task: ${task}`);
+    return lines;
+}
+function formatNamedContext(id, title) {
+    const cleanId = id?.trim();
+    const cleanTitle = title?.trim();
+    if (!cleanId && !cleanTitle)
+        return null;
+    if (!cleanId)
+        return cleanTitle ?? null;
+    if (!cleanTitle || cleanTitle === cleanId)
+        return cleanId;
+    return `${cleanId} - ${cleanTitle}`;
+}
 function sanitizeCommitSubjectDescription(value) {
     const cleaned = value
         .replace(/[\x00-\x1F\x7F]+/g, " ")
@@ -535,14 +567,45 @@ export class GitServiceImpl {
         if (keyFiles.length === 0)
             return false;
         const allExclusions = [...RUNTIME_EXCLUSION_PATHS, ...extraExclusions];
-        const paths = Array.from(new Set(keyFiles
+        const normalized = keyFiles
             .map(file => normalizeRepoRelativePath(this.basePath, file))
             .filter((file) => file !== null)
-            .filter(file => !isExcludedScopedPath(file, allExclusions))));
+            .filter(file => !isExcludedScopedPath(file, allExclusions));
+        // Drop entries that don't exist on disk. The LLM occasionally lists files
+        // it intended to write but didn't (or names them with wrong casing/path).
+        // Pre-`b304f738b` `git add -A` swallowed these silently; the scoped
+        // pathspec form passes each path explicitly, so a single bad entry made
+        // the whole commit fail (see #5500). Filter so valid paths still commit.
+        const missing = [];
+        const existing = [];
+        for (const path of normalized) {
+            if (existsSync(join(this.basePath, path))) {
+                existing.push(path);
+            }
+            else {
+                missing.push(path);
+            }
+        }
+        if (missing.length > 0) {
+            logWarning("engine", `scoped stage: dropping ${missing.length} non-existent keyFile(s) from task commit: ${missing.join(", ")}`, { file: "git-service.ts" });
+        }
+        const paths = Array.from(new Set(existing));
         if (paths.length === 0)
             return false;
-        nativeAddPaths(this.basePath, paths);
-        return true;
+        try {
+            nativeAddPaths(this.basePath, paths);
+            return true;
+        }
+        catch (err) {
+            // Defense-in-depth: even after existence filtering, libgit2/git can
+            // still reject paths (gitignore matches, case-only differences on
+            // case-insensitive FS, submodule boundaries). Returning false lets
+            // autoCommit fall through to smartStage so the commit still goes out
+            // — restoring the resilience the unscoped path used to provide.
+            const msg = err instanceof Error ? err.message : String(err);
+            logWarning("engine", `scoped stage failed (${msg}); falling back to smartStage`, { file: "git-service.ts" });
+            return false;
+        }
     }
     /** Tracks whether runtime file cleanup has run this session. */
     _runtimeFilesCleanedUp = false;
@@ -823,7 +886,12 @@ export function createDraftPR(basePath, milestoneId, title, body, opts) {
             args.push("--head", opts.head);
         if (opts?.base)
             args.push("--base", opts.base);
-        const result = execFileSync("gh", args, { cwd: basePath, encoding: "utf8", timeout: 30000, env: GIT_NO_PROMPT_ENV });
+        const result = execFileSync("gh", args, {
+            cwd: basePath,
+            encoding: "utf8",
+            timeout: 30000,
+            env: opts?.env ?? GIT_NO_PROMPT_ENV,
+        });
         return result.trim();
     }
     catch {

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

@@ -22,6 +22,7 @@
 // intentionally independent store for cross-worktree claim races and is
 // excluded from this invariant.
 import { createRequire } from "node:module";
+import { createHash } from "node:crypto";
 import { existsSync, copyFileSync, mkdirSync, realpathSync } from "node:fs";
 import { dirname } from "node:path";
 import { GSDError, GSD_STALE_STATE } from "./errors.js";
@@ -36,7 +37,7 @@ import { rowToActiveDecision, rowToActiveRequirement, rowToDecision, rowToRequir
 import { rowToGate } from "./db-gate-rows.js";
 import { rowToArtifact, rowToMilestone } from "./db-milestone-artifact-rows.js";
 import { backupDatabaseBeforeMigration } 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, } from "./db-migration-steps.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, } from "./db-migration-steps.js";
 import { isMemoriesFtsAvailableSchema, tryCreateMemoriesFtsSchema } from "./db-memory-fts-schema.js";
 import { createDbOpenState } from "./db-open-state.js";
 import { createRuntimeKvTableV25 } from "./db-runtime-kv-schema.js";
@@ -52,7 +53,7 @@ const providerLoader = createSqliteProviderLoader({
     nodeVersion: process.versions.node,
     writeStderr: (message) => process.stderr.write(message),
 });
-export const SCHEMA_VERSION = 26;
+export const SCHEMA_VERSION = 28;
 function initSchema(db, fileBacked) {
     if (fileBacked)
         db.exec("PRAGMA journal_mode=WAL");
@@ -250,6 +251,14 @@ function migrateSchema(db) {
             applyMigrationV26MilestoneCommitAttributions(db);
             recordSchemaVersion(db, 26);
         }
+        if (currentVersion < 27) {
+            applyMigrationV27ArtifactHash(db);
+            recordSchemaVersion(db, 27);
+        }
+        if (currentVersion < 28) {
+            applyMigrationV28MemoryLastHitAt(db);
+            recordSchemaVersion(db, 28);
+        }
         db.exec("COMMIT");
     }
     catch (err) {
@@ -821,8 +830,9 @@ export function clearArtifacts() {
 export function insertArtifact(a) {
     if (!currentDb)
         throw new GSDError(GSD_STALE_STATE, "gsd-db: No database open");
-    currentDb.prepare(`INSERT OR REPLACE INTO artifacts (path, artifact_type, milestone_id, slice_id, task_id, full_content, imported_at)
-     VALUES (:path, :artifact_type, :milestone_id, :slice_id, :task_id, :full_content, :imported_at)`).run({
+    const contentHash = createHash("sha256").update(a.full_content).digest("hex");
+    currentDb.prepare(`INSERT OR REPLACE INTO artifacts (path, artifact_type, milestone_id, slice_id, task_id, full_content, imported_at, content_hash)
+     VALUES (:path, :artifact_type, :milestone_id, :slice_id, :task_id, :full_content, :imported_at, :content_hash)`).run({
         ":path": a.path,
         ":artifact_type": a.artifact_type,
         ":milestone_id": a.milestone_id,
@@ -830,6 +840,7 @@ export function insertArtifact(a) {
         ":task_id": a.task_id,
         ":full_content": a.full_content,
         ":imported_at": new Date().toISOString(),
+        ":content_hash": contentHash,
     });
 }
 export function insertMilestone(m) {
@@ -1521,6 +1532,13 @@ export function reconcileWorktreeDb(mainDbPath, worktreeDbPath) {
             const hasEscalationAwaiting = wtTaskInfo.some((col) => col["name"] === "escalation_awaiting_review");
             const hasEscalationArtifact = wtTaskInfo.some((col) => col["name"] === "escalation_artifact_path");
             const hasEscalationOverride = wtTaskInfo.some((col) => col["name"] === "escalation_override_applied_at");
+            const wtArtifactInfo = adapter.prepare("PRAGMA wt.table_info('artifacts')").all();
+            const hasArtifactContentHash = wtArtifactInfo.some((col) => col["name"] === "content_hash");
+            const wtMemoryInfo = adapter.prepare("PRAGMA wt.table_info('memories')").all();
+            const hasMemoryScope = wtMemoryInfo.some((col) => col["name"] === "scope");
+            const hasMemoryTags = wtMemoryInfo.some((col) => col["name"] === "tags");
+            const hasMemoryStructuredFields = wtMemoryInfo.some((col) => col["name"] === "structured_fields");
+            const hasMemoryLastHitAt = wtMemoryInfo.some((col) => col["name"] === "last_hit_at");
             const decConf = adapter.prepare(`SELECT m.id FROM decisions m INNER JOIN wt.decisions w ON m.id = w.id WHERE m.decision != w.decision OR m.choice != w.choice OR m.rationale != w.rationale OR ${hasMadeBy ? "m.made_by != w.made_by" : "'agent' != 'agent'"} OR m.superseded_by IS NOT w.superseded_by`).all();
             for (const row of decConf)
                 conflicts.push(`decision ${row["id"]}: modified in both`);
@@ -1553,12 +1571,17 @@ export function reconcileWorktreeDb(mainDbPath, worktreeDbPath) {
                  supporting_slices, validation, notes, full_content, superseded_by
           FROM wt.requirements
         `).run());
+                // V27: preserve content_hash. If the worktree predates V27 (no column),
+                // fall back to the main DB's existing hash so reconcile doesn't null
+                // out integrity fingerprints on artifacts that were unchanged in wt.
                 merged.artifacts = countChanges(adapter.prepare(`
           INSERT OR REPLACE INTO artifacts (
-            path, artifact_type, milestone_id, slice_id, task_id, full_content, imported_at
+            path, artifact_type, milestone_id, slice_id, task_id, full_content, imported_at, content_hash
           )
-          SELECT path, artifact_type, milestone_id, slice_id, task_id, full_content, imported_at
-          FROM wt.artifacts
+          SELECT w.path, w.artifact_type, w.milestone_id, w.slice_id, w.task_id, w.full_content, w.imported_at,
+                 ${hasArtifactContentHash ? "w.content_hash" : "m.content_hash"}
+          FROM wt.artifacts w
+          LEFT JOIN artifacts m ON m.path = w.path
         `).run());
                 // Merge milestones — worktree may have updated status/planning fields.
                 // Never downgrade status: complete > active > pre-planning (#4372).
@@ -1656,15 +1679,25 @@ export function reconcileWorktreeDb(mainDbPath, worktreeDbPath) {
           FROM wt.tasks w
           LEFT JOIN tasks m ON m.milestone_id = w.milestone_id AND m.slice_id = w.slice_id AND m.id = w.id
         `).run());
-                // Merge memories — keep worktree-learned insights
+                // Merge memories — keep worktree-learned insights.
+                // V18 (scope, tags), V21 (structured_fields), V28 (last_hit_at): for each
+                // column the wt may not yet have (older worktree DB), fall back to the
+                // main DB's existing value via LEFT JOIN so reconcile never silently
+                // resets these fields to defaults on rows that already had them.
                 merged.memories = countChanges(adapter.prepare(`
           INSERT OR REPLACE INTO memories (
             seq, id, category, content, confidence, source_unit_type, source_unit_id,
-            created_at, updated_at, superseded_by, hit_count
+            created_at, updated_at, superseded_by, hit_count,
+            scope, tags, structured_fields, last_hit_at
           )
-          SELECT seq, id, category, content, confidence, source_unit_type, source_unit_id,
-                 created_at, updated_at, superseded_by, hit_count
-          FROM wt.memories
+          SELECT w.seq, w.id, w.category, w.content, w.confidence, w.source_unit_type, w.source_unit_id,
+                 w.created_at, w.updated_at, w.superseded_by, w.hit_count,
+                 ${hasMemoryScope ? "w.scope" : "COALESCE(m.scope, 'project')"},
+                 ${hasMemoryTags ? "w.tags" : "COALESCE(m.tags, '[]')"},
+                 ${hasMemoryStructuredFields ? "w.structured_fields" : "m.structured_fields"},
+                 ${hasMemoryLastHitAt ? "w.last_hit_at" : "m.last_hit_at"}
+          FROM wt.memories w
+          LEFT JOIN memories m ON m.id = w.id
         `).run());
                 // Merge verification evidence — append-only, use INSERT OR IGNORE to avoid duplicates
                 merged.verification_evidence = countChanges(adapter.prepare(`
@@ -2423,7 +2456,7 @@ export function updateMemoryContentRow(id, content, confidence, updatedAt) {
 export function incrementMemoryHitCount(id, updatedAt) {
     if (!currentDb)
         throw new GSDError(GSD_STALE_STATE, "gsd-db: No database open");
-    currentDb.prepare("UPDATE memories SET hit_count = hit_count + 1, updated_at = :updated_at WHERE id = :id").run({ ":updated_at": updatedAt, ":id": id });
+    currentDb.prepare("UPDATE memories SET hit_count = hit_count + 1, updated_at = :updated_at, last_hit_at = :last_hit_at WHERE id = :id").run({ ":updated_at": updatedAt, ":last_hit_at": updatedAt, ":id": id });
 }
 export function supersedeMemoryRow(oldId, newId, updatedAt) {
     if (!currentDb)