claude-code-session-manager 0.41.0 → 0.41.1

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-H7rwsoKV.js"></script>
+    <script type="module" crossorigin src="./assets/index-CV9TNjxX.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-CKY3mHgV.css">

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "claude-code-session-manager",
-  "version": "0.41.0",
+  "version": "0.41.1",
   "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__/opsErrorLog.test.cjs

@@ -0,0 +1,87 @@
+/**
+ * opsErrorLog.test.cjs — appendError() is the sole writer of the `logs` ops
+ * namespace (single-writer law, opsOwnership.cjs). Verifies: writes a tagged
+ * JSONL line to <cwd>/session-manager-operations/logs/errors-<date>.jsonl,
+ * redacts sensitive meta keys, and no-ops (never throws) with no cwd.
+ *
+ * Run: timeout 120 npx vitest run src/main/__tests__/opsErrorLog.test.cjs
+ */
+
+'use strict';
+
+import { test } from 'vitest';
+import assert from 'node:assert/strict';
+const fs = require('node:fs');
+const os = require('node:os');
+const path = require('node:path');
+
+const opsErrorLog = require('../lib/opsErrorLog.cjs');
+
+function mkTmpProject() {
+  return fs.mkdtempSync(path.join(os.tmpdir(), 'sm-opslog-test-'));
+}
+
+function readLines(cwd) {
+  const dir = opsErrorLog.logsDir(cwd);
+  const file = opsErrorLog.todayFile(cwd);
+  if (!fs.existsSync(file)) return [];
+  return fs.readFileSync(file, 'utf8').trim().split('\n').filter(Boolean).map((l) => JSON.parse(l));
+}
+
+test('appendError writes a tagged JSONL line', () => {
+  const cwd = mkTmpProject();
+  opsErrorLog.appendError({
+    cwd,
+    scope: 'pty',
+    tabId: 'tab-123',
+    tags: ['spawn-failed'],
+    message: 'pty.spawn threw: boom',
+  });
+  const lines = readLines(cwd);
+  assert.equal(lines.length, 1);
+  const [line] = lines;
+  assert.equal(line.level, 'error');
+  assert.equal(line.scope, 'pty');
+  assert.equal(line.tabId, 'tab-123');
+  assert.equal(line.message, 'pty.spawn threw: boom');
+  assert.ok(line.tags.includes('level:error'));
+  assert.ok(line.tags.includes('scope:pty'));
+  assert.ok(line.tags.includes('tab:tab-123'));
+  assert.ok(line.tags.includes('spawn-failed'));
+  assert.ok(typeof line.ts === 'string' && !Number.isNaN(Date.parse(line.ts)));
+});
+
+test('appendError redacts sensitive meta keys', () => {
+  const cwd = mkTmpProject();
+  opsErrorLog.appendError({
+    cwd,
+    scope: 'chatRunner',
+    message: 'run failed',
+    meta: { token: 'sk-secret', sessionId: 'abc', password: 'hunter2' },
+  });
+  const [line] = readLines(cwd);
+  assert.equal(line.meta.token, '[redacted]');
+  assert.equal(line.meta.password, '[redacted]');
+  assert.equal(line.meta.sessionId, 'abc');
+});
+
+test('appendError is a no-op with no cwd', () => {
+  // Must not throw, and there is nowhere to assert a file was NOT written
+  // since no cwd means no path — this just proves it never throws.
+  assert.doesNotThrow(() => opsErrorLog.appendError({ scope: 'x', message: 'y' }));
+});
+
+test('appendError merges caller tags without duplicating auto-derived ones', () => {
+  const cwd = mkTmpProject();
+  opsErrorLog.appendError({
+    cwd,
+    scope: 'chatRunner',
+    tabId: 'tab-9',
+    tags: ['level:error', 'silent-probe'], // deliberately duplicates an auto tag
+    message: 'probe failed',
+  });
+  const [line] = readLines(cwd);
+  const count = line.tags.filter((t) => t === 'level:error').length;
+  assert.equal(count, 1);
+  assert.ok(line.tags.includes('silent-probe'));
+});

package/src/main/__tests__/prdCreate.test.cjs

