@a-company/paradigm 3.17.1 → 3.18.0

package/dist/{chunk-D4VBBKGV.js → chunk-TUW27EIC.js}

@@ -5,12 +5,12 @@ import * as fs9 from "fs";
 import * as path10 from "path";
 import * as yaml8 from "js-yaml";
 
-// ../paradigm-mcp/node_modules/.pnpm/@a-company+premise-core@0.2.0_typescript@5.9.3/node_modules/@a-company/premise-core/dist/index.js
+// ../premise/core/dist/index.js
 import * as yaml3 from "js-yaml";
 import { z as z2 } from "zod";
 import * as path3 from "path";
 
-// ../paradigm-mcp/node_modules/.pnpm/@a-company+purpose-core@3.5.0_typescript@5.9.3/node_modules/@a-company/purpose-core/dist/index.js
+// ../purpose/core/dist/index.js
 import * as fs from "fs";
 import * as yaml from "js-yaml";
 import { z } from "zod";
@@ -617,7 +617,7 @@ function validatePurposeItem(id, item, itemType, prefix, issues) {
   }
 }
 
-// ../paradigm-mcp/node_modules/.pnpm/@a-company+portal-core@0.1.0/node_modules/@a-company/portal-core/dist/index.js
+// ../portal/core/dist/index.js
 import * as fs2 from "fs";
 import * as path2 from "path";
 import * as yaml2 from "js-yaml";
@@ -761,7 +761,7 @@ async function findGateFiles(rootDir) {
   return files;
 }
 
-// ../paradigm-mcp/node_modules/.pnpm/@a-company+premise-core@0.2.0_typescript@5.9.3/node_modules/@a-company/premise-core/dist/index.js
+// ../premise/core/dist/index.js
 var PositionSchema = z2.object({
   x: z2.number(),
   y: z2.number()
@@ -926,7 +926,9 @@ async function aggregateFromPremise(premiseFile, rootDir) {
             data: item,
             description: item.description,
             anchors: item.anchors?.map((a) => parseAnchorString(a)),
-            appliesTo: item["applies-to"]
+            appliesTo: item["applies-to"],
+            tags: item.tags,
+            enforcement: item.enforcement
           }));
         }
         const symbolRefs = extractSymbolReferences(parsed);
@@ -1218,7 +1220,7 @@ function getAllSymbols(index) {
   return Array.from(index.entries.values());
 }
 
