claude-code-session-manager 0.17.2 → 0.18.0

package/src/main/index.cjs

@@ -34,6 +34,7 @@ const agentMemory = require('./agentMemory.cjs');
 const { registerDocEditorHandlers } = require('./docEditor.cjs');
 const git = require('./git.cjs');
 const superagent = require('./superagent.cjs');
+const kg = require('./kg.cjs');
 const { registerProjectSkillsHandlers } = require('./projectSkills.cjs');
 const filesIpc = require('./files.cjs');
 const searchIpc = require('./search.cjs');
@@ -276,6 +277,7 @@ async function rebootApp() {
     logReboot('falling back to app.relaunch()');
     app.relaunch();
   }
+  runShutdownCleanup();   // app.exit bypasses will-quit
   app.exit(0);
 }
 
@@ -338,6 +340,7 @@ function createWindow() {
     // instead of blindly trying http://localhost:5173, which would (a) load
     // remote content and (b) almost always fail in a packaged install.
     console.error('[main] dist/index.html missing and SM_DEV is not set — refusing to load remote content. Reinstall or set SM_DEV=1 for dev.');
+    runShutdownCleanup();   // app.exit bypasses will-quit
     app.exit(1);
     return;
   }
@@ -732,7 +735,13 @@ app.whenReady().then(async () => {
   // uncleanly (the silent OOM-kill we've been chasing), then starts the memory
   // heartbeat + render/child-process-gone hooks for this run. See
   // crashDiagnostics.cjs for the full rationale.
-  crashDiagnostics.init({ logs, getPowerBlockerId: () => powerBlockerId });
+  crashDiagnostics.init({
+    logs,
+    getPowerBlockerId: () => powerBlockerId,
+    // If a suspend ever fires while we're alive, the OS lock lapsed — re-assert
+    // our block-mode systemd-inhibit so the next idle window stays covered.
+    onSuspendWhileAlive: () => { stopSystemdInhibit(); startSystemdInhibit(); },
+  });
 
   // Boot-time detection 1: surface `claude` binary resolution so a missing
   // install becomes visible to the renderer instead of failing silently on
@@ -908,9 +917,14 @@ app.whenReady().then(async () => {
   watchers.attachWindow(mainWindow);
   pluginInstall.attachWindow(mainWindow);
   superagent.attachWindow(mainWindow);
+  kg.attachWindow(mainWindow);
   scheduler.init().catch((e) => {
     logs.writeLine({ scope: 'scheduler', level: 'error', message: 'init failed', meta: { error: e?.message } });
   });
+  // Knowledge Graph: watch the prompt log + register kg:* IPC. Best-effort.
+  try { kg.init({ logger: logs }); } catch (e) {
+    logs.writeLine({ scope: 'kg', level: 'error', message: 'init failed', meta: { error: e?.message } });
+  }
 
   // Keep the machine awake while the app is open. The scheduler polls billing
   // usage every 2 min and runs `claude -p` jobs that must survive an idle
@@ -941,7 +955,15 @@ app.whenReady().then(async () => {
     });
 });
 
-app.on('will-quit', () => {
+// Centralized teardown. `will-quit` fires on a normal quit, but `app.exit()`
+// (in-app reboot, dist-missing abort) bypasses will-quit entirely — so those
+// sites must call this directly, otherwise markCleanShutdown never runs and the
+// next boot misreports a clean reboot as an UNCLEAN OOM crash, and the
+// powerSaveBlocker/inhibitor leak until process death.
+let teardownDone = false;
+function runShutdownCleanup() {
+  if (teardownDone) return;          // idempotent — will-quit may still fire after an app.exit path
+  teardownDone = true;
   // Mark a clean exit so the next boot can distinguish a graceful quit from an
   // OOM-kill / native crash (which leaves the sentinel `open`).
   crashDiagnostics.markCleanShutdown();
@@ -953,7 +975,9 @@ app.on('will-quit', () => {
     powerBlockerId = -1;
   }
   stopSystemdInhibit();
-});
+}
+
+app.on('will-quit', runShutdownCleanup);
 
 app.on('window-all-closed', () => {
   if (rebooting) return; // new window is about to be created

package/src/main/memoryTool.cjs

@@ -1,10 +1,10 @@
 /**
  * memoryTool.cjs — Memory tab backend (cycle 3, Bundle C).
  *
- * Workspace-scoped markdown store at
- *   ~/.claude/session-manager/memories/<workspace>/
- * where <workspace> is a derived encoding of an active cwd (mirrors the
- * Claude-Code transcript-dir convention). The Memory tab is a list+detail
+ * Workspace-scoped markdown store at Claude's native auto-memory location:
+ *   ~/.claude/projects/<workspace>/memory/
+ * where <workspace> is a derived encoding of an active cwd (the same
+ * transcript-dir slug Claude Code uses). The Memory tab is a list+detail
  * view over these files. Files are plain markdown with optional frontmatter:
  *
  *   ---
@@ -37,11 +37,17 @@ const SLUG_RE = /^[a-z0-9-_]+\.md$/;
 const { encodeCwd: encodeWorkspace } = require('./lib/encodeCwd.cjs');
 
 function memoryRoot() {
-  return path.join(os.homedir(), '.claude', 'session-manager', 'memories');
+  return path.join(os.homedir(), '.claude', 'projects');
 }
 
 function workspaceDir(workspace) {
-  return path.join(memoryRoot(), workspace);
+  // Repointed at Claude's native auto-memory store:
+  //   ~/.claude/projects/<encodedCwd>/memory/
+  // where <encodedCwd> is the same transcript-dir slug produced by encodeCwd.
+  // Reads AND writes target this dir so the user's real memories (incl. the
+  // Claude-managed MEMORY.md index) appear in the Memory tab, and new entries
+  // land where Claude actually reads them.
+  return path.join(memoryRoot(), workspace, 'memory');
 }
 
 /**

package/src/preload/api.d.ts

@@ -1025,6 +1025,53 @@ export interface SessionManagerAPI {
     stop: (tabId: string) => Promise<{ ok: boolean }>;
     onStateChanged: (handler: (ev: SuperAgentStateChangedEvent) => void) => () => void;
   };
+  kg: {
+    /** Distilled knowledge graph + ingest status over the prompt log. */
+    get: () => Promise<KgState>;
+    /** Process new prompt-log lines into the graph (incremental). */
+    ingest: () => Promise<{ ok: boolean; added?: number; nodes?: number; edges?: number; error?: string; note?: string }>;
+    /** Ask a question answered from the graph + your real prompts via claude -p. */
+    ask: (question: string) => Promise<{ ok: boolean; answer?: string; cited?: { ts: string; prompt: string }[]; error?: string }>;
+    onIngestProgress: (handler: (ev: KgIngestProgress) => void) => () => void;
+  };
+}
+
+export interface KgNode {
+  id: string;
+  key: string;
+  name: string;
+  type: string;
+  description: string;
+  count: number;
+  firstTs: string | null;
+  lastTs: string | null;
+}
+export interface KgEdge {
+  src: string;
+  dst: string;
+  relation: string;
+  weight: number;
+  lastTs: string | null;
+}
+export interface KgState {
+  nodes: KgNode[];
+  edges: KgEdge[];
+  status: {
+    promptCount: number;
+    totalPrompts: number;
+    pending: number;
+    lastIngest: string | null;
+    ingesting: boolean;
+    logPath: string;
+  };
+}
+export interface KgIngestProgress {
+  phase: 'start' | 'extract' | 'done' | 'error';
+  ingesting: boolean;
+  batch?: number;
+  totalBatches?: number;
+  added?: number;
+  error?: string;
 }
 
 declare global {

package/src/preload/index.cjs

@@ -279,4 +279,15 @@ contextBridge.exposeInMainWorld('api', {
       return () => ipcRenderer.removeListener('superagent:state-changed', listener);
     },
   },
+  kg: {
+    /** Knowledge Graph distilled from the prompt log (~/.claude/knowledge-log). */
+    get: () => ipcRenderer.invoke('kg:get'),
+    ingest: () => ipcRenderer.invoke('kg:ingest'),
+    ask: (question) => ipcRenderer.invoke('kg:ask', { question }),
+    onIngestProgress: (handler) => {
+      const listener = (_e, payload) => handler(payload);
+      ipcRenderer.on('kg:ingest-progress', listener);
+      return () => ipcRenderer.removeListener('kg:ingest-progress', listener);
+    },
+  },
 });