claude-code-session-manager 0.104.2 → 0.106.0

package/scripts/scheduler-mcp-server.cjs

@@ -16,6 +16,8 @@
  *
  *   macro_list({ cwd? }) -> GET  /admin/macros?cwd=<encoded>
  *   macro_save({ cwd?, id?, label, agentName, tag, prompt }) -> POST /admin/macros/save
+ *   customer_feedback_list({ pull?, includeHidden? }) -> GET  /admin/customer-feedback/inbox
+ *   customer_feedback_set_status({ id, status, note? }) -> POST /admin/customer-feedback/status
  *
  * This is a separate process from the Electron app — it only ever reaches
  * it over the token-authed loopback HTTP API in admin-api.json, never by
@@ -30,12 +32,7 @@ const { PROC_NAMES, setProcessTitle } = require('../src/main/lib/smProcNames.cjs
 setProcessTitle(PROC_NAMES.mcpServer);
 const path = require('node:path');
 const fsp = require('node:fs/promises');
-const { Server } = require('@modelcontextprotocol/sdk/server/index.js');
-const { StdioServerTransport } = require('@modelcontextprotocol/sdk/server/stdio.js');
-const {
-  ListToolsRequestSchema,
-  CallToolRequestSchema,
-} = require('@modelcontextprotocol/sdk/types.js');
+const { createStdioServer } = require('../src/main/lib/mcpStdioServer.cjs');
 const { PRD_WORK_TYPES } = require('../src/main/lib/workTypeLibrary.cjs');
 const { MCP_TOOL_CATALOG, MCP_RECIPES, composeDescription } = require('../src/main/lib/mcpToolCatalog.cjs');
 
@@ -424,6 +421,30 @@ const TOOLS = [
       required: ['label', 'agentName', 'tag', 'prompt'],
     },
   },
+  {
+    name: 'customer_feedback_list',
+    description: descriptionFor('customer_feedback_list'),
+    inputSchema: {
+      type: 'object',
+      properties: {
+        pull: { type: 'boolean', description: 'Fetch new items from the feedback service before listing. Default true.' },
+        includeHidden: { type: 'boolean', description: 'Include moderated-away items. Default false.' },
+      },
+    },
+  },
+  {
+    name: 'customer_feedback_set_status',
+    description: descriptionFor('customer_feedback_set_status'),
+    inputSchema: {
+      type: 'object',
+      properties: {
+        id: { type: 'string', description: 'Feedback item id (from customer_feedback_list).' },
+        status: { type: 'string', enum: ['open', 'in_progress', 'resolved', 'wontfix'], description: 'New status.' },
+        note: { type: 'string', description: 'Optional short note shown to the customer.' },
+      },
+      required: ['id', 'status'],
+    },
+  },
   {
     name: 'session_manager_help',
     description: descriptionFor('session_manager_help'),
@@ -437,13 +458,6 @@ const TOOLS = [
   },
 ];
 
-const server = new Server(
-  { name: 'session-manager-scheduler', version: '1.0.0' },
-  { capabilities: { tools: {} } }
-);
-
-server.setRequestHandler(ListToolsRequestSchema, async () => ({ tools: TOOLS }));
-
 // Named + exported (see module.exports below) so mcpToolCatalog.test.cjs's
 // sibling can exercise session_manager_help's argument handling directly —
 // mocking node:fs/promises + global.fetch to drive adminRequest — without
@@ -674,6 +688,24 @@ async function handleCallTool(request) {
       const result = await adminRequest('POST', '/admin/macros/save', payload);
       return { content: [{ type: 'text', text: JSON.stringify(result) }] };
     }
