claude-code-session-manager 0.75.3 → 0.77.0

package/src/main/lib/epicDelegationStats.cjs

@@ -40,7 +40,8 @@ const APPLICATION_SOURCE_PREFIXES = ['src/', 'scripts/', 'plugins/', 'bin/'];
 function countPrdsQueued(cwd, epicId, deps = {}) {
   const readdirSync = deps.readdirSync || fs.readdirSync;
   try {
-    const dir = path.join(cwd, 'session-manager-operations', 'scheduler', 'epics', epicId, 'prds');
+    const { opsPath } = require('./opsOwnership.cjs');
+    const dir = opsPath(cwd, 'scheduler', 'epics', epicId, 'prds');
     return readdirSync(dir).filter((name) => name.endsWith('.md')).length;
   } catch {
     return 0;

package/src/main/lib/epicMint.cjs

@@ -34,6 +34,7 @@ const crypto = require('node:crypto');
 const { resolveEpicPrdWriteDir } = require('./prdLocations.cjs');
 const { assertOpsWrite } = require('./opsOwnership.cjs');
 const { appendAuditEvent } = require('./auditLog.cjs');
+const { mirrorEpicStatus, removeEpicMirror } = require('./epicStatusMirror.cjs');
 // Required as the module object (not destructured) so a test can
 // monkeypatch promptSessionSchema.assertValidPromptSession in place to
 // simulate a corrupted construction — the real construction below is
@@ -74,7 +75,10 @@ const MINT_AUTHORITIES = Object.freeze([
 ]);
 
 function activeIndexPath(cwd) {
-  return path.join(cwd, 'session-manager-operations', 'prompt-sessions', 'active-index.json');
+  // Lazy: opsOwnership → ephemeralCwd → activeSessions; this module is
+  // required early by several of those neighbours.
+  const { opsPath } = require('./opsOwnership.cjs');
+  return opsPath(cwd, 'prompt-sessions', 'active-index.json');
 }
 
 function readActiveIndex(cwd) {
@@ -362,6 +366,13 @@ function ensureEpic(cwd, { goalText, tag, epicId: explicitEpicId, status = 'prop
     index.sessions[epicId] = session;
     index.events[epicId] = [firstEvent];
     writeActiveIndex(cwd, index);
+    // Status mirror (see epicStatusMirror.cjs's header) — every Epic is born
+    // 'proposed', so this is the FIRST mirror write for this id, inside the
+    // same withPathLock task the index write above just ran in. Carries the
+    // full validated `session` object (not just status) so a later rebuild
+    // (activeIndexRebuild.cjs) can reconstruct a complete row from this file
+    // alone.
+    mirrorEpicStatus(cwd, epicId, { session, status });
 
     // Every mint is logged — the trace-back point for "who created this Epic"
     // (see auditLog.cjs).
@@ -416,6 +427,10 @@ function removeEpic(cwd, epicId) {
     delete index.sessions[epicId];
     delete index.events[epicId];
     writeActiveIndex(cwd, index);
+    // Undo the mirror written by ensureEpic's mint branch too — otherwise
+    // the rolled-back id would linger as an orphan_file (a mirrored status
+    // with no index row and no tombstone) in health.cjs's epic_index check.
+    removeEpicMirror(cwd, epicId);
     return true;
   });
 }
@@ -429,6 +444,7 @@ module.exports = {
   removeEpic,
   activeIndexPath,
   readActiveIndex,
+  writeActiveIndex,
   personaFileExists,
   resolvePersonaPaths,
   // Exported so lib/activeIndexMerge.cjs's renderer-facing merge IPC handler

package/src/main/lib/epicStatusMirror.cjs

@@ -0,0 +1,95 @@
+'use strict';
+
+/**
+ * epicStatusMirror.cjs — mirrors an Epic's lifecycle `status` onto its own
+ * durable file, `prompt-sessions/<epicId>.json`, every time a write path
+ * changes that status in `active-index.json`.
+ *
+ * Why this exists: `active-index.json` is the ONLY place an Epic's status
+ * lives today. A lost, clobbered, git-reverted, or worktree-snapshotted index
+ * silently erases every open Epic it held, with no way to recover them —
+ * `activeIndexRebuild.cjs`'s `rebuildActiveIndex` is that recovery path, and
+ * it reconstructs rows from exactly the mirror this module writes. The
+ * archive file `markCompleted()` already writes at completion (session/
+ * events/transcript/archivedAt — see prompt-sessions/README.md) is the same
+ * file this module targets; a live (proposed/active) Epic gets a sparse
+ * mirror here instead, later overwritten wholesale by the real archive.
+ *
+ * Raw fs tmp+rename — NOT config.cjs's `writeJson` — so this module stays
+ * requirable from epicMint.cjs, which is deliberately Electron-free (its own
+ * header: "so the external watchdog scripts can require it"; config.cjs
+ * requires 'electron' at module load). The write shape matches config.cjs's
+ * writeJson exactly (`JSON.stringify(data, null, 2) + '\n'`, `<path>.tmp-
+ * <pid>` then rename) so main-process callers (activeIndexMerge.cjs) and
+ * epicMint.cjs never diverge in format despite using different write paths.
+ */
+
+const fs = require('node:fs');
+const path = require('node:path');
+const { assertOpsWrite, opsPath } = require('./opsOwnership.cjs');
+
+function epicMirrorPath(cwd, epicId) {
+  return opsPath(cwd, 'prompt-sessions', `${epicId}.json`);
+}
+
+function readExistingMirror(file) {
+  try {
+    const parsed = JSON.parse(fs.readFileSync(file, 'utf8'));
+    return parsed && typeof parsed === 'object' && !Array.isArray(parsed) ? parsed : {};
+  } catch {
+    return {};
+  }
+}
+
+/**
+ * mirrorEpicStatus(cwd, epicId, { session?, status?, archivedAt?, writer? })
+ * — read-merge-write onto `prompt-sessions/<epicId>.json`, preserving
+ * whatever else is already there (e.g. a full `PromptSessionArchive` written
+ * by `markCompleted`, or a prior mirror).
+ *
+ * When `session` (the full PromptSession record) is given, it is spread onto
+ * the file too — not just the four mirror fields — so a live (proposed/
+ * active) Epic's file alone is enough for `activeIndexRebuild.cjs` to
+ * reconstruct a complete `active-index.json` row, not just its status.
+ * `status`/`archivedAt` may be passed independently of `session` (or to
+ * override `session.status`) for callers that only know the status.
+ *
+ * Never throws on a read failure (a missing/corrupt existing file is treated
+ * as "start fresh"); a write failure propagates, matching every other atomic
+ * writer in this codebase (config.cjs's writeTextAtomic, epicMint.cjs's own
+ * writeActiveIndex).
+ */
+function mirrorEpicStatus(cwd, epicId, { session = null, status = null, archivedAt = null, writer = 'epics' } = {}) {
+  const resolvedStatus = status || (session && session.status) || null;
+  if (!cwd || !epicId || !resolvedStatus) return;
+  const file = epicMirrorPath(cwd, epicId);
+  assertOpsWrite(file, writer);
+  const existing = readExistingMirror(file);
+  const merged = {
+    ...existing,
+    ...(session || {}),
+    id: epicId,
+    cwd,
+    status: resolvedStatus,
+    archivedAt: archivedAt ?? existing.archivedAt ?? null,
+    indexedAt: new Date().toISOString(),
+  };
+  fs.mkdirSync(path.dirname(file), { recursive: true });
+  const tmp = `${file}.tmp-${process.pid}`;
+  fs.writeFileSync(tmp, JSON.stringify(merged, null, 2) + '\n');
+  fs.renameSync(tmp, file);
+}
+
+/**
+ * removeEpicMirror(cwd, epicId) — best-effort delete of the mirror file, used
+ * only by epicMint.cjs's removeEpic() rollback (undoing a mint whose caller
+ * failed to complete its own work). Never throws — a missing file is a no-op.
+ */
+function removeEpicMirror(cwd, epicId) {
+  if (!cwd || !epicId) return;
+  try {
+    fs.unlinkSync(epicMirrorPath(cwd, epicId));
+  } catch { /* never existed, or already gone */ }
+}
+
+module.exports = { mirrorEpicStatus, removeEpicMirror, epicMirrorPath };

package/src/main/lib/epicValidationHook.cjs

@@ -62,7 +62,8 @@ function pairKey(epicId, prdSlug) {
  */
 function defaultReadActiveIndex(cwd) {
   try {
-    const p = path.join(cwd, 'session-manager-operations', 'prompt-sessions', 'active-index.json');
+    const { opsPath } = require('./opsOwnership.cjs');
+    const p = opsPath(cwd, 'prompt-sessions', 'active-index.json');
     return JSON.parse(fs.readFileSync(p, 'utf8'));
   } catch {
     return null;

package/src/main/lib/epicWorktreeMint.cjs

@@ -13,8 +13,11 @@
  * that can only run main-process side, so approveProposed fires this IPC
  * call fire-and-forget and patches `worktree` onto the session once it
  * resolves — the transition itself is never blocked or delayed by it, and a
- * failure (not a repo / dirty base tree / disabled / cap reached) simply
- * leaves `worktree` unset, exactly as if this call had never been made.
+ * failure (not a repo / disabled / cap reached / carry-over of a dirty base
+ * tree's WIP failed) simply leaves `worktree` unset, exactly as if this call
+ * had never been made. A dirty base tree itself no longer disables
+ * isolation — its outstanding diff is carried into the fresh worktree
+ * instead (gitWorktree.cjs's createWorktree).
  *
  * Mirrors promptSessionsCreateEpic.cjs's shape: `validatePath(cwd)` closes
  * the same "arbitrary renderer-supplied cwd" gap that handler documents,

package/src/main/lib/fixChainDepth.cjs

@@ -0,0 +1,45 @@
+/**
+ * fixChainDepth.cjs — pure slug-inspection helpers for the fix-chain depth
+ * guard (PRD 1113). Generalizes scheduler.cjs's `isFixPlanSlug` (`^\d+-fix-`)
+ * into a counter: how many CONSECUTIVE '-fix-' segments immediately follow
+ * the leading `NN-` prefix. Only a run starting right at the prefix counts —
+ * a later segment that happens to read 'fix' (e.g.
+ * '13-fix-loop-extraction-and-round-trip', where 'loop' breaks the run right
+ * after the first 'fix') does not extend the count, and a segment that only
+ * contains 'fix' as a substring (e.g. '113-prefix-foo') never matches at all
+ * since segments are compared for exact equality after splitting on '-'.
+ *
+ * No filesystem access, no scheduler.cjs dependency — safe to require from
+ * lib/prdCreate.cjs without pulling in the scheduler module graph.
+ */
+'use strict';
+
+function fixChainDepthOf(slug) {
+  const rest = String(slug).replace(/^\d+-/, '');
+  const segments = rest.split('-');
+  let depth = 0;
+  for (const seg of segments) {
+    if (seg !== 'fix') break;
+    depth += 1;
+  }
+  return depth;
+}
+
+/**
+ * Strips the leading consecutive '-fix-' chain a slug carries, returning the
+ * base slug the chain descends from — e.g. '113-fix-fix-foo' -> '113-foo'.
+ * Used only for error messages (naming what actually failed to close).
+ */
+function baseSlugOf(slug) {
+  const str = String(slug);
+  const prefixMatch = str.match(/^(\d+)-/);
+  const prefix = prefixMatch ? prefixMatch[1] : '';
+  const rest = str.replace(/^\d+-/, '');
+  const segments = rest.split('-');
+  let i = 0;
+  while (i < segments.length && segments[i] === 'fix') i += 1;
+  const remainder = segments.slice(i).join('-');
+  return prefix ? `${prefix}-${remainder}` : remainder;
+}
+
+module.exports = { fixChainDepthOf, baseSlugOf };