claude-code-session-manager 0.40.3 → 0.41.0

package/src/main/lib/rcaFeedbackHook.cjs

@@ -28,6 +28,7 @@ const fs = require('node:fs');
 const os = require('node:os');
 const path = require('node:path');
 const config = require('../config.cjs');
+const { ensureEpic } = require('./epicMint.cjs');
 const { splitFrontmatter } = require('./prdFrontmatter.cjs');
 const { readTail } = require('./fileTail.cjs');
 const { resolvePrdWriteDir } = require('./prdLocations.cjs');
@@ -35,7 +36,6 @@ const { resolvePrdWriteDir } = require('./prdLocations.cjs');
 // The one project this hook always knows how to reach, used as the fallback
 // destination when a job's own cwd has no feedback inbox.
 const SM_REPO_ROOT = path.join(os.homedir(), 'Projects', 'session-manager');
-const SM_REPO_FEEDBACK_DIR = path.join(SM_REPO_ROOT, 'session-manager-operations', 'feedback');
 
 // NEVER write here: ~/.claude/session-manager/feedback/ is the scheduler's
 // auto-PRD intake (src/main/scheduler.cjs's periodic feedback sweep) — it
@@ -200,27 +200,31 @@ function extractAcceptanceCriteria(prdBody) {
 // ─── Destination resolution ──────────────────────────────────────────────────
 
 /**
- * Resolve where an RCA for `job` should be filed.
- *   1. <job.cwd>/session-manager-operations/feedback/ if it exists.
- *   2. Else session-manager's own repo inbox, naming the target project.
+ * Resolve which PROJECT the proposal is filed into.
+ *   1. the job's own cwd — Epics live in every project, so this is almost
+ *      always the answer.
+ *   2. else session-manager's own repo, naming the target project in the body.
+ *
+ * The old version probed for a `session-manager-operations/feedback/`
+ * directory and fell back when it was missing; with proposals there is
+ * nothing to probe for — the Epic store is created on demand.
  */
 function resolveDestination(job) {
   const jobCwd = job?.cwd;
   if (jobCwd) {
-    const candidate = path.join(jobCwd, 'session-manager-operations', 'feedback');
-    try {
-      if (fs.statSync(candidate).isDirectory()) {
-        return { dir: candidate, allowlistRoot: jobCwd, targetProjectNote: null };
-      }
-    } catch {
-      // missing/inaccessible — fall through to the session-manager fallback
-    }
+    return { cwd: jobCwd, allowlistRoot: jobCwd, targetProjectNote: null };
   }
-  const targetProjectNote = jobCwd
-    ? `Filed into session-manager's own feedback inbox because \`${jobCwd}\` has no ` +
-      `\`session-manager-operations/feedback/\` directory. Target project: \`${jobCwd}\`.`
-    : 'Filed into session-manager\'s own feedback inbox (job had no cwd on record).';
-  return { dir: SM_REPO_FEEDBACK_DIR, allowlistRoot: SM_REPO_ROOT, targetProjectNote };
+  return {
+    cwd: SM_REPO_ROOT,
+    allowlistRoot: SM_REPO_ROOT,
+    targetProjectNote: "Filed into session-manager's own project (job had no cwd on record).",
+  };
+}
+
+/** One-line title for the proposal — goalText is what the Epics list shows,
+ *  so it must stay short; the full RCA markdown rides in openingPrompt. */
+function rcaProposalTitle(job, verdict) {
+  return `PRD ${job?.slug ?? 'unknown'} needs review: ${humanVerdict(verdict)}`;
 }
 
 function shortRunId(runId) {
@@ -228,10 +232,6 @@ function shortRunId(runId) {
   return cleaned.slice(0, 12) || 'norun';
 }
 
-function rcaFileName(dateStr, slug, runId) {
-  return `${dateStr}-rca-${slug}-${shortRunId(runId)}.md`;
-}
-
 function lastNLines(text, n) {
   const lines = (text || '').split('\n');
   return lines.slice(-n).join('\n');
@@ -328,35 +328,6 @@ async function fileRcaFeedback({ job, runDir, verdict, annotations, investigatio
     }
 
     const dest = resolveDestination(job);
-    const dateStr = (now instanceof Date ? now : new Date()).toISOString().slice(0, 10);
-    const fileName = rcaFileName(dateStr, job.slug, job.runId);
-    const destPath = path.resolve(path.join(dest.dir, fileName));
-    if (!destPath.startsWith(path.resolve(dest.dir) + path.sep)) {
-      console.log(`[rca] skip: destPath escaped dest dir (${destPath})`);
-      return { filed: false, reason: 'unsafe-path' };
-    }
-    // /process-feedback archives dispositioned items to <dest.dir>/processed/
-    // immediately at disposition time (its own README convention) — long
-    // before this hook's own run-verify/self-heal passes might touch the same
-    // (slug, runId) again. Once archived, the live-dir check alone goes false
-    // and a re-trigger would refile a duplicate straight into the live inbox.
-    const processedPath = path.resolve(path.join(dest.dir, 'processed', fileName));
-    if (!processedPath.startsWith(path.resolve(path.join(dest.dir, 'processed')) + path.sep)) {
-      console.log(`[rca] skip: processedPath escaped processed dir (${processedPath})`);
-      return { filed: false, reason: 'unsafe-path' };
-    }
-
-    const liveExists = fs.existsSync(destPath);
-    const processedExists = !liveExists && fs.existsSync(processedPath);
-    const alreadyFiled = liveExists || processedExists;
-    if (alreadyFiled && !investigationText) {
-      const existingPath = liveExists ? destPath : processedPath;
-      console.log(`[rca] skip: already filed for ${job.slug}@${job.runId}`);
-      return { filed: false, reason: 'duplicate', path: existingPath };
-    }
-    // An investigationText update must target wherever the file actually
-    // lives (live dir or processed/), not assume the live dir.
-    const targetPath = liveExists || !processedExists ? destPath : processedPath;
 
     const meta = readRunMeta(runDir, job.slug);
     const logPath = runDir ? path.join(runDir, `${job.slug}.log`) : null;
@@ -369,11 +340,27 @@ async function fileRcaFeedback({ job, runDir, verdict, annotations, investigatio
       targetProjectNote: dest.targetProjectNote, annotations,
     });
 
+    // File it as a PROPOSED Epic rather than a markdown file in a feedback
+    // inbox. The proposal lands directly in the Epics workspace behind an
+    // Approve & start gate: nothing runs and nothing is spent until a human
+    // approves it. This replaced the feedback-folder intake (and the
+    // process-feedback triage pass that existed only to read it back out) —
+    // the proposal IS the work item, already carrying its own session and
+    // PRD directory. reuseByGoal makes a re-trigger for the same failure
+    // join the existing proposal instead of duplicating it, which is what
+    // the old live/processed existence checks were for.
     config.addAllowedRoot(dest.allowlistRoot);
-    await config.writeTextAtomic(targetPath, markdown);
+    const title = rcaProposalTitle(job, verdict);
+    const { epicId, created } = await ensureEpic(dest.cwd, {
+      goalText: title,
+      tag: 'bug',
+      status: 'proposed',
+      reuseByGoal: true,
+      openingPrompt: markdown,
+    });
 
-    console.log(`[rca] ${alreadyFiled ? 'updated (investigation)' : 'filed'} ${targetPath}`);
-    return { filed: true, path: targetPath, updated: alreadyFiled };
+    console.log(`[rca] ${created ? 'proposed' : 'joined'} epic ${epicId} for ${job.slug}`);
+    return { filed: true, epicId, created, updated: !created };
   } catch (e) {
     console.error('[rca] error filing RCA feedback', e?.message ?? String(e));
     return { filed: false, reason: 'error', error: e?.message ?? String(e) };
@@ -382,15 +369,14 @@ async function fileRcaFeedback({ job, runDir, verdict, annotations, investigatio
 
 module.exports = {
   fileRcaFeedback,
+  rcaProposalTitle,
   // Pure helpers, exported for unit tests.
   humanVerdict,
   classifyFailure,
   extractAcceptanceCriteria,
   extractRcaBlock,
   resolveDestination,
-  rcaFileName,
   buildRcaMarkdown,
   FAILURE_CLASSES,
   VERDICT_LABELS,
-  SM_REPO_FEEDBACK_DIR,
 };

package/src/main/projectBrief.cjs

@@ -226,8 +226,22 @@ async function gatherSrcTree(cwd) {
 
 const inFlight = new Set();
 
+/**
+ * Register the project root as an allowed WRITE root before persisting
+ * brief.json. config.cjs only grants project-root writes to roots added via
+ * addAllowedRoot, and until now the sole caller was pty.cjs's spawn — so a
+ * project whose tab had no live PTY (dormant/hydrated tab, chat-only Epic)
+ * failed the write with "Write outside allowed write boundaries" *after*
+ * paying for a full synthesis. The read-side validatePath above has already
+ * proven the cwd is inside allowedRoots, so this widens nothing.
+ */
+function allowBriefWrites(realCwd) {
+  config.addAllowedRoot(realCwd);
+}
+
 async function refresh({ cwd }) {
   const realCwd = config.validatePath(cwd);
+  allowBriefWrites(realCwd);
 
   if (inFlight.has(realCwd)) {
     return { ok: false, error: 'refresh already running' };
@@ -279,9 +293,10 @@ async function refresh({ cwd }) {
       priorPinned,
       model: BRIEF_MODEL,
       nowIso: new Date().toISOString(),
+      priorEditedAt: priorBrief ? priorBrief.editedAt : null,
     });
 
-    await config.writeJson(briefPath(realCwd), persisted);
+    await config.writeJson(briefPath(realCwd), persisted, { writer: 'project-home' });
     return { ok: true, brief: persisted };
   } finally {
     if (token) sessionSlots.release(token);
@@ -289,12 +304,29 @@ async function refresh({ cwd }) {
   }
 }
 
+/**
+ * Hand-edit brief.json in place — the "maintain" half of the generate-and-
+ * maintain loop, and the reason the brief is a real file rather than a cache.
+ * Zero LLM cost. Edited pinnable blocks are auto-pinned by computeUpdate so
+ * the next refresh feeds them back in instead of rewriting them.
+ */
+async function update({ cwd, patch }) {
+  const realCwd = config.validatePath(cwd);
+  allowBriefWrites(realCwd);
+  const currentBrief = await readBrief(realCwd);
+  const result = core.computeUpdate(currentBrief, patch, new Date().toISOString());
+  if (!result.ok) return result;
+  await config.writeJson(briefPath(realCwd), result.brief, { writer: 'project-home' });
+  return { ok: true, brief: result.brief };
+}
+
 async function setPin({ cwd, block, pinned }) {
   const realCwd = config.validatePath(cwd);
+  allowBriefWrites(realCwd);
   const currentBrief = await readBrief(realCwd);
   const result = core.computeSetPin(currentBrief, block, pinned);
   if (!result.ok) return result;
-  await config.writeJson(briefPath(realCwd), result.brief);
+  await config.writeJson(briefPath(realCwd), result.brief, { writer: 'project-home' });
   return { ok: true, brief: result.brief };
 }
 
@@ -303,6 +335,7 @@ function registerProjectBriefIpc() {
   ipcMain.handle('project-brief:get', v(s.projectBriefCwd, get));
   ipcMain.handle('project-brief:refresh', v(s.projectBriefCwd, refresh));
   ipcMain.handle('project-brief:set-pin', v(s.projectBriefSetPin, setPin));
+  ipcMain.handle('project-brief:update', v(s.projectBriefUpdate, update));
 }
 
 module.exports = {
@@ -310,4 +343,5 @@ module.exports = {
   get,
   refresh,
   setPin,
+  update,
 };

package/src/main/promptSessionEvents.cjs

@@ -18,6 +18,22 @@ function promptSessionActiveIndexPath(cwd) {
   return `${String(cwd).replace(/\/+$/, '')}/session-manager-operations/prompt-sessions/active-index.json`;
 }
 
+// IPC channel broadcast whenever an event is appended to a PromptSession's
+// chain from the main process (currently only the scheduler's response-event
+// append below). Mirrors chatRunner.cjs's attachWindow/broadcast pattern.
+const EVENT_APPENDED_CHANNEL = 'promptSession:event-appended';
+
+let mainWindow = null;
+function attachWindow(win) { mainWindow = win; }
+
+function broadcast(channel, payload) {
+  try {
+    if (mainWindow && !mainWindow.isDestroyed() && mainWindow.webContents && !mainWindow.webContents.isDestroyed()) {
+      mainWindow.webContents.send(channel, payload);
+    }
+  } catch { /* render frame may be gone */ }
+}
+
 let seq = 0;
 function mintEventId() {
   seq += 1;
@@ -75,7 +91,8 @@ async function appendResponseEventIfKnown(cwd, sourcePromptId, text) {
         text,
       };
       data.events[sourcePromptId] = [...events, event];
-      await config.writeJson(path, data);
+      await config.writeJson(path, data, { writer: 'scheduler' });
+      broadcast(EVENT_APPENDED_CHANNEL, { cwd, promptSessionId: sourcePromptId, event });
       return true;
     });
   } catch (e) {
@@ -84,4 +101,9 @@ async function appendResponseEventIfKnown(cwd, sourcePromptId, text) {
   }
 }
 
-module.exports = { appendResponseEventIfKnown, promptSessionActiveIndexPath };
+module.exports = {
+  appendResponseEventIfKnown,
+  promptSessionActiveIndexPath,
+  attachWindow,
+  EVENT_APPENDED_CHANNEL,
+};

package/src/main/queueOps.cjs

@@ -519,7 +519,7 @@ async function retagOne({ slug, parallelGroup, estimateMinutes }) {
   // Atomic write via shared helper. If slug changed, write at the new path
   // and unlink the old slug.
   try {
-    await config.writeTextAtomic(dst, newRaw);
+    await config.writeTextAtomic(dst, newRaw, { writer: 'scheduler' });
     if (dst !== src) {
       try { await fsp.unlink(src); } catch { /* if src is already same as dst (race), fine */ }
     }

package/src/main/scheduler/prdParser.cjs

@@ -73,6 +73,14 @@ async function parsePrdRaw(filePath) {
     // dropped straight into an Epic's prds/ dir still get real linkage
     // instead of null.
     sourcePromptId: fm.sourcePromptId || deriveEpicIdFromPrdPath(filePath) || null,
+    // The Epic this PRD actually belongs to, derived purely from its location
+    // (epic dir name == epic id, 1:1 by design — prdLocations.deriveEpicIdFromPrdPath).
+    // Deliberately separate from sourcePromptId: that field is *intent* and
+    // can be stale or hand-written wrong in frontmatter (real rows in
+    // queue.json exist where sourcePromptId and sourceTabId disagree), while
+    // this one is *fact* on disk. Every surface that shows "which Epic is this
+    // from" reads this, so Scheduler and Epics can't drift apart.
+    epicId: deriveEpicIdFromPrdPath(filePath),
     // Optional traceability back to the chat tab that queued this PRD (PRD
     // 761) — read back at job completion to route a status prompt via
     // enqueueExternalPrompt (PRD 753). Additive — absent on every PRD