gsd-pi 2.24.0 → 2.25.0

package/dist/resources/extensions/gsd/auto.ts

@@ -16,9 +16,9 @@ import type {
   ExtensionCommandContext,
 } from "@gsd/pi-coding-agent";
 
-import { deriveState, invalidateStateCache } from "./state.js";
+import { deriveState } from "./state.js";
 import type { BudgetEnforcementMode, GSDState } from "./types.js";
-import { loadFile, parseRoadmap, getManifestStatus, resolveAllOverrides } from "./files.js";
+import { loadFile, parseRoadmap, getManifestStatus, resolveAllOverrides, parseSummary } from "./files.js";
 import { loadPrompt } from "./prompt-loader.js";
 export { inlinePriorMilestoneSummary } from "./files.js";
 import { collectSecretsFromManifest } from "../get-secrets-from-user.js";
@@ -94,7 +94,7 @@ import {
   parseSliceBranch,
   setActiveMilestoneId,
 } from "./worktree.js";
-import { GitServiceImpl } from "./git-service.js";
+import { GitServiceImpl, type TaskCommitContext } from "./git-service.js";
 import { getPriorSliceCompletionBlocker } from "./dispatch-guard.js";
 import { formatGitError } from "./git-self-heal.js";
 import {
@@ -889,23 +889,37 @@ export async function startAuto(
       );
       return;
     }
