claude-code-session-manager 0.10.5 → 0.11.1

package/src/main/git.cjs

@@ -0,0 +1,333 @@
+/**
+ * Git IPC handlers — richer status data than the StatusBar-only `app:git-branch`.
+ *
+ * Ported (in spirit) from ClaudeCodeUnleashed's src/main/ipc/git.ts. Built
+ * fresh for our conventions: argv-array spawn (never shell:true), validatePath
+ * gating, zod-validated IPC payloads, 5s timeout ceiling, 5s per-cwd cache.
+ *
+ * Channels:
+ *   git:status      → { branch, ahead, behind, uncommittedCount, files[] } | null
+ *   git:file-status → { [absolutePath]: 'modified' | 'added' | 'deleted' |
+ *                       'renamed' | 'untracked' | 'staged' | 'conflict' }
+ *
+ * "Not a git repo" / spawn errors / timeouts all surface as `null` (status)
+ * or `{}` (file-status) so the renderer can render unconditionally.
+ *
+ * Future readers: this file is for OBSERVATION only. No mutation commands
+ * (commit/push/pull/add) — those belong to a separate, much-more-restricted
+ * surface if they ever land. The whole point of the cache is so the planned
+ * file-tree sidebar can poll cheaply without spawning git for every render.
+ */
+
+const { spawn } = require('node:child_process');
+const path = require('node:path');
+const { schemas } = require('./ipcSchemas.cjs');
+const { validatePath } = require('./config.cjs');
+
+const GIT_TIMEOUT_MS = 5_000;
+const CACHE_TTL_MS = 5_000;
+const MAX_BUFFER = 10 * 1024 * 1024; // 10 MiB — same cap Unleashed uses
+
+// Per-cwd in-memory caches. Keyed by the realpath-validated cwd so symlinks
+// to the same repo dedupe. Each entry: { value, expiresAt }.
+const statusCache = new Map();
+const fileStatusCache = new Map();
+
+/**
+ * Run `git <args>` in cwd with a hard 5s SIGKILL ceiling. Resolves
+ * { ok:true, stdout } on exit 0, { ok:false, code, stderr } otherwise.
+ * Never throws — IPC handlers want a discriminated result, not an exception.
+ *
+ * argv-array spawn — never `shell: true`. cwd MUST already be validatePath-checked.
+ */
+function runGit(args, cwd) {
+  return new Promise((resolve) => {
+    let proc;
+    try {
+      proc = spawn('git', args, {
+        cwd,
+        windowsHide: true,
+        // Inherit env minus anything that could change git behaviour; default
+        // is fine here — we explicitly do NOT want `cleanChildEnv` because
+        // git relies on $HOME/$PATH/$GIT_* to find config + ssh credentials.
+      });
+    } catch (err) {
+      resolve({ ok: false, code: -1, stderr: `spawn failed: ${err?.message ?? String(err)}` });
+      return;
+    }
+
+    const stdoutChunks = [];
+    const stderrChunks = [];
+    let stdoutLen = 0;
+    let stderrLen = 0;
+    let timedOut = false;
+
+    const killTimer = setTimeout(() => {
+      timedOut = true;
+      try { proc.kill('SIGKILL'); } catch { /* already dead */ }
+    }, GIT_TIMEOUT_MS);
+
+    proc.stdout.on('data', (b) => {
+      if (stdoutLen < MAX_BUFFER) {
+        stdoutChunks.push(b);
+        stdoutLen += b.length;
+      }
+    });
+    proc.stderr.on('data', (b) => {
+      if (stderrLen < MAX_BUFFER) {
+        stderrChunks.push(b);
+        stderrLen += b.length;
+      }
+    });
+
+    proc.on('error', (err) => {
+      clearTimeout(killTimer);
+      resolve({ ok: false, code: -1, stderr: `spawn error: ${err?.message ?? String(err)}` });
+    });
+
+    proc.on('close', (code) => {
+      clearTimeout(killTimer);
+      const stdout = Buffer.concat(stdoutChunks).toString('utf8');
+      const stderr = Buffer.concat(stderrChunks).toString('utf8');
+      if (timedOut) {
+        resolve({ ok: false, code: -1, stderr: `timeout after ${GIT_TIMEOUT_MS}ms\n${stderr}` });
+        return;
+      }
+      if (code === 0) {
+        resolve({ ok: true, stdout, stderr });
+      } else {
+        resolve({ ok: false, code: typeof code === 'number' ? code : -1, stderr });
+      }
+    });
+  });
+}
+
+/**
+ * Unquote a git path. With porcelain v1 *without* -z, git quotes paths
+ * containing special chars (spaces, unicode, control bytes). We use -z so
+ * paths come through raw NUL-separated, but kept as a defensive shim in
+ * case a future caller drops -z.
+ */
+function unquoteGitPath(p) {
+  if (p.startsWith('"') && p.endsWith('"')) {
+    return p.slice(1, -1)
+      .replace(/\\n/g, '\n')
+      .replace(/\\t/g, '\t')
+      .replace(/\\"/g, '"')
+      .replace(/\\\\/g, '\\');
+  }
+  return p;
+}
+
+/**
+ * Map porcelain XY pair to one of our enum values. Mirrors Unleashed's
+ * git-file-status handler, with the same conflict-detection rules.
+ *
+ *   ' M' → modified           '??' → untracked
+ *   'A ' → added              'AM' → added (index) — staged-then-modified
+ *   ' D' → deleted            'D ' → deleted
+ *   'R ' → renamed            'C ' → added (copy treated as new)
+ *   'U.' / '.U' / 'DD' / 'AA' → conflict
+ *   any other staged change   → staged
+ */
+function mapStatus(indexChar, workChar) {
+  if (indexChar === '?' && workChar === '?') return 'untracked';
+  if (
+    indexChar === 'U' || workChar === 'U' ||
+    (indexChar === 'D' && workChar === 'D') ||
+    (indexChar === 'A' && workChar === 'A')
+  ) return 'conflict';
+  if (indexChar === 'A') return 'added';
+  if (indexChar === 'D' || workChar === 'D') return 'deleted';
+  if (indexChar === 'R') return 'renamed';
+  if (indexChar === 'C') return 'added';
+  if (indexChar !== ' ' && indexChar !== '?') return 'staged';
+  if (workChar === 'M') return 'modified';
+  return 'modified';
+}
+
+/**
+ * Parse `git status --porcelain=v1 -b -u -z` output.
+ *
+ * First entry (when -b is set) is the branch header:
+ *   "## main...origin/main [ahead 1, behind 2]"
+ *   "## HEAD (no branch)" — detached
+ *   "## No commits yet on main"
+ *
+ * Remaining entries are NUL-separated "XY <path>" records. Renamed/copied
+ * records consume TWO entries (new path, then original path).
+ *
+ * Returns { branch, ahead, behind, files }.
+ */
+function parsePorcelain(stdout, cwd) {
+  const entries = stdout.split('\0').filter((e) => e.length > 0);
+  const out = {
+    branch: 'HEAD',
+    ahead: 0,
+    behind: 0,
+    files: [],
+  };
+
+  let i = 0;
+  // Branch header
+  if (entries.length > 0 && entries[0].startsWith('## ')) {
+    const header = entries[0].slice(3);
+    if (header.startsWith('No commits yet on ')) {
+      out.branch = header.slice('No commits yet on '.length).split(' ')[0];
+    } else if (header.startsWith('HEAD (no branch)')) {
+      out.branch = 'HEAD';
+    } else {
+      // "main" or "main...origin/main [ahead 1, behind 2]"
+      const m = /^([^.\s]+)(?:\.\.\.([^\s]+))?(?:\s+\[([^\]]+)\])?/.exec(header);
+      if (m) {
+        out.branch = m[1];
+        const bracket = m[3];
+        if (bracket) {
+          const am = /ahead (\d+)/.exec(bracket);
+          const bm = /behind (\d+)/.exec(bracket);
+          if (am) out.ahead = parseInt(am[1], 10) || 0;
+          if (bm) out.behind = parseInt(bm[1], 10) || 0;
+        }
+      }
+    }
+    i = 1;
+  }
+
+  while (i < entries.length) {
+    const entry = entries[i];
+    if (entry.length < 3) { i++; continue; }
+    const indexChar = entry[0];
+    const workChar = entry[1];
+    // Format with -z: "XY <path>" — note SINGLE space between XY and path.
+    let filePath = entry.substring(3);
+
+    // Renamed/copied → next entry is the original path; skip it.
+    if (indexChar === 'R' || indexChar === 'C') {
+      i++;
+    }
+
+    filePath = unquoteGitPath(filePath);
+    const absolutePath = path.resolve(cwd, filePath);
+    const status = mapStatus(indexChar, workChar);
+
+    out.files.push({
+      path: absolutePath,
+      relativePath: filePath,
+      status,
+      indexStatus: indexChar,
+      workTreeStatus: workChar,
+    });
+
+    i++;
+  }
+
+  return out;
+}
+
+/**
+ * git:status(cwd) — full status. Returns null if not a git repo / git fails.
+ *
+ * Cached per realpath-cwd for 5s so the renderer can poll cheaply (the
+ * planned file-tree sidebar will tick this every couple seconds).
+ */
+async function getStatus(cwd) {
+  let realCwd;
+  try {
+    realCwd = validatePath(cwd);
+  } catch {
+    return null;
+  }
+
+  const now = Date.now();
+  const cached = statusCache.get(realCwd);
+  if (cached && cached.expiresAt > now) return cached.value;
+
+  // Single porcelain call gets us branch + ahead/behind + files in one shot.
+  const result = await runGit(
+    ['status', '--porcelain=v1', '-b', '-u', '-z'],
+    realCwd,
+  );
+
+  if (!result.ok) {
+    // "not a git repository" or any other failure → null
+    statusCache.set(realCwd, { value: null, expiresAt: now + CACHE_TTL_MS });
+    return null;
+  }
+
+  const parsed = parsePorcelain(result.stdout, realCwd);
+  const value = {
+    branch: parsed.branch,
+    ahead: parsed.ahead,
+    behind: parsed.behind,
+    uncommittedCount: parsed.files.length,
+    files: parsed.files,
+  };
+  statusCache.set(realCwd, { value, expiresAt: now + CACHE_TTL_MS });
+  return value;
+}
+
+/**
+ * git:file-status(cwd) — `{ absPath: status }` map. Returns `{}` if not a
+ * git repo / git fails. Same 5s per-cwd cache.
+ */
+async function getFileStatus(cwd) {
+  let realCwd;
+  try {
+    realCwd = validatePath(cwd);
+  } catch {
+    return {};
+  }
+
+  const now = Date.now();
+  const cached = fileStatusCache.get(realCwd);
+  if (cached && cached.expiresAt > now) return cached.value;
+
+  const result = await runGit(
+    ['status', '--porcelain=v1', '-u', '-z'],
+    realCwd,
+  );
+
+  if (!result.ok) {
+    fileStatusCache.set(realCwd, { value: {}, expiresAt: now + CACHE_TTL_MS });
+    return {};
+  }
+
+  // No -b here, so parsePorcelain's branch-header branch will simply not fire.
+  const parsed = parsePorcelain(result.stdout, realCwd);
+  const map = {};
+  for (const f of parsed.files) {
+    map[f.path] = f.status;
+  }
+  fileStatusCache.set(realCwd, { value: map, expiresAt: now + CACHE_TTL_MS });
+  return map;
+}
+
+/** Drop cached entries — useful for tests / forced refresh. Not wired to IPC. */
+function clearCache() {
+  statusCache.clear();
+  fileStatusCache.clear();
+}
+
+function register(ipcMain) {
+  ipcMain.handle('git:status', async (_e, payload) => {
+    const parsed = schemas.gitStatus.safeParse(payload);
+    if (!parsed.success) return null;
+    return getStatus(parsed.data.cwd);
+  });
+
+  ipcMain.handle('git:file-status', async (_e, payload) => {
+    const parsed = schemas.gitFileStatus.safeParse(payload);
+    if (!parsed.success) return {};
+    return getFileStatus(parsed.data.cwd);
+  });
+}
+
+module.exports = {
+  register,
+  // Exposed for unit-test / sanity-check use.
+  getStatus,
+  getFileStatus,
+  parsePorcelain,
+  mapStatus,
+  clearCache,
+};

