claude-code-session-manager 0.38.5 → 0.38.7

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, sourceTabId,
+    implementationNotes, outOfScope, sourcePromptId, sourceTabId, tag,
   } = input;
 
   // No `parallelGroup` frontmatter key by convention (SKILL.md) — the NN-
@@ -61,6 +61,9 @@ function buildPrdBody(input) {
   // 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}`);
+  // Optional, additive: the user-selected Feature/Bug tag (PRD 774) carried
+  // through from the originating PromptTicket — deterministic, never LLM-classified.
+  if (tag) fmLines.push(`tag: ${tag}`);
   fmLines.push('---', '');
 
   const acLines = acceptanceCriteria.map((line) => `- [ ] ${line}`).join('\n');
@@ -85,6 +88,63 @@ function buildPrdBody(input) {
   return `${fmLines.join('\n')}${bodyLines.join('\n')}`;
 }
 
+/**
+ * Core create-PRD orchestration: cwd validation, slug derivation, NN
+ * allocation, existing-file collision check, body build, write. Shared by
+ * both the admin HTTP route (registerAdminRoute, used by the MCP tool) and
+ * the renderer-facing IPC handler (chat:create-prd, index.cjs) so the
+ * validation/write logic lives in exactly one place (API-reuse standard).
+ * `input` must already be schema-validated by the caller (schemas.schedulerCreatePrd).
+ * `remote` is scheduler.cjs's remote object (allocateParallelGroup/readPrd/writePrd).
+ *
+ * Returns `{ ok: true, nn, filename }` on success, or `{ ok: false, status, error }`
+ * on failure — `status` is the HTTP status code the caller should map errors to
+ * (400/409/500), left to the caller since only the HTTP route needs it.
+ */
+async function createPrd(input, remote) {
+  // cwd is untrusted: this is the first *creating* mutation on a
+  // token-authed API whose product is "a command that will later run
+  // with --dangerously-skip-permissions in a chosen cwd". Route it
+  // through config.cjs's validatePath (allowedRoots = home dir) —
+  // same boundary every other fs-touching IPC handler uses — never a
+  // bespoke check here.
+  try {
+    config.validatePath(expandHome(input.cwd));
+  } catch (e) {
+    return { ok: false, status: 400, error: `cwd rejected: ${e?.message ?? 'outside allowed roots'}` };
+  }
+
+  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' };
+  }
+
+  // NN allocation is delegated to allocateParallelGroup() (PRD 548) via
+  // the injected remote — never re-derived here — unless the caller
+  // opted into an existing group explicitly.
+  const nn = input.parallelGroup ?? await remote.allocateParallelGroup();
+  const filenameSlug = `${nn}-${slug}`;
+
+  // An explicit `parallelGroup` bypasses allocateParallelGroup()'s
+  // collision-proof reservation, so re-check for an existing file at
+  // this exact destination before writing — remote.writePrd itself has
+  // no existence guard (by design, it doubles as the edit-in-place
+  // path for Scheduler UI PRD edits), so "create" must not silently
+  // clobber an existing job's PRD.
+  const existing = await remote.readPrd(filenameSlug);
+  if (existing?.ok) {
+    return { ok: false, status: 409, error: `PRD already exists: ${filenameSlug}.md` };
+  }
+
+  const body = buildPrdBody(input);
+  const writeResult = await remote.writePrd(filenameSlug, body);
+  if (!writeResult?.ok) {
+    return { ok: false, status: 500, error: writeResult?.error ?? 'write failed' };
+  }
+
+  return { ok: true, nn, filename: `${filenameSlug}.md` };
+}
+
 /**
  * Registers the create-prd admin HTTP route (PRD 689 — moved verbatim out of
  * the former standalone admin HTTP server module's handleRequest, no behavior
@@ -112,51 +172,13 @@ function registerAdminRoute(adminHttp, remote) {
       return;
     }
 
-    // cwd is untrusted: this is the first *creating* mutation on a
-    // token-authed API whose product is "a command that will later run
-    // with --dangerously-skip-permissions in a chosen cwd". Route it
-    // through config.cjs's validatePath (allowedRoots = home dir) —
-    // same boundary every other fs-touching IPC handler uses — never a
-    // bespoke check here.
-    try {
-      config.validatePath(expandHome(input.cwd));
-    } catch (e) {
-      sendJson(res, 400, { ok: false, error: `cwd rejected: ${e?.message ?? 'outside allowed roots'}` });
-      return;
-    }
-
-    const slug = input.slug || deriveSlugFromTitle(input.title);
-    if (!slug || !PRD_CREATE_SLUG_RE.test(slug)) {
-      sendJson(res, 400, { ok: false, error: 'could not derive a valid kebab-case slug from title; supply "slug" explicitly' });
-      return;
-    }
-
-    // NN allocation is delegated to allocateParallelGroup() (PRD 548) via
-    // the injected remote — never re-derived here — unless the caller
-    // opted into an existing group explicitly.
-    const nn = input.parallelGroup ?? await remote.allocateParallelGroup();
-    const filenameSlug = `${nn}-${slug}`;
-
-    // An explicit `parallelGroup` bypasses allocateParallelGroup()'s
-    // collision-proof reservation, so re-check for an existing file at
-    // this exact destination before writing — remote.writePrd itself has
-    // no existence guard (by design, it doubles as the edit-in-place
-    // path for Scheduler UI PRD edits), so "create" must not silently
-    // clobber an existing job's PRD.
-    const existing = await remote.readPrd(filenameSlug);
-    if (existing?.ok) {
-      sendJson(res, 409, { ok: false, error: `PRD already exists: ${filenameSlug}.md` });
-      return;
-    }
-
-    const body = buildPrdBody(input);
-    const writeResult = await remote.writePrd(filenameSlug, body);
-    if (!writeResult?.ok) {
-      sendJson(res, 500, { ok: false, error: writeResult?.error ?? 'write failed' });
+    const result = await createPrd(input, remote);
+    if (!result.ok) {
+      sendJson(res, result.status, { ok: false, error: result.error });
       return;
     }
 
-    sendJson(res, 200, { nn, filename: `${filenameSlug}.md`, status: 'queued' });
+    sendJson(res, 200, { nn: result.nn, filename: result.filename, status: 'queued' });
   });
 }
 
@@ -166,5 +188,6 @@ module.exports = {
   readStandards,
   deriveSlugFromTitle,
   buildPrdBody,
+  createPrd,
   registerAdminRoute,
 };

package/src/main/pty.cjs

@@ -226,9 +226,6 @@ class PtyManager {
       }
       this.sessions.delete(tabId);
     }
-    // Always drop superagent run state — a run can be started before the pty
-    // finishes spawning, so clean up regardless of whether a session existed.
-    try { require('./superagent.cjs').dropTab(tabId); } catch { /* superagent not loaded (e2e) */ }
   }
 
   killAll() {
@@ -245,8 +242,6 @@ function registerPtyHandlers() {
   ipcMain.on('pty:resize', (_e, payload) => { try { manager.resize(s.ptyResize.parse(payload)); } catch { /* ignore */ } });
   ipcMain.on('pty:kill', (_e, tabId) => {
     if (typeof tabId !== 'string') return;
-    // manager.kill() already drops superagent run state for tabId — see kill()
-    // above. Do not duplicate that call here.
     manager.kill(tabId);
   });
 }

package/src/main/queueOps.cjs

@@ -83,6 +83,50 @@ const LINE_RULES = [
   },
 ];
 
