claude-code-session-manager 0.120.0 → 0.121.0

package/src/main/webRemote.cjs

@@ -29,7 +29,6 @@ const logs = require('./logs.cjs');
 const { sendIfAlive } = require('./lib/sendToRenderer.cjs');
 const { claudeHome } = require('./lib/scheduler/schedulerPaths.cjs');
 const { schemas } = require('./ipcSchemas.cjs');
-const { summarize: _sharedSummarize } = require('./lib/summarize.cjs');
 const { makeState, confirmSas: confirmSasLogic } = require('./lib/e2eStateMachine.cjs');
 const { createClientSessions, LEGACY_CLIENT_KEY } = require('./lib/feedback-remote/remoteClientSessions.cjs');
 
@@ -497,12 +496,11 @@ async function handleTokenRevoked(deviceId) {
   sendIfAlive(_window, 'webRemote:token-revoked', { deviceId });
 }
 
-// ─── v2 mobile: session live state + summary push ────────────────────────────
+// ─── v2 mobile: session live state push ────────────────────────────
 //
 // For each subscribed tab the agent tails its transcript JSONL (reusing the
 // canonical classifyLine + transcriptPath from transcripts.cjs — single source of
 // truth), derives a coarse state, and pushes event:session:state on change.
-// The last completed assistant turn drives the Haiku summary (see maybeSummarize).
 
 const SESSION_POLL_MS = 1500;
 const SESSION_INIT_TAIL_BYTES = 512 * 1024; // bound the initial read
@@ -524,7 +522,7 @@ function pushEventTo(client, type, payload) {
   }
 }
 
-/** Authenticated clients subscribed to a tab's session state/summary. */
+/** Authenticated clients subscribed to a tab's session state. */
 function subscribersOf(tabId) {
   return _clients.authenticated().filter((c) => c.subscriptions.has(tabId));
 }
@@ -551,15 +549,6 @@ function teardownAllClients() {
   return n;
 }
 
