claude-code-session-manager 0.74.0 → 0.75.0

package/src/main/lib/__tests__/epicDelegationStats.test.cjs

@@ -0,0 +1,137 @@
+/**
+ * epicDelegationStats.test.cjs — unit tests for the derived-at-read-time
+ * "did this Epic delegate?" counters (prdsQueued from the Epic's own live
+ * PRD dir, inlineEdits from its interactive claude session transcript).
+ *
+ * Run: timeout 120 npx vitest run src/main/lib/__tests__/epicDelegationStats.test.cjs
+ */
+
+'use strict';
+
+import { test, expect, afterEach } from 'vitest';
+const fs = require('node:fs');
+const os = require('node:os');
+const path = require('node:path');
+const {
+  computeEpicDelegationStats,
+  countPrdsQueued,
+  countInlineEdits,
+  isApplicationSourcePath,
+} = require('../epicDelegationStats.cjs');
+const { encodeCwd } = require('../encodeCwd.cjs');
+
+const tmpDirs = [];
+function makeTmpCwd() {
+  const dir = fs.mkdtempSync(path.join(os.tmpdir(), 'epic-delegation-'));
+  tmpDirs.push(dir);
+  return dir;
+}
+
+afterEach(() => {
+  while (tmpDirs.length) {
+    fs.rmSync(tmpDirs.pop(), { recursive: true, force: true });
+  }
+});
+
+function makeTmpHome() {
+  const dir = fs.mkdtempSync(path.join(os.tmpdir(), 'epic-delegation-home-'));
+  tmpDirs.push(dir);
+  return dir;
+}
+
+function writeTranscript(homeDir, cwd, sessionId, lines) {
+  const dir = path.join(homeDir, '.claude', 'projects', encodeCwd(cwd));
+  fs.mkdirSync(dir, { recursive: true });
+  const filePath = path.join(dir, `${sessionId}.jsonl`);
+  fs.writeFileSync(filePath, lines.map((l) => JSON.stringify(l)).join('\n') + '\n');
+  return filePath;
+}
+
+function toolUseLine(name, filePath) {
+  return {
+    type: 'assistant',
+    message: { content: [{ type: 'tool_use', name, id: 't1', input: { file_path: filePath } }] },
+  };
+}
+
+test('countPrdsQueued counts only .md files in the Epic own live prds dir', () => {
+  const cwd = makeTmpCwd();
+  const prdsDir = path.join(cwd, 'session-manager-operations', 'scheduler', 'epics', 'epic-1', 'prds');
+  fs.mkdirSync(prdsDir, { recursive: true });
+  fs.writeFileSync(path.join(prdsDir, '01-foo.md'), '# foo');
+  fs.writeFileSync(path.join(prdsDir, '02-bar.md'), '# bar');
+  fs.writeFileSync(path.join(prdsDir, '.reserved-03'), '');
+  expect(countPrdsQueued(cwd, 'epic-1')).toBe(2);
+});
+
+test('countPrdsQueued returns 0 when the prds dir does not exist', () => {
+  const cwd = makeTmpCwd();
+  expect(countPrdsQueued(cwd, 'missing-epic')).toBe(0);
+});
+
+test('isApplicationSourcePath matches src/scripts/plugins/bin, rejects everything else', () => {
+  const cwd = '/repo';
+  expect(isApplicationSourcePath(cwd, '/repo/src/main/index.cjs')).toBe(true);
+  expect(isApplicationSourcePath(cwd, '/repo/scripts/hooks/foo.cjs')).toBe(true);
+  expect(isApplicationSourcePath(cwd, '/repo/plugins/dev/skill.md')).toBe(true);
+  expect(isApplicationSourcePath(cwd, '/repo/bin/cli.cjs')).toBe(true);
+  expect(isApplicationSourcePath(cwd, '/repo/session-manager-operations/scheduler/epics/e1/prds/01.md')).toBe(false);
+  expect(isApplicationSourcePath(cwd, '/repo/README.md')).toBe(false);
+  expect(isApplicationSourcePath(cwd, '/outside/src/index.cjs')).toBe(false);
+  expect(isApplicationSourcePath(cwd, undefined)).toBe(false);
+});
+
+test('countInlineEdits counts Write/Edit/NotebookEdit tool_use blocks under application source only', () => {
+  const cwd = makeTmpCwd();
+  const homeDir = makeTmpHome();
+  writeTranscript(homeDir, cwd, 'sess-1', [
+    toolUseLine('Write', path.join(cwd, 'src', 'main', 'foo.cjs')),
+    toolUseLine('Edit', path.join(cwd, 'src', 'main', 'foo.cjs')),
+    toolUseLine('Read', path.join(cwd, 'src', 'main', 'foo.cjs')),
+    toolUseLine('Write', path.join(cwd, 'session-manager-operations', 'scheduler', 'epics', 'e1', 'prds', '01.md')),
+    toolUseLine('NotebookEdit', path.join(cwd, 'scripts', 'nb.ipynb')),
+  ]);
+  expect(countInlineEdits(cwd, 'sess-1', { homeDir })).toBe(3);
+});
+
+test('countInlineEdits returns 0 when the transcript file does not exist', () => {
+  const cwd = makeTmpCwd();
+  const homeDir = makeTmpHome();
+  expect(countInlineEdits(cwd, 'no-such-session', { homeDir })).toBe(0);
+});
+
+test('countInlineEdits returns 0 when claudeSessionId is missing', () => {
+  const cwd = makeTmpCwd();
+  expect(countInlineEdits(cwd, null)).toBe(0);
+});
+
+test('countInlineEdits tolerates a malformed trailing line', () => {
+  const cwd = makeTmpCwd();
+  const homeDir = makeTmpHome();
+  const dir = path.join(homeDir, '.claude', 'projects', encodeCwd(cwd));
+  fs.mkdirSync(dir, { recursive: true });
+  const filePath = path.join(dir, 'sess-2.jsonl');
+  fs.writeFileSync(
+    filePath,
+    JSON.stringify(toolUseLine('Write', path.join(cwd, 'src', 'a.ts'))) + '\n{not json\n',
+  );
+  expect(countInlineEdits(cwd, 'sess-2', { homeDir })).toBe(1);
+});
+
+test('computeEpicDelegationStats combines both counters and never throws on missing state', () => {
+  const cwd = makeTmpCwd();
+  const homeDir = makeTmpHome();
+  expect(computeEpicDelegationStats(cwd, 'ghost-epic', 'ghost-session', { homeDir })).toEqual({
+    prdsQueued: 0,
+    inlineEdits: 0,
+  });
+
+  const prdsDir = path.join(cwd, 'session-manager-operations', 'scheduler', 'epics', 'epic-2', 'prds');
+  fs.mkdirSync(prdsDir, { recursive: true });
+  fs.writeFileSync(path.join(prdsDir, '01-foo.md'), '# foo');
+  writeTranscript(homeDir, cwd, 'sess-3', [toolUseLine('Edit', path.join(cwd, 'src', 'x.ts'))]);
+  expect(computeEpicDelegationStats(cwd, 'epic-2', 'sess-3', { homeDir })).toEqual({
+    prdsQueued: 1,
+    inlineEdits: 1,
+  });
+});