+// Interactive/GUI-rendering-as-headless-AC patterns (research: PRDs 776/779,
+// the 2026-07-30 exit143 incident — a claude -p executor hits a tool-use
+// rejection on these and hangs until the scheduler SIGTERMs it, even when
+// the step works fine run interactively). Keyed off AC-checkbox context
+// specifically (a "- [ ] " line via INTERACTIVE_AC_CHECKBOX_RE), not any
+// occurrence anywhere in the file — a PRD's Out-of-scope/Implementation-notes
+// prose explicitly telling the executor NOT to do this (e.g. "NOTE: do NOT
+// add a `playwright test ... under xvfb` acceptance criterion here", as in
+// PRDs 780/787/788) is plain prose, not a checkbox line, so it must not
+// trigger a false positive.
+const INTERACTIVE_AC_CHECKBOX_RE = /^\s*-\s*\[[ xX]\]/;
+const INTERACTIVE_AC_PATTERNS = [
+  {
+    id: 'interactive-xvfb',
+    re: /\bxvfb-run\b/i,
+    label: 'xvfb-run as a headless AC — cannot run under claude -p (see PRD_AUTHORING.md / 776+779 incidents)',
+  },
+  {
+    id: 'interactive-electron-launch',
+    re: /electron\.launch\b/i,
+    label: 'playwright electron.launch as a headless AC — interactive tool-use rejection hangs the executor',
+  },
+  {
+    id: 'interactive-playwright-test',
+    re: /\bplaywright\s+test\b/i,
+    label: '"playwright test" as a headless AC — GUI-rendering e2e cannot run headlessly',
+  },
+  {
+    id: 'interactive-launch-app',
+    re: /\blaunch(?:ing)?\s+the\s+app\b/i,
+    label: '"launch the app" as a headless AC — interactive/GUI step',
+  },
+  {
+    id: 'interactive-click-through',
+    re: /\bclick(?:ing)?\s+through\b/i,
+    label: '"click through" as a headless AC — interactive/GUI step',
+  },
+  {
+    id: 'interactive-screenshot',
+    re: /\bscreenshot/i,
+    label: 'screenshot capture as a headless AC — interactive/GUI-rendering step',
+  },
+];
+
 const { splitFrontmatter } = require('./lib/prdFrontmatter.cjs');
 
 /**
@@ -165,6 +209,20 @@ function lintParsed(slug, raw) {
         });
       }
     }
+    // Interactive-AC scan — only on checkbox-format AC lines, see the
+    // pattern-list comment above for why prose mentions must not match.
+    if (INTERACTIVE_AC_CHECKBOX_RE.test(line)) {
+      for (const rule of INTERACTIVE_AC_PATTERNS) {
+        if (rule.re.test(line)) {
+          findings.push({
+            rule: rule.id,
+            line: fmLineCount + i + 1,
+            snippet: `${rule.label} — ${line.trim().slice(0, 80)}`,
+            severity: 'warn',
+          });
+        }
+      }
+    }
   }
 
   return { slug, findings };

package/src/main/scheduler.cjs

@@ -264,6 +264,27 @@ async function computeCommittedDuringRun(cwd, headBefore, headAfter, startedAt,
   return committedInWindow(cwd, startedAt, untilIso);
 }
 
+/**
+ * Override for a SIGTERM'd (143) run when a commit landed in its window.
+ * Exit 143 alone doesn't prove the deliverable is missing — the 776/779
+ * incidents (2026-07-30) both died on a headless-incompatible interactive
+ * step (xvfb Electron screenshot / playwright electron.launch) AFTER their
+ * commit had already landed, and sat `failed` forever with a real deliverable
+ * on disk. A landed commit doesn't prove every AC line passed though (the
+ * step it died on is still unverified), so this routes to `needs_review`,
+ * never silently promotes to `completed`. Returns null for every other exit
+ * code, or for a 143 with no commit found in window — those fall through to
+ * the existing `failed` path unchanged. Pure/no I/O: the commit-window scan
+ * (committedInWindow) happens at the call site, not here.
+ */
+function classifySigtermWithCommit(exitCode, commitFoundInWindow) {
+  if (exitCode !== 143 || !commitFoundInWindow) return null;
+  return {
+    status: 'needs_review',
+    reason: 'SIGTERM after a commit landed — verify AC before treating as done',
+  };
+}
+
 const ROOT = path.join(os.homedir(), '.claude', 'session-manager', 'scheduled-plans');
 const PRDS_DIR = path.join(ROOT, 'prds');
 const RUNS_DIR = path.join(ROOT, 'runs');
