@askexenow/exe-os 0.9.61 → 0.9.63

package/dist/hooks/session-end.js

@@ -257,8 +257,8 @@ var init_config = __esm({
         rerankerAutoTrigger: {
           enabled: true,
           broadQueryMinCardinality: 5e4,
-          fetchTopK: 150,
-          returnTopK: 5
+          fetchTopK: 200,
+          returnTopK: 20
         }
       },
       graphRagEnabled: true,
@@ -3302,6 +3302,51 @@ async function ensureSchema() {
       VALUES (new.rowid, new.content_text, new.sender_name, new.agent_response);
     END;
   `);
+  await client.executeMultiple(`
+    CREATE TABLE IF NOT EXISTS memory_cards (
+      id            TEXT PRIMARY KEY,
+      memory_id     TEXT NOT NULL,
+      agent_id      TEXT NOT NULL,
+      session_id    TEXT NOT NULL,
+      project_name  TEXT,
+      timestamp     TEXT NOT NULL,
+      card_type     TEXT NOT NULL,
+      subject       TEXT,
+      predicate     TEXT,
+      object        TEXT,
+      content       TEXT NOT NULL,
+      source_ref    TEXT,
+      confidence    REAL DEFAULT 0.6,
+      active        INTEGER DEFAULT 1,
+      created_at    TEXT NOT NULL
+    );
+
+    CREATE INDEX IF NOT EXISTS idx_memory_cards_agent
+      ON memory_cards(agent_id, active, timestamp);
+
+    CREATE INDEX IF NOT EXISTS idx_memory_cards_memory
+      ON memory_cards(memory_id);
+
+    CREATE VIRTUAL TABLE IF NOT EXISTS memory_cards_fts
+      USING fts5(content, subject, predicate, object, content='memory_cards', content_rowid='rowid');
+
+    CREATE TRIGGER IF NOT EXISTS memory_cards_fts_ai AFTER INSERT ON memory_cards BEGIN
+      INSERT INTO memory_cards_fts(rowid, content, subject, predicate, object)
+      VALUES (new.rowid, new.content, new.subject, new.predicate, new.object);
+    END;
+
+    CREATE TRIGGER IF NOT EXISTS memory_cards_fts_ad AFTER DELETE ON memory_cards BEGIN
+      INSERT INTO memory_cards_fts(memory_cards_fts, rowid, content, subject, predicate, object)
+      VALUES('delete', old.rowid, old.content, old.subject, old.predicate, old.object);
+    END;
+
+    CREATE TRIGGER IF NOT EXISTS memory_cards_fts_au AFTER UPDATE ON memory_cards BEGIN
+      INSERT INTO memory_cards_fts(memory_cards_fts, rowid, content, subject, predicate, object)
+      VALUES('delete', old.rowid, old.content, old.subject, old.predicate, old.object);
+      INSERT INTO memory_cards_fts(rowid, content, subject, predicate, object)
+      VALUES (new.rowid, new.content, new.subject, new.predicate, new.object);
+    END;
+  `);
   try {
     await client.execute({
       sql: `ALTER TABLE memories ADD COLUMN tier INTEGER DEFAULT 3`,
@@ -6889,15 +6934,15 @@ var init_task_scope = __esm({
 
 // src/lib/keychain.ts
 import { readFile as readFile4, writeFile as writeFile5, unlink, mkdir as mkdir4, chmod as chmod2 } from "fs/promises";
-import { existsSync as existsSync17 } from "fs";
+import { existsSync as existsSync18 } from "fs";
 import { execSync as execSync8 } from "child_process";
-import path21 from "path";
+import path22 from "path";
 import os13 from "os";
 function getKeyDir() {
-  return process.env.EXE_OS_DIR ?? process.env.EXE_MEM_DIR ?? path21.join(os13.homedir(), ".exe-os");
+  return process.env.EXE_OS_DIR ?? process.env.EXE_MEM_DIR ?? path22.join(os13.homedir(), ".exe-os");
 }
 function getKeyPath() {
-  return path21.join(getKeyDir(), "master.key");
+  return path22.join(getKeyDir(), "master.key");
 }
 function macKeychainGet() {
   if (process.platform !== "darwin") return null;
@@ -7045,7 +7090,7 @@ async function getMasterKey() {
     }
   }
   const keyPath = getKeyPath();
-  if (!existsSync17(keyPath)) {
+  if (!existsSync18(keyPath)) {
     process.stderr.write(
       `[keychain] Key not found at ${keyPath} (HOME=${os13.homedir()}, EXE_OS_DIR=${process.env.EXE_OS_DIR ?? "unset"})
 `
@@ -7319,12 +7364,12 @@ __export(shard_manager_exports, {
   listShards: () => listShards,
   shardExists: () => shardExists
 });
-import path22 from "path";
-import { existsSync as existsSync18, mkdirSync as mkdirSync10, readdirSync as readdirSync5, renameSync as renameSync4, statSync as statSync2 } from "fs";
+import path23 from "path";
+import { existsSync as existsSync19, mkdirSync as mkdirSync10, readdirSync as readdirSync5, renameSync as renameSync5, statSync as statSync3 } from "fs";
 import { createClient as createClient2 } from "@libsql/client";
 function initShardManager(encryptionKey) {
   _encryptionKey = encryptionKey;
-  if (!existsSync18(SHARDS_DIR)) {
+  if (!existsSync19(SHARDS_DIR)) {
     mkdirSync10(SHARDS_DIR, { recursive: true });
   }
   _shardingEnabled = true;
@@ -7354,7 +7399,7 @@ function getShardClient(projectName) {
   while (_shards.size >= MAX_OPEN_SHARDS) {
     evictLRU();
   }
-  const dbPath = path22.join(SHARDS_DIR, `${safeName}.db`);
+  const dbPath = path23.join(SHARDS_DIR, `${safeName}.db`);
   const client = createClient2({
     url: `file:${dbPath}`,
     encryptionKey: _encryptionKey
@@ -7365,13 +7410,13 @@ function getShardClient(projectName) {
 }
 function shardExists(projectName) {
   const safeName = safeShardName(projectName);
-  return existsSync18(path22.join(SHARDS_DIR, `${safeName}.db`));
+  return existsSync19(path23.join(SHARDS_DIR, `${safeName}.db`));
 }
 function safeShardName(projectName) {
   return projectName.replace(/[^a-zA-Z0-9_-]/g, "_");
 }
 function listShards() {
-  if (!existsSync18(SHARDS_DIR)) return [];
+  if (!existsSync19(SHARDS_DIR)) return [];
   return readdirSync5(SHARDS_DIR).filter((f) => f.endsWith(".db")).map((f) => f.replace(".db", ""));
 }
 async function auditShardHealth(options = {}) {
@@ -7383,8 +7428,8 @@ async function auditShardHealth(options = {}) {
   const names = listShards();
   const shards = [];
   for (const name of names) {
-    const dbPath = path22.join(SHARDS_DIR, `${name}.db`);
-    const stat = statSync2(dbPath);
+    const dbPath = path23.join(SHARDS_DIR, `${name}.db`);
+    const stat = statSync3(dbPath);
     const item = {
       name,
       path: dbPath,
@@ -7418,8 +7463,8 @@ async function auditShardHealth(options = {}) {
         _shards.delete(name);
         _shardLastAccess.delete(name);
         const stamp = (/* @__PURE__ */ new Date()).toISOString().replace(/[:.]/g, "-");
-        const archivedPath = path22.join(SHARDS_DIR, `${name}.db.broken-${stamp}`);
-        renameSync4(dbPath, archivedPath);
+        const archivedPath = path23.join(SHARDS_DIR, `${name}.db.broken-${stamp}`);
+        renameSync5(dbPath, archivedPath);
         item.archivedPath = archivedPath;
       }
     } finally {
@@ -7635,12 +7680,12 @@ async function getReadyShardClient(projectName) {
     client.close();
     _shards.delete(safeName);
     _shardLastAccess.delete(safeName);
-    const dbPath = path22.join(SHARDS_DIR, `${safeName}.db`);
-    if (existsSync18(dbPath)) {
-      const stat = statSync2(dbPath);
+    const dbPath = path23.join(SHARDS_DIR, `${safeName}.db`);
+    if (existsSync19(dbPath)) {
+      const stat = statSync3(dbPath);
       const stamp = (/* @__PURE__ */ new Date()).toISOString().replace(/[:.]/g, "-");
-      const archivedPath = path22.join(SHARDS_DIR, `${safeName}.db.broken-${stamp}`);
-      renameSync4(dbPath, archivedPath);
+      const archivedPath = path23.join(SHARDS_DIR, `${safeName}.db.broken-${stamp}`);
+      renameSync5(dbPath, archivedPath);
       process.stderr.write(
         `[shard-manager] Archived unreadable shard ${safeName}: ${archivedPath} (${stat.size} bytes, mtime ${stat.mtime.toISOString()})
 `
@@ -7707,7 +7752,7 @@ var init_shard_manager = __esm({
   "src/lib/shard-manager.ts"() {
     "use strict";
     init_config();
-    SHARDS_DIR = path22.join(EXE_AI_DIR, "shards");
+    SHARDS_DIR = path23.join(EXE_AI_DIR, "shards");
     SHARD_IDLE_MS = 5 * 60 * 1e3;
     MAX_OPEN_SHARDS = 10;
     EVICTION_INTERVAL_MS = 60 * 1e3;
@@ -7974,6 +8019,164 @@ ${p.content}`).join("\n\n");
   }
 });
 