package/src/main/lib/delegationReadiness.cjs

@@ -0,0 +1,141 @@
+/**
+ * Delegation-readiness probe — answers "can this project actually hand work
+ * to the scheduler?" as structured data instead of a silent tool-list gap.
+ *
+ * Why this exists: when the session-manager-scheduler MCP server isn't
+ * registered, `scheduler_create_prd` is simply absent from the agent's tool
+ * list — there's no error to catch, so an agent asked to delegate just
+ * implements inline instead. See scripts/install-scheduler-mcp-user-scope.sh's
+ * header for the incident this repeat-guards against (PRD 1024-1030).
+ *
+ * This module only computes the four checks below; surfacing them in the UI
+ * or the Epic's grounding line is a dependent PRD (delegation-readiness-ui).
+ */
+
+const fs = require('node:fs');
+const path = require('node:path');
+const os = require('node:os');
+
+const SCHEDULER_MCP_NAME = 'session-manager-scheduler';
+const DEV_PLUGIN_ENABLED_KEY = 'session-manager-dev@session-manager';
+const SCHEDULER_MCP_SERVER_SCRIPT = path.resolve(__dirname, '..', '..', '..', 'scripts', 'scheduler-mcp-server.cjs');
+
+/** Read + JSON.parse a file, returning `fallback` on any read/parse failure. */
+function readJsonSafe(absPath, fallback) {
+  try {
+    return JSON.parse(fs.readFileSync(absPath, 'utf8'));
+  } catch {
+    return fallback;
+  }
+}
+
+function checkSchedulerMcp({ cwd, homeDir }) {
+  const userConfig = readJsonSafe(path.join(homeDir, '.claude.json'), null);
+  const userHas = !!userConfig?.mcpServers?.[SCHEDULER_MCP_NAME];
+
+  const projectConfig = readJsonSafe(path.join(cwd, '.mcp.json'), null);
+  const projectHas = !!projectConfig?.mcpServers?.[SCHEDULER_MCP_NAME];
+
+  const ok = userHas || projectHas;
+  let detail;
+  if (userHas) detail = `${SCHEDULER_MCP_NAME} registered at user scope (~/.claude.json)`;
+  else if (projectHas) detail = `${SCHEDULER_MCP_NAME} registered at project scope (${cwd}/.mcp.json)`;
+  else detail = `no ${SCHEDULER_MCP_NAME} entry in ~/.claude.json or ${cwd}/.mcp.json`;
+
+  return {
+    id: 'scheduler-mcp',
+    label: 'Scheduler MCP server registered',
+    ok,
+    detail,
+    fix: ok
+      ? null
+      : `claude mcp add ${SCHEDULER_MCP_NAME} --scope user -- node ${SCHEDULER_MCP_SERVER_SCRIPT}`,
+  };
+}
+
+function checkDevPlugin({ homeDir }) {
+  const settings = readJsonSafe(path.join(homeDir, '.claude', 'settings.json'), null);
+  const ok = settings?.enabledPlugins?.[DEV_PLUGIN_ENABLED_KEY] === true;
+
+  return {
+    id: 'dev-plugin',
+    label: 'session-manager-dev plugin enabled',
+    ok,
+    detail: ok
+      ? `${DEV_PLUGIN_ENABLED_KEY} enabled in ~/.claude/settings.json`
+      : `${DEV_PLUGIN_ENABLED_KEY} missing from ~/.claude/settings.json enabledPlugins`,
+    fix: ok ? null : 'Enable in Plugins tab: session-manager-dev (Session Manager)',
+  };
+}
+
+// Personas resolve from BOTH scopes (agentLibrary.cjs: "project cwd wins
+// over the global" one) — a project that only ever defines project-scoped
+// overrides in `<cwd>/.claude/agents/` (this repo's own `.claude/agents/`
+// is exactly that case) is a legitimately delegation-ready project, not a
+// failing one, so both directories must be counted.
+function countMdFiles(dir) {
+  try {
+    return fs.readdirSync(dir).filter((f) => f.endsWith('.md')).length;
+  } catch {
+    return 0;
+  }
+}
+
+function checkAgentPersonas({ cwd, homeDir }) {
+  const globalCount = countMdFiles(path.join(homeDir, '.claude', 'agents'));
+  const projectCount = countMdFiles(path.join(cwd, '.claude', 'agents'));
+  const count = globalCount + projectCount;
+  const ok = count > 0;
+
+  return {
+    id: 'agent-personas',
+    label: 'At least one agent persona defined',
+    ok,
+    detail: ok
+      ? `${count} persona(s) across ~/.claude/agents/ and ${cwd}/.claude/agents/`
+      : `no .md personas in ~/.claude/agents/ or ${cwd}/.claude/agents/`,
+    fix: ok ? null : 'Create a persona in the Agent Library tab',
+  };
+}
+
+function checkPrdWriteGuard({ cwd }) {
+  const settings = readJsonSafe(path.join(cwd, '.claude', 'settings.json'), null);
+  const preToolUse = Array.isArray(settings?.hooks?.PreToolUse) ? settings.hooks.PreToolUse : [];
+  const ok = preToolUse.some((matcher) =>
+    Array.isArray(matcher?.hooks) &&
+    matcher.hooks.some((h) => typeof h?.command === 'string' && h.command.includes('guard-prd-writes'))
+  );
+
+  return {
+    id: 'prd-write-guard',
+    label: 'PRD-write guard hook installed',
+    ok,
+    detail: ok
+      ? `guard-prd-writes PreToolUse hook found in ${cwd}/.claude/settings.json`
+      : `no guard-prd-writes PreToolUse hook in ${cwd}/.claude/settings.json`,
+    fix: ok
+      ? null
+      : `Add a PreToolUse hook to ${cwd}/.claude/settings.json matching Write|Edit|NotebookEdit that runs node scripts/hooks/guard-prd-writes.cjs`,
+  };
+}
+
+/**
+ * Runs all four delegation-readiness checks for `cwd`. Every filesystem read
+ * is wrapped (readJsonSafe / try-catch) so a missing or unparseable file
+ * yields ok:false with a detail, never a thrown exception.
+ */
+function checkDelegationReadiness({ cwd, homeDir = os.homedir() }) {
+  const checks = [
+    checkSchedulerMcp({ cwd, homeDir }),
+    checkDevPlugin({ homeDir }),
+    checkAgentPersonas({ cwd, homeDir }),
+    checkPrdWriteGuard({ cwd }),
+  ];
+
+  return {
+    ok: checks.every((c) => c.ok),
+    checks,
+  };
+}
+
+module.exports = { checkDelegationReadiness };

