claude-code-session-manager 0.123.1 → 0.124.1

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

@@ -26,11 +26,9 @@
  *     lock (epicMint.cjs exports withPathLock; requiring it here shares the
  *     same module-level Map via Node's require cache, not a second one).
  *
- * Tombstones are never auto-cleared: resumeArchived() (state/promptSessions.ts)
- * always mints a BRAND NEW Epic id + claudeSessionId — it never reuses the
- * archived id — so a tombstoned id is never legitimately reborn under the
- * current domain model. If that ever changes, this module would need an
- * explicit "un-tombstone" path; today one would be dead code.
+ * Tombstones are cleared in exactly one place: reopenEpic (lib/epic/epicReopen.cjs),
+ * a human pressing Resume/Reopen on a completed Epic, under the same withPathLock.
+ * Nothing else un-tombstones an id.
  */
 
 const path = require('path');

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

@@ -0,0 +1,161 @@
+'use strict';
+
+/**
+ * epicReopen.cjs — flip a completed Epic back to 'active' IN PLACE (same Epic id, same
+ * claudeSessionId, same event chain) so the next turn continues via `claude --resume`.
+ * Clears the three disk guards deliberately: the removal tombstone, the archive-shaped
+ * `<id>.json` (rewritten as a live status mirror), and the merged-away worktree.
+ * Electron-free at load; electron/config/ipcSchemas are required lazily in the register fn.
+ */
+
+const fs = require('node:fs');
+const { activeIndexPath, readActiveIndex, withPathLock } = require('./epicMint.cjs');
+const { epicMirrorPath } = require('./epicStatusMirror.cjs');
+const { assertOpsWrite } = require('../opsOwnership.cjs');
+const atomicFs = require('../util/atomicFs.cjs');
+const { hasTranscriptSource, ensureEpicTranscriptReachable } = require('./epicTranscriptRestore.cjs');
+const { restoreEpicWorktree } = require('./epicSpawnCwd.cjs');
+
+const inFlight = new Map();
+
+const fail = (code, message) => ({ ok: false, code, message });
+
+function isDir(dir, deps) {
+  try {
+    return (deps.statSync || fs.statSync)(dir).isDirectory();
+  } catch {
+    return false;
+  }
+}
+
+async function provisionWorktree({ cwd, epicId, archived, deps }) {
+  const wt = archived && typeof archived === 'object' ? archived : null;
+  const st = wt && wt.status;
+  if (!wt || !wt.dir || st === 'merged' || st === 'disabled') {
+    const createWorktree = deps.createWorktree || ((c, id) => require('./epicWorktreeMint.cjs').createEpicWorktreeViaIpc(c, id));
+    let created = null;
+    try {
+      created = await createWorktree(cwd, epicId);
+    } catch {
+      created = null;
+    }
+    return created ? { worktree: created, created: true } : { worktree: wt, created: false };
+  }
+  if (st === 'active' || st === 'needs_merge_resolution') {
+    if (isDir(wt.dir, deps)) return { worktree: { ...wt, status: 'active' }, created: false };
+    const restore = deps.restoreWorktree || restoreEpicWorktree;
+    let ok = false;
+    try {
+      ok = await restore({ dir: wt.dir, branch: wt.branch, baseCwd: cwd });
+    } catch {
+      ok = false;
+    }
+    return { worktree: ok ? { ...wt, status: 'active' } : wt, created: false };
+  }
+  return { worktree: wt, created: false };
+}
+
+function usableDir(worktree, deps) {
+  return worktree && worktree.dir && worktree.status === 'active' && isDir(worktree.dir, deps) ? worktree.dir : null;
+}
+
+async function doReopen({ cwd, epicId, deps }) {
+  const current = readActiveIndex(cwd);
+  const row = Object.prototype.hasOwnProperty.call(current.sessions, epicId) ? current.sessions[epicId] : null;
+  if (row && (row.status === 'active' || row.status === 'proposed')) {
+    return { ok: true, session: row, events: current.events[epicId] || [], alreadyOpen: true };
+  }
+
+  const mirrorFile = epicMirrorPath(cwd, epicId);
+  let archive = null;
+  try {
+    archive = JSON.parse(fs.readFileSync(mirrorFile, 'utf8'));
+  } catch {
+    archive = null;
+  }
+  const arch = archive && archive.session;
+  if (
+    !arch || typeof arch !== 'object' || arch.id !== epicId ||
+    (arch.cwd && arch.cwd !== cwd) ||
+    (archive.status || arch.status) !== 'completed'
+  ) {
+    return fail('not_found', `No completed Epic ${epicId} to reopen.`);
+  }
+
+  const claudeSessionId = arch.claudeSessionId;
+  const tDeps = deps.homeDir || deps.statSync ? { homeDir: deps.homeDir, statSync: deps.statSync } : {};
+  if (!hasTranscriptSource({ cwd, epicId, claudeSessionId, deps: tDeps })) {
+    // No source anywhere, so this never writes; it only names the failure.
+    const r = ensureEpicTranscriptReachable({ cwd, epicId, claudeSessionId, deps: tDeps });
+    return r.ok ? fail('transcript_missing', 'No saved transcript.') : r;
+  }
+
+  const { worktree, created } = await provisionWorktree({ cwd, epicId, archived: arch.worktree, deps });
+  const spawnCwd = usableDir(worktree, deps) || cwd;
+  const reach = ensureEpicTranscriptReachable({ cwd, epicId, claudeSessionId, spawnCwd, deps: tDeps });
+  if (!reach.ok) {
+    if (created && worktree && worktree.dir) {
+      try {
+        const cleanup = deps.cleanupWorktree || require('../git/gitWorktree.cjs').cleanupEpicWorktree;
+        await cleanup({ cwd, dir: worktree.dir, branch: worktree.branch, keepBranch: false });
+      } catch { /* best-effort */ }
+    }
+    return reach;
+  }
+
+  const indexFile = activeIndexPath(cwd);
+  let reopened;
+  let events;
+  try {
+    await withPathLock(indexFile, async () => {
+      const index = readActiveIndex(cwd);
+      delete index.tombstones[epicId];
+      reopened = { ...arch, status: 'active', completedAt: null };
+      if (worktree) reopened.worktree = worktree;
+      events = Array.isArray(archive.events) ? archive.events : [];
+      index.sessions[epicId] = reopened;
+      index.events[epicId] = events;
+      assertOpsWrite(indexFile, 'epics');
+      atomicFs.writeJsonAtomicSync(indexFile, index, { newline: false });
+    });
+    assertOpsWrite(mirrorFile, 'epics');
+    atomicFs.writeJsonAtomicSync(mirrorFile, {
+      ...reopened,
+      id: epicId,
+      cwd,
+      status: 'active',
+      archivedAt: null,
+      indexedAt: new Date().toISOString(),
+    });
+  } catch (err) {
+    return fail('write_failed', `Could not reopen Epic ${epicId}: ${err && err.message ? err.message : err}`);
+  }
+  return { ok: true, session: reopened, events, alreadyOpen: false };
+}
+
+/**
+ * @param {{ cwd: string, epicId: string, deps?: object }} opts
+ */
+function reopenEpic({ cwd, epicId, deps = {} } = {}) {
+  const key = `${cwd}\0${epicId}`;
+  const existing = inFlight.get(key);
+  if (existing) return existing;
+  const p = doReopen({ cwd, epicId, deps }).finally(() => inFlight.delete(key));
+  inFlight.set(key, p);
+  return p;
+}
+
+function registerEpicReopenHandlers() {
+  const { ipcMain } = require('electron');
+  const { validatePath } = require('../../config.cjs');
+  const { schemas: s, validated: v } = require('../../ipcSchemas.cjs');
+  ipcMain.handle(
+    'promptSessions:reopen',
+    v(s.promptSessionsReopen, ({ cwd, epicId }) => {
+      validatePath(cwd);
+      return reopenEpic({ cwd, epicId });
+    }),
+  );
+}
+
+module.exports = { reopenEpic, registerEpicReopenHandlers };

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

@@ -16,6 +16,9 @@
  * the real cause, never claim a flag that cannot work. Reachable = "some existing transcript lives
  * under encodeCwd(candidate cwd)" and the candidate is a real directory.
  *
+ * A turn-1 `worktreeDirHint` lets a brand-new Epic's first spawn land in its freshly minted worktree;
+ * once any transcript exists (or the hint is not a directory) the hint is ignored.
+ *
  * Also refuses requests routed to a closed (`completed`) Epic, and keeps a per-session circuit
  * breaker: once a session is found unreachable, later requests are refused after ONE stat (is the
  * worktree dir still missing?) without re-running the restore git commands.
@@ -74,7 +77,7 @@ function findEpic(cwd, claudeSessionId, deps) {
  * @returns {{ ok: true, execCwd: string, useResume: boolean, transcriptPath: string|null }
  *   | { ok: false, code: 'epic_closed'|'session_unreachable'|'spawn_cwd_missing', message: string }}
  */
-function planEpicSpawn({ cwd, claudeSessionId, fallbackResume = false, deps = {} } = {}) {
+function planEpicSpawn({ cwd, claudeSessionId, fallbackResume = false, worktreeDirHint, deps = {} } = {}) {
   const statSync = deps.statSync || fs.statSync;
   const epic = findEpic(cwd, claudeSessionId, deps);
 
@@ -98,6 +101,11 @@ function planEpicSpawn({ cwd, claudeSessionId, fallbackResume = false, deps = {}
     useResume = !!resolved.existsAnywhere;
   } catch { /* keep the caller-supplied flag */ }
 
+  // Turn-1 hint: no transcript anywhere yet and the freshly minted worktree exists → spawn there.
+  if ((!resolved || !resolved.existsAnywhere) && typeof worktreeDirHint === 'string' && worktreeDirHint && isDir(worktreeDirHint, statSync)) {
+    return { ok: true, execCwd: worktreeDirHint, useResume: false, transcriptPath: null };
+  }
+
   let execCwd = (deps.resolveSpawnCwd || resolveEpicSpawnCwd)({ cwd, claudeSessionId, deps: { restore: true, readActiveIndex: deps.readActiveIndex, statSync: deps.statSync, restoreWorktree: deps.restoreWorktree } });
 
   if (resolved && resolved.existsAnywhere) {

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

@@ -0,0 +1,109 @@
+'use strict';
+
+/**
+ * epicTranscriptRestore.cjs — guarantee the Claude CLI can find a completed Epic's transcript
+ * from the cwd it will be resumed in.
+ *
+ * `claude --resume <id>` only finds `~/.claude/projects/<encodeCwd(spawn cwd)>/<id>.jsonl`.
+ * Reopening a completed Epic must never fall back to a fresh `--session-id`: that silently
+ * starts a context-less conversation (the reported "Resume starts a new session" bug). A
+ * completed Epic's JSONL can sit under an old worktree encoding, or be gone entirely
+ * (Claude Code's cleanupPeriodDays) while our gzip sidecar still holds it. This module copies
+ * or restores it to the spawn cwd's encoding. It never overwrites a non-empty target and never
+ * moves or deletes a source.
+ */
+
+const fs = require('node:fs');
+const os = require('node:os');
+const path = require('node:path');
+const { encodeCwd } = require('../util/encodeCwd.cjs');
+const atomicFs = require('../util/atomicFs.cjs');
+const { resolveEpicTranscriptPath } = require('./epicTranscriptPath.cjs');
+const { readSidecar } = require('./archivedTranscript.cjs');
+
+const SID_RE = /^[A-Za-z0-9_-]{1,128}$/;
+
+const isValidSid = (sid) => typeof sid === 'string' && SID_RE.test(sid);
+
+function isNonEmptyFile(p, deps) {
+  try {
+    const st = (deps.statSync || fs.statSync)(p);
+    return st.isFile() && st.size > 0;
+  } catch {
+    return false;
+  }
+}
+
+function fileFor(dir, sid, deps) {
+  return path.join(deps.homeDir || os.homedir(), '.claude', 'projects', encodeCwd(dir), `${sid}.jsonl`);
+}
+
+function sidecarText(cwd, epicId) {
+  try {
+    const t = readSidecar(cwd, epicId);
+    return typeof t === 'string' && t.length > 0 ? t : null;
+  } catch {
+    return null;
+  }
+}
+
+/** Find the first source: reachable file, other JSONL, or sidecar. No writes. */
+function locate({ cwd, epicId, sid, spawnCwd, deps }) {
+  for (const dir of [...new Set([spawnCwd, cwd].filter(Boolean))]) {
+    const p = fileFor(dir, sid, deps);
+    if (isNonEmptyFile(p, deps)) return { kind: 'none', path: p };
+  }
+  let resolved = null;
+  try {
+    resolved = resolveEpicTranscriptPath({ cwd, claudeSessionId: sid, deps });
+  } catch {
+    resolved = null;
+  }
+  if (resolved && resolved.existsAnywhere && resolved.path && isNonEmptyFile(resolved.path, deps)) {
+    return { kind: 'copied', path: resolved.path };
+  }
+  const text = sidecarText(cwd, epicId);
+  if (text) return { kind: 'sidecar', text };
+  return null;
+}
+
+/**
+ * @param {{ cwd: string, epicId: string, claudeSessionId: string, deps?: object }} opts
+ * @returns {boolean}
+ */
+function hasTranscriptSource({ cwd, epicId, claudeSessionId, spawnCwd, deps = {} } = {}) {
+  if (!isValidSid(claudeSessionId) || !cwd) return false;
+  return locate({ cwd, epicId, sid: claudeSessionId, spawnCwd: spawnCwd || cwd, deps }) !== null;
+}
+
+/**
+ * @param {{ cwd: string, epicId: string, claudeSessionId: string, spawnCwd?: string, deps?: object }} opts
+ * @returns {{ ok: true, path: string, restored: 'none'|'copied'|'sidecar' } | { ok: false, code: 'transcript_missing'|'invalid_session_id'|'restore_failed', message: string }}
+ */
+function ensureEpicTranscriptReachable({ cwd, epicId, claudeSessionId, spawnCwd, deps = {} } = {}) {
+  if (!isValidSid(claudeSessionId)) {
+    return { ok: false, code: 'invalid_session_id', message: 'Invalid Claude session id.' };
+  }
+  const sid = claudeSessionId;
+  const target = fileFor(spawnCwd || cwd, sid, deps);
+  const found = locate({ cwd, epicId, sid, spawnCwd, deps });
+  if (!found) {
+    return {
+      ok: false,
+      code: 'transcript_missing',
+      message: `No saved transcript for session ${sid} — it cannot be resumed. Use "Duplicate as new session" to start a fresh one.`,
+    };
+  }
+  if (found.kind === 'none') return { ok: true, path: found.path, restored: 'none' };
+  try {
+    const text = found.kind === 'copied' ? fs.readFileSync(found.path, 'utf8') : found.text;
+    // Re-check right before writing: never overwrite a non-empty target.
+    if (isNonEmptyFile(target, deps)) return { ok: true, path: target, restored: 'none' };
+    atomicFs.writeTextAtomicSync(target, text, { mode: 0o600 });
+    return { ok: true, path: target, restored: found.kind };
+  } catch (err) {
+    return { ok: false, code: 'restore_failed', message: `Could not restore transcript for session ${sid}: ${err && err.message ? err.message : err}` };
+  }
+}
+
+module.exports = { hasTranscriptSource, ensureEpicTranscriptReachable };

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

@@ -173,7 +173,7 @@ async function runEpicSettle({ cwd, epicId } = {}, deps = {}) {
     }
 
     const prompt = buildSettledDigest(digestSettle, { epicId, notValidatedReason });
-    sendPrompt(epicId, prompt);
+    sendPrompt(epicId, prompt, { origin: 'scheduler' });
     await appendResponseEvent(
       cwd, epicId,
       `Plan digest sent: ${settle.verified.length} verified, ${settle.refuted.length} refuted, ${settle.uncovered.length} not validated`,

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

@@ -24,6 +24,7 @@
  * since this is likewise reachable from the renderer over IPC.
  */
 
+const path = require('node:path');
 const { createEpicWorktree } = require('../git/gitWorktree.cjs');
 const { validatePath } = require('../../config.cjs');
 
@@ -35,8 +36,54 @@ const { validatePath } = require('../../config.cjs');
  * `null` on any failure — createEpicWorktree/createWorktree never throw, so
  * this never does either.
  */
-async function createEpicWorktreeViaIpc(cwd, epicId) {
-  validatePath(cwd);
+/** In-flight mints, keyed by resolved cwd + epicId (turn 1 awaits these — awaitPendingEpicWorktree). */
+const pendingMints = new Map();
+const mintKey = (cwd, epicId) => `${path.resolve(String(cwd))}\0${epicId}`;
+
+function createEpicWorktreeViaIpc(cwd, epicId) {
+  try { validatePath(cwd); } catch (err) { return Promise.reject(err); }
+  const key = mintKey(cwd, epicId);
+  const p = mintEpicWorktree(cwd, epicId);
+  pendingMints.set(key, p);
+  p.finally(() => { if (pendingMints.get(key) === p) pendingMints.delete(key); }).catch(() => {});
+  return p;
+}
+
+/**
+ * awaitPendingEpicWorktree(cwd, epicId, { timeoutMs }) → Promise<EpicWorktree | null>
+ * Resolves the in-flight mint's result, null when nothing is pending or after timeoutMs. Never rejects.
+ */
+async function awaitPendingEpicWorktree(cwd, epicId, { timeoutMs = 90000 } = {}) {
+  let p;
+  try { p = pendingMints.get(mintKey(cwd, epicId)); } catch { return null; }
+  if (!p) return null;
+  let timer;
+  const timeout = new Promise((resolve) => {
+    timer = setTimeout(() => {
+      console.log(`[epicWorktreeMint] ${epicId}: pending mint timed out after ${timeoutMs}ms`);
+      resolve(null);
+    }, timeoutMs);
+    if (timer && typeof timer.unref === 'function') timer.unref();
+  });
+  try {
+    return await Promise.race([p.catch(() => null), timeout]);
+  } catch {
+    return null;
+  } finally {
+    clearTimeout(timer);
+  }
+}
+
+/** True exactly when a mint is in flight for this Epic. Synchronous, never throws. */
+function hasPendingEpicWorktree(cwd, epicId) {
+  try { return pendingMints.has(mintKey(cwd, epicId)); } catch { return false; }
+}
+
+function __resetPendingForTests() {
+  pendingMints.clear();
+}
+
+async function mintEpicWorktree(cwd, epicId) {
   const result = await createEpicWorktree({ cwd, epicId });
   if (!result.ok) {
     console.log(`[epicWorktreeMint] ${epicId}: not isolated (${result.reason})`);
@@ -66,4 +113,4 @@ function registerEpicWorktreeMintHandlers() {
   );
 }
 
-module.exports = { createEpicWorktreeViaIpc, registerEpicWorktreeMintHandlers };
+module.exports = { createEpicWorktreeViaIpc, awaitPendingEpicWorktree, hasPendingEpicWorktree, __resetPendingForTests, registerEpicWorktreeMintHandlers };

package/src/main/lib/feedback-remote/crossProjectFeedback.cjs

@@ -67,6 +67,7 @@
 const fs = require('node:fs');
 const fsp = require('node:fs/promises');
 const os = require('node:os');
+const { sendIfAlive } = require('../sendToRenderer.cjs');
 const path = require('node:path');
 
 const config = require('../../config.cjs');
@@ -453,7 +454,7 @@ function defaultNotifyRenderer(payload) {
     const { BrowserWindow } = require('electron');
     for (const win of BrowserWindow.getAllWindows()) {
       try {
-        win.webContents.send('promptSessions:inbound-auto-approve', payload);
+        sendIfAlive(win, 'promptSessions:inbound-auto-approve', payload);
       } catch { /* window going away */ }
     }
   } catch { /* not running under Electron */ }

package/src/main/lib/feedback-remote/remoteAssets.cjs

@@ -0,0 +1,98 @@
+'use strict';
+
+/**
+ * remoteAssets.cjs — serves this desktop's own `<app root>/dist-web/` build to an
+ * E2E-authenticated browser, so the browser runs exactly the UI of the desktop it talks to.
+ * Names are basename-only and realpath-confined; nothing outside dist-web is readable.
+ */
+
+const fs = require('node:fs');
+const path = require('node:path');
+const crypto = require('node:crypto');
+
+const MAX_ASSET_BYTES = 25 * 1024 * 1024;
+
+const TYPES = {
+  '.html': 'text/html', '.js': 'text/javascript', '.mjs': 'text/javascript', '.css': 'text/css',
+  '.json': 'application/json', '.svg': 'image/svg+xml', '.png': 'image/png', '.jpg': 'image/jpeg',
+  '.jpeg': 'image/jpeg', '.gif': 'image/gif', '.webp': 'image/webp', '.ico': 'image/x-icon',
+  '.woff': 'font/woff', '.woff2': 'font/woff2', '.ttf': 'font/ttf', '.wasm': 'application/wasm',
+  '.map': 'application/json', '.txt': 'text/plain', '.onnx': 'application/octet-stream',
+};
+
+let _rootOverride = null;
+
+/** Same layout rule as index.cjs's dist/index.html lookup: <src/main>/../../dist-web. */
+function webRoot() {
+  return _rootOverride || path.join(__dirname, '..', '..', '..', '..', 'dist-web');
+}
+
+function typeOf(name) {
+  return TYPES[path.extname(name).toLowerCase()] || 'application/octet-stream';
+}
+
+function realRoot() {
+  try {
+    const r = fs.realpathSync(webRoot());
+    return fs.statSync(r).isDirectory() ? r : null;
+  } catch { return null; }
+}
+
+/** Resolve a requested name to a confined regular file, or null. */
+function resolveAsset(name) {
+  if (typeof name !== 'string' || name.length === 0 || name.length > 255) return null;
+  if (name !== path.basename(name) || name.includes('\\') || name.includes('/') || name.includes('\0') ||
+      name === '.' || name === '..') return null;
+  const root = realRoot();
+  if (!root) return null;
+  try {
+    const real = fs.realpathSync(path.join(root, name));
+    if (path.dirname(real) !== root) return null;
+    const st = fs.statSync(real);
+    return st.isFile() ? { real, size: st.size } : null;
+  } catch { return null; }
+}
+
+function packageVersion() {
+  try {
+    return JSON.parse(fs.readFileSync(path.join(__dirname, '..', '..', '..', '..', 'package.json'), 'utf8')).version || null;
+  } catch { return null; }
+}
+
+/** -> { available, version, files:[{ name, size, sha256, type }] } */
+function assetManifest() {
+  const version = packageVersion();
+  const root = realRoot();
+  if (!root) return { available: false, version, files: [] };
+  const files = [];
+  for (const e of fs.readdirSync(root, { withFileTypes: true })) {
+    if (!e.isFile()) continue;
+    const a = resolveAsset(e.name);
+    if (!a || a.size > MAX_ASSET_BYTES) continue;
+    files.push({
+      name: e.name, size: a.size,
+      sha256: crypto.createHash('sha256').update(fs.readFileSync(a.real)).digest('hex'),
+      type: typeOf(e.name),
+    });
+  }
+  files.sort((x, y) => (x.name < y.name ? -1 : 1));
+  return { available: true, version, files };
+}
+
+/** -> { ok:true, name, size, type, sha256, data(base64) } | { ok:false, error } */
+function readAsset(name) {
+  const a = resolveAsset(name);
+  if (!a) return { ok: false, error: 'not_found' };
+  if (a.size > MAX_ASSET_BYTES) return { ok: false, error: 'too_large' };
+  const buf = fs.readFileSync(a.real);
+  return {
+    ok: true, name, size: buf.length, type: typeOf(name),
+    sha256: crypto.createHash('sha256').update(buf).digest('hex'),
+    data: buf.toString('base64'),
+  };
+}
+
+module.exports = {
+  assetManifest, readAsset, MAX_ASSET_BYTES,
+  __test: { setRoot: (p) => { _rootOverride = p; } },
+};