@askexenow/exe-os 0.9.63 → 0.9.64

package/dist/hooks/session-end.js

@@ -6934,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 existsSync18 } from "fs";
+import { existsSync as existsSync17 } from "fs";
 import { execSync as execSync8 } from "child_process";
-import path22 from "path";
+import path21 from "path";
 import os13 from "os";
 function getKeyDir() {
-  return process.env.EXE_OS_DIR ?? process.env.EXE_MEM_DIR ?? path22.join(os13.homedir(), ".exe-os");
+  return process.env.EXE_OS_DIR ?? process.env.EXE_MEM_DIR ?? path21.join(os13.homedir(), ".exe-os");
 }
 function getKeyPath() {
-  return path22.join(getKeyDir(), "master.key");
+  return path21.join(getKeyDir(), "master.key");
 }
 function macKeychainGet() {
   if (process.platform !== "darwin") return null;
@@ -7090,7 +7090,7 @@ async function getMasterKey() {
     }
   }
   const keyPath = getKeyPath();
-  if (!existsSync18(keyPath)) {
+  if (!existsSync17(keyPath)) {
     process.stderr.write(
       `[keychain] Key not found at ${keyPath} (HOME=${os13.homedir()}, EXE_OS_DIR=${process.env.EXE_OS_DIR ?? "unset"})
 `
@@ -7364,12 +7364,12 @@ __export(shard_manager_exports, {
   listShards: () => listShards,
   shardExists: () => shardExists
 });
-import path23 from "path";
-import { existsSync as existsSync19, mkdirSync as mkdirSync10, readdirSync as readdirSync5, renameSync as renameSync5, statSync as statSync3 } from "fs";
+import path22 from "path";
+import { existsSync as existsSync18, mkdirSync as mkdirSync10, readdirSync as readdirSync5, renameSync as renameSync4, statSync as statSync2 } from "fs";
 import { createClient as createClient2 } from "@libsql/client";
 function initShardManager(encryptionKey) {
   _encryptionKey = encryptionKey;
-  if (!existsSync19(SHARDS_DIR)) {
+  if (!existsSync18(SHARDS_DIR)) {
     mkdirSync10(SHARDS_DIR, { recursive: true });
   }
   _shardingEnabled = true;
@@ -7399,7 +7399,7 @@ function getShardClient(projectName) {
   while (_shards.size >= MAX_OPEN_SHARDS) {
     evictLRU();
   }
-  const dbPath = path23.join(SHARDS_DIR, `${safeName}.db`);
+  const dbPath = path22.join(SHARDS_DIR, `${safeName}.db`);
   const client = createClient2({
     url: `file:${dbPath}`,
     encryptionKey: _encryptionKey
@@ -7410,13 +7410,13 @@ function getShardClient(projectName) {
 }
 function shardExists(projectName) {
   const safeName = safeShardName(projectName);
-  return existsSync19(path23.join(SHARDS_DIR, `${safeName}.db`));
+  return existsSync18(path22.join(SHARDS_DIR, `${safeName}.db`));
 }
 function safeShardName(projectName) {
   return projectName.replace(/[^a-zA-Z0-9_-]/g, "_");
 }
 function listShards() {
-  if (!existsSync19(SHARDS_DIR)) return [];
+  if (!existsSync18(SHARDS_DIR)) return [];
   return readdirSync5(SHARDS_DIR).filter((f) => f.endsWith(".db")).map((f) => f.replace(".db", ""));
 }
 async function auditShardHealth(options = {}) {
@@ -7428,8 +7428,8 @@ async function auditShardHealth(options = {}) {
   const names = listShards();
   const shards = [];
   for (const name of names) {
-    const dbPath = path23.join(SHARDS_DIR, `${name}.db`);
-    const stat = statSync3(dbPath);
+    const dbPath = path22.join(SHARDS_DIR, `${name}.db`);
+    const stat = statSync2(dbPath);
     const item = {
       name,
       path: dbPath,
@@ -7463,8 +7463,8 @@ async function auditShardHealth(options = {}) {
         _shards.delete(name);
         _shardLastAccess.delete(name);
         const stamp = (/* @__PURE__ */ new Date()).toISOString().replace(/[:.]/g, "-");
-        const archivedPath = path23.join(SHARDS_DIR, `${name}.db.broken-${stamp}`);
-        renameSync5(dbPath, archivedPath);
+        const archivedPath = path22.join(SHARDS_DIR, `${name}.db.broken-${stamp}`);
+        renameSync4(dbPath, archivedPath);
         item.archivedPath = archivedPath;
       }
     } finally {
@@ -7680,12 +7680,12 @@ async function getReadyShardClient(projectName) {
     client.close();
     _shards.delete(safeName);
     _shardLastAccess.delete(safeName);
-    const dbPath = path23.join(SHARDS_DIR, `${safeName}.db`);
-    if (existsSync19(dbPath)) {
-      const stat = statSync3(dbPath);
+    const dbPath = path22.join(SHARDS_DIR, `${safeName}.db`);
+    if (existsSync18(dbPath)) {
+      const stat = statSync2(dbPath);
       const stamp = (/* @__PURE__ */ new Date()).toISOString().replace(/[:.]/g, "-");
-      const archivedPath = path23.join(SHARDS_DIR, `${safeName}.db.broken-${stamp}`);
-      renameSync5(dbPath, archivedPath);
+      const archivedPath = path22.join(SHARDS_DIR, `${safeName}.db.broken-${stamp}`);
+      renameSync4(dbPath, archivedPath);
       process.stderr.write(
         `[shard-manager] Archived unreadable shard ${safeName}: ${archivedPath} (${stat.size} bytes, mtime ${stat.mtime.toISOString()})
 `
@@ -7752,7 +7752,7 @@ var init_shard_manager = __esm({
   "src/lib/shard-manager.ts"() {
     "use strict";
     init_config();
-    SHARDS_DIR = path23.join(EXE_AI_DIR, "shards");
+    SHARDS_DIR = path22.join(EXE_AI_DIR, "shards");
     SHARD_IDLE_MS = 5 * 60 * 1e3;
     MAX_OPEN_SHARDS = 10;
     EVICTION_INTERVAL_MS = 60 * 1e3;
@@ -8867,6 +8867,78 @@ 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, {
@@ -9414,119 +9486,6 @@ 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";
@@ -9576,7 +9535,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]
         });
-        await writeContinuityCheckpoint({
+        const { checkpointText, decisionTexts } = buildAutoCheckpoint({
           agentId: agent.agentId,
           agentRole: agent.agentRole,
           sessionId: data.session_id,
@@ -9584,9 +9543,35 @@ Orphaned tasks at session end: ${orphanResult.rows.map((r) => `"${String(r.title
           reason: "session-end",
           memories: recent.rows,
           tasks: taskRows.rows,
-          maxSamples: 12,
-          extraSections: orphanInfo ? [`## Session-End Warnings${orphanInfo}`] : []
+          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"
+        });
+        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);

package/dist/hooks/summary-worker.js

@@ -6952,6 +6952,46 @@ function vectorToBlob(vector) {
 // src/adapters/claude/hooks/summary-worker.ts
 init_database();
 init_notifications();
+
+// src/lib/memory-queue-client.ts
+init_exe_daemon_client();
+
+// src/lib/memory-queue.ts
+init_config();
+import { appendFileSync as appendFileSync2, readFileSync as readFileSync11, renameSync as renameSync5, unlinkSync as unlinkSync4, existsSync as existsSync15, statSync as statSync3 } from "fs";
+import path16 from "path";
+var QUEUE_PATH2 = path16.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/adapters/claude/hooks/summary-worker.ts
 init_task_scope();
 init_employees();
 import { execSync as execSync5 } from "child_process";
@@ -7038,119 +7078,6 @@ function buildAutoCheckpoint(input) {
   };
 }
 
-// src/lib/memory-queue-client.ts
-init_exe_daemon_client();
-
-// src/lib/memory-queue.ts
-init_config();
-import { appendFileSync as appendFileSync2, readFileSync as readFileSync11, renameSync as renameSync5, unlinkSync as unlinkSync4, existsSync as existsSync15, statSync as statSync3 } from "fs";
-import path16 from "path";
-var QUEUE_PATH2 = path16.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(input) {
-  const { checkpointText, decisionTexts } = buildAutoCheckpoint({
-    agentId: input.agentId,
-    agentRole: input.agentRole,
-    sessionId: input.sessionId,
-    projectName: input.projectName,
-    reason: input.reason,
-    memories: input.memories ?? [],
-    tasks: input.tasks ?? [],
-    maxSamples: input.maxSamples
-  });
-  const extra = input.extraSections?.filter((section) => section.trim().length > 0) ?? [];
-  return {
-    checkpointText: extra.length > 0 ? `${checkpointText}
-
-${extra.join("\n\n")}` : checkpointText,
-    decisionTexts
-  };
-}
-async function writeContinuityCheckpoint(input) {
-  const result = buildContinuityCheckpoint(input);
-  const now = (/* @__PURE__ */ new Date()).toISOString();
-  await writeMemoryViaDaemon({
-    raw_text: result.checkpointText,
-    agent_id: input.agentId,
-    agent_role: input.agentRole,
-    session_id: input.sessionId,
-    tool_name: toolNameForReason(input.reason),
-    project_name: input.projectName,
-    timestamp: now,
-    importance: importanceForReason(input.reason, input.importance),
-    task_id: input.taskId,
-    memory_type: "checkpoint"
-  });
-  const decisionLimit = input.reason === "periodic" ? 3 : 5;
-  for (const decisionText of result.decisionTexts.slice(0, decisionLimit)) {
-    await writeMemoryViaDaemon({
-      raw_text: decisionText,
-      agent_id: input.agentId,
-      agent_role: input.agentRole,
-      session_id: input.sessionId,
-      tool_name: "auto-decision",
-      project_name: input.projectName,
-      timestamp: (/* @__PURE__ */ new Date()).toISOString(),
-      importance: 8,
-      memory_type: "decision"
-    });
-  }
-  return result;
-}
-
 // src/adapters/claude/hooks/summary-worker.ts
 async function main() {
   const agentId = process.env.AGENT_ID ?? "default";
@@ -7209,8 +7136,15 @@ async function main() {
     taskRows = tasks.rows;
   } catch {
   }
-  const summarySessionId = `auto-summary-${Date.now()}`;
-  let summaryText = "";
+  const { checkpointText: summaryText, decisionTexts } = buildAutoCheckpoint({
+    agentId,
+    agentRole,
+    sessionId: `auto-summary-${Date.now()}`,
+    projectName: primaryProject,
+    reason: "periodic",
+    memories: result.rows,
+    tasks: taskRows
+  });
   let limitReached = false;
   try {
     const { assertMemoryLimit: assertMemoryLimit2 } = await Promise.resolve().then(() => (init_plan_limits(), plan_limits_exports));
@@ -7228,16 +7162,30 @@ async function main() {
   }
   if (limitReached) {
   } else {
-    const checkpointResult = await writeContinuityCheckpoint({
-      agentId,
-      agentRole,
-      sessionId: summarySessionId,
-      projectName: primaryProject,
-      reason: "periodic",
-      memories: result.rows,
-      tasks: taskRows
+    await writeMemoryViaDaemon({
+      raw_text: summaryText,
+      agent_id: agentId,
+      agent_role: agentRole,
+      session_id: `auto-summary-${Date.now()}`,
+      tool_name: "auto-summary",
+      project_name: primaryProject,
+      timestamp: (/* @__PURE__ */ new Date()).toISOString(),
+      importance: 7,
+      memory_type: "checkpoint"
     });
-    summaryText = checkpointResult.checkpointText;
+    for (const decisionText of decisionTexts.slice(0, 3)) {
+      await writeMemoryViaDaemon({
+        raw_text: decisionText,
+        agent_id: agentId,
+        agent_role: agentRole,
+        session_id: `auto-decision-${Date.now()}`,
+        tool_name: "auto-decision",
+        project_name: primaryProject,
+        timestamp: (/* @__PURE__ */ new Date()).toISOString(),
+        importance: 8,
+        memory_type: "decision"
+      });
+    }
     if (!canCoordinate(agentId, agentRole)) {
       let totalErrors = 0;
       for (const [, data] of projects) {