-/** Extract concatenated text from an assistant transcript line, or '' if none. */
-function extractAssistantText(raw) {
-  const msg = raw?.message || raw;
-  const content = msg?.content;
-  if (typeof content === 'string') return content;
-  if (!Array.isArray(content)) return '';
-  return content.filter((b) => b?.type === 'text' && typeof b.text === 'string').map((b) => b.text).join('\n').trim();
-}
-
 /** Map a classified transcript event to a coarse session state. */
 function deriveState(ev, raw) {
   // API/usage errors surface as a flagged message line.
@@ -613,6 +602,19 @@ async function tailLines(filePath, fromOffset) {
 }
 
 async function pollSessionWatcher(w) {
+  // The transcript may not exist yet (new session) or may live under another
+  // project/worktree encoding: re-resolve while the watched file is missing.
+  if (!fs.existsSync(w.filePath)) {
+    try {
+      const next = require('./transcripts.cjs').transcriptPath(w.cwd, w.sessionId);
+      if (next && next !== w.filePath) {
+        validatePath(next);
+        w.filePath = next;
+        w.offset = null;
+        w.inode = undefined;
+      }
+    } catch { /* keep the old path */ }
+  }
   let res;
   try {
     res = await tailLines(w.filePath, w.offset);
@@ -627,8 +629,6 @@ async function pollSessionWatcher(w) {
   w.inode = res.inode;
 
   let nextState = null;
-  let newAssistantText = null;
-  let newMsgId = null;
   for (const line of res.lines) {
     let obj;
     try { obj = JSON.parse(line); } catch { continue; }
@@ -636,10 +636,6 @@ async function pollSessionWatcher(w) {
     for (const ev of events) {
       const s = deriveState(ev, obj);
       if (s) nextState = s;
-      if (ev.kind === 'assistant') {
-        const text = extractAssistantText(obj);
-        if (text) { newAssistantText = text; newMsgId = obj.uuid || obj.message?.id || `${w.tabId}:${res.size}`; }
-      }
     }
   }
 
@@ -650,33 +646,20 @@ async function pollSessionWatcher(w) {
       pushEventTo(c, 'event:session:state', { tabId: w.tabId, state: w.state, since: Date.now() });
     }
   }
-  if (newAssistantText && newMsgId !== w.lastMsgId) {
-    w.lastAssistantText = newAssistantText;
-    w.lastMsgId = newMsgId;
-  }
-  // Summarize only a COMPLETED turn (state idle) — not assistant text mid-turn that
-  // is followed by a tool call. Cache by msgId so re-subscribe doesn't re-bill.
-  if (w.state === 'idle' && w.lastAssistantText && w.lastMsgId !== w.summarizedMsgId) {
-    w.summarizedMsgId = w.lastMsgId;
-    maybeSummarize(w).catch(() => {});
-  }
 }
 
-function startSessionWatch(tabId, cwd) {
+function startSessionWatch(tabId, cwd, sessionId = tabId) {
   if (_sessionWatchers.has(tabId)) return;
-  const filePath = require('./transcripts.cjs').transcriptPath(cwd, tabId);
+  const filePath = require('./transcripts.cjs').transcriptPath(cwd, sessionId);
   // Defense in depth: the schema restricts tabId charset, but re-validate the
   // FINAL joined path against the home-dir boundary (validatePath resolves
   // symlinks + rejects escapes) before any fs read. Throws → dispatch drops it.
   validatePath(filePath);
   const w = {
-    tabId, cwd, filePath,
+    tabId, cwd, sessionId, filePath,
     offset: null,       // null → first poll reads a bounded tail then tracks EOF
     inode: undefined,
     state: 'idle',
-    lastAssistantText: null,
-    lastMsgId: null,
-    summarizedMsgId: null,
     timer: null,
   };
   _sessionWatchers.set(tabId, w);
@@ -732,44 +715,6 @@ function buildRemoteSessionList(tabs, readIndex) {
   return out;
 }
 
-// ─── SM-V2-03: mobile summary via Claude Haiku 4.5 ───────────────────────────
-// Summarization logic lives in lib/summarize.cjs (shared with exchanges.cjs).
-
-const SUMMARY_MIN_CHARS = 280; // below this, push raw — not worth an API call
-
-/**
- * Produce a mobile summary of the watcher's last completed assistant turn and push it.
- * Short turns are pushed raw (no API call). If no API key is configured, degrades to
- * the raw message so core remote control is never blocked. Cost: Haiku in+out per
- * completed turn per subscribed tab (~$1/$5 per 1M tokens).
- */
-async function maybeSummarize(w) {
-  // Guard: summaries (session transcript content) go only to SAS-confirmed subscribers.
-  if (subscribersOf(w.tabId).length === 0) return;
-  const text = w.lastAssistantText;
-  if (!text) return;
-  const ofMessageId = w.lastMsgId;
-
-  if (text.length < SUMMARY_MIN_CHARS) {
-    for (const c of subscribersOf(w.tabId)) {
-      pushEventTo(c, 'event:session:summary', { tabId: w.tabId, summary: text, ofMessageId, model: 'raw', ts: Date.now() });
-    }
-    return;
-  }
-
-  const { summary, model, degraded } = await _sharedSummarize(text);
-  if (degraded) {
-    logs.writeLine({ scope: 'webRemote', level: 'warn', message: `summary degraded: ${degraded}`, meta: {} });
-  }
-  for (const c of subscribersOf(w.tabId)) {
-    pushEventTo(c, 'event:session:summary', {
-      tabId: w.tabId, summary, ofMessageId, model,
-      ...(degraded ? { degraded } : {}),
-      ts: Date.now(),
-    });
-  }
-}
-
 /**
  * Shared finish-up for any path that transitions a client's e2e state into 'authenticated'
  * (manual SAS confirmation or pinned-key auto-trust): log, broadcast the new
@@ -1010,7 +955,7 @@ async function dispatchEnvelope(envelope, device, client) {
   let result;
   try {
     result = await dispatchCommand(type, payload ?? {}, client);
-    await auditLog(ts, type, device.deviceId, id, 'ok', client);
+    await auditLog(ts, type, device.deviceId, id, auditResultFor(result), client);
   } catch (e) {
     const code = e?.name === 'ZodError' ? 'schema_invalid' : 'dispatch_error';
     await auditLog(ts, type, device.deviceId, id, `error:${code}`, client);
@@ -1020,6 +965,14 @@ async function dispatchEnvelope(envelope, device, client) {
   respond(id, result, undefined, client);
 }
 
+/** Audit result string for a handler result: structured refusals log as refused[:reason]. */
+function auditResultFor(result) {
+  if (result && result.ok === false && typeof result.disposition === 'string') {
+    return typeof result.reason === 'string' && result.reason ? `refused:${result.reason}` : 'refused';
+  }
+  return 'ok';
+}
+
 function respond(msgId, payload, typeOverride, client) {
   if (!_ws || _ws.readyState !== WebSocket.OPEN) return;
   const responseType = typeOverride || (msgId ? `resp:${msgId}` : undefined);
@@ -1102,26 +1055,34 @@ function getDispatchMap() {
       const parsed = schemas.remoteSessionTranscript.parse(payload);
       const { readActiveIndex } = require('./lib/epic/epicMint.cjs');
       const { resolveEpicTranscriptPath } = require('./lib/epic/epicTranscriptPath.cjs');
-      const { readRecentChatMessages } = require('./lib/remoteTranscriptTail.cjs');
+      const { readRecentChatMessages, buildRemoteConversation } = require('./lib/remoteTranscriptTail.cjs');
+      const { listExchanges } = require('./exchanges.cjs');
       const data = await sessionsStore.load();
       const tab = (data?.tabs ?? []).find((t) => t && t.cwd === parsed.cwd);
       if (!tab) throw new Error('cwd is not an open project');
       validatePath(parsed.cwd);
+      const limit = parsed.limit ?? 10;
+      const before = parsed.before ?? 0;
       let filePath = null;
-      if (parsed.sessionKey === (tab.id ?? tab.sessionId)) {
-        filePath = require('./transcripts.cjs').transcriptPath(parsed.cwd, parsed.sessionKey);
+      let sessionId = null;
+      if (parsed.sessionKey === tab.id || parsed.sessionKey === tab.sessionId) {
+        sessionId = tab.sessionId || parsed.sessionKey;
+        filePath = require('./transcripts.cjs').transcriptPath(parsed.cwd, sessionId);
       } else {
         const sessions = readActiveIndex(parsed.cwd)?.sessions ?? {};
         const epic = Object.values(sessions).find(
           (e) => e && (e.id === parsed.sessionKey || e.claudeSessionId === parsed.sessionKey),
         );
         if (epic && epic.claudeSessionId) {
-          filePath = resolveEpicTranscriptPath({ cwd: parsed.cwd, claudeSessionId: epic.claudeSessionId }).path;
+          sessionId = epic.claudeSessionId;
+          filePath = resolveEpicTranscriptPath({ cwd: parsed.cwd, claudeSessionId: sessionId }).path;
         }
       }
-      if (!filePath) return { messages: [] };
+      if (!filePath || !sessionId) return { messages: [], hasMore: false, nextBefore: null };
       validatePath(filePath);
-      return { messages: await readRecentChatMessages(filePath, { limit: parsed.limit }) };
+      const exchanges = await listExchanges({ cwd: parsed.cwd, sessionId, limit: limit + 1, offset: before });
+      const tail = before === 0 ? await readRecentChatMessages(filePath, { limit: 30 }) : [];
+      return buildRemoteConversation({ exchanges, tail, limit, before });
     },
 
     'cmd:session:prds': async (payload) => {
@@ -1209,12 +1170,15 @@ function getDispatchMap() {
     'cmd:app:info': async () =>
       ({ version: app.getVersion(), platform: process.platform }),
 
-    // v2 mobile: start/stop pushing live state + summary for a session.
+    // v2 mobile: start/stop pushing live state for a session.
     'cmd:session:subscribe': async (payload, reqClient) => {
       const client = reqClient || _clients.getOrCreate(LEGACY_CLIENT_KEY);
       const parsed = schemas.sessionSubscribe.parse(payload);
       validatePath(parsed.cwd); // home-dir boundary before any fs access
-      startSessionWatch(parsed.tabId, parsed.cwd);
+      // The phone's Main row passes the tab `id`, but the transcript is keyed by the tab's `sessionId`.
+      const { tabs } = await require('./sessionsStore.cjs').load();
+      const tab = (Array.isArray(tabs) ? tabs : []).find((t) => t && t.id === parsed.tabId && t.cwd === parsed.cwd);
+      startSessionWatch(parsed.tabId, parsed.cwd, tab?.sessionId || parsed.tabId);
       client.subscriptions.add(parsed.tabId);
       return { ok: true };
     },
@@ -1236,23 +1200,28 @@ function getDispatchMap() {
       const data = await sessionsStore.load();
       const tabs = data?.tabs ?? [];
       // Resolve the target in main: an open tab, or an ACTIVE Epic (by id or
-      // claudeSessionId) of an open project. Anything else fails loudly.
+      // claudeSessionId) of an open project. Anything else is a structured refusal.
+      const outcome = (r) => ({
+        ok: r.disposition !== 'refused',
+        disposition: r.disposition,
+        ...(r.reason ? { reason: r.reason } : {}),
+      });
       if (tabs.some((t) => t.sessionId === parsed.tabId || t.id === parsed.tabId)) {
-        chatRunner.enqueueExternalPrompt(parsed.tabId, parsed.prompt);
-        return { ok: true };
+        return outcome(await chatRunner.enqueueExternalPrompt(parsed.tabId, parsed.prompt));
       }
       for (const tab of tabs) {
         const sessions = Object.values(readActiveIndex(tab.cwd)?.sessions ?? {});
         const epic = sessions.find((e) => e && (e.id === parsed.tabId || e.claudeSessionId === parsed.tabId));
         if (!epic) continue;
-        if (epic.status !== 'active' || !epic.claudeSessionId) throw new Error('target is not an active session');
-        chatRunner.enqueueExternalPrompt(epic.id, parsed.prompt, {
+        if (epic.status !== 'active' || !epic.claudeSessionId) {
+          return { ok: false, disposition: 'refused', reason: epic.status === 'proposed' ? 'proposed' : 'not-active' };
+        }
+        return outcome(await chatRunner.enqueueExternalPrompt(epic.id, parsed.prompt, {
           sessionId: epic.claudeSessionId,
           cwd: epic.cwd || tab.cwd,
-        });
-        return { ok: true };
+        }));
       }
-      throw new Error('unknown chat target');
+      return { ok: false, disposition: 'refused', reason: 'unknown-target' };
     },
 
     'cmd:session:options': async () => {
@@ -1266,6 +1235,7 @@ function getDispatchMap() {
         agents: personas.map((a) => ({ name: a.name, description: a.description })),
         tags: EpicTagSchema.options,
         macros: await macroLibrary.listMacros(),
+        macroInputs: true,
       };
     },
 
@@ -1278,7 +1248,23 @@ function getDispatchMap() {
       if (!tabs.some((t) => t.cwd === parsed.cwd)) throw new Error('cwd is not an open project');
       const personas = await agentLibrary.listPersonas();
       if (!personas.some((a) => a.name === parsed.agentName)) throw new Error('unknown agent');
-      chatRunner.requestExternalNewSession(parsed);
+      let prompt = parsed.prompt;
+      if (parsed.macroId) {
+        const macroLibrary = require('./lib/persona-macro/macroLibrary.cjs');
+        const macros = await macroLibrary.listMacros();
+        const macro = macros.find((m) => m.id === parsed.macroId);
+        if (!macro || !macroLibrary.macroVisibleIn(macro, parsed.cwd)) throw new Error('unknown macro');
+        const result = macroLibrary.renderMacroPrompt(parsed.prompt, macro.inputs, parsed.inputs ?? {});
+        if (!result.ok) throw new Error(result.error);
+        prompt = result.prompt;
+      }
+      chatRunner.requestExternalNewSession({
+        cwd: parsed.cwd,
+        agentName: parsed.agentName,
+        tag: parsed.tag,
+        title: parsed.title,
+        prompt,
+      });
       return { ok: true };
     },
   };
@@ -1551,6 +1537,11 @@ module.exports = {
   },
   __test: {
     getDispatchMap,
+    auditResultFor,
+    startSessionWatch,
+    pollSessionWatcher,
+    getSessionWatcher: (tabId) => _sessionWatchers.get(tabId),
+    stopAllSessionWatches,
     buildRemoteSessionList,
     setWs: (ws) => { _ws = ws; },
     connect,

package/src/preload/api.d.ts

@@ -1646,6 +1646,17 @@ export interface ChatExternalSendEvent {
   /** Epic's claudeSessionId + project cwd, resolved by main so the renderer can deliver before the Epic's project is loaded. */
   sessionId?: string;
   cwd?: string;
+  /** Set by main's enqueueExternalPrompt on every push; the renderer must echo it back via `reportExternalSendResult`. */
+  requestId?: string;
+}
+
+export type ChatExternalSendDisposition = 'sent' | 'queued' | 'refused';
+export type ChatExternalSendRefusalReason = 'terminal-attached' | 'completed' | 'unknown-target' | 'empty-prompt';
+/** What the renderer did with a `ChatExternalSendEvent`, reported back to main. */
+export interface ChatExternalSendResult {
+  requestId: string;
+  disposition: ChatExternalSendDisposition;
+  reason?: ChatExternalSendRefusalReason;
 }
 
 export type CreateProjectFolderResult =
@@ -2297,6 +2308,8 @@ export interface SessionManagerAPI {
      *  tool) pushes a prompt into an open tab's queue from outside the
      *  renderer (PRD 753). */
     onExternalSend: (handler: (e: ChatExternalSendEvent) => void) => () => void;
+    /** Reports what the renderer did with an external send (echoing its requestId) back to main. */
+    reportExternalSendResult: (result: ChatExternalSendResult) => Promise<void>;
     /** Fires when a paired phone asks main to start a new Session (payload pre-validated in main). */
     onExternalNewSession: (
       handler: (e: { cwd: string; agentName: string; tag: AgentPersonaTag; title: string; prompt: string }) => void,

package/src/preload/index.cjs

@@ -536,6 +536,8 @@ contextBridge.exposeInMainWorld('api', {
       ipcRenderer.on('chat:external-send', listener);
       return () => ipcRenderer.removeListener('chat:external-send', listener);
     },
+    /** Reports the renderer's disposition for an external send back to main. */
+    reportExternalSendResult: (result) => ipcRenderer.invoke('chat:external-send-result', result),
     /** Fires when a paired phone asks main to start a new Session. */
     onExternalNewSession: (handler) => {
       const listener = (_e, payload) => handler(payload);