claude-code-session-manager 0.38.5 → 0.38.7

package/dist/index.html

@@ -7,10 +7,10 @@
     <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-DwjviHVo.js"></script>
+    <script type="module" crossorigin src="./assets/index-DPSmbyU_.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-CZrfXQpq.css">
+    <link rel="stylesheet" crossorigin href="./assets/index-BGTU12rl.css">
   </head>
   <body class="bg-bg text-fg font-sans antialiased">
     <div id="root"></div>

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "claude-code-session-manager",
-  "version": "0.38.5",
+  "version": "0.38.7",
   "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",
@@ -98,6 +98,7 @@
     "@xterm/addon-web-links": "^0.11.0",
     "@xterm/xterm": "^5.5.0",
     "chokidar": "^4.0.1",
+    "dockview-react": "^6.6.1",
     "dompurify": "^3.4.8",
     "electron": "42.1.0",
     "framer-motion": "^12.38.0",

package/plugins/session-manager-dev/skills/blog-for-project-feature/2-storyboard/SKILL.md

@@ -12,8 +12,8 @@ Mission/description + feature description + demo surface (routes, run command, s
 ## Steps
 
 1. **Break the feature into aspects**, not just clicks. Each storyboard step should reveal ONE
-   idea — a screen, a state change, a result — not an arbitrary UI action. 4-8 steps is a good
-   range; fewer feels thin, more starts diluting the "one aspect at a time" promise.
+   idea — a screen, a state change, a result — not an arbitrary UI action. **5-10 steps** ("swipes")
+   is the target range; fewer feels thin, more starts diluting the "one aspect at a time" promise.
 
 2. **For each step, define:**
    - `step`: index + short name (e.g. `2-queue-populated`)
@@ -21,18 +21,44 @@ Mission/description + feature description + demo surface (routes, run command, s
      submit form with Z) — precise enough that `:capture` can execute it without re-deciding
    - `expected_screen`: what should be visible when the action completes — this is the
      hypothesis `:capture` verifies against the real app
+   - `capture_scope`: `full_page` or `component` (see the composition recipe below) — plus, when
+     `component`, which element/region to frame (a CSS selector, ARIA role+name, or plain
+     description precise enough for `:capture` to target a single element screenshot instead of
+     the whole viewport)
    - `caption`: one sentence, written for the reader of the final page, naming what changed on
      screen (not internal mechanics)
 
-3. **Order for narrative sense**: typically entry point → the feature's core interaction →
-   the result/outcome it produces. Match `content.demo_interaction` in `feature.config.yaml`
-   (one-step reveal, not a scroll dump) — so the order IS the reveal sequence.
+3. **Compose the sequence with this recipe — authoritative, not a suggestion.** A full-page shot
+   every step is disorienting (the reader has to re-find the relevant thing each time); an
+   all-component sequence loses context (the reader forgets where they are in the app). Mix them
+   deliberately in this arc:
+   - **Orientation (1 step, `full_page`).** Where the feature lives in the real product — the
+     screen the reader would actually land on. Establishes context before zooming in.
+   - **Mechanism (2-5 steps, `component`).** The actual control, interaction, or state change,
+     cropped/framed to just that component so the reader's eye isn't hunting across a full
+     screen for what changed. This is the bulk of the demo — most features are *shown* here.
+   - **Variation or depth (0-2 steps, mixed).** Secondary states, options, or edge cases worth
+     surfacing. Default to `component`; use `full_page` only if the variation reshapes the whole
+     screen (a new page, a full dashboard swap) rather than one region of it.
+   - **Outcome (1-2 steps, `full_page`).** The result landing back in the real product, in
+     context — proof the feature actually changed something the user will encounter, not just a
+     component in isolation.
 
-4. **Note any setup steps** needed before step 1 is reachable (login, seed data, feature flag)
+   Decision rule when a step doesn't obviously fit: default to `component` — it isolates the
+   thing being demonstrated and reads more clearly at small size. Only use `full_page` for
+   orientation/outcome steps, or when the change genuinely spans the whole viewport (new page,
+   layout shift, multi-panel result) and a cropped shot would lose the point.
+
+4. **Order for narrative sense**: entry point → mechanism → variation → outcome, per the recipe
+   above. Match `content.demo_interaction` in `feature.config.yaml` (one-step reveal, not a
+   scroll dump) — so the order IS the reveal sequence.
+
+5. **Note any setup steps** needed before step 1 is reachable (login, seed data, feature flag)
    — hand these to `:capture` explicitly so it isn't guessing at prerequisites.
 
 ## Output
 
-Hand off to `:capture`: the ordered step list (`step`, `action`, `expected_screen`, `caption`)
-plus any setup/prerequisite steps. This is a draft — `:capture` is expected to correct captions
-or drop steps that don't match what the real app actually shows.
+Hand off to `:capture`: the ordered step list (`step`, `action`, `expected_screen`,
+`capture_scope`, `caption`) plus any setup/prerequisite steps. This is a draft — `:capture` is
+expected to correct captions, adjust `capture_scope` if the planned framing doesn't hold up
+against the real screen, or drop steps that don't match what the real app actually shows.

package/plugins/session-manager-dev/skills/blog-for-project-feature/3-capture/SKILL.md

@@ -6,8 +6,8 @@ description: Step 3 of blog-for-project-feature — drive the REAL running app a
 # blog-for-project-feature:capture
 
 ## Input
-Ordered storyboard steps (`step`, `action`, `expected_screen`, `caption`) + setup steps, from
-`:storyboard`.
+Ordered storyboard steps (`step`, `action`, `expected_screen`, `capture_scope`, `caption`) +
+setup steps, from `:storyboard`.
 
 ## Steps
 
@@ -22,12 +22,21 @@ Ordered storyboard steps (`step`, `action`, `expected_screen`, `caption`) + setu
 3. **For each storyboard step, in order:**
    - Perform the `action` using `mcp__playwright__browser_navigate` /
      `browser_click` / `browser_type` / etc.
-   - Take the screenshot with `mcp__playwright__browser_take_screenshot`.
+   - Take the screenshot per the step's `capture_scope`:
+     - `full_page`: `mcp__playwright__browser_take_screenshot` for the full viewport/page.
+     - `component`: use a `ref`/element target (via `browser_snapshot` to locate the element,
+       then an element-scoped `browser_take_screenshot`) framed to the specific control or
+       region the step calls out — not the whole viewport. If the described element can't be
+       resolved to a single clean region, fall back to `full_page` for that step rather than
+       guessing at a crop.
    - Compare what actually rendered against `expected_screen`. If it matches: keep the step,
-     correct the caption only if something material differs (a number, a label). If it doesn't
-     match at all (error state, feature not reachable, requires access you don't have): **drop
-     this step and record why** — do not screenshot an error page and caption around it, and
-     never substitute a mockup, wireframe, or hand-drawn image for a missing real one.
+     correct the caption only if something material differs (a number, a label). If the planned
+     `capture_scope` doesn't hold up (the "component" is actually two disconnected regions, or a
+     "full_page" shot is so busy the point gets lost), correct `capture_scope` for that step
+     before saving. If the step doesn't match `expected_screen` at all (error state, feature not
+     reachable, requires access you don't have): **drop this step and record why** — do not
+     screenshot an error page and caption around it, and never substitute a mockup, wireframe, or
+     hand-drawn image for a missing real one.
 
 4. **Save images** per `feature.config.yaml`'s `images` block (format, max width, compression) —
    downscale before handing to `:compose`, don't pass raw multi-MB captures through.

package/plugins/session-manager-dev/skills/blog-for-project-feature/6-compose/SKILL.md

@@ -18,15 +18,18 @@ its omission-reason (from `:illustrate`).
    the `folder_fallback_layout` instead (html + `screenshots/` dir, relative paths).
 
 2. **Build the page**, self-contained (inline `<style>`/`<script>`, no external CDN/font/JS
-   requests — must work fully offline via `file://`), with exactly the three required sections
-   in order:
+   requests — must work fully offline via `file://`), with exactly the three required sections,
+   **Click-Through Demo first** — the real screenshots are the most persuasive thing on the page,
+   so they lead, above the fold, before any prose:
+   - **Click-Through Demo** — the captured steps rendered as a one-step-at-a-time viewer
+     (numbered tabs or next/prev buttons — vanilla JS, no framework). Each step's real image
+     renders on top, full width within the viewer, with its caption directly below it — image
+     first, caption second, never the reverse. Screenshots only — the illustration never appears
+     in this section. This section opens the page, immediately above the fold.
    - **Project Mission & Description** — the finalized text from `:draft-copy`, verbatim
    - **Feature Description** — the finalized text from `:draft-copy`, verbatim. If a companion
      illustration exists, place it here as a header/hero image for the section — never inside
      the Click-Through Demo viewer, so it's never confusable with a real screenshot
