claude-code-session-manager 0.76.0 → 0.78.0

package/scripts/render-project-pages.cjs

@@ -0,0 +1,70 @@
+#!/usr/bin/env node
+// Bash-invocable CLI wrapping the Stage 0 renderer (render.tsx →
+// scripts/render-project-pages/dist/renderer.cjs, built by
+// `npm run build:project-pages`). Requires that build to have already run —
+// this script does NOT bundle on the fly, since PRD authoring standards
+// forbid unbounded/slow steps inside a headless job.
+//
+// Usage:
+//   node scripts/render-project-pages.cjs <summary.json> <picks.json> <output dir> <generatedAt>
+//
+// generatedAt (4th arg, required) is an ISO 8601 timestamp string the CALLER
+// stamps — Date.now() is unavailable in some execution contexts (e.g.
+// workflow scripts) that may drive this CLI, so this script never generates
+// its own timestamp. This is the "accept generatedAt as a 4th CLI arg"
+// option from the PRD's two documented choices (the alternative — omitting
+// generatedAt from manifest.json entirely — was not taken).
+//
+// Writes <output dir>/home.html, marketing.html, feature.html,
+// architecture.html, brief.html, and manifest.json ({ generatedAt }).
+//
+// Path arguments are used as-is (no allowedRoots validation like
+// config.cjs's validatePath) — this is a standalone local dev/ops script run
+// by a trusted human or agent shell, not an IPC-reachable surface, so it's
+// out of scope for that guard by design.
+'use strict';
+
+const fs = require('node:fs');
+const path = require('node:path');
+
+function fail(message) {
+  console.error(`render-project-pages: ${message}`);
+  process.exit(1);
+}
+
+function main() {
+  const [summaryPath, picksPath, outDir, generatedAt] = process.argv.slice(2);
+  if (!summaryPath || !picksPath || !outDir || !generatedAt) {
+    fail('usage: node scripts/render-project-pages.cjs <summary.json> <picks.json> <output dir> <generatedAt>');
+  }
+  if (Number.isNaN(Date.parse(generatedAt))) {
+    fail(`generatedAt must be an ISO 8601 timestamp, got: ${generatedAt}`);
+  }
+
+  const bundlePath = path.join(__dirname, 'render-project-pages', 'dist', 'renderer.cjs');
+  if (!fs.existsSync(bundlePath)) {
+    fail(`build bundle not found at ${bundlePath} — run "npm run build:project-pages" first`);
+  }
+
+  let renderProjectPages;
+  try {
+    ({ renderProjectPages } = require(bundlePath));
+  } catch (err) {
+    fail(`failed to load ${bundlePath}: ${err.message}`);
+  }
+
+  const summary = JSON.parse(fs.readFileSync(summaryPath, 'utf8'));
+  const picks = JSON.parse(fs.readFileSync(picksPath, 'utf8'));
+
+  const pages = renderProjectPages(summary, picks);
+
+  fs.mkdirSync(outDir, { recursive: true });
+  for (const lens of ['home', 'marketing', 'feature', 'architecture', 'brief']) {
+    fs.writeFileSync(path.join(outDir, `${lens}.html`), pages[lens]);
+  }
+  fs.writeFileSync(path.join(outDir, 'manifest.json'), JSON.stringify({ generatedAt }, null, 2));
+
+  console.log(`Wrote home.html, marketing.html, feature.html, architecture.html, brief.html, manifest.json to ${outDir}`);
+}
+
+main();

package/scripts/scheduler-mcp-server.cjs

@@ -11,6 +11,11 @@
  *   feedback_list_projects()       -> GET  /admin/feedback/targets
  *   feedback_open_session({ ... }) -> POST /admin/feedback/open-session
  *
+ *   project_home_get_contract({ cwd? })              -> GET  /admin/project-home/contract
+ *   project_home_validate_summary({ cwd?, summary }) -> POST /admin/project-home/validate-summary
+ *   project_home_render({ cwd?, summary, picks })    -> POST /admin/project-home/render
+ *   project_home_status({ cwd? })                    -> GET  /admin/project-home/status
+ *
  * This is a separate process from the Electron app — it only ever reaches
  * it over the token-authed loopback HTTP API in admin-api.json, never by
  * requiring scheduler.cjs/localAdminHttp.cjs directly. The admin server IS the
