claude-code-session-manager 0.98.0 → 0.101.0

package/src/main/lib/epicWorktreeProjectConfig.cjs

@@ -36,6 +36,7 @@ const fs = require('node:fs');
 const path = require('node:path');
 const os = require('node:os');
 const { assertOpsWrite, opsPath } = require('./opsOwnership.cjs');
+const atomicFs = require('./atomicFs.cjs');
 
 // The old machine-wide map. Read-only from here on (migration source only) —
 // never written again, and deliberately never deleted so unmigrated projects
@@ -76,10 +77,7 @@ function readPerProjectConfigFile(cwd) {
 function writePerProjectConfig(cwd, config, writer = 'epics') {
   const file = perProjectConfigPath(cwd);
   assertOpsWrite(file, writer);
-  fs.mkdirSync(path.dirname(file), { recursive: true });
-  const tmp = `${file}.tmp-${process.pid}`;
-  fs.writeFileSync(tmp, JSON.stringify(config, null, 2) + '\n');
-  fs.renameSync(tmp, file);
+  atomicFs.writeJsonAtomicSync(file, config);
 }
 
 /**

package/src/main/lib/gateAuthority.cjs

@@ -0,0 +1,96 @@
+'use strict';
+
+/**
+ * gateAuthority.cjs — pure decision rule for "gate authority": whether a
+ * green gate re-run may complete a needs_review park on its own, with no
+ * human in the loop.
+ *
+ * Scoped to transcript-noise verdicts only (GATE_AUTHORITY_VERDICTS). Those
+ * parks are jobs whose real work landed, but whose transcript had
+ * error-looking text, no verdict line, or an abandoned background task — not
+ * a real defect. That premise only holds once two things are proven, never
+ * assumed from the job's own fields: `evidenceOk` proves the landed commit is
+ * git-verified evidence from THIS dispatch, not an older run's stale sha
+ * (a stale sha survives a reset/requeue, so it can otherwise outlive the run
+ * that actually produced it); `ancestorOk`, `cleanOk` and `headStable`
+ * together prove the gate ran against the EXACT tree that commit left behind
+ * — the same commit, HEAD unmoved, nothing else dirty, both before and after
+ * the gate ran. A green re-run of the SAME gate the PRD authored, under all
+ * of that, is as much proof of done-ness as the live run's own gate step
+ * would have been.
+ *
+ * Pure: no fs/git/process I/O here. scheduler.cjs computes `evidenceOk`,
+ * `ancestorOk`, `cleanOk`, `headStable` and `outcome` (runGateSequence's
+ * result) and passes them in, so this stays unit-testable with plain
+ * objects.
+ */
+
+// The only verdicts a green gate re-run may override. Any other verdict
+// (for example `shared_tree_reverted`) is a different kind of park, handled
+// elsewhere (isStaleSharedTreeRevertedPark in scheduler.cjs) — never widen
+// this set to cover those.
+const GATE_AUTHORITY_VERDICTS = Object.freeze([
+  'transcript_errors',
+  'no_verdict_sentinel',
+  'abandoned_background_task',
+]);
+
+/**
+ * decideGateAuthority({ job, gate, outcome, evidenceOk, ancestorOk, cleanOk, headStable, env }) → { complete, reason }
+ *
+ * Checks run in a fixed order; the first failed check is the reason. Every
+ * check must pass for `complete: true`.
+ *
+ * @param {object} params
+ * @param {object} params.job - the needs_review job row: reads `status`, `verifierVerdict`, `landedCommit`.
+ * @param {{source: string, sequence: unknown[]}} params.gate - resolveGate(prdText) output for this PRD.
+ * @param {{status: string}} params.outcome - runGateSequence output ('green'|'red'|'unavailable'|'busy').
+ * @param {boolean} params.evidenceOk - true when job.landedCommit is git-verified evidence from THIS
+ *   dispatch (resolveLandedCommitEvidence checked against job.startedAt) — false for a stale sha left
+ *   over from an earlier run, or when job.startedAt is missing/unparseable.
+ * @param {boolean} params.ancestorOk - true when job.landedCommit is an ancestor of (or equal to) the
+ *   HEAD recorded BEFORE the gate ran.
+ * @param {boolean} params.cleanOk - true when the tracked+untracked tree (app-owned churn stripped) was
+ *   clean both before and after the gate ran.
+ * @param {boolean} params.headStable - true when HEAD after the gate equals the HEAD recorded before it
+ *   — the gate ran against the tree it is being trusted to have judged, not one that moved under it.
+ * @param {object} [params.env] - defaults to process.env; pass a plain object in tests.
+ * @returns {{complete: boolean, reason: string}}
+ */
+function decideGateAuthority({ job, gate, outcome, evidenceOk, ancestorOk, cleanOk, headStable, env = process.env } = {}) {
+  if (env?.SM_GATE_AUTHORITATIVE_DISABLE === '1') {
+    return { complete: false, reason: 'kill-switch' };
+  }
+  if (!job || job.status !== 'needs_review' || !GATE_AUTHORITY_VERDICTS.includes(job.verifierVerdict)) {
+    return { complete: false, reason: 'verdict-not-eligible' };
+  }
+  if (typeof job.landedCommit !== 'string' || job.landedCommit.length === 0) {
+    return { complete: false, reason: 'no-landed-commit' };
+  }
+  if (evidenceOk !== true) {
+    return { complete: false, reason: 'commit-not-from-this-run' };
+  }
+  if (ancestorOk !== true) {
+    return { complete: false, reason: 'commit-not-on-head' };
+  }
+  if (cleanOk !== true) {
+    return { complete: false, reason: 'tree-dirty' };
+  }
+  if (headStable !== true) {
+    return { complete: false, reason: 'head-moved-during-gate' };
+  }
+  const gateSource = gate?.source;
+  const gateSequence = gate?.sequence;
+  // 'ac-line-guess' (a bare AC line whose command end was guessed) is never
+  // trusted: a cut-short command like `npm run` can pass vacuously.
+  const hasGate = (gateSource === 'explicit' || gateSource === 'ac-line') && Array.isArray(gateSequence) && gateSequence.length > 0;
+  if (!hasGate) {
+    return { complete: false, reason: 'no-gate' };
+  }
+  if (outcome?.status !== 'green') {
+    return { complete: false, reason: 'gate-not-green' };
+  }
+  return { complete: true, reason: 'gate-green' };
+}
+
+module.exports = { GATE_AUTHORITY_VERDICTS, decideGateAuthority };

package/src/main/lib/gitExec.cjs

@@ -0,0 +1,69 @@
+/**
+ * gitExec.cjs — shared `git` exec primitive + worktree-porcelain parser.
+ *
+ * Consolidates three near-duplicate `execGit` helpers that grew up
+ * independently (gitWorktree.cjs, branchSweep.cjs, scheduler.cjs's
+ * `execGitAt`) into one implementation. Deliberately has ZERO requires of
+ * electron, scheduler.cjs, or gitWorktree.cjs — gitWorktree.cjs's own
+ * comment (near its `unquotePorcelainPath`) notes scheduler.cjs requires
+ * gitWorktree.cjs, so anything gitWorktree.cjs or scheduler.cjs needs to
+ * share must live BELOW both in the require graph, never above. This file
+ * is that floor.
+ *
+ * Always `execFile('git', ...)` with an argv array — never a shell string,
+ * never `shell: true`.
+ */
+'use strict';
+
+const { execFile } = require('node:child_process');
+
+/**
+ * execGit(cwd, args, opts?) → Promise<string> (stdout)
+ *
+ * `opts.timeout` (default 20_000ms), `opts.maxBuffer` (node's own execFile
+ * default when omitted), `opts.env` (merged over `process.env`, never
+ * replacing it — so PATH/HOME etc. survive). Rejects with the raw execFile
+ * error, decorated with `err.stderrText` and `err.stdoutText` — some git
+ * subcommands (e.g. `diff --no-index`) exit non-zero to mean "found a
+ * difference", not "failed", so callers that need the output back can
+ * recover it off the rejected error rather than losing it.
+ */
+function execGit(cwd, args, opts = {}) {
+  const { timeout = 20_000, maxBuffer, env } = opts;
+  const execOpts = {
+    cwd,
+    timeout,
+    windowsHide: true,
+    encoding: 'utf8',
+  };
+  if (maxBuffer !== undefined) execOpts.maxBuffer = maxBuffer;
+  if (env) execOpts.env = { ...process.env, ...env };
+  return new Promise((resolve, reject) => {
+    execFile('git', args, execOpts, (err, stdout, stderr) => {
+      if (err) {
+        err.stderrText = stderr;
+        err.stdoutText = stdout;
+        reject(err);
+        return;
+      }
+      resolve(stdout || '');
+    });
+  });
+}
+
+/** Parse `git worktree list --porcelain` into `[{ worktree, branch }]`. */
+function parseWorktreePorcelain(text) {
+  const entries = [];
+  let cur = null;
+  for (const line of String(text || '').split('\n')) {
+    if (line.startsWith('worktree ')) {
+      cur = { worktree: line.slice('worktree '.length).trim(), branch: null };
+      entries.push(cur);
+    } else if (line.startsWith('branch ') && cur) {
+      cur.branch = line.slice('branch '.length).trim().replace(/^refs\/heads\//, '');
+    }
+  }
+  return entries;
+}
+
+module.exports = { execGit, parseWorktreePorcelain };