-   - **Click-Through Demo** — the captured steps rendered as a one-step-at-a-time viewer
-     (numbered tabs or next/prev buttons — vanilla JS, no framework), each step showing its real
-     image + caption. Screenshots only — the illustration never appears in this section
    - If `:illustrate` reported an omission, skip the hero image silently (it's an optional
      companion, not a required section) — do not note the omission on the page itself
 

package/plugins/session-manager-dev/skills/blog-for-project-feature/7-review/SKILL.md

@@ -24,13 +24,16 @@ Check every item in `feature.config.yaml`'s `gates` list against the actual file
 3. Confirm all three required sections are present and non-empty (or explicitly gap-noted per
    `:compose` step 5, which is an acceptable non-empty state). The companion illustration is
    optional — its absence is never a gate failure.
-4. Confirm the demo is genuinely click-through — the next/prev or tab controls exist and their
+4. Confirm the section order matches `feature.config.yaml`'s `content.sections_required` —
+   Click-Through Demo leads the page (above the fold, before the prose sections), each visible
+   step showing its real image on top and the caption directly below it.
+5. Confirm the demo is genuinely click-through — the next/prev or tab controls exist and their
    JS actually switches the visible step (not just a cosmetic active-class flip with all steps
    rendered stacked underneath).
-5. Confirm no external network calls (grep for `http://`/`https://` in `<script src>`,
+6. Confirm no external network calls (grep for `http://`/`https://` in `<script src>`,
    `<link href>`, `fetch(`, `@import` — should be none).
-6. Confirm the size ceiling was respected for the mode chosen.
-7. Spot-check 2-3 sentences in the Mission/Feature sections against `:research`'s notes for
+7. Confirm the size ceiling was respected for the mode chosen.
+8. Spot-check 2-3 sentences in the Mission/Feature sections against `:research`'s notes for
    traceability — flag anything that reads like invented marketing language.
 
 ## On failure

package/plugins/session-manager-dev/skills/blog-for-project-feature/SKILL.md

@@ -74,7 +74,7 @@ project (+ optional feature name)
 |---|---|---|---|
 | 0. `:select` | project (cwd or named) + optional feature hint | one confirmed project + one confirmed feature name + why it's demo-worthy | **STOP** — report if no clear feature can be confirmed (don't guess) |
 | 1. `:research` | confirmed project + feature | mission/description (project-level), feature description, key files, how it actually works | n/a — always produces notes, flags gaps explicitly rather than inventing claims |