+// src/lib/memory-cards.ts
+var memory_cards_exports = {};
+__export(memory_cards_exports, {
+  extractMemoryCards: () => extractMemoryCards,
+  insertMemoryCardsForBatch: () => insertMemoryCardsForBatch,
+  searchMemoryCards: () => searchMemoryCards
+});
+import { createHash as createHash2 } from "crypto";
+function stableId(memoryId, type, content) {
+  return createHash2("sha256").update(`${memoryId}:${type}:${content}`).digest("hex").slice(0, 32);
+}
+function cleanText(text) {
+  return text.replace(/```[\s\S]*?```/g, " ").replace(/<[^>]+>/g, " ").replace(/\s+/g, " ").trim();
+}
+function splitSentences(text) {
+  return cleanText(text).split(/(?<=[.!?])\s+|\n+/).map((s) => s.trim()).filter((s) => s.length >= 24 && s.length <= MAX_SENTENCE_CHARS);
+}
+function inferCardType(sentence, toolName) {
+  const lower = sentence.toLowerCase();
+  if (toolName === "store_decision" || /\b(decided|decision|adr|approved|rejected)\b/.test(lower)) return "decision";
+  if (/\b(prefers|preference|likes|dislikes|wants|doesn't want|does not want)\b/.test(lower)) return "preference";
+  if (/\b(changed|updated|replaced|now|no longer|instead|supersedes)\b/.test(lower)) return "belief_update";
+  if (toolName && ["Read", "Write", "Edit", "Bash"].includes(toolName)) return "code";
+  if (/\b(meeting|deadline|shipped|launched|completed|failed|blocked|assigned|created)\b/.test(lower)) return "event";
+  return "fact";
+}
+function extractSubject(sentence, agentId) {
+  const explicit = sentence.match(/\b([A-Z][a-zA-Z0-9_-]{2,}(?:\s+[A-Z][a-zA-Z0-9_-]{2,})?)\b/);
+  return explicit?.[1] ?? agentId;
+}
+function predicateFor(type) {
+  switch (type) {
+    case "preference":
+      return "prefers";
+    case "belief_update":
+      return "updated";
+    case "decision":
+      return "decided";
+    case "event":
+      return "happened";
+    case "code":
+      return "implemented";
+    default:
+      return "states";
+  }
+}
+function extractMemoryCards(row) {
+  const sentences = splitSentences(row.raw_text);
+  const cards = [];
+  for (const sentence of sentences) {
+    const type = inferCardType(sentence, row.tool_name);
+    const subject = extractSubject(sentence, row.agent_id);
+    const content = sentence.length > MAX_SENTENCE_CHARS ? `${sentence.slice(0, MAX_SENTENCE_CHARS - 1)}\u2026` : sentence;
+    cards.push({
+      id: stableId(row.id, type, content),
+      memory_id: row.id,
+      agent_id: row.agent_id,
+      session_id: row.session_id,
+      project_name: row.project_name ?? null,
+      timestamp: row.timestamp,
+      card_type: type,
+      subject,
+      predicate: predicateFor(type),
+      object: content,
+      content,
+      source_ref: row.id,
+      confidence: type === "fact" ? 0.55 : 0.65
+    });
+    if (cards.length >= MAX_CARDS_PER_MEMORY) break;
+  }
+  return cards;
+}
+async function insertMemoryCardsForBatch(rows) {
+  const cards = rows.flatMap(extractMemoryCards);
+  if (cards.length === 0) return 0;
+  const now = (/* @__PURE__ */ new Date()).toISOString();
+  const client = getClient();
+  const stmts = cards.map((card) => ({
+    sql: `INSERT OR IGNORE INTO memory_cards
+          (id, memory_id, agent_id, session_id, project_name, timestamp, card_type,
+           subject, predicate, object, content, source_ref, confidence, active, created_at)
+          VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, 1, ?)`,
+    args: [
+      card.id,
+      card.memory_id,
+      card.agent_id,
+      card.session_id,
+      card.project_name,
+      card.timestamp,
+      card.card_type,
+      card.subject,
+      card.predicate,
+      card.object,
+      card.content,
+      card.source_ref,
+      card.confidence,
+      now
+    ]
+  }));
+  await client.batch(stmts, "write");
+  return cards.length;
+}
+function buildMatchExpr(queryText) {
+  const terms = queryText.toLowerCase().split(/\s+/).filter((t) => t.length >= 3).map((t) => t.replace(/[^a-z0-9_]/g, "")).filter((t) => t.length >= 3).slice(0, 12);
+  if (terms.length === 0) return null;
+  return terms.map((t) => `${t}*`).join(terms.length >= 3 ? " AND " : " OR ");
+}
+async function searchMemoryCards(queryText, agentId, options) {
+  const limit = options?.limit ?? 10;
+  const matchExpr = buildMatchExpr(queryText);
+  if (!matchExpr) return [];
+  let sql = `SELECT c.id, c.memory_id, c.agent_id, c.session_id, c.project_name,
+                    c.timestamp, c.card_type, c.content, c.source_ref, c.confidence
+             FROM memory_cards c
+             JOIN memory_cards_fts fts ON c.rowid = fts.rowid
+             WHERE memory_cards_fts MATCH ?
+               AND c.agent_id = ?
+               AND COALESCE(c.active, 1) = 1`;
+  const args = [matchExpr, agentId];
+  if (options?.projectName) {
+    sql += ` AND c.project_name = ?`;
+    args.push(options.projectName);
+  }
+  if (options?.since) {
+    sql += ` AND c.timestamp >= ?`;
+    args.push(options.since);
+  }
+  sql += ` ORDER BY rank LIMIT ?`;
+  args.push(limit);
+  const result = await getClient().execute({ sql, args });
+  return result.rows.map((row) => ({
+    id: `card:${String(row.id)}`,
+    agent_id: String(row.agent_id),
+    agent_role: "memory_card",
+    session_id: String(row.session_id),
+    timestamp: String(row.timestamp),
+    tool_name: `memory_card:${String(row.card_type)}`,
+    project_name: row.project_name == null ? "" : String(row.project_name),
+    has_error: false,
+    raw_text: `[${String(row.card_type)}] ${String(row.content)}
+Source memory: ${String(row.source_ref ?? row.memory_id)}`,
+    vector: [],
+    importance: 6,
+    status: "active",
+    confidence: Number(row.confidence ?? 0.6),
+    last_accessed: String(row.timestamp)
+  }));
+}
+var MAX_CARDS_PER_MEMORY, MAX_SENTENCE_CHARS;
+var init_memory_cards = __esm({
+  "src/lib/memory-cards.ts"() {
+    "use strict";
+    init_database();
+    MAX_CARDS_PER_MEMORY = 6;
+    MAX_SENTENCE_CHARS = 360;
+  }
+});
+
 // src/lib/store.ts
 var store_exports = {};
 __export(store_exports, {
@@ -8312,6 +8515,11 @@ async function flushBatch() {
     const globalClient = getClient();
     const globalStmts = batch.map(buildStmt);
     await globalClient.batch(globalStmts, "write");
+    try {
+      const { insertMemoryCardsForBatch: insertMemoryCardsForBatch2 } = await Promise.resolve().then(() => (init_memory_cards(), memory_cards_exports));
+      await insertMemoryCardsForBatch2(batch);
+    } catch {
+    }
     schedulePostWriteMemoryHygiene(batch.map((row) => row.id));
     _pendingRecords.splice(0, batch.length);
     try {
@@ -8659,78 +8867,6 @@ var init_fast_db_init = __esm({
   }
 });
 
-// src/lib/memory-queue.ts
-import { appendFileSync as appendFileSync2, readFileSync as readFileSync15, renameSync as renameSync5, unlinkSync as unlinkSync9, existsSync as existsSync19, statSync as statSync3 } from "fs";
-import path23 from "path";
-function enqueueMemory(entry) {
-  appendFileSync2(QUEUE_PATH2, JSON.stringify(entry) + "\n");
-}
-var QUEUE_PATH2, PROCESSING_PATH, TTL_MS2;
-var init_memory_queue = __esm({
-  "src/lib/memory-queue.ts"() {
-    "use strict";
-    init_config();
-    QUEUE_PATH2 = path23.join(EXE_AI_DIR, "memory-queue.jsonl");
-    PROCESSING_PATH = QUEUE_PATH2 + ".processing";
-    TTL_MS2 = 24 * 60 * 60 * 1e3;
-  }
-});
-
-// src/lib/memory-queue-client.ts
-var memory_queue_client_exports = {};
-__export(memory_queue_client_exports, {
-  batchWriteMemoryViaDaemon: () => batchWriteMemoryViaDaemon,
-  writeMemoryViaDaemon: () => writeMemoryViaDaemon
-});
-async function writeMemoryViaDaemon(entry) {
-  if (process.env.EXE_IS_DAEMON === "1") {
-    enqueueMemory(entry);
-    return false;
-  }
-  if (!isClientConnected()) {
-    enqueueMemory(entry);
-    return false;
-  }
-  try {
-    const response = await sendDaemonRequest({
-      type: "write-memory",
-      entry
-    });
-    if (response.ok) return true;
-    enqueueMemory(entry);
-    return false;
-  } catch {
-    enqueueMemory(entry);
-    return false;
-  }
-}
-async function batchWriteMemoryViaDaemon(entries) {
-  if (entries.length === 0) return 0;
-  if (process.env.EXE_IS_DAEMON === "1" || !isClientConnected()) {
-    for (const entry of entries) enqueueMemory(entry);
-    return 0;
-  }
-  try {
-    const response = await sendDaemonRequest({
-      type: "batch-write-memory",
-      entries
-    });
-    if (response.ok) return response.count ?? entries.length;
-    for (const entry of entries) enqueueMemory(entry);
-    return 0;
-  } catch {
-    for (const entry of entries) enqueueMemory(entry);
-    return 0;
-  }
-}
-var init_memory_queue_client = __esm({
-  "src/lib/memory-queue-client.ts"() {
-    "use strict";
-    init_exe_daemon_client();
-    init_memory_queue();
-  }
-});
-
 // src/lib/git-staleness.ts
 var git_staleness_exports = {};
 __export(git_staleness_exports, {
@@ -9278,6 +9414,119 @@ function buildAutoCheckpoint(input2) {
   };
 }
 
+// src/lib/memory-queue-client.ts
+init_exe_daemon_client();
+
+// src/lib/memory-queue.ts
+init_config();
+import { appendFileSync as appendFileSync2, readFileSync as readFileSync15, renameSync as renameSync4, unlinkSync as unlinkSync9, existsSync as existsSync17, statSync as statSync2 } from "fs";
+import path21 from "path";
+var QUEUE_PATH2 = path21.join(EXE_AI_DIR, "memory-queue.jsonl");
+var PROCESSING_PATH = QUEUE_PATH2 + ".processing";
+var TTL_MS2 = 24 * 60 * 60 * 1e3;
+function enqueueMemory(entry) {
+  appendFileSync2(QUEUE_PATH2, JSON.stringify(entry) + "\n");
+}
+
+// src/lib/memory-queue-client.ts
+async function writeMemoryViaDaemon(entry) {
+  if (process.env.EXE_IS_DAEMON === "1") {
+    enqueueMemory(entry);
+    return false;
+  }
+  if (!isClientConnected()) {
+    enqueueMemory(entry);
+    return false;
+  }
+  try {
+    const response = await sendDaemonRequest({
+      type: "write-memory",
+      entry
+    });
+    if (response.ok) return true;
+    enqueueMemory(entry);
+    return false;
+  } catch {
+    enqueueMemory(entry);
+    return false;
+  }
+}
+
+// src/lib/checkpoint-orchestrator.ts
+function toolNameForReason(reason) {
+  switch (reason) {
+    case "periodic":
+      return "auto-summary";
+    case "session-end":
+      return "SessionEnd";
+    case "pre-compact":
+      return "pre-compact-hook";
+    case "capacity-signal":
+      return "auto-checkpoint";
+  }
+}
+function importanceForReason(reason, override) {
+  if (override !== void 0) return override;
+  switch (reason) {
+    case "periodic":
+      return 7;
+    case "session-end":
+    case "pre-compact":
+    case "capacity-signal":
+      return 8;
+  }
+}
+function buildContinuityCheckpoint(input2) {
+  const { checkpointText, decisionTexts } = buildAutoCheckpoint({
+    agentId: input2.agentId,
+    agentRole: input2.agentRole,
+    sessionId: input2.sessionId,
+    projectName: input2.projectName,
+    reason: input2.reason,
+    memories: input2.memories ?? [],
+    tasks: input2.tasks ?? [],
+    maxSamples: input2.maxSamples
+  });
+  const extra = input2.extraSections?.filter((section) => section.trim().length > 0) ?? [];
+  return {
+    checkpointText: extra.length > 0 ? `${checkpointText}
+
+${extra.join("\n\n")}` : checkpointText,
+    decisionTexts
+  };
+}
+async function writeContinuityCheckpoint(input2) {
+  const result = buildContinuityCheckpoint(input2);
+  const now = (/* @__PURE__ */ new Date()).toISOString();
+  await writeMemoryViaDaemon({
+    raw_text: result.checkpointText,
+    agent_id: input2.agentId,
+    agent_role: input2.agentRole,
+    session_id: input2.sessionId,
+    tool_name: toolNameForReason(input2.reason),
+    project_name: input2.projectName,
+    timestamp: now,
+    importance: importanceForReason(input2.reason, input2.importance),
+    task_id: input2.taskId,
+    memory_type: "checkpoint"
+  });
+  const decisionLimit = input2.reason === "periodic" ? 3 : 5;
+  for (const decisionText of result.decisionTexts.slice(0, decisionLimit)) {
+    await writeMemoryViaDaemon({
+      raw_text: decisionText,
+      agent_id: input2.agentId,
+      agent_role: input2.agentRole,
+      session_id: input2.sessionId,
+      tool_name: "auto-decision",
+      project_name: input2.projectName,
+      timestamp: (/* @__PURE__ */ new Date()).toISOString(),
+      importance: 8,
+      memory_type: "decision"
+    });
+  }
+  return result;
+}
+
 // src/adapters/claude/hooks/session-end.ts
 if (!process.env.AGENT_ID) {
   process.env.AGENT_ID = "default";
@@ -9327,7 +9576,7 @@ Orphaned tasks at session end: ${orphanResult.rows.map((r) => `"${String(r.title
                 ORDER BY priority ASC, updated_at DESC LIMIT 10`,
           args: [agent.agentId, ...seScope.args]
         });
-        const { checkpointText, decisionTexts } = buildAutoCheckpoint({
+        await writeContinuityCheckpoint({
           agentId: agent.agentId,
           agentRole: agent.agentRole,
           sessionId: data.session_id,
@@ -9335,35 +9584,9 @@ Orphaned tasks at session end: ${orphanResult.rows.map((r) => `"${String(r.title
           reason: "session-end",
           memories: recent.rows,
           tasks: taskRows.rows,
-          maxSamples: 12
-        });
-        const { writeMemoryViaDaemon: writeMemoryViaDaemon2 } = await Promise.resolve().then(() => (init_memory_queue_client(), memory_queue_client_exports));
-        await writeMemoryViaDaemon2({
-          raw_text: `${checkpointText}${orphanInfo ? `
-
-## Session-End Warnings${orphanInfo}` : ""}`,
-          agent_id: agent.agentId,
-          agent_role: agent.agentRole,
-          session_id: data.session_id,
-          tool_name: "SessionEnd",
-          project_name: projectName,
-          timestamp: (/* @__PURE__ */ new Date()).toISOString(),
-          importance: 8,
-          memory_type: "checkpoint"
+          maxSamples: 12,
+          extraSections: orphanInfo ? [`## Session-End Warnings${orphanInfo}`] : []
         });
-        for (const decisionText of decisionTexts.slice(0, 5)) {
-          await writeMemoryViaDaemon2({
-            raw_text: decisionText,
-            agent_id: agent.agentId,
-            agent_role: agent.agentRole,
-            session_id: data.session_id,
-            tool_name: "auto-decision",
-            project_name: projectName,
-            timestamp: (/* @__PURE__ */ new Date()).toISOString(),
-            importance: 8,
-            memory_type: "decision"
-          });
-        }
         try {
           const { clearSessionFileReads: clearSessionFileReads2 } = await Promise.resolve().then(() => (init_git_staleness(), git_staleness_exports));
           await clearSessionFileReads2(data.session_id);