claude-code-session-manager 0.75.3 → 0.77.0

package/src/main/__tests__/scheduler-worktree-cap-defer.test.cjs

@@ -0,0 +1,194 @@
+/**
+ * scheduler-worktree-cap-defer.test.cjs — PRD 1112: a job that cannot get
+ * worktree isolation because the concurrency cap is currently exhausted must
+ * be DEFERRED (left 'pending', retried on the next dispatch pass), never
+ * spawned in a shared working tree the way every OTHER worktree.ok===false
+ * reason (e.g. "not a git repository") still falls back to running in place.
+ *
+ * Drives spawnJob end-to-end against a real git fixture repo, forcing the
+ * cap via SM_JOB_WORKTREE_MAX=1 plus a real occupying worktree (so the cap
+ * check itself, not a mock, is what defers the job).
+ *
+ * Run: timeout 120 npx vitest run src/main/__tests__/scheduler-worktree-cap-defer.test.cjs
+ */
+
+'use strict';
+
+import { test, expect, beforeAll, afterAll, afterEach } from 'vitest';
+const fs = require('node:fs');
+const os = require('node:os');
+const path = require('node:path');
+const { execFileSync } = require('node:child_process');
+
+let tmpHome;
+let originalHome;
+let originalMax;
+let spawnJob;
+let gitWorktree;
+
+function git(args, cwd) {
+  return execFileSync('git', args, { cwd, encoding: 'utf8' });
+}
+
+function initRepo(dir) {
+  fs.mkdirSync(dir, { recursive: true });
+  git(['init', '-q'], dir);
+  git(['config', 'user.email', 'test@example.com'], dir);
+  git(['config', 'user.name', 'Test'], dir);
+  fs.writeFileSync(path.join(dir, 'README.md'), 'hello\n', 'utf8');
+  git(['add', '-A'], dir);
+  git(['commit', '-q', '-m', 'initial'], dir);
+}
+
+// See scheduler-quiet-machine-lease.test.cjs's identical helper: readQueue()'s
+// per-project discovery walks ~/.claude/projects/*/*.jsonl transcripts for a
+// `cwd` field to find known project queue.json shards.
+function registerActiveProject(cwd) {
+  const projectsDir = path.join(tmpHome, '.claude', 'projects');
+  const slugDir = path.join(projectsDir, `fake-project-slug-${path.basename(cwd)}`);
+  fs.mkdirSync(slugDir, { recursive: true });
+  fs.writeFileSync(path.join(slugDir, 'transcript.jsonl'), JSON.stringify({ cwd }) + '\n');
+}
+
+function writeProjectQueue(cwd, jobs) {
+  const stateDir = path.join(cwd, 'session-manager-operations', 'scheduler', 'state');
+  fs.mkdirSync(stateDir, { recursive: true });
+  fs.writeFileSync(path.join(stateDir, 'queue.json'), JSON.stringify({ jobs }, null, 2));
+  return path.join(stateDir, 'queue.json');
+}
+
+// Stub `claude` binary: writes a marker file into its OWN process.cwd() so a
+// test can prove whether — and where — it was actually spawned, then emits a
+// clean stream-json success result.
+function writeClaudeStub() {
+  const stubPath = path.join(os.tmpdir(), `sm-claude-stub-capdefer-${process.pid}-${Math.floor(Math.random() * 1e9)}.cjs`);
+  const body = `
+    const fs = require('fs');
+    const path = require('path');
+    const { execFileSync } = require('child_process');
+    fs.writeFileSync(path.join(process.cwd(), 'ran-here.marker'), 'yes', 'utf8');
+    // Land a real commit + finish-protocol sentinel when possible, so a run
+    // that actually reaches the finish protocol lands 'completed' — a
+    // best-effort no-op when the cwd isn't a git repo (e.g. the non-git
+    // fallback case), where the run parks in needs_review instead, which is
+    // fine — this test only cares whether it ran in place, not its verdict.
+    try {
+      execFileSync('git', ['add', '-A'], { cwd: process.cwd() });
+      execFileSync('git', ['commit', '-q', '-m', 'stub commit'], { cwd: process.cwd() });
+    } catch { /* not a git repo — best-effort only */ }
+    process.stdout.write(JSON.stringify({ type: 'result', subtype: 'success', result: 'ok\\nSCHEDULER_VERDICT: PASS' }) + '\\n');
+    process.exit(0);
+  `;
+  fs.writeFileSync(stubPath, `#!${process.execPath}\n${body}\n`, { mode: 0o755 });
+  return stubPath;
+}
+
+beforeAll(() => {
+  originalHome = process.env.HOME;
+  tmpHome = fs.mkdtempSync(path.join(os.tmpdir(), 'sm-worktree-cap-defer-'));
+  process.env.HOME = tmpHome;
+  originalMax = process.env.SM_JOB_WORKTREE_MAX;
+  ({ spawnJob } = require('../scheduler.cjs'));
+  gitWorktree = require('../lib/gitWorktree.cjs');
+});
+
+afterAll(() => {
+  process.env.HOME = originalHome;
+  if (originalMax === undefined) delete process.env.SM_JOB_WORKTREE_MAX;
+  else process.env.SM_JOB_WORKTREE_MAX = originalMax;
+  fs.rmSync(tmpHome, { recursive: true, force: true });
+});
+
+afterEach(() => {
+  delete process.env.SM_CLAUDE_BIN;
+  delete process.env.SM_JOB_WORKTREE_MAX;
+  gitWorktree._resetActiveWorktreeCountForTests('job', 0);
+});
+
+test('a job held behind the worktree cap stays pending with a heldReason, is never spawned in place, and dispatches once the cap frees up', async () => {
+  const projectCwd = fs.mkdtempSync(path.join(os.tmpdir(), 'sm-worktree-cap-defer-project-'));
+  initRepo(projectCwd);
+  registerActiveProject(projectCwd);
+
+  const slug = `1112-test-held-${process.pid}-${Math.floor(Math.random() * 1e6)}`;
+  const prdsDir = path.join(projectCwd, 'session-manager-operations', 'scheduler', 'prds');
+  fs.mkdirSync(prdsDir, { recursive: true });
+  fs.writeFileSync(path.join(prdsDir, `${slug}.md`), 'Held behind the worktree cap.', 'utf8');
+  const queuePath = writeProjectQueue(projectCwd, [{ slug, status: 'pending', cwd: projectCwd }]);
+
+  process.env.SM_JOB_WORKTREE_MAX = '1';
+  process.env.SM_CLAUDE_BIN = writeClaudeStub();
+
+  // Occupy the single worktree slot with a REAL checkout, so the cap check
+  // spawnJob relies on is exercising the actual gitWorktree plumbing, not a
+  // mock.
+  const occupier = await gitWorktree.createJobWorktree({ cwd: projectCwd, slug: 'occupier' });
+  expect(occupier.ok).toBe(true);
+
+  const runId = `run-${slug}`;
+  const runDir = path.join(tmpHome, '.claude', 'session-manager', 'scheduled-plans', 'runs', runId);
+  fs.mkdirSync(runDir, { recursive: true });
+
+  try {
+    await spawnJob({ slug, cwd: projectCwd }, runId, runDir, projectCwd);
+
+    // Held: still pending, never spawned, heldReason visible on the row.
+    let jobs = JSON.parse(fs.readFileSync(queuePath, 'utf8')).jobs;
+    let row = jobs.find((j) => j.slug === slug);
+    expect(row.status).toBe('pending');
+    expect(row.heldReason).toMatch(/worktree cap reached/);
+    expect(fs.existsSync(path.join(projectCwd, 'ran-here.marker'))).toBe(false);
+    expect(fs.existsSync(path.join(occupier.dir, 'ran-here.marker'))).toBe(false);
+
+    // Free the cap (mirrors cleanupJobWorktree releasing the counter), then
+    // retry — the held job dispatches on this next pass, exactly like a
+    // sessionSlots-blocked job retries once a slot frees up.
+    await gitWorktree.cleanupJobWorktree({ cwd: projectCwd, dir: occupier.dir, branch: occupier.branch });
+
+    await spawnJob({ slug, cwd: projectCwd }, `${runId}-2`, runDir, projectCwd);
+
+    jobs = JSON.parse(fs.readFileSync(queuePath, 'utf8')).jobs;
+    row = jobs.find((j) => j.slug === slug);
+    expect(row.status).toBe('completed');
+    expect(row.heldReason).toBeUndefined();
+  } finally {
+    fs.rmSync(projectCwd, { recursive: true, force: true });
+    fs.rmSync(runDir, { recursive: true, force: true });
+  }
+}, 30_000);
+
+test('a non-git cwd still falls back to running in place (unchanged behaviour — only cap-reached is a deferral)', async () => {
+  const projectCwd = fs.mkdtempSync(path.join(os.tmpdir(), 'sm-worktree-cap-defer-nongit-'));
+  fs.mkdirSync(projectCwd, { recursive: true }); // deliberately NOT a git repo
+  registerActiveProject(projectCwd);
+
+  const slug = `1112-test-nongit-${process.pid}-${Math.floor(Math.random() * 1e6)}`;
+  const prdsDir = path.join(projectCwd, 'session-manager-operations', 'scheduler', 'prds');
+  fs.mkdirSync(prdsDir, { recursive: true });
+  fs.writeFileSync(path.join(prdsDir, `${slug}.md`), 'Non-git cwd, must run in place.', 'utf8');
+  const queuePath = writeProjectQueue(projectCwd, [{ slug, status: 'pending', cwd: projectCwd }]);
+
+  process.env.SM_CLAUDE_BIN = writeClaudeStub();
+
+  const runId = `run-${slug}`;
+  const runDir = path.join(tmpHome, '.claude', 'session-manager', 'scheduled-plans', 'runs', runId);
+  fs.mkdirSync(runDir, { recursive: true });
+
+  try {
+    await spawnJob({ slug, cwd: projectCwd }, runId, runDir, projectCwd);
+
+    const jobs = JSON.parse(fs.readFileSync(queuePath, 'utf8')).jobs;
+    const row = jobs.find((j) => j.slug === slug);
+    // Not held/deferred — it actually ran (a non-git cwd can't commit, so it
+    // parks in needs_review rather than completed; this test only cares that
+    // it was dispatched in place, not its exact verdict).
+    expect(row.status).not.toBe('pending');
+    expect(row.heldReason).toBeUndefined();
+    expect(row.worktreeFallbackReason).toMatch(/not a git repository/);
+    // Ran IN PLACE — the marker landed directly in projectCwd, not a worktree.
+    expect(fs.existsSync(path.join(projectCwd, 'ran-here.marker'))).toBe(true);
+  } finally {
+    fs.rmSync(projectCwd, { recursive: true, force: true });
+    fs.rmSync(runDir, { recursive: true, force: true });
+  }
+}, 30_000);

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