-| 2. `:storyboard` | mission + feature notes | ordered list of `{step, action, expected_screen, caption}` — one aspect per step | n/a — storyboard is a draft, `:capture` is allowed to correct it |
+| 2. `:storyboard` | mission + feature notes | ordered list of `{step, action, expected_screen, capture_scope, caption}`, 5-10 steps, a deliberate mix of full-page and component-scoped shots | n/a — storyboard is a draft, `:capture` is allowed to correct it |
 | 3. `:capture` | storyboard | one real screenshot file per step + any corrected captions | **STOP** on that step — report what's missing; never substitute a placeholder/mockup image |
 | 4. `:draft-copy` | research notes + captured captions | final Mission & Feature Description prose + one-sentence essence line | n/a — always produces final text, gaps stay explicit |
 | 5. `:illustrate` | the essence line (text must exist first) | one companion illustration, tagged distinct from screenshots — or an explicit omission note | never blocks — skips cleanly if no image generator is configured, or after one off-brief retry |

package/plugins/session-manager-dev/skills/blog-for-project-feature/feature.config.yaml

@@ -28,6 +28,12 @@ images:
   compression: "reasonable lossy ok for PNG->WebP if it keeps text legible; never so lossy captions become unreadable"
   source_of_truth: "mcp__playwright__browser_take_screenshot against a real running instance"
   placeholder_or_mockup_images: forbidden   # a dropped step beats a fabricated one
