claude-code-session-manager 0.8.6 → 0.10.0

package/src/main/ipcSchemas.cjs

@@ -20,9 +20,12 @@ const ptySpawn = z.object({
 
 const ptyTabId = z.object({ tabId: z.string().min(1).max(128) });
 
+// 64 KiB cap per pty:write — typewriter input is bounded; a renderer firing
+// megabytes per call is either a bug or an attack. Block it at the boundary.
+const PTY_WRITE_MAX_BYTES = 64 * 1024;
 const ptyWrite = z.object({
   tabId: z.string().min(1).max(128),
-  data: z.string(),
+  data: z.string().max(PTY_WRITE_MAX_BYTES),
 });
 
 const ptyResize = z.object({
@@ -96,6 +99,34 @@ const scheduleReadLog = z.object({
   runId: z.string().regex(SCHEDULE_RUN_ID_RE),
 });
 
+// PRD write: slug + body (≤256 KiB, matches PRD_WRITE_MAX_BYTES in scheduler.cjs).
+const PRD_WRITE_MAX_BYTES = 256 * 1024;
+const scheduleWritePrd = z.object({
+  slug: z.string().regex(SCHEDULE_SLUG_RE),
+  body: z.string().refine(
+    (s) => Buffer.byteLength(s, 'utf8') <= PRD_WRITE_MAX_BYTES,
+    `body must be ≤ ${PRD_WRITE_MAX_BYTES} bytes`,
+  ),
+});
+
+// Bulk archive: slug list, capped to limit unbounded retag/archive payloads.
+const scheduleArchivePrd = z.object({
+  slugs: z.array(z.string().regex(SCHEDULE_SLUG_RE)).min(1).max(500),
+});
+
+const scheduleRetagItem = z.object({
+  slug: z.string().regex(SCHEDULE_SLUG_RE),
+  parallelGroup: z.number().int().min(0).max(999).optional(),
+  estimateMinutes: z.number().int().min(1).max(100000).optional(),
+}).refine(
+  (it) => it.parallelGroup !== undefined || it.estimateMinutes !== undefined,
+  'at least one of parallelGroup or estimateMinutes is required',
+);
+
+const scheduleRetagPrd = z.object({
+  items: z.array(scheduleRetagItem).min(1).max(500),
+});
+
 // ──────────────────────────────────────────── Projects
 const ENCODED_SLUG_RE = /^[A-Za-z0-9._-]+$/;
 
@@ -135,17 +166,125 @@ const setConfigSchema = z.object({
   }).optional(),
 }).strict();
 
+// ──────────────────────────────────────────── Memory tool (Bundle C, cycle 3)
+// Workspace-scoped markdown store at ~/.claude/session-manager/memories/<ws>/.
+// Slug regex must match memoryTool.cjs SLUG_RE; workspace regex matches its
+// encodeWorkspace() output (alphanumeric + dash) plus 'default'.
+const MEMORY_WORKSPACE_RE = /^[a-zA-Z0-9-_]{1,256}$/;
+const MEMORY_SLUG_RE = /^[a-z0-9-_]+\.md$/;
+// 1 MiB hard cap — matches MAX_FILE_BYTES in memoryTool.cjs.
+const MEMORY_MAX_BYTES = 1024 * 1024;
+
+const memoryList = z.object({
+  workspace: z.string().regex(MEMORY_WORKSPACE_RE).optional(),
+}).strict();
+
+const memoryRead = z.object({
+  workspace: z.string().regex(MEMORY_WORKSPACE_RE).optional(),
+  name: z.string().regex(MEMORY_SLUG_RE),
+}).strict();
+
+const memoryWrite = z.object({
+  workspace: z.string().regex(MEMORY_WORKSPACE_RE).optional(),
+  name: z.string().regex(MEMORY_SLUG_RE),
+  content: z.string().max(MEMORY_MAX_BYTES),
+}).strict();
+
+const memoryDelete = z.object({
+  workspace: z.string().regex(MEMORY_WORKSPACE_RE).optional(),
+  name: z.string().regex(MEMORY_SLUG_RE),
+}).strict();
+
+const memoryCreate = z.object({
+  workspace: z.string().regex(MEMORY_WORKSPACE_RE).optional(),
+  name: z.string().regex(MEMORY_SLUG_RE),
+  description: z.string().max(2048).optional(),
+}).strict();
+
 // ──────────────────────────────────────────── History
 const DATE_YYYY_MM_DD = /^\d{4}-\d{2}-\d{2}$/;
 
 const historyAggregate = z.object({
   fromDate: z.string().regex(DATE_YYYY_MM_DD).optional(),
   toDate: z.string().regex(DATE_YYYY_MM_DD).optional(),
-}).optional().nullable();
+}).nullish();
+
+// ──────────────────────────────────────────── Voice (F1/F5/F7/F8)
+// Mirrors voiceSettings.cjs isValidConfig / isValidDevicePref / isValid…
+// validators (ad-hoc on disk). Schemas here gate the IPC boundary so a
+// malformed renderer payload can never reach the file writer.
+const VOICE_ACCELERATOR_RE = /^(CommandOrControl|CmdOrCtrl|Cmd|Command|Ctrl|Control|Alt|Option|Shift|Super|Meta)(\+(CommandOrControl|CmdOrCtrl|Cmd|Command|Ctrl|Control|Alt|Option|Shift|Super|Meta))*\+([A-Z]|[0-9]|F([1-9]|1[0-9]|2[0-4])|Space|Tab|Enter|Backspace|Delete|Escape|Esc)$/;
+
+const voiceSetHotkey = z.object({
+  accelerator: z.string().regex(VOICE_ACCELERATOR_RE),
+  mode: z.enum(['hold', 'toggle']),
+  global: z.boolean(),
+  schemaVersion: z.number().int().optional(),
+}).passthrough();
+
+const voiceSetDevicePref = z.object({
+  selectedDeviceId: z.string().max(256).nullable(),
+  selectedLabel: z.string().max(256).nullable(),
+  schemaVersion: z.number().int().optional(),
+}).passthrough();
+
+const voiceSetTurnDetector = z.object({
+  enabled: z.boolean(),
+  mode: z.enum(['audio', 'text', 'off']),
+  schemaVersion: z.number().int().optional(),
+}).passthrough();
+
+const voiceSetRecording = z.boolean();
+
+// ──────────────────────────────────────────── Watchers
+// watchers:add runs `spawn(command, { shell: true })` — second-highest blast
+// radius after app:test-fire-hook. The 8 KiB cap on `command` is the same
+// cap watchers.cjs uses internally; centralizing here so the schema is the
+// injection fence rather than relying on the inline schemas in watchers.cjs.
+const watchersAdd = z.object({
+  tabId: z.string().min(1).max(128),
+  label: z.string().max(256).optional().default(''),
+  command: z.string().min(1).max(8192),
+  cwd: z.string().max(4096).optional().nullable(),
+});
+
+const watchersList = z.object({ tabId: z.string().min(1).max(128) });
+const watchersRemove = z.object({ watcherId: z.string().min(1).max(128) });
+const watchersKillTab = z.object({ tabId: z.string().min(1).max(128) });
+
+// ──────────────────────────────────────────── Hooks / git / plugins
+// Free-form env: keys must be safe identifier shape (no '=' / NUL / weird
+// unicode), values must be plain strings, both length-capped. We don't
+// restrict the key set — Hooks can legitimately need any env name — but we
+// do refuse anything that wouldn't survive a child_process env-block round
+// trip.
+const ENV_KEY_RE = /^[A-Za-z_][A-Za-z0-9_]*$/;
+const appTestFireHook = z.object({
+  command: z.string().min(1).max(16 * 1024),
+  env: z.record(z.string().regex(ENV_KEY_RE).max(256), z.string().max(8 * 1024))
+    .nullable()
+    .optional(),
+  payload: z.string().max(1 * 1024 * 1024).optional(),
+  timeoutMs: z.number().int().min(0).max(30_000).optional(),
+}).passthrough();
+
+const appGitBranch = z.object({
+  cwd: z.string().min(1).max(4096),
+}).passthrough();
+
+// Plugin install: mirrors pluginInstall.cjs SLUG_RE + length cap. Defense in
+// depth — install() re-checks; the schema rejects earlier.
+const PLUGIN_SLUG_RE = /^[a-z0-9\-/]+$/;
+const pluginsInstall = z.object({
+  slug: z.string().regex(PLUGIN_SLUG_RE).min(1).max(128),
+}).passthrough();
 
 /**
  * Wrap an IPC handler with schema validation. Returns a new handler that
- * parses the payload before calling the original.
+ * parses the payload before calling the original. On invalid payload throws
+ * a ZodError (caught by Electron's IPC harness → rejected promise). Existing
+ * call sites already rely on throw semantics for malformed input, so we keep
+ * that behavior for backwards compatibility.
  */
 function validated(schema, handler) {
   return (_event, payload) => {
@@ -155,6 +294,10 @@ function validated(schema, handler) {
 }
 
 module.exports = {
+  // Centralized slug regex — used by scheduler.cjs and queueOps.cjs for
+  // direct test()/match() containment checks alongside the zod parses.
+  SCHEDULE_SLUG_RE,
+  SCHEDULE_RUN_ID_RE,
   schemas: {
     ptySpawn,
     ptyTabId,
@@ -171,12 +314,31 @@ module.exports = {
     sessionsPayload,
     scheduleSlug,
     scheduleReadLog,
+    scheduleWritePrd,
+    scheduleArchivePrd,
+    scheduleRetagPrd,
     setConfigSchema,
     openInEditor,
     openInFinder,
     openInTerminal,
     archiveProject,
     historyAggregate,
+    voiceSetHotkey,
+    voiceSetDevicePref,
+    voiceSetTurnDetector,
+    voiceSetRecording,
+    appTestFireHook,
+    appGitBranch,
+    pluginsInstall,
+    memoryList,
+    memoryRead,
+    memoryWrite,
+    memoryDelete,
+    memoryCreate,
+    watchersAdd,
+    watchersList,
+    watchersRemove,
+    watchersKillTab,
   },
   validated,
 };

package/src/main/lib/claudeBin.cjs

@@ -0,0 +1,39 @@
+/**
+ * claudeBin.cjs — shared resolver for the `claude` executable.
+ *
+ * Both scheduler.cjs and supervisor.cjs need to spawn `claude -p` jobs.
+ * Both used to duplicate this list. Single source of truth here.
+ *
+ * Returns the first executable candidate found, falling back to bare
+ * "claude" so spawn() can still try PATH lookup.
+ *
+ * Cached after first successful resolution. Process-lifetime.
+ */
+'use strict';
+
+const fs = require('node:fs');
+const path = require('node:path');
+const os = require('node:os');
+
+let cached = null;
+
+function resolveClaudeBin() {
+  if (cached) return cached;
+  // Merged candidate list — was forked in scheduler vs pluginInstall before.
+  const home = os.homedir();
+  const candidates = [
+    path.join(home, '.claude', 'local', 'claude'),    // Claude Code bundled install
+    path.join(home, '.local', 'bin', 'claude'),       // user pip-style install
+    path.join(home, '.npm-global', 'bin', 'claude'),  // user npm-global
+    '/usr/local/bin/claude',
+    '/opt/homebrew/bin/claude',
+    '/usr/bin/claude',
+  ];
+  for (const c of candidates) {
+    try { fs.accessSync(c, fs.constants.X_OK); cached = c; return c; } catch { /* */ }
+  }
+  cached = 'claude';
+  return cached;
+}
+
+module.exports = { resolveClaudeBin };

package/src/main/lib/encodeCwd.cjs

@@ -0,0 +1,19 @@
+/**
+ * encodeCwd.cjs — canonical "cwd to directory-safe slug" encoder.
+ *
+ * Mirrors Claude Code's transcript directory naming convention: replace every
+ * non-alphanumeric character with '-'. Used by:
+ *   - transcripts.cjs to locate `~/.claude/projects/<encoded>/<sessionUuid>.jsonl`
+ *   - memoryTool.cjs to derive the workspace label for memory storage
+ *   - the renderer's Memory tab (purely advisory; main process is authoritative)
+ *
+ * Falls back to 'default' on null/blank input so callers always get a valid slug.
+ */
+'use strict';
+
+function encodeCwd(cwd) {
+  if (!cwd || typeof cwd !== 'string' || !cwd.trim()) return 'default';
+  return cwd.replace(/[^a-zA-Z0-9]/g, '-');
+}
+
+module.exports = { encodeCwd };

package/src/main/lib/fileTail.cjs

@@ -0,0 +1,35 @@
+/**
+ * fileTail.cjs — read the last N bytes of a file as UTF-8.
+ *
+ * Three near-identical copies existed before: scheduler.cjs readTail (1011),
+ * supervisor.cjs readTailBytes (104), and an inline copy in scheduler's
+ * post-result watchdog (~792). Unified here. Callers MUST be in a synchronous
+ * context; intentionally sync because callers are inside polling intervals or
+ * exit handlers where async would add an unnecessary event-loop hop.
+ *
+ * Returns '' on any I/O error (missing file, permission denied, etc.) — the
+ * tail readers are best-effort log scanners, not data paths.
+ */
+'use strict';
+
+const fs = require('node:fs');
+
+function readTail(filePath, bytes) {
+  try {
+    const stat = fs.statSync(filePath);
+    const n = Math.min(stat.size, bytes);
+    if (n <= 0) return '';
+    const fd = fs.openSync(filePath, 'r');
+    try {
+      const buf = Buffer.alloc(n);
+      fs.readSync(fd, buf, 0, n, stat.size - n);
+      return buf.toString('utf8');
+    } finally {
+      fs.closeSync(fd);
+    }
+  } catch {
+    return '';
+  }
+}
+
+module.exports = { readTail };

package/src/main/lib/insideHome.cjs

@@ -0,0 +1,38 @@
+/**
+ * insideHome.cjs — security invariant: every renderer-controlled cwd must
+ * resolve (after realpath, symlink-safe) to a path inside the user's home
+ * directory. Four call sites used to reimplement this: pty.cjs spawn,
+ * watchers.cjs add, index.cjs checkInsideHome, ipcSchemas.cjs setConfigSchema
+ * defaultCwd refine. The check is a single chokepoint here.
+ *
+ * Returns { ok: true, realCwd } on success or { ok: false, error } on rejection.
+ * Realpath of the cwd is returned so callers can use it without recomputing.
+ *
+ * NOTE: schemas can't easily call this (zod refines are inline); they retain
+ * a simpler `startsWith` check that does NOT symlink-resolve. The runtime
+ * resolution here is the authoritative one — schemas are belt-and-suspenders.
+ */
+'use strict';
+
+const fs = require('node:fs');
+const path = require('node:path');
+const os = require('node:os');
+
+function assertCwdInsideHome(cwd) {
+  if (typeof cwd !== 'string' || !cwd) {
+    return { ok: false, error: 'cwd must be a non-empty string' };
+  }
+  const home = os.homedir();
+  let realCwd;
+  try {
+    realCwd = fs.realpathSync(cwd);
+  } catch {
+    realCwd = path.resolve(cwd);
+  }
+  if (realCwd !== home && !realCwd.startsWith(home + path.sep)) {
+    return { ok: false, error: `cwd outside home directory: ${realCwd}` };
+  }
+  return { ok: true, realCwd };
+}
+
+module.exports = { assertCwdInsideHome };

package/src/main/lib/prdFrontmatter.cjs

@@ -0,0 +1,51 @@
+/**
+ * prdFrontmatter.cjs — minimal YAML frontmatter parser for scheduled PRD files.
+ *
+ * PRDs at `~/.claude/session-manager/scheduled-plans/prds/<NN>-<slug>.md` use
+ * a small documented frontmatter subset (title, cwd, estimateMinutes,
+ * parallelGroup, …). Two callers used to roll their own parser:
+ *   - scheduler.cjs::parsePrdRaw — typed extraction of the known keys
+ *   - queueOps.cjs::splitFrontmatter — linting; needs the raw map plus the
+ *     line-count of the frontmatter region so warnings point at the right line
+ *
+ * This module owns the parse. Callers transform the raw map into whatever
+ * typed shape they need.
+ *
+ * Format:
+ *   ---
+ *   key: value
+ *   ---
+ *   body…
+ *
+ * - Keys must match /^[A-Za-z][A-Za-z0-9_]*$/ (alpha first; alphanum + _).
+ * - Values are read as strings; surrounding ' or " quotes are stripped.
+ * - Missing or malformed frontmatter → { fm: {}, body: raw, fmLineCount: 0 }.
+ */
+'use strict';
+
+function splitFrontmatter(raw) {
+  if (typeof raw !== 'string' || !raw.startsWith('---\n')) {
+    return { fm: {}, body: raw, fmLineCount: 0 };
+  }
+  const end = raw.indexOf('\n---', 4);
+  if (end === -1) return { fm: {}, body: raw, fmLineCount: 0 };
+  const fmRaw = raw.slice(4, end);
+  const fm = {};
+  for (const line of fmRaw.split('\n')) {
+    const m = line.match(/^([A-Za-z][A-Za-z0-9_]*)\s*:\s*(.*)\s*$/);
+    if (!m) continue;
+    let v = m[2];
+    if ((v.startsWith('"') && v.endsWith('"')) || (v.startsWith("'") && v.endsWith("'"))) {
+      v = v.slice(1, -1);
+    }
+    fm[m[1]] = v;
+  }
+  return {
+    fm,
+    body: raw.slice(end + 4).replace(/^\n/, ''),
+    // +2 for the two `---` fences themselves
+    fmLineCount: fmRaw.split('\n').length + 2,
+  };
+}
+
+module.exports = { splitFrontmatter };

package/src/main/lib/sendToRenderer.cjs

@@ -0,0 +1,21 @@
+/**
+ * sendToRenderer.cjs — `webContents.send` with a destroyed-window guard.
+ *
+ * Every IPC-broadcasting module was open-coding `if (window && !window.isDestroyed())`
+ * before invoking `webContents.send`. Forgetting the guard produces a hard
+ * crash when a broadcast lands during teardown. Centralized here so new
+ * broadcasters can't reintroduce the footgun.
+ */
+'use strict';
+
+/**
+ * Send a payload on a channel iff the BrowserWindow is alive.
+ * No-ops on null/destroyed windows so callers don't need their own guards.
+ */
+function sendIfAlive(window, channel, payload) {
+  if (window && !window.isDestroyed()) {
+    window.webContents.send(channel, payload);
+  }
+}
+
+module.exports = { sendIfAlive };

package/src/main/memoryTool.cjs

@@ -0,0 +1,203 @@
+/**
+ * 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
+ * view over these files. Files are plain markdown with optional frontmatter:
+ *
+ *   ---
+ *   name: short label
+ *   description: one-line summary
+ *   ---
+ *   <body>
+ *
+ * Hard caps:
+ *   - 1 MB per file
+ *   - 1000 entries per workspace
+ *   - slugs MUST match /^[a-z0-9-_]+\.md$/
+ *
+ * Every read/write/delete is routed through config.cjs's atomic helpers,
+ * which in turn pin every absolute path inside the home directory via
+ * validatePath (with validateWrite layered on top for mutations).
+ */
+
+const { ipcMain } = require('electron');
+const fs = require('node:fs');
+const fsp = require('node:fs/promises');
+const path = require('node:path');
+const os = require('node:os');
+const config = require('./config.cjs');
+
+const MAX_FILE_BYTES = 1024 * 1024; // 1 MiB
+const MAX_ENTRIES = 1000;
+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');
+}
+
+function workspaceDir(workspace) {
+  return path.join(memoryRoot(), workspace);
+}
+
+/**
+ * Reject NUL chars, '..' segments, absolute paths, or anything that would
+ * resolve outside the workspace dir. Returns the resolved absolute path.
+ * The downstream config.cjs helpers add a second layer of validation, but
+ * this lets us return a clean error message before we get there.
+ */
+function resolveEntryPath(workspace, name) {
+  if (typeof name !== 'string' || !name) {
+    throw new Error('invalid entry name');
+  }
+  if (name.includes('\0')) throw new Error('NUL in name');
+  if (!SLUG_RE.test(name)) {
+    throw new Error(`invalid slug (must match ${SLUG_RE.source}): ${name}`);
+  }
+  const dir = workspaceDir(workspace);
+  const full = path.resolve(dir, name);
+  // path.resolve normalizes; verify the result is still under dir to guard
+  // against bizarre name inputs.
+  if (full !== path.join(dir, name)) {
+    throw new Error('path escapes workspace');
+  }
+  const rel = path.relative(dir, full);
+  if (rel.startsWith('..') || path.isAbsolute(rel)) {
+    throw new Error('path escapes workspace');
+  }
+  return full;
+}
+
+function validWorkspaceName(name) {
+  return typeof name === 'string' && /^[a-zA-Z0-9-_]{1,256}$/.test(name);
+}
+
+async function list({ workspace }) {
+  const ws = validWorkspaceName(workspace) ? workspace : 'default';
+  const dir = workspaceDir(ws);
+  const r = await config.listDir(dir, { filesOnly: true });
+  if (!r.ok) {
+    return { entries: [], workspace: ws, error: r.error };
+  }
+  const entries = r.entries
+    .filter((e) => e.name.endsWith('.md'))
+    .map((e) => ({
+      name: e.name,
+      path: e.path,
+      mtimeMs: e.mtimeMs,
+      bytes: e.size,
+    }))
+    .sort((a, b) => a.name.localeCompare(b.name));
+  return { entries, workspace: ws, error: null };
+}
+
+async function read({ workspace, name }) {
+  const ws = validWorkspaceName(workspace) ? workspace : 'default';
+  const abs = resolveEntryPath(ws, name);
+  const r = await config.readText(abs);
+  if (!r.exists) {
+    return { content: '', exists: false, mtimeMs: 0, bytes: 0, error: r.error };
+  }
+  return {
+    content: r.text,
+    exists: true,
+    mtimeMs: r.mtimeMs,
+    bytes: Buffer.byteLength(r.text, 'utf8'),
+    error: null,
+  };
+}
+
+async function write({ workspace, name, content }) {
+  const ws = validWorkspaceName(workspace) ? workspace : 'default';
+  if (typeof content !== 'string') {
+    return { ok: false, error: 'content must be a string' };
+  }
+  const bytes = Buffer.byteLength(content, 'utf8');
+  if (bytes > MAX_FILE_BYTES) {
+    return { ok: false, error: `file exceeds 1 MiB cap (${bytes} bytes)` };
+  }
+  const abs = resolveEntryPath(ws, name);
+  // Enforce per-workspace entry cap on creates (writes to existing files are
+  // always allowed regardless of count). Cheap fs.stat check rather than a
+  // full directory enumeration where possible.
+  let exists = true;
+  try { await fsp.access(abs, fs.constants.F_OK); }
+  catch { exists = false; }
+  if (!exists) {
+    const l = await list({ workspace: ws });
+    if (l.entries.length >= MAX_ENTRIES) {
+      return { ok: false, error: `workspace at ${MAX_ENTRIES}-entry cap` };
+    }
+  }
+  try {
+    await config.writeTextAtomic(abs, content);
+    return { ok: true, error: null };
+  } catch (e) {
+    return { ok: false, error: e.message };
+  }
+}
+
+async function deleteEntry({ workspace, name }) {
+  const ws = validWorkspaceName(workspace) ? workspace : 'default';
+  const abs = resolveEntryPath(ws, name);
+  // Route through config.cjs::validatePath (home-boundary pin, symlink-safe)
+  // plus validateWrite (write-prefix pin) — same contract every other
+  // mutating call in the codebase follows. Complexity: O(1) per call.
+  let real;
+  try {
+    real = config.validatePath(abs);
+    config.validateWrite(real);
+  } catch (e) {
+    return { ok: false, error: e.message };
+  }
+  try {
+    await fsp.unlink(real);
+    return { ok: true, error: null };
+  } catch (e) {
+    if (e.code === 'ENOENT') return { ok: true, error: null };
+    return { ok: false, error: e.message };
+  }
+}
+
+async function create({ workspace, name, description }) {
+  const ws = validWorkspaceName(workspace) ? workspace : 'default';
+  const abs = resolveEntryPath(ws, name);
+  // Refuse to overwrite — create is strictly "new file".
+  try {
+    await fsp.access(abs, fs.constants.F_OK);
+    return { ok: false, error: 'memory already exists' };
+  } catch { /* expected */ }
+  const stem = name.replace(/\.md$/, '');
+  const desc = typeof description === 'string' ? description.trim() : '';
+  const fm = [
+    '---',
+    `name: ${stem}`,
+    ...(desc ? [`description: ${desc.replace(/\n/g, ' ')}`] : []),
+    '---',
+    '',
+    desc || `# ${stem}`,
+    '',
+  ].join('\n');
+  return await write({ workspace: ws, name, content: fm });
+}
+
+function registerMemoryHandlers() {
+  const { schemas: s, validated: v } = require('./ipcSchemas.cjs');
+  ipcMain.handle('memory:list', v(s.memoryList, list));
+  ipcMain.handle('memory:read', v(s.memoryRead, read));
+  ipcMain.handle('memory:write', v(s.memoryWrite, write));
+  ipcMain.handle('memory:delete', v(s.memoryDelete, deleteEntry));
+  ipcMain.handle('memory:create', v(s.memoryCreate, create));
+}
+
+module.exports = {
+  registerMemoryHandlers,
+  encodeWorkspace,
+  // exported for tests
+  memoryRoot,
+  workspaceDir,
+};

package/src/main/otelSettings.cjs

@@ -17,6 +17,7 @@
 const fsp = require('node:fs/promises');
 const path = require('node:path');
 const os = require('node:os');
+const config = require('./config.cjs');
 
 const SCHEMA_VERSION = 1;
 
@@ -74,13 +75,7 @@ async function save(cfg) {
   if (!isValid(cfg)) throw new Error('Invalid OTEL config');
   const next = normalize(cfg);
   const run = async () => {
-    const p = storePath();
-    await fsp.mkdir(path.dirname(p), { recursive: true }).catch(() => {});
-    const body = JSON.stringify(next, null, 2) + '\n';
-    const tmp = `${p}.tmp-${process.pid}-${Date.now()}`;
-    await fsp.writeFile(tmp, body, { encoding: 'utf8', mode: 0o600 });
-    try { await fsp.chmod(tmp, 0o600); } catch { /* */ }
-    await fsp.rename(tmp, p);
+    await config.writeTextAtomic(storePath(), JSON.stringify(next, null, 2) + '\n', { mode: 0o600 });
     return next;
   };
   const tail = writeQueue.then(run, run);