@@ -54,22 +54,20 @@ function silentLogger() {
   return { log: () => {}, warn: () => {} };
 }
 
-test('fresh seed writes both persona files', async () => {
-  await seedAgentPersonas({ logger: silentLogger() });
+const ALL_PERSONAS = ['architect', 'dev-lead', 'project-home-builder'];
 
-  const architect = path.join(agentsDir(), 'architect.md');
-  const devLead = path.join(agentsDir(), 'dev-lead.md');
-  expect(fs.existsSync(architect)).toBe(true);
-  expect(fs.existsSync(devLead)).toBe(true);
+test('fresh seed writes every persona file', async () => {
+  await seedAgentPersonas({ logger: silentLogger() });
 
-  const bundledArchitect = fs.readFileSync(
-    path.join(__dirname, '..', '..', 'seed', 'agents', 'architect.md'),
-    'utf8'
-  );
-  expect(fs.readFileSync(architect, 'utf8')).toBe(bundledArchitect);
+  for (const name of ALL_PERSONAS) {
+    const dest = path.join(agentsDir(), `${name}.md`);
+    expect(fs.existsSync(dest)).toBe(true);
+    const bundled = fs.readFileSync(path.join(__dirname, '..', '..', 'seed', 'agents', `${name}.md`), 'utf8');
+    expect(fs.readFileSync(dest, 'utf8')).toBe(bundled);
+  }
 
   const marker = JSON.parse(fs.readFileSync(markerPath(), 'utf8'));
-  expect(marker.done).toBe(true);
+  expect(marker.seeded.sort()).toEqual([...ALL_PERSONAS].sort());
 });
 
 test('a pre-existing persona file is left byte-identical', async () => {
@@ -81,20 +79,83 @@ test('a pre-existing persona file is left byte-identical', async () => {
   await seedAgentPersonas({ logger: silentLogger() });
 
   expect(fs.readFileSync(architect, 'utf8')).toBe(customContent);
-  // dev-lead had no pre-existing file, so it should still be seeded.
+  // dev-lead and project-home-builder had no pre-existing file, so they should still be seeded.
   expect(fs.existsSync(path.join(agentsDir(), 'dev-lead.md'))).toBe(true);
+  expect(fs.existsSync(path.join(agentsDir(), 'project-home-builder.md'))).toBe(true);
 });
 
-test('done:true marker short-circuits without touching agents dir', async () => {
+test('a machine already fully seeded under the old done:true marker only picks up a newly added persona', async () => {
   const mPath = markerPath();
   fs.mkdirSync(path.dirname(mPath), { recursive: true });
+  // Legacy marker shape from before the seeded-set change — no `seeded` array.
   fs.writeFileSync(mPath, JSON.stringify({ done: true, attempts: 1, ts: '2026-01-01T00:00:00.000Z' }));
+  fs.mkdirSync(agentsDir(), { recursive: true });
+  fs.writeFileSync(path.join(agentsDir(), 'architect.md'), 'old architect content\n');
+  fs.writeFileSync(path.join(agentsDir(), 'dev-lead.md'), 'old dev-lead content\n');
+
+  await seedAgentPersonas({ logger: silentLogger() });
+
+  // Pre-existing files from the old run are untouched...
+  expect(fs.readFileSync(path.join(agentsDir(), 'architect.md'), 'utf8')).toBe('old architect content\n');
+  expect(fs.readFileSync(path.join(agentsDir(), 'dev-lead.md'), 'utf8')).toBe('old dev-lead content\n');
+  // ...but the newly added persona is delivered.
+  expect(fs.existsSync(path.join(agentsDir(), 'project-home-builder.md'))).toBe(true);
+
+  const marker = JSON.parse(fs.readFileSync(mPath, 'utf8'));
+  expect(marker.seeded.sort()).toEqual([...ALL_PERSONAS].sort());
+});
+
+test('a machine already seeded under the new seeded-set marker picks up a newly added persona', async () => {
+  const mPath = markerPath();
+  fs.mkdirSync(path.dirname(mPath), { recursive: true });
+  fs.writeFileSync(mPath, JSON.stringify({ seeded: ['architect', 'dev-lead'], attempts: 0, ts: '2026-01-01T00:00:00.000Z' }));
+
+  await seedAgentPersonas({ logger: silentLogger() });
+
+  expect(fs.existsSync(path.join(agentsDir(), 'project-home-builder.md'))).toBe(true);
+  const marker = JSON.parse(fs.readFileSync(mPath, 'utf8'));
+  expect(marker.seeded.sort()).toEqual([...ALL_PERSONAS].sort());
+});
+
+test('a machine with every known persona already in the seeded set short-circuits without touching agents dir', async () => {
+  const mPath = markerPath();
+  fs.mkdirSync(path.dirname(mPath), { recursive: true });
+  fs.writeFileSync(mPath, JSON.stringify({ seeded: ALL_PERSONAS, attempts: 0, ts: '2026-01-01T00:00:00.000Z' }));
 
   await seedAgentPersonas({ logger: silentLogger() });
 
   expect(fs.existsSync(agentsDir())).toBe(false);
 });
 
+test('a corrupt/unparseable marker file still seeds correctly', async () => {
+  const mPath = markerPath();
+  fs.mkdirSync(path.dirname(mPath), { recursive: true });
+  fs.writeFileSync(mPath, '{ not valid json');
+
+  await seedAgentPersonas({ logger: silentLogger() });
+
+  for (const name of ALL_PERSONAS) {
+    expect(fs.existsSync(path.join(agentsDir(), `${name}.md`))).toBe(true);
+  }
+});
+
+test('the bundled project-home-builder persona contains no session-manager-repo paths', () => {
+  const content = fs.readFileSync(
+    path.join(__dirname, '..', '..', 'seed', 'agents', 'project-home-builder.md'),
+    'utf8'
+  );
+  const forbidden = [
+    'session-manager-operations/architecture/',
+    '.claude/agents/',
+    'session-manager-operations/design-mocks/',
+    'scripts/',
+    'npm run build:project-pages',
+  ];
+  for (const substr of forbidden) {
+    expect(content).not.toContain(substr);
+  }
+});
+
 test('SM_SEED_AGENT_PERSONAS_DISABLE=1 short-circuits', async () => {
   process.env.SM_SEED_AGENT_PERSONAS_DISABLE = '1';
 

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

@@ -143,3 +143,69 @@ test('a failed attempt bumps the counter and stops after MAX_ATTEMPTS', async ()
   expect(called).toBe(false);
   expect(readMarker()).toMatchObject({ done: false, attempts: 3 });
 });
+
+// ─────────────────────────────── repair: marker done, script path stale
+
+test('marker done + user-scope script path missing -> removes then re-adds, marker stays done', async () => {
+  fs.mkdirSync(path.dirname(markerPath()), { recursive: true });
+  fs.writeFileSync(markerPath(), JSON.stringify({ done: true, attempts: 0, ts: '2026-01-01T00:00:00.000Z' }));
+  fs.writeFileSync(
+    claudeJsonPath(),
+    JSON.stringify({
+      mcpServers: {
+        'session-manager-scheduler': { type: 'stdio', command: 'node', args: ['/definitely/does/not/exist.cjs'] },
+      },
+    })
+  );
+
+  const removeCalls = [];
+  const removeFn = async () => { removeCalls.push(1); return { ok: true }; };
+  const addCalls = [];
+  const addFn = async (serverPath) => { addCalls.push(serverPath); return { ok: true, exitCode: 0 }; };
+
+  await seedSchedulerMcp({ logger: silentLogger(), addFn, removeFn });
+
+  expect(removeCalls).toHaveLength(1);
+  expect(addCalls).toHaveLength(1);
+  expect(path.isAbsolute(addCalls[0])).toBe(true);
+  expect(readMarker().done).toBe(true);
+});
+
+test('marker done + user-scope entry ABSENT (deliberate remove) stays removed, no repair attempted', async () => {
+  fs.mkdirSync(path.dirname(markerPath()), { recursive: true });
+  fs.writeFileSync(markerPath(), JSON.stringify({ done: true, attempts: 0, ts: '2026-01-01T00:00:00.000Z' }));
+  // No ~/.claude.json at all — same as a deliberate `claude mcp remove`.
+
+  let removeCalled = false;
+  let addCalled = false;
+  const removeFn = async () => { removeCalled = true; return { ok: true }; };
+  const addFn = async () => { addCalled = true; return { ok: true }; };
+
+  await seedSchedulerMcp({ logger: silentLogger(), addFn, removeFn });
+
+  expect(removeCalled).toBe(false);
+  expect(addCalled).toBe(false);
+});
+
+test('marker done + user-scope script path exists -> healthy, no repair attempted', async () => {
+  fs.mkdirSync(path.dirname(markerPath()), { recursive: true });
+  fs.writeFileSync(markerPath(), JSON.stringify({ done: true, attempts: 0, ts: '2026-01-01T00:00:00.000Z' }));
+  fs.writeFileSync(
+    claudeJsonPath(),
+    JSON.stringify({
+      mcpServers: {
+        'session-manager-scheduler': { type: 'stdio', command: 'node', args: [markerPath()] }, // any existing file
+      },
+    })
+  );
+
+  let removeCalled = false;
+  let addCalled = false;
+  const removeFn = async () => { removeCalled = true; return { ok: true }; };
+  const addFn = async () => { addCalled = true; return { ok: true }; };
+
+  await seedSchedulerMcp({ logger: silentLogger(), addFn, removeFn });
+
+  expect(removeCalled).toBe(false);
+  expect(addCalled).toBe(false);
+});

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

@@ -101,11 +101,20 @@ describe('pickForProject dependsOn eligibility (PRD 832)', () => {
   // like anything else with no blocking dependsOn — the 828 row is no longer
   // held back merely for carrying a higher number.
   it('legacy same-NN pending jobs are eligible alongside higher-numbered ones', () => {
-    const a = job('827-one', 'pending', 827);
-    const b = job('827-two', 'pending', 827);
-    const later = job('828-three', 'pending', 828);
-    const res = pickForProject([a, b, later], new Set(), 3);
-    expect(res.batch.map((j) => j.slug).sort()).toEqual(['827-one', '827-two', '828-three']);
+    // Predates the per-project job cap (PRD 1066, default 2); raise it so
+    // this test keeps exercising parallelGroup semantics, not the cap.
+    const prevCap = process.env.SM_PROJECT_JOB_CAP;
+    process.env.SM_PROJECT_JOB_CAP = '10';
+    try {
+      const a = job('827-one', 'pending', 827);
+      const b = job('827-two', 'pending', 827);
+      const later = job('828-three', 'pending', 828);
+      const res = pickForProject([a, b, later], new Set(), 3);
+      expect(res.batch.map((j) => j.slug).sort()).toEqual(['827-one', '827-two', '828-three']);
+    } finally {
+      if (prevCap === undefined) delete process.env.SM_PROJECT_JOB_CAP;
+      else process.env.SM_PROJECT_JOB_CAP = prevCap;
+    }
   });
 });
 

package/src/main/bilkoHost.cjs

@@ -29,6 +29,7 @@
  */
 
 const { ipcMain } = require('electron');
+const { opsPath } = require('./lib/opsOwnership.cjs');
 const fsp = require('node:fs/promises');
 const path = require('node:path');
 const crypto = require('node:crypto');
@@ -46,7 +47,7 @@ const WRITER = 'bilko-host';
 const PROJECT_PAGE_LENSES = new Set(['home', 'marketing', 'feature', 'architecture']);
 
 function bilkoHostDir(cwd) {
-  return path.join(cwd, 'session-manager-operations', 'bilko-host');
+  return opsPath(cwd, 'bilko-host');
 }
 
 function distDir(cwd) {
@@ -103,7 +104,7 @@ async function get({ cwd }) {
   const realCwd = config.validatePath(cwd);
 
   const marketingResult = await config.readText(
-    path.join(realCwd, 'session-manager-operations', 'project-pages', 'output', 'marketing.html'),
+    opsPath(realCwd, 'project-pages', 'output', 'marketing.html'),
   );
   const pkgResult = await config.readJson(path.join(realCwd, 'package.json'));
   const pkg = pkgResult.exists && !pkgResult.parseError ? pkgResult.data : null;
@@ -215,7 +216,7 @@ async function removeDocument({ cwd, id }) {
 async function resolveDocumentHtml(cwd, doc) {
   if (doc.source.kind === 'project-page-lens') {
     const result = await config.readText(
-      path.join(cwd, 'session-manager-operations', 'project-pages', 'output', `${doc.source.lens}.html`),
+      opsPath(cwd, 'project-pages', 'output', `${doc.source.lens}.html`),
     );
     if (!result.exists) {
       throw new Error(`document "${doc.title}" points at the ${doc.source.lens} Project Page, but it hasn't been generated yet`);

package/src/main/chatRunner.cjs

@@ -518,7 +518,12 @@ function executeRun({ tabId, sessionId, prompt, cwd, resume, silent, onSilentRes
     // resolveSourcePromptIdFromClaudeSession. sessionId IS the Epic's
     // claudeSessionId for an Epic-backed tab (domain model: Epic:claude-session
     // 1:1); for a non-Epic tab, resolution below simply finds no match.
-    const childEnv = cleanChildEnv({ PATH: pathWithUserBins(), SM_CHAT_SESSION_ID: sessionId });
+    // SM_PROJECT_ROOT is the real project cwd (never the worktree spawn cwd
+    // resolved below) — scheduler-mcp-server.cjs forwards it as
+    // originProjectRoot on create-prd/open-session/readiness calls so those
+    // routes can resolve the right project even from a worktree pwd. See
+    // projectRootResolve.cjs.
+    const childEnv = cleanChildEnv({ PATH: pathWithUserBins(), SM_CHAT_SESSION_ID: sessionId, SM_PROJECT_ROOT: cwd });
 
     // Prepend the stop-signal protocol instruction and the chat-mode truth
     // instruction to every prompt

package/src/main/config.cjs

@@ -19,7 +19,7 @@ const fs = require('node:fs');
 const fsp = require('node:fs/promises');
 const path = require('node:path');
 const os = require('node:os');
-const { assertOpsWrite } = require('./lib/opsOwnership.cjs');
+const { assertOpsWrite, opsPath } = require('./lib/opsOwnership.cjs');
 const chokidar = require('chokidar');
 const logs = require('./logs.cjs');
 const { sendIfAlive } = require('./lib/sendToRenderer.cjs');
@@ -139,39 +139,31 @@ function validateWrite(realAbs) {
       if (realAbs === claudeSub || realAbs.startsWith(claudeSub + path.sep)) {
         return;
       }
-      // PromptSession persistence (active-index.json + per-session archives,
-      // promptSessions.ts) and the scheduler's own read-modify-write of that
-      // same active index (promptSessionEvents.cjs, PRD 814) — narrowly
-      // scoped to session-manager-operations/prompt-sessions/, this repo's
-      // existing per-project artifact-store convention.
-      const promptSessionsSub = path.join(realRoot, 'session-manager-operations', 'prompt-sessions');
-      if (realAbs === promptSessionsSub || realAbs.startsWith(promptSessionsSub + path.sep)) {
-        return;
-      }
-      // Scheduler PRD sources (PRD 825 — per-project Epic PRD dirs under
-      // scheduler/epics/<id>/prds/, plus the legacy flat scheduler/prds/ and
-      // scheduler/state/ shards): narrowly scoped to
-      // session-manager-operations/scheduler/, this repo's existing
-      // per-project artifact-store convention (scheduler.cjs's remote.writePrd
-      // writes here via config.writeTextAtomic).
-      const schedulerSub = path.join(realRoot, 'session-manager-operations', 'scheduler');
-      if (realAbs === schedulerSub || realAbs.startsWith(schedulerSub + path.sep)) {
-        return;
-      }
-      // Project Brief persistence (PRD 837 — projectBrief.cjs's writeJson of
-      // brief.json): narrowly scoped to session-manager-operations/project-brief/,
-      // this repo's existing per-project artifact-store convention.
-      const briefSub = path.join(realRoot, 'session-manager-operations', 'project-brief');
-      if (realAbs === briefSub || realAbs.startsWith(briefSub + path.sep)) {
-        return;
+      // Writable ops namespaces under a registered project root — this
+      // repo's per-project artifact-store convention:
+      //   prompt-sessions  PromptSession persistence (promptSessions.ts) and
+      //                    the scheduler's read-modify-write of active-index
+      //                    (promptSessionEvents.cjs, PRD 814)
+      //   scheduler        PRD sources + Epic PRD dirs + state shards
+      //                    (PRD 825; scheduler.cjs remote.writePrd)
+      //   project-brief    projectBrief.cjs's brief.json (PRD 837)
+      //   bilko-host       bilkoHost.cjs's bundle prep
+      //   project-pages    projectHomeAdminRoutes.cjs's app-side render path
+      //                    (summary.json/picks.json/output/*; PRD:
+      //                    project-home-admin-routes)
+      // Paths come from opsOwnership.opsPath (PRD 1082) — the one ops-root
+      // resolver — which THROWS for an ephemeral root (a linked worktree that
+      // pty.cjs registered as an allowed root for its spawn cwd, or
+      // os.tmpdir()). That throw is the point: a worktree's ops subtree is
+      // never a writable destination, so its exemptions simply do not exist.
+      let opsSubs;
+      try {
+        opsSubs = ['prompt-sessions', 'scheduler', 'project-brief', 'bilko-host', 'project-pages'].map((ns) => opsPath(realRoot, ns));
+      } catch {
+        opsSubs = [];
       }
-      // Host on Bilko.run bundle prep (bilkoHost.cjs's prepareBundle/
-      // addDocument/removeDocument): narrowly scoped to
-      // session-manager-operations/bilko-host/, this repo's existing
-      // per-project artifact-store convention.
-      const bilkoHostSub = path.join(realRoot, 'session-manager-operations', 'bilko-host');
-      if (realAbs === bilkoHostSub || realAbs.startsWith(bilkoHostSub + path.sep)) {
-        return;
+      for (const sub of opsSubs) {
+        if (realAbs === sub || realAbs.startsWith(sub + path.sep)) return;
       }
     }
   }