claude-code-session-manager 0.38.1 → 0.38.2

package/dist/index.html

@@ -7,7 +7,7 @@
     <link rel="preconnect" href="https://fonts.googleapis.com">
     <link rel="preconnect" href="https://fonts.gstatic.com" crossorigin>
     <link href="https://fonts.googleapis.com/css2?family=Newsreader:ital,opsz,wght@0,6..72,400;0,6..72,500;0,6..72,600;0,6..72,700;1,6..72,400&family=Geist:wght@300;400;500;600;700&family=IBM+Plex+Mono:wght@400;500;600&display=swap" rel="stylesheet">
-    <script type="module" crossorigin src="./assets/index-CBSyk1aI.js"></script>
+    <script type="module" crossorigin src="./assets/index-CZPF8Qve.js"></script>
     <link rel="modulepreload" crossorigin href="./assets/monaco-editor-BW5C4Iv1.js">
     <link rel="stylesheet" crossorigin href="./assets/monaco-editor-BTnBOi8r.css">
     <link rel="stylesheet" crossorigin href="./assets/index-DyOGjslF.css">

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "claude-code-session-manager",
-  "version": "0.38.1",
+  "version": "0.38.2",
   "description": "Local cockpit for the Claude Code CLI — multi-tab terminal, full config surface, scheduler, voice dictation, and live observability.",
   "type": "module",
   "main": "src/main/index.cjs",

package/src/main/__tests__/scheduler-notify-originating-tab.test.cjs

@@ -0,0 +1,99 @@
+/**
+ * scheduler-notify-originating-tab.test.cjs — unit tests for
+ * notifyOriginatingTab (PRD 761): on a job's terminal completed/failed
+ * transition, push a short status prompt into the chat tab that originated
+ * it via enqueueExternalPrompt (PRD 753).
+ *
+ * Run: timeout 300 npx vitest run src/main/__tests__/scheduler-notify-originating-tab.test.cjs
+ */
+
+'use strict';
+
+import { test, expect, vi } from 'vitest';
+const { notifyOriginatingTab, isNotifiableTerminalStatus } = require('../scheduler.cjs');
+
+test('isNotifiableTerminalStatus: completed and failed are notifiable', () => {
+  expect(isNotifiableTerminalStatus('completed')).toBe(true);
+  expect(isNotifiableTerminalStatus('failed')).toBe(true);
+});
+
+test('isNotifiableTerminalStatus: needs_review is not notifiable (may still auto-fix)', () => {
+  expect(isNotifiableTerminalStatus('needs_review')).toBe(false);
+});
+
+test('isNotifiableTerminalStatus: a rateLimited exit never reaches an effectiveStatus (undefined) and is not notifiable', () => {
+  // spawnJob's treatAsPending branch (rateLimited || paused for rate_limit)
+  // resets the job to pending and returns before effectiveStatus is ever
+  // computed — so this hook is only ever evaluated with undefined/pending,
+  // never with a real status, on that path.
+  expect(isNotifiableTerminalStatus(undefined)).toBe(false);
+  expect(isNotifiableTerminalStatus('pending')).toBe(false);
+});
+
+test('resolves via sourceTabId when present on the PRD frontmatter', async () => {
+  const sendPrompt = vi.fn();
+  const parsePrdRaw = vi.fn(async () => ({ sourceTabId: 'tab-from-frontmatter' }));
+  const loadSessions = vi.fn(async () => ({ tabs: [] }));
+
+  await notifyOriginatingTab(
+    { slug: '761-notify', status: 'completed', cwd: '/some/cwd' },
+    { parsePrdRaw, loadSessions, sendPrompt },
+  );
+
+  expect(loadSessions).not.toHaveBeenCalled();
+  expect(sendPrompt).toHaveBeenCalledTimes(1);
+  expect(sendPrompt).toHaveBeenCalledWith(
+    'tab-from-frontmatter',
+    expect.stringContaining('761-notify'),
+  );
+});
+
+test('falls back to the first open tab whose cwd matches the job cwd', async () => {
+  const sendPrompt = vi.fn();
+  const parsePrdRaw = vi.fn(async () => ({ sourceTabId: null }));
+  const loadSessions = vi.fn(async () => ({
+    tabs: [
+      { id: 'tab-other', cwd: '/other/cwd' },
+      { id: 'tab-match', cwd: '/some/cwd' },
+      { id: 'tab-second-match', cwd: '/some/cwd' },
+    ],
+  }));
+
+  await notifyOriginatingTab(
+    { slug: '761-notify', status: 'failed', cwd: '/some/cwd' },
+    { parsePrdRaw, loadSessions, sendPrompt },
+  );
+
+  expect(sendPrompt).toHaveBeenCalledTimes(1);
+  expect(sendPrompt).toHaveBeenCalledWith('tab-match', expect.stringContaining('761-notify'));
+});
+
+test('no-ops without throwing when neither sourceTabId nor a cwd-matching tab resolves', async () => {
+  const sendPrompt = vi.fn();
+  const parsePrdRaw = vi.fn(async () => ({ sourceTabId: null }));
+  const loadSessions = vi.fn(async () => ({ tabs: [{ id: 'tab-other', cwd: '/unrelated' }] }));
+
+  await expect(
+    notifyOriginatingTab(
+      { slug: '761-notify', status: 'completed', cwd: '/some/cwd' },
+      { parsePrdRaw, loadSessions, sendPrompt },
+    ),
+  ).resolves.not.toThrow();
+
+  expect(sendPrompt).not.toHaveBeenCalled();
+});
+
+test('no-ops when parsing the PRD frontmatter throws', async () => {
+  const sendPrompt = vi.fn();
+  const parsePrdRaw = vi.fn(async () => { throw new Error('ENOENT'); });
+  const loadSessions = vi.fn(async () => ({ tabs: [] }));
+
+  await expect(
+    notifyOriginatingTab(
+      { slug: '761-notify', status: 'completed', cwd: '/some/cwd' },
+      { parsePrdRaw, loadSessions, sendPrompt },
+    ),
+  ).resolves.not.toThrow();
+
+  expect(sendPrompt).not.toHaveBeenCalled();
+});