package/src/main/historyAggregator.cjs

@@ -105,6 +105,34 @@ async function parseJSONL(filePath, stat) {
   return acc;
 }
 
+/** Lightweight per-file meta: { firstTs, lastTs, inputTokens, outputTokens, skipped }.
+ *  Powers the `history:list-conversations` IPC used by the Overview detailed-
+ *  stats panel. Single-pass O(L) scan, only honors ts + usage blocks. */
+async function parseConversationMeta(filePath, stat) {
+  const meta = { firstTs: null, lastTs: null, inputTokens: 0, outputTokens: 0, skipped: false };
+  if (stat.size > MAX_FILE_BYTES) { meta.skipped = true; return meta; }
+  let text;
+  try { text = await fsp.readFile(filePath, 'utf8'); } catch { return meta; }
+  const lines = text.split('\n');
+  for (const raw of lines) {
+    const line = raw.trim();
+    if (!line) continue;
+    let obj;
+    try { obj = JSON.parse(line); } catch { continue; }
+    const ts = obj.ts ?? obj.timestamp;
+    if (ts) {
+      if (meta.firstTs === null) meta.firstTs = ts;
+      meta.lastTs = ts;
+    }
+    const usage = obj.usage ?? obj.message?.usage;
+    if (usage && typeof usage === 'object') {
+      if (typeof usage.inputTokens === 'number') meta.inputTokens += usage.inputTokens;
+      if (typeof usage.outputTokens === 'number') meta.outputTokens += usage.outputTokens;
+    }
+  }
+  return meta;
+}
+
 function registerHistoryAggregatorHandlers() {
   ipcMain.handle('history:aggregate', async (_e, rawReq) => {
     // Wire the historyAggregate schema (previously defined but never used).
@@ -208,6 +236,48 @@ function registerHistoryAggregatorHandlers() {
     const scannedMs = Date.now() - t0;
     return { rows, partial, scannedMs, skippedLargeFiles };
   });
+
+  /** Per-conversation metadata: one row per JSONL with derived duration +
+   *  token totals. Used by the Overview detailed-stats panel to compute
+   *  hourly/daily distribution + top-projects. */
+  ipcMain.handle('history:list-conversations', async () => {
+    const t0 = Date.now();
+    const conversations = [];
+    let projectEntries;
+    try {
+      projectEntries = await fsp.readdir(PROJECTS_DIR, { withFileTypes: true });
+    } catch {
+      return { conversations: [], scannedMs: Date.now() - t0 };
+    }
+    for (const ent of projectEntries) {
+      if (!ent.isDirectory()) continue;
+      const projectDir = path.join(PROJECTS_DIR, ent.name);
+      const projectFolder = '/' + ent.name.replace(/-/g, '/');
+      let files;
+      try { files = await fsp.readdir(projectDir, { withFileTypes: true }); } catch { continue; }
+      for (const f of files) {
+        if (!f.isFile() || !f.name.endsWith('.jsonl')) continue;
+        const filePath = path.join(projectDir, f.name);
+        let stat;
+        try { stat = await fsp.stat(filePath); } catch { continue; }
+        const meta = await parseConversationMeta(filePath, stat);
+        const firstTs = meta.firstTs || new Date(stat.mtimeMs).toISOString();
+        const duration =
+          meta.firstTs && meta.lastTs
+            ? Math.max(0, Date.parse(meta.lastTs) - Date.parse(meta.firstTs))
+            : undefined;
+        conversations.push({
+          timestamp: firstTs,
+          projectFolder,
+          stats: {
+            ...(duration !== undefined ? { duration } : {}),
+            estimatedTokens: meta.inputTokens + meta.outputTokens,
+          },
+        });
+      }
+    }
+    return { conversations, scannedMs: Date.now() - t0 };
+  });
 }
 
 module.exports = { registerHistoryAggregatorHandlers };

package/src/main/index.cjs

@@ -24,7 +24,12 @@ const otel = require('./otel.cjs');
 const otelSettings = require('./otelSettings.cjs');
 const { registerHistoryAggregatorHandlers } = require('./historyAggregator.cjs');
 const memoryTool = require('./memoryTool.cjs');
+const agentMemory = require('./agentMemory.cjs');
 const { registerDocEditorHandlers } = require('./docEditor.cjs');
+const git = require('./git.cjs');
+const superagent = require('./superagent.cjs');
+const { registerProjectSkillsHandlers } = require('./projectSkills.cjs');
+const filesIpc = require('./files.cjs');
 const { resolveClaudeBin } = require('./lib/claudeBin.cjs');
 const { assertCwdInsideHome } = require('./lib/insideHome.cjs');
 
@@ -184,6 +189,7 @@ async function rebootApp() {
     scheduler.attachWindow(mainWindow);
     watchers.attachWindow(mainWindow);
     pluginInstall.attachWindow(mainWindow);
+    superagent.attachWindow(mainWindow);
     rebooting = false;
     return;
   }
@@ -630,7 +636,12 @@ queueOps.registerQueueOpsHandlers();
 registerHistoryAggregatorHandlers();
 pluginInstall.registerPluginInstallHandlers();
 memoryTool.registerMemoryHandlers();
+agentMemory.registerAgentMemoryHandlers();
 registerDocEditorHandlers();
+git.register(ipcMain);
+superagent.registerSuperAgentHandlers();
+registerProjectSkillsHandlers();
+filesIpc.registerFilesHandlers();
 
 // OTEL telemetry export (opt-in via ~/.config/session-manager/otel.json).
 ipcMain.handle('otel:get-config', async () => otelSettings.load());
@@ -842,6 +853,7 @@ app.whenReady().then(async () => {
   scheduler.attachWindow(mainWindow);
   watchers.attachWindow(mainWindow);
   pluginInstall.attachWindow(mainWindow);
+  superagent.attachWindow(mainWindow);
   scheduler.init().catch((e) => {
     logs.writeLine({ scope: 'scheduler', level: 'error', message: 'init failed', meta: { error: e?.message } });
   });

package/src/main/ipcSchemas.cjs

@@ -212,6 +212,36 @@ const memoryCreate = z.object({
   description: z.string().max(2048).optional(),
 }).strict();
 
+// ──────────────────────────────────────────── Per-subagent memory
+// Distinct from the workspace-scoped Memory tool: agentMemory is keyed by
+// subagent name (the .md filename in ~/.claude/agents/, e.g. "code-reviewer"),
+// not by cwd. Storage lives at ~/.claude/session-manager/agent-memory/<agentId>.json.
+// Regex caps must stay in lockstep with agentMemory.cjs AGENT_ID_RE / ENTRY_ID_RE.
+const AGENT_MEMORY_ID_RE = /^[A-Za-z0-9._-]{1,128}$/;
+const AGENT_MEMORY_CATEGORY = z.enum(['command', 'preference', 'pattern', 'failure', 'workflow']);
+const AGENT_MEMORY_MAX_BODY = 1024 * 1024; // 1 MiB — must match MAX_BODY_BYTES in agentMemory.cjs
+
+const agentMemoryList = z.object({
+  agentId: z.string().regex(AGENT_MEMORY_ID_RE),
+}).strict();
+
+const agentMemoryGet = z.object({
+  agentId: z.string().regex(AGENT_MEMORY_ID_RE),
+  entryId: z.string().regex(AGENT_MEMORY_ID_RE),
+}).strict();
+
+const agentMemorySet = z.object({
+  agentId: z.string().regex(AGENT_MEMORY_ID_RE),
+  entryId: z.string().regex(AGENT_MEMORY_ID_RE),
+  body: z.string().max(AGENT_MEMORY_MAX_BODY),
+  category: AGENT_MEMORY_CATEGORY.optional(),
+}).strict();
+
+const agentMemoryDelete = z.object({
+  agentId: z.string().regex(AGENT_MEMORY_ID_RE),
+  entryId: z.string().regex(AGENT_MEMORY_ID_RE),
+}).strict();
+
 // ──────────────────────────────────────────── History
 const DATE_YYYY_MM_DD = /^\d{4}-\d{2}-\d{2}$/;
 
@@ -283,6 +313,16 @@ const appGitBranch = z.object({
   cwd: z.string().min(1).max(4096),
 }).passthrough();
 
+// git:status / git:file-status — see src/main/git.cjs. cwd is validatePath'd
+// inside the handler (allowedRoots = home), so the schema only enforces shape.
+const gitStatus = z.object({
+  cwd: z.string().min(1).max(4096),
+}).passthrough();
+
+const gitFileStatus = 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\-/]+$/;
@@ -290,6 +330,20 @@ const pluginsInstall = z.object({
   slug: z.string().regex(PLUGIN_SLUG_RE).min(1).max(128),
 }).passthrough();
 
+// SuperAgent — "boss" run that writes a structured prompt to the active
+// tab's PTY. Bounds match the inline schemas in superagent.cjs; centralizing
+// here so the schema is the boundary fence rather than each handler.
+const superagentStart = z.object({
+  tabId: z.string().min(1).max(128),
+  prompt: z.string().min(1).max(8 * 1024),
+  specialistCount: z.number().int().min(1).max(8),
+  depth: z.enum(['quick', 'standard', 'deep']),
+}).strict();
+
+const superagentTabId = z.object({
+  tabId: z.string().min(1).max(128),
+}).strict();
+
 /**
  * Wrap an IPC handler with schema validation. Returns a new handler that
  * parses the payload before calling the original. On invalid payload throws
@@ -342,12 +396,20 @@ module.exports = {
     voiceSetRecording,
     appTestFireHook,
     appGitBranch,
+    gitStatus,
+    gitFileStatus,
     pluginsInstall,
+    superagentStart,
+    superagentTabId,
     memoryList,
     memoryRead,
     memoryWrite,
     memoryDelete,
     memoryCreate,
+    agentMemoryList,
+    agentMemoryGet,
+    agentMemorySet,
+    agentMemoryDelete,
     watchersAdd,
     watchersList,
     watchersRemove,

package/src/main/projectSkills.cjs

@@ -0,0 +1,124 @@
+/**
+ * ProjectSkills — per-project skill enable/disable state.
+ *
+ * Storage: <cwd>/.claude/project-skills.json
+ *   Format: { skills: Array<{ skillId: string; enabled: boolean }>, schemaVersion: 1 }
+ *
+ * Reads enumerate all skills under <cwd>/.claude/skills/ and <home>/.claude/skills/
+ * and merge their enable state from the project-local config. Skills not listed in
+ * the JSON default to `enabled: true` (i.e., opt-out per project).
+ *
+ * IPC:
+ *   - project-skills:get(cwd) -> SkillState[]
+ *   - project-skills:set(cwd, skillId, enabled) -> { ok: boolean }
+ *
+ * Atomic writes go through config.cjs::writeJson. cwd is validated via
+ * validatePath which constrains it to allowedRoots (home + registered project
+ * dirs).
+ */
+
+const { ipcMain } = require('electron');
+const path = require('node:path');
+const { z } = require('zod');
+const { readJson, writeJson, addAllowedRoot } = require('./config.cjs');
+
+const SCHEMA_VERSION = 1;
+
+function projectSkillsPath(cwd) {
+  return path.join(cwd, '.claude', 'project-skills.json');
+}
+
+/**
+ * Load the project-skills.json record for a cwd. Missing file => empty record.
+ * Returns { skills: Array<{skillId, enabled}>, schemaVersion }.
+ */
+async function loadRecord(cwd) {
+  const filePath = projectSkillsPath(cwd);
+  const r = await readJson(filePath);
+  if (!r.exists || !r.data || typeof r.data !== 'object') {
+    return { skills: [], schemaVersion: SCHEMA_VERSION };
+  }
+  const data = r.data;
+  const skills = Array.isArray(data.skills) ? data.skills : [];
+  // Filter for well-formed entries; tolerate corruption silently.
+  const clean = [];
+  const seen = new Set();
+  for (const s of skills) {
+    if (!s || typeof s.skillId !== 'string' || typeof s.enabled !== 'boolean') continue;
+    if (seen.has(s.skillId)) continue;
+    seen.add(s.skillId);
+    clean.push({ skillId: s.skillId, enabled: s.enabled });
+  }
+  return { skills: clean, schemaVersion: SCHEMA_VERSION };
+}
+
+async function saveRecord(cwd, record) {
+  const filePath = projectSkillsPath(cwd);
+  const payload = {
+    schemaVersion: SCHEMA_VERSION,
+    skills: record.skills,
+    savedAt: Date.now(),
+  };
+  return writeJson(filePath, payload);
+}
+
+/** Return the array of skill enable-states for a project cwd. */
+async function getProjectSkills(cwd) {
+  // Register cwd so writeJson is permitted under <cwd>/.claude.
+  addAllowedRoot(cwd);
+  const record = await loadRecord(cwd);
+  return record.skills;
+}
+
+/** Upsert a single skillId's enabled flag. */
+async function setProjectSkill(cwd, skillId, enabled) {
+  addAllowedRoot(cwd);
+  const record = await loadRecord(cwd);
+  const idx = record.skills.findIndex((s) => s.skillId === skillId);
+  if (idx >= 0) {
+    record.skills[idx] = { skillId, enabled };
+  } else {
+    record.skills.push({ skillId, enabled });
+  }
+  await saveRecord(cwd, record);
+  return { ok: true };
+}
+
+// ──────────────────────────────────────────── IPC schemas
+const projectSkillsCwd = z.object({
+  cwd: z.string().min(1).max(4096),
+});
+
+const projectSkillsSet = z.object({
+  cwd: z.string().min(1).max(4096),
+  skillId: z.string().min(1).max(256),
+  enabled: z.boolean(),
+});
+
+function validated(schema, handler) {
+  return (_event, payload) => {
+    const parsed = schema.parse(payload);
+    return handler(parsed);
+  };
+}
+
+function registerProjectSkillsHandlers() {
+  ipcMain.handle(
+    'project-skills:get',
+    validated(projectSkillsCwd, ({ cwd }) => getProjectSkills(cwd)),
+  );
+  ipcMain.handle(
+    'project-skills:set',
+    validated(projectSkillsSet, ({ cwd, skillId, enabled }) =>
+      setProjectSkill(cwd, skillId, enabled),
+    ),
+  );
+}
+
+module.exports = {
+  registerProjectSkillsHandlers,
+  // Exported for tests / direct use.
+  getProjectSkills,
+  setProjectSkill,
+  projectSkillsPath,
+};