-// ../paradigm-mcp/node_modules/.pnpm/@a-company+probe-core@3.5.0/node_modules/@a-company/probe-core/dist/generator.js
+// ../probe/core/dist/generator.js
 var PARADIGM_VERSION = "0.1.0";
 var SCHEMA_VERSION = "1.0.0";
 function generateScanIndex(input, options) {
@@ -3403,9 +3405,72 @@ function inferSeverity(data, entry) {
 import * as fs6 from "fs";
 import * as path7 from "path";
 import * as yaml5 from "js-yaml";
+import { execSync as execSync2 } from "child_process";
+import * as os2 from "os";
 var LORE_DIR = ".paradigm/lore";
 var ENTRIES_DIR = "entries";
 var TIMELINE_FILE = "timeline.yaml";
+function inferProvider(model) {
+  const lower = model.toLowerCase();
+  if (lower.includes("claude") || lower.includes("anthropic")) return "anthropic";
+  if (lower.includes("gpt") || lower.includes("openai") || lower.includes("o1") || lower.includes("o3")) return "openai";
+  if (lower.includes("gemini") || lower.includes("google") || lower.includes("palm")) return "google";
+  if (lower.includes("llama") || lower.includes("meta")) return "meta";
+  if (lower.includes("mistral") || lower.includes("mixtral")) return "mistral";
+  if (lower.includes("deepseek")) return "deepseek";
+  if (lower.includes("cohere") || lower.includes("command")) return "cohere";
+  return "unknown";
+}
+function normalizeLoreEntry(raw) {
+  const entry = raw;
+  const author = entry.author;
+  if (typeof author === "string") {
+    return raw;
+  }
+  if (author && typeof author === "object" && !Array.isArray(author)) {
+    const old = author;
+    if (old.type === "agent") {
+      entry.author = "unknown";
+      entry.agent = {
+        provider: old.model ? inferProvider(old.model) : inferProvider(old.id),
+        model: old.model || old.id
+      };
+    } else {
+      entry.author = old.id || "unknown";
+    }
+    delete entry.assistedBy;
+  }
+  return entry;
+}
+function sanitizeAuthor(name) {
+  return name.toLowerCase().replace(/[^a-z0-9-]/g, "-").replace(/-+/g, "-").replace(/^-|-$/g, "").slice(0, 20) || "unknown";
+}
+function resolveAuthor() {
+  const envAuthor = process.env.PARADIGM_AUTHOR;
+  if (envAuthor) return sanitizeAuthor(envAuthor);
+  try {
+    const gitName = execSync2("git config user.name", { encoding: "utf-8", timeout: 3e3 }).trim();
+    if (gitName) return sanitizeAuthor(gitName);
+  } catch {
+  }
+  try {
+    const username = os2.userInfo().username;
+    if (username) return sanitizeAuthor(username);
+  } catch {
+  }
+  return "unknown";
+}
+function isLoreFile(filename) {
+  return filename.endsWith(".yaml") || filename.endsWith(".lore");
+}
+function resolveEntryPath(rootDir, dateStr, entryId) {
+  const dirPath = path7.join(rootDir, LORE_DIR, ENTRIES_DIR, dateStr);
+  const lorePath = path7.join(dirPath, `${entryId}.lore`);
+  if (fs6.existsSync(lorePath)) return lorePath;
+  const yamlPath = path7.join(dirPath, `${entryId}.yaml`);
+  if (fs6.existsSync(yamlPath)) return yamlPath;
+  return null;
+}
 async function loadLoreEntries(rootDir, filter) {
   const entriesPath = path7.join(rootDir, LORE_DIR, ENTRIES_DIR);
   if (!fs6.existsSync(entriesPath)) {
@@ -3418,12 +3483,12 @@ async function loadLoreEntries(rootDir, filter) {
     if (filter?.dateFrom && dateDir < filter.dateFrom.slice(0, 10)) continue;
     if (filter?.dateTo && dateDir > filter.dateTo.slice(0, 10)) continue;
     const dirPath = path7.join(entriesPath, dateDir);
-    const files = fs6.readdirSync(dirPath).filter((f) => f.endsWith(".yaml")).sort();
+    const files = fs6.readdirSync(dirPath).filter(isLoreFile).sort();
     for (const file of files) {
       try {
         const content = fs6.readFileSync(path7.join(dirPath, file), "utf8");
-        const entry = yaml5.load(content);
-        entries.push(entry);
+        const raw = yaml5.load(content);
+        entries.push(normalizeLoreEntry(raw));
       } catch {
       }
     }
@@ -3434,11 +3499,12 @@ async function loadLoreEntry(rootDir, entryId) {
   const dateMatch = entryId.match(/^L-(\d{4}-\d{2}-\d{2})-/);
   if (dateMatch) {
     const dateStr = dateMatch[1];
-    const entryPath = path7.join(rootDir, LORE_DIR, ENTRIES_DIR, dateStr, `${entryId}.yaml`);
-    if (fs6.existsSync(entryPath)) {
+    const entryPath = resolveEntryPath(rootDir, dateStr, entryId);
+    if (entryPath) {
       try {
         const content = fs6.readFileSync(entryPath, "utf8");
-        return yaml5.load(content);
+        const raw = yaml5.load(content);
+        return normalizeLoreEntry(raw);
       } catch {
         return null;
       }
@@ -3459,6 +3525,16 @@ async function loadLoreTimeline(rootDir) {
     return null;
   }
 }
+function captureGitContext(cwd) {
+  try {
+    const ref = execSync2("git rev-parse HEAD", { cwd, encoding: "utf8", stdio: ["pipe", "pipe", "pipe"] }).trim();
+    const branch = execSync2("git rev-parse --abbrev-ref HEAD", { cwd, encoding: "utf8", stdio: ["pipe", "pipe", "pipe"] }).trim();
+    const status = execSync2("git status --porcelain", { cwd, encoding: "utf8", stdio: ["pipe", "pipe", "pipe"] }).trim();
+    return { ref, branch, dirty: status.length > 0 };
+  } catch {
+    return void 0;
+  }
+}
 async function recordLoreEntry(rootDir, entry) {
   const lorePath = path7.join(rootDir, LORE_DIR);
   const dateStr = entry.timestamp.slice(0, 10);
@@ -3466,10 +3542,16 @@ async function recordLoreEntry(rootDir, entry) {
   if (!fs6.existsSync(datePath)) {
     fs6.mkdirSync(datePath, { recursive: true });
   }
+  if (!entry.author) {
+    entry.author = resolveAuthor();
+  }
+  if (!entry.git_context) {
+    entry.git_context = captureGitContext(rootDir);
+  }
   if (!entry.id) {
-    entry.id = generateLoreId(rootDir, dateStr);
+    entry.id = generateLoreId(rootDir, dateStr, entry.author, entry.timestamp);
   }
-  const entryPath = path7.join(datePath, `${entry.id}.yaml`);
+  const entryPath = path7.join(datePath, `${entry.id}.lore`);
   fs6.writeFileSync(entryPath, yaml5.dump(entry, { lineWidth: -1, noRefs: true }));
   await rebuildTimeline(rootDir);
   return entry.id;
@@ -3485,12 +3567,13 @@ async function rebuildTimeline(rootDir) {
   const dateDirs = fs6.readdirSync(entriesPath).filter((d) => /^\d{4}-\d{2}-\d{2}$/.test(d));
   for (const dateDir of dateDirs) {
     const dirPath = path7.join(entriesPath, dateDir);
-    const files = fs6.readdirSync(dirPath).filter((f) => f.endsWith(".yaml"));
+    const files = fs6.readdirSync(dirPath).filter(isLoreFile);
     for (const file of files) {
       try {
         const content = fs6.readFileSync(path7.join(dirPath, file), "utf8");
-        const entry = yaml5.load(content);
-        authors.add(entry.author.id);
+        const raw = yaml5.load(content);
+        const entry = normalizeLoreEntry(raw);
+        authors.add(entry.author);
         entryCount++;
         if (!lastUpdated || entry.timestamp > lastUpdated) {
           lastUpdated = entry.timestamp;
@@ -3526,7 +3609,7 @@ async function rebuildTimeline(rootDir) {
 function migrateLegacyEntries(rootDir) {
   const entriesPath = path7.join(rootDir, LORE_DIR, ENTRIES_DIR);
   if (!fs6.existsSync(entriesPath)) return 0;
-  const rootFiles = fs6.readdirSync(entriesPath).filter((f) => f.endsWith(".yaml") && !f.startsWith("."));
+  const rootFiles = fs6.readdirSync(entriesPath).filter((f) => isLoreFile(f) && !f.startsWith("."));
   let migrated = 0;
   for (const file of rootFiles) {
     const filePath = path7.join(entriesPath, file);
@@ -3536,12 +3619,15 @@ function migrateLegacyEntries(rootDir) {
       const content = fs6.readFileSync(filePath, "utf8");
       const raw = yaml5.load(content);
       if (raw.author && typeof raw.author === "object") continue;
+      if (typeof raw.author === "string" && raw.timestamp) continue;
       const dateStr = typeof raw.date === "string" ? raw.date.slice(0, 10) : (/* @__PURE__ */ new Date()).toISOString().slice(0, 10);
       const datePath = path7.join(entriesPath, dateStr);
       if (!fs6.existsSync(datePath)) {
         fs6.mkdirSync(datePath, { recursive: true });
       }
-      const id = generateLoreId(rootDir, dateStr);
+      const author = resolveAuthor();
+      const timestamp = `${dateStr}T00:00:00.000Z`;
+      const id = generateLoreId(rootDir, dateStr, author, timestamp);
       const oldType = String(raw.type || "agent-session");
       const v2Type = ["agent-session", "human-note", "decision", "review", "incident", "milestone"].includes(oldType) ? oldType : "agent-session";
       let verification;
@@ -3555,9 +3641,10 @@ function migrateLegacyEntries(rootDir) {
       const v2Entry = {
         id,
         type: v2Type,
-        timestamp: `${dateStr}T00:00:00.000Z`,
-        author: { type: "agent", id: "unknown" },
-        title: String(raw.title || file.replace(".yaml", "")),
+        timestamp,
+        author: "unknown",
+        agent: { provider: "unknown", model: "unknown" },
+        title: String(raw.title || file.replace(/\.(yaml|lore)$/, "")),
         summary: String(raw.summary || ""),
         symbols_touched: Array.isArray(raw.symbols_touched) ? raw.symbols_touched : [],
         files_modified: Array.isArray(raw.files_modified) ? raw.files_modified : void 0,
@@ -3565,7 +3652,7 @@ function migrateLegacyEntries(rootDir) {
         tags: ["migrated", oldType]
       };
       fs6.writeFileSync(
-        path7.join(datePath, `${id}.yaml`),
+        path7.join(datePath, `${id}.lore`),
         yaml5.dump(v2Entry, { lineWidth: -1, noRefs: true })
       );
       fs6.unlinkSync(filePath);
@@ -3579,8 +3666,8 @@ async function updateLoreEntry(rootDir, entryId, partial) {
   const entry = await loadLoreEntry(rootDir, entryId);
   if (!entry) return false;
   const dateStr = entry.timestamp.slice(0, 10);
-  const entryPath = path7.join(rootDir, LORE_DIR, ENTRIES_DIR, dateStr, `${entryId}.yaml`);
-  if (!fs6.existsSync(entryPath)) return false;
+  const entryPath = resolveEntryPath(rootDir, dateStr, entryId);
+  if (!entryPath) return false;
   if (partial.title !== void 0) entry.title = partial.title;
   if (partial.summary !== void 0) entry.summary = partial.summary;
   if (partial.type !== void 0) entry.type = partial.type;
@@ -3605,11 +3692,11 @@ async function deleteLoreEntry(rootDir, entryId) {
   const entry = await loadLoreEntry(rootDir, entryId);
   if (!entry) return false;
   const dateStr = entry.timestamp.slice(0, 10);
-  const entryPath = path7.join(rootDir, LORE_DIR, ENTRIES_DIR, dateStr, `${entryId}.yaml`);
-  if (!fs6.existsSync(entryPath)) return false;
+  const entryPath = resolveEntryPath(rootDir, dateStr, entryId);
+  if (!entryPath) return false;
   fs6.unlinkSync(entryPath);
   const dateDir = path7.dirname(entryPath);
-  const remaining = fs6.readdirSync(dateDir).filter((f) => f.endsWith(".yaml"));
+  const remaining = fs6.readdirSync(dateDir).filter(isLoreFile);
   if (remaining.length === 0) {
     fs6.rmdirSync(dateDir);
   }
@@ -3619,10 +3706,16 @@ async function deleteLoreEntry(rootDir, entryId) {
 function applyFilter(entries, filter) {
   let result = entries;
   if (filter.author) {
-    result = result.filter((e) => e.author.id === filter.author);
+    result = result.filter((e) => e.author === filter.author);
   }
-  if (filter.authorType) {
-    result = result.filter((e) => e.author.type === filter.authorType);
+  if (filter.hasAgent !== void 0) {
+    result = result.filter(
+      (e) => filter.hasAgent ? e.agent != null : e.agent == null
+    );
+  } else if (filter.authorType) {
+    result = result.filter(
+      (e) => filter.authorType === "agent" ? e.agent != null : e.agent == null
+    );
   }
   if (filter.symbol) {
     result = result.filter(
@@ -3651,17 +3744,24 @@ function applyFilter(entries, filter) {
   if (filter.limit) result = result.slice(0, filter.limit);
   return result;
 }
-function generateLoreId(rootDir, dateStr) {
+function generateLoreId(rootDir, dateStr, author, timestamp) {
+  const sanitized = sanitizeAuthor(author);
+  const ts = new Date(timestamp);
+  const hh = String(ts.getUTCHours()).padStart(2, "0");
+  const mm = String(ts.getUTCMinutes()).padStart(2, "0");
+  const ss = String(ts.getUTCSeconds()).padStart(2, "0");
+  const timeStr = `${hh}${mm}${ss}`;
+  const prefix = `L-${dateStr}-${sanitized}-${timeStr}`;
   const datePath = path7.join(rootDir, LORE_DIR, ENTRIES_DIR, dateStr);
   if (!fs6.existsSync(datePath)) {
-    return `L-${dateStr}-001`;
+    return `${prefix}-001`;
   }
-  const existing = fs6.readdirSync(datePath).filter((f) => f.startsWith("L-") && f.endsWith(".yaml")).map((f) => {
-    const match = f.match(/L-\d{4}-\d{2}-\d{2}-(\d+)\.yaml/);
+  const existing = fs6.readdirSync(datePath).filter((f) => f.startsWith(prefix) && isLoreFile(f)).map((f) => {
+    const match = f.match(/-(\d{3})\.(yaml|lore)$/);
     return match ? parseInt(match[1], 10) : 0;
   });
   const next = existing.length > 0 ? Math.max(...existing) + 1 : 1;
-  return `L-${dateStr}-${String(next).padStart(3, "0")}`;
+  return `${prefix}-${String(next).padStart(3, "0")}`;
 }
 
 // ../paradigm-mcp/src/utils/aspect-lore-bridge.ts
@@ -4470,7 +4570,7 @@ function assertStep(step, event) {
 async function validateAgainstSentinel(persona, options = {}) {
   const steps = [];
   try {
-    const { SentinelStorage } = await import("./dist-YHDSIZQD.js");
+    const { SentinelStorage } = await import("./dist-IKBGY7FQ.js");
     const storage = new SentinelStorage();
     const events = storage.queryEvents?.({
       schemaId: "paradigm-personas",

package/dist/{chunk-6GWRQWQB.js → chunk-YHRRJM6J.js}

@@ -3,23 +3,52 @@ import {
   __require
 } from "./chunk-ZXMDA7VB.js";
 
+// src/core/lore/resolve-author.ts
+import { execSync } from "child_process";
+import * as os from "os";
+function sanitizeAuthor(name) {
+  return name.toLowerCase().replace(/[^a-z0-9-]/g, "-").replace(/-+/g, "-").replace(/^-|-$/g, "").slice(0, 20) || "unknown";
+}
+function resolveAuthor() {
+  const envAuthor = process.env.PARADIGM_AUTHOR;
+  if (envAuthor) return sanitizeAuthor(envAuthor);
+  try {
+    const gitName = execSync("git config user.name", { encoding: "utf-8", timeout: 3e3 }).trim();
+    if (gitName) return sanitizeAuthor(gitName);
+  } catch {
+  }
+  try {
+    const username = os.userInfo().username;
+    if (username) return sanitizeAuthor(username);
+  } catch {
+  }
+  return "unknown";
+}
+
 // src/core/lore/storage.ts
 import * as fs from "fs";
 import * as path from "path";
 import * as yaml from "js-yaml";
+import { execSync as execSync2 } from "child_process";
 
 // src/core/lore/filter.ts
 function applyLoreFilter(entries, filter) {
   let result = entries;
   if (filter.author) {
-    result = result.filter((e) => e.author.id === filter.author);
+    result = result.filter((e) => e.author === filter.author);
   }
-  if (filter.authorType) {
-    result = result.filter((e) => e.author.type === filter.authorType);
+  if (filter.hasAgent !== void 0) {
+    result = result.filter(
+      (e) => filter.hasAgent ? e.agent != null : e.agent == null
+    );
+  } else if (filter.authorType) {
+    result = result.filter(
+      (e) => filter.authorType === "agent" ? e.agent != null : e.agent == null
+    );
   }
   if (filter.symbol) {
     result = result.filter(
-      (e) => e.symbols_touched.includes(filter.symbol) || e.symbols_created?.includes(filter.symbol)
+      (e) => e.symbols_touched?.includes(filter.symbol) || e.symbols_created?.includes(filter.symbol)
     );
   }
   if (filter.dateFrom) {
@@ -58,10 +87,65 @@ function applyLoreFilter(entries, filter) {
   return result;
 }
 
+// src/core/lore/normalize.ts
+function inferProvider(model) {
+  const lower = model.toLowerCase();
+  if (lower.includes("claude") || lower.includes("anthropic")) return "anthropic";
+  if (lower.includes("gpt") || lower.includes("openai") || lower.includes("o1") || lower.includes("o3")) return "openai";
+  if (lower.includes("gemini") || lower.includes("google") || lower.includes("palm")) return "google";
+  if (lower.includes("llama") || lower.includes("meta")) return "meta";
+  if (lower.includes("mistral") || lower.includes("mixtral")) return "mistral";
+  if (lower.includes("deepseek")) return "deepseek";
+  if (lower.includes("cohere") || lower.includes("command")) return "cohere";
+  return "unknown";
+}
+function normalizeLoreEntry(raw) {
+  const entry = raw;
+  const author = entry.author;
+  if (typeof author === "string") {
+    return raw;
+  }
+  if (author && typeof author === "object" && !Array.isArray(author)) {
+    const old = author;
+    if (old.type === "agent") {
+      entry.author = "unknown";
+      entry.agent = {
+        provider: old.model ? inferProvider(old.model) : inferProvider(old.id),
+        model: old.model || old.id
+      };
+    } else {
+      entry.author = old.id || "unknown";
+    }
+    delete entry.assistedBy;
+  }
+  return entry;
+}
+
 // src/core/lore/storage.ts
 var LORE_DIR = ".paradigm/lore";
 var ENTRIES_DIR = "entries";
 var TIMELINE_FILE = "timeline.yaml";
+function isLoreFile(filename) {
+  return filename.endsWith(".yaml") || filename.endsWith(".lore");
+}
+function resolveEntryPath(rootDir, dateStr, entryId) {
+  const dirPath = path.join(rootDir, LORE_DIR, ENTRIES_DIR, dateStr);
+  const lorePath = path.join(dirPath, `${entryId}.lore`);
+  if (fs.existsSync(lorePath)) return lorePath;
+  const yamlPath = path.join(dirPath, `${entryId}.yaml`);
+  if (fs.existsSync(yamlPath)) return yamlPath;
+  return null;
+}
+function captureGitContext(cwd) {
+  try {
+    const ref = execSync2("git rev-parse HEAD", { cwd, encoding: "utf8", stdio: ["pipe", "pipe", "pipe"] }).trim();
+    const branch = execSync2("git rev-parse --abbrev-ref HEAD", { cwd, encoding: "utf8", stdio: ["pipe", "pipe", "pipe"] }).trim();
+    const status = execSync2("git status --porcelain", { cwd, encoding: "utf8", stdio: ["pipe", "pipe", "pipe"] }).trim();
+    return { ref, branch, dirty: status.length > 0 };
+  } catch {
+    return void 0;
+  }
+}
 function validateLoreSymbols(rootDir, symbols) {
   const result = { unregistered: [], warnings: [] };
   if (symbols.length === 0) return result;
@@ -129,10 +213,16 @@ async function recordLore(rootDir, entry, options) {
   if (!fs.existsSync(datePath)) {
     fs.mkdirSync(datePath, { recursive: true });
   }
+  if (!entry.author) {
+    entry.author = resolveAuthor();
+  }
+  if (!entry.git_context) {
+    entry.git_context = captureGitContext(rootDir);
+  }
   if (!entry.id) {
-    entry.id = generateLoreId(rootDir, dateStr);
+    entry.id = generateLoreId(rootDir, dateStr, entry.author, entry.timestamp);
   }
-  const entryPath = path.join(datePath, `${entry.id}.yaml`);
+  const entryPath = path.join(datePath, `${entry.id}.lore`);
   fs.writeFileSync(entryPath, yaml.dump(entry, { lineWidth: -1, noRefs: true }));
   await rebuildTimeline(rootDir);
   return { validation };
@@ -149,12 +239,12 @@ async function loadLoreEntries(rootDir, filter) {
     if (filter?.dateFrom && dateDir < filter.dateFrom.slice(0, 10)) continue;
     if (filter?.dateTo && dateDir > filter.dateTo.slice(0, 10)) continue;
     const dirPath = path.join(entriesPath, dateDir);
-    const files = fs.readdirSync(dirPath).filter((f) => f.endsWith(".yaml")).sort();
+    const files = fs.readdirSync(dirPath).filter(isLoreFile).sort();
     for (const file of files) {
       try {
         const content = fs.readFileSync(path.join(dirPath, file), "utf8");
-        const entry = yaml.load(content);
-        entries.push(entry);
+        const raw = yaml.load(content);
+        entries.push(normalizeLoreEntry(raw));
       } catch {
       }
     }
@@ -174,12 +264,13 @@ async function rebuildTimeline(rootDir) {
   const dateDirs = fs.readdirSync(entriesPath).filter((d) => /^\d{4}-\d{2}-\d{2}$/.test(d));
   for (const dateDir of dateDirs) {
     const dirPath = path.join(entriesPath, dateDir);
-    const files = fs.readdirSync(dirPath).filter((f) => f.endsWith(".yaml"));
+    const files = fs.readdirSync(dirPath).filter(isLoreFile);
     for (const file of files) {
       try {
         const content = fs.readFileSync(path.join(dirPath, file), "utf8");
-        const entry = yaml.load(content);
-        authors.add(entry.author.id);
+        const raw = yaml.load(content);
+        const entry = normalizeLoreEntry(raw);
+        authors.add(entry.author);
         entryCount++;
         if (!lastUpdated || entry.timestamp > lastUpdated) {
           lastUpdated = entry.timestamp;
@@ -219,8 +310,8 @@ async function addReview(rootDir, entryId, review) {
     return false;
   }
   const dateStr = entry.timestamp.slice(0, 10);
-  const entryPath = path.join(rootDir, LORE_DIR, ENTRIES_DIR, dateStr, `${entryId}.yaml`);
-  if (!fs.existsSync(entryPath)) {
+  const entryPath = resolveEntryPath(rootDir, dateStr, entryId);
+  if (!entryPath) {
     return false;
   }
   entry.review = review;
@@ -231,11 +322,12 @@ async function loadLoreEntry(rootDir, entryId) {
   const dateMatch = entryId.match(/^L-(\d{4}-\d{2}-\d{2})-/);
   if (dateMatch) {
     const dateStr = dateMatch[1];
-    const entryPath = path.join(rootDir, LORE_DIR, ENTRIES_DIR, dateStr, `${entryId}.yaml`);
-    if (fs.existsSync(entryPath)) {
+    const entryPath = resolveEntryPath(rootDir, dateStr, entryId);
+    if (entryPath) {
       try {
         const content = fs.readFileSync(entryPath, "utf8");
-        return yaml.load(content);
+        const raw = yaml.load(content);
+        return normalizeLoreEntry(raw);
       } catch {
         return null;
       }
@@ -248,8 +340,8 @@ async function updateLoreEntry(rootDir, entryId, partial) {
   const entry = await loadLoreEntry(rootDir, entryId);
   if (!entry) return false;
   const dateStr = entry.timestamp.slice(0, 10);
-  const entryPath = path.join(rootDir, LORE_DIR, ENTRIES_DIR, dateStr, `${entryId}.yaml`);
-  if (!fs.existsSync(entryPath)) return false;
+  const entryPath = resolveEntryPath(rootDir, dateStr, entryId);
+  if (!entryPath) return false;
   if (partial.title !== void 0) entry.title = partial.title;
   if (partial.summary !== void 0) entry.summary = partial.summary;
   if (partial.type !== void 0) entry.type = partial.type;
@@ -274,11 +366,11 @@ async function deleteLoreEntry(rootDir, entryId) {
   const entry = await loadLoreEntry(rootDir, entryId);
   if (!entry) return false;
   const dateStr = entry.timestamp.slice(0, 10);
-  const entryPath = path.join(rootDir, LORE_DIR, ENTRIES_DIR, dateStr, `${entryId}.yaml`);
-  if (!fs.existsSync(entryPath)) return false;
+  const entryPath = resolveEntryPath(rootDir, dateStr, entryId);
+  if (!entryPath) return false;
   fs.unlinkSync(entryPath);
   const dateDir = path.dirname(entryPath);
-  const remaining = fs.readdirSync(dateDir).filter((f) => f.endsWith(".yaml"));
+  const remaining = fs.readdirSync(dateDir).filter(isLoreFile);
   if (remaining.length === 0) {
     fs.rmdirSync(dateDir);
   }
@@ -288,7 +380,7 @@ async function deleteLoreEntry(rootDir, entryId) {
 function migrateLegacyEntries(rootDir) {
   const entriesPath = path.join(rootDir, LORE_DIR, ENTRIES_DIR);
   if (!fs.existsSync(entriesPath)) return 0;
-  const rootFiles = fs.readdirSync(entriesPath).filter((f) => f.endsWith(".yaml") && !f.startsWith("."));
+  const rootFiles = fs.readdirSync(entriesPath).filter((f) => isLoreFile(f) && !f.startsWith("."));
   let migrated = 0;
   for (const file of rootFiles) {
     const filePath = path.join(entriesPath, file);
@@ -298,12 +390,15 @@ function migrateLegacyEntries(rootDir) {
       const content = fs.readFileSync(filePath, "utf8");
       const raw = yaml.load(content);
       if (raw.author && typeof raw.author === "object") continue;
+      if (typeof raw.author === "string" && raw.timestamp) continue;
       const dateStr = typeof raw.date === "string" ? raw.date.slice(0, 10) : (/* @__PURE__ */ new Date()).toISOString().slice(0, 10);
       const datePath = path.join(entriesPath, dateStr);
       if (!fs.existsSync(datePath)) {
         fs.mkdirSync(datePath, { recursive: true });
       }
-      const id = generateLoreId(rootDir, dateStr);
+      const author = resolveAuthor();
+      const timestamp = `${dateStr}T00:00:00.000Z`;
+      const id = generateLoreId(rootDir, dateStr, author, timestamp);
       const oldType = String(raw.type || "agent-session");
       const v2Type = ["agent-session", "human-note", "decision", "review", "incident", "milestone"].includes(oldType) ? oldType : "agent-session";
       let verification;
@@ -317,9 +412,10 @@ function migrateLegacyEntries(rootDir) {
       const v2Entry = {
         id,
         type: v2Type,
-        timestamp: `${dateStr}T00:00:00.000Z`,
-        author: { type: "agent", id: "unknown" },
-        title: String(raw.title || file.replace(".yaml", "")),
+        timestamp,
+        author: "unknown",
+        agent: { provider: "unknown", model: "unknown" },
+        title: String(raw.title || file.replace(/\.(yaml|lore)$/, "")),
         summary: String(raw.summary || ""),
         symbols_touched: Array.isArray(raw.symbols_touched) ? raw.symbols_touched : [],
         files_modified: Array.isArray(raw.files_modified) ? raw.files_modified : void 0,
@@ -327,7 +423,7 @@ function migrateLegacyEntries(rootDir) {
         tags: ["migrated", oldType]
       };
       fs.writeFileSync(
-        path.join(datePath, `${id}.yaml`),
+        path.join(datePath, `${id}.lore`),
         yaml.dump(v2Entry, { lineWidth: -1, noRefs: true })
       );
       fs.unlinkSync(filePath);
@@ -337,20 +433,28 @@ function migrateLegacyEntries(rootDir) {
   }
   return migrated;
 }
-function generateLoreId(rootDir, dateStr) {
+function generateLoreId(rootDir, dateStr, author, timestamp) {
+  const sanitized = sanitizeAuthor(author);
+  const ts = new Date(timestamp);
+  const hh = String(ts.getUTCHours()).padStart(2, "0");
+  const mm = String(ts.getUTCMinutes()).padStart(2, "0");
+  const ss = String(ts.getUTCSeconds()).padStart(2, "0");
+  const timeStr = `${hh}${mm}${ss}`;
+  const prefix = `L-${dateStr}-${sanitized}-${timeStr}`;
   const datePath = path.join(rootDir, LORE_DIR, ENTRIES_DIR, dateStr);
   if (!fs.existsSync(datePath)) {
-    return `L-${dateStr}-001`;
+    return `${prefix}-001`;
   }
-  const existing = fs.readdirSync(datePath).filter((f) => f.startsWith("L-") && f.endsWith(".yaml")).map((f) => {
-    const match = f.match(/L-\d{4}-\d{2}-\d{2}-(\d+)\.yaml/);
+  const existing = fs.readdirSync(datePath).filter((f) => f.startsWith(prefix) && isLoreFile(f)).map((f) => {
+    const match = f.match(/-(\d{3})\.(yaml|lore)$/);
     return match ? parseInt(match[1], 10) : 0;
   });
   const next = existing.length > 0 ? Math.max(...existing) + 1 : 1;
-  return `L-${dateStr}-${String(next).padStart(3, "0")}`;
+  return `${prefix}-${String(next).padStart(3, "0")}`;
 }
 
 export {
+  resolveAuthor,
   recordLore,
   loadLoreEntries,
   addReview,