@@ -1994,6 +2015,23 @@ async function spawnJob(job, runId, runDir, defaultCwd) {
       }
     }
 
+    // SIGTERM commit check: reuse the same commit-window scan the exit=0
+    // guard uses above (one commit-detection path, not two) to see whether a
+    // 143 (SIGTERM) run still landed a deliverable before it died. Scoped
+    // narrowly to exit 143 — never applied to other non-zero exit codes or to
+    // rateLimited (already handled separately, above).
+    let sigtermCommitFound = false;
+    if (res.exitCode === 143 && !res.rateLimited) {
+      const guardHeadAtSigterm = await gitHead(guardCwd);
+      sigtermCommitFound = await computeCommittedDuringRun(
+        guardCwd,
+        guardHeadBefore,
+        guardHeadAtSigterm,
+        job.startedAt,
+        new Date().toISOString(),
+      );
+    }
+
     let actuallyFailed = false;
     let failedJobSnapshot = null;
     let needsInvestigationNow = false;
@@ -2009,7 +2047,14 @@ async function spawnJob(job, runId, runDir, defaultCwd) {
         } else {
           // Determine effective status, applying the verifier verdict for exit=0 runs.
           let effectiveStatus;
-          if (res.exitCode !== 0) {
+          let sigtermOverrideReason = null;
+          const sigtermOverride = res.exitCode !== 0
+            ? classifySigtermWithCommit(res.exitCode, sigtermCommitFound)
+            : null;
+          if (sigtermOverride) {
+            effectiveStatus = sigtermOverride.status;
+            sigtermOverrideReason = sigtermOverride.reason;
+          } else if (res.exitCode !== 0) {
             effectiveStatus = 'failed';
           } else if (
             !verifyResult
@@ -2033,7 +2078,7 @@ async function spawnJob(job, runId, runDir, defaultCwd) {
           s.jobs[i2].finishedAt = new Date().toISOString();
           s.jobs[i2].exitCode = res.exitCode;
           s.jobs[i2].error = effectiveStatus === 'needs_review'
-            ? (verifyResult?.reason ?? null)
+            ? (verifyResult?.reason ?? sigtermOverrideReason ?? null)
             : (res.error || null);
           // Persist the verifier's verdict string so the renderer can show it.
           if (verifyResult?.verdict && verifyResult.verdict !== 'clean') {
@@ -3454,4 +3499,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, notifyOriginatingTab, isNotifiableTerminalStatus };
+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, classifySigtermWithCommit, 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/transcripts.cjs

@@ -25,7 +25,6 @@ const os = require('node:os');
 const chokidar = require('chokidar');
 const otel = require('./otel.cjs');
 const logs = require('./logs.cjs');
-const usageMatrix = require('./usageMatrix.cjs');
 const { sendIfAlive } = require('./lib/sendToRenderer.cjs');
 
 let window = null;
@@ -103,7 +102,7 @@ async function readDelta(sub) {
   }
 }
 
-async function doFlush(sub, { emit = true, replay = false } = {}) {
+async function doFlush(sub, { emit = true } = {}) {
   const lines = await readDelta(sub);
   for (const line of lines) {
     let obj;
@@ -117,15 +116,6 @@ async function doFlush(sub, { emit = true, replay = false } = {}) {
     // Ring buffer (cap at 500 entries to bound memory).
     sub.buffer.push(ev);
     if (sub.buffer.length > 500) sub.buffer.shift();
-    // Feed the AgOps aggregator on every event — both replay and live, so
-    // freshly-attached tabs land with full history reflected in the matrix.
-    usageMatrix.recordEvent({
-      tabId: sub.tabId,
-      cwd: sub.cwd,
-      sessionUuid: sub.sessionUuid,
-      ev,
-      replay,
-    });
     if (emit) sendIfAlive(window, `transcript:event:${sub.tabId}`, ev);
     // Mirror to OTEL — no-op when disabled. We emit on the initial drain too
     // so backfilled transcripts show up in the trace store.
@@ -178,7 +168,6 @@ function _closeSub(tabId) {
   if (!sub) return;
   sub.watcher?.close().catch(() => {});
   subs.delete(tabId);
-  usageMatrix.removeTab(tabId);
   const i = lruReleased.indexOf(tabId);
   if (i !== -1) lruReleased.splice(i, 1);
 }
@@ -247,9 +236,8 @@ async function subscribe({ tabId, cwd, sessionUuid }) {
   // during this initial drain — the renderer drains sub.buffer via
   // `transcript:buffer` after `transcript:subscribe` resolves. Emitting here
   // would race the renderer's onEvent listener registration and drop events.
-  // replay:true prevents historical usage events from entering the 5-min window.
   if (fs.existsSync(filePath)) {
-    await doFlush(sub, { emit: false, replay: true });
+    await doFlush(sub, { emit: false });
   }
   const watcher = chokidar.watch(filePath, {
     ignoreInitial: false,
@@ -277,7 +265,6 @@ function getBuffer(tabId) {
 function closeAll() {
   for (const sub of subs.values()) sub.watcher?.close().catch(() => {});
   subs.clear();
-  usageMatrix.closeAll();
 }
 
 function registerTranscriptHandlers() {

package/src/preload/api.d.ts

@@ -176,6 +176,14 @@ export interface LoadedSessions {
   freshStart?: boolean;
 }
 
+export interface LayoutEnvelope {
+  version: number;
+  /** Panel ids present in `dockview` at save time — pruned against the live registry on hydrate. */
+  panels: string[];
+  /** Opaque dockview `SerializedDockview` blob (from `api.toJSON()`/for `api.fromJSON()`). */
+  dockview: Record<string, unknown>;
+}
+
 export interface UsageWindow {
   utilization: number;
   resets_at: string | null;
@@ -228,54 +236,6 @@ export interface McpStatusResult {
   checkedAt: number;
 }
 
-// ── Usage matrix (AgOps dashboard, main-side aggregator)
-export type UsageMatrixState = 'idle' | 'executing' | 'plan' | 'background';
-export type UsageMatrixIntensity = 'idle' | 'low' | 'medium' | 'critical';
-export type UsageMatrixCacheState = 'warm' | 'expiring' | 'cold';
-
-export interface UsageMatrixAlert {
-  level: 'info' | 'warn';
-  code:
-    | 'geometric-growth'
-    | 'long-session'
-    | 'cache-cold-start'
-    | 'cache-cold'
-    | 'subagent-fanout';
-  message: string;
-}
-
-export interface UsageMatrixTab {
-  tabId: string;
-  workspace: string;
-  cwd: string;
-  state: UsageMatrixState;
-  turns: number;
-  lastEventAt: number;
-  lastAssistantAt: number;
-  cacheAgeMs: number | null;
-  cacheState: UsageMatrixCacheState;
-  tokensPerMin: number;
-  intensity: UsageMatrixIntensity;
-  avgTokensPerTurn: number;
-  cumulativeUsage: { input: number; output: number; cacheRead: number; cacheCreate: number };
-  subagentsActive: number;
-  subagentsSpawned: number;
-  geometricGrowth: boolean;
-  alerts: UsageMatrixAlert[];
-}
-
-export interface UsageMatrixSnapshot {
-  generatedAt: number;
-  tabs: UsageMatrixTab[];
-  totals: {
-    activeSessions: number;
-    subagentsActive: number;
-    subagentsSpawned: number;
-    tokensTotal: number;
-    combinedTokensPerMin: number;
-  };
-}
-
 export interface VoiceHotkeyConfig {
   accelerator: string;
   mode: 'hold' | 'toggle';
@@ -691,19 +651,6 @@ export interface RepoAnalyzeResult {
 }
 export interface RepoAnalyzeError { ok: false; error: string }
 
-export interface RecipeStep { agentName: string; note?: string }
-export interface Recipe {
-  slug: string;
-  name: string;
-  description: string;
-  brief?: string;
-  steps: RecipeStep[];
-}
-// Channel keeps legacy "hives" name; concept is now "recipe".
-export interface HiveListResult { hives: Recipe[]; error: string | null }
-export interface HiveGetResult { hive: Recipe | null; error: string | null }
-export interface HiveMutationResult { ok: boolean; error: string | null }
-
 export interface WatcherInfo {
   watcherId: string;
   tabId: string;
@@ -956,40 +903,6 @@ export interface PluginInstallProgressEvent {
   line: string;
 }
 
-// ────────────────────────────────────────────── SuperAgent
-// "Boss" run that dispatches specialist subagents on the active tab's claude
-// session. Renderer-driven progress — main only owns lifecycle + prompt write.
-
-export type SuperAgentDepth = 'quick' | 'standard' | 'deep';
-export type SuperAgentStatus = 'idle' | 'running' | 'done' | 'error';
-
-export interface SuperAgentRunState {
-  status: SuperAgentStatus;
-  prompt: string;
-  specialistCount: number;
-  depth: SuperAgentDepth;
-  startedAt: number | null;
-  finishedAt: number | null;
-  error?: string;
-}
-
-export interface SuperAgentStartArgs {
-  tabId: string;
-  prompt: string;
-  specialistCount: number;
-  depth: SuperAgentDepth;
-}
-
-export interface SuperAgentStartResult {
-  ok: boolean;
-  error?: string;
-}
-
-export interface SuperAgentStateChangedEvent {
-  tabId: string;
-  state: SuperAgentRunState | null;
-}
-
 // ────────────────────────────────────────────── Web Remote (PRD 08)
 
 export interface WebRemoteDevice {
@@ -1046,6 +959,28 @@ export interface ChatRunPayload {
   promptId?: string;
 }
 
+export interface ChatCreatePrdPayload {
+  title: string;
+  cwd: string;
+  estimateMinutes: number;
+  goal: string;
+  acceptanceCriteria: string[];
+  implementationNotes: string;
+  outOfScope?: string[];
+  slug?: string;
+  parallelGroup?: number;
+  /** Originating PromptTicket.id (PRD 748) — traces the PRD back to the prompt that spawned it. */
+  sourcePromptId?: string;
+  /** Originating tab id — used at job completion to route a status prompt back into the tab. */
+  sourceTabId?: string;
+  /** User-selected Feature/Bug tag (PRD 774) carried from the originating PromptTicket. */
+  tag?: 'feature' | 'bug';
+}
+
+export type ChatCreatePrdResult =
+  | { ok: true; nn: number; filename: string }
+  | { ok: false; status: number; error: string };
+
 export interface ChatRunQueuedEvent {
   tabId: string;
   sessionId: string;
@@ -1213,16 +1148,16 @@ export interface SessionManagerAPI {
     load: () => Promise<LoadedSessions>;
     save: (payload: LoadedSessions) => Promise<{ ok: boolean }>;
   };
+  layout: {
+    load: () => Promise<LayoutEnvelope | null>;
+    save: (payload: LayoutEnvelope) => Promise<{ ok: boolean }>;
+  };
   billing: {
     fetch: () => Promise<BillingFetchResult>;
   };
   mcp: {
     status: () => Promise<McpStatusResult>;
   };
-  usageMatrix: {
-    snapshot: () => Promise<UsageMatrixSnapshot>;
-    onTick: (handler: (snap: UsageMatrixSnapshot) => void) => () => void;
-  };
   logs: {
     write: (scope: string, level: 'debug' | 'info' | 'warn' | 'error', message: string, meta?: unknown) => void;
     dir: () => Promise<string>;
@@ -1315,12 +1250,6 @@ export interface SessionManagerAPI {
   repo: {
     analyze: (cwd: string) => Promise<RepoAnalyzeResult | RepoAnalyzeError>;
   };
-  hives: {
-    list: () => Promise<HiveListResult>;
-    get: (slug: string) => Promise<HiveGetResult>;
-    save: (slug: string, hive: Recipe) => Promise<HiveMutationResult>;
-    delete: (slug: string) => Promise<HiveMutationResult>;
-  };
   history: {
     aggregate: (req?: HistoryAggregateRequest) => Promise<HistoryAggregateResult>;
     scanProjects: () => Promise<SessionScanResult>;
@@ -1436,17 +1365,6 @@ export interface SessionManagerAPI {
      *  renderer needs per-row badges without a separate git call per file. */
     fileStatus: (cwd: string) => Promise<GitFileStatusMap>;
   };
-  superagent: {
-    /** Start a SuperAgent boss run — writes a structured prompt to the tab's
-     *  PTY asking Claude to pick + dispatch specialists. Single run per tab. */
-    start: (args: SuperAgentStartArgs) => Promise<SuperAgentStartResult>;
-    /** Current run state for tab, or null if no run has been started. */
-    status: (tabId: string) => Promise<SuperAgentRunState | null>;
-    /** Mark the run as done. Does not interrupt Claude — the user can stop
-     *  the in-PTY work via Ctrl-C; this only flips the renderer indicator. */
-    stop: (tabId: string) => Promise<{ ok: boolean }>;
-    onStateChanged: (handler: (ev: SuperAgentStateChangedEvent) => void) => () => void;
-  };
   webRemote: {
     getStatus: () => Promise<WebRemoteStatus>;
     enable: () => Promise<WebRemoteMutationResult>;
@@ -1490,6 +1408,11 @@ export interface SessionManagerAPI {
      *  chatRunner) or 'develop' (dispatch to /develop for PRD decomposition).
      *  A single bounded `claude -p` call, never a scheduler job. */
     classifyTicket: (payload: { text: string }) => Promise<'inline' | 'develop'>;
+    /** Author a mechanical draft PRD from a queued PromptTicket classified
+     *  'develop' — an in-process call to prdCreate.createPrd, never an HTTP
+     *  round-trip. The draft is meant to be reviewed/edited in the Scheduler
+     *  tab's PRD editor before it runs. */
+    createPrd: (payload: ChatCreatePrdPayload) => Promise<ChatCreatePrdResult>;
   };
   exchanges: {
     /** Durable per-exchange log entries for a project, newest-first (max 100 by default). */

package/src/preload/index.cjs

@@ -132,20 +132,16 @@ contextBridge.exposeInMainWorld('api', {
     load: () => ipcRenderer.invoke('sessions:load'),
     save: (payload) => ipcRenderer.invoke('sessions:save', payload),
   },
+  layout: {
+    load: () => ipcRenderer.invoke('layout:load'),
+    save: (payload) => ipcRenderer.invoke('layout:save', payload),
+  },
   billing: {
     fetch: () => ipcRenderer.invoke('billing:fetch'),
   },
   mcp: {
     status: () => ipcRenderer.invoke('mcp:status'),
   },
-  usageMatrix: {
-    snapshot: () => ipcRenderer.invoke('usage:matrix:snapshot'),
-    onTick: (handler) => {
-      const listener = (_e, payload) => handler(payload);
-      ipcRenderer.on('usage:matrix:tick', listener);
-      return () => ipcRenderer.removeListener('usage:matrix:tick', listener);
-    },
-  },
   logs: {
     write: (scope, level, message, meta) =>
       ipcRenderer.send('log:write', { scope, level, message, meta }),
@@ -248,12 +244,6 @@ contextBridge.exposeInMainWorld('api', {
   repo: {
     analyze: (cwd) => ipcRenderer.invoke('repo:analyze', { cwd }),
   },
-  hives: {
-    list: () => ipcRenderer.invoke('hives:list'),
-    get: (slug) => ipcRenderer.invoke('hives:get', { slug }),
-    save: (slug, hive) => ipcRenderer.invoke('hives:save', { slug, hive }),
-    delete: (slug) => ipcRenderer.invoke('hives:delete', { slug }),
-  },
   schedule: {
     state: () => ipcRenderer.invoke('schedule:state'),
     setConfig: (partial) => ipcRenderer.invoke('schedule:set-config', partial),
@@ -338,19 +328,6 @@ contextBridge.exposeInMainWorld('api', {
     status: (cwd) => ipcRenderer.invoke('git:status', { cwd }),
     fileStatus: (cwd) => ipcRenderer.invoke('git:file-status', { cwd }),
   },
-  superagent: {
-    /** Start a SuperAgent boss run on a tab — writes a structured prompt to
-     *  the PTY asking Claude to pick + dispatch specialists. Single live run
-     *  per tab; starting again on a running tab terminates the prior one. */
-    start: (payload) => ipcRenderer.invoke('superagent:start', payload),
-    status: (tabId) => ipcRenderer.invoke('superagent:status', { tabId }),
-    stop: (tabId) => ipcRenderer.invoke('superagent:stop', { tabId }),
-    onStateChanged: (handler) => {
-      const listener = (_e, payload) => handler(payload);
-      ipcRenderer.on('superagent:state-changed', listener);
-      return () => ipcRenderer.removeListener('superagent:state-changed', listener);
-    },
-  },
   webRemote: {
     /** Current connection state (no token values). */
     getStatus: () => ipcRenderer.invoke('webRemote:get-status'),
@@ -445,6 +422,8 @@ contextBridge.exposeInMainWorld('api', {
     },
     /** Classify a queued PromptTicket's text as 'inline' or 'develop'. */
     classifyTicket: (payload) => ipcRenderer.invoke('chat:classify-ticket', payload),
+    /** Author a mechanical draft PRD from a queued PromptTicket classified 'develop'. */
+    createPrd: (payload) => ipcRenderer.invoke('chat:create-prd', payload),
   },
   exchanges: {
     /** List exchanges for a project (durable chat-run log), newest-first.