@@ -23,6 +23,7 @@ const {
   PRD_CREATE_SLUG_RE,
   registerAdminRoute,
   createPrd,
+  resolveSourcePromptIdFromClaudeSession,
 } = require('../lib/prdCreate.cjs');
 const { createAdminHttp } = require('../lib/localAdminHttp.cjs');
 const config = require('../config.cjs');
@@ -505,3 +506,72 @@ test('POST /admin/scheduler/create-prd with sourcePromptId writes it into the cr
     await admin.stop();
   }
 });
+
+// ──────────────────────────────────────────── originClaudeSessionId fallback
+// (2026-08-01 fix: a PRD queued via the scheduler_create_prd MCP tool from
+// inside an Epic's own chat session, without an explicit sourcePromptId,
+// must still join that Epic rather than mint an unrelated sibling one.)
+
+async function writeActiveIndexFixture(cwd, sessions) {
+  const dir = path.join(cwd, 'session-manager-operations', 'prompt-sessions');
+  await fsp.mkdir(dir, { recursive: true });
+  await fsp.writeFile(path.join(dir, 'active-index.json'), JSON.stringify({ sessions, events: {} }, null, 2));
+}
+
+test('resolveSourcePromptIdFromClaudeSession finds the Epic whose claudeSessionId matches', async () => {
+  const root = await fsp.mkdtemp(path.join(os.tmpdir(), 'sm-resolve-epic-'));
+  try {
+    await writeActiveIndexFixture(root, {
+      'psess-abc123': { id: 'psess-abc123', claudeSessionId: 'claude-sess-1', status: 'active' },
+    });
+    expect(resolveSourcePromptIdFromClaudeSession(root, 'claude-sess-1')).toBe('psess-abc123');
+    expect(resolveSourcePromptIdFromClaudeSession(root, 'claude-sess-unknown')).toBeNull();
+    expect(resolveSourcePromptIdFromClaudeSession(root, null)).toBeNull();
+  } finally {
+    await fsp.rm(root, { recursive: true, force: true });
+  }
+});
+
+test('createPrd resolves sourcePromptId from originClaudeSessionId when the caller omitted sourcePromptId', async () => {
+  const root = await fsp.mkdtemp(path.join(os.homedir(), '.sm-origin-session-epic-'));
+  config.addAllowedRoot(root);
+  try {
+    await writeActiveIndexFixture(root, {
+      'psess-always-select-tab': { id: 'psess-always-select-tab', claudeSessionId: 'claude-sess-epic-1', status: 'active' },
+    });
+    const prdsDir = path.join(root, 'session-manager-operations', 'scheduler', 'epics', 'psess-always-select-tab', 'prds');
+    const remote = makeFakeRemoteWithPrdsDir(prdsDir);
+
+    const result = await createPrd(
+      validCreateBody({ cwd: root, slug: 'joins-the-epic', originClaudeSessionId: 'claude-sess-epic-1' }),
+      remote,
+    );
+
+    expect(result.ok).toBe(true);
+    const written = await fsp.readFile(path.join(prdsDir, result.filename), 'utf8');
+    expect(written).toMatch(/sourcePromptId: psess-always-select-tab/);
+  } finally {
+    await fsp.rm(root, { recursive: true, force: true });
+  }
+});
+
+test('createPrd leaves sourcePromptId unset when originClaudeSessionId matches no known Epic (plain SessionTab chat)', async () => {
+  const root = await fsp.mkdtemp(path.join(os.homedir(), '.sm-origin-session-no-match-'));
+  config.addAllowedRoot(root);
+  try {
+    await writeActiveIndexFixture(root, {});
+    const prdsDir = path.join(root, 'session-manager-operations', 'scheduler', 'prds');
+    const remote = makeFakeRemoteWithPrdsDir(prdsDir);
+
+    const result = await createPrd(
+      validCreateBody({ cwd: root, slug: 'no-epic-match', originClaudeSessionId: 'claude-sess-not-an-epic' }),
+      remote,
+    );
+
+    expect(result.ok).toBe(true);
+    const written = await fsp.readFile(path.join(prdsDir, result.filename), 'utf8');
+    expect(!/sourcePromptId:/.test(written)).toBeTruthy();
+  } finally {
+    await fsp.rm(root, { recursive: true, force: true });
+  }
+});

