claude-code-session-manager 0.119.0 → 0.120.0

package/src/main/lib/epic/archivedTranscript.cjs

@@ -0,0 +1,91 @@
+'use strict';
+
+/**
+ * archivedTranscript.cjs — gzip sidecar store for the raw Claude JSONL that
+ * archived Epic JSONs used to embed as a `transcript` string. The sidecar
+ * lives at `prompt-sessions/transcripts-archive/<epicId>.jsonl.gz` (inside the
+ * `prompt-sessions` namespace, so the `epics` owner already covers it) and the
+ * caller keeps only the small pointer returned by writeSidecar.
+ *
+ * Electron-free at load (like epicStatusMirror.cjs); registerIpc takes ipcMain.
+ */
+
+const crypto = require('node:crypto');
+const fs = require('node:fs');
+const zlib = require('node:zlib');
+const { assertOpsWrite, opsPath } = require('../opsOwnership.cjs');
+const atomicFs = require('../util/atomicFs.cjs');
+
+const SUBDIR = 'transcripts-archive';
+
+function assertSafeEpicId(epicId) {
+  if (typeof epicId !== 'string' || !epicId || epicId.includes('..') || /[\\/\0]/.test(epicId)) {
+    throw new Error(`archivedTranscript: invalid epicId "${epicId}"`);
+  }
+}
+
+function sidecarPath(cwd, epicId) {
+  assertSafeEpicId(epicId);
+  return opsPath(cwd, 'prompt-sessions', SUBDIR, `${epicId}.jsonl.gz`);
+}
+
+const sha256Of = (text) => crypto.createHash('sha256').update(text, 'utf8').digest('hex');
+
+/**
+ * writeSidecar(cwd, epicId, text) -> {path, bytes, gzBytes, sha256}.
+ * Idempotent: if the existing sidecar already decompresses to the same text,
+ * nothing is rewritten.
+ */
+function writeSidecar(cwd, epicId, text, { writer = 'epics' } = {}) {
+  if (typeof text !== 'string') throw new Error('archivedTranscript: text must be a string');
+  const file = sidecarPath(cwd, epicId);
+  assertOpsWrite(file, writer);
+  const sha256 = sha256Of(text);
+  const bytes = Buffer.byteLength(text, 'utf8');
+  const existing = readSidecar(cwd, epicId);
+  if (existing !== null && sha256Of(existing) === sha256) {
+    return { path: file, bytes, gzBytes: fs.statSync(file).size, sha256 };
+  }
+  const gz = zlib.gzipSync(Buffer.from(text, 'utf8'));
+  atomicFs.writeTextAtomicSync(file, gz);
+  return { path: file, bytes, gzBytes: gz.length, sha256 };
+}
+
+/** readSidecar(cwd, epicId) -> string | null (null when absent or unreadable). */
+function readSidecar(cwd, epicId) {
+  const file = sidecarPath(cwd, epicId);
+  try {
+    return zlib.gunzipSync(fs.readFileSync(file)).toString('utf8');
+  } catch {
+    return null;
+  }
+}
+
+/**
+ * archiveTranscript({cwd, epicId, claudeSessionId}, {resolvePath}) -> pointer | null.
+ * Reads the raw Claude JSONL main-side and writes the sidecar; null when the
+ * JSONL is missing or empty (caller falls back to durableTurns).
+ */
+function archiveTranscript(args, { resolvePath } = {}) {
+  const { cwd, epicId, claudeSessionId } = args || {};
+  if (typeof cwd !== 'string' || !require('node:path').isAbsolute(cwd)) {
+    throw new Error('archivedTranscript: cwd must be an absolute path');
+  }
+  assertSafeEpicId(epicId);
+  if (typeof claudeSessionId !== 'string' || !claudeSessionId) return null;
+  const resolve = resolvePath || ((c, s) => require('../../transcripts.cjs').transcriptPath(c, s));
+  let text;
+  try {
+    text = fs.readFileSync(resolve(cwd, claudeSessionId), 'utf8');
+  } catch {
+    return null;
+  }
+  if (!text) return null;
+  return writeSidecar(cwd, epicId, text);
+}
+
+function registerIpc(ipcMain, deps) {
+  ipcMain.handle('promptSessions:archiveTranscript', async (_e, payload) => archiveTranscript(payload, deps));
+}
+
+module.exports = { writeSidecar, readSidecar, sidecarPath, archiveTranscript, registerIpc };