package/src/main/chatRunner.cjs

@@ -677,6 +677,48 @@ function cancel(tabId) {
   return Promise.resolve();
 }
 
+// ─── External-caller entry point (PRD 753) ─────────────────────────────────
+// Pushes a prompt into an already-open tab's chat queue from outside the
+// renderer — Web Remote, the admin HTTP route, or the scheduler MCP tool.
+// Fire-and-forget over IPC: the renderer-side listener (chat.ts) resolves
+// the tab's live sessionId/cwd from useSessions and calls useChat.send()
+// directly, reusing send()'s existing queued-vs-immediate branching rather
+// than duplicating it here.
+
+function enqueueExternalPrompt(tabId, prompt) {
+  broadcast('chat:external-send', { tabId, prompt });
+}
+
+/**
+ * Registers the admin-HTTP entry point for enqueueExternalPrompt, mirroring
+ * prdCreate.cjs's registerAdminRoute pattern (auth is the injected transport's
+ * job; this only owns route logic + body parsing).
+ */
+function registerAdminRoute(adminHttp) {
+  const { readBody, sendJson } = require('./lib/localAdminHttp.cjs');
+  const { schemas } = require('./ipcSchemas.cjs');
+
+  adminHttp.registerRoute('POST', '/admin/chat/send-prompt', async (req, res) => {
+    const raw = await readBody(req);
+    let parsed;
+    try {
+      parsed = raw ? JSON.parse(raw) : {};
+    } catch {
+      sendJson(res, 400, { ok: false, error: 'invalid JSON body' });
+      return;
+    }
+    let body;
+    try {
+      body = schemas.chatExternalSend.parse(parsed);
+    } catch (e) {
+      sendJson(res, 400, { ok: false, error: e?.message ?? 'invalid body' });
+      return;
+    }
+    enqueueExternalPrompt(body.tabId, body.prompt);
+    sendJson(res, 200, { ok: true });
+  });
+}
+
 // ─── IPC handler registration ─────────────────────────────────────────────
 
 function registerChatHandlers() {
@@ -718,4 +760,6 @@ module.exports = {
   STOP_SENTINEL,
   CHAT_MODE_TRUTH_INSTRUCTION,
   __setExecutor,
+  enqueueExternalPrompt,
+  registerAdminRoute,
 };

package/src/main/index.cjs

@@ -27,9 +27,11 @@ const voiceWizard = require('./voiceWizard.cjs');
 const scheduler = require('./scheduler.cjs');
 const { createAdminHttp } = require('./lib/localAdminHttp.cjs');
 const prdCreate = require('./lib/prdCreate.cjs');
+const chatRunner = require('./chatRunner.cjs');
 const adminHttp = createAdminHttp();
 scheduler.registerAdminRoutes(adminHttp);
 prdCreate.registerAdminRoute(adminHttp, scheduler.remote);
+chatRunner.registerAdminRoute(adminHttp);
 const { createBrowserAgentServer } = require('./browserAgentServer.cjs');
 const browserAgentServer = createBrowserAgentServer({
   listTabs: () => browserView.listViews(),
@@ -60,7 +62,6 @@ const searchIpc = require('./search.cjs');
 const repoAnalyzer = require('./repoAnalyzer.cjs');
 const hivesIpc = require('./hives.cjs');
 const webRemote = require('./webRemote.cjs');
-const chatRunner = require('./chatRunner.cjs');
 const { listExchanges } = require('./exchanges.cjs');
 const { resolveClaudeBin } = require('./lib/claudeBin.cjs');
 const { checkInsideHome, assertInsideHome } = require('./lib/insideHome.cjs');

package/src/main/ipcSchemas.cjs

@@ -257,6 +257,10 @@ const schedulerCreatePrd = z.object({
   // prompt that spawned it. Same newline-injection guard as title/cwd since
   // it also becomes a frontmatter value.
   sourcePromptId: z.string().min(1).max(128).regex(NO_NEWLINE_RE, 'must not contain newlines').optional(),
+  // Originating tab id (PRD 761) — used at job completion to route a status
+  // prompt back into the chat tab that queued this PRD, via
+  // enqueueExternalPrompt (PRD 753). Same newline-injection guard.
+  sourceTabId: z.string().min(1).max(128).regex(NO_NEWLINE_RE, 'must not contain newlines').optional(),
 });
 
 // Bulk archive: slug list, capped to limit unbounded retag/archive payloads.
@@ -476,6 +480,18 @@ const chatClassifyTicket = z.object({
   ),
 });
 
+// External-caller entry point (admin HTTP route + MCP tool + web-remote
+// command, PRD 753) — pushes a prompt into an already-open tab's chat queue
+// from outside the renderer. tabId only (no sessionId/cwd): those are
+// resolved renderer-side from useSessions, same as the AC requires.
+const chatExternalSend = z.object({
+  tabId: z.string().min(1).max(128),
+  prompt: z.string().min(1).refine(
+    (s) => Buffer.byteLength(s, 'utf8') <= CHAT_PROMPT_MAX_BYTES,
+    `prompt must be ≤ ${CHAT_PROMPT_MAX_BYTES} bytes`,
+  ),
+});
+
 // ──────────────────────────────────────────── Web Remote
 // OTP is 8 uppercase alphanumeric chars (case-insensitive entry, normalised to upper in handler).
 const WEB_REMOTE_OTP_RE = /^[A-Z0-9]{8}$/i;
@@ -683,6 +699,9 @@ const MUTATE_COMMANDS = new Set([
   'cmd:schedule:reset-job',
   'cmd:schedule:run-now',
   'cmd:schedule:set-config',
+  // Pushes a prompt into an open tab's chat queue — a real mutation of that
+  // tab's session, same tier as pty:write.
+  'cmd:chat:send',
 ]);
 
 const ALLOWED_COMMANDS = new Set([...READ_COMMANDS, ...SAS_GATED_READS, ...MUTATE_COMMANDS]);
@@ -774,6 +793,7 @@ module.exports = {
     chatCancel,
     chatProbeContext,
     chatClassifyTicket,
+    chatExternalSend,
     exchangesList,
   },
   validated,

package/src/main/lib/prdCreate.cjs

@@ -48,7 +48,7 @@ function deriveSlugFromTitle(title) {
 function buildPrdBody(input) {
   const {
     title, cwd, estimateMinutes, goal, acceptanceCriteria,
-    implementationNotes, outOfScope, sourcePromptId,
+    implementationNotes, outOfScope, sourcePromptId, sourceTabId,
   } = input;
 
   // No `parallelGroup` frontmatter key by convention (SKILL.md) — the NN-
@@ -58,6 +58,9 @@ function buildPrdBody(input) {
   // Optional, additive: traces this PRD back to the PromptTicket (PRD 748)
   // that was classified 'develop' and spawned it (PRD 749).
   if (sourcePromptId) fmLines.push(`sourcePromptId: ${sourcePromptId}`);
+  // Optional, additive: the tab that queued this PRD, read back by
+  // scheduler.cjs at job completion (PRD 761) to route a status prompt.
+  if (sourceTabId) fmLines.push(`sourceTabId: ${sourceTabId}`);
   fmLines.push('---', '');
 
   const acLines = acceptanceCriteria.map((line) => `- [ ] ${line}`).join('\n');

package/src/main/scheduler/prdParser.cjs

@@ -68,6 +68,11 @@ async function parsePrdRaw(filePath) {
     // classified 'develop' and spawned this PRD (PRD 749). Additive — absent
     // on every PRD authored before this field existed.
     sourcePromptId: fm.sourcePromptId || null,
+    // 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
+    // authored before this field existed.
+    sourceTabId: fm.sourceTabId || null,
     body: body.trim(),
   };
 }

package/src/main/scheduler.cjs

@@ -60,6 +60,8 @@ const { openLog, withChildAndLog } = require('./lib/childWithLog.cjs');
 const { sendIfAlive } = require('./lib/sendToRenderer.cjs');
 const { createBroadcastCoalescer } = require('./lib/broadcastCoalescer.cjs');
 const prdParser = require('./scheduler/prdParser.cjs');
+const sessionsStore = require('./sessionsStore.cjs');
+const { enqueueExternalPrompt } = require('./chatRunner.cjs');
 const { verifyRun } = require('./runVerify.cjs');
 const logs = require('./logs.cjs');
 const { schemas, validated } = require('./ipcSchemas.cjs');
@@ -1185,6 +1187,62 @@ function applyOrphanOutcome(job, outcome, killNote = '') {
   }
 }
 
+/**
+ * isNotifiableTerminalStatus(effectiveStatus) → boolean
+ *
+ * Gates notifyOriginatingTab to true terminal transitions only: 'completed'
+ * and 'failed'. Excludes 'needs_review' (not yet truly done — may still
+ * auto-fix) and, implicitly, the rateLimited/paused-queue path, which never
+ * reaches effectiveStatus computation at all (it takes the treatAsPending
+ * branch in spawnJob and resets the job to pending instead).
+ */
+function isNotifiableTerminalStatus(effectiveStatus) {
+  return effectiveStatus === 'completed' || effectiveStatus === 'failed';
+}
+
+/**
+ * notifyOriginatingTab(job) → void
+ *
+ * On a true terminal transition (completed/failed — never the benign
+ * rateLimited auto-pause, which resets the job to pending instead), push a
+ * short status prompt into the chat tab that queued this PRD via
+ * enqueueExternalPrompt (PRD 753). Resolution order: (1) the PRD's own
+ * `sourceTabId` frontmatter, captured at creation time; (2) the first open
+ * tab (per sessionsStore's persisted tabs.json) whose cwd matches the job's
+ * cwd — first match only, no fan-out to multiple matching tabs; (3) no-op.
+ * Never throws to the caller (fire-and-forget from spawnJob). Deps are
+ * injectable (mirrors partitionBootOrphans's isAlive param) so unit tests can
+ * exercise the resolution logic without touching disk/electron.
+ */
+async function notifyOriginatingTab(job, {
+  parsePrdRaw = prdParser.parsePrdRaw,
+  loadSessions = sessionsStore.load,
+  sendPrompt = enqueueExternalPrompt,
+} = {}) {
+  try {
+    const prdPath = path.join(PRDS_DIR, `${job.slug}.md`);
+    const prd = await parsePrdRaw(prdPath).catch(() => null);
+
+    let targetTabId = prd?.sourceTabId || null;
+    if (!targetTabId) {
+      const jobCwd = job.cwd || null;
+      if (jobCwd) {
+        const { tabs } = await loadSessions();
+        const match = (tabs || []).find((t) => t && t.cwd === jobCwd);
+        targetTabId = match?.id || null;
+      }
+    }
+    if (!targetTabId) {
+      console.log(`[scheduler] notifyOriginatingTab: no target tab for ${job.slug}, skipping`);
+      return;
+    }
+
+    sendPrompt(targetTabId, `PRD ${job.slug} finished: ${job.status}. Check Scheduler for details.`);
+  } catch (e) {
+    console.error('[scheduler] notifyOriginatingTab error', job?.slug, e);
+  }
+}
+
 /** Scan the tail of a job's log for the canonical rate-limit signal. We look
  *  at the last 16 KB — final result event always lands at the end.
  *  Uses readTail() so no raw fd lifecycle is needed here. */
@@ -1941,6 +1999,7 @@ async function spawnJob(job, runId, runDir, defaultCwd) {
     let needsInvestigationNow = false;
     let investigationJobSnapshot = null;
     let needsReviewRcaSnapshot = null;
+    let terminalNotifySnapshot = null;
     await mutate((s) => {
       const i2 = s.jobs.findIndex((x) => x.slug === job.slug);
       if (i2 >= 0) {
@@ -1994,6 +2053,9 @@ async function spawnJob(job, runId, runDir, defaultCwd) {
           }
           delete s.jobs[i2].runtime;
 
+          if (isNotifiableTerminalStatus(effectiveStatus)) {
+            terminalNotifySnapshot = { ...s.jobs[i2] };
+          }
           if (effectiveStatus === 'failed') {
             actuallyFailed = true;
             failedJobSnapshot = { ...s.jobs[i2] };
@@ -2052,6 +2114,12 @@ async function spawnJob(job, runId, runDir, defaultCwd) {
     });
     await broadcast({ flush: true });
 
+    if (terminalNotifySnapshot) {
+      notifyOriginatingTab(terminalNotifySnapshot).catch((e) => {
+        console.error('[scheduler] notifyOriginatingTab error', job.slug, e);
+      });
+    }
+
     if (needsReviewRcaSnapshot) {
       // Fire-and-forget, mirroring the DoD drain hook: never blocks the status
       // transition, never throws to this caller.
@@ -3386,4 +3454,4 @@ function registerAdminRoutes(adminHttp, remoteObj = remote) {
   });
 }
 
-module.exports = { registerScheduleHandlers, attachWindow, init, ROOT, PRDS_DIR, allocateParallelGroup, selectHistoryJobs, parsePorcelain, FINISH_PROTOCOL, remote, pickNextBatch, pickForProject, reapDeadRunningJobs, pollRecoveryClearSource, memoryLimitedBatchSize, availableForJobs, reverifyNeedsReview, isRescanCandidate, isPromotableOriginal, selectAutoFixTargets, isEligibleForImmediateAutoFix, resolveRunId, isUnresolvableNeedsReview, healTargetForFix, buildInvestigationPrompt, committedInWindow, computeCommittedDuringRun, isFixPlanSlug, isFixPlanBeyondDepthCap, MAX_INVESTIGATION_DEPTH, forceTickOutcome, applyPauseCleared, detectNetworkErrorInLog, detectRateLimitInLog, classifyFailureOutcome, TRANSIENT_RETRY_CAP, buildScheduleStatePayload, partitionBootOrphans, applyOrphanOutcome, BOOT_ORPHAN_KILL_GRACE_MS, feedbackSweepDue, FEEDBACK_SWEEP_TICK_INTERVAL, sweepFeedback, registerAdminRoutes };
+module.exports = { registerScheduleHandlers, attachWindow, init, ROOT, PRDS_DIR, allocateParallelGroup, selectHistoryJobs, parsePorcelain, FINISH_PROTOCOL, remote, pickNextBatch, pickForProject, reapDeadRunningJobs, pollRecoveryClearSource, memoryLimitedBatchSize, availableForJobs, reverifyNeedsReview, isRescanCandidate, isPromotableOriginal, selectAutoFixTargets, isEligibleForImmediateAutoFix, resolveRunId, isUnresolvableNeedsReview, healTargetForFix, buildInvestigationPrompt, committedInWindow, computeCommittedDuringRun, isFixPlanSlug, isFixPlanBeyondDepthCap, MAX_INVESTIGATION_DEPTH, forceTickOutcome, applyPauseCleared, detectNetworkErrorInLog, detectRateLimitInLog, classifyFailureOutcome, TRANSIENT_RETRY_CAP, buildScheduleStatePayload, partitionBootOrphans, applyOrphanOutcome, BOOT_ORPHAN_KILL_GRACE_MS, feedbackSweepDue, FEEDBACK_SWEEP_TICK_INTERVAL, sweepFeedback, registerAdminRoutes, notifyOriginatingTab, isNotifiableTerminalStatus };

package/src/main/webRemote.cjs

@@ -1056,6 +1056,7 @@ function getDispatchMap() {
   const sessionsStore = require('./sessionsStore.cjs');
   const scheduler = require('./scheduler.cjs');
   const { remote: histRemote } = require('./historyAggregator.cjs');
+  const chatRunner = require('./chatRunner.cjs');
 
   _dispatchMap = {
     'cmd:sessions:load': async () =>
@@ -1146,6 +1147,15 @@ function getDispatchMap() {
       stopSessionWatch(parsed.tabId);
       return { ok: true };
     },
+
+    // Push a prompt into an open tab's chat queue from the paired phone
+    // client — in-process call, no admin HTTP hop needed since webRemote
+    // already runs inside the Electron main process (PRD 753).
+    'cmd:chat:send': async (payload) => {
+      const parsed = schemas.chatExternalSend.parse(payload);
+      chatRunner.enqueueExternalPrompt(parsed.tabId, parsed.prompt);
+      return { ok: true };
+    },
   };
 
   return _dispatchMap;

package/src/preload/api.d.ts

@@ -1102,6 +1102,13 @@ export interface ChatRunNoticeEvent {
   message: string;
 }
 
+/** Pushed by enqueueExternalPrompt (PRD 753) — Web Remote, the admin HTTP
+ *  route, or an MCP caller asking to enqueue a prompt into an open tab. */
+export interface ChatExternalSendEvent {
+  tabId: string;
+  prompt: string;
+}
+
 export interface SessionManagerAPI {
   app: {
     version: () => Promise<string>;
@@ -1475,6 +1482,10 @@ export interface SessionManagerAPI {
     onComplete: (handler: (e: ChatRunCompleteEvent) => void) => () => void;
     onError: (handler: (e: ChatRunErrorEvent) => void) => () => void;
     onNotice: (handler: (e: ChatRunNoticeEvent) => void) => () => void;
+    /** Fires when a main-process caller (Web Remote, admin HTTP route, MCP
+     *  tool) pushes a prompt into an open tab's queue from outside the
+     *  renderer (PRD 753). */
+    onExternalSend: (handler: (e: ChatExternalSendEvent) => void) => () => void;
     /** Classify a queued PromptTicket's text as 'inline' (run through
      *  chatRunner) or 'develop' (dispatch to /develop for PRD decomposition).
      *  A single bounded `claude -p` call, never a scheduler job. */

package/src/preload/index.cjs

@@ -436,6 +436,13 @@ contextBridge.exposeInMainWorld('api', {
       ipcRenderer.on('chat:run:notice', listener);
       return () => ipcRenderer.removeListener('chat:run:notice', listener);
     },
+    /** Fires when a main-process caller pushes a prompt into an open tab's
+     *  queue from outside the renderer (Web Remote / admin HTTP / MCP). */
+    onExternalSend: (handler) => {
+      const listener = (_e, payload) => handler(payload);
+      ipcRenderer.on('chat:external-send', listener);
+      return () => ipcRenderer.removeListener('chat:external-send', listener);
+    },
     /** Classify a queued PromptTicket's text as 'inline' or 'develop'. */
     classifyTicket: (payload) => ipcRenderer.invoke('chat:classify-ticket', payload),
   },