package/src/main/lib/epicDelegationStats.cjs

@@ -0,0 +1,124 @@
+'use strict';
+
+/**
+ * Derived-at-read-time counters answering "did this Epic delegate work into
+ * PRDs, or did the interactive session just edit application source
+ * inline?" — no new writer, no new namespace; both numbers are computed
+ * from state that already exists on disk (single-writer law,
+ * opsOwnership.cjs).
+ *
+ * prdsQueued reads the Epic's own live PRD dir
+ * (session-manager-operations/scheduler/epics/<epicId>/prds/) — the
+ * "prds-archived" sibling deliberately does NOT count here: this is a
+ * live-delegation signal, not a lifetime PRD count (that's epicPrds() in
+ * the renderer, sourced from the scheduler's own snapshot).
+ *
+ * inlineEdits reads the Epic's OWN interactive claude session transcript —
+ * ~/.claude/projects/<encodeCwd(cwd)>/<claudeSessionId>.jsonl, the same file
+ * transcripts.cjs already tails for the live feed — and counts Write/Edit/
+ * NotebookEdit tool_use blocks whose file_path resolves under this repo's
+ * src/, scripts/, plugins/, or bin/. That transcript already carries real
+ * tool_use blocks (classifyTranscriptLine.cjs); the durable
+ * session-manager-operations/prompt-sessions/transcripts/<epicId>.jsonl
+ * store does NOT (it holds only rendered {role, text} turns, verified by
+ * reading one), so it is not a usable source for this counter.
+ */
+
+const fs = require('node:fs');
+const os = require('node:os');
+const path = require('node:path');
+const { encodeCwd } = require('./encodeCwd.cjs');
+const { classifyLine } = require('./classifyTranscriptLine.cjs');
+
+// Same cap transcripts.cjs's readDelta uses for a single pass — bounds
+// memory/time on a very large transcript instead of reading it whole.
+const MAX_TRANSCRIPT_BYTES = 8 * 1024 * 1024;
+
+const INLINE_EDIT_TOOL_NAMES = new Set(['Write', 'Edit', 'NotebookEdit']);
+const APPLICATION_SOURCE_PREFIXES = ['src/', 'scripts/', 'plugins/', 'bin/'];
+
+function countPrdsQueued(cwd, epicId, deps = {}) {
+  const readdirSync = deps.readdirSync || fs.readdirSync;
+  try {
+    const dir = path.join(cwd, 'session-manager-operations', 'scheduler', 'epics', epicId, 'prds');
+    return readdirSync(dir).filter((name) => name.endsWith('.md')).length;
+  } catch {
+    return 0;
+  }
+}
+
+/** True when `filePath` (absolute or relative) resolves to a path under
+ *  cwd's src/, scripts/, plugins/, or bin/ — never a dotfile/root config,
+ *  never a path outside the repo entirely. */
+function isApplicationSourcePath(cwd, filePath) {
+  if (typeof filePath !== 'string' || !filePath) return false;
+  const rel = path.relative(cwd, path.resolve(cwd, filePath)).split(path.sep).join('/');
+  if (rel.startsWith('..')) return false;
+  return APPLICATION_SOURCE_PREFIXES.some((prefix) => rel === prefix.slice(0, -1) || rel.startsWith(prefix));
+}
+
+/** Reads at most the trailing MAX_TRANSCRIPT_BYTES of `filePath`, dropping
+ *  a truncated leading partial line when the read didn't start at byte 0. */
+function readTranscriptTail(filePath, deps = {}) {
+  const statSync = deps.statSync || fs.statSync;
+  const openSync = deps.openSync || fs.openSync;
+  const readSync = deps.readSync || fs.readSync;
+  const closeSync = deps.closeSync || fs.closeSync;
+
+  const size = statSync(filePath).size;
+  const start = Math.max(0, size - MAX_TRANSCRIPT_BYTES);
+  const length = size - start;
+  const buffer = Buffer.alloc(length);
+  const fd = openSync(filePath, 'r');
+  try {
+    readSync(fd, buffer, 0, length, start);
+  } finally {
+    closeSync(fd);
+  }
+  const text = buffer.toString('utf8');
+  return start > 0 ? text.slice(text.indexOf('\n') + 1) : text;
+}
+
+function countInlineEdits(cwd, claudeSessionId, deps = {}) {
+  if (!claudeSessionId) return 0;
+  const readFn = deps.readTranscriptTail || readTranscriptTail;
+  const homeDir = deps.homeDir || os.homedir();
+  try {
+    const filePath = path.join(homeDir, '.claude', 'projects', encodeCwd(cwd), `${claudeSessionId}.jsonl`);
+    const text = readFn(filePath, deps);
+    let count = 0;
+    for (const line of text.split('\n')) {
+      const trimmed = line.trim();
+      if (!trimmed) continue;
+      let obj;
+      try {
+        obj = JSON.parse(trimmed);
+      } catch {
+        continue;
+      }
+      for (const event of classifyLine(obj)) {
+        if (event.kind !== 'tool_use') continue;
+        const { name, input } = event.data || {};
+        if (!INLINE_EDIT_TOOL_NAMES.has(name)) continue;
+        if (isApplicationSourcePath(cwd, input?.file_path)) count += 1;
+      }
+    }
+    return count;
+  } catch {
+    return 0;
+  }
+}
+
+function computeEpicDelegationStats(cwd, epicId, claudeSessionId, deps = {}) {
+  return {
+    prdsQueued: countPrdsQueued(cwd, epicId, deps),
+    inlineEdits: countInlineEdits(cwd, claudeSessionId, deps),
+  };
+}
+
+module.exports = {
+  computeEpicDelegationStats,
+  countPrdsQueued,
+  countInlineEdits,
+  isApplicationSourcePath,
+};