+    if (name === 'customer_feedback_list') {
+      const qs = new URLSearchParams();
+      if (!args || args.pull !== false) qs.set('pull', '1');
+      if (args && args.includeHidden === true) qs.set('includeHidden', '1');
+      const result = await adminRequest('GET', `/admin/customer-feedback/inbox?${qs.toString()}`);
+      if (result?.ok === false) return errorResult(result.error ?? 'customer_feedback_list failed');
+      return { content: [{ type: 'text', text: JSON.stringify(result) }] };
+    }
+    if (name === 'customer_feedback_set_status') {
+      if (!args || typeof args.id !== 'string' || !args.id || typeof args.status !== 'string') {
+        return errorResult('missing or invalid required argument(s): id, status');
+      }
+      const payload = { id: args.id, status: args.status };
+      if (typeof args.note === 'string' && args.note) payload.note = args.note;
+      const result = await adminRequest('POST', '/admin/customer-feedback/status', payload);
+      if (result?.ok === false) return errorResult(result.error ?? 'customer_feedback_set_status failed');
+      return { content: [{ type: 'text', text: JSON.stringify(result) }] };
+    }
     if (name === 'session_manager_help') {
       const toolName = args && typeof args.tool === 'string' ? args.tool : null;
       const topic = args && typeof args.topic === 'string' ? args.topic : null;
@@ -713,11 +745,13 @@ async function handleCallTool(request) {
   }
 }
 
-server.setRequestHandler(CallToolRequestSchema, handleCallTool);
-
 async function main() {
-  const transport = new StdioServerTransport();
-  await server.connect(transport);
+  createStdioServer({
+    name: 'session-manager-scheduler',
+    version: '1.0.0',
+    listTools: () => TOOLS,
+    callTool: (params) => handleCallTool({ params }),
+  }).start();
 }
 
 // Guarded so mcpToolCatalog.test.cjs can `require()` this file to read TOOLS

package/src/main/build-info.json

@@ -1,8 +1,8 @@
 {
-  "version": "0.104.2",
-  "gitSha": "624deb56c80a4f331daa808a77f7c19a39b1b63d",
-  "gitShortSha": "624deb56",
+  "version": "0.106.0",
+  "gitSha": "6b6a18cb35bd060a6fa46a6645068a8768c9ff34",
+  "gitShortSha": "6b6a18cb",
   "gitBranch": "HEAD",
-  "builtAt": "2026-10-04T12:28:16.870Z",
+  "builtAt": "2026-10-09T03:16:51.117Z",
   "dirty": false
 }

package/src/main/chatRunner.cjs

@@ -52,6 +52,7 @@ const { extractJson } = require('./lib/extractJson.cjs');
 const { classifyPromptTicket } = require('./lib/classifyPromptTicket.cjs');
 const sessionSlots = require('./lib/sessionSlots.cjs');
 const opsErrorLog = require('./lib/opsErrorLog.cjs');
+const { killTree, detachedSpawnOpts } = require('./lib/killTree.cjs');
 const agentModelResolve = require('./lib/agentModelResolve.cjs');
 const { resolveEpicEffort, effortArgs } = require('./lib/agentEffortResolve.cjs');
 const { planEpicSpawn } = require('./lib/epicSpawnPlan.cjs');
