claude-code-session-manager 0.111.0 → 0.113.0

package/src/main/lib/{epicMint.cjs → epic/epicMint.cjs}

@@ -31,20 +31,20 @@ const fs = require('node:fs');
 const os = require('node:os');
 const path = require('node:path');
 const crypto = require('node:crypto');
-const { resolveEpicPrdWriteDir } = require('./prdLocations.cjs');
-const { assertOpsWrite } = require('./opsOwnership.cjs');
-const { appendAuditEvent } = require('./auditLog.cjs');
+const { resolveEpicPrdWriteDir } = require('../prd/prdLocations.cjs');
+const { assertOpsWrite } = require('../opsOwnership.cjs');
+const { appendAuditEvent } = require('../telemetry/auditLog.cjs');
 const { mirrorEpicStatus, removeEpicMirror } = require('./epicStatusMirror.cjs');
-const atomicFs = require('./atomicFs.cjs');
-const telemetryCounters = require('./telemetryCounters.cjs');
+const atomicFs = require('../util/atomicFs.cjs');
+const telemetryCounters = require('../telemetry/telemetryCounters.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
 // hardcoded and always valid.
-const promptSessionSchema = require('./promptSessionSchema.cjs');
+const promptSessionSchema = require('../promptSessionSchema.cjs');
 
 // The one token that unlocks ensureEpic's mint branch. Held by
-// lib/promptSessionsCreateEpic.cjs (the New Epic card's IPC handler) and
+// lib/epic/promptSessionsCreateEpic.cjs (the New Epic card's IPC handler) and
 // nothing else — grep for it before adding a second holder, that is a
 // deliberate domain-model change, not a convenience.
 const MINT_AUTHORITY_NEW_EPIC_UI = 'new-epic-ui';
@@ -56,7 +56,7 @@ const MINT_AUTHORITY_NEW_EPIC_UI = 'new-epic-ui';
 // the `feedback/` folder retired (2026-08-02) and the scheduler correctly
 // locked down to join-only, an agent working in Project-A had NO way to hand
 // a finding to Project-B — the finding either died in a transcript or the
-// human had to relay it by hand. `lib/crossProjectFeedback.cjs` restores that
+// human had to relay it by hand. `lib/feedback-remote/crossProjectFeedback.cjs` restores that
 // conduit, and it is the sole holder of this token.
 //
 // What makes it safe is the part of the SINGLE-CREATOR LAW that actually
@@ -79,7 +79,7 @@ const MINT_AUTHORITIES = Object.freeze([
 function activeIndexPath(cwd) {
   // Lazy: opsOwnership → ephemeralCwd → activeSessions; this module is
   // required early by several of those neighbours.
-  const { opsPath } = require('./opsOwnership.cjs');
+  const { opsPath } = require('../opsOwnership.cjs');
   return opsPath(cwd, 'prompt-sessions', 'active-index.json');
 }
 
@@ -93,7 +93,7 @@ function readActiveIndex(cwd) {
       // doesn't resurrect completed/deleted Epics on its own), but every
       // caller here does read-modify-write on the object this returns, so
       // dropping the field would silently erase the removal tombstones
-      // lib/activeIndexMerge.cjs's mergeActiveIndex records the next time any
+      // lib/epic/activeIndexMerge.cjs's mergeActiveIndex records the next time any
       // of ensureEpic/appendPrdCreatedEvent/removeEpic writes this file.
       tombstones: parsed && typeof parsed.tombstones === 'object' && parsed.tombstones ? parsed.tombstones : {},
     };
@@ -450,7 +450,7 @@ module.exports = {
   writeActiveIndex,
   personaFileExists,
   resolvePersonaPaths,
-  // Exported so lib/activeIndexMerge.cjs's renderer-facing merge IPC handler
+  // Exported so lib/epic/activeIndexMerge.cjs's renderer-facing merge IPC handler
   // serializes through the SAME lock instance as ensureEpic/
   // appendPrdCreatedEvent (module-level Map, shared via Node's require
   // cache) — one lock per active-index.json path across both callers, not

package/src/main/lib/{epicSpawnPlan.cjs → epic/epicSpawnPlan.cjs}

@@ -27,8 +27,8 @@
 const fs = require('node:fs');
 const os = require('node:os');
 const path = require('node:path');
-const { encodeCwd } = require('./encodeCwd.cjs');
-const { projectRootOf } = require('./activeSessions.cjs');
+const { encodeCwd } = require('../util/encodeCwd.cjs');
+const { projectRootOf } = require('../activeSessions.cjs');
 const { readActiveIndex } = require('./epicMint.cjs');
 const { resolveEpicSpawnCwd } = require('./epicSpawnCwd.cjs');
 const { resolveEpicTranscriptPath } = require('./epicTranscriptPath.cjs');
@@ -56,7 +56,7 @@ function findEpic(cwd, claudeSessionId, deps) {
     }
   } catch { /* unreadable index → try archives */ }
   try {
-    const { opsPath } = require('./opsOwnership.cjs');
+    const { opsPath } = require('../opsOwnership.cjs');
     const dir = opsPath(cwd, 'prompt-sessions');
     for (const name of fs.readdirSync(dir)) {
       if (!name.endsWith('.json') || name === 'active-index.json') continue;

package/src/main/lib/{epicStatusMirror.cjs → epic/epicStatusMirror.cjs}

@@ -26,8 +26,8 @@
  */
 
 const fs = require('node:fs');
-const { assertOpsWrite, opsPath } = require('./opsOwnership.cjs');
-const atomicFs = require('./atomicFs.cjs');
+const { assertOpsWrite, opsPath } = require('../opsOwnership.cjs');
+const atomicFs = require('../util/atomicFs.cjs');
 
 function epicMirrorPath(cwd, epicId) {
   return opsPath(cwd, 'prompt-sessions', `${epicId}.json`);

package/src/main/lib/{epicTranscriptDiagnostic.cjs → epic/epicTranscriptDiagnostic.cjs}

@@ -17,9 +17,9 @@
 const fs = require('node:fs');
 const os = require('node:os');
 const path = require('node:path');
-const { encodeCwd } = require('./encodeCwd.cjs');
+const { encodeCwd } = require('../util/encodeCwd.cjs');
 const { readActiveIndex } = require('./epicMint.cjs');
-const { opsPath } = require('./opsOwnership.cjs');
+const { opsPath } = require('../opsOwnership.cjs');
 const { resolveEpicTranscriptPath } = require('./epicTranscriptPath.cjs');
 
 /** [epicId, session] pairs: active-index rows plus archived per-Epic `<id>.json` records. */

package/src/main/lib/{epicTranscriptPath.cjs → epic/epicTranscriptPath.cjs}

@@ -25,7 +25,7 @@
 const fs = require('node:fs');
 const os = require('node:os');
 const path = require('node:path');
-const { encodeCwd } = require('./encodeCwd.cjs');
+const { encodeCwd } = require('../util/encodeCwd.cjs');
 const { readActiveIndex } = require('./epicMint.cjs');
 const { resolveEpicSpawnCwd } = require('./epicSpawnCwd.cjs');
 
@@ -53,7 +53,7 @@ function statKey(statSync, p) {
 }
 
 function opsFile(cwd, ...segments) {
-  const { opsPath } = require('./opsOwnership.cjs');
+  const { opsPath } = require('../opsOwnership.cjs');
   return opsPath(cwd, 'prompt-sessions', ...segments);
 }
 

package/src/main/lib/{epicValidationHook.cjs → epic/epicValidationHook.cjs}

@@ -15,7 +15,7 @@
  * VERIFIED or REFUTED with evidence. The job's self-reported status is an
  * input to that check, never a substitute for it.
  *
- * Shape mirrors lib/dodDrainHook.cjs: fire-and-forget (never throws to the
+ * Shape mirrors lib/scheduler/dodDrainHook.cjs: fire-and-forget (never throws to the
  * caller — errors are logged), kill-switched, idempotent.
  *
  * Kill-switch: SM_EPIC_VALIDATION_DISABLE=1 (mirrors the SM_DOD_DISABLE
@@ -24,7 +24,7 @@
  * SESSION SLOT POOL: this module spawns NOTHING. The prompt is enqueued via
  * chatRunner.cjs's enqueueExternalPrompt → `chat:external-send` → the
  * renderer's chat queue → chatRunner's pump, which acquires a slot from the
- * machine-wide lib/sessionSlots.cjs pool (chatRunner.cjs pump()) before any
+ * machine-wide lib/scheduler/sessionSlots.cjs pool (chatRunner.cjs pump()) before any
  * `claude -p` process starts. So the validation session cannot start outside
  * the pool — if the pool is exhausted the prompt simply waits in the chat
  * lane's FIFO, it never fans out into an extra parallel process (the
@@ -62,7 +62,7 @@ function pairKey(epicId, prdSlug) {
  */
 function defaultReadActiveIndex(cwd) {
   try {
-    const { opsPath } = require('./opsOwnership.cjs');
+    const { opsPath } = require('../opsOwnership.cjs');
     const p = opsPath(cwd, 'prompt-sessions', 'active-index.json');
     return JSON.parse(fs.readFileSync(p, 'utf8'));
   } catch {

package/src/main/lib/{epicWorktreeBoot.cjs → epic/epicWorktreeBoot.cjs}

@@ -22,7 +22,7 @@
  * automatically — this predicate covers the other half.
  */
 
-const gitWorktree = require('./gitWorktree.cjs');
+const gitWorktree = require('../git/gitWorktree.cjs');
 const { readActiveIndex } = require('./epicMint.cjs');
 
 /**

package/src/main/lib/{epicWorktreeMerge.cjs → epic/epicWorktreeMerge.cjs}

@@ -25,8 +25,8 @@
  * them from the command line.
  */
 
-const { integrateEpicBranch, cleanupEpicWorktree } = require('./gitWorktree.cjs');
-const { validatePath } = require('../config.cjs');
+const { integrateEpicBranch, cleanupEpicWorktree } = require('../git/gitWorktree.cjs');
+const { validatePath } = require('../../config.cjs');
 
 /**
  * mergeEpicToMainViaIpc(cwd, epicId, branch, dir) → Promise<MergeOutcome>
@@ -54,7 +54,7 @@ async function mergeEpicToMainViaIpc(cwd, epicId, branch, dir, carriedPaths) {
 
 function registerEpicWorktreeMergeHandlers() {
   const { ipcMain } = require('electron');
-  const { schemas: s, validated: v } = require('../ipcSchemas.cjs');
+  const { schemas: s, validated: v } = require('../../ipcSchemas.cjs');
   ipcMain.handle(
     'promptSessions:merge-to-main',
     v(s.promptSessionsMergeToMain, ({ cwd, epicId, branch, dir, carriedPaths }) => mergeEpicToMainViaIpc(cwd, epicId, branch, dir, carriedPaths)),

package/src/main/lib/{epicWorktreeMint.cjs → epic/epicWorktreeMint.cjs}

@@ -24,8 +24,8 @@
  * since this is likewise reachable from the renderer over IPC.
  */
 
-const { createEpicWorktree } = require('./gitWorktree.cjs');
-const { validatePath } = require('../config.cjs');
+const { createEpicWorktree } = require('../git/gitWorktree.cjs');
+const { validatePath } = require('../../config.cjs');
 
 /**
  * createEpicWorktreeViaIpc(cwd, epicId) → Promise<EpicWorktree | null>
@@ -59,7 +59,7 @@ async function createEpicWorktreeViaIpc(cwd, epicId) {
 
 function registerEpicWorktreeMintHandlers() {
   const { ipcMain } = require('electron');
-  const { schemas: s, validated: v } = require('../ipcSchemas.cjs');
+  const { schemas: s, validated: v } = require('../../ipcSchemas.cjs');
   ipcMain.handle(
     'promptSessions:create-worktree',
     v(s.promptSessionsCreateWorktree, ({ cwd, epicId }) => createEpicWorktreeViaIpc(cwd, epicId)),

package/src/main/lib/{epicWorktreeProjectConfig.cjs → epic/epicWorktreeProjectConfig.cjs}

@@ -35,8 +35,8 @@
 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');
+const { assertOpsWrite, opsPath } = require('../opsOwnership.cjs');
+const atomicFs = require('../util/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
@@ -116,8 +116,8 @@ function setEpicWorktreeDisabledForProject(cwd, disabled, writer = 'epics') {
 
 function registerEpicWorktreeProjectConfigHandlers() {
   const { ipcMain } = require('electron');
-  const { schemas: s, validated: v } = require('../ipcSchemas.cjs');
-  const { validatePath } = require('../config.cjs');
+  const { schemas: s, validated: v } = require('../../ipcSchemas.cjs');
+  const { validatePath } = require('../../config.cjs');
   ipcMain.handle(
     'promptSessions:get-worktree-disabled',
     v(s.promptSessionsGetWorktreeDisabled, ({ cwd }) => {

package/src/main/lib/{promptSessionsCreateEpic.cjs → epic/promptSessionsCreateEpic.cjs}

@@ -7,14 +7,14 @@
  *
  * Step 1 of a two-PRD chain (PRD 953 here; PRD 954 routes createPromptSession
  * through it): purely additive today — nothing calls this handler yet. Kept
- * as a sibling module (mirrors lib/activeIndexMerge.cjs, which does the same
+ * as a sibling module (mirrors lib/epic/activeIndexMerge.cjs, which does the same
  * "own file, own register*Handlers export, wired from index.cjs" shape for
  * the neighboring active-index merge IPC) rather than growing epicMint.cjs
  * itself, since this is IPC-registration plumbing, not Epic-minting logic.
  */
 
 const { ensureEpic, readActiveIndex, MINT_AUTHORITY_NEW_EPIC_UI } = require('./epicMint.cjs');
-const { validatePath } = require('../config.cjs');
+const { validatePath } = require('../../config.cjs');
 
 /**
  * createEpicViaIpc(cwd, { goalText, tag?, agentType?, source? }) → Promise<{ epicId, session }>
@@ -38,7 +38,7 @@ const { validatePath } = require('../config.cjs');
  * + every cwd a TAB has opened) closes the gap so this handler can't be used
  * to make main write session-manager-operations/ into an arbitrary
  * filesystem location — the same boundary every other renderer-facing path
- * IPC (config:read-json/write-json, lib/activeIndexMerge.cjs's own merge) is
+ * IPC (config:read-json/write-json, lib/epic/activeIndexMerge.cjs's own merge) is
  * already required to pass through.
  */
 async function createEpicViaIpc(cwd, { goalText, tag, agentType, model, effort, source, openingPrompt, sections } = {}) {
@@ -61,7 +61,7 @@ async function createEpicViaIpc(cwd, { goalText, tag, agentType, model, effort,
 
 function registerPromptSessionsCreateEpicHandlers() {
   const { ipcMain } = require('electron');
-  const { schemas: s, validated: v } = require('../ipcSchemas.cjs');
+  const { schemas: s, validated: v } = require('../../ipcSchemas.cjs');
   ipcMain.handle(
     'promptSessions:create-epic',
     v(s.promptSessionsCreateEpic, ({ cwd, goalText, tag, agentType, model, effort, source, openingPrompt, sections }) =>

package/src/main/lib/{crossProjectFeedback.cjs → feedback-remote/crossProjectFeedback.cjs}

@@ -33,7 +33,19 @@
  * feedback Epic is born 'proposed' like every other Epic (epicMint.cjs's
  * BORN-PROPOSED check applies to this mint authority verbatim), so the human
  * in the RECEIVING project is still the one who decides whether a single token
- * gets spent. An agent can ask; it cannot start.
+ * gets spent. An agent can ask; it cannot start on its own say-so.
+ *
+ * The one exception is a VERIFIED HUMAN REQUEST. When the human themselves
+ * asked, in chat, for work in another project, making them re-confirm in the
+ * receiving project is pure friction. So `autoStart: true` plus a
+ * `humanRequestQuote` is honored only when main can check the quote against
+ * humanPromptLedger (prompts chat:run recorded with human origin) for the
+ * originating chat session — `input.originClaudeSessionId`, taken from the MCP
+ * server's env, set only for interactive chat runs, never for scheduler jobs —
+ * AND that human prompt names the target project. Even then the Epic is still
+ * minted 'proposed'; it is only stamped `source.autoApprove` and the renderer
+ * is told to approve-and-start it through its normal approveProposed path.
+ * Anything unverifiable degrades to the ordinary proposal.
  *
  * Guards, all fail-closed:
  *   - both cwds go through config.cjs's validatePath (allowedRoots = home)
@@ -57,16 +69,16 @@ const fsp = require('node:fs/promises');
 const os = require('node:os');
 const path = require('node:path');
 
-const config = require('../config.cjs');
+const config = require('../../config.cjs');
 const { readBody, sendJson } = require('./localAdminHttp.cjs');
 const {
   ensureEpic,
   readActiveIndex,
   MINT_AUTHORITY_CROSS_PROJECT_FEEDBACK,
-} = require('./epicMint.cjs');
-const { appendAuditEvent } = require('./auditLog.cjs');
-const { OPS_ROOT_DIR } = require('./opsOwnership.cjs');
-const { resolveProjectContext } = require('./projectRootResolve.cjs');
+} = require('../epic/epicMint.cjs');
+const { appendAuditEvent } = require('../telemetry/auditLog.cjs');
+const { OPS_ROOT_DIR } = require('../opsOwnership.cjs');
+const { resolveProjectContext } = require('../projectRootResolve.cjs');
 
 /** Only these three Epic tags make sense for an inbound report — they are
  *  exactly the tags that route through /develop (tagLibrary.ts). 'build' and
@@ -90,6 +102,7 @@ const MAX_SERIES_KEY_CHARS = 60;
 const MAX_SERIES_TITLE_CHARS = 120;
 const MAX_SERIES_TOTAL = 50;
 const MAX_ORIGIN_ASK_CHARS = 300;
+const MAX_HUMAN_QUOTE_CHARS = 2000;
 const KEBAB_RE = /^[a-z0-9]+(?:-[a-z0-9]+)*$/;
 
 /** Bound on how many `~/.claude/projects/` folders listFeedbackTargets will
@@ -349,6 +362,18 @@ function validateFeedbackInput(input = {}) {
     series = { key, title: stitle, index: sr.index, total: sr.total };
   }
 
+  if (input.autoStart !== undefined && input.autoStart !== null && typeof input.autoStart !== 'boolean') {
+    return bad(400, 'autoStart must be a boolean');
+  }
+  let humanRequestQuote = '';
+  if (input.humanRequestQuote !== undefined && input.humanRequestQuote !== null) {
+    if (typeof input.humanRequestQuote !== 'string') return bad(400, 'humanRequestQuote must be a string');
+    humanRequestQuote = input.humanRequestQuote.trim();
+    if (humanRequestQuote.length > MAX_HUMAN_QUOTE_CHARS) {
+      return bad(400, `humanRequestQuote is ${humanRequestQuote.length} chars; cap is ${MAX_HUMAN_QUOTE_CHARS}`);
+    }
+  }
+
   const referencePaths = Array.isArray(input.referencePaths) ? input.referencePaths : [];
   if (referencePaths.length > MAX_REFERENCES) {
     return bad(400, `too many referencePaths (${referencePaths.length}); cap is ${MAX_REFERENCES}`);
@@ -410,6 +435,8 @@ function validateFeedbackInput(input = {}) {
       acceptanceCriteria: lists.acceptanceCriteria,
       outOfScope: lists.outOfScope,
       series,
+      autoStart: input.autoStart === true,
+      humanRequestQuote,
       referencePaths: referencePaths.map((p) => String(p)),
       fromEpicId: input.fromEpicId ? String(input.fromEpicId) : null,
       agentType: input.agentType ? String(input.agentType) : DEFAULT_FEEDBACK_AGENT,
@@ -418,6 +445,44 @@ function validateFeedbackInput(input = {}) {
   };
 }
 
+/** Tell every renderer window to approve-and-start a granted auto-start Epic.
+ *  Electron is required lazily so unit tests never need it. */
+function defaultNotifyRenderer(payload) {
+  try {
+    const { BrowserWindow } = require('electron');
+    for (const win of BrowserWindow.getAllWindows()) {
+      try {
+        win.webContents.send('promptSessions:inbound-auto-approve', payload);
+      } catch { /* window going away */ }
+    }
+  } catch { /* not running under Electron */ }
+}
+
+/**
+ * verifyAutoStart(v, originClaudeSessionId) → { granted: true, quote } | { granted: false, reason }
+ *
+ * Every check is fail-closed. The session identity is ONLY the caller-supplied
+ * originClaudeSessionId (MCP env), never a field an agent can pick freely.
+ */
+function verifyAutoStart(v, originClaudeSessionId) {
+  if (!v.autoStart) return { granted: false, reason: 'autoStart was not requested' };
+  if (!v.humanRequestQuote) return { granted: false, reason: 'no humanRequestQuote was given' };
+  if (!originClaudeSessionId) {
+    return { granted: false, reason: 'no originClaudeSessionId — only interactive chat sessions can auto-start' };
+  }
+  const { findHumanPromptContaining } = require('./humanPromptLedger.cjs');
+  const found = findHumanPromptContaining(originClaudeSessionId, v.humanRequestQuote);
+  if (!found) {
+    return { granted: false, reason: 'humanRequestQuote was not found in a prompt the human typed in this chat session' };
+  }
+  const prompt = found.text.toLowerCase();
+  const base = path.basename(v.toCwd).toLowerCase();
+  if (!(base && prompt.includes(base)) && !prompt.includes(v.toCwd.toLowerCase())) {
+    return { granted: false, reason: `the human's prompt does not name the receiving project (${path.basename(v.toCwd)})` };
+  }
+  return { granted: true, quote: v.humanRequestQuote };
+}
+
 /**
  * openFeedbackSession(input, deps?) → { ok, status?, error?, epicId, toCwd, ... }
  *
@@ -427,8 +492,8 @@ function validateFeedbackInput(input = {}) {
  * best-effort: a failure there never invalidates a delivered proposal, it just
  * reports `receiptOnOriginEpic: false`.
  *
- * `deps` exists so tests can inject the two side-effecting collaborators
- * without an Electron/main-process boot.
+ * `deps` exists so tests can inject the side-effecting collaborators
+ * (ensureEpic, appendResponseEventIfKnown, notifyRenderer) without an Electron/main-process boot.
  */
 async function openFeedbackSession(input, deps = {}) {
   const mint = deps.ensureEpic || ensureEpic;
@@ -437,19 +502,28 @@ async function openFeedbackSession(input, deps = {}) {
     // Required lazily: promptSessionEvents.cjs pulls in config.cjs's watcher
     // machinery, and this module is also required from unit tests that never
     // boot the main process.
-    || ((...args) => require('../promptSessionEvents.cjs').appendResponseEventIfKnown(...args));
+    || ((...args) => require('../../promptSessionEvents.cjs').appendResponseEventIfKnown(...args));
+
+  const notify = deps.notifyRenderer || defaultNotifyRenderer;
 
   const checked = validateFeedbackInput(input);
   if (!checked.ok) return checked;
   const v = checked.value;
 
+  const originClaudeSessionId =
+    typeof input.originClaudeSessionId === 'string' && input.originClaudeSessionId
+      ? input.originClaudeSessionId
+      : null;
+  const auto = verifyAutoStart(v, originClaudeSessionId);
+  const verifiedAt = new Date().toISOString();
+
   // The MCP client can't know its own Epic id — it only inherits the claude
   // session id chatRunner.cjs stamps on the `claude -p` child. Resolve it
   // through prdCreate.cjs's existing resolver rather than a second copy of
   // the same lookup (required lazily: prdCreate pulls in ipcSchemas/config).
   if (!v.fromEpicId && input.originClaudeSessionId) {
     try {
-      const { resolveSourcePromptIdFromClaudeSession } = require('./prdCreate.cjs');
+      const { resolveSourcePromptIdFromClaudeSession } = require('../prd/prdCreate.cjs');
       v.fromEpicId = resolveSourcePromptIdFromClaudeSession(v.fromCwd, String(input.originClaudeSessionId)) || null;
     } catch { /* unresolvable — the proposal still delivers, just without a receipt */ }
   }
@@ -488,6 +562,16 @@ async function openFeedbackSession(input, deps = {}) {
         producer: 'cross-project-feedback',
         fromCwd: v.fromCwd,
         ...(v.fromEpicId ? { fromEpicId: v.fromEpicId } : {}),
+        ...(auto.granted
+          ? {
+              autoApprove: {
+                requestedBy: 'human',
+                quote: auto.quote,
+                verifiedAt,
+                fromClaudeSessionId: originClaudeSessionId,
+              },
+            }
+          : {}),
         proposal: {
           motivation: v.motivation,
           originAsk,
@@ -511,8 +595,16 @@ async function openFeedbackSession(input, deps = {}) {
     tag: v.tag,
     title: v.title,
     series: v.series,
+    autoStartGranted: auto.granted,
+    autoStartReason: auto.granted ? 'verified human request' : auto.reason,
   });
 
+  if (auto.granted) {
+    try {
+      notify({ cwd: v.toCwd, epicId: minted.epicId });
+    } catch { /* the Epic is delivered either way; a human can still approve it */ }
+  }
+
   let receiptOnOriginEpic = false;
   if (v.fromEpicId) {
     try {
@@ -522,7 +614,9 @@ async function openFeedbackSession(input, deps = {}) {
         `Feedback delivered to ${v.toCwd} as a proposed session (${minted.epicId}): "${v.title}"`
         + (v.series ? ` [${seriesLine(v.series)}]` : '')
         + '. '
-        + 'It will not run until a human in that project approves it.',
+        + (auto.granted
+          ? 'It was auto-approved at the human\'s explicit request and is starting in that project.'
+          : 'It will not run until a human in that project approves it.'),
       );
     } catch {
       receiptOnOriginEpic = false;
@@ -535,14 +629,18 @@ async function openFeedbackSession(input, deps = {}) {
     toCwd: v.toCwd,
     fromCwd: v.fromCwd,
     tag: v.tag,
-    status: 'proposed',
+    status: auto.granted ? 'auto-approved' : 'proposed',
+    ...(v.autoStart ? { autoStart: auto.granted ? { granted: true } : { granted: false, reason: auto.reason } } : {}),
     receiptOnOriginEpic,
     // Say plainly what did NOT happen, same posture as create-prd's
     // `enqueued: false` — never let a caller report this as "work started".
-    note:
-      'Delivered as a PROPOSED session in the receiving project\'s Sessions queue. Nothing runs and no '
-      + 'tokens are spent until a human in that project presses Approve & start. There is no callback: '
-      + 'if you need an answer, ask the human to follow up.',
+    note: auto.granted
+      ? 'Auto-approved at the human\'s explicit request (verified against their chat prompt): the session '
+        + 'is starting in the receiving project. There is no callback: if you need an answer, ask the human '
+        + 'to follow up.'
+      : 'Delivered as a PROPOSED session in the receiving project\'s Sessions queue. Nothing runs and no '
+        + 'tokens are spent until a human in that project presses Approve & start. There is no callback: '
+        + 'if you need an answer, ask the human to follow up.',
     goalText,
   };
 }

package/src/main/lib/{customerFeedbackClient.cjs → feedback-remote/customerFeedbackClient.cjs}

@@ -14,8 +14,8 @@
 
 const path = require('node:path');
 const fsp = require('node:fs/promises');
-const atomicFs = require('./atomicFs.cjs');
-const schedulerPaths = require('./schedulerPaths.cjs');
+const atomicFs = require('../util/atomicFs.cjs');
+const schedulerPaths = require('../scheduler/schedulerPaths.cjs');
 
 const FEEDBACK_SLUG = 'session-manager';
 const TAGS = /** @type {const} */ (['bug', 'feature', 'discussion']);
@@ -77,7 +77,7 @@ function defaultVersion() {
     if (electron && electron.app && typeof electron.app.getVersion === 'function') return electron.app.getVersion();
   } catch { /* not running under Electron */ }
   try {
-    return String(require('../../../package.json').version || 'unknown');
+    return String(require('../../../../package.json').version || 'unknown');
   } catch {
     return 'unknown';
   }

package/src/main/lib/{customerFeedbackInbox.cjs → feedback-remote/customerFeedbackInbox.cjs}

@@ -12,8 +12,8 @@
 
 const path = require('node:path');
 const fsp = require('node:fs/promises');
-const atomicFs = require('./atomicFs.cjs');
-const schedulerPaths = require('./schedulerPaths.cjs');
+const atomicFs = require('../util/atomicFs.cjs');
+const schedulerPaths = require('../scheduler/schedulerPaths.cjs');
 const { resolveFeedbackBase, fromWireType, FEEDBACK_SLUG } = require('./customerFeedbackClient.cjs');
 
 const STATUSES = /** @type {const} */ (['open', 'in_progress', 'resolved', 'wontfix']);

package/src/main/lib/{customerFeedbackIpc.cjs → feedback-remote/customerFeedbackIpc.cjs}

@@ -10,7 +10,7 @@ const REFRESH_DELAY_MS = 30_000;
  */
 function registerCustomerFeedbackHandlers(deps = {}) {
   const ipcMain = deps.ipcMain || require('electron').ipcMain;
-  const { schemas: s, validated: v } = require('../ipcSchemas.cjs');
+  const { schemas: s, validated: v } = require('../../ipcSchemas.cjs');
   const client = deps.client || require('./customerFeedbackClient.cjs');
   const inbox = deps.inbox || require('./customerFeedbackInbox.cjs');
   const timer = deps.setTimeoutImpl || setTimeout;

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

@@ -0,0 +1,93 @@
+'use strict';
+
+/**
+ * humanPromptLedger.cjs — in-memory record of prompts a HUMAN typed into each
+ * chat claude session, keyed by claudeSessionId.
+ *
+ * Why it exists. The cross-project feedback conduit (crossProjectFeedback.cjs)
+ * may auto-approve a receiving-project session only when the human explicitly
+ * asked for it. An agent's say-so is not evidence of that. This ledger is the
+ * ONLY evidence that a human — not an agent, not an external/Web Remote
+ * injection, not an inbound proposal's agent-written opening prompt — typed a
+ * given prompt. Callers record only prompts that arrived from the human's own
+ * chat input, then ask `findHumanPromptContaining` whether a quoted request
+ * really appears in one.
+ *
+ * In-memory by design. Losing the ledger on restart only degrades auto-approve
+ * back to the ordinary 'proposed' path — it fails closed, so nothing is
+ * persisted to disk.
+ *
+ * Bounds: 10 prompts per session, 24h TTL, 200 sessions (least-recently-
+ * recorded evicted), 20000 chars per stored prompt. Pure Node, no Electron.
+ */
+
+const MIN_QUOTE_CHARS = 20;
+const MAX_PER_SESSION = 10;
+const TTL_MS = 24 * 60 * 60 * 1000;
+const MAX_SESSIONS = 200;
+const MAX_TEXT_CHARS = 20000;
+
+/** @type {Map<string, Array<{ text: string, norm: string, at: number }>>} */
+const ledger = new Map();
+
+/** @param {string} s */
+function normalize(s) {
+  return s.replace(/\s+/g, ' ').trim().toLowerCase();
+}
+
+/**
+ * @param {unknown} claudeSessionId
+ * @param {unknown} text
+ * @param {number} [now]
+ */
+function recordHumanPrompt(claudeSessionId, text, now = Date.now()) {
+  try {
+    if (typeof claudeSessionId !== 'string' || !claudeSessionId) return;
+    if (typeof text !== 'string' || !text.trim()) return;
+    const stored = text.slice(0, MAX_TEXT_CHARS);
+    const prior = (ledger.get(claudeSessionId) || []).filter((e) => now - e.at <= TTL_MS);
+    prior.push({ text: stored, norm: normalize(stored), at: now });
+    while (prior.length > MAX_PER_SESSION) prior.shift();
+    // Re-insert so Map order is least-recently-recorded first.
+    ledger.delete(claudeSessionId);
+    ledger.set(claudeSessionId, prior);
+    while (ledger.size > MAX_SESSIONS) {
+      const oldest = ledger.keys().next().value;
+      if (oldest === undefined) break;
+      ledger.delete(oldest);
+    }
+  } catch {
+    /* never throws */
+  }
+}
+
+/**
+ * @param {unknown} claudeSessionId
+ * @param {unknown} quote
+ * @param {number} [now]
+ * @returns {{ text: string, at: number } | null}
+ */
+function findHumanPromptContaining(claudeSessionId, quote, now = Date.now()) {
+  try {
+    if (typeof claudeSessionId !== 'string' || typeof quote !== 'string') return null;
+    const q = normalize(quote);
+    if (q.length < MIN_QUOTE_CHARS) return null;
+    const entries = ledger.get(claudeSessionId);
+    if (!entries) return null;
+    const live = entries.filter((e) => now - e.at <= TTL_MS);
+    if (live.length === 0) ledger.delete(claudeSessionId);
+    else if (live.length !== entries.length) ledger.set(claudeSessionId, live);
+    for (let i = live.length - 1; i >= 0; i--) {
+      if (live[i].norm.includes(q)) return { text: live[i].text, at: live[i].at };
+    }
+    return null;
+  } catch {
+    return null;
+  }
+}
+
+function _resetForTests() {
+  ledger.clear();
+}
+
+module.exports = { recordHumanPrompt, findHumanPromptContaining, MIN_QUOTE_CHARS, _resetForTests };

package/src/main/lib/{localAdminHttp.cjs → feedback-remote/localAdminHttp.cjs}

@@ -35,8 +35,8 @@ const http = require('node:http');
 const path = require('node:path');
 const crypto = require('node:crypto');
 const fsp = require('node:fs/promises');
-const config = require('../config.cjs');
-const schedulerPaths = require('./schedulerPaths.cjs');
+const config = require('../../config.cjs');
+const schedulerPaths = require('../scheduler/schedulerPaths.cjs');
 
 /**
  * Mode-aware token file path, resolved fresh on every call (never cached at