claude-code-session-manager 0.38.7 → 0.39.1

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-DPSmbyU_.js"></script>
+    <script type="module" crossorigin src="./assets/index-CefVSjmm.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-BGTU12rl.css">
+    <link rel="stylesheet" crossorigin href="./assets/index-B6JNrbpD.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.7",
+  "version": "0.39.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/plugins/session-manager-dev/skills/develop/SKILL.md

@@ -77,8 +77,9 @@ can't load skills.
    do they actually share the same shape, or only look similar — confirm by reading, don't
    assume: a wrong assumption here means an inaccurate PRD, discovered only after the executor
    runs it), check existing tests for the area, and check whether a prior PRD already touched
-   this subsystem (`ls ~/.claude/session-manager/scheduled-plans/prds/` for related slugs) —
-   duplicating or contradicting a still-queued PRD is a real failure mode, not a hypothetical one.
+   this subsystem (`ls <cwd>/session-manager-operations/scheduler/prds/` for related slugs, in
+   the target repo) — duplicating or contradicting a still-queued PRD is a real failure mode,
+   not a hypothetical one.
 
 3. **Analyze the request through five named lenses, draft a candidate decomposition, then run
    a completeness pass before finalizing it.** This step exists because small, bounded individual
@@ -193,17 +194,19 @@ can't load skills.
    (the session-manager Electron app must be running for this MCP tool to work; if it isn't,
    don't block on it): compute the highest in-use number deterministically yourself — never
    eyeball or narrow-grep the `ls` (a narrowed pattern like `'^10[0-9]'` silently misses `110+`
-   and collides):
+   and collides). PRDs are stored per-project, so `NN` allocation for a given PRD only needs
+   *that project's own* prds directory scanned — not every project's:
    ```bash
-   ls ~/.claude/session-manager/scheduled-plans/prds/ | grep -oE '^[0-9]+' | sort -n | uniq | tail -5
+   ls <cwd>/session-manager-operations/scheduler/prds/ | grep -oE '^[0-9]+' | sort -n | uniq | tail -5
    ```
-   The last line is the current max. Then: same `NN` as a logically independent sibling that
-   can run in parallel; **next free `NN` = max+1** when this PRD hard-depends on prior work or
-   is unrelated to every existing group. This manual path has a small, accepted race (two
-   concurrent authors could compute the same "next free" `NN`) — cosmetic (two unrelated groups
-   end up sharing a number) rather than destructive, and only reachable when the atomic tool
-   path above isn't available. Record each cross-PRD dependency in the dependent PRD's notes
-   either way.
+   (`<cwd>` is the target repo's absolute path — the same one this PRD's `cwd` field will use.)
+   The last line is the current max within that project. Then: same `NN` as a logically
+   independent sibling that can run in parallel; **next free `NN` = max+1** when this PRD
+   hard-depends on prior work or is unrelated to every existing group. This manual path has a
+   small, accepted race (two concurrent authors could compute the same "next free" `NN`) —
+   cosmetic (two unrelated groups end up sharing a number) rather than destructive, and only
+   reachable when the atomic tool path above isn't available. Record each cross-PRD dependency
+   in the dependent PRD's notes either way.
 
    ### PRD structure and location
 
@@ -215,15 +218,19 @@ can't load skills.
    system that runs `claude -p <prd-body> --dangerously-skip-permissions` jobs around 5-hour
    token-window resets, with auto-pause on rate-limit and auto-resume.
 
-   **Canonical location — non-negotiable.** PRDs MUST be written to:
+   **Canonical location — non-negotiable.** PRDs MUST be written to, inside the target repo:
    ```
-   ~/.claude/session-manager/scheduled-plans/prds/<NN>-<kebab-slug>.md
+   <cwd>/session-manager-operations/scheduler/prds/<NN>-<kebab-slug>.md
    ```
    **Anywhere else doesn't get scheduled.** If you write to `data/prds/`, `docs/prds/`, or the