@@ -57,6 +62,14 @@ function errorResult(text) {
 const NOT_RUNNING_ERROR =
   `session-manager app is not running (admin API unreachable) — start it first${HELP_POINTER}`;
 
+// Same resolution fetchReadiness() below uses: a project-home-builder session
+// running inside an Epic worktree still targets the real project cwd, not
+// the worktree's own pwd.
+function resolveCwdArg(args) {
+  if (args && typeof args.cwd === 'string' && args.cwd) return args.cwd;
+  return process.env.SM_PROJECT_ROOT || process.cwd();
+}
+
 async function readAdminConfig() {
   const raw = await fsp.readFile(TOKEN_PATH, 'utf8');
   const parsed = JSON.parse(raw);
@@ -156,7 +169,15 @@ const TOOLS = [
         tag: {
           type: 'string',
           enum: PRD_WORK_TYPES,
-          description: 'Optional: the work type of THIS PRD — independent of the parent Epic\'s own tag. An Epic is the plan; a PRD is one unit of work inside it, and a single plan may legitimately contain several different work types. Never derived or inherited from the Epic.',
+          description: 'Optional: the WORK TYPE of THIS PRD — independent of the parent Epic\'s own tag. An Epic is the plan; a PRD is one unit of work inside it, and a single plan may legitimately contain several different work types. Never derived or inherited from the Epic.',
+        },
+        agentType: {
+          type: 'string',
+          description: 'Optional: WHO executes this PRD — the persona name (a file at ~/.claude/agents/<name>.md, e.g. "dev-lead") the executor should adopt. Distinct from `tag` (what kind of work); this is who does it. Defaults to "dev-lead" when omitted. Rejected at write time if the name does not resolve to a readable persona file.',
+        },
+        quietMachine: {
+          type: 'boolean',
+          description: 'Optional: set true only when this PRD\'s acceptance criteria are wall-clock/timing measurements (frame time, performance fences) that CPU contention from concurrent jobs would invalidate. The scheduler dispatches it only once zero other jobs are running machine-wide, and holds every other job off the whole slot pool for its run — a whole-machine exclusive lease, not a per-project one. If the machine never goes quiet within the configured wait window (default 30 minutes), it dispatches anyway and is marked degraded. Opt-in only; omit for ordinary PRDs.',
         },
       },
       required: ['title', 'estimateMinutes', 'goal', 'acceptanceCriteria', 'implementationNotes'],
@@ -208,6 +229,8 @@ const TOOLS = [
             sourcePromptId: { type: 'string' },
             sourceTabId: { type: 'string' },
             tag: { type: 'string', enum: PRD_WORK_TYPES },
+            agentType: { type: 'string', description: 'WHO executes this PRD (persona name) — patchable after creation too, see scheduler_create_prd' },
+            quietMachine: { type: 'boolean', description: 'Optional: the exclusive machine-wide quiet lease flag (see scheduler_create_prd) — patchable after creation too' },
           },
         },
         body: { type: 'string', description: 'Optional: full replacement body (everything after the frontmatter)' },
@@ -316,6 +339,51 @@ const TOOLS = [
       required: ['toCwd', 'fromCwd', 'title', 'body'],
     },
   },