+  capture_scope: "full_page | component, chosen per step in :storyboard and executed in :capture.
+    Full-page screenshots are not always the clearest way to show a feature — a control or state
+    change is often clearer cropped to just that component. Default to component-scoped shots for
+    mechanism/detail steps; reserve full_page for orientation (where the feature lives) and
+    outcome (the result landing back in the real product) steps. See :storyboard's composition
+    recipe for the authoritative mix."
 
 illustration:
   # The ONE companion image, generated by :illustrate — a distinct image class from the
@@ -49,10 +55,13 @@ illustration:
 
 content:
   sections_required:
+    # Order matters: this IS the on-page order, top to bottom.
+    - "Click-Through Demo"              # LEADS the page — the storyboard steps, one aspect
+                                         # revealed at a time; screenshot on top, caption below
     - "Project Mission & Description"   # 2-4 sentences, from :research, project-level not feature-level
     - "Feature Description"             # what it does, why it matters, 1-2 short paragraphs
-    - "Click-Through Demo"              # the storyboard steps, one aspect revealed at a time
-  demo_interaction: "one-step-at-a-time reveal (next/prev controls or numbered tabs) — never a single long scroll dump of every screenshot at once"
+  demo_interaction: "one-step-at-a-time reveal (next/prev controls or numbered tabs) — never a single long scroll dump of every screenshot at once. Each step: real image on top, caption directly below it."
+  demo_step_count: "5-10 steps (a mix of full_page and component-scoped captures — see :storyboard's composition recipe), not a flat full-page-per-step dump"
   tone: "same plain, non-salesy, show-don't-tell bar as blog-from-git/voice.md bot-tell blocklist — no 'excited to share', no grand-implication filler"
   caption_rule: "every screenshot has a one-sentence caption naming what changed on screen, not what the code does internally"
 

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

@@ -9,7 +9,7 @@
 
 'use strict';
 
-import { test, expect } from 'vitest';
+import { test, expect, vi } from 'vitest';
 const fs = require('node:fs');
 const fsp = require('node:fs/promises');
 const os = require('node:os');
@@ -22,6 +22,7 @@ const {
   STANDARDS_PATH,
   PRD_CREATE_SLUG_RE,
   registerAdminRoute,
+  createPrd,
 } = require('../lib/prdCreate.cjs');
 const { createAdminHttp } = require('../lib/localAdminHttp.cjs');
 const config = require('../config.cjs');
@@ -338,6 +339,59 @@ test('POST /admin/scheduler/create-prd honors an explicit slug + parallelGroup i
   }
 });
 