package/src/main/chatRunner.cjs

@@ -51,6 +51,7 @@ const { classifyToolUse } = require('./lib/toolUseClassify.cjs');
 const { extractJson } = require('./lib/extractJson.cjs');
 const { classifyPromptTicket } = require('./lib/classifyPromptTicket.cjs');
 const sessionSlots = require('./lib/sessionSlots.cjs');
+const opsErrorLog = require('./lib/opsErrorLog.cjs');
 
 // ─── Stop-signal protocol ──────────────────────────────────────────────────
 // Single source of truth for the sentinel and parser. The renderer (PRD 320)
@@ -470,6 +471,19 @@ function executeRun({ tabId, sessionId, prompt, cwd, resume, silent, onSilentRes
     const emitTerminal = (channel, payload) => {
       if (terminalSent) return;
       terminalSent = true;
+      // Every terminal error for this tab, logged once, regardless of the
+      // `silent` gate below — a probe run's failure is still real signal for
+      // tracing even though it never reaches the visible chat UI.
+      if (channel === 'chat:run:error') {
+        opsErrorLog.appendError({
+          cwd,
+          scope: 'chatRunner',
+          tabId,
+          tags: silent ? ['silent-probe'] : [],
+          message: payload?.message ?? 'chat run failed',
+          meta: { sessionId, silent },
+        });
+      }
       // Silent (probe) runs still need this bookkeeping so the lane frees
       // correctly, but must never surface on the six turn-affecting channels.
       if (silent) return;
@@ -495,7 +509,14 @@ function executeRun({ tabId, sessionId, prompt, cwd, resume, silent, onSilentRes
     };
 
     const claudeBin = resolveClaudeBin();
-    const childEnv = cleanChildEnv({ PATH: pathWithUserBins() });
+    // Carried down to any MCP server this run spawns (e.g.
+    // scripts/scheduler-mcp-server.cjs, inherited via the claude CLI's own
+    // child env) so scheduler_create_prd can auto-resolve sourcePromptId
+    // when the model forgets to pass it — see prdCreate.cjs's
+    // resolveSourcePromptIdFromClaudeSession. sessionId IS the Epic's
+    // claudeSessionId for an Epic-backed tab (domain model: Epic:claude-session
+    // 1:1); for a non-Epic tab, resolution below simply finds no match.
+    const childEnv = cleanChildEnv({ PATH: pathWithUserBins(), SM_CHAT_SESSION_ID: sessionId });
 
     // Prepend the stop-signal protocol instruction and the chat-mode truth
     // instruction to every prompt

package/src/main/ipcSchemas.cjs

@@ -303,6 +303,14 @@ const schedulerCreatePrd = z.object({
   // 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(),
+  // The calling MCP process's own claude session id (scheduler-mcp-server.cjs
+  // forwards its inherited SM_CHAT_SESSION_ID env var here when the model
+  // omitted sourcePromptId) — never written to frontmatter itself; prdCreate.cjs's
+  // createPrd() resolves it against active-index.json to fill sourcePromptId
+  // when it matches an existing Epic's claudeSessionId, so a PRD queued from
+  // within an Epic's own chat session joins that Epic even if the tool call
+  // forgot to pass sourcePromptId explicitly.
+  originClaudeSessionId: z.string().min(1).max(128).regex(NO_NEWLINE_RE, 'must not contain newlines').optional(),
   // User-selected Feature/Bug tag (PRD 774) carried from the originating
   // PromptTicket — deterministic, never LLM-classified.
   tag: z.enum(['feature', 'bug', 'discussion']).optional(),

package/src/main/lib/opsErrorLog.cjs

@@ -0,0 +1,96 @@
+'use strict';
+
+/**
+ * opsErrorLog.cjs — sole writer of the `logs` ops namespace
+ * (single-writer law, see opsOwnership.cjs). Appends one structured JSONL
+ * line per error to `<cwd>/session-manager-operations/logs/errors-<date>.jsonl`
+ * so errors from every tab/surface land in one common, per-project place
+ * instead of scattered across console.error calls and the machine-global
+ * <userData>/logs/ (which mixes every project together and isn't tagged for
+ * tracing). Every call site funnels through `appendError` — that is what
+ * makes this the sole writer in practice, not just in the OWNERS map.
+ */
+
+const fs = require('node:fs');
+const path = require('node:path');
+const { assertOpsWrite } = require('./opsOwnership.cjs');
+
+// Same redaction policy as logs.cjs's sanitizeMeta — kept independent (not
+// shared/required) so this module has no dependency on the Electron `app`
+// module and can be unit-tested without a running app.
+const REDACT_KEY = /^(transcript|interim|final|text|content|partial|userText|message|token|secret|password|authorization|cookie|api[_-]?key|access[_-]?token|refresh[_-]?token)$/i;
+
+function sanitizeMeta(meta) {
+  if (!meta || typeof meta !== 'object') return meta;
+  if (Array.isArray(meta)) return meta;
+  const out = {};
+  for (const [k, v] of Object.entries(meta)) {
+    out[k] = REDACT_KEY.test(k) ? '[redacted]' : v;
+  }
+  return out;
+}
+
+function logsDir(cwd) {
+  return path.join(cwd, 'session-manager-operations', 'logs');
+}
+
+function todayFile(cwd) {
+  const d = new Date();
+  const yyyy = d.getFullYear();
+  const mm = String(d.getMonth() + 1).padStart(2, '0');
+  const dd = String(d.getDate()).padStart(2, '0');
+  return path.join(logsDir(cwd), `errors-${yyyy}-${mm}-${dd}.jsonl`);
+}
+
+/**
+ * Append one structured error line, tagged for tracing/analysis.
+ *
+ * @param {{
+ *   cwd: string,           // required — which project's ops root owns this line
+ *   scope: string,         // subsystem name, e.g. 'pty', 'chatRunner', 'voice'
+ *   level?: string,        // default 'error'; 'warn' also accepted
+ *   tabId?: string,        // claudeSessionId of the tab this error belongs to, if any
+ *   epicId?: string,       // Epic id, if this error happened inside an Epic-backed run
+ *   tags?: string[],       // extra caller-supplied tags, merged with the auto-derived ones
+ *   message: string,
+ *   meta?: unknown,
+ * }} entry
+ */
+function appendError({ cwd, scope, level = 'error', tabId, epicId, tags = [], message, meta }) {
+  if (!cwd || typeof cwd !== 'string') return; // no project to attribute this line to — skip
+  const file = todayFile(cwd);
+  try {
+    assertOpsWrite(file, 'logs');
+  } catch {
+    return; // fail-closed, same as every other ops write path — never throw from a log call
+  }
+
+  const autoTags = [
+    `level:${level}`,
+    `scope:${scope || 'unknown'}`,
+    ...(tabId ? [`tab:${tabId}`] : []),
+    ...(epicId ? [`epic:${epicId}`] : []),
+  ];
+  const allTags = Array.from(new Set([...autoTags, ...tags]));
+
+  const line = {
+    ts: new Date().toISOString(),
+    level,
+    scope: scope || 'unknown',
+    tabId: tabId || null,
+    epicId: epicId || null,
+    tags: allTags,
+    message: String(message ?? ''),
+    ...(meta !== undefined ? { meta: sanitizeMeta(meta) } : {}),
+  };
+
+  try {
+    fs.mkdirSync(logsDir(cwd), { recursive: true });
+    // 0o600: same rationale as logs.cjs — error meta can carry local paths /
+    // device labels, keep it off other local users' reach.
+    const fd = fs.openSync(file, 'a', 0o600);
+    try { fs.writeSync(fd, JSON.stringify(line) + '\n'); } finally { fs.closeSync(fd); }
+  } catch { /* best-effort — a logging failure must never break the caller */ }
+}
+
+module.exports = { appendError, logsDir, todayFile };

package/src/main/lib/opsOwnership.cjs

@@ -26,6 +26,7 @@
  *   - config.cjs writeTextAtomic / writeBinaryAtomic / writeJson / writeJsonSync
  *   - lib/epicMint.cjs      (raw fs tmp+rename)
  *   - lib/queueStore.cjs    (raw fs tmp+rename)
+ *   - lib/opsErrorLog.cjs   (raw fs append, JSONL error log)
  * Renderer callers declare their writer id through the IPC payload.
  */
 
@@ -51,6 +52,8 @@ const OWNERS = Object.freeze({
   'feedback': 'feedback',
   // Browser tab scratch saves (DOM captures, screenshots, recorded flows).
   'browser': 'browser',
+  // Structured per-tab error log lines (JSONL), tagged for tracing/analysis.
+  'logs': 'logs',
 });
 
 /**

package/src/main/lib/prdCreate.cjs

@@ -23,6 +23,7 @@ const { kebabCase } = require('./kebabCase.cjs');
 const config = require('../config.cjs');
 const { expandHome } = require('./expandHome.cjs');
 const { readBody, sendJson } = require('./localAdminHttp.cjs');
+const { readActiveIndex } = require('./epicMint.cjs');
 
 const STANDARDS_PATH = path.join(
   __dirname, '..', '..', '..',
@@ -90,6 +91,29 @@ function buildPrdBody(input) {
   return `${fmLines.join('\n')}${bodyLines.join('\n')}`;
 }
 
+/**
+ * Best-effort fallback for a PRD queued via the scheduler_create_prd MCP tool
+ * from inside an Epic's own headless chat session, when the model's tool
+ * call omitted `sourcePromptId` — the exact gap that let PRDs 866/867 mint
+ * two unrelated sibling Epics instead of joining the Epic that was actually
+ * driving the conversation (2026-08-01). `claudeSessionId` is this process's
+ * `originClaudeSessionId` input (chatRunner.cjs's SM_CHAT_SESSION_ID env var,
+ * inherited down to the MCP server child); looked up against `cwd`'s
+ * active-index.json for the Epic whose own claudeSessionId matches (domain
+ * model: Epic:claude-session is 1:1). Returns null for a non-Epic tab (plain
+ * SessionTab chat) or when the id is stale/unknown — never throws, since this
+ * is strictly a convenience default and a miss must fall back to minting a
+ * normal Epic exactly like today.
+ */
+function resolveSourcePromptIdFromClaudeSession(cwd, claudeSessionId) {
+  if (!claudeSessionId) return null;
+  const { sessions } = readActiveIndex(cwd);
+  for (const session of Object.values(sessions)) {
+    if (session && session.claudeSessionId === claudeSessionId) return session.id;
+  }
+  return null;
+}
+
 /**
  * Core create-PRD orchestration: cwd validation, slug derivation, NN
  * allocation, existing-file collision check, body build, write. Shared by
@@ -130,6 +154,11 @@ async function createPrd(input, remote) {
   config.addAllowedRoot(realCwd);
   input = { ...input, cwd };
 
+  if (!input.sourcePromptId && input.originClaudeSessionId) {
+    const resolved = resolveSourcePromptIdFromClaudeSession(cwd, input.originClaudeSessionId);
+    if (resolved) input = { ...input, sourcePromptId: resolved };
+  }
+
   const slug = input.slug || deriveSlugFromTitle(input.title);
   if (!slug || !PRD_CREATE_SLUG_RE.test(slug)) {
     return { ok: false, status: 400, error: 'could not derive a valid kebab-case slug from title; supply "slug" explicitly' };
@@ -209,6 +238,7 @@ module.exports = {
   readStandards,
   deriveSlugFromTitle,
   buildPrdBody,
+  resolveSourcePromptIdFromClaudeSession,
   createPrd,
   registerAdminRoute,
 };

package/src/main/logs.cjs

@@ -1,6 +1,7 @@
 const { app, ipcMain } = require('electron');
 const fs = require('node:fs');
 const path = require('node:path');
+const opsErrorLog = require('./lib/opsErrorLog.cjs');
 
 // Rolling daily files under <userData>/logs/. Anything mtime'd older than
 // RETENTION_MS is pruned at boot; we never compact mid-session, since the
@@ -75,7 +76,24 @@ function writeLine(payload) {
 }
 
 function registerLogHandlers() {
-  ipcMain.on('log:write', (_e, payload) => writeLine(payload));
+  ipcMain.on('log:write', (_e, payload) => {
+    writeLine(payload);
+    // Renderer errors that name which project/tab they belong to also land
+    // in that project's own session-manager-operations/logs/ — the
+    // machine-global file above mixes every project together and isn't
+    // taggable, so it's not a substitute for the per-project trace.
+    if (payload && payload.level === 'error' && payload.cwd) {
+      opsErrorLog.appendError({
+        cwd: payload.cwd,
+        scope: payload.scope,
+        tabId: payload.tabId,
+        epicId: payload.epicId,
+        tags: Array.isArray(payload.tags) ? payload.tags : [],
+        message: payload.message,
+        meta: payload.meta,
+      });
+    }
+  });
   ipcMain.handle('log:dir', () => logDir());
 }
 

package/src/main/pty.cjs

@@ -20,6 +20,7 @@ const { addAllowedRoot } = require('./config.cjs');
 const { cleanChildEnv, pathWithUserBins } = require('./lib/cleanEnv.cjs');
 const { checkInsideHome } = require('./lib/insideHome.cjs');
 const { sendIfAlive } = require('./lib/sendToRenderer.cjs');
+const opsErrorLog = require('./lib/opsErrorLog.cjs');
 
 // Absolute path to the installed package root (src/main/ -> ../../), shown in
 // the remediation message so the user can cd there and rebuild.
@@ -162,6 +163,13 @@ class PtyManager {
       });
     } catch (err) {
       console.error('[pty] pty.spawn threw:', err);
+      opsErrorLog.appendError({
+        cwd,
+        scope: 'pty',
+        tabId,
+        tags: ['spawn-failed'],
+        message: `pty.spawn threw: ${err?.message ?? String(err)}`,
+      });
       // Surface the cause in the tab + report a clean exit rather than throwing
       // an opaque IPC error (covers a missing/invalid cwd or a native fault).
       sendIfAlive(this.window, `pty:data:${tabId}`, nativeModuleHelp(`pty.spawn failed: ${err?.message ?? String(err)}`));
@@ -196,6 +204,13 @@ class PtyManager {
       // real interactive shell (which prints a prompt immediately) is exempt.
       if (!gotData && exitCode !== 0 && Date.now() - spawnedAt < 1200) {
         sendIfAlive(this.window, `pty:data:${tabId}`, nativeModuleHelp(`The shell exited immediately (code ${exitCode}).`));
+        opsErrorLog.appendError({
+          cwd,
+          scope: 'pty',
+          tabId,
+          tags: ['immediate-exit'],
+          message: `shell exited immediately (code ${exitCode}, signal ${signal ?? 'none'}) after ${Date.now() - spawnedAt}ms with no output`,
+        });
       }
       sendIfAlive(this.window, `pty:exit:${tabId}`, { exitCode, signal });
       this.sessions.delete(tabId);

package/src/preload/api.d.ts

@@ -1283,7 +1283,13 @@ export interface SessionManagerAPI {
     status: () => Promise<McpStatusResult>;
   };
   logs: {
-    write: (scope: string, level: 'debug' | 'info' | 'warn' | 'error', message: string, meta?: unknown) => void;
+    write: (
+      scope: string,
+      level: 'debug' | 'info' | 'warn' | 'error',
+      message: string,
+      meta?: unknown,
+      ctx?: { cwd?: string; tabId?: string; epicId?: string; tags?: string[] },
+    ) => void;
     dir: () => Promise<string>;
   };
   config: {

package/src/preload/index.cjs

@@ -146,8 +146,11 @@ contextBridge.exposeInMainWorld('api', {
     status: () => ipcRenderer.invoke('mcp:status'),
   },
   logs: {
-    write: (scope, level, message, meta) =>
-      ipcRenderer.send('log:write', { scope, level, message, meta }),
+    // ctx is optional: { cwd, tabId, epicId, tags } — when present and
+    // level is 'error', main also appends a tagged line to that project's
+    // own session-manager-operations/logs/ (see opsErrorLog.cjs).
+    write: (scope, level, message, meta, ctx) =>
+      ipcRenderer.send('log:write', { scope, level, message, meta, ...ctx }),
     dir: () => ipcRenderer.invoke('log:dir'),
   },
   config: {