-   project root, the scheduler will not see it and the user loses their token-budget-managed
-   execution. There is exactly one queue for all projects — that's intentional, because the
-   5-hour token budget is global across all of the user's Claude work. The `~` expands to
-   `os.homedir()` so the same convention works for any user on any machine.
+   old, now-retired global `prds/` dir under `~/.claude/session-manager/scheduled-plans/`,
+   the scheduler will not see it and the user loses their token-budget-managed execution. PRD
+   *source* files are per-project — each active project's own
+   `session-manager-operations/scheduler/prds/` directory, resolved at runtime from active
+   session cwds (`src/main/lib/prdLocations.cjs`) — but there is still exactly one **queue**
+   across all projects (`queue.json`/`history.jsonl`/`runs/` under
+   `~/.claude/session-manager/scheduled-plans/` remain global bookkeeping), because the 5-hour
+   token budget is global across all of the user's Claude work.
 
    **Filename rules.** `NN` is the 2-digit zero-padded parallel group (picked per the `ls`
    command above — same `NN` as an independent sibling, or next free `NN` = max+1 when this PRD

package/plugins/session-manager-dev/skills/develop/standards.md

@@ -85,6 +85,7 @@ Data-driven from 400+ scheduler runs: long hangs (not bad code) are the dominant
 - **You ARE the executor — never re-queue or self-schedule.** A headless PRD run must perform its own acceptance criteria directly. Do NOT invoke `/develop`, `/process-feedback`, or any queue-authoring skill from inside a run — those are interactive main-loop skills that author a *new* PRD and return, so the run exits 0 having done nothing (no commit, no sentinel → `needs_review` with `no_verdict_sentinel`). Do NOT call `ScheduleWakeup`/set a tracking loop either — the process exits when the run ends and nothing re-invokes it. This applies just as much to spawning your own review agents and waiting on them: do NOT invoke `/code-review`, `/security-review`, `requesting-code-review`, or any other skill/subagent as a background/async step and then end your turn with something like "I'll wait for the review agents to complete" — a headless run has no next turn, so that line is the run's last output, no verdict sentinel prints, and the job parks in `needs_review` even though the actual work already landed. If a PRD's acceptance criteria call for a second review pass, run it **synchronously, inline, before the finish protocol** — call the reviewer and read its result in the same turn, don't fire-and-wait. If the PRD's work looks large, decompose and execute it inline within this run; never delegate it back to the queue. (Incidents: PRD 460 invoked `/develop`, spawned a duplicate PRD 461, and exited 0 with no work. PRD 479 landed its commit correctly but then backgrounded `/code-review --fix` + `/security-review` and called `ScheduleWakeup` to "wait" for them — same class of failure, different entry point.)
 - **A shared-repo `cwd` can be occupied by a concurrent job — check before you touch shared state.** When a PRD's `cwd` is a repo other headless runs may also target (a shared team repo like sigma, not a private single-purpose project), a `git checkout`/`gh pr checkout` can land you in another job's live worktree with its own uncommitted WIP. Before running `git stash`, `git reset`, or any command that discards or hides working-tree state, check `git stash list` and `git status` first, and if you must set aside pre-existing uncommitted changes that aren't yours, **stash with a descriptive message** (`git stash push -m "pre-existing WIP found by PRD <NN>, not mine"`) and **restore it before your run ends** (or, if you can't safely restore because your own commit depends on that worktree state, leave it stashed with the message and say so explicitly in your finish output — never let the run end silently dropping someone else's stash). Never `git stash drop`/`git clean -fd` on state you didn't create. (Incident: PRD 477 stashed a concurrent job's rAF-throttle-revert WIP to get its own checkout, finished, and exited without restoring it — orphaning the other job's uncommitted work in `stash@{0}` with no record of whose it was.)
 - **`gh pr edit --body` can fail on repos with legacy GitHub Projects (classic) boards** — the underlying GraphQL query fetches `repository.pullRequest.projectCards`, a field GitHub is sunsetting, and errors with `GraphQL: Projects (classic) is being deprecated ... (repository.pullRequest.projectCards)` even though the edit itself would otherwise succeed. This is a known `gh` CLI quirk, not a defect in your work. Prefer `gh api -X PATCH repos/<owner>/<repo>/pulls/<n> -f body="$(cat body.md)"` for updating a PR description headlessly — it doesn't touch the deprecated field. If you do use `gh pr edit` and it fails this way, don't leave the bare GraphQL error as the last thing in that step (it reads as an unrecovered error in the final-20%-of-transcript verifier heuristic): immediately retry with the `gh api` form and print one line noting the known-bug fallback, so the recovery is adjacent to the error.
+- **`gh pr checks`/`gh run watch` exit non-zero while CI is merely *pending*, not failed — don't let that surface as a bare error.** Polling `gh pr checks <n>` before checks finish returns a non-zero exit (e.g. 8) with output like `check  pending  0  <url>` — this is normal, documented `gh` CLI behavior, not a failure. If you retry with a *differently-worded* command (e.g. dropping a `sleep N &&` prefix, or switching to `gh run watch <id> --exit-status`), the verifier's self-recovery detector pairs retries by exact command-description match and may not recognize the differently-worded retry as the same recovery, leaving the original pending-state error looking unrecovered in the transcript (incident: `745-pr188-ci-lint-docs-integrity`, a fully green, committed, pushed run flagged `needs_review` over exactly this). Prefer polling with the *same* command/description each time (e.g. loop `gh pr checks <n>` unchanged, or use `gh run watch <id> --exit-status` from the start rather than switching mid-poll) so a later success is recognized as recovering the earlier pending-state failure.
 - **Negative-assertion checks must exit 0 when clean.** A check that verifies the *absence* of something (a `grep` that should find nothing, "no leftover X", `diff` expecting no change) must return exit 0 on the clean case. A bare `grep` exits **1 on no-match** — so the *success* path surfaces as `is_error=true` and the verifier downgrades a perfect run to `needs_review`. Always invert: `if <detector>; then echo "HALT: <what was found>"; exit 1; fi; echo clean`. Never let the no-match/empty path carry the non-zero exit.
 - **Recover or annotate every error — don't strand a Traceback in the transcript.** The verifier downgrades an otherwise-perfect run to `needs_review` when a `Traceback`/`Error` appears with *no visible recovery within ~10 lines* (the `transcript_errors` heuristic — the single most common false-positive on green deliverables). Two executor habits cause it: (1) **throwaway probes that error** — an inline `python -c` with a quoting/f-string slip, a wrong kwarg, a bad path. When a probe errors, immediately re-run the corrected version *or* print one line `# expected/handled: <why>` right after, so recovery is adjacent. Don't move on leaving a bare error as the last thing in that step. Prefer a small temp `.py` file over a fragile multi-quote `python -c` one-liner (inline f-string errors are the top source of stranded tracebacks). (2) See the timeout rule below.
 - **An *expected* bounded-timeout (exit 124) must be annotated, not bare.** `timeout`-capping a genuinely long task you expect to hit the cap (a full-universe ingest, a long scan) is correct — but a bare `Exit code 124` reads as a failure to the verifier. Wrap it so the cap is a success-with-note: `timeout 120 <cmd> || { rc=$?; [ $rc -eq 124 ] && echo "hit time cap — idempotent/partial, rows persist incrementally; OK" || { echo "HALT: <cmd> failed rc=$rc"; exit 1; }; }`. (Distinguish 124 = expected cap from a real non-zero.) For work that legitimately needs longer than a safe cap, run it in the background and poll a bounded number of times rather than capping the foreground command.

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

@@ -0,0 +1,56 @@
+/**
+ * prdLocations.test.cjs — unit tests for prdLocations.cjs's per-project PRD
+ * directory resolution (PRD 808).
+ *
+ * Run: timeout 120 npx vitest run src/main/__tests__/prdLocations.test.cjs
+ */
+
+'use strict';
+
+import { test, expect, afterEach } from 'vitest';
+const fs = require('node:fs');
+const fsp = require('node:fs/promises');
+const os = require('node:os');
+const path = require('node:path');
+const { resolvePrdWriteDir, resolvePrdsDirs } = require('../lib/prdLocations.cjs');
+
+const tmpDirs = [];
+afterEach(async () => {
+  while (tmpDirs.length) {
+    const d = tmpDirs.pop();
+    await fsp.rm(d, { recursive: true, force: true });
+  }
+});
+
+test('resolvePrdWriteDir joins the project-scoped PRDs subpath onto cwd', () => {
+  expect(resolvePrdWriteDir('/home/user/Projects/foo')).toBe(
+    path.join('/home/user/Projects/foo', 'session-manager-operations', 'scheduler', 'prds'),
+  );
+});
+
+test('resolvePrdWriteDir throws on a missing cwd', () => {
+  expect(() => resolvePrdWriteDir()).toThrow();
+  expect(() => resolvePrdWriteDir('')).toThrow();
+});
+
+test('resolvePrdsDirs maps each active project cwd to its own PRDs dir', async () => {
+  const projectsDir = await fsp.mkdtemp(path.join(os.tmpdir(), 'sm-prdlocations-projects-'));
+  tmpDirs.push(projectsDir);
+  const projectCwd = await fsp.mkdtemp(path.join(os.tmpdir(), 'sm-prdlocations-cwd-'));
+  tmpDirs.push(projectCwd);
+
+  const slug = 'abc123';
+  const projDir = path.join(projectsDir, slug);
+  fs.mkdirSync(projDir, { recursive: true });
+  const transcript = path.join(projDir, 'session1.jsonl');
+  fs.writeFileSync(transcript, `${JSON.stringify({ cwd: projectCwd })}\n`);
+
+  const dirs = resolvePrdsDirs(90, { projectsDir });
+  expect(dirs).toEqual([resolvePrdWriteDir(projectCwd)]);
+  expect(dirs[0].endsWith(path.join('session-manager-operations', 'scheduler', 'prds'))).toBe(true);
+});
+
+test('resolvePrdsDirs returns [] when no project has a recent transcript', () => {
+  const dirs = resolvePrdsDirs(90, { projectsDir: '/nonexistent-projects-dir' });
+  expect(dirs).toEqual([]);
+});

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

@@ -0,0 +1,126 @@
+/**
+ * prdMigration.test.cjs — unit tests for the one-time PRD-relocation
+ * migration (PRD 808): moves legacy-global PRD .md files into their own
+ * project's `<cwd>/session-manager-operations/scheduler/prds/`, based on
+ * each file's frontmatter `cwd`.
+ *
+ * Run: timeout 120 npx vitest run src/main/__tests__/prdMigration.test.cjs
+ */
+
+'use strict';
+
+import { test, expect, afterEach } from 'vitest';
+const fs = require('node:fs');
+const fsp = require('node:fs/promises');
+const os = require('node:os');
+const path = require('node:path');
+const { migratePrds } = require('../lib/prdMigration.cjs');
+const { resolvePrdWriteDir } = require('../lib/prdLocations.cjs');
+
+const tmpDirs = [];
+afterEach(async () => {
+  while (tmpDirs.length) {
+    const d = tmpDirs.pop();
+    await fsp.rm(d, { recursive: true, force: true });
+  }
+});
+
+async function mkLegacyDir() {
+  const dir = await fsp.mkdtemp(path.join(os.tmpdir(), 'sm-prdmigration-legacy-'));
+  tmpDirs.push(dir);
+  return dir;
+}
+
+async function mkProjectCwd() {
+  const dir = await fsp.mkdtemp(path.join(os.tmpdir(), 'sm-prdmigration-cwd-'));
+  tmpDirs.push(dir);
+  return dir;
+}
+
+test('migratePrds moves a PRD whose frontmatter cwd resolves to an on-disk project', async () => {
+  const legacyDir = await mkLegacyDir();
+  const projectCwd = await mkProjectCwd();
+  const body = `---\ntitle: Do the thing\ncwd: ${projectCwd}\nestimateMinutes: 15\n---\n\n# Goal\n\nDo it.\n`;
+  await fsp.writeFile(path.join(legacyDir, '01-do-thing.md'), body, 'utf8');
+
+  const result = await migratePrds(legacyDir);
+
+  expect(result.moved).toBe(1);
+  expect(result.unresolved).toEqual([]);
+  expect(fs.existsSync(path.join(legacyDir, '01-do-thing.md'))).toBe(false);
+  const dest = path.join(resolvePrdWriteDir(projectCwd), '01-do-thing.md');
+  expect(fs.existsSync(dest)).toBe(true);
+  expect(await fsp.readFile(dest, 'utf8')).toBe(body);
+});
+
+test('migratePrds is idempotent — a second run over an already-migrated dir is a no-op', async () => {
+  const legacyDir = await mkLegacyDir();
+  const projectCwd = await mkProjectCwd();
+  const body = `---\ntitle: Do the thing\ncwd: ${projectCwd}\nestimateMinutes: 15\n---\n\nBody.\n`;
+  await fsp.writeFile(path.join(legacyDir, '02-do-thing.md'), body, 'utf8');
+
+  await migratePrds(legacyDir);
+  const second = await migratePrds(legacyDir);
+
+  expect(second.moved).toBe(0);
+  expect(second.unresolved).toEqual([]);
+});
+
+test('migratePrds leaves a file with no cwd in frontmatter in place and reports it unresolved', async () => {
+  const legacyDir = await mkLegacyDir();
+  const body = `---\ntitle: No cwd here\nestimateMinutes: 15\n---\n\nBody.\n`;
+  await fsp.writeFile(path.join(legacyDir, '03-no-cwd.md'), body, 'utf8');
+
+  const result = await migratePrds(legacyDir);
+
+  expect(result.moved).toBe(0);
+  expect(result.unresolved).toEqual([{ file: '03-no-cwd.md', reason: 'no cwd in frontmatter' }]);
+  expect(fs.existsSync(path.join(legacyDir, '03-no-cwd.md'))).toBe(true);
+});
+
+test('migratePrds leaves a file whose cwd does not exist on disk in place and reports it unresolved', async () => {
+  const legacyDir = await mkLegacyDir();
+  const body = `---\ntitle: Bad cwd\ncwd: /this/path/does/not/exist/anywhere\nestimateMinutes: 15\n---\n\nBody.\n`;
+  await fsp.writeFile(path.join(legacyDir, '04-bad-cwd.md'), body, 'utf8');
+
+  const result = await migratePrds(legacyDir);
+
+  expect(result.moved).toBe(0);
+  expect(result.unresolved).toHaveLength(1);
+  expect(result.unresolved[0].file).toBe('04-bad-cwd.md');
+  expect(fs.existsSync(path.join(legacyDir, '04-bad-cwd.md'))).toBe(true);
+});
+
+test('migratePrds ignores non-.md and dotfiles, and no-ops on a missing legacy dir', async () => {
+  const legacyDir = await mkLegacyDir();
+  await fsp.writeFile(path.join(legacyDir, 'notes.txt'), 'not a prd', 'utf8');
+  await fsp.writeFile(path.join(legacyDir, '.hidden.md'), 'ignored', 'utf8');
+
+  const result = await migratePrds(legacyDir);
+  expect(result).toEqual({ moved: 0, skipped: 0, unresolved: [] });
+
+  const missing = await migratePrds(path.join(legacyDir, 'nope'));
+  expect(missing).toEqual({ moved: 0, skipped: 0, unresolved: [] });
+});
+
+test('migratePrds moves multiple PRDs to different projects independently', async () => {
+  const legacyDir = await mkLegacyDir();
+  const cwdA = await mkProjectCwd();
+  const cwdB = await mkProjectCwd();
+  await fsp.writeFile(
+    path.join(legacyDir, '05-a.md'),
+    `---\ntitle: A\ncwd: ${cwdA}\nestimateMinutes: 5\n---\n\nA.\n`,
+    'utf8',
+  );
+  await fsp.writeFile(
+    path.join(legacyDir, '06-b.md'),
+    `---\ntitle: B\ncwd: ${cwdB}\nestimateMinutes: 5\n---\n\nB.\n`,
+    'utf8',
+  );
+
+  const result = await migratePrds(legacyDir);
+
+  expect(result.moved).toBe(2);
+  expect(fs.existsSync(path.join(resolvePrdWriteDir(cwdA), '05-a.md'))).toBe(true);
+  expect(fs.existsSync(path.join(resolvePrdWriteDir(cwdB), '06-b.md'))).toBe(true);
+});

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

@@ -16,7 +16,7 @@ let realHome;
 let rcaFeedbackHook;
 
 // config.cjs and rcaFeedbackHook.cjs both bake os.homedir() into top-level
-// consts at first require (allowedRoots/WRITE_PREFIXES, PRDS_DIR/SM_REPO_ROOT).
+// consts at first require (allowedRoots/WRITE_PREFIXES, SM_REPO_ROOT).
 // Node's require cache must be purged per test so each test's tmpHome takes
 // effect — vi.resetModules() only resets vitest's ESM graph, not require().
 const MODULES_TO_RELOAD = ['../lib/rcaFeedbackHook.cjs', '../config.cjs'];
@@ -65,8 +65,8 @@ function writeRun(runDir, slug, { logLines = ['line1', 'line2'], exitCode = 1, d
   fs.writeFileSync(path.join(runDir, `${slug}.meta.json`), JSON.stringify({ exitCode, durationMs }));
 }
 
-function writePrd(slug, { acBody = '- [ ] `timeout 10 echo ok` passes.' } = {}) {
-  const prdsDir = path.join(tmpHome, '.claude', 'session-manager', 'scheduled-plans', 'prds');
+function writePrd(cwd, slug, { acBody = '- [ ] `timeout 10 echo ok` passes.' } = {}) {
+  const prdsDir = path.join(cwd, 'session-manager-operations', 'scheduler', 'prds');
   fs.mkdirSync(prdsDir, { recursive: true });
   const body = ['---', `title: ${slug}`, '---', '', '# Goal', '', 'Do the thing.', '', '# Acceptance criteria', '', acBody, '', '# Out of scope', '', '- N/A'].join('\n');
   fs.writeFileSync(path.join(prdsDir, `${slug}.md`), body);
@@ -82,7 +82,7 @@ test('fileRcaFeedback: second call with same (slug, runId) is a no-op', async ()
   const cwd = makeProjectWithInbox();
   const runDir = path.join(tmpHome, 'run1');
   writeRun(runDir, 'testslug');
-  writePrd('testslug');
+  writePrd(cwd, 'testslug');
   const job = baseJob({ cwd });
 
   const first = await rcaFeedbackHook.fileRcaFeedback({ job, runDir, verdict: 'transcript_errors' });
@@ -102,7 +102,7 @@ test('fileRcaFeedback: new runId for the same slug files a new RCA', async () =>
   const runDir2 = path.join(tmpHome, 'run2');
   writeRun(runDir1, 'testslug');
   writeRun(runDir2, 'testslug');
-  writePrd('testslug');
+  writePrd(cwd, 'testslug');
 
   const r1 = await rcaFeedbackHook.fileRcaFeedback({ job: baseJob({ cwd, runId: 'run-aaa' }), runDir: runDir1, verdict: 'transcript_errors' });
   const r2 = await rcaFeedbackHook.fileRcaFeedback({ job: baseJob({ cwd, runId: 'run-bbb' }), runDir: runDir2, verdict: 'transcript_errors' });
@@ -195,7 +195,7 @@ test('fileRcaFeedback: actually writes into the fallback dir when the target inb
   const cwd = makeProjectWithoutInbox();
   const runDir = path.join(tmpHome, 'run1');
   writeRun(runDir, 'testslug');
-  writePrd('testslug');
+  writePrd(cwd, 'testslug');
 
   const res = await rcaFeedbackHook.fileRcaFeedback({ job: baseJob({ cwd }), runDir, verdict: 'transcript_errors' });
   expect(res.filed).toBe(true);
@@ -221,7 +221,7 @@ test('fileRcaFeedback: SM_RCA_DISABLE=1 skips without writing', async () => {
   const cwd = makeProjectWithInbox();
   const runDir = path.join(tmpHome, 'run1');
   writeRun(runDir, 'testslug');
-  writePrd('testslug');
+  writePrd(cwd, 'testslug');
 
   const res = await rcaFeedbackHook.fileRcaFeedback({ job: baseJob({ cwd }), runDir, verdict: 'transcript_errors' });
   expect(res.filed).toBe(false);
@@ -235,7 +235,7 @@ test('fileRcaFeedback: investigationText updates the existing RCA instead of dup
   const cwd = makeProjectWithInbox();
   const runDir = path.join(tmpHome, 'run1');
   writeRun(runDir, 'testslug');
-  writePrd('testslug');
+  writePrd(cwd, 'testslug');
   const job = baseJob({ cwd });
 
   const first = await rcaFeedbackHook.fileRcaFeedback({ job, runDir, verdict: 'transcript_errors' });

package/src/main/config.cjs

@@ -23,6 +23,7 @@ const chokidar = require('chokidar');
 const logs = require('./logs.cjs');
 const { sendIfAlive } = require('./lib/sendToRenderer.cjs');
 const { expandHome } = require('./lib/expandHome.cjs');
+const { listReferencedFiles } = require('./lib/importReferences.cjs');
 
 /** Map<absPath, {watcher, refCount}> — one chokidar watcher per path. */
 const watchers = new Map();
@@ -409,6 +410,14 @@ function registerConfigHandlers() {
   ipcMain.handle('config:write-text', v(s.configWriteText, ({ path: p, text }) => writeTextAtomic(p, text)));
   ipcMain.handle('config:list-dir', v(s.configListDir, ({ path: p, opts }) => listDir(p, opts || {})));
   ipcMain.handle('config:exists', v(s.configPath, ({ path: p }) => exists(p)));
+  ipcMain.handle('config:parse-imports', v(s.configParseImports, async ({ path: p }) => {
+    try {
+      const real = validatePath(expandHome(p));
+      return { ok: true, imports: listReferencedFiles(real) };
+    } catch (e) {
+      return { ok: false, error: e.message };
+    }
+  }));
   ipcMain.on('config:watch', (e, { paths }) => { try { s.configWatch.parse(paths); watch(paths, e.sender.id); } catch (err) { logs.writeLine({ level: 'warn', scope: 'config', message: 'config:watch schema reject', meta: { error: err?.message } }); } });
   ipcMain.on('config:unwatch', (e, { paths }) => { try { s.configWatch.parse(paths); unwatch(paths, e.sender.id); } catch (err) { logs.writeLine({ level: 'warn', scope: 'config', message: 'config:unwatch schema reject', meta: { error: err?.message } }); } });
 }

package/src/main/health.cjs

@@ -11,6 +11,7 @@ const os = require('node:os');
 const { execFileSync } = require('node:child_process');
 const { POLL_INTERVAL_MS } = require('./lib/schedulerConfig.cjs');
 const { checkPersonaImports } = require('./lib/personaImportHealth.cjs');
+const { resolvePrdsDirs } = require('./lib/prdLocations.cjs');
 
 const MAX_LOG_AGE_MS = 5 * 60_000; // 5 min — warn if no logs this old
 const PROJECT_ROOT = path.resolve(__dirname, '../..');
@@ -237,28 +238,33 @@ async function check() {
     };
   }
 
-  // 4. Check PRDs directory.
-  const prdsDir = path.join(schedulerBaseDir, 'prds');
-  try {
-    await fsp.access(prdsDir, fs.constants.R_OK);
-    const files = await fsp.readdir(prdsDir);
-    const prdFiles = files.filter((f) => f.endsWith('.md'));
-    status.components.scheduler_prds = {
-      ok: true,
-      path: prdsDir,
-      count: prdFiles.length,
-    };
-  } catch (e) {
-    if (e.code !== 'ENOENT') {
-      status.issues.push(`PRDs directory not accessible: ${e.message}`);
+  // 4. Check PRDs directories — one per active project
+  // (session-manager-operations/scheduler/prds/), summed. PRD 809.
+  const prdsDirs = resolvePrdsDirs();
+  let totalPrdCount = 0;
+  let anyPrdsDirAccessible = false;
+  const prdsDirErrors = [];
+  for (const dir of prdsDirs) {
+    try {
+      await fsp.access(dir, fs.constants.R_OK);
+      const files = await fsp.readdir(dir);
+      totalPrdCount += files.filter((f) => f.endsWith('.md')).length;
+      anyPrdsDirAccessible = true;
+    } catch (e) {
+      if (e.code !== 'ENOENT') {
+        prdsDirErrors.push(`${dir}: ${e.message}`);
+      }
     }
-    status.components.scheduler_prds = {
-      ok: e.code === 'ENOENT', // ok if not yet created
-      path: prdsDir,
-      exists: false,
-      error: e.code === 'ENOENT' ? 'not yet created' : e.message,
-    };
   }
+  if (prdsDirErrors.length > 0) {
+    status.issues.push(`PRDs directory not accessible: ${prdsDirErrors.join('; ')}`);
+  }
+  status.components.scheduler_prds = {
+    ok: prdsDirErrors.length === 0,
+    dirs: prdsDirs,
+    count: totalPrdCount,
+    ...(prdsDirs.length === 0 || anyPrdsDirAccessible ? {} : { exists: false }),
+  };
 
   // 5. Check transcripts directory (where live session logs are tailed).
   const projectsDir = path.join(os.homedir(), '.claude/projects');

package/src/main/ipcSchemas.cjs

@@ -192,6 +192,8 @@ const configListDir = z.object({
 
 const configWatch = z.array(z.string().min(1).max(4096));
 
+const configParseImports = z.object({ path: z.string().min(1).max(4096) });
+
 // ──────────────────────────────────────────── Sessions
 const sessionsPayload = z.object({
   tabs: z.array(z.object({
@@ -748,6 +750,7 @@ module.exports = {
     configWriteText,
     configListDir,
     configWatch,
+    configParseImports,
     sessionsPayload,
     layoutEnvelope,
     scheduleSlug,

package/src/main/lib/__tests__/importReferences.spec.cjs

@@ -0,0 +1,56 @@
+/**
+ * importReferences.spec.cjs — unit tests for listReferencedFiles, the IPC-facing
+ * wrapper around personaImportHealth's `@path` import-chain walker.
+ *
+ * Run: timeout 120 npx vitest run src/main/lib/__tests__/importReferences.spec.cjs
+ */
+
+'use strict';
+
+import { test, expect } from 'vitest';
+const fs = require('node:fs');
+const os = require('node:os');
+const path = require('node:path');
+const { listReferencedFiles } = require('../importReferences.cjs');
+
+function mkTmpDir() {
+  return fs.mkdtempSync(path.join(os.tmpdir(), 'import-refs-test-'));
+}
+
+test('listReferencedFiles: 2 valid @imports returns 2 entries with correct sizeBytes/tokenEstimate/ok', () => {
+  const dir = mkTmpDir();
+  const a = path.join(dir, 'a.md');
+  const b = path.join(dir, 'b.md');
+  const root = path.join(dir, 'root.md');
+  fs.writeFileSync(a, 'x'.repeat(40));
+  fs.writeFileSync(b, 'y'.repeat(8));
+  fs.writeFileSync(root, `@${a}\n@${b}\n`);
+
+  const result = listReferencedFiles(root);
+
+  expect(result).toHaveLength(2);
+  const byPath = Object.fromEntries(result.map((r) => [r.path, r]));
+  expect(byPath[a]).toEqual({ path: a, exists: true, sizeBytes: 40, tokenEstimate: 10, ok: true });
+  expect(byPath[b]).toEqual({ path: b, exists: true, sizeBytes: 8, tokenEstimate: 2, ok: true });
+});
+
+test('listReferencedFiles: missing import returns ok=false with sizeBytes 0', () => {
+  const dir = mkTmpDir();
+  const missing = path.join(dir, 'does-not-exist.md');
+  const root = path.join(dir, 'root.md');
+  fs.writeFileSync(root, `@${missing}\n`);
+
+  const result = listReferencedFiles(root);
+
+  expect(result).toEqual([
+    { path: missing, exists: false, sizeBytes: 0, tokenEstimate: 0, ok: false },
+  ]);
+});
+
+test('listReferencedFiles: zero @import lines returns an empty array', () => {
+  const dir = mkTmpDir();
+  const root = path.join(dir, 'root.md');
+  fs.writeFileSync(root, 'no imports here, just prose.\n');
+
+  expect(listReferencedFiles(root)).toEqual([]);
+});

package/src/main/lib/definitionOfDone.cjs

@@ -13,6 +13,7 @@ const os = require('node:os');
 const path = require('node:path');
 const { spawn, spawnSync } = require('node:child_process');
 const { splitFrontmatter } = require('./prdFrontmatter.cjs');
+const { resolvePrdWriteDir } = require('./prdLocations.cjs');
 
 // Regex identifying meta/dod slugs that must NOT influence the batchKey.
 // This is the load-bearing loop-avoidance filter: when the gate job itself
@@ -96,11 +97,6 @@ function reportExists(key, runsDir = RUNS_DIR) {
 // watchers.cjs and app:test-fire-hook only.
 const SHELL_META_RE = /[|>&;<`]|\$[({]/;
 
-const PRDS_DIR = path.join(
-  os.homedir(),
-  '.claude', 'session-manager', 'scheduled-plans', 'prds'
-);
-
 /**
  * Extract the first bounded AC test command from a PRD body.
  *
@@ -185,11 +181,12 @@ function extractAcCommand(prdBody) {
  * @param {{ slug: string, cwd: string }} job
  * @param {{ timeoutMs?: number, prdsDir?: string }} opts
  *   timeoutMs  Hard kill ceiling for the child (default 60s).
- *   prdsDir    Override PRD directory (for tests).
+ *   prdsDir    Override PRD directory (for tests). Defaults to the job's own
+ *              per-project PRDs dir (resolvePrdWriteDir(job.cwd)).
  * @returns {Promise<{ slug: string, status: 'pass'|'fail'|'unverifiable', code: number|null, ms: number }>}
  */
 function reverifyAc(job, { timeoutMs = 60_000, prdsDir } = {}) {
-  const resolvedPrdsDir = prdsDir ?? PRDS_DIR;
+  const resolvedPrdsDir = prdsDir ?? (job.cwd ? resolvePrdWriteDir(job.cwd) : null);
   const startNs = process.hrtime.bigint();
 
   function elapsedMs() {
@@ -371,14 +368,16 @@ function _extractSection(body, headingText) {
  *
  * @param {Array<{ slug: string, cwd: string, landedCommit?: string }>} jobs
  * @param {{ prdsDir?: string, gitTimeoutMs?: number }} opts
+ *   prdsDir  Override PRD directory for every job (for tests). Defaults per-job to
+ *            the job's own per-project PRDs dir (resolvePrdWriteDir(job.cwd)).
  * @returns {Array<{ slug: string, surfaces: string[] }>}  Only jobs with ≥1 hit.
  */
 function flagRiskySurfaces(jobs, { prdsDir, gitTimeoutMs = 10_000 } = {}) {
-  const resolvedPrdsDir = prdsDir ?? PRDS_DIR;
   const results = [];
 
   for (const job of jobs) {
     let candidateText = '';
+    const resolvedPrdsDir = prdsDir ?? (job.cwd ? resolvePrdWriteDir(job.cwd) : null);
 
     // 1. Try git commit — bounded by gitTimeoutMs.
     if (job.landedCommit && job.cwd) {
@@ -395,7 +394,7 @@ function flagRiskySurfaces(jobs, { prdsDir, gitTimeoutMs = 10_000 } = {}) {
     // 2. Fallback: PRD # Implementation notes section.
     // Guard: slug must contain only safe chars to prevent path traversal via a
     // corrupted queue.json entry (e.g. slug: "../../.ssh/id_rsa").
-    if (!candidateText && job.slug && /^[\w-]+$/.test(job.slug)) {
+    if (!candidateText && resolvedPrdsDir && job.slug && /^[\w-]+$/.test(job.slug)) {
       try {
         const raw = fs.readFileSync(path.join(resolvedPrdsDir, `${job.slug}.md`), 'utf8');
         const body = splitFrontmatter(raw).body;

package/src/main/lib/importReferences.cjs

@@ -0,0 +1,34 @@
+'use strict';
+
+/**
+ * importReferences.cjs — IPC-facing wrapper around personaImportHealth's
+ * import-chain walker, adding the size/token-estimate fields the "referenced
+ * files" panel needs. Reuses walkImports rather than reparsing `@path` syntax.
+ */
+
+const fs = require('node:fs');
+const { walkImports } = require('./personaImportHealth.cjs');
+
+// Maps walkImports' result shape to what the renderer panel needs per file:
+// resolved path, existence, size, a rough token estimate, and overall health.
+function listReferencedFiles(rootPath) {
+  return walkImports(rootPath).map(({ importPath, exists, ok }) => {
+    let sizeBytes = 0;
+    if (exists) {
+      try {
+        sizeBytes = fs.statSync(importPath).size;
+      } catch {
+        sizeBytes = 0;
+      }
+    }
+    return {
+      path: importPath,
+      exists,
+      sizeBytes,
+      tokenEstimate: Math.round(sizeBytes / 4),
+      ok,
+    };
+  });
+}
+
+module.exports = { listReferencedFiles };

package/src/main/lib/prdCreate.cjs

@@ -122,7 +122,7 @@ async function createPrd(input, remote) {
   // 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 nn = input.parallelGroup ?? await remote.allocateParallelGroup(input.cwd);
   const filenameSlug = `${nn}-${slug}`;
 
   // An explicit `parallelGroup` bypasses allocateParallelGroup()'s
@@ -131,13 +131,13 @@ async function createPrd(input, remote) {
   // 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);
+  const existing = await remote.readPrd(filenameSlug, input.cwd);
   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);
+  const writeResult = await remote.writePrd(filenameSlug, body, input.cwd);
   if (!writeResult?.ok) {
     return { ok: false, status: 500, error: writeResult?.error ?? 'write failed' };
   }