+// ──────────────────────────────────────────── createPrd() (chat:create-prd IPC handler, PRD 749 follow-up)
+//
+// createPrd() is the function ipcMain.handle('chat:create-prd', ...) in
+// index.cjs calls directly (in-process, no HTTP) — same function
+// registerAdminRoute's HTTP handler calls above. These tests exercise it
+// directly, mirroring the handler's own call shape: createPrd(input, remote).
+
+test('createPrd rejects a cwd outside allowedRoots before any write, returning {ok:false, status:400}', async () => {
+  const prdsDir = await mkTmpPrdsDir();
+  const remote = makeFakeRemoteWithPrdsDir(prdsDir);
+  const writePrdSpy = vi.fn(remote.writePrd);
+  remote.writePrd = writePrdSpy;
+
+  const result = await createPrd(validCreateBody({ cwd: '/etc/passwd-adjacent-outside-home' }), remote);
+
+  expect(result.ok).toBe(false);
+  expect(result.status).toBe(400);
+  expect(writePrdSpy).not.toHaveBeenCalled();
+  const entries = await fsp.readdir(prdsDir);
+  expect(entries.filter((f) => f.endsWith('.md')).length).toBe(0);
+});
+
+test('createPrd with a valid payload allocates a group, writes through remote.writePrd, and returns {ok:true, nn, filename}', async () => {
+  const prdsDir = await mkTmpPrdsDir();
+  const remote = makeFakeRemoteWithPrdsDir(prdsDir);
+
+  const result = await createPrd(validCreateBody({ sourcePromptId: 'ticket-abc', sourceTabId: 'tab-1' }), remote);
+
+  expect(result.ok).toBe(true);
+  expect(typeof result.nn).toBe('number');
+  expect(result.filename).toMatch(/^\d+-add-widget-frobnication\.md$/);
+
+  const written = await fsp.readFile(path.join(prdsDir, result.filename), 'utf8');
+  expect(written).toMatch(/^---\n/);
+  expect(written).toMatch(/title: Add widget frobnication/);
+  expect(written).toMatch(/sourcePromptId: ticket-abc/);
+  expect(written).toMatch(/sourceTabId: tab-1/);
+  expect(written).toMatch(/# Goal/);
+});
+
+test('createPrd returns {ok:false, status:409} without clobbering an existing file at the same destination', async () => {
+  const prdsDir = await mkTmpPrdsDir();
+  const remote = makeFakeRemoteWithPrdsDir(prdsDir);
+  await fsp.writeFile(path.join(prdsDir, '777-my-explicit-slug.md'), 'ORIGINAL CONTENT\n');
+
+  const result = await createPrd(validCreateBody({ slug: 'my-explicit-slug', parallelGroup: 777 }), remote);
+
+  expect(result.ok).toBe(false);
+  expect(result.status).toBe(409);
+  const stillThere = await fsp.readFile(path.join(prdsDir, '777-my-explicit-slug.md'), 'utf8');
+  expect(stillThere).toBe('ORIGINAL CONTENT\n');
+});
+
 test('POST /admin/scheduler/create-prd with sourcePromptId writes it into the created PRD frontmatter', async () => {
   const prdsDir = await mkTmpPrdsDir();
   const remote = makeFakeRemoteWithPrdsDir(prdsDir);

package/src/main/__tests__/queueOps-interactive-ac-lint.test.cjs

@@ -0,0 +1,65 @@
+/**
+ * queueOps-interactive-ac-lint.test.cjs — lint for AC checkboxes that
+ * instruct an interactive/GUI-rendering step (xvfb-run, playwright test,
+ * electron.launch, screenshot, ...) that a headless claude -p executor can
+ * never satisfy (see the 776/779 exit143 incidents, 2026-07-30). Must key off
+ * AC-checkbox context specifically — a PRD's Out-of-scope/notes prose telling
+ * the executor NOT to do this (PRDs 780/787/788's pattern) must not trigger.
+ *
+ * Run: timeout 120 npx vitest run src/main/__tests__/queueOps-interactive-ac-lint.test.cjs
+ */
+
+'use strict';
+
+import { test, expect } from 'vitest';
+const fs = require('node:fs');
+const os = require('node:os');
+const path = require('node:path');
+const { lintOneAsync } = require('../queueOps.cjs');
+
+function writeTmpPrd(body) {
+  const dir = fs.mkdtempSync(path.join(os.tmpdir(), 'sm-lint-interactive-'));
+  const p = path.join(dir, 'test-prd.md');
+  const raw = `---\ntitle: "test"\ncwd: ~\nestimateMinutes: 10\n---\n\n${body}\n`;
+  fs.writeFileSync(p, raw, 'utf8');
+  return p;
+}
+
+test('flags a PRD with xvfb-run as an AC checkbox line', async () => {
+  const p = writeTmpPrd(
+    '# Acceptance criteria\n\n- [ ] `xvfb-run -a npx playwright test tests/e2e/foo.spec.ts` passes\n',
+  );
+  const { findings } = await lintOneAsync(p);
+  expect(findings.some((f) => f.rule === 'interactive-xvfb')).toBe(true);
+});
+
+test('flags a PRD with playwright electron.launch as an AC checkbox line', async () => {
+  const p = writeTmpPrd(
+    '# Acceptance criteria\n\n- [ ] Playwright `electron.launch` boots the app and captures a screenshot of the Scheduler tab\n',
+  );
+  const { findings } = await lintOneAsync(p);
+  expect(findings.some((f) => f.rule === 'interactive-electron-launch')).toBe(true);
+});
+
+test('does NOT flag Out-of-scope/notes prose that mentions xvfb without being a checkbox line', async () => {
+  const p = writeTmpPrd(
+    '# Acceptance criteria\n\n- [ ] `timeout 300 npm run typecheck` passes\n' +
+    '- [ ] `timeout 300 npx vitest run src/foo.test.ts` passes\n\n' +
+    'NOTE: do NOT add a `playwright test ... under xvfb` acceptance criterion here. Two prior\n' +
+    'links in this chain stalled and were SIGTERM\'d (exit 143) on exactly that step — a headless\n' +
+    '`claude -p` executor spawning `xvfb-run`/Playwright hits a tool-use rejection and hangs.\n\n' +
+    '# Out of scope\n\n' +
+    '- Making xvfb-run/Playwright actually work inside a headless claude -p job — out of scope\n',
+  );
+  const { findings } = await lintOneAsync(p);
+  expect(findings.filter((f) => f.rule.startsWith('interactive-')).length).toBe(0);
+});
+
+test('a clean PRD with only typecheck/vitest AC is not flagged', async () => {
+  const p = writeTmpPrd(
+    '# Acceptance criteria\n\n- [ ] `timeout 300 npm run typecheck` passes\n' +
+    '- [ ] `timeout 300 npx vitest run src/foo.test.ts` passes\n',
+  );
+  const { findings } = await lintOneAsync(p);
+  expect(findings.filter((f) => f.rule.startsWith('interactive-')).length).toBe(0);
+});

package/src/main/__tests__/scheduler-sigterm-commit.test.cjs

@@ -0,0 +1,43 @@
+/**
+ * scheduler-sigterm-commit.test.cjs — a run SIGTERM'd (exit 143) mid an
+ * interactive/headless-incompatible AC step (xvfb Electron screenshot,
+ * playwright electron.launch — see the 776/779 incidents, 2026-07-30) can
+ * still have landed its deliverable commit before it died. classifySigtermWithCommit
+ * decides whether that run should be routed to needs_review (commit found —
+ * a human should verify the rest of the AC) instead of staying `failed`
+ * forever, without ever silently auto-promoting to `completed`.
+ *
+ * Run: timeout 120 npx vitest run src/main/__tests__/scheduler-sigterm-commit.test.cjs
+ */
+
+'use strict';
+
+import { test, expect } from 'vitest';
+const { classifySigtermWithCommit } = require('../scheduler.cjs');
+
+test('classifySigtermWithCommit: exit 143 + commit found in window → needs_review', () => {
+  const decision = classifySigtermWithCommit(143, true);
+  expect(decision.status).toBe('needs_review');
+  expect(decision.reason).toMatch(/SIGTERM/);
+  expect(decision.reason).toMatch(/verify AC/i);
+});
+
+test('classifySigtermWithCommit: exit 143 + no commit found in window → still failed (regression check)', () => {
+  const decision = classifySigtermWithCommit(143, false);
+  expect(decision).toBeNull();
+});
+
+test('classifySigtermWithCommit: exit 1 (non-143 code) is unaffected even with a commit found', () => {
+  const decision = classifySigtermWithCommit(1, true);
+  expect(decision).toBeNull();
+});
+
+test('classifySigtermWithCommit: exit 137 (SIGKILL) is unaffected — scoped narrowly to 143', () => {
+  const decision = classifySigtermWithCommit(137, true);
+  expect(decision).toBeNull();
+});
+
+test('classifySigtermWithCommit: exit 0 is unaffected', () => {
+  const decision = classifySigtermWithCommit(0, true);
+  expect(decision).toBeNull();
+});

package/src/main/index.cjs

@@ -12,8 +12,8 @@ const browserView = require('./browserView.cjs');
 const browserCapture = require('./browserCapture.cjs');
 const configMgr = require('./config.cjs');
 const transcripts = require('./transcripts.cjs');
-const usageMatrix = require('./usageMatrix.cjs');
 const sessionsStore = require('./sessionsStore.cjs');
+const layoutStore = require('./layoutStore.cjs');
 const billing = require('./usage.cjs');
 const { probeMcpStatus } = require('./mcpStatus.cjs');
 const logs = require('./logs.cjs');
@@ -55,12 +55,10 @@ const memoryTool = require('./memoryTool.cjs');
 const { registerMemoryAggregateIpc } = require('./memoryAggregate.cjs');
 const agentMemory = require('./agentMemory.cjs');
 const git = require('./git.cjs');
-const superagent = require('./superagent.cjs');
 const filesIpc = require('./files.cjs');
 const { registerDocEditHandlers, attachWindow: attachDocEditWindow } = require('./docEdit.cjs');
 const searchIpc = require('./search.cjs');
 const repoAnalyzer = require('./repoAnalyzer.cjs');
-const hivesIpc = require('./hives.cjs');
 const webRemote = require('./webRemote.cjs');
 const { listExchanges } = require('./exchanges.cjs');
 const { resolveClaudeBin } = require('./lib/claudeBin.cjs');
@@ -298,7 +296,6 @@ async function rebootApp() {
     ptyManager.attachWindow(mainWindow);
     configMgr.attachWindow(mainWindow);
     transcripts.attachWindow(mainWindow);
-    usageMatrix.attachWindow(mainWindow);
     browserView.attachWindow(mainWindow);
     browserCapture.attachWindow(mainWindow);
     voiceHotkey.init(mainWindow).catch((e) => {
@@ -307,7 +304,6 @@ async function rebootApp() {
     scheduler.attachWindow(mainWindow);
     watchers.attachWindow(mainWindow);
     pluginInstall.attachWindow(mainWindow);
-    superagent.attachWindow(mainWindow);
     chatRunner.attachWindow(mainWindow);
     attachDocEditWindow(mainWindow);
     rebooting = false;
@@ -755,8 +751,8 @@ ipcMain.handle('app:archive-project', validated(schemas.archiveProject, async ({
 registerPtyHandlers();
 configMgr.registerConfigHandlers();
 transcripts.registerTranscriptHandlers();
-usageMatrix.registerHandlers();
 sessionsStore.registerSessionsHandlers();
+layoutStore.registerLayoutHandlers();
 billing.registerBillingHandlers();
 logs.registerLogHandlers();
 voiceHotkey.registerHotkeyHandlers();
@@ -772,15 +768,21 @@ memoryTool.registerMemoryHandlers();
 registerMemoryAggregateIpc();
 agentMemory.registerAgentMemoryHandlers();
 git.register(ipcMain);
-superagent.registerSuperAgentHandlers();
 filesIpc.registerFilesHandlers();
 registerDocEditHandlers();
 searchIpc.registerSearchHandlers();
 repoAnalyzer.register(ipcMain);
-hivesIpc.registerHiveHandlers();
 webRemote.registerRemoteHandlers();
 chatRunner.registerChatHandlers();
 
+// Direct in-process PRD authoring for a queued PromptTicket classified
+// 'develop' (PRD 749 follow-up) — calls the same createPrd() the admin HTTP
+// route (prdCreate.registerAdminRoute above) and the MCP tool use, just
+// in-process instead of over localAdminHttp.cjs.
+ipcMain.handle('chat:create-prd', validated(schemas.schedulerCreatePrd, async (input) => {
+  return prdCreate.createPrd(input, scheduler.remote);
+}));
+
 // Exchanges: read the durable per-exchange log (written by chatRunner → recordExchange).
 ipcMain.handle('exchanges:list', validated(schemas.exchangesList, async (payload) => {
   try {
@@ -1073,7 +1075,6 @@ app.whenReady().then(async () => {
   ptyManager.attachWindow(mainWindow);
   configMgr.attachWindow(mainWindow);
   transcripts.attachWindow(mainWindow);
-  usageMatrix.attachWindow(mainWindow);
   browserView.registerBrowserView({ mainWindow, ipcMain });
   browserCapture.attachWindow(mainWindow);
   browserCapture.registerBrowserCapture({ ipcMain, getView: browserView.getView });
@@ -1083,7 +1084,6 @@ app.whenReady().then(async () => {
   scheduler.attachWindow(mainWindow);
   watchers.attachWindow(mainWindow);
   pluginInstall.attachWindow(mainWindow);
-  superagent.attachWindow(mainWindow);
   webRemote.attachWindow(mainWindow);
   chatRunner.attachWindow(mainWindow);
   attachDocEditWindow(mainWindow);

package/src/main/ipcSchemas.cjs

@@ -204,6 +204,19 @@ const sessionsPayload = z.object({
   activeTabId: z.string().max(128).nullable(),
 });
 
+// ──────────────────────────────────────────── Workbench layout
+// layout:save envelope — validated at the shape level only (version + panel
+// id list); `dockview` is dockview's own opaque SerializedDockview blob and
+// is intentionally z.unknown() so a dockview library upgrade never fails
+// validation on a shape this schema doesn't know about. Zero-panel layouts
+// are refused here too (defense in depth — the renderer serializer already
+// refuses to call save() with an empty panels list).
+const layoutEnvelope = z.object({
+  version: z.number().int().min(1),
+  panels: z.array(z.string().min(1).max(128)).min(1).max(64),
+  dockview: z.record(z.string(), z.unknown()),
+}).strict();
+
 // ──────────────────────────────────────────── Schedule
 const SCHEDULE_SLUG_RE = /^[A-Za-z0-9._-]{1,128}$/;
 const SCHEDULE_RUN_ID_RE = /^[A-Za-z0-9._:-]{1,64}$/;
@@ -261,6 +274,9 @@ 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(),
+  // User-selected Feature/Bug tag (PRD 774) carried from the originating
+  // PromptTicket — deterministic, never LLM-classified.
+  tag: z.enum(['feature', 'bug']).optional(),
 });
 
 // Bulk archive: slug list, capped to limit unbounded retag/archive payloads.
@@ -620,20 +636,6 @@ const pluginsAbort = z.object({
   slug: z.string().regex(PLUGIN_SLUG_RE).min(1).max(128),
 }).passthrough();
 
-// SuperAgent — "boss" run that writes a structured prompt to the active
-// tab's PTY. Bounds match the inline schemas in superagent.cjs; centralizing
-// here so the schema is the boundary fence rather than each handler.
-const superagentStart = z.object({
-  tabId: z.string().min(1).max(128),
-  prompt: z.string().min(1).max(8 * 1024),
-  specialistCount: z.number().int().min(1).max(8),
-  depth: z.enum(['quick', 'standard', 'deep']),
-}).strict();
-
-const superagentTabId = z.object({
-  tabId: z.string().min(1).max(128),
-}).strict();
-
 /**
  * Wrap an IPC handler with schema validation. Returns a new handler that
  * parses the payload before calling the original. On invalid payload throws
@@ -747,6 +749,7 @@ module.exports = {
     configListDir,
     configWatch,
     sessionsPayload,
+    layoutEnvelope,
     scheduleSlug,
     scheduleReadLog,
     scheduleWritePrd,
@@ -769,8 +772,6 @@ module.exports = {
     repoAnalyze,
     pluginsInstall,
     pluginsAbort,
-    superagentStart,
-    superagentTabId,
     memoryList,
     memoryRead,
     memoryWrite,

package/src/main/layoutStore.cjs

@@ -0,0 +1,58 @@
+/**
+ * LayoutStore — persists the Workbench's ONE system dockview layout so
+ * resizes/splits survive an electron restart.
+ *
+ * Storage: ~/.claude/session-manager/workbench-layout.json
+ * Shape: { version: number, panels: string[], dockview: object, savedAt: number }
+ *
+ * `dockview` is dockview's own opaque `SerializedDockview` blob (from
+ * `api.toJSON()`) — only the envelope (version + panels list) is validated
+ * here; the blob itself is round-tripped verbatim so a dockview library
+ * upgrade never bricks a saved layout. Unknown-panel pruning against the
+ * live screen registry happens renderer-side (main has no knowledge of the
+ * NavKey registry) before `api.fromJSON()` is called.
+ */
+
+const fsp = require('node:fs/promises');
+const path = require('node:path');
+const os = require('node:os');
+const { ipcMain } = require('electron');
+const config = require('./config.cjs');
+
+function storePath() {
+  return path.join(os.homedir(), '.claude', 'session-manager', 'workbench-layout.json');
+}
+
+async function load() {
+  const p = storePath();
+  try {
+    const raw = await fsp.readFile(p, 'utf8');
+    const data = JSON.parse(raw);
+    if (!data || typeof data !== 'object' || !Array.isArray(data.panels) || !data.dockview) {
+      console.warn('[layoutStore] load: malformed shape, ignoring');
+      return null;
+    }
+    return {
+      version: typeof data.version === 'number' ? data.version : 1,
+      panels: data.panels,
+      dockview: data.dockview,
+    };
+  } catch (e) {
+    if (e.code !== 'ENOENT') console.warn('[layoutStore] load failed:', e.message);
+    return null;
+  }
+}
+
+async function save({ version, panels, dockview }) {
+  const payload = { version, panels, dockview, savedAt: Date.now() };
+  await config.writeJson(storePath(), payload);
+  return { ok: true };
+}
+
+function registerLayoutHandlers() {
+  const { schemas: s, validated: v } = require('./ipcSchemas.cjs');
+  ipcMain.handle('layout:load', () => load());
+  ipcMain.handle('layout:save', v(s.layoutEnvelope, (payload) => save(payload)));
+}
+
+module.exports = { registerLayoutHandlers, load, save, storePath };