@@ -629,9 +630,8 @@ function executeRun({ tabId, sessionId, prompt, cwd, resume, silent, onSilentRes
       if (killed) return;
       killed = true;
       if (!child) return;
-      // Negative pid targets the process group (requires detached: true)
-      try { process.kill(-child.pid, sig); }
-      catch { try { child.kill(sig); } catch { /* already dead */ } }
+      // Group kill on POSIX / taskkill /T on win32 (requires detachedSpawnOpts at spawn)
+      if (!killTree(child.pid, sig)) { try { child.kill(sig); } catch { /* already dead */ } }
     };
 
     const cancelFn = () => {
@@ -690,13 +690,15 @@ function executeRun({ tabId, sessionId, prompt, cwd, resume, silent, onSilentRes
     // real-time NDJSON streaming; stderr piped for error-message capture.
     let thisChild;
     try {
-      const target = claudeSpawnTarget('chat', sessionId, claudeBin);
-      thisChild = spawn(target.command, buildArgs(resumeFlag), {
+      const chatArgs = buildArgs(resumeFlag);
+      const target = claudeSpawnTarget('chat', sessionId, claudeBin, chatArgs);
+      thisChild = spawn(target.command, target.args || chatArgs, {
         ...(target.argv0 ? { argv0: target.argv0 } : {}),
+        ...(target.windowsVerbatimArguments ? { windowsVerbatimArguments: true } : {}),
         cwd: execCwd,
         env: childEnv,
         stdio: ['ignore', 'pipe', 'pipe'],
-        detached: true, // own process group so killTree can SIGTERM descendants
+        ...detachedSpawnOpts(), // own process group so killTree can SIGTERM descendants
       });
     } catch (err) {
       clearTimeout(killTimer);

package/src/main/crashDiagnostics.cjs

@@ -56,15 +56,51 @@ function sentinelFile() {
 // crashes (NOT OOM — a SIGKILL leaves no dump). Local-only, never uploaded.
 // Must run before the app is ready, so call this at module require time from
 // index.cjs's top level.
-function startCrashReporter() {
+//
+// On Windows Electron relaunches this exe as the crashpad handler with
+// --database=<crashDumps path>; an empty path makes the handler exit with
+// "--database is required" and the browser process self-terminates before any
+// window opens. So we resolve a non-empty dir first, and skip start() entirely
+// if we cannot — crash reporting must never be able to stop boot.
+// `deps` is injectable for tests; the runtime call signature is unchanged.
+function startCrashReporter(deps = {}) {
+  const a = deps.app || app;
+  const reporter = deps.crashReporter || crashReporter;
+  const fsImpl = deps.fs || fs;
+  const log = deps.log || ((msg) => console.warn(msg));
   try {
-    crashReporter.start({
+    const reasons = [];
+    const getDir = (name) => {
+      try {
+        const d = a.getPath(name);
+        if (typeof d === 'string') return d.trim();
+        reasons.push(`${name}: non-string ${typeof d}`);
+      } catch (err) {
+        reasons.push(`${name}: ${err && err.message}`);
+      }
+      return '';
+    };
+    let dir = getDir('crashDumps');
+    let fellBack = false;
+    if (!dir) {
+      const userData = getDir('userData');
+      if (userData) { dir = path.join(userData, 'Crashpad'); fellBack = true; }
+    }
+    if (!dir) {
+      log('[crash-diag] no crashDumps/userData path; crash reporter skipped' + (reasons.length ? ` (${reasons.join('; ')})` : ''));
+      return;
+    }
+    fsImpl.mkdirSync(dir, { recursive: true });
+    if (fellBack) a.setPath('crashDumps', dir);
+    reporter.start({
       productName: 'claude-code-session-manager',
       companyName: 'session-manager',
       uploadToServer: false,
       compress: true,
     });
-  } catch { /* best-effort: diagnostics must never break boot */ }
+  } catch (err) {
+    try { (deps.log || ((m) => console.warn(m)))(`[crash-diag] crash reporter skipped: ${err && err.message}`); } catch { /* ignore */ }
+  }
 }
 
 // Snapshot per-process memory. app.getAppMetrics() returns one entry per

package/src/main/historyAggregator.cjs

@@ -92,7 +92,12 @@ async function mapWithConcurrency(items, limit, fn) {
 
 // ── date helpers ──────────────────────────────────────────────────────────────
 
-function decodeCwd(encoded) {
+function decodeCwd(encoded, platform = process.platform) {
+  // encodeCwd turns `C:\\Users\\Me` into `C--Users-Me`: drive letter, then `--`.
+  if (platform === 'win32') {
+    const m = /^([A-Za-z])--(.*)$/.exec(encoded);
+    if (m) return m[1] + ':\\' + m[2].replace(/-+/g, '\\');
+  }
   return '/' + encoded.replace(/-+/g, '/');
 }
 
@@ -944,6 +949,7 @@ module.exports = {
   remote,
   MODEL_PRICING,
   finalizeClosedDays,
+  decodeCwd,
   refreshIntradayToday,
   computeIntradayBuckets,
   // exported for tests

package/src/main/index.cjs

@@ -1,3 +1,15 @@
+// Boot diagnostic (SM_BOOT_DIAG=1, set by the packaged smoke): one stderr line that
+// shows whether `electron` resolved to the built-in module or ran in node mode.
+if (process.env.SM_BOOT_DIAG === '1') {
+  try {
+    const e = require('electron');
+    let userData;
+    try { userData = String(e.app.getPath('userData')); } catch (err) { userData = `error: ${err && err.message}`; }
+    process.stderr.write(`[boot-diag] platform=${process.platform} electron=${process.versions.electron} typeof electron=${typeof e} typeof electron.app=${typeof (e && e.app)} ELECTRON_RUN_AS_NODE=${process.env.ELECTRON_RUN_AS_NODE} execPath=${process.execPath} __dirname=${__dirname} userData=${userData}\n`);
+  } catch (err) {
+    process.stderr.write(`[boot-diag] failed: ${err && err.message}\n`);
+  }
+}
 const { PROC_NAMES, setProcessTitle, inhibitHolderShell } = require('./lib/smProcNames.cjs');
 // Self-describing `comm` in System Monitor (pn-03). process.argv is a JS copy
 // made at startup, so the argv-memory overwrite below never affects the
@@ -10,7 +22,9 @@ const fs = require('node:fs');
 const fsp = require('node:fs/promises');
 const os = require('node:os');
 const { schemas, validated } = require('./ipcSchemas.cjs');
+const { createProjectFolder } = require('./lib/projectFolder.cjs');
 const { cleanChildEnv } = require('./lib/cleanEnv.cjs');
+const { applyLoginShellPath } = require('./lib/loginShellPath.cjs');
 const { terminateLosingInstance } = require('./lib/singleInstanceGuard.cjs');
 const { acquireSchedulerOwnership, releaseSchedulerOwnership } = require('./lib/instanceLock.cjs');
 const { manager: ptyManager, registerPtyHandlers } = require('./pty.cjs');
@@ -25,6 +39,20 @@ const crashDiagnostics = require('./crashDiagnostics.cjs');
 // Start the local minidump collector before app-ready (required by Electron).
 // Catches renderer/GPU SIGSEGV/SIGABRT; OOM-kills leave no dump but are caught
 // by the sentinel + render-process-gone hooks in crashDiagnostics.init().
+// ELECTRON_RUN_AS_NODE audit: every src/main site (appRuntime, watchdogHelpers,
+// seedSchedulerMcp, timeoutShim) sets it only in a child's env / launcher text,
+// or deletes it from a copied env — none writes the main process.env, so it
+// cannot leak into Electron's own children (crashpad handler included).
+// Chromium can't resolve known folders under a stripped Windows profile; pin an explicit
+// userData path first (never allowed to stop boot).
+try {
+  require('./lib/winUserData.cjs').ensureWinUserDataPath({
+    app: require('electron').app, env: process.env, platform: process.platform, fs: require('node:fs'), os: require('node:os'),
+    log: (m) => process.stderr.write(`${m}\n`),
+  });
+} catch (err) {
+  process.stderr.write(`[win-userdata] fallback failed: ${err && err.message}\n`);
+}
 crashDiagnostics.startCrashReporter();
 const voiceHotkey = require('./voiceHotkey.cjs');
 const voiceWizard = require('./voiceWizard.cjs');
@@ -40,6 +68,7 @@ const chatRunner = require('./chatRunner.cjs');
 const promptSessionEvents = require('./promptSessionEvents.cjs');
 const activeIndexMerge = require('./lib/activeIndexMerge.cjs');
 const promptSessionsCreateEpic = require('./lib/promptSessionsCreateEpic.cjs');
+const customerFeedbackIpc = require('./lib/customerFeedbackIpc.cjs');
 const epicWorktreeMint = require('./lib/epicWorktreeMint.cjs');
 const epicWorktreeMerge = require('./lib/epicWorktreeMerge.cjs');
 const epicWorktreeProjectConfig = require('./lib/epicWorktreeProjectConfig.cjs');
@@ -67,6 +96,7 @@ chatRunner.registerAdminRoute(adminHttp);
 // several projects' operations roots open, so it performs the cross-folder
 // write (lib/crossProjectFeedback.cjs).
 crossProjectFeedback.registerAdminRoute(adminHttp);
+require('./lib/customerFeedbackAdminRoutes.cjs').registerAdminRoute(adminHttp);
 const supervisor = require('./supervisor.cjs');
 const watchers = require('./watchers.cjs');
 const queueOps = require('./queueOps.cjs');
@@ -101,7 +131,8 @@ const { registerDocEditHandlers, attachWindow: attachDocEditWindow } = require('
 const { listExchanges } = require('./exchanges.cjs');
 const { resolveClaudeBin } = require('./lib/claudeBin.cjs');
 const { checkInsideHome, assertInsideHome } = require('./lib/insideHome.cjs');
-const { openInEditor, openFileInEditor, openInFinder, openInTerminal } = require('./lib/openExternalApp.cjs');
+const { openInEditor, openFileInEditor, openInFinder, openInTerminal, runInTerminal } = require('./lib/openExternalApp.cjs');
+const { checkPrereqs } = require('./lib/prereqs.cjs');
 const { rebuildActiveIndex } = require('./lib/activeIndexRebuild.cjs');
 const { activeIndexPath: promptSessionsActiveIndexPath } = require('./lib/epicMint.cjs');
 const { allProjectCwds } = require('./lib/activeSessions.cjs');
@@ -266,6 +297,8 @@ function writeFirstPaintFailureLog() {
   }
 }
 
+const { isPackagedApp } = require('./lib/appRuntime.cjs');
+
 function resolveNpx() {
   const isWin = process.platform === 'win32';
   try {
@@ -373,6 +406,14 @@ async function performReboot() {
   // Bounded-lifetime marker: the watchdog must not relaunch a second instance
   // during this deliberate exit window (single-instance-lock race).
   upgradeDrain.markRestarting();
+  if (isPackagedApp()) {
+    // Installer build: no npx — restart the app binary in place.
+    logReboot('packaged build: app.relaunch()');
+    app.relaunch();
+    runShutdownCleanup();   // app.exit bypasses will-quit
+    app.exit(0);
+    return;
+  }
   let childOk = false;
   try {
     const child = relaunchViaNpx();
@@ -715,6 +756,15 @@ ipcMain.handle('app:engage-rules-path', () => process.env.SESSION_MANAGER_ENGAGE
 // on disk or the home self-check failed (e.g. macOS /Users symlink mismatch).
 ipcMain.handle('app:claude-bin-status', () => bootClaudeBin);
 ipcMain.handle('app:home-self-check', () => bootHomeSelfCheck);
+ipcMain.handle('app:prereqs', async () => await checkPrereqs());
+// Renderer sends only an id; the command always comes from a fresh main-side probe.
+ipcMain.handle('app:prereqs-run-fix', async (_e, id) => {
+  const items = await checkPrereqs();
+  const item = typeof id === 'string' ? items.find((i) => i.id === id) : undefined;
+  if (!item) throw new Error(`unknown prereq id: ${String(id)}`);
+  if (!item.fix || !item.fix.command) throw new Error(`prereq ${id} has no fix command`);
+  return runInTerminal({ command: item.fix.command, shell: item.fix.shell });
+});
 // First-boot seeder outcomes ('done' | 'pending' | 'exhausted' per seeder),
 // read live from each seeder's own marker file — see seedStatus.cjs.
 ipcMain.handle('app:seed-status', () => getSeedStatus());
@@ -722,9 +772,9 @@ ipcMain.handle('app:seed-status', () => getSeedStatus());
 ipcMain.handle('app:pick-directory', async () => {
   console.log('[main] pick-directory invoked');
   const result = await dialog.showOpenDialog(mainWindow, {
-    // createDirectory enables the picker's "New Folder" affordance (macOS;
-    // the GTK chooser has its own) — this is the "Start Project" path:
-    // create a fresh folder in place, open it as the project's TAB.
+    // createDirectory is macOS-only (it adds the picker's "New Folder"
+    // button there). Linux/Windows users create folders via the in-app
+    // Start new project form (app:create-project-folder, below).
     properties: ['openDirectory', 'createDirectory'],
     defaultPath: os.homedir(),
     title: 'Open a project folder — or create a new one to start a project',
@@ -734,6 +784,12 @@ ipcMain.handle('app:pick-directory', async () => {
   return result.filePaths[0];
 });
 
+ipcMain.handle('app:create-project-folder', validated(schemas.appCreateProjectFolder, async (payload) => {
+  const result = await createProjectFolder(payload);
+  console.log('[main] create-project-folder', result.ok ? 'ok' : result.code, JSON.stringify({ parentDir: payload.parentDir, name: payload.name }));
+  return result;
+}));
+
 ipcMain.on('app:reboot-app', (_e, opts) => { rebootApp({ force: opts?.force === true }).catch((e) => logReboot(`reboot failed: ${e?.message}`)); });
 
 // Image paste — Ctrl+V in the Terminal pane. Reads the OS clipboard via
@@ -1009,6 +1065,7 @@ pluginInstall.registerPluginInstallHandlers();
 memoryTool.registerMemoryHandlers();
 activeIndexMerge.registerActiveIndexMergeHandlers();
 promptSessionsCreateEpic.registerPromptSessionsCreateEpicHandlers();
+customerFeedbackIpc.registerCustomerFeedbackHandlers();
 epicWorktreeMint.registerEpicWorktreeMintHandlers();
 epicWorktreeMerge.registerEpicWorktreeMergeHandlers();
 epicWorktreeProjectConfig.registerEpicWorktreeProjectConfigHandlers();
@@ -1190,6 +1247,18 @@ app.whenReady().then(async () => {
     onSuspendWhileAlive: () => { stopSystemdInhibit(); startSystemdInhibit(); },
   });
 
+  // A Finder/Dock-launched packaged app inherits a minimal PATH; adopt the
+  // login shell's so node/git/claude resolve like in the user's terminal.
+  // Must run before resolveClaudeBin() and before any pty/scheduler/MCP spawn.
+  if (process.platform !== 'win32' && process.env.SM_SKIP_LOGIN_SHELL_PATH !== '1') {
+    try {
+      const loginPath = await applyLoginShellPath();
+      logs.writeLine({ scope: 'main', level: 'info', message: 'login-shell PATH', meta: loginPath });
+    } catch (err) {
+      logs.writeLine({ scope: 'main', level: 'warn', message: 'login-shell PATH failed', meta: { error: String(err && err.message || err) } });
+    }
+  }
+
   // Boot-time detection 1: surface `claude` binary resolution so a missing
   // install becomes visible to the renderer instead of failing silently on
   // first spawn attempt.

package/src/main/ipcSchemas.cjs

@@ -687,6 +687,13 @@ const delegationReadinessCwd = z.object({
   cwd: z.string().min(1).max(4096),
 }).strict();
 
+// app:create-project-folder — name semantics (separators, '..') are checked in
+// lib/projectFolder.cjs, not here.
+const appCreateProjectFolder = z.object({
+  parentDir: z.string().min(1).max(4096),
+  name: z.string().min(1).max(255),
+}).strict();
+
 // ──────────────────────────────────────────── Agent persona body (New Epic AIM)
 const agentsGetPersonaBody = z.object({
   cwd: z.string().min(1).max(4096),
@@ -1051,6 +1058,20 @@ const telemetrySetConfig = z.object({
   schemaVersion: z.literal(1),
 });
 
+const customerFeedbackSubmit = z.object({
+  title: z.string().max(120),
+  body: z.string().max(4000),
+  tag: z.enum(['bug', 'feature', 'discussion']),
+});
+const customerFeedbackMarkSeen = z.object({ ids: z.array(z.string().max(200)).max(500).optional() });
+const customerFeedbackInboxList = z.object({ includeHidden: z.boolean().optional() });
+const customerFeedbackInboxSetStatus = z.object({
+  id: z.string().max(200),
+  status: z.enum(['open', 'in_progress', 'resolved', 'wontfix']),
+  note: z.string().max(500).optional(),
+});
+const customerFeedbackInboxLinkEpic = z.object({ id: z.string().max(200), epicId: z.string().max(200) });
+
 /**
  * Wrap an IPC handler with schema validation. Returns a new handler that
  * parses the payload before calling the original. On invalid payload throws
@@ -1179,7 +1200,13 @@ module.exports = {
     agentsResolveEpicModel,
     agentsResolveEpicEffort,
     delegationReadinessCwd,
+    appCreateProjectFolder,
     telemetrySetConfig,
+    customerFeedbackSubmit,
+    customerFeedbackMarkSeen,
+    customerFeedbackInboxList,
+    customerFeedbackInboxSetStatus,
+    customerFeedbackInboxLinkEpic,
   },
   validated,
 };

package/src/main/lib/agentPersonaSchema.cjs

@@ -22,6 +22,7 @@
  */
 'use strict';
 
+const path = require('node:path');
 const { z } = require('zod');
 const { WorkTypeSchema, LEGACY_WORK_TYPES } = require('./workTypeLibrary.cjs');
 const { PERSONA_NAME_RE, ALL_PROJECTS } = require('../agentLibrary.cjs');
@@ -35,8 +36,13 @@ const BoundedString = z.string().max(2000);
 // `projects` entries are either the `'*'` sentinel (every project) or an
 // absolute path — agentLibrary.cjs's openProjects always deals in absolute
 // cwds, and a relative entry could never match one.
+/** @param {string} v @param {NodeJS.Platform} [platform] */
+function isAbsoluteForPlatform(v, platform = process.platform) {
+  return (platform === 'win32' ? path.win32 : path.posix).isAbsolute(v);
+}
+
 const ProjectEntrySchema = z.string().refine(
-  (v) => v === ALL_PROJECTS || v.startsWith('/'),
+  (/** @type {string} */ v) => v === ALL_PROJECTS || isAbsoluteForPlatform(v),
   `must be "${ALL_PROJECTS}" or an absolute path`,
 );
 
@@ -95,4 +101,5 @@ function assertValidAgentPersonaSave(persona) {
 module.exports = {
   AgentPersonaSaveSchema,
   assertValidAgentPersonaSave,
+  isAbsoluteForPlatform,
 };

package/src/main/lib/appRuntime.cjs

@@ -0,0 +1,57 @@
+/**
+ * appRuntime.cjs — how to run a Node script from an EXTERNAL process.
+ *
+ * Packaged installer builds may have no system `node`, so scripts handed to
+ * Claude Code hooks / MCP registrations run through the app's own binary with
+ * ELECTRON_RUN_AS_NODE=1. npx/dev builds keep using `node`.
+ */
+
+'use strict';
+
+/**
+ * @param {{ packaged?: boolean }} [opts]
+ * @returns {boolean}
+ */
+function isPackagedApp(opts) {
+  if (opts && typeof opts.packaged === 'boolean') return opts.packaged;
+  if (process.env.SM_FORCE_PACKAGED === '1') return true;
+  try {
+    return require('electron').app?.isPackaged === true;
+  } catch {
+    return false;
+  }
+}
+
+/**
+ * @param {string} scriptPath
+ * @param {{ packaged?: boolean, execPath?: string }} [opts]
+ * @returns {{ command: string, args: string[], env: Record<string, string> }}
+ */
+function nodeSpawnSpec(scriptPath, opts) {
+  if (!isPackagedApp(opts)) return { command: 'node', args: [scriptPath], env: {} };
+  return {
+    command: (opts && opts.execPath) || process.execPath,
+    args: [scriptPath],
+    env: { ELECTRON_RUN_AS_NODE: '1' },
+  };
+}
+
+/** @param {string} p */
+function quote(p) {
+  if (p.includes('"')) throw new Error(`appRuntime: path contains a double quote: ${p}`);
+  return `"${p}"`;
+}
+
+/**
+ * Shell command string (hook `command` fields). Paths are double-quoted.
+ * @param {string} scriptPath
+ * @param {{ packaged?: boolean, execPath?: string }} [opts]
+ * @returns {string}
+ */
+function nodeShellCommand(scriptPath, opts) {
+  if (!isPackagedApp(opts)) return `node ${quote(scriptPath)}`;
+  const execPath = (opts && opts.execPath) || process.execPath;
+  return `ELECTRON_RUN_AS_NODE=1 ${quote(execPath)} ${quote(scriptPath)}`;
+}
+
+module.exports = { isPackagedApp, nodeSpawnSpec, nodeShellCommand };

package/src/main/lib/childWithLog.cjs

@@ -52,6 +52,7 @@
 
 const fs = require('node:fs');
 const { spawn, execFile } = require('node:child_process');
+const { killTree } = require('./killTree.cjs');
 
 // Injectable for tests (enumeration-failure coverage).
 const deps = { execFile };
@@ -150,6 +151,7 @@ function openLog(logPath) {
 // Async: resolves to the survivors list, rejects on ps failure/timeout. O(P) in
 // the process table, off the main event loop.
 function enumerateProcessGroupSurvivors(pgid) {
+  // ps -eo is Linux-only; on win32 (and macOS) report the empty/unknown result without spawning ps.
   if (process.platform !== 'linux') return Promise.resolve([]);
   if (!pgid || pgid <= 1) return Promise.resolve([]);
   return new Promise((resolve, reject) => {
@@ -182,12 +184,14 @@ function sweepChildProcessGroup(child, detached, safeLog) {
   if (!child || !child.pid || child.pid <= 1) return null;
   // Defensive: never target the Session Manager process's own group.
   if (child.pid === process.pid) return null;
+  // win32 has no process groups; taskkill on an already-exited pid risks hitting a reused pid.
+  if (process.platform === 'win32') return null;
 
   const pid = child.pid;
   const kill = () => {
-    try { process.kill(-pid, 'SIGTERM'); } catch { /* ESRCH: empty group, the normal case */ }
+    killTree(pid, 'SIGTERM'); // ESRCH on an empty group is the normal case
     const t = setTimeout(() => {
-      try { process.kill(-pid, 'SIGKILL'); } catch { /* ESRCH: empty group, the normal case */ }
+      killTree(pid, 'SIGKILL');
     }, POST_EXIT_GROUP_SWEEP_GRACE_MS);
     if (t.unref) t.unref();
   };
@@ -219,13 +223,9 @@ function withChildAndLog({ fd, logPath, safeLog, closeFd, spawn: spawnSpec, watc
     killTree(signal) {
       const c = ctx.child;
       if (!c) return false;
-      // Negative pid targets the whole process group (requires detached: true at spawn).
-      // Falls back to direct kill if the process is not a group leader.
-      try { process.kill(-c.pid, signal); return true; }
-      catch {
-        try { process.kill(c.pid, signal); return true; }
-        catch { return false; /* already dead */ }
-      }
+      // Whole process group on POSIX / taskkill /T on win32 (requires detachedSpawnOpts at spawn);
+      // killTree falls back to the bare pid if the process is not a group leader.
+      return killTree(c.pid, signal, { log: safeLog });
     },
     addTimer(t) { extraTimers.push(t); },
   };
@@ -315,7 +315,7 @@ function withChildAndLog({ fd, logPath, safeLog, closeFd, spawn: spawnSpec, watc
   const cancel = () => {
     clearAllTimers();
     // Best-effort kill; ignore errors (process may already be gone).
-    try { process.kill(-child.pid, 'SIGKILL'); } catch {
+    if (!killTree(child.pid, 'SIGKILL', { log: safeLog })) {
       try { child.kill('SIGKILL'); } catch { /* */ }
     }
   };