-    // Stale lock from a dead process — synthesize crash recovery context.
-    const activityDir = join(gsdRoot(base), "activity");
-    const recovery = synthesizeCrashRecovery(
-      base, crashLock.unitType, crashLock.unitId,
-      crashLock.sessionFile, activityDir,
-    );
-    if (recovery && recovery.trace.toolCallCount > 0) {
-      pendingCrashRecovery = recovery.prompt;
+    // Stale lock from a dead process — validate before synthesizing recovery context.
+    // If the recovered unit belongs to a fully-completed milestone (SUMMARY exists),
+    // discard recovery context to prevent phantom skip loops (#790).
+    const recoveredMid = crashLock.unitId.split("/")[0];
+    const milestoneAlreadyComplete = recoveredMid
+      ? !!resolveMilestoneFile(base, recoveredMid, "SUMMARY")
+      : false;
+
+    if (milestoneAlreadyComplete) {
       ctx.ui.notify(
-        `${formatCrashInfo(crashLock)}\nRecovered ${recovery.trace.toolCallCount} tool calls from crashed session. Resuming with full context.`,
-        "warning",
+        `Crash recovery: discarding stale context for ${crashLock.unitId} — milestone ${recoveredMid} is already complete.`,
+        "info",
       );
     } else {
-      ctx.ui.notify(
-        `${formatCrashInfo(crashLock)}\nNo session data recovered. Resuming from disk state.`,
-        "warning",
+      const activityDir = join(gsdRoot(base), "activity");
+      const recovery = synthesizeCrashRecovery(
+        base, crashLock.unitType, crashLock.unitId,
+        crashLock.sessionFile, activityDir,
       );
+      if (recovery && recovery.trace.toolCallCount > 0) {
+        pendingCrashRecovery = recovery.prompt;
+        ctx.ui.notify(
+          `${formatCrashInfo(crashLock)}\nRecovered ${recovery.trace.toolCallCount} tool calls from crashed session. Resuming with full context.`,
+          "warning",
+        );
+      } else {
+        ctx.ui.notify(
+          `${formatCrashInfo(crashLock)}\nNo session data recovered. Resuming from disk state.`,
+          "warning",
+        );
+      }
     }
     clearLock(base);
   }
@@ -1314,12 +1328,41 @@ export async function handleAgentEnd(
   // Small delay to let files settle (git commits, file writes)
   await new Promise(r => setTimeout(r, 500));
 
-  // Auto-commit any dirty files the LLM left behind on the current branch.
+  // Commit any dirty files the LLM left behind on the current branch.
+  // For execute-task units, build a meaningful commit message from the
+  // task summary (one-liner, key_files, inferred type). For other unit
+  // types, fall back to the generic chore() message.
   if (currentUnit) {
     try {
-      const commitMsg = autoCommitCurrentBranch(basePath, currentUnit.type, currentUnit.id);
+      let taskContext: TaskCommitContext | undefined;
+
+      if (currentUnit.type === "execute-task") {
+        const parts = currentUnit.id.split("/");
+        const [mid, sid, tid] = parts;
+        if (mid && sid && tid) {
+          const summaryPath = resolveTaskFile(basePath, mid, sid, tid, "SUMMARY");
+          if (summaryPath) {
+            try {
+              const summaryContent = await loadFile(summaryPath);
+              if (summaryContent) {
+                const summary = parseSummary(summaryContent);
+                taskContext = {
+                  taskId: `${sid}/${tid}`,
+                  taskTitle: summary.title?.replace(/^T\d+:\s*/, "") || tid,
+                  oneLiner: summary.oneLiner || undefined,
+                  keyFiles: summary.frontmatter.key_files?.filter(f => !f.includes("{{")) || undefined,
+                };
+              }
+            } catch {
+              // Non-fatal — fall back to generic message
+            }
+          }
+        }
+      }
+
+      const commitMsg = autoCommitCurrentBranch(basePath, currentUnit.type, currentUnit.id, taskContext);
       if (commitMsg) {
-        ctx.ui.notify(`Auto-committed uncommitted changes.`, "info");
+        ctx.ui.notify(`Committed: ${commitMsg.split("\n")[0]}`, "info");
       }
     } catch {
       // Non-fatal
@@ -1372,7 +1415,8 @@ export async function handleAgentEnd(
     }
     try {
       await rebuildState(basePath);
-      autoCommitCurrentBranch(basePath, currentUnit.type, currentUnit.id);
+      // State rebuild commit is bookkeeping — generic message is appropriate
+      autoCommitCurrentBranch(basePath, "state-rebuild", currentUnit.id);
     } catch {
       // Non-fatal
     }
@@ -1465,7 +1509,7 @@ export async function handleAgentEnd(
             persistCompletedKey(basePath, completionKey);
             completedKeySet.add(completionKey);
           }
-          invalidateStateCache();
+          invalidateAllCaches();
         }
       } catch {
         // Non-fatal — worst case we fall through to normal dispatch which has its own checks
@@ -1504,7 +1548,16 @@ export async function handleAgentEnd(
       if (currentUnit) {
         const modelId = ctx.model?.id ?? "unknown";
         snapshotUnitMetrics(ctx, currentUnit.type, currentUnit.id, currentUnit.startedAt, modelId, { promptCharCount: lastPromptCharCount, baselineCharCount: lastBaselineCharCount, ...(currentUnitRouting ?? {}) });
-        saveActivityLog(ctx, basePath, currentUnit.type, currentUnit.id);
+        const hookActivityFile = saveActivityLog(ctx, basePath, currentUnit.type, currentUnit.id);
+        if (hookActivityFile) {
+          try {
+            const { buildMemoryLLMCall, extractMemoriesFromUnit } = await import('./memory-extractor.js');
+            const llmCallFn = buildMemoryLLMCall(ctx);
+            if (llmCallFn) {
+              extractMemoriesFromUnit(hookActivityFile, currentUnit.type, currentUnit.id, llmCallFn).catch(() => {});
+            }
+          } catch { /* non-fatal */ }
+        }
       }
       currentUnit = { type: hookUnit.unitType, id: hookUnit.unitId, startedAt: hookStartedAt };
       writeUnitRuntimeRecord(basePath, hookUnit.unitType, hookUnit.unitId, hookStartedAt, {
@@ -1646,7 +1699,16 @@ export async function handleAgentEnd(
             if (currentUnit) {
               const modelId = ctx.model?.id ?? "unknown";
               snapshotUnitMetrics(ctx, currentUnit.type, currentUnit.id, currentUnit.startedAt, modelId);
-              saveActivityLog(ctx, basePath, currentUnit.type, currentUnit.id);
+              const triageActivityFile = saveActivityLog(ctx, basePath, currentUnit.type, currentUnit.id);
+              if (triageActivityFile) {
+                try {
+                  const { buildMemoryLLMCall, extractMemoriesFromUnit } = await import('./memory-extractor.js');
+                  const llmCallFn = buildMemoryLLMCall(ctx);
+                  if (llmCallFn) {
+                    extractMemoriesFromUnit(triageActivityFile, currentUnit.type, currentUnit.id, llmCallFn).catch(() => {});
+                  }
+                } catch { /* non-fatal */ }
+              }
             }
 
             // Dispatch triage as a new unit (early-dispatch-and-return)
@@ -1724,7 +1786,16 @@ export async function handleAgentEnd(
       if (currentUnit) {
         const modelId = ctx.model?.id ?? "unknown";
         snapshotUnitMetrics(ctx, currentUnit.type, currentUnit.id, currentUnit.startedAt, modelId);
-        saveActivityLog(ctx, basePath, currentUnit.type, currentUnit.id);
+        const qtActivityFile = saveActivityLog(ctx, basePath, currentUnit.type, currentUnit.id);
+        if (qtActivityFile) {
+          try {
+            const { buildMemoryLLMCall, extractMemoriesFromUnit } = await import('./memory-extractor.js');
+            const llmCallFn = buildMemoryLLMCall(ctx);
+            if (llmCallFn) {
+              extractMemoriesFromUnit(qtActivityFile, currentUnit.type, currentUnit.id, llmCallFn).catch(() => {});
+            }
+          } catch { /* non-fatal */ }
+        }
       }
 
       // Dispatch quick-task as a new unit
@@ -2418,26 +2489,61 @@ async function dispatchNextUnit(
       const skipCount = (unitConsecutiveSkips.get(idempotencyKey) ?? 0) + 1;
       unitConsecutiveSkips.set(idempotencyKey, skipCount);
       if (skipCount > MAX_CONSECUTIVE_SKIPS) {
+        // Cross-check: verify deriveState actually returns this unit (#790).
+        // If the unit's milestone is already complete, this is a phantom skip
+        // loop from stale crash recovery context — don't evict.
+        const skippedMid = unitId.split("/")[0];
+        const skippedMilestoneComplete = skippedMid
+          ? !!resolveMilestoneFile(basePath, skippedMid, "SUMMARY")
+          : false;
+        if (skippedMilestoneComplete) {
+          // Milestone is complete — evicting this key would fight self-heal.
+          // Clear skip counter and re-dispatch from fresh state.
+          unitConsecutiveSkips.delete(idempotencyKey);
+          invalidateAllCaches();
+          ctx.ui.notify(
+            `Phantom skip loop cleared: ${unitType} ${unitId} belongs to completed milestone ${skippedMid}. Re-dispatching from fresh state.`,
+            "info",
+          );
+          _skipDepth++;
+          await new Promise(r => setTimeout(r, 50));
+          await dispatchNextUnit(ctx, pi);
+          _skipDepth = Math.max(0, _skipDepth - 1);
+          return;
+        }
         unitConsecutiveSkips.delete(idempotencyKey);
         completedKeySet.delete(idempotencyKey);
         removePersistedKey(basePath, idempotencyKey);
-        invalidateStateCache();
+        invalidateAllCaches();
         ctx.ui.notify(
           `Skip loop detected: ${unitType} ${unitId} skipped ${skipCount} times without advancing. Evicting completion record and forcing reconciliation.`,
           "warning",
         );
+        if (!active) return;
         _skipDepth++;
-        await new Promise(r => setTimeout(r, 50));
+        await new Promise(r => setTimeout(r, 150));
         await dispatchNextUnit(ctx, pi);
         _skipDepth = Math.max(0, _skipDepth - 1);
         return;
       }
+      // Count toward lifetime cap so hard-stop fires during skip loops (#792)
+      const lifeSkip = (unitLifetimeDispatches.get(idempotencyKey) ?? 0) + 1;
+      unitLifetimeDispatches.set(idempotencyKey, lifeSkip);
+      if (lifeSkip > MAX_LIFETIME_DISPATCHES) {
+        await stopAuto(ctx, pi, `Hard loop: ${unitType} ${unitId} (skip cycle)`);
+        ctx.ui.notify(
+          `Hard loop detected: ${unitType} ${unitId} hit lifetime cap during skip cycle (${lifeSkip} iterations).`,
+          "error",
+        );
+        return;
+      }
       ctx.ui.notify(
         `Skipping ${unitType} ${unitId} — already completed in a prior session. Advancing.`,
         "info",
       );
+      if (!active) return;
       _skipDepth++;
-      await new Promise(r => setTimeout(r, 50));
+      await new Promise(r => setTimeout(r, 150));
       await dispatchNextUnit(ctx, pi);
       _skipDepth = Math.max(0, _skipDepth - 1);
       return;
@@ -2460,31 +2566,62 @@ async function dispatchNextUnit(
   if (verifyExpectedArtifact(unitType, unitId, basePath)) {
     persistCompletedKey(basePath, idempotencyKey);
     completedKeySet.add(idempotencyKey);
-    invalidateStateCache();
+    invalidateAllCaches();
     // Same consecutive-skip guard as the idempotency path above.
     const skipCount2 = (unitConsecutiveSkips.get(idempotencyKey) ?? 0) + 1;
     unitConsecutiveSkips.set(idempotencyKey, skipCount2);
     if (skipCount2 > MAX_CONSECUTIVE_SKIPS) {
+      // Cross-check: verify the unit's milestone is still active (#790).
+      const skippedMid2 = unitId.split("/")[0];
+      const skippedMilestoneComplete2 = skippedMid2
+        ? !!resolveMilestoneFile(basePath, skippedMid2, "SUMMARY")
+        : false;
+      if (skippedMilestoneComplete2) {
+        unitConsecutiveSkips.delete(idempotencyKey);
+        invalidateAllCaches();
+        ctx.ui.notify(
+          `Phantom skip loop cleared: ${unitType} ${unitId} belongs to completed milestone ${skippedMid2}. Re-dispatching from fresh state.`,
+          "info",
+        );
+        _skipDepth++;
+        await new Promise(r => setTimeout(r, 50));
+        await dispatchNextUnit(ctx, pi);
+        _skipDepth = Math.max(0, _skipDepth - 1);
+        return;
+      }
       unitConsecutiveSkips.delete(idempotencyKey);
       completedKeySet.delete(idempotencyKey);
       removePersistedKey(basePath, idempotencyKey);
-      invalidateStateCache();
+      invalidateAllCaches();
       ctx.ui.notify(
         `Skip loop detected: ${unitType} ${unitId} skipped ${skipCount2} times without advancing. Evicting completion record and forcing reconciliation.`,
         "warning",
       );
+      if (!active) return;
       _skipDepth++;
-      await new Promise(r => setTimeout(r, 50));
+      await new Promise(r => setTimeout(r, 150));
       await dispatchNextUnit(ctx, pi);
       _skipDepth = Math.max(0, _skipDepth - 1);
       return;
     }
+    // Count toward lifetime cap so hard-stop fires during skip loops (#792)
+    const lifeSkip2 = (unitLifetimeDispatches.get(idempotencyKey) ?? 0) + 1;
+    unitLifetimeDispatches.set(idempotencyKey, lifeSkip2);
+    if (lifeSkip2 > MAX_LIFETIME_DISPATCHES) {
+      await stopAuto(ctx, pi, `Hard loop: ${unitType} ${unitId} (skip cycle)`);
+      ctx.ui.notify(
+        `Hard loop detected: ${unitType} ${unitId} hit lifetime cap during skip cycle (${lifeSkip2} iterations).`,
+        "error",
+      );
+      return;
+    }
     ctx.ui.notify(
       `Skipping ${unitType} ${unitId} — artifact exists but completion key was missing. Repaired and advancing.`,
       "info",
     );
+    if (!active) return;
     _skipDepth++;
-    await new Promise(r => setTimeout(r, 50));
+    await new Promise(r => setTimeout(r, 150));
     await dispatchNextUnit(ctx, pi);
     _skipDepth = Math.max(0, _skipDepth - 1);
     return;
@@ -2554,7 +2691,7 @@ async function dispatchNextUnit(
             persistCompletedKey(basePath, reconciledKey);
             completedKeySet.add(reconciledKey);
             unitDispatchCount.delete(dispatchKey);
-            invalidateStateCache();
+            invalidateAllCaches();
             await new Promise(r => setImmediate(r));
             await dispatchNextUnit(ctx, pi);
             return;
@@ -2581,7 +2718,7 @@ async function dispatchNextUnit(
       persistCompletedKey(basePath, dispatchKey);
       completedKeySet.add(dispatchKey);
       unitDispatchCount.delete(dispatchKey);
-      invalidateStateCache();
+      invalidateAllCaches();
       await new Promise(r => setImmediate(r));
       await dispatchNextUnit(ctx, pi);
       return;
@@ -2601,7 +2738,7 @@ async function dispatchNextUnit(
             persistCompletedKey(basePath, dispatchKey);
             completedKeySet.add(dispatchKey);
             unitDispatchCount.delete(dispatchKey);
-            invalidateStateCache();
+            invalidateAllCaches();
             await new Promise(r => setImmediate(r));
             await dispatchNextUnit(ctx, pi);
             return;
@@ -2642,7 +2779,7 @@ async function dispatchNextUnit(
             persistCompletedKey(basePath, repairedKey);
             completedKeySet.add(repairedKey);
             unitDispatchCount.delete(dispatchKey);
-            invalidateStateCache();
+            invalidateAllCaches();
             await new Promise(r => setImmediate(r));
             await dispatchNextUnit(ctx, pi);
             return;
@@ -2686,7 +2823,18 @@ async function dispatchNextUnit(
   if (currentUnit) {
     const modelId = ctx.model?.id ?? "unknown";
     snapshotUnitMetrics(ctx, currentUnit.type, currentUnit.id, currentUnit.startedAt, modelId, { promptCharCount: lastPromptCharCount, baselineCharCount: lastBaselineCharCount, ...(currentUnitRouting ?? {}) });
-    saveActivityLog(ctx, basePath, currentUnit.type, currentUnit.id);
+    const activityFile = saveActivityLog(ctx, basePath, currentUnit.type, currentUnit.id);
+
+    // Fire-and-forget memory extraction from completed unit
+    if (activityFile) {
+      try {
+        const { buildMemoryLLMCall, extractMemoriesFromUnit } = await import('./memory-extractor.js');
+        const llmCallFn = buildMemoryLLMCall(ctx);
+        if (llmCallFn) {
+          extractMemoriesFromUnit(activityFile, currentUnit.type, currentUnit.id, llmCallFn).catch(() => {});
+        }
+      } catch { /* non-fatal */ }
+    }
 
     // Record routing outcome for adaptive learning
     if (currentUnitRouting) {

package/dist/resources/extensions/gsd/cache.ts

@@ -12,16 +12,18 @@
 import { invalidateStateCache } from './state.js';
 import { clearPathCache } from './paths.js';
 import { clearParseCache } from './files.js';
+import { clearArtifacts } from './gsd-db.js';
 
 /**
  * Invalidate all GSD runtime caches in one call.
  *
  * Call this after file writes, milestone transitions, merge reconciliation,
  * or any operation that changes .gsd/ contents on disk. Forgetting to clear
- * any single cache causes stale reads (see #431).
+ * any single cache causes stale reads (see #431, #793).
  */
 export function invalidateAllCaches(): void {
   invalidateStateCache();
   clearPathCache();
   clearParseCache();
+  clearArtifacts();
 }

package/dist/resources/extensions/gsd/doctor.ts

@@ -4,6 +4,7 @@ import { join, sep } from "node:path";
 import { loadFile, parsePlan, parseRoadmap, parseSummary, saveFile, parseTaskPlanMustHaves, countMustHavesMentionedInSummary } from "./files.js";
 import { resolveMilestoneFile, resolveMilestonePath, resolveSliceFile, resolveSlicePath, resolveTaskFile, resolveTaskFiles, resolveTasksDir, milestonesDir, gsdRoot, relMilestoneFile, relSliceFile, relTaskFile, relSlicePath, relGsdRootFile, resolveGsdRootFile } from "./paths.js";
 import { deriveState, isMilestoneComplete } from "./state.js";
+import { invalidateAllCaches } from "./cache.js";
 import { loadEffectiveGSDPreferences, type GSDPreferences } from "./preferences.js";
 import { listWorktrees, resolveGitDir } from "./worktree-manager.js";
 import { abortAndReset } from "./git-self-heal.js";
@@ -200,6 +201,7 @@ async function updateStateFile(basePath: string, fixesApplied: string[]): Promis
 
 /** Rebuild STATE.md from current disk state. Exported for auto-mode post-hooks. */
 export async function rebuildState(basePath: string): Promise<void> {
+  invalidateAllCaches();
   const state = await deriveState(basePath);
   const path = resolveGsdRootFile(basePath, "STATE");
   await saveFile(path, buildStateMarkdown(state));

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

@@ -68,6 +68,50 @@ export interface CommitOptions {
   allowEmpty?: boolean;
 }
 
+// ─── Meaningful Commit Message Generation ───────────────────────────────────
+
+/** Context for generating a meaningful commit message from task execution results. */
+export interface TaskCommitContext {
+  taskId: string;
+  taskTitle: string;
+  /** The one-liner from the task summary (e.g. "Added retry-aware worker status logging") */
+  oneLiner?: string;
+  /** Files modified by this task (from task summary frontmatter) */
+  keyFiles?: string[];
+}
+
+/**
+ * Build a meaningful conventional commit message from task execution context.
+ * Format: `{type}({sliceId}/{taskId}): {description}`
+ *
+ * The description is the task summary one-liner if available (it describes
+ * what was actually built), falling back to the task title (what was planned).
+ */
+export function buildTaskCommitMessage(ctx: TaskCommitContext): string {
+  const scope = ctx.taskId; // e.g. "S01/T02" or just "T02"
+  const description = ctx.oneLiner || ctx.taskTitle;
+  const type = inferCommitType(ctx.taskTitle, ctx.oneLiner);
+
+  // Truncate description to ~72 chars for subject line
+  const maxDescLen = 68 - type.length - scope.length;
+  const truncated = description.length > maxDescLen
+    ? description.slice(0, maxDescLen - 1).trimEnd() + "…"
+    : description;
+
+  const subject = `${type}(${scope}): ${truncated}`;
+
+  // Build body with key files if available
+  if (ctx.keyFiles && ctx.keyFiles.length > 0) {
+    const fileLines = ctx.keyFiles
+      .slice(0, 8) // cap at 8 files to keep commit concise
+      .map(f => `- ${f}`)
+      .join("\n");
+    return `${subject}\n\n${fileLines}`;
+  }
+
+  return subject;
+}
+
 /**
  * Thrown when a slice merge hits code conflicts in non-.gsd files.
  * The working tree is left in a conflicted state (no reset) so the
@@ -253,18 +297,14 @@ export function runGit(basePath: string, args: string[], options: { allowFailure
  * Each entry: [keywords[], commitType]
  */
 const COMMIT_TYPE_RULES: [string[], string][] = [
-  [["fix", "bug", "patch", "hotfix"], "fix"],
+  [["fix", "fixed", "fixes", "bug", "patch", "hotfix", "repair", "correct"], "fix"],
   [["refactor", "restructure", "reorganize"], "refactor"],
-  [["doc", "docs", "documentation"], "docs"],
-  [["test", "tests", "testing"], "test"],
-  [["chore", "cleanup", "clean up", "archive", "remove", "delete"], "chore"],
+  [["doc", "docs", "documentation", "readme", "changelog"], "docs"],
+  [["test", "tests", "testing", "spec", "coverage"], "test"],
+  [["perf", "performance", "optimize", "speed", "cache"], "perf"],
+  [["chore", "cleanup", "clean up", "dependencies", "deps", "bump", "config", "ci", "archive", "remove", "delete"], "chore"],
 ];
 
-/**
- * Infer a conventional commit type from a slice title.
- * Uses case-insensitive word-boundary matching against known keywords.
- * Returns "feat" when no keywords match.
- */
 // ─── GitServiceImpl ────────────────────────────────────────────────────
 
 export class GitServiceImpl {
@@ -356,11 +396,22 @@ export class GitServiceImpl {
   }
 
   /**
-   * Auto-commit dirty working tree with a conventional chore message.
+   * Auto-commit dirty working tree.
+   *
+   * When `taskContext` is provided, generates a meaningful conventional commit
+   * message from the task execution results (one-liner, title, inferred type).
+   * Falls back to a generic `chore()` message when no context is available
+   * (e.g. pre-switch commits, stop commits, state rebuild commits).
+   *
    * Returns the commit message on success, or null if nothing to commit.
    * @param extraExclusions Additional paths to exclude from staging (e.g. [".gsd/"] for pre-switch commits).
    */
-  autoCommit(unitType: string, unitId: string, extraExclusions: readonly string[] = []): string | null {
+  autoCommit(
+    unitType: string,
+    unitId: string,
+    extraExclusions: readonly string[] = [],
+    taskContext?: TaskCommitContext,
+  ): string | null {
     // Quick check: is there anything dirty at all?
     // Native path uses libgit2 (single syscall), fallback spawns git.
     if (!nativeHasChanges(this.basePath)) return null;
@@ -371,7 +422,9 @@ export class GitServiceImpl {
     // (all changes might have been runtime files that got excluded)
     if (!nativeHasStagedChanges(this.basePath)) return null;
 
-    const message = `chore(${unitId}): auto-commit after ${unitType}`;
+    const message = taskContext
+      ? buildTaskCommitMessage(taskContext)
+      : `chore(${unitId}): auto-commit after ${unitType}`;
     nativeCommit(this.basePath, message, { allowEmpty: false });
     return message;
   }
@@ -497,8 +550,15 @@ export class GitServiceImpl {
 
 // ─── Commit Type Inference ─────────────────────────────────────────────────
 
-export function inferCommitType(sliceTitle: string): string {
-  const lower = sliceTitle.toLowerCase();
+/**
+ * Infer a conventional commit type from a title (and optional one-liner).
+ * Uses case-insensitive word-boundary matching against known keywords.
+ * Returns "feat" when no keywords match.
+ *
+ * Used for both slice squash-merge titles and task commit messages.
+ */
+export function inferCommitType(title: string, oneLiner?: string): string {
+  const lower = `${title} ${oneLiner || ""}`.toLowerCase();
 
   for (const [keywords, commitType] of COMMIT_TYPE_RULES) {
     for (const keyword of keywords) {

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

@@ -161,7 +161,7 @@ function openRawDb(path: string): unknown {
 
 // ─── Schema ────────────────────────────────────────────────────────────────
 
-const SCHEMA_VERSION = 2;
+const SCHEMA_VERSION = 3;
 
 function initSchema(db: DbAdapter, fileBacked: boolean): void {
   // WAL mode for file-backed databases (must be outside transaction)
@@ -221,9 +221,36 @@ function initSchema(db: DbAdapter, fileBacked: boolean): void {
       )
     `);
 
+    db.exec(`
+      CREATE TABLE IF NOT EXISTS memories (
+        seq INTEGER PRIMARY KEY AUTOINCREMENT,
+        id TEXT NOT NULL UNIQUE,
+        category TEXT NOT NULL,
+        content TEXT NOT NULL,
+        confidence REAL NOT NULL DEFAULT 0.8,
+        source_unit_type TEXT,
+        source_unit_id TEXT,
+        created_at TEXT NOT NULL,
+        updated_at TEXT NOT NULL,
+        superseded_by TEXT DEFAULT NULL,
+        hit_count INTEGER NOT NULL DEFAULT 0
+      )
+    `);
+
+    db.exec(`
+      CREATE TABLE IF NOT EXISTS memory_processed_units (
+        unit_key TEXT PRIMARY KEY,
+        activity_file TEXT,
+        processed_at TEXT NOT NULL
+      )
+    `);
+
+    db.exec('CREATE INDEX IF NOT EXISTS idx_memories_active ON memories(superseded_by)');
+
     // Views — DROP + CREATE since CREATE VIEW IF NOT EXISTS doesn't update definitions
     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`);
 
     // Insert schema version if not already present
     const existing = db.prepare('SELECT count(*) as cnt FROM schema_version').get();
@@ -274,6 +301,41 @@ function migrateSchema(db: DbAdapter): void {
       );
     }
 
+    // v2 → v3: add memories + memory_processed_units tables
+    if (currentVersion < 3) {
+      db.exec(`
+        CREATE TABLE IF NOT EXISTS memories (
+          seq INTEGER PRIMARY KEY AUTOINCREMENT,
+          id TEXT NOT NULL UNIQUE,
+          category TEXT NOT NULL,
+          content TEXT NOT NULL,
+          confidence REAL NOT NULL DEFAULT 0.8,
+          source_unit_type TEXT,
+          source_unit_id TEXT,
+          created_at TEXT NOT NULL,
+          updated_at TEXT NOT NULL,
+          superseded_by TEXT DEFAULT NULL,
+          hit_count INTEGER NOT NULL DEFAULT 0
+        )
+      `);
+
+      db.exec(`
+        CREATE TABLE IF NOT EXISTS memory_processed_units (
+          unit_key TEXT PRIMARY KEY,
+          activity_file TEXT,
+          processed_at TEXT NOT NULL
+        )
+      `);
+
+      db.exec('CREATE INDEX IF NOT EXISTS idx_memories_active ON memories(superseded_by)');
+      db.exec('DROP VIEW IF EXISTS active_memories');
+      db.exec('CREATE VIEW active_memories AS SELECT * FROM memories WHERE superseded_by IS NULL');
+
+      db.prepare('INSERT INTO schema_version (version, applied_at) VALUES (:version, :applied_at)').run(
+        { ':version': 3, ':applied_at': new Date().toISOString() },
+      );
+    }
+
     db.exec('COMMIT');
   } catch (err) {
     db.exec('ROLLBACK');
@@ -728,6 +790,21 @@ export function upsertRequirement(r: Requirement): void {
 /**
  * Insert or replace an artifact. Uses the `path` PK for idempotency.
  */
+/**
+ * Delete all rows from the artifacts table.
+ * The artifacts table is a read cache — clearing it forces the next
+ * deriveState() to fall through to disk reads (native Rust batch parse).
+ * Safe to call when no database is open (no-op).
+ */
+export function clearArtifacts(): void {
+  if (!currentDb) return;
+  try {
+    currentDb.exec('DELETE FROM artifacts');
+  } catch {
+    // Clearing a cache should never be fatal
+  }
+}
+
 export function insertArtifact(a: {
   path: string;
   artifact_type: string;