package/src/main/lib/promptSessionSchema.cjs

@@ -41,7 +41,7 @@ const EpicSourceSchema = z.object({
 // data so the Epic's first turn can render a structured AIM briefing card
 // instead of regex-parsing the flat string back apart.
 const EpicIntakeSectionSchema = z.object({
-  kind: z.enum(['actor', 'injection', 'input', 'mission', 'goal', 'reference']),
+  kind: z.enum(['actor', 'persona-body', 'injection', 'input', 'mission', 'goal', 'reference']),
   label: z.string(),
   text: z.string(),
   source: z.string().optional(),

package/src/main/seedAgentPersonas.cjs

@@ -0,0 +1,92 @@
+/**
+ * First-boot seeder for the bundled Agent personas (Architect, Dev Lead).
+ *
+ * On a fresh install `~/.claude/agents/` is empty, so the Agent Library has
+ * nothing to offer — no persona to select for an Epic's Actor. This seeder
+ * copies the personas bundled at `src/seed/agents/*.md` into `~/.claude/agents/`
+ * on first boot, one file per persona, and NEVER overwrites a file that
+ * already exists there (hand-edited or user-authored personas win).
+ *
+ * Idempotent the same way as seedDevPlugin.cjs:
+ *   1. A marker file (`~/.claude/session-manager/.agent-personas-seeded`)
+ *      records seed state. Once seeding SUCCEEDS we write `done` and never
+ *      touch it again. A FAILED attempt only bumps an attempt counter and
+ *      retries on the next few boots (bounded by MAX_ATTEMPTS), so a
+ *      transient first-boot failure doesn't permanently skip the personas.
+ *
+ * Fire-and-forget: called post-window from index.cjs. Errors are logged,
+ * never thrown. Kill-switch: SM_SEED_AGENT_PERSONAS_DISABLE=1.
+ */
+
+const fs = require('node:fs');
+const path = require('node:path');
+const os = require('node:os');
+const { writeJsonSync } = require('./config.cjs');
+
+const PERSONAS = ['architect', 'dev-lead'];
+const MAX_ATTEMPTS = 3; // give a transient first-boot failure a few chances
+
+function bundledSourceDir() {
+  return path.join(__dirname, '..', 'seed', 'agents');
+}
+
+function destAgentsDir() {
+  return path.join(os.homedir(), '.claude', 'agents');
+}
+
+function markerPath() {
+  return path.join(os.homedir(), '.claude', 'session-manager', '.agent-personas-seeded');
+}
+
+/** Read the marker → { done:boolean, attempts:number }. Absent = fresh. */
+function readMarker() {
+  try {
+    const raw = fs.readFileSync(markerPath(), 'utf8').trim();
+    const m = JSON.parse(raw);
+    return { done: !!m.done, attempts: Number(m.attempts) || 0 };
+  } catch {
+    return { done: false, attempts: 0 };
+  }
+}
+
+function writeMarker(state) {
+  try {
+    writeJsonSync(markerPath(), { ...state, ts: new Date().toISOString() });
+  } catch (err) {
+    console.warn('[seedAgentPersonas] could not write marker:', err?.message ?? err);
+  }
+}
+
+async function seedAgentPersonas({ logger = console, writeLog = () => {} } = {}) {
+  if (process.env.SM_SEED_AGENT_PERSONAS_DISABLE === '1') return;
+  const marker = readMarker();
+  if (marker.done) return;                       // succeeded before — leave it alone.
+  if (marker.attempts >= MAX_ATTEMPTS) return;   // gave up — manual copy only.
+
+  try {
+    const srcDir = bundledSourceDir();
+    const destDir = destAgentsDir();
+    fs.mkdirSync(destDir, { recursive: true });
+
+    for (const name of PERSONAS) {
+      const src = path.join(srcDir, `${name}.md`);
+      const dest = path.join(destDir, `${name}.md`);
+      if (fs.existsSync(dest)) continue; // never overwrite an existing persona
+      fs.copyFileSync(src, dest);
+      logger.log?.(`[seedAgentPersonas] seeded ${name}.md`);
+    }
+
+    writeMarker({ done: true, attempts: marker.attempts });
+  } catch (err) {
+    logger.warn?.('[seedAgentPersonas] error:', err?.message ?? err);
+    writeLog({
+      scope: 'seed-agent-personas',
+      level: 'error',
+      message: 'seed error',
+      meta: { error: err?.message ?? String(err), attempt: marker.attempts + 1, maxAttempts: MAX_ATTEMPTS },
+    });
+    writeMarker({ done: false, attempts: marker.attempts + 1 });
+  }
+}
+
+module.exports = { seedAgentPersonas, markerPath, MAX_ATTEMPTS };

package/src/main/seedDevPlugin.cjs

@@ -65,7 +65,7 @@ function writeMarker(state) {
   }
 }
 
-async function seedDevPlugin({ logger = console } = {}) {
+async function seedDevPlugin({ logger = console, writeLog = () => {} } = {}) {
   if (process.env.SM_SEED_DEV_PLUGIN_DISABLE === '1') return;
   const marker = readMarker();
   if (marker.done) return;                       // succeeded before — leave it alone.
@@ -84,12 +84,24 @@ async function seedDevPlugin({ logger = console } = {}) {
     } else {
       // Failure: bump the attempt counter so the next boot can retry (bounded).
       logger.warn?.(`[seedDevPlugin] install failed (exit ${r.exitCode})${r.error ? ` — ${r.error}` : ''}; attempt ${marker.attempts + 1}/${MAX_ATTEMPTS}`);
+      writeLog({
+        scope: 'seed-dev-plugin',
+        level: 'error',
+        message: 'install failed',
+        meta: { exitCode: r.exitCode, error: r.error, attempt: marker.attempts + 1, maxAttempts: MAX_ATTEMPTS },
+      });
       writeMarker({ done: false, attempts: marker.attempts + 1 });
     }
   } catch (err) {
     logger.warn?.('[seedDevPlugin] error:', err?.message ?? err);
+    writeLog({
+      scope: 'seed-dev-plugin',
+      level: 'error',
+      message: 'seed error',
+      meta: { error: err?.message ?? String(err), attempt: marker.attempts + 1, maxAttempts: MAX_ATTEMPTS },
+    });
     writeMarker({ done: false, attempts: marker.attempts + 1 });
   }
 }
 
-module.exports = { seedDevPlugin };
+module.exports = { seedDevPlugin, markerPath, MAX_ATTEMPTS };