@tonycasey/lisa 2.25.4 → 2.26.0

package/dist/opencode/lisa.js

@@ -2379,6 +2379,27 @@ var init_ITranscriptEnricher = __esm({
   }
 });
 
+// src/lib/domain/interfaces/ICommitEnricher.ts
+function isValidCommitFactType(value) {
+  return COMMIT_FACT_TYPE_VALUES.includes(value);
+}
+var COMMIT_FACT_TYPE_VALUES;
+var init_ICommitEnricher = __esm({
+  "src/lib/domain/interfaces/ICommitEnricher.ts"() {
+    "use strict";
+    COMMIT_FACT_TYPE_VALUES = [
+      "feature",
+      "decision",
+      "refactor",
+      "migration",
+      "bugfix",
+      "breaking-change",
+      "convention",
+      "dependency"
+    ];
+  }
+});
+
 // src/lib/domain/interfaces/INlCurationService.ts
 function isValidNlCurationIntent(value) {
   return NL_CURATION_INTENT_VALUES.includes(value);
@@ -2693,6 +2714,7 @@ var init_interfaces = __esm({
     init_ILlmService();
     init_ILlmUsageTracker();
     init_ITranscriptEnricher();
+    init_ICommitEnricher();
     init_INlCurationService();
     init_events();
     init_types2();
@@ -6903,13 +6925,14 @@ var init_clients = __esm({
 });
 
 // src/lib/application/services/SessionContextFormatter.ts
-var RECENT_HOURS, MAX_RECENT_MEMORIES, GROUP_WINDOW_MINUTES, EXCLUDED_RELATIONSHIPS, SessionContextFormatter;
+var RECENT_HOURS, MAX_RECENT_MEMORIES, GROUP_WINDOW_MINUTES, MAX_HOTSPOTS, EXCLUDED_RELATIONSHIPS, SessionContextFormatter;
 var init_SessionContextFormatter = __esm({
   "src/lib/application/services/SessionContextFormatter.ts"() {
     "use strict";
     RECENT_HOURS = 24;
     MAX_RECENT_MEMORIES = 5;
     GROUP_WINDOW_MINUTES = 5;
+    MAX_HOTSPOTS = 3;
     EXCLUDED_RELATIONSHIPS = /* @__PURE__ */ new Set([
       "USER_SUBMITS_DIRECTION",
       "DIRECTION_IS_TOPIC",
@@ -6957,7 +6980,7 @@ var init_SessionContextFormatter = __esm({
       /**
        * Format the full context content for injection into session context.
        */
-      formatContextContent(trigger, memories, tasks, taskCounts, context, gitCommits = [], querySince) {
+      formatContextContent(trigger, memories, tasks, taskCounts, context, gitCommits = [], querySince, gitTriage) {
         const { projectName, userName, folderType, projectRoot, branch } = context;
         const lines = [];
         lines.push(this.getTriggerMessage(trigger, memories.timedOut));
@@ -6976,7 +6999,10 @@ var init_SessionContextFormatter = __esm({
           lines.push(`  ${memories.initReview}`);
           lines.push("");
         }
-        if (gitCommits.length > 0) {
+        if (gitTriage && gitTriage.totalCommits > 0) {
+          lines.push("");
+          lines.push(...this.formatGitTriageSummary(gitTriage));
+        } else if (gitCommits.length > 0) {
           lines.push("");
           lines.push(`Recent commits (${gitCommits.length}):`);
           gitCommits.slice(0, 5).forEach((c) => {
@@ -7155,6 +7181,46 @@ var init_SessionContextFormatter = __esm({
           return `${month} ${day} ${time}`;
         }
       }
+      /**
+       * Format git triage results as a compact summary.
+       * Shows aggregate counts rather than individual commits.
+       */
+      formatGitTriageSummary(triage) {
+        const lines = [];
+        lines.push(`Git history: scanned ${triage.totalCommits.toLocaleString()} commits`);
+        if (triage.belowThreshold > 0) {
+          lines.push(`  \u2192 ${triage.belowThreshold.toLocaleString()} below threshold (skipped)`);
+        }
+        if (triage.minorInterest > 0) {
+          lines.push(`  \u2192 ${triage.minorInterest.toLocaleString()} minor interest`);
+        }
+        const highCount = triage.highInterest.length;
+        if (highCount > 0) {
+          lines.push(`  \u2192 ${highCount.toLocaleString()} high interest`);
+          if (triage.linkedToPRs > 0) {
+            lines.push(`      \u2192 ${triage.linkedToPRs} linked to PRs`);
+          }
+          if (triage.linkedToTags > 0) {
+            lines.push(`      \u2192 ${triage.linkedToTags} linked to tags/releases`);
+          }
+        }
+        if (triage.hotspots.length > 0) {
+          const topHotspots = triage.hotspots.slice(0, MAX_HOTSPOTS);
+          const hotspotList = topHotspots.map((h) => this.formatHotspotPath(h.path)).join(", ");
+          lines.push(`  Hotspots: ${hotspotList}`);
+        }
+        return lines;
+      }
+      /**
+       * Format a file path for hotspot display (truncate long paths).
+       */
+      formatHotspotPath(path15) {
+        const parts = path15.split("/");
+        if (parts.length <= 2) {
+          return path15;
+        }
+        return `.../${parts.slice(-2).join("/")}`;
+      }
     };
   }
 });
@@ -7357,6 +7423,300 @@ var init_MemoryContextLoader = __esm({
   }
 });
 
+// src/lib/application/services/GitTriageService.ts
+var DEFAULT_THRESHOLD, DEFAULT_DAYS, CONVENTIONAL_PREFIXES, CONVENTIONAL_COMMIT_REGEX, DECISION_KEYWORDS, SCORES, TAG_ADJACENT_DISTANCE, STAT_FETCH_MARGIN, GitTriageService;
+var init_GitTriageService = __esm({
+  "src/lib/application/services/GitTriageService.ts"() {
+    "use strict";
+    DEFAULT_THRESHOLD = 3;
+    DEFAULT_DAYS = 90;
+    CONVENTIONAL_PREFIXES = [
+      "feat",
+      "fix",
+      "refactor",
+      "docs",
+      "test",
+      "chore",
+      "style",
+      "perf",
+      "ci",
+      "build",
+      "revert"
+    ];
+    CONVENTIONAL_COMMIT_REGEX = new RegExp(
+      `^(${CONVENTIONAL_PREFIXES.join("|")})(\\(.+\\))?[!]?:`,
+      "i"
+    );
+    DECISION_KEYWORDS = [
+      "migrate",
+      "replace",
+      "rewrite",
+      "deprecate",
+      "breaking",
+      "workaround",
+      "decision",
+      "architecture",
+      "redesign",
+      "overhaul"
+    ];
+    SCORES = {
+      largeDiffFiles: 3,
+      // 10+ files changed
+      largeDiffLines: 2,
+      // 500+ lines changed
+      mergeCommitWithPR: 3,
+      // merge commit with PR reference
+      conventionalPrefix: 1,
+      // has conventional commit prefix
+      decisionKeywords: 2,
+      // contains decision keywords
+      createsNewDirectory: 2,
+      // creates new top-level dir
+      tagAdjacent: 2,
+      // within N commits of a tag
+      longMessageBody: 1
+      // multi-line body
+    };
+    TAG_ADJACENT_DISTANCE = 3;
+    STAT_FETCH_MARGIN = 2;
+    GitTriageService = class {
+      constructor(git) {
+        this.git = git;
+      }
+      async triage(options) {
+        const startTime = Date.now();
+        const threshold = options?.threshold ?? DEFAULT_THRESHOLD;
+        const cwd = options?.cwd;
+        const since = options?.since ?? this.getDefaultSince();
+        const until = options?.until ?? /* @__PURE__ */ new Date();
+        const tags = this.git.listTags(cwd);
+        const tagShas = new Set(tags.map((t) => t.sha));
+        const tagInfo = tags.map((t) => ({
+          name: t.name,
+          sha: t.sha,
+          isVersionTag: this.isVersionTag(t.name)
+        }));
+        const rawCommits = this.git.logDetailed({
+          since: since.toISOString(),
+          until: until.toISOString(),
+          maxCount: options?.maxCommits,
+          cwd
+        });
+        if (rawCommits.length === 0) {
+          return this.emptyResult(startTime, tagInfo);
+        }
+        const shaToPosition = /* @__PURE__ */ new Map();
+        for (let i = 0; i < rawCommits.length; i++) {
+          shaToPosition.set(rawCommits[i].sha, i);
+        }
+        const tagPositions = /* @__PURE__ */ new Set();
+        for (const tag of tags) {
+          const pos = shaToPosition.get(tag.sha);
+          if (pos !== void 0) {
+            for (let i = Math.max(0, pos - TAG_ADJACENT_DISTANCE); i <= pos + TAG_ADJACENT_DISTANCE; i++) {
+              tagPositions.add(i);
+            }
+          }
+        }
+        const fileStats = /* @__PURE__ */ new Map();
+        const scoredCommits = [];
+        const belowThreshold = [];
+        const minorInterest = [];
+        for (let i = 0; i < rawCommits.length; i++) {
+          const raw = rawCommits[i];
+          const commit = this.parseCommit(raw);
+          const isTagAdjacent = tagPositions.has(i);
+          const quickSignals = this.detectSignals(commit, null, tagShas, isTagAdjacent);
+          const quickScore = this.calculateScore(quickSignals);
+          let stats = null;
+          let finalSignals = quickSignals;
+          let finalScore = quickScore;
+          if (quickScore >= threshold - STAT_FETCH_MARGIN || options?.fetchAllStats) {
+            const rawStats = this.git.getCommitStats(commit.sha, cwd);
+            stats = this.parseStats(rawStats);
+            finalSignals = this.detectSignals(commit, stats, tagShas, isTagAdjacent);
+            finalScore = this.calculateScore(finalSignals);
+            for (const entry of rawStats) {
+              const existing = fileStats.get(entry.path) ?? { commits: 0, lines: 0 };
+              existing.commits++;
+              existing.lines += (entry.added ?? 0) + (entry.deleted ?? 0);
+              fileStats.set(entry.path, existing);
+            }
+          }
+          const scored = {
+            commit,
+            stats,
+            signals: finalSignals,
+            score: finalScore,
+            passedTriage: finalScore >= threshold
+          };
+          if (finalScore >= threshold) {
+            scoredCommits.push(scored);
+          } else if (finalScore > 0) {
+            minorInterest.push(scored);
+          } else {
+            belowThreshold.push(scored);
+          }
+        }
+        scoredCommits.sort((a, b) => b.score - a.score);
+        const hotspots = Array.from(fileStats.entries()).map(([path15, data]) => ({
+          path: path15,
+          commitCount: data.commits,
+          totalLinesChanged: data.lines
+        })).sort((a, b) => b.commitCount - a.commitCount || b.totalLinesChanged - a.totalLinesChanged).slice(0, 20);
+        const linkedToPRs = scoredCommits.filter((s) => s.signals.prNumber !== null).length;
+        const linkedToTags = scoredCommits.filter((s) => s.signals.isTagAdjacent).length;
+        return {
+          totalCommits: rawCommits.length,
+          belowThreshold: belowThreshold.length,
+          minorInterest: minorInterest.length,
+          highInterest: scoredCommits,
+          linkedToPRs,
+          linkedToTags,
+          hotspots,
+          tags: tagInfo,
+          durationMs: Date.now() - startTime
+        };
+      }
+      scoreCommit(commit, stats, tagShas, isTagAdjacent) {
+        const tagAdjacent = isTagAdjacent ?? tagShas.has(commit.sha);
+        const signals = this.detectSignals(commit, stats, tagShas, tagAdjacent);
+        const score = this.calculateScore(signals);
+        return {
+          commit,
+          stats,
+          signals,
+          score,
+          passedTriage: score >= DEFAULT_THRESHOLD
+        };
+      }
+      /**
+       * Parse raw git log commit into domain type.
+       */
+      parseCommit(raw) {
+        const refs = raw.refNames.split(",").map((r) => r.trim()).filter((r) => r && r !== "HEAD");
+        return {
+          sha: raw.sha,
+          shortSha: raw.shortSha,
+          subject: raw.subject,
+          body: raw.body,
+          parentCount: raw.parentShas.length,
+          author: raw.authorName,
+          authorEmail: raw.authorEmail,
+          timestamp: new Date(raw.authorTimestamp * 1e3),
+          refs
+        };
+      }
+      /**
+       * Parse raw stat entries into domain type.
+       */
+      parseStats(entries) {
+        let insertions = 0;
+        let deletions = 0;
+        const filesAdded = [];
+        const filesDeleted = [];
+        const directories = /* @__PURE__ */ new Set();
+        for (const entry of entries) {
+          insertions += entry.added ?? 0;
+          deletions += entry.deleted ?? 0;
+          if (entry.isNew) {
+            filesAdded.push(entry.path);
+            const dir = entry.path.split("/")[0];
+            if (dir && dir !== entry.path) {
+              directories.add(dir);
+            }
+          }
+          if (entry.isDeleted) {
+            filesDeleted.push(entry.path);
+          }
+        }
+        return {
+          filesChanged: entries.length,
+          insertions,
+          deletions,
+          filesAdded,
+          filesDeleted,
+          directoriesCreated: Array.from(directories)
+        };
+      }
+      /**
+       * Detect interest signals for a commit.
+       */
+      detectSignals(commit, stats, _tagShas, isTagAdjacent) {
+        const largeDiffFiles = stats !== null && stats.filesChanged >= 10;
+        const largeDiffLines = stats !== null && stats.insertions + stats.deletions >= 500;
+        const prMatch = commit.subject.match(/Merge pull request #(\d+)/i) ?? commit.subject.match(/\(#(\d+)\)/) ?? commit.body.match(/PR[:\s#]+(\d+)/i);
+        const prNumber = prMatch ? parseInt(prMatch[1], 10) : null;
+        const mergeCommitWithPR = commit.parentCount >= 2 && prNumber !== null;
+        const conventionalMatch = commit.subject.match(CONVENTIONAL_COMMIT_REGEX);
+        const hasConventionalPrefix = conventionalMatch !== null;
+        const conventionalType = conventionalMatch ? conventionalMatch[1].toLowerCase() : null;
+        const messageText = `${commit.subject} ${commit.body}`.toLowerCase();
+        const hasDecisionKeywords = DECISION_KEYWORDS.some((kw) => messageText.includes(kw));
+        const createsNewDirectory = stats !== null && stats.directoriesCreated.length > 0;
+        const hasLongMessageBody = commit.body.split("\n").filter((l) => l.trim()).length >= 2;
+        return {
+          largeDiffFiles,
+          largeDiffLines,
+          mergeCommitWithPR,
+          hasConventionalPrefix,
+          conventionalType,
+          hasDecisionKeywords,
+          createsNewDirectory,
+          isTagAdjacent,
+          hasLongMessageBody,
+          prNumber
+        };
+      }
+      /**
+       * Calculate interest score from signals.
+       */
+      calculateScore(signals) {
+        let score = 0;
+        if (signals.largeDiffFiles) score += SCORES.largeDiffFiles;
+        if (signals.largeDiffLines) score += SCORES.largeDiffLines;
+        if (signals.mergeCommitWithPR) score += SCORES.mergeCommitWithPR;
+        if (signals.hasConventionalPrefix) score += SCORES.conventionalPrefix;
+        if (signals.hasDecisionKeywords) score += SCORES.decisionKeywords;
+        if (signals.createsNewDirectory) score += SCORES.createsNewDirectory;
+        if (signals.isTagAdjacent) score += SCORES.tagAdjacent;
+        if (signals.hasLongMessageBody) score += SCORES.longMessageBody;
+        return score;
+      }
+      /**
+       * Get default "since" date (3 months ago).
+       */
+      getDefaultSince() {
+        const date = /* @__PURE__ */ new Date();
+        date.setDate(date.getDate() - DEFAULT_DAYS);
+        return date;
+      }
+      /**
+       * Check if a tag name looks like a version tag.
+       */
+      isVersionTag(name) {
+        return /^v?\d+\.\d+(\.\d+)?/.test(name);
+      }
+      /**
+       * Create an empty result (for repos with no commits in range).
+       */
+      emptyResult(startTime, tags) {
+        return {
+          totalCommits: 0,
+          belowThreshold: 0,
+          minorInterest: 0,
+          highInterest: [],
+          linkedToPRs: 0,
+          linkedToTags: 0,
+          hotspots: [],
+          tags,
+          durationMs: Date.now() - startTime
+        };
+      }
+    };
+  }
+});
+
 // src/lib/infrastructure/git/GitClient.ts
 var GitClient_exports = {};
 __export(GitClient_exports, {
@@ -7367,7 +7727,7 @@ var init_GitClient = __esm({
   "src/lib/infrastructure/git/GitClient.ts"() {
     "use strict";
     import_child_process6 = require("child_process");
-    GitClient = class {
+    GitClient = class _GitClient {
       log(options) {
         const args = ["log"];
         if (options.since) args.push(`--since=${options.since}`);
@@ -7425,6 +7785,154 @@ var init_GitClient = __esm({
           return false;
         }
       }
+      static {
+        /**
+         * Record separator for parsing detailed log output.
+         * Using ASCII RS (Record Separator) to avoid conflicts with commit content.
+         */
+        this.RECORD_SEP = "";
+      }
+      static {
+        this.FIELD_SEP = "";
+      }
+      logDetailed(options) {
+        const format = [
+          "%H",
+          // full sha
+          "%h",
+          // short sha
+          "%P",
+          // parent shas (space-separated)
+          "%s",
+          // subject
+          "%b",
+          // body
+          "%an",
+          // author name
+          "%ae",
+          // author email
+          "%at",
+          // author timestamp (unix)
+          "%D"
+          // ref names
+        ].join(_GitClient.FIELD_SEP);
+        const args = [
+          "log",
+          `--format=${_GitClient.RECORD_SEP}${format}`
+        ];
+        if (options.since) args.push(`--since=${options.since}`);
+        if (options.until) args.push(`--until=${options.until}`);
+        if (options.maxCount) args.push(`-n${options.maxCount}`);
+        try {
+          const output = (0, import_child_process6.execFileSync)("git", args, {
+            encoding: "utf8",
+            cwd: options.cwd,
+            stdio: ["pipe", "pipe", "pipe"],
+            maxBuffer: 50 * 1024 * 1024
+            // 50MB buffer for large repos
+          }).trim();
+          if (!output) return [];
+          const records = output.split(_GitClient.RECORD_SEP).filter((r) => r.trim());
+          return records.map((record) => {
+            const fields = record.split(_GitClient.FIELD_SEP);
+            return {
+              sha: fields[0] || "",
+              shortSha: fields[1] || "",
+              parentShas: (fields[2] || "").split(" ").filter((s) => s),
+              subject: fields[3] || "",
+              body: (fields[4] || "").trim(),
+              authorName: fields[5] || "",
+              authorEmail: fields[6] || "",
+              authorTimestamp: parseInt(fields[7] || "0", 10),
+              refNames: fields[8] || ""
+            };
+          });
+        } catch {
+          return [];
+        }
+      }
+      getCommitStats(sha, cwd) {
+        try {
+          const output = (0, import_child_process6.execFileSync)(
+            "git",
+            ["show", "--numstat", "--format=", sha],
+            {
+              encoding: "utf8",
+              cwd,
+              stdio: ["pipe", "pipe", "pipe"]
+            }
+          ).trim();
+          if (!output) return [];
+          const statusOutput = (0, import_child_process6.execFileSync)(
+            "git",
+            ["show", "--name-status", "--format=", sha],
+            {
+              encoding: "utf8",
+              cwd,
+              stdio: ["pipe", "pipe", "pipe"]
+            }
+          ).trim();
+          const statusMap = /* @__PURE__ */ new Map();
+          for (const line of statusOutput.split("\n")) {
+            const match = line.match(/^([AMDRC])\t(.+)$/);
+            if (match) {
+              statusMap.set(match[2], match[1]);
+            }
+          }
+          return output.split("\n").filter((line) => line.trim()).map((line) => {
+            const parts = line.split("	");
+            const added = parts[0] === "-" ? null : parseInt(parts[0], 10);
+            const deleted = parts[1] === "-" ? null : parseInt(parts[1], 10);
+            const path15 = parts[2] || "";
+            const status = statusMap.get(path15) || "M";
+            return {
+              added,
+              deleted,
+              path: path15,
+              isNew: status === "A",
+              isDeleted: status === "D"
+            };
+          });
+        } catch {
+          return [];
+        }
+      }
+      listTags(cwd) {
+        try {
+          const output = (0, import_child_process6.execFileSync)(
+            "git",
+            ["tag", "-l", "--format=%(refname:short)	%(objectname)"],
+            {
+              encoding: "utf8",
+              cwd,
+              stdio: ["pipe", "pipe", "pipe"]
+            }
+          ).trim();
+          if (!output) return [];
+          return output.split("\n").filter((line) => line.trim()).map((line) => {
+            const [name, sha] = line.split("	");
+            return { name: name || "", sha: sha || "" };
+          });
+        } catch {
+          return [];
+        }
+      }
+      countCommits(cwd) {
+        try {
+          const output = (0, import_child_process6.execFileSync)(
+            "git",
+            ["rev-list", "--count", "HEAD"],
+            {
+              encoding: "utf8",
+              cwd,
+              stdio: ["pipe", "pipe", "pipe"]
+            }
+          ).trim();
+          return parseInt(output, 10) || 0;
+        } catch {
+          return 0;
+        }
+      }
     };
   }
 });
@@ -7438,6 +7946,7 @@ var init_SessionStartHandler = __esm({
     init_SessionContextFormatter();
     init_GitIntrospectionService();
     init_MemoryContextLoader();
+    init_GitTriageService();
     RECENT_HOURS2 = 24;
     SessionStartHandler = class {
       constructor(contextOrServices, memoryOrGitClient, tasks, mcp, router, logger, githubSync, gitClient) {
@@ -7451,6 +7960,7 @@ var init_SessionStartHandler = __esm({
           this.router = services.router;
           this.logger = services.logger;
           this.githubSync = services.githubSync;
+          this.commitEnricher = services.commitEnricher;
           resolvedGitClient = memoryOrGitClient;
         } else {
           this.context = contextOrServices;
@@ -7475,6 +7985,7 @@ var init_SessionStartHandler = __esm({
           this.router,
           this.logger
         );
+        this.triageService = new GitTriageService(resolvedGitClient);
       }
       /**
        * Handle a session start request.
@@ -7483,13 +7994,19 @@ var init_SessionStartHandler = __esm({
         const { hierarchicalGroupIds, projectAliases, branch, projectName, userName, folderType, projectRoot } = this.context;
         await this.syncGitHubOnStartup(request.trigger, hierarchicalGroupIds, projectName);
         const dateOptions = this.computeDateOptions(request.trigger);
-        const memories = await this.memoryLoader.loadMemory(
-          hierarchicalGroupIds,
-          projectAliases,
-          branch,
-          dateOptions
-        );
-        const gitCommits = await this.gitService.loadGitCommits(dateOptions.since, projectRoot);
+        const [memories, gitTriage] = await Promise.all([
+          this.memoryLoader.loadMemory(
+            hierarchicalGroupIds,
+            projectAliases,
+            branch,
+            dateOptions
+          ),
+          this.runGitTriage(dateOptions.since, projectRoot)
+        ]);
+        const gitCommits = gitTriage ? [] : await this.gitService.loadGitCommits(dateOptions.since, projectRoot);
+        if (gitTriage && request.trigger === "startup") {
+          this.enrichAndSaveCommits(gitTriage.highInterest, hierarchicalGroupIds[0]).catch((err) => this.logger?.warn("Commit enrichment failed", { error: err.message }));
+        }
         const tasks = this.processTasks(memories.tasks);
         const taskCounts = this.countTasks(tasks);
         const contextContent = this.formatter.formatContextContent(
@@ -7499,7 +8016,8 @@ var init_SessionStartHandler = __esm({
           taskCounts,
           { projectName, userName, folderType, projectRoot, branch },
           gitCommits,
-          dateOptions.since
+          dateOptions.since,
+          gitTriage
         );
         const message = this.formatter.getTriggerMessage(request.trigger, memories.timedOut);
         return {
@@ -7536,6 +8054,96 @@ var init_SessionStartHandler = __esm({
           this.logger?.warn("GitHub sync failed", { error: error.message });
         }
       }
+      /**
+       * Run git triage to analyze commit history.
+       * Returns null if triage fails (non-blocking).
+       */
+      async runGitTriage(since, projectRoot) {
+        try {
+          const result = await this.triageService.triage({
+            since,
+            cwd: projectRoot
+          });
+          this.logger?.debug("Git triage completed", {
+            total: result.totalCommits,
+            highInterest: result.highInterest.length,
+            durationMs: result.durationMs
+          });
+          return result;
+        } catch (error) {
+          this.logger?.warn("Git triage failed", { error: error.message });
+          return null;
+        }
+      }
+      /**
+       * Enrich high-interest commits and save facts to memory (fire-and-forget).
+       */
+      async enrichAndSaveCommits(commits, groupId) {
+        if (!this.commitEnricher || commits.length === 0) return;
+        try {
+          const existingShas = await this.checkEnrichedCommits(groupId);
+          const toEnrich = commits.filter((c) => !existingShas.has(c.commit.shortSha));
+          if (toEnrich.length === 0) {
+            this.logger?.debug("All commits already enriched, skipping");
+            return;
+          }
+          this.logger?.debug("Enriching commits", { count: toEnrich.length });
+          const result = await this.commitEnricher.enrich(toEnrich, { maxCommits: 5 });
+          if (result.facts.length === 0) {
+            this.logger?.debug("No facts extracted from commits");
+            return;
+          }
+          const shaToShort = /* @__PURE__ */ new Map();
+          for (const commit of toEnrich) {
+            if (commit.commit.sha && commit.commit.shortSha) {
+              shaToShort.set(commit.commit.sha, commit.commit.shortSha);
+              shaToShort.set(commit.commit.shortSha, commit.commit.shortSha);
+            }
+          }
+          for (const fact of result.facts) {
+            const commitSha = shaToShort.get(fact.commitSha) ?? fact.commitSha;
+            const tags = [
+              "type:commit-enrichment",
+              `commit:${commitSha}`,
+              `factType:${fact.type}`,
+              `confidence:${fact.confidence}`,
+              "source:git-enrichment",
+              ...fact.tags.map((t) => `tag:${t}`)
+            ];
+            await this.memory.addFact(groupId, fact.text, tags);
+          }
+          this.logger?.info("Commit enrichment complete", {
+            processed: result.commitsProcessed,
+            facts: result.facts.length,
+            inputTokens: result.usage.inputTokens,
+            outputTokens: result.usage.outputTokens
+          });
+        } catch (error) {
+          this.logger?.warn("Commit enrichment error", { error: error.message });
+        }
+      }
+      /**
+       * Check which commits have already been enriched (by short SHA tag in memory).
+       */
+      async checkEnrichedCommits(groupId) {
+        const enrichedShas = /* @__PURE__ */ new Set();
+        try {
+          const existingFacts = await this.memory.searchFacts(
+            [groupId],
+            "type:commit-enrichment",
+            100
+          );
+          for (const fact of existingFacts) {
+            const shaTag = fact.tags?.find((t) => t.startsWith("commit:"));
+            if (shaTag) {
+              enrichedShas.add(shaTag.replace("commit:", ""));
+            }
+          }
+        } catch (error) {
+          this.logger?.debug("Could not check existing enrichments", { error: error.message });
+        }
+        return enrichedShas;
+      }
       /**
        * Compute date options based on trigger type.
        */
@@ -10561,6 +11169,7 @@ var INFRA_TOKENS = {
   LlmGuard: /* @__PURE__ */ Symbol.for("Lisa.LlmGuard"),
   SummarizationService: /* @__PURE__ */ Symbol.for("Lisa.SummarizationService"),
   TranscriptEnricher: /* @__PURE__ */ Symbol.for("Lisa.TranscriptEnricher"),
+  CommitEnricher: /* @__PURE__ */ Symbol.for("Lisa.CommitEnricher"),
   LlmDeduplicationEnhancer: /* @__PURE__ */ Symbol.for("Lisa.LlmDeduplicationEnhancer"),
   NlCurationService: /* @__PURE__ */ Symbol.for("Lisa.NlCurationService")
 };
@@ -11152,6 +11761,7 @@ var Logger = class _Logger {
     this.getCorrelationId = getCorrelationId2 ?? (() => void 0);
     this.bindings = bindings ?? {};
     this.boundContext = boundContext ?? {};
+    this.asyncWrites = options.asyncWrites ?? false;
     const logDir = import_path2.default.resolve(options.logDir);
     this.ensureLogDir(logDir);
     this.logFile = import_path2.default.join(logDir, `lisa-${getDateString()}.log`);
@@ -11187,6 +11797,7 @@ var Logger = class _Logger {
   }
   /**
    * Write a log entry.
+   * Uses async (fire-and-forget) writes when asyncWrites is enabled.
    */
   writeLog(level, levelStr, message, context) {
     if (!this.shouldLog(level)) return;
@@ -11195,9 +11806,18 @@ var Logger = class _Logger {
     if (this.options.enableFile) {
       const fileLine = `${timestamp} ${levelStr.padEnd(5)} ${message}${contextStr}
 `;
-      try {
-        import_fs.default.appendFileSync(this.logFile, fileLine);
-      } catch {
+      if (this.asyncWrites) {
+        void (async () => {
+          try {
+            await import_fs.default.promises.appendFile(this.logFile, fileLine);
+          } catch {
+          }
+        })();
+      } else {
+        try {
+          import_fs.default.appendFileSync(this.logFile, fileLine);
+        } catch {
+        }
       }
     }
     if (this.options.enableConsole) {
@@ -11226,7 +11846,7 @@ var Logger = class _Logger {
   }
   child(bindings) {
     return new _Logger(
-      this.options,
+      { ...this.options, asyncWrites: this.asyncWrites },
       void 0,
       this.getCorrelationId,
       { ...this.bindings, ...bindings },
@@ -11295,7 +11915,7 @@ var Logger = class _Logger {
    */
   withContext(context) {
     return new _Logger(
-      this.options,
+      { ...this.options, asyncWrites: this.asyncWrites },
       void 0,
       this.getCorrelationId,
       this.bindings,
@@ -14649,6 +15269,266 @@ function extractJson3(text) {
   return null;
 }
 
+// src/lib/infrastructure/services/CommitEnricher.ts
+init_ICommitEnricher();
+init_IMemoryQuality();
+
+// src/lib/infrastructure/services/prompts/commit-extraction.ts
+var DEFAULT_MAX_FACTS3 = 10;
+function buildCommitExtractionPrompt(commits, options = {}) {
+  const extractTypes = options.extractTypes;
+  const maxFacts = Math.min(commits.length * 2, DEFAULT_MAX_FACTS3);
+  const validTypes = extractTypes && extractTypes.length > 0 ? extractTypes : [
+    "feature",
+    "decision",
+    "refactor",
+    "migration",
+    "bugfix",
+    "breaking-change",
+    "convention",
+    "dependency"
+  ];
+  const system = [
+    "You are analyzing git commits to extract structured facts for project memory.",
+    "Your task is to identify important information worth remembering long-term.",
+    "",
+    "Fact types to extract:",
+    "- feature: New functionality or capability added to the project",
+    "- decision: Architecture or technology choice evident from the commit",
+    "- refactor: Code restructuring without behavior change",
+    "- migration: Data migration, API migration, or technology migration",
+    "- bugfix: Bug fix with root cause (what was broken and why)",
+    "- breaking-change: Changes that break backward compatibility",
+    "- convention: New patterns or coding conventions introduced",
+    "- dependency: Significant dependency additions, updates, or removals",
+    "",
+    "Confidence levels:",
+    "- high: Clear from commit message, subject, or explicit description",
+    "- medium: Reasonably inferred from commit context and signals",
+    "- low: Tentative inference, may need verification",
+    "",
+    "Guidelines:",
+    "- Each fact should be self-contained and understandable without the commit context.",
+    "- Include relevant file paths, technologies, or components in tags.",
+    "- For bugfixes, try to identify the root cause if evident from the message.",
+    "- Focus on facts that would be valuable for future developers.",
+    "- Do not extract trivial changes (formatting, typos, version bumps).",
+    `- Extract at most ${maxFacts} facts total across all commits.`,
+    extractTypes && extractTypes.length > 0 ? `- Only extract facts of these types: ${extractTypes.join(", ")}` : "- Extract facts of any type listed above.",
+    "",
+    "Respond with ONLY a valid JSON object in this exact format:",
+    "{",
+    '  "facts": [',
+    "    {",
+    '      "text": "Clear description of the fact",',
+    `      "type": "one of: ${validTypes.join(", ")}",`,
+    '      "confidence": "high | medium | low",',
+    '      "tags": ["relevant", "tags"],',
+    '      "commitSha": "short SHA of the source commit",',
+    '      "rationale": "Why this fact is worth remembering"',
+    "    }",
+    "  ]",
+    "}"
+  ].join("\n");
+  const user = formatCommitsForPrompt(commits);
+  return { system, user };
+}
+function formatCommitsForPrompt(commits) {
+  const parts = [];
+  parts.push("## Commits to Analyze");
+  parts.push("");
+  for (let i = 0; i < commits.length; i++) {
+    const { commit, stats, signals } = commits[i];
+    parts.push(`### Commit ${i + 1}: ${commit.shortSha}`);
+    parts.push(`**Subject:** ${commit.subject}`);
+    if (commit.body && commit.body.trim().length > 0) {
+      const truncatedBody = commit.body.length > 500 ? commit.body.slice(0, 500) + "..." : commit.body;
+      parts.push(`**Body:** ${truncatedBody}`);
+    }
+    parts.push(`**Timestamp:** ${commit.timestamp.toISOString()}`);
+    parts.push(`**Author:** ${commit.author}`);
+    if (stats) {
+      parts.push(`**Files changed:** ${stats.filesChanged}`);
+      parts.push(`**Lines:** +${stats.insertions} -${stats.deletions}`);
+      if (stats.directoriesCreated.length > 0) {
+        parts.push(`**New directories:** ${stats.directoriesCreated.join(", ")}`);
+      }
+    }
+    const signalList = formatSignals(signals);
+    if (signalList.length > 0) {
+      parts.push(`**Signals:** ${signalList.join(", ")}`);
+    }
+    parts.push("");
+  }
+  return parts.join("\n");
+}
+function formatSignals(signals) {
+  const result = [];
+  if (signals.largeDiffFiles) {
+    result.push("large-diff-files");
+  }
+  if (signals.largeDiffLines) {
+    result.push("large-diff-lines");
+  }
+  if (signals.mergeCommitWithPR && signals.prNumber) {
+    result.push(`merge-PR-#${signals.prNumber}`);
+  }
+  if (signals.hasConventionalPrefix && signals.conventionalType) {
+    result.push(`conventional:${signals.conventionalType}`);
+  }
+  if (signals.hasDecisionKeywords) {
+    result.push("decision-keywords");
+  }
+  if (signals.createsNewDirectory) {
+    result.push("new-directory");
+  }
+  if (signals.isTagAdjacent) {
+    result.push("tag-adjacent");
+  }
+  if (signals.hasLongMessageBody) {
+    result.push("detailed-message");
+  }
+  return result;
+}
+
+// src/lib/infrastructure/services/CommitEnricher.ts
+var DEFAULT_MAX_COMMITS = 5;
+var DEFAULT_MAX_TOKENS = 4096;
+var EMPTY_USAGE2 = { inputTokens: 0, outputTokens: 0, totalTokens: 0 };
+function createCommitEnricher(llmGuard, logger) {
+  return {
+    async enrich(commits, options = {}) {
+      try {
+        const skipShas = new Set(options.skipShas ?? []);
+        const filteredCommits = commits.filter((c) => !skipShas.has(c.commit.shortSha));
+        if (filteredCommits.length === 0) {
+          return {
+            facts: [],
+            commitsProcessed: 0,
+            commitsSkipped: commits.length,
+            usage: EMPTY_USAGE2
+          };
+        }
+        const maxCommits = Math.max(0, options.maxCommits ?? DEFAULT_MAX_COMMITS);
+        const toProcess = filteredCommits.slice(0, maxCommits);
+        if (toProcess.length === 0) {
+          return {
+            facts: [],
+            commitsProcessed: 0,
+            commitsSkipped: commits.length,
+            usage: EMPTY_USAGE2
+          };
+        }
+        const skipped = commits.length - toProcess.length;
+        const allowedShas = new Set(
+          toProcess.flatMap((c) => [c.commit.sha, c.commit.shortSha].filter(Boolean))
+        );
+        const prompt = buildCommitExtractionPrompt(toProcess, options);
+        const response = await llmGuard.complete(prompt.user, "extraction", {
+          systemPrompt: prompt.system,
+          temperature: 0.3,
+          maxTokens: options.maxTokens ?? DEFAULT_MAX_TOKENS
+        });
+        const parsed = parseCommitExtractionResponse(response.text, options, allowedShas);
+        return {
+          facts: parsed.facts,
+          commitsProcessed: toProcess.length,
+          commitsSkipped: skipped,
+          usage: response.usage
+        };
+      } catch (error) {
+        const errorMsg = error instanceof Error ? error.message.split("\n")[0] : "Unknown error";
+        logger?.warn("Commit enrichment failed, returning empty result", {
+          error: errorMsg
+        });
+        return {
+          facts: [],
+          commitsProcessed: 0,
+          commitsSkipped: commits.length,
+          usage: EMPTY_USAGE2
+        };
+      }
+    }
+  };
+}
+function parseCommitExtractionResponse(responseText, options = {}, allowedShas) {
+  const jsonText = extractJson4(responseText);
+  if (!jsonText) {
+    return { facts: [] };
+  }
+  let parsed;
+  try {
+    parsed = JSON.parse(jsonText);
+  } catch {
+    return { facts: [] };
+  }
+  if (typeof parsed !== "object" || parsed === null) {
+    return { facts: [] };
+  }
+  const obj = parsed;
+  const rawFacts = Array.isArray(obj.facts) ? obj.facts : [];
+  const allowedTypes = options.extractTypes;
+  const facts = [];
+  for (const raw of rawFacts) {
+    const fact = validateCommitFact(raw, allowedTypes, allowedShas);
+    if (fact) {
+      facts.push(fact);
+    }
+  }
+  return { facts };
+}
+function extractJson4(text) {
+  const trimmed = text.trim();
+  let start = trimmed.indexOf("{");
+  while (start !== -1) {
+    for (let end = trimmed.lastIndexOf("}"); end > start; end = trimmed.lastIndexOf("}", end - 1)) {
+      const candidate = trimmed.slice(start, end + 1);
+      try {
+        JSON.parse(candidate);
+        return candidate;
+      } catch {
+      }
+    }
+    start = trimmed.indexOf("{", start + 1);
+  }
+  return null;
+}
+function validateCommitFact(raw, allowedTypes, allowedShas) {
+  if (typeof raw !== "object" || raw === null) return null;
+  const obj = raw;
+  if (typeof obj.text !== "string" || obj.text.trim().length === 0) return null;
+  if (typeof obj.type !== "string" || !isValidCommitFactType(obj.type)) return null;
+  if (allowedTypes && allowedTypes.length > 0 && !allowedTypes.includes(obj.type)) {
+    return null;
+  }
+  if (typeof obj.commitSha !== "string" || obj.commitSha.trim().length === 0) return null;
+  const commitSha = obj.commitSha.trim();
+  if (allowedShas && !allowedShas.has(commitSha)) return null;
+  let confidence = "medium";
+  if (typeof obj.confidence === "string") {
+    if (isValidConfidence(obj.confidence)) {
+      confidence = obj.confidence;
+    }
+  }
+  const tags = [];
+  if (Array.isArray(obj.tags)) {
+    for (const tag of obj.tags) {
+      if (typeof tag === "string" && tag.trim().length > 0) {
+        tags.push(tag.trim());
+      }
+    }
+  }
+  const rationale = typeof obj.rationale === "string" && obj.rationale.trim().length > 0 ? obj.rationale.trim() : void 0;
+  return {
+    text: obj.text.trim(),
+    type: obj.type,
+    confidence,
+    tags,
+    commitSha,
+    rationale
+  };
+}
+
 // src/lib/domain/interfaces/dal/types.ts
 var DEFAULT_QUERY_OPTIONS = {
   limit: 10,
@@ -16375,7 +17255,7 @@ async function bootstrapContainer(config = {}) {
     container.registerInstance(TOKENS.ApiKey, apiKey);
   }
   container.registerInstance(TOKENS.ServiceConfig, config);
-  const logger = config.logger ?? (config.disableLogging ? createNullLogger() : createLogger());
+  const logger = config.logger ?? (config.disableLogging ? createNullLogger() : createLogger({ asyncWrites: config.asyncLogging }));
   container.registerInstance(TOKENS.Logger, logger);
   const context = ContextDetector.detect(projectRoot);
   container.registerInstance(TOKENS.Context, context);
@@ -16438,6 +17318,15 @@ async function bootstrapContainer(config = {}) {
     },
     "transient"
   );
+  container.register(
+    TOKENS.CommitEnricher,
+    async () => {
+      const guard = await container.resolve(TOKENS.LlmGuard);
+      const log = logger.child({ service: "commit-enricher" });
+      return createCommitEnricher(guard, log);
+    },
+    "transient"
+  );
   container.register(
     TOKENS.SessionCaptureService,
     async () => {