+  {
+    name: 'project_home_get_contract',
+    description: descriptionFor('project_home_get_contract'),
+    inputSchema: {
+      type: 'object',
+      properties: {
+        cwd: { type: 'string', description: "Optional: absolute path to the target project. Defaults to the calling session's own project root (SM_PROJECT_ROOT or process.cwd()) when omitted." },
+      },
+    },
+  },
+  {
+    name: 'project_home_validate_summary',
+    description: descriptionFor('project_home_validate_summary'),
+    inputSchema: {
+      type: 'object',
+      properties: {
+        cwd: { type: 'string', description: "Optional: absolute path to the target project. Defaults to the calling session's own project root when omitted." },
+        summary: { type: 'object', description: 'ProjectPageSummary object matching the summarySchema from project_home_get_contract' },
+      },
+      required: ['summary'],
+    },
+  },
+  {
+    name: 'project_home_render',
+    description: descriptionFor('project_home_render'),
+    inputSchema: {
+      type: 'object',
+      properties: {
+        cwd: { type: 'string', description: "Optional: absolute path to the target project. Defaults to the calling session's own project root when omitted." },
+        summary: { type: 'object', description: 'ProjectPageSummary object matching the summarySchema from project_home_get_contract' },
+        picks: { type: 'object', description: 'ProjectPagePicks object (lensId -> slotId -> variantId) matching the picksSchema from project_home_get_contract' },
+      },
+      required: ['summary', 'picks'],
+    },
+  },
+  {
+    name: 'project_home_status',
+    description: descriptionFor('project_home_status'),
+    inputSchema: {
+      type: 'object',
+      properties: {
+        cwd: { type: 'string', description: "Optional: absolute path to the target project. Defaults to the calling session's own project root when omitted." },
+      },
+    },
+  },
   {
     name: 'session_manager_help',
     description: descriptionFor('session_manager_help'),
@@ -420,6 +488,21 @@ async function handleCallTool(request) {
       return { content: [{ type: 'text', text: JSON.stringify(result) }] };
     }
     if (name === 'scheduler_create_prd') {
+      // Hard refusal at the authoring boundary (issue #11, list C1): a
+      // headless scheduled executor performs its own acceptance criteria and
+      // never queues follow-on work — PRD 460 called /develop from inside its
+      // run, spawned a duplicate PRD, and exited 0 having done nothing. The
+      // standards prose already says so; this makes the harness enforce it.
+      // scheduler.cjs stamps SM_SCHEDULER_JOB_SLUG on every job spawn and
+      // SM_SCHEDULER_JOB_MAY_QUEUE=1 only for personas whose whole job is
+      // decomposition (architect), so a planning PRD still can.
+      if (process.env.SM_SCHEDULER_JOB_SLUG && process.env.SM_SCHEDULER_JOB_MAY_QUEUE !== '1') {
+        return errorResult(
+          `refused: scheduler_create_prd was called from inside headless scheduled job '${process.env.SM_SCHEDULER_JOB_SLUG}'. `
+          + 'A PRD executor performs its own acceptance criteria directly and never queues follow-on work (self-queue failure class). '
+          + 'If more work is genuinely needed, say so in your final result text — the authoring Epic decides whether to queue it.',
+        );
+      }
       // If the caller (the model) didn't pass sourcePromptId, forward this
       // process's own SM_CHAT_SESSION_ID (set by chatRunner.cjs on the
       // parent claude -p process this MCP server inherited its env from) so
@@ -485,6 +568,37 @@ async function handleCallTool(request) {
       const result = await adminRequest('POST', '/admin/chat/send-prompt', { tabId, prompt });
       return { content: [{ type: 'text', text: JSON.stringify(result) }] };
     }
+    if (name === 'project_home_get_contract') {
+      const cwd = resolveCwdArg(args);
+      const qs = new URLSearchParams({ cwd });
+      const result = await adminRequest('GET', `/admin/project-home/contract?${qs.toString()}`);
+      return { content: [{ type: 'text', text: JSON.stringify(result) }] };
+    }
+    if (name === 'project_home_validate_summary') {
+      if (!args || typeof args.summary !== 'object' || args.summary === null) {
+        return errorResult('missing required argument: summary');
+      }
+      const cwd = resolveCwdArg(args);
+      const result = await adminRequest('POST', '/admin/project-home/validate-summary', { cwd, summary: args.summary });
+      return { content: [{ type: 'text', text: JSON.stringify(result) }] };
+    }
+    if (name === 'project_home_render') {
+      if (!args || typeof args.summary !== 'object' || args.summary === null) {
+        return errorResult('missing required argument: summary');
+      }
+      if (typeof args.picks !== 'object' || args.picks === null) {
+        return errorResult('missing required argument: picks');
+      }
+      const cwd = resolveCwdArg(args);
+      const result = await adminRequest('POST', '/admin/project-home/render', { cwd, summary: args.summary, picks: args.picks });
+      return { content: [{ type: 'text', text: JSON.stringify(result) }] };
+    }
+    if (name === 'project_home_status') {
+      const cwd = resolveCwdArg(args);
+      const qs = new URLSearchParams({ cwd });
+      const result = await adminRequest('GET', `/admin/project-home/status?${qs.toString()}`);
+      return { content: [{ type: 'text', text: JSON.stringify(result) }] };
+    }
     if (name === 'session_manager_help') {
       const toolName = args && typeof args.tool === 'string' ? args.tool : null;
       const topic = args && typeof args.topic === 'string' ? args.topic : null;

package/scripts/validate-project-pages-summary.cjs

@@ -0,0 +1,62 @@
+#!/usr/bin/env node
+// Thin CLI wrapper around validateProjectPageSummary (src/renderer/lib/
+// projectPages/summaryValidate.ts), compiled into
+// scripts/project-pages-logic/dist/logic.cjs by `npm run
+// build:project-pages-logic`. The project-home-builder Epic runs this
+// against its own summary.json before proceeding to Stage 2/3 (see
+// .claude/agents/project-home-builder.md).
+//
+// Usage: node scripts/validate-project-pages-summary.cjs <summary.json path>
+// Exits 0 and prints "valid" on success; exits 1 and prints each error on
+// failure. Same CLI-wrapper pattern as scripts/render-project-pages.cjs.
+//
+// The path argument is used as-is (no allowedRoots validation like
+// config.cjs's validatePath) — this is a standalone local dev/ops script run
+// by a trusted human or agent shell, not an IPC-reachable surface, so it's
+// out of scope for that guard by design.
+'use strict';
+
+const fs = require('node:fs');
+const path = require('node:path');
+
+function fail(message) {
+  console.error(`validate-project-pages-summary: ${message}`);
+  process.exit(1);
+}
+
+function main() {
+  const [summaryPath] = process.argv.slice(2);
+  if (!summaryPath) {
+    fail('usage: node scripts/validate-project-pages-summary.cjs <summary.json path>');
+  }
+
+  const bundlePath = path.join(__dirname, 'project-pages-logic', 'dist', 'logic.cjs');
+  if (!fs.existsSync(bundlePath)) {
+    fail(`build bundle not found at ${bundlePath} — run "npm run build:project-pages-logic" first`);
+  }
+
+  let validateProjectPageSummary;
+  try {
+    ({ validateProjectPageSummary } = require(bundlePath));
+  } catch (err) {
+    fail(`failed to load ${bundlePath}: ${err.message}`);
+  }
+
+  let summary;
+  try {
+    summary = JSON.parse(fs.readFileSync(summaryPath, 'utf8'));
+  } catch (err) {
+    fail(`could not read/parse ${summaryPath}: ${err.message}`);
+  }
+
+  const result = validateProjectPageSummary(summary);
+  if (!result.ok) {
+    console.error('validate-project-pages-summary: invalid summary:');
+    for (const err of result.errors) console.error(`  - ${err}`);
+    process.exit(1);
+  }
+
+  console.log('valid');
+}
+
+main();

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

@@ -18,6 +18,7 @@ const {
   resolveEpicModel,
   findAgentTypeByClaudeSessionId,
   readPersonaModel,
+  resolvePrdPersonaForSpawn,
 } = require('../lib/agentModelResolve.cjs');
 
 const tmpDirs = [];
@@ -136,3 +137,68 @@ test('readPersonaModel returns null (does not throw) for a persona deleted after
   expect(matches).toHaveLength(1);
   expect(matches[0].level).toBe('warn');
 });
+
+// resolvePrdPersonaForSpawn — the PRD-path resolver scheduler.cjs's executeJob
+// calls to turn a job's agentType into a --append-system-prompt body and a
+// --model value (PRD 1115).
+
+test('resolvePrdPersonaForSpawn returns the persona body and its own model, overriding the fallback', async () => {
+  const result = await resolvePrdPersonaForSpawn({
+    cwd: '/irrelevant',
+    agentType: 'dev-lead',
+    deps: {
+      getPersonaBody: async ({ name }) => {
+        expect(name).toBe('dev-lead');
+        return { path: '/home/user/.claude/agents/dev-lead.md', text: '---\nmodel: opus\n---\nOperate methodically.' };
+      },
+    },
+  });
+  expect(result.model).toBe('opus');
+  expect(result.systemPrompt).toBe('Operate methodically.');
+  expect(result.personaPath).toBe('/home/user/.claude/agents/dev-lead.md');
+});
+
+test("resolvePrdPersonaForSpawn falls back to the fallback model when the persona's model is 'inherit'", async () => {
+  const result = await resolvePrdPersonaForSpawn({
+    cwd: '/irrelevant',
+    agentType: 'dev-lead',
+    deps: { getPersonaBody: async () => ({ path: '/x/dev-lead.md', text: '---\nmodel: inherit\n---\nBody text.' }) },
+  });
+  expect(result.model).toBe(FALLBACK_MODEL);
+});
+
+test('resolvePrdPersonaForSpawn falls back without throwing when agentType no longer resolves to a persona file, and logs it once', async () => {
+  const cwd = await mkTmpDir('sm-agentmodel-cwd-');
+  const call = () => resolvePrdPersonaForSpawn({
+    cwd,
+    agentType: 'ghost-persona',
+    deps: { getPersonaBody: async () => null },
+  });
+  await expect(call()).resolves.toEqual({ model: FALLBACK_MODEL, systemPrompt: null, personaPath: null });
+  await call(); // second call must not log a second line (dedup)
+
+  const { todayFile } = require('../lib/opsErrorLog.cjs');
+  const lines = fs.readFileSync(todayFile(cwd), 'utf8').split('\n').filter(Boolean).map((l) => JSON.parse(l));
+  const matches = lines.filter((l) => l.message.includes('ghost-persona'));
+  expect(matches).toHaveLength(1);
+  expect(matches[0].level).toBe('warn');
+});
+
+test('resolvePrdPersonaForSpawn returns the fallback (no persona applied) when agentType is absent, without touching getPersonaBody', async () => {
+  const getPersonaBody = async () => { throw new Error('must not be called'); };
+  const result = await resolvePrdPersonaForSpawn({ cwd: '/irrelevant', agentType: null, deps: { getPersonaBody } });
+  expect(result).toEqual({ model: FALLBACK_MODEL, systemPrompt: null, personaPath: null });
+});
+
+test('resolvePrdPersonaForSpawn caps the persona body at 6000 characters with a truncation notice naming the persona path', async () => {
+  const longBody = 'x'.repeat(6500);
+  const result = await resolvePrdPersonaForSpawn({
+    cwd: '/irrelevant',
+    agentType: 'dev-lead',
+    deps: { getPersonaBody: async () => ({ path: '/home/user/.claude/agents/dev-lead.md', text: longBody }) },
+  });
+  expect(result.systemPrompt.startsWith('x'.repeat(6000))).toBe(true);
+  expect(result.systemPrompt.length).toBeLessThan(longBody.length);
+  expect(result.systemPrompt.toLowerCase()).toContain('truncat');
+  expect(result.systemPrompt).toContain('/home/user/.claude/agents/dev-lead.md');
+});

package/src/main/__tests__/health-delegation-chain.test.cjs

@@ -86,7 +86,7 @@ test('failing check with no fix omits the "(fix: ...)" suffix', () => {
 test('end-to-end: check() reports delegation_chain for this repo, expected to pass here', async () => {
   const status = await check();
   expect(status.components.delegation_chain).toBeDefined();
-  expect(status.components.delegation_chain.checks).toHaveLength(6);
+  expect(status.components.delegation_chain.checks).toHaveLength(7);
   const ids = status.components.delegation_chain.checks.map((c) => c.id);
   expect(ids).toEqual([
     'scheduler-mcp',
@@ -95,6 +95,7 @@ test('end-to-end: check() reports delegation_chain for this repo, expected to pa
     'dev-plugin',
     'agent-personas',
     'prd-write-guard',
+    'destructive-git-guard',
   ]);
   // This repo registers the scheduler MCP at user scope (~/.claude.json) and
   // wires guard-prd-writes in .claude/settings.json, and no longer carries a

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

@@ -0,0 +1,103 @@
+/**
+ * prdAgentType.test.cjs — the PRD `agentType` FK (lib/prdAgentType.cjs):
+ * throw on write, report on read, mirroring agentModelResolve.cjs's/
+ * epicMint.cjs's established convention for the Epic-level agentType FK.
+ *
+ * Run: timeout 120 npx vitest run src/main/__tests__/prdAgentType.test.cjs
+ */
+
+'use strict';
+
+import { test, expect } from 'vitest';
+
+const fs = require('node:fs');
+const fsp = require('node:fs/promises');
+const os = require('node:os');
+const path = require('node:path');
+const {
+  DEFAULT_PRD_AGENT_TYPE,
+  assertAgentTypeWritable,
+  reportDanglingAgentTypeOnce,
+} = require('../lib/prdAgentType.cjs');
+const { todayFile } = require('../lib/opsErrorLog.cjs');
+
+async function mkTmpDir(prefix) {
+  return fsp.mkdtemp(path.join(os.tmpdir(), prefix));
+}
+
+test('DEFAULT_PRD_AGENT_TYPE is dev-lead', () => {
+  expect(DEFAULT_PRD_AGENT_TYPE).toBe('dev-lead');
+});
+
+test('assertAgentTypeWritable is a no-op when agentType is omitted', async () => {
+  await expect(assertAgentTypeWritable('/some/cwd', null)).resolves.toBeUndefined();
+  await expect(assertAgentTypeWritable('/some/cwd', undefined)).resolves.toBeUndefined();
+  await expect(assertAgentTypeWritable('/some/cwd', '')).resolves.toBeUndefined();
+});
+
+test('assertAgentTypeWritable resolves without throwing when a project-overlay persona file exists', async () => {
+  const cwd = await mkTmpDir('sm-prd-agenttype-');
+  try {
+    const agentsDir = path.join(cwd, '.claude', 'agents');
+    await fsp.mkdir(agentsDir, { recursive: true });
+    await fsp.writeFile(path.join(agentsDir, 'my-persona.md'), '---\nname: my-persona\n---\nbody\n', 'utf8');
+    await expect(assertAgentTypeWritable(cwd, 'my-persona')).resolves.toBeUndefined();
+  } finally {
+    await fsp.rm(cwd, { recursive: true, force: true });
+  }
+});
+
+test('assertAgentTypeWritable rejects an unknown persona name, naming available personas in the error', async () => {
+  const cwd = await mkTmpDir('sm-prd-agenttype-');
+  try {
+    await expect(
+      assertAgentTypeWritable(cwd, 'zzz-definitely-not-a-real-persona-12345'),
+    ).rejects.toThrow(/does not resolve to a readable persona file/);
+    await expect(
+      assertAgentTypeWritable(cwd, 'zzz-definitely-not-a-real-persona-12345'),
+    ).rejects.toThrow(/Available personas/);
+  } finally {
+    await fsp.rm(cwd, { recursive: true, force: true });
+  }
+});
+
+// READ side of the FK, mirroring agentModelResolve.test.cjs's sibling test
+// for the Epic-level FK: verify against the REAL opsErrorLog write path
+// (todayFile), not a mock — a plain mkdtemp() cwd is not "ephemeral"
+// (ephemeralCwd.cjs only refuses os.tmpdir() itself / managed worktree
+// roots), so appendError writes a real line here.
+test('reportDanglingAgentTypeOnce logs once via opsErrorLog when the persona does not resolve, and never throws', async () => {
+  const cwd = await mkTmpDir('sm-prd-agenttype-log-');
+  try {
+    expect(() => {
+      reportDanglingAgentTypeOnce(cwd, 'ghost-persona-xyz', { personaExists: () => false });
+      reportDanglingAgentTypeOnce(cwd, 'ghost-persona-xyz', { personaExists: () => false });
+    }).not.toThrow();
+
+    const lines = fs.readFileSync(todayFile(cwd), 'utf8').split('\n').filter(Boolean).map((l) => JSON.parse(l));
+    const matches = lines.filter((l) => l.message.includes('ghost-persona-xyz'));
+    // Logged once despite two calls above — dedup key is (cwd, agentType).
+    expect(matches).toHaveLength(1);
+    expect(matches[0].level).toBe('warn');
+    expect(matches[0].scope).toBe('prdAgentType');
+  } finally {
+    await fsp.rm(cwd, { recursive: true, force: true });
+  }
+});
+
+test('reportDanglingAgentTypeOnce is a no-op when the persona resolves', async () => {
+  const cwd = await mkTmpDir('sm-prd-agenttype-log-');
+  try {
+    reportDanglingAgentTypeOnce(cwd, 'real-persona', { personaExists: () => true });
+    expect(fs.existsSync(todayFile(cwd))).toBe(false);
+  } finally {
+    await fsp.rm(cwd, { recursive: true, force: true });
+  }
+});
+
+test('reportDanglingAgentTypeOnce is a no-op when cwd or agentType is missing', () => {
+  expect(() => {
+    reportDanglingAgentTypeOnce(null, 'x', { personaExists: () => false });
+    reportDanglingAgentTypeOnce('/some/cwd-missing-agenttype', null, { personaExists: () => false });
+  }).not.toThrow();
+});

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

@@ -80,6 +80,23 @@ test('buildPrdBody emits required frontmatter keys and body sections in order',
   expect(body.includes('Lay out hot data contiguously')).toBeFalsy();
 });
 
+test('buildPrdBody emits agentType: dev-lead by default when omitted (PRD 1114)', () => {
+  const body = buildPrdBody({
+    title: 't', cwd: '~/x', estimateMinutes: 5, goal: 'g',
+    acceptanceCriteria: ['a'], implementationNotes: 'n',
+  });
+  expect(body).toMatch(/^agentType: dev-lead$/m);
+});
+
+test('buildPrdBody emits the supplied agentType instead of the default', () => {
+  const body = buildPrdBody({
+    title: 't', cwd: '~/x', estimateMinutes: 5, goal: 'g',
+    acceptanceCriteria: ['a'], implementationNotes: 'n',
+    agentType: 'architect',
+  });
+  expect(body).toMatch(/^agentType: architect$/m);
+});
+
 test('buildPrdBody omits parallelGroup frontmatter key when not supplied', () => {
   const body = buildPrdBody({
     title: 't', cwd: '~/x', estimateMinutes: 5, goal: 'g',
@@ -530,6 +547,56 @@ test('POST /admin/scheduler/create-prd with tag writes it into the created PRD f
   }
 });
 
+// ──────────────────────────────────────────── PRD 1114: agentType (WHO
+// executes a PRD) — throw on write for an unresolvable persona, default to
+// dev-lead when omitted.
+
+test('createPrd rejects an unknown agentType at write time, naming available personas, and writes no file', async () => {
+  const prdsDir = await mkTmpPrdsDir();
+  const remote = makeFakeRemoteWithPrdsDir(prdsDir);
+  const writePrdSpy = vi.fn(remote.writePrd);
+  remote.writePrd = writePrdSpy;
+
+  const result = await createPrd(
+    validCreateBody({ agentType: 'zzz-definitely-not-a-real-persona-12345' }),
+    remote,
+  );
+
+  expect(result.ok).toBe(false);
+  expect(result.status).toBe(400);
+  expect(result.error).toMatch(/does not resolve to a readable persona file/);
+  expect(result.error).toMatch(/Available personas/);
+  expect(writePrdSpy).not.toHaveBeenCalled();
+  const entries = await fsp.readdir(prdsDir);
+  expect(entries.filter((f) => f.endsWith('.md')).length).toBe(0);
+});
+
+test('createPrd accepts a caller-supplied agentType that resolves to a project-overlay persona file', async () => {
+  const prdsDir = await mkTmpPrdsDir();
+  const cwd = path.dirname(path.dirname(prdsDir)); // mkTmpPrdsDir's root (prdsDir = root/.claude/prds)
+  const agentsDir = path.join(cwd, '.claude', 'agents');
+  await fsp.mkdir(agentsDir, { recursive: true });
+  await fsp.writeFile(path.join(agentsDir, 'my-persona.md'), '---\nname: my-persona\n---\nbody\n', 'utf8');
+  const remote = makeFakeRemoteWithPrdsDir(prdsDir);
+
+  const result = await createPrd(validCreateBody({ cwd, slug: 'with-agent-type', agentType: 'my-persona' }), remote);
+
+  expect(result.ok).toBe(true);
+  const written = await fsp.readFile(path.join(prdsDir, result.filename), 'utf8');
+  expect(written).toMatch(/^agentType: my-persona$/m);
+});
+
+test('createPrd defaults agentType to dev-lead when omitted, without any persona-existence check', async () => {
+  const prdsDir = await mkTmpPrdsDir();
+  const remote = makeFakeRemoteWithPrdsDir(prdsDir);
+
+  const result = await createPrd(validCreateBody({ slug: 'no-agent-type-supplied' }), remote);
+
+  expect(result.ok).toBe(true);
+  const written = await fsp.readFile(path.join(prdsDir, result.filename), 'utf8');
+  expect(written).toMatch(/^agentType: dev-lead$/m);
+});
+
 // ──────────────────────────────────────────── originClaudeSessionId fallback
 // (2026-08-01 fix: a PRD queued via the scheduler_create_prd MCP tool from
 // inside an Epic's own chat session, without an explicit sourcePromptId,
@@ -692,6 +759,77 @@ test('createPrd with neither cwd nor a resolvable Epic fails with a clear cwd-re
   expect(result.error).toMatch(/cwd is required/);
 });
 
+// ──────────────────────────────────────────── PRD 1113: fix-chain depth guard
+// at the authoring boundary. lib/prdCreate.cjs's createPrd() is the shared
+// write path behind both scheduler_create_prd (MCP) and chat:create-prd
+// (IPC) — enforcing here covers both callers with one check.
+
+test('createPrd refuses a depth-2 fix-chain slug (fix-of-a-fix) with a distinct, human-escalation error and writes no file', async () => {
+  const prdsDir = await mkTmpPrdsDir();
+  const remote = makeFakeRemoteWithPrdsDir(prdsDir);
+  const writePrdSpy = vi.fn(remote.writePrd);
+  remote.writePrd = writePrdSpy;
+
+  const result = await createPrd(validCreateBody({ slug: 'fix-fix-widget-frobnication' }), remote);
+
+  expect(result.ok).toBe(false);
+  expect(result.status).toBe(409);
+  // Distinct from the provenance/validation error text elsewhere in this
+  // file ('cwd rejected', 'invalid PRD payload', 'already exists') and
+  // explicitly states escalation, not another attempt, is correct.
+  expect(result.error).toMatch(/fix-chain depth cap/i);
+  expect(result.error).toMatch(/not the correct response/i);
+  expect(result.error).toMatch(/human/i);
+  expect(writePrdSpy).not.toHaveBeenCalled();
+  const entries = await fsp.readdir(prdsDir);
+  expect(entries.filter((f) => f.endsWith('.md')).length).toBe(0);
+});
+
+test('createPrd refuses a depth-3 fix-chain slug the same way as depth-2', async () => {
+  const prdsDir = await mkTmpPrdsDir();
+  const remote = makeFakeRemoteWithPrdsDir(prdsDir);
+
+  const result = await createPrd(validCreateBody({ slug: 'fix-fix-fix-widget-frobnication' }), remote);
+
+  expect(result.ok).toBe(false);
+  expect(result.status).toBe(409);
+  const entries = await fsp.readdir(prdsDir);
+  expect(entries.filter((f) => f.endsWith('.md')).length).toBe(0);
+});
+
+test('createPrd allows a depth-1 fix slug through the same code path that rejects depth 2 (matches MAX_INVESTIGATION_DEPTH=1)', async () => {
+  const prdsDir = await mkTmpPrdsDir();
+  const remote = makeFakeRemoteWithPrdsDir(prdsDir);
+
+  const result = await createPrd(validCreateBody({ slug: 'fix-widget-frobnication' }), remote);
+
+  expect(result.ok).toBe(true);
+  expect(result.filename).toMatch(/^\d+-fix-widget-frobnication\.md$/);
+  const written = await fsp.readFile(path.join(prdsDir, result.filename), 'utf8');
+  expect(written).toMatch(/title: Add widget frobnication/);
+});
+
+test('createPrd is unaffected by the fix-chain guard for an ordinary slug with no fix chain at all', async () => {
+  const prdsDir = await mkTmpPrdsDir();
+  const remote = makeFakeRemoteWithPrdsDir(prdsDir);
+
+  const result = await createPrd(validCreateBody(), remote);
+
+  expect(result.ok).toBe(true);
+  const written = await fsp.readFile(path.join(prdsDir, result.filename), 'utf8');
+  expect(written).toMatch(/title: Add widget frobnication/);
+});
+
+test('createPrd is not fooled by a slug where a later segment merely reads "fix" (false-positive bait)', async () => {
+  const prdsDir = await mkTmpPrdsDir();
+  const remote = makeFakeRemoteWithPrdsDir(prdsDir);
+
+  const result = await createPrd(validCreateBody({ slug: 'fix-loop-extraction-and-round-trip' }), remote);
+
+  expect(result.ok).toBe(true);
+  expect(result.filename).toMatch(/^\d+-fix-loop-extraction-and-round-trip\.md$/);
+});
+
 test('createPrd leaves sourcePromptId unset when originClaudeSessionId matches no known Epic (plain SessionTab chat)', async () => {
   const root = await fsp.mkdtemp(path.join(os.homedir(), '.sm-origin-session-no-match-'));
   config.addAllowedRoot(root);