package/src/main/lib/epic/archivedTranscriptMigration.cjs

@@ -0,0 +1,84 @@
+'use strict';
+
+/**
+ * archivedTranscriptMigration.cjs — one-shot, idempotent, crash-safe move of the
+ * embedded `transcript` string in archived Epic JSONs into the gzip sidecar
+ * (archivedTranscript.cjs). Per file: write sidecar -> re-read + compare sha ->
+ * only then atomically rewrite the JSON with `transcriptRef` and no `transcript`.
+ * A crash or failure before the rewrite leaves the original JSON byte-identical.
+ *
+ * Never touches `active-index.json` or files whose status is 'active'.
+ * Writes as the `epics` owner (the sidecar lives inside `prompt-sessions`).
+ */
+
+const fs = require('node:fs');
+const path = require('node:path');
+const { assertOpsWrite, opsPath } = require('../opsOwnership.cjs');
+const atomicFs = require('../util/atomicFs.cjs');
+const archivedTranscript = require('./archivedTranscript.cjs');
+
+const SKIP_FILES = new Set(['active-index.json']);
+
+/**
+ * migrateProject(projectRoot, {dryRun, limit, yieldFn, deps})
+ *   -> Promise<{scanned, migrated, skipped, freedBytes, errors}>
+ * `limit` caps files migrated (or failed) per call; dryRun counts what would
+ * migrate without writing. `deps` lets tests inject the sidecar functions.
+ */
+async function migrateProject(projectRoot, { dryRun = false, limit = Infinity, yieldFn = null, deps = {} } = {}) {
+  const writeSidecar = deps.writeSidecar || archivedTranscript.writeSidecar;
+  const readSidecar = deps.readSidecar || archivedTranscript.readSidecar;
+  const result = { scanned: 0, migrated: 0, skipped: 0, freedBytes: 0, errors: [] };
+  const dir = opsPath(projectRoot, 'prompt-sessions');
+  let names;
+  try {
+    names = fs.readdirSync(dir);
+  } catch {
+    return result;
+  }
+  let attempted = 0;
+  for (const name of names) {
+    if (!name.endsWith('.json') || SKIP_FILES.has(name)) continue;
+    if (attempted >= limit) break;
+    result.scanned += 1;
+    const file = path.join(dir, name);
+    try {
+      const raw = fs.readFileSync(file, 'utf8');
+      // Cheap pre-check so files without a transcript are never JSON-parsed.
+      if (!raw.includes('"transcript"')) { result.skipped += 1; continue; }
+      const doc = JSON.parse(raw);
+      if (!doc || typeof doc !== 'object' || typeof doc.transcript !== 'string' || doc.status === 'active') {
+        result.skipped += 1;
+        continue;
+      }
+      attempted += 1;
+      const epicId = name.slice(0, -'.json'.length);
+      if (dryRun) {
+        result.migrated += 1;
+        result.freedBytes += Buffer.byteLength(doc.transcript, 'utf8');
+        continue;
+      }
+      assertOpsWrite(file, 'epics');
+      const ref = writeSidecar(projectRoot, epicId, doc.transcript);
+      const back = readSidecar(projectRoot, epicId);
+      if (typeof back !== 'string' || archivedTranscriptSha(back) !== ref.sha256) {
+        throw new Error('sidecar sha mismatch');
+      }
+      const { transcript: _drop, ...rest } = doc;
+      const next = { ...rest, transcriptRef: { path: ref.path, bytes: ref.bytes, gzBytes: ref.gzBytes, sha256: ref.sha256 } };
+      atomicFs.writeJsonAtomicSync(file, next);
+      result.migrated += 1;
+      result.freedBytes += Math.max(0, Buffer.byteLength(raw, 'utf8') - fs.statSync(file).size);
+    } catch (e) {
+      result.errors.push({ file: name, error: e && e.message ? e.message : String(e) });
+    }
+    if (yieldFn) await yieldFn();
+  }
+  return result;
+}
+
+function archivedTranscriptSha(text) {
+  return require('node:crypto').createHash('sha256').update(text, 'utf8').digest('hex');
+}
+
+module.exports = { migrateProject };

package/src/main/lib/epic/delegationReadiness.cjs

@@ -671,6 +671,7 @@ function logAutoInstallEvent({ cwd, guard, action, error }) {
       scope: 'delegationReadiness',
       level: action === 'error' ? 'error' : 'info',
       message: `auto-install ${guard}: ${action}`,
+      code: `guard-install-${action}:${guard}`,
       meta: { guard, action, ...(error ? { error } : {}) },
     });
   } catch { /* logging must never break the caller */ }
@@ -796,6 +797,7 @@ async function ensureGuardsInstalled(cwd, { homeDir = os.homedir() } = {}) {
 module.exports = {
   checkDelegationReadiness,
   ensureGuardsInstalled,
+  logAutoInstallEvent,
   clearGuardsInstalledCache,
   installPrdWriteGuard,
   installDestructiveGitGuard,

package/src/main/lib/epic/epicSettle.cjs

@@ -21,6 +21,17 @@ const ts = (at) => {
 const isValidatorCheckin = (e, bare) =>
   e.agentType === 'validator' || (e.agentType == null && bare.startsWith('validate-'));
 
+// Mirrors the scheduler's cancel rule locally (lib/epic stays free of scheduler deps).
+const isCancelledRow = (r) => {
+  if (!r || (r.status !== 'failed' && r.status !== 'needs_review')) return false;
+  if (typeof r.cancelledAt === 'string' && r.cancelledAt) return true;
+  const hist = Array.isArray(r.statusHistory) ? r.statusHistory : [];
+  for (let i = hist.length - 1; i >= 0; i--) {
+    if (hist[i] && hist[i].to === r.status) return hist[i].source === 'remote:cancelJob';
+  }
+  return false;
+};
+
 /**
  * @param {{ epicId: string, cwd?: string|null, events?: any[], jobs?: any[], now?: number, horizonMs?: number }} args
  */
@@ -34,8 +45,13 @@ function evaluateEpicSettle({ epicId, cwd, events, jobs, now, horizonMs } = {})
     (r) => r && (r.epicId === epicId || r.sourcePromptId === epicId) && (r.cwd == null || cwd == null || r.cwd === cwd),
   );
   const settled = !epicRows.some((r) => r.status === 'pending' || r.status === 'running');
+  const cancelled = epicRows
+    .filter(isCancelledRow)
+    .map((r) => String(r.slug))
+    .sort();
+  const cancelledSet = new Set(cancelled.flatMap((s) => [s, bareSlug(s)]));
   const parked = epicRows
-    .filter((r) => r.status === 'needs_review')
+    .filter((r) => r.status === 'needs_review' && !isCancelledRow(r))
     .map((r) => String(r.slug))
     .sort();
 
@@ -83,7 +99,7 @@ function evaluateEpicSettle({ epicId, cwd, events, jobs, now, horizonMs } = {})
   const failed = [];
   for (const [bare, { event, t }] of checkins) {
     if (event.outcome === 'failed') {
-      failed.push(event.prdSlug);
+      if (!cancelledSet.has(event.prdSlug) && !cancelledSet.has(bare)) failed.push(event.prdSlug);
       continue;
     }
     const v = verdicts.get(bare);
@@ -94,12 +110,12 @@ function evaluateEpicSettle({ epicId, cwd, events, jobs, now, horizonMs } = {})
   failed.sort();
 
   const digestKey = createHash('sha1')
-    .update(JSON.stringify({ verified, refuted, failed, parked, uncovered: uncovered.map((u) => u.slug) }))
+    .update(JSON.stringify({ verified, refuted, failed, parked, cancelled, uncovered: uncovered.map((u) => u.slug) }))
     .digest('hex')
     .slice(0, 16);
-  const hasContent = [uncovered, verified, refuted, failed, parked].some((l) => l.length > 0);
+  const hasContent = [uncovered, verified, refuted, failed, parked, cancelled].some((l) => l.length > 0);
 
-  return { settled, uncovered, verified, refuted, failed, parked, digestKey, hasContent };
+  return { settled, uncovered, verified, refuted, failed, parked, cancelled, digestKey, hasContent };
 }
 
 module.exports = { evaluateEpicSettle, DEFAULT_SETTLE_HORIZON_MS };

package/src/main/lib/epic/epicValidationHook.cjs

@@ -52,6 +52,7 @@ function buildSettledDigest(settle, { epicId, notValidatedReason } = {}) {
   const refuted = s.refuted || [];
   const failed = s.failed || [];
   const parked = s.parked || [];
+  const cancelled = s.cancelled || [];
   const notValidated = (s.uncovered || []).map((u) => (typeof u === 'string' ? u : u.slug));
   const lines = [
     `PLAN SETTLED — no PRD of this session is pending or running. This is ONE digest, not a per-PRD request.`,
@@ -70,6 +71,12 @@ function buildSettledDigest(settle, { epicId, notValidatedReason } = {}) {
   if (parked.length) {
     lines.push('', `Parked (needs_review) (${parked.length}):`, ...parked.map((p) => `- ${p}`));
   }
+  if (cancelled.length) {
+    lines.push(
+      '', `Cancelled (${cancelled.length}) — stopped by scheduler_cancel_job; only scheduler_reset_job revives them:`,
+      ...cancelled.map((c) => `- ${c}`),
+    );
+  }
   if (notValidated.length) {
     lines.push(
       '', `Not validated (${notValidated.length}) — ${notValidatedReason || 'no validator checked them'}:`,

package/src/main/lib/git/depHealth.cjs

@@ -0,0 +1,161 @@
+/**
+ * depHealth.cjs — detect and repair a broken pnpm node_modules in the main checkout.
+ *
+ * Incident: a `pnpm install` run through a symlinked worktree node_modules purged
+ * the main checkout's modules dir, so every later gate went red with
+ * `Cannot find module .../node_modules/typescript/bin/tsc`. Recovery is
+ * `pnpm install --offline` in the main checkout; it needs CI=1 plus
+ * `--config.confirmModulesPurge=false`, otherwise pnpm prompts and aborts with
+ * ERR_PNPM_ABORTED_REMOVE_MODULES_DIR_NO_TTY.
+ *
+ * Second incident (Bilko, 2026-10-18): the same install rewrote 37 workspace links
+ * in the main checkout's node_modules to point into a job worktree; once the
+ * worktree was deleted they all dangled. Workspace packages are not in the root
+ * package.json deps, so the deps check missed it. findWorktreeEscapingLinks flags
+ * top-level links that resolve into a worktree root or dangle.
+ *
+ * Neither function throws. The check runs on the scheduler main loop, so it is
+ * O(deps) stats plus one bounded top-level readdir (no deep walks).
+ */
+'use strict';
+
+const fs = require('node:fs');
+const path = require('node:path');
+const { execFile } = require('node:child_process');
+
+const MAX_DEPS = 200;
+const MAX_MISSING = 20;
+const TAIL_CHARS = 2000;
+const MAX_SCANNED = 2000;
+
+function defaultWorktreeRoots() {
+  try {
+    const sp = require('../scheduler/schedulerPaths.cjs');
+    return [sp.worktreeRoot('job'), sp.worktreeRoot('epic')].filter((r) => typeof r === 'string' && r);
+  } catch {
+    return [];
+  }
+}
+
+/**
+ * Scan node_modules/* and node_modules/@scope/* (lstat only, no deeper) for symlinks
+ * that resolve into a worktree root or whose target is gone.
+ * @param {string} mainCwd
+ * @param {{ worktreeRoots?: string[] }} [opts]
+ * @returns {{ intoWorktree: string[], dangling: string[] }}
+ */
+function findWorktreeEscapingLinks(mainCwd, opts = {}) {
+  const intoWorktree = [];
+  const dangling = [];
+  try {
+    const rawRoots = Array.isArray(opts.worktreeRoots) ? opts.worktreeRoots : defaultWorktreeRoots();
+    const roots = [];
+    for (const r of rawRoots) {
+      if (!r) continue;
+      roots.push(path.resolve(r));
+      try { roots.push(fs.realpathSync(r)); } catch { /* root absent */ }
+    }
+    const modules = path.join(mainCwd, 'node_modules');
+    let scanned = 0;
+    const check = (rel) => {
+      const full = path.join(modules, rel);
+      let target;
+      try {
+        target = fs.realpathSync(full);
+      } catch (e) {
+        if (dangling.length < MAX_MISSING) dangling.push(rel);
+        return;
+      }
+      if (roots.some((r) => target.startsWith(r + path.sep)) && intoWorktree.length < MAX_MISSING) {
+        intoWorktree.push(rel);
+      }
+    };
+    const entries = fs.readdirSync(modules, { withFileTypes: true });
+    outer: for (const ent of entries) {
+      if (ent.name.startsWith('.')) continue;
+      if (++scanned > MAX_SCANNED) break;
+      if (ent.name.startsWith('@')) {
+        let subs = [];
+        try { subs = fs.readdirSync(path.join(modules, ent.name), { withFileTypes: true }); } catch { continue; }
+        for (const sub of subs) {
+          if (sub.name.startsWith('.')) continue;
+          if (++scanned > MAX_SCANNED) break outer;
+          if (sub.isSymbolicLink()) check(`${ent.name}/${sub.name}`);
+        }
+      } else if (ent.isSymbolicLink()) {
+        check(ent.name);
+      }
+    }
+  } catch {
+    return { intoWorktree: [], dangling: [] };
+  }
+  return { intoWorktree, dangling };
+}
+
+/**
+ * @param {string} mainCwd
+ * @param {{ worktreeRoots?: string[] }} [opts]
+ * @returns {{ ok: boolean, skipped?: string, reason?: string, missing?: string[] }}
+ */
+function checkMainDependencyHealth(mainCwd, opts = {}) {
+  try {
+    if (!fs.existsSync(path.join(mainCwd, 'pnpm-lock.yaml'))) return { ok: true, skipped: 'not-pnpm' };
+    const modules = path.join(mainCwd, 'node_modules');
+    let isDir = false;
+    try { isDir = fs.statSync(modules).isDirectory(); } catch { /* missing */ }
+    if (!isDir) return { ok: false, reason: 'node_modules-missing' };
+    if (!fs.existsSync(path.join(modules, '.modules.yaml'))) return { ok: false, reason: 'modules-yaml-missing' };
+
+    const links = findWorktreeEscapingLinks(mainCwd, { worktreeRoots: opts && opts.worktreeRoots });
+    if (links.intoWorktree.length) return { ok: false, reason: 'links-into-worktree', missing: links.intoWorktree };
+    if (links.dangling.length) return { ok: false, reason: 'dangling-links', missing: links.dangling };
+
+    let pkg;
+    try {
+      pkg = JSON.parse(fs.readFileSync(path.join(mainCwd, 'package.json'), 'utf8'));
+    } catch {
+      return { ok: true, skipped: 'no-package-json' };
+    }
+    if (!pkg || typeof pkg !== 'object') return { ok: true, skipped: 'no-package-json' };
+    const names = [
+      ...Object.keys(pkg.dependencies || {}),
+      ...Object.keys(pkg.devDependencies || {}),
+    ].slice(0, MAX_DEPS);
+    const missing = [];
+    for (const name of names) {
+      try {
+        fs.statSync(path.join(modules, name, 'package.json'));
+      } catch {
+        if (missing.length < MAX_MISSING) missing.push(name);
+      }
+    }
+    return missing.length ? { ok: false, reason: 'unresolved-deps', missing } : { ok: true };
+  } catch {
+    return { ok: true, skipped: 'no-package-json' };
+  }
+}
+
+/**
+ * @param {string} mainCwd
+ * @returns {Promise<{ ok: boolean, code: number|null, tail: string }>}
+ */
+function repairMainDependencies(mainCwd) {
+  return new Promise((resolve) => {
+    try {
+      execFile(
+        process.env.SM_PNPM_BIN || 'pnpm',
+        ['install', '--offline', '--frozen-lockfile', '--config.confirmModulesPurge=false'],
+        { cwd: mainCwd, env: { ...process.env, CI: '1' }, timeout: 300_000, maxBuffer: 16 * 1024 * 1024 },
+        (err, stdout, stderr) => {
+          const tail = `${stdout || ''}${stderr || ''}`.slice(-TAIL_CHARS) || (err ? String(err.message) : '');
+          if (!err) return resolve({ ok: true, code: 0, tail });
+          resolve({ ok: false, code: typeof err.code === 'number' ? err.code : null, tail: tail || String(err.message) });
+        },
+      );
+    } catch (e) {
+      resolve({ ok: false, code: null, tail: String((e && e.message) || e) });
+    }
+  });
+}
+
+module.exports = { checkMainDependencyHealth, findWorktreeEscapingLinks, repairMainDependencies };

package/src/main/lib/git/worktreeDeps.cjs

@@ -9,12 +9,40 @@
  * `info/exclude` as `/<name>` — otherwise the link shows as untracked and the
  * job parks as `uncommitted_changes`.
  *
+ * pnpm projects are the exception for node_modules: `pnpm install` purges and
+ * rebuilds the modules dir THROUGH a symlink, wiping the main checkout's
+ * node_modules. So a pnpm worktree gets its own node_modules, installed
+ * offline from the shared store (`installed`); the main checkout is never
+ * touched. `node_modules/` (any depth) is excluded so nested workspace
+ * node_modules stay untracked.
+ *
+ * Relative `file:`/`link:` deps that point OUTSIDE the repo (e.g.
+ * `file:../Bilko/packages/host-kit`) cannot resolve from a worktree, which lives
+ * under the session-manager state dir rather than next to the sibling repo — the
+ * offline install would ENOENT and leave no node_modules. So before installing,
+ * `linkOutOfRepoLocalDeps` creates a symlink at the equivalent location relative
+ * to the worktree (first path segment past the `..` hops, e.g.
+ * `<worktrees>/<hash>/Bilko -> ~/Projects/Bilko`). That link may therefore sit
+ * OUTSIDE the worktree; it is only created where nothing exists, never inside
+ * the main checkout, and never overwrites anything.
+ *
+ * uv projects (`uv.lock`) are the exception for .venv/venv: `uv run` and
+ * `uv sync` re-sync the project env, and for an editable project install that
+ * rewrites site-packages/<pkg>.pth to the CURRENT tree's src. Through a shared
+ * symlink that silently repoints the main checkout's imports at the worktree
+ * (social-signals-trader, 2026-10-18), and worktree tests import whichever
+ * tree synced last. So a uv worktree gets its own env, built by an offline
+ * frozen `uv sync` (hardlinks from uv's cache — cheap); the main env is never
+ * linked. If that sync fails the name is skipped and the executor's own `uv`
+ * call builds a worktree-local env — never the main one.
+ *
  * Never throws; failures land in `skipped`.
  */
 'use strict';
 
 const fs = require('node:fs');
 const path = require('node:path');
+const { execFile } = require('node:child_process');
 const { execGit } = require('./gitExec.cjs');
 
 const DEFAULT_DEP_DIRS = ['node_modules', '.venv', 'venv'];
@@ -34,27 +62,141 @@ async function isIgnored(cwd, name) {
   } catch { return false; }
 }
 
-async function addExcludes(mainCwd, names) {
+/** True when mainCwd is a pnpm project (lockfile or pnpm modules manifest). Never throws. */
+function isPnpmProject(mainCwd) {
+  try {
+    return fs.existsSync(path.join(mainCwd, 'pnpm-lock.yaml'))
+      || fs.existsSync(path.join(mainCwd, 'node_modules', '.modules.yaml'));
+  } catch { return false; }
+}
+
+/** True when mainCwd is a uv project (uv.lock). Never throws. */
+function isUvProject(mainCwd) {
+  try { return fs.existsSync(path.join(mainCwd, 'uv.lock')); } catch { return false; }
+}
+
+/** Offline frozen `uv sync` into worktreeCwd/<name>. Resolves true on exit 0; never throws. */
+function installUvEnv(worktreeCwd, name) {
+  return new Promise((resolve) => {
+    try {
+      const env = { ...process.env, UV_PROJECT_ENVIRONMENT: path.join(worktreeCwd, name) };
+      delete env.VIRTUAL_ENV;
+      execFile(
+        'uv',
+        ['sync', '--frozen', '--offline'],
+        { cwd: worktreeCwd, env, timeout: 180_000, maxBuffer: 16 * 1024 * 1024 },
+        (err) => resolve(!err),
+      );
+    } catch { resolve(false); }
+  });
+}
+
+/** Top-level importer dirs from pnpm-lock.yaml (`.` is the root). Simple line scan; never throws. */
+function lockImporters(cwd) {
+  const out = ['.'];
+  try {
+    let inImporters = false;
+    for (const line of fs.readFileSync(path.join(cwd, 'pnpm-lock.yaml'), 'utf8').split('\n')) {
+      if (/^importers:\s*$/.test(line)) { inImporters = true; continue; }
+      if (!inImporters) continue;
+      if (/^\S/.test(line)) break;
+      const m = /^ {2}(\S[^:]*):\s*$/.exec(line);
+      if (m) out.push(m[1].replace(/^(['"])(.*)\1$/, '$2'));
+    }
+  } catch { /* no lockfile */ }
+  return [...new Set(out)];
+}
+
+/** Relative file:/link: specifiers of a package.json. Never throws. */
+function localSpecs(pkgJson) {
+  const specs = [];
+  try {
+    const pkg = JSON.parse(fs.readFileSync(pkgJson, 'utf8'));
+    for (const f of ['dependencies', 'devDependencies', 'optionalDependencies']) {
+      for (const v of Object.values(pkg[f] || {})) {
+        const m = typeof v === 'string' && /^(?:file|link):(.+)$/.exec(v);
+        if (m && !path.isAbsolute(m[1])) specs.push(m[1]);
+      }
+    }
+  } catch { /* unreadable */ }
+  return specs;
+}
+
+const within = (parent, p) => p === parent || p.startsWith(parent + path.sep);
+
+/**
+ * Best-effort: link out-of-repo relative file:/link: dep targets at their
+ * worktree-relative location so the offline install can resolve them. Never throws.
+ */
+function linkOutOfRepoLocalDeps(mainCwd, worktreeCwd) {
+  try {
+    for (const importer of lockImporters(worktreeCwd)) {
+      const mainDir = path.resolve(mainCwd, importer);
+      const wtDir = path.resolve(worktreeCwd, importer);
+      for (const spec of localSpecs(path.join(mainDir, 'package.json'))) {
+        try {
+          const target = path.resolve(mainDir, spec);
+          if (within(mainCwd, target) || !exists(target)) continue;
+          const segs = path.normalize(spec).split(path.sep).filter((x) => x && x !== '.');
+          let ups = 0;
+          while (segs[ups] === '..') ups++;
+          const rest = segs.slice(ups);
+          if (!rest.length) continue;
+          // Link the first segment past the `..` hops, to the matching target ancestor.
+          let wtBase = wtDir;
+          for (let i = 0; i < ups; i++) wtBase = path.dirname(wtBase);
+          const linkPath = path.join(wtBase, rest[0]);
+          let linkTarget = target;
+          for (let i = 1; i < rest.length; i++) linkTarget = path.dirname(linkTarget);
+          if (within(mainCwd, linkPath) || within(worktreeCwd, linkPath) || exists(linkPath)) continue;
+          fs.mkdirSync(path.dirname(linkPath), { recursive: true });
+          fs.symlinkSync(linkTarget, linkPath, isDir(linkTarget) ? 'dir' : 'file');
+        } catch { /* best-effort per dep */ }
+      }
+    }
+  } catch { /* best-effort */ }
+}
+
+/** Offline frozen install in the worktree. Resolves true on exit 0; never throws. */
+function installPnpmModules(worktreeCwd) {
+  return new Promise((resolve) => {
+    try {
+      execFile(
+        'pnpm',
+        ['install', '--offline', '--frozen-lockfile', '--config.confirmModulesPurge=false'],
+        { cwd: worktreeCwd, env: { ...process.env, CI: '1' }, timeout: 180_000, maxBuffer: 16 * 1024 * 1024 },
+        (err) => resolve(!err),
+      );
+    } catch { resolve(false); }
+  });
+}
+
+async function addExcludeLines(mainCwd, lines) {
   const out = (await execGit(mainCwd, ['rev-parse', '--git-common-dir'], { timeout: 10_000 })).trim();
   const commonDir = path.resolve(mainCwd, out);
   const file = path.join(commonDir, 'info', 'exclude');
   let existing = '';
   try { existing = fs.readFileSync(file, 'utf8'); } catch { /* absent */ }
   const have = new Set(existing.split('\n').map((l) => l.trim()));
-  const missing = names.map((n) => `/${n}`).filter((l) => !have.has(l));
+  const missing = lines.filter((l) => !have.has(l));
   if (!missing.length) return;
   fs.mkdirSync(path.dirname(file), { recursive: true });
   const sep = existing && !existing.endsWith('\n') ? '\n' : '';
   fs.appendFileSync(file, `${sep}${missing.join('\n')}\n`);
 }
 
+function addExcludes(mainCwd, names) {
+  return addExcludeLines(mainCwd, names.map((n) => `/${n}`));
+}
+
 /**
  * @param {{ mainCwd: string, worktreeCwd: string, names?: string[] }} opts
- * @returns {Promise<{ linked: string[], skipped: string[] }>}
+ * @returns {Promise<{ linked: string[], skipped: string[], installed: string[] }>}
  */
 async function linkDependencyDirs({ mainCwd, worktreeCwd, names = DEFAULT_DEP_DIRS }) {
   const linked = [];
   const skipped = [];
+  const installed = [];
   for (const name of names) {
     try {
       const src = path.join(mainCwd, name);
@@ -63,6 +205,17 @@ async function linkDependencyDirs({ mainCwd, worktreeCwd, names = DEFAULT_DEP_DI
         skipped.push(name);
         continue;
       }
+      if (name === 'node_modules' && isPnpmProject(mainCwd)) {
+        await addExcludeLines(mainCwd, ['node_modules/']);
+        linkOutOfRepoLocalDeps(mainCwd, worktreeCwd);
+        (await installPnpmModules(worktreeCwd) ? installed : skipped).push(name);
+        continue;
+      }
+      if ((name === '.venv' || name === 'venv') && isUvProject(mainCwd)) {
+        await addExcludes(mainCwd, [name]);
+        (await installUvEnv(worktreeCwd, name) ? installed : skipped).push(name);
+        continue;
+      }
       // Exclude first: a link without its exclude line would dirty status.
       await addExcludes(mainCwd, [name]);
       fs.symlinkSync(src, dest, 'dir');
@@ -71,7 +224,7 @@ async function linkDependencyDirs({ mainCwd, worktreeCwd, names = DEFAULT_DEP_DI
       skipped.push(name);
     }
   }
-  return { linked, skipped };
+  return { linked, skipped, installed };
 }
 
-module.exports = { linkDependencyDirs, DEFAULT_DEP_DIRS };
+module.exports = { linkDependencyDirs, isPnpmProject, isUvProject, DEFAULT_DEP_DIRS };

package/src/main/lib/machineProfile.cjs

@@ -117,6 +117,8 @@ async function buildMachineProfile(opts = {}) {
   let appPath = null;
   if (electronApp) {
     try { appVersion = electronApp.getVersion(); } catch { /* not ready / not a real app object */ }
+    // Unpackaged launch with a script path makes getVersion() return Electron's own version.
+    if (appVersion && process.versions && appVersion === process.versions.electron) appVersion = null;
     try { appPath = electronApp.getAppPath(); } catch { /* not ready / not a real app object */ }
   }
   if (!appVersion) appVersion = resolvePackageVersion();

package/src/main/lib/mcpToolCatalog.cjs

@@ -193,7 +193,9 @@ const MCP_TOOL_CATALOG = [
     purpose: "THE ONLY SUPPORTED WAY to cancel a not-yet-terminal scheduler job via the session-manager app's admin "
       + 'API. A running job is SIGTERM\'d; a pending job is simply retired. There is no "cancelled" job status, so a '
       + 'cancelled job lands as "failed" with an error naming the cause. Refuses a slug whose job is already terminal '
-      + '(completed/failed/needs_review) — nothing to cancel.',
+      + '(completed/failed/needs_review) — nothing to cancel. A cancelled running job\'s commits are never landed on '
+      + 'the base branch; they stay on the job branch, reported in the result as landed:false plus '
+      + 'jobBranch/jobBranchSha.',
     whenToUse: 'Use to stop a running or pending job that should not continue (e.g. it was queued in error, or scope changed underneath it).',
     whenNotToUse: 'Do not use on an already-terminal job (completed/failed/needs_review) — use scheduler_reset_job if it should run again.',
     exampleArgs: { slug: 'add-mcp-tool-catalog' },