claude-code-session-manager 0.74.0 → 0.75.1

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/scheduler.cjs

@@ -2289,6 +2289,37 @@ async function resolveVerifyPrdPath(job) {
   return liveDir ? safeSlugPathIn(liveDir, job.slug) : null;
 }
 
+/**
+ * resolveFixPlanPath(failedJob) → { fixPath, fixSlug, group, livePrdDir }
+ *
+ * Where spawnInvestigation's auto-fix plan for `failedJob` must be written.
+ * The plan belongs in the SAME dir the original PRD lives in right now
+ * (`livePrdDir`, from resolveVerifyPrdPath's live-dir search — usually the
+ * originating Epic's `epics/<epicId>/prds/`), never the retired flat dir:
+ * consolidateFlatPrds (prdMigration.cjs) sweeps only the flat dir and
+ * archives any `.md` there with no live queue row, which a freshly-authored
+ * fix plan never has yet — so writing it flat means the very next
+ * reconcile() pass (src/main/scheduler.cjs's consolidateAllFlatPrds call)
+ * archives it before it can ever be enqueued. `livePrdDir` is null (and the
+ * flat dir, `prdDirForCwd`, is used instead) only when the original PRD
+ * can't be found live anywhere on disk — an archived twin is deliberately
+ * NOT treated as a live location for this purpose.
+ *
+ * Exported as a pure(ish) helper (one fs-free branch, one await) so tests
+ * can prove the round trip — fix plan lands beside its original and
+ * survives a consolidateFlatPrds(cwd) pass — without spawning a real
+ * investigation.
+ */
+async function resolveFixPlanPath(failedJob) {
+  const livePrdPath = await resolveVerifyPrdPath(failedJob);
+  const livePrdDir = livePrdPath ? path.dirname(livePrdPath) : null;
+  const baseSlug = failedJob.slug.replace(/^\d+-/, '');
+  const group = failedJob.parallelGroup ?? 99;
+  const fixSlug = `${String(group).padStart(2, '0')}-fix-${baseSlug}`;
+  const fixPath = path.join(livePrdDir ?? prdDirForCwd(failedJob.cwd), `${fixSlug}.md`);
+  return { fixPath, fixSlug, group, livePrdDir };
+}
+
 /**
  * notifyOriginatingTab(job) → void
  *
@@ -2980,6 +3011,16 @@ function isFixPlanSlug(slug) {
   return /^\d+-fix-/.test(slug);
 }
 
+/**
+ * The fix-plan slug spawnInvestigation authors for a given failed job —
+ * shared by selectAutoFixTargets (queue-membership check) and
+ * reverifyNeedsReview's autofix_plan_unqueued annotation (same check, run
+ * one or more passes later) so both use one slug formula.
+ */
+function fixSlugFor(job) {
+  return `${String(job.parallelGroup ?? 99).padStart(2, '0')}-fix-${job.slug.replace(/^\d+-/, '')}`;
+}
+
 /**
  * Returns true for statuses that a fix-plan completion should promote
  * (clear) on the original job. Both 'failed' and 'needs_review' are
@@ -3165,9 +3206,18 @@ async function spawnInvestigation(failedJob, runDir) {
   const failedLogPath = path.join(runDir, `${failedJob.slug}.log`);
   const investigationLogPath = path.join(runDir, `${failedJob.slug}.investigation.log`);
 
+  // livePrdDir is the SAME dir the original PRD lives in right now (usually
+  // its Epic-scoped `epics/<epicId>/prds/`) — the fix plan must land there
+  // too, since consolidateFlatPrds only ever sweeps the retired flat dir
+  // (prdDirForCwd) and would archive a freshly-authored fix plan on the very
+  // next reconcile() pass before it ever gets a queue row. Only fall back to
+  // the flat dir when the original PRD can't be found on disk at all — an
+  // archived twin (archivedPrdPathForJob) is deliberately NOT used for the
+  // write dir, only for reading originalBody below.
   let originalBody = '';
+  const { fixPath, fixSlug, group, livePrdDir } = await resolveFixPlanPath(failedJob);
   try {
-    const originalPath = (await resolveVerifyPrdPath(failedJob)) ?? archivedPrdPathForJob(failedJob);
+    const originalPath = livePrdDir ? path.join(livePrdDir, `${failedJob.slug}.md`) : archivedPrdPathForJob(failedJob);
     originalBody = (await parsePrd(originalPath)).body;
   } catch {
     originalBody = failedJob.bodyPreview || '(original PRD missing from disk)';
@@ -3175,11 +3225,6 @@ async function spawnInvestigation(failedJob, runDir) {
 
   const logTail = readTail(failedLogPath, 16 * 1024) || '(failed to read log)';
 
-  const baseSlug = failedJob.slug.replace(/^\d+-/, '');
-  const group = failedJob.parallelGroup ?? 99;
-  const fixSlug = `${String(group).padStart(2, '0')}-fix-${baseSlug}`;
-  const fixPath = path.join(prdDirForCwd(failedJob.cwd), `${fixSlug}.md`);
-
   if (fs.existsSync(fixPath)) {
     console.log(`[scheduler] skip investigation: fix plan already exists at ${fixPath}`);
     releaseSlot();
@@ -3281,6 +3326,13 @@ async function spawnInvestigation(failedJob, runDir) {
           ? `investigation spawn failed: ${error?.message ?? String(error)}`
           : `investigation error: ${error.message}`;
         sl(`\n[scheduler] ${errMsg}\n`);
+        // Stamp the outcome even on this early exit — otherwise the job is
+        // left with autoFixAttempted: true and no outcome, which used to
+        // read as a permanent dead-end (see selectAutoFixTargets).
+        mutate((s) => {
+          const j = s.jobs.find((x) => x.slug === failedJob.slug);
+          if (j) j.autoFixOutcome = 'error';
+        }).catch(() => {});
         return;
       }
       sl(`\n[scheduler] investigation exit code=${exitCode}\n`);
@@ -3301,6 +3353,10 @@ async function spawnInvestigation(failedJob, runDir) {
       }
       if (fs.existsSync(fixPath)) {
         console.log(`[scheduler] investigation produced fix plan: ${fixSlug}`);
+        mutate((s) => {
+          const j = s.jobs.find((x) => x.slug === failedJob.slug);
+          if (j) j.autoFixOutcome = 'plan';
+        }).catch(() => {});
       } else {
         console.log(`[scheduler] investigation finished WITHOUT producing fix plan (slug=${failedJob.slug}, code=${exitCode})`);
         // Record the no-plan outcome so selectAutoFixTargets can offer one
@@ -3711,10 +3767,10 @@ async function spawnJob(job, runId, runDir, defaultCwd) {
               process.env.SM_AUTOFIX_DISABLE !== '1' &&
               isEligibleForImmediateAutoFix(s.jobs[i2], s.jobs, fixSlugExists)
             ) {
-              const isNoPlanRetry = s.jobs[i2].autoFixAttempted && s.jobs[i2].autoFixOutcome === 'no-plan';
+              const isRetryAttempt = s.jobs[i2].autoFixAttempted === true;
               s.jobs[i2].autoFixAttempted = true;
               if (!s.jobs[i2].runId) s.jobs[i2].runId = runId;
-              if (isNoPlanRetry) {
+              if (isRetryAttempt) {
                 s.jobs[i2].autoFixRetries = (s.jobs[i2].autoFixRetries ?? 0) + 1;
                 delete s.jobs[i2].autoFixOutcome;
               }
@@ -4337,6 +4393,35 @@ function isUnresolvableNeedsReview(job, { hasRunDir }) {
   return !!job && job.status === 'needs_review' && !job.runId && !hasRunDir;
 }
 
+/**
+ * Pure predicate: an auto-fix attempt whose one bounded retry is already
+ * spent, and whose outcome was NOT 'plan' (a produced plan is judged by
+ * isPlanUnqueued instead — a plan is never retried, only annotated if it
+ * never reaches the queue). Covers all three exhaustible outcomes
+ * ('no-plan', 'error', and unstamped/undefined) — mirrors the retry
+ * eligibility rule in selectAutoFixTargets so a job can never be retry-
+ * eligible there and simultaneously un-annotatable here.
+ */
+function isExhaustedAutoFix(job) {
+  return !!job && job.status === 'needs_review'
+    && job.autoFixAttempted === true
+    && job.autoFixOutcome !== 'plan'
+    && (job.autoFixRetries ?? 0) >= 1;
+}
+
+/**
+ * Pure predicate: an investigation produced a fix plan (autoFixOutcome ===
+ * 'plan') but its fix-plan slug is not present among `queuedSlugs` — the
+ * plan file failed to become a queue row (write failure, or some other
+ * reason reconcile() never ingested it). `queuedSlugs` is the caller's
+ * current job-slug set, passed in rather than read here so this stays pure.
+ */
+function isPlanUnqueued(job, queuedSlugs) {
+  if (!job || job.status !== 'needs_review') return false;
+  if (job.autoFixOutcome !== 'plan') return false;
+  return !queuedSlugs.has(fixSlugFor(job));
+}
+
 /**
  * Pure predicate: is this job eligible for the boot re-verify self-heal? Only
  * needs_review jobs with a run log (own or backfilled via resolveRunId) AND a
@@ -4417,9 +4502,13 @@ function isRescanCandidate(job) {
  *   - a runId, own or backfilled via resolveJobRunId (need a run log to investigate)
  *   - not itself a fix-plan slug (avoids infinite recursion)
  *   - autoFixAttempted cap: a job with no prior attempt is eligible; a job
- *     whose prior attempt outcome was 'no-plan' gets ONE bounded retry
- *     (autoFixRetries < 1); any other attempted job (or an exhausted
- *     no-plan retry) is excluded
+ *     whose prior attempt outcome was 'no-plan', 'error', or UNSTAMPED
+ *     (investigation exited without recording any outcome — unknown is not
+ *     "succeeded") gets ONE bounded retry (autoFixRetries < 1); a job whose
+ *     outcome was 'plan' (a fix plan was produced) is never retried here —
+ *     it either lands as a queue row on its own or gets flagged
+ *     autofix_plan_unqueued by reverifyNeedsReview's annotation pass; an
+ *     exhausted retry is excluded
  *   - no fix sibling on disk (fixSlugExists) or already in the queue
  */
 function selectAutoFixTargets(jobs, { fixSlugExists, resolveJobRunId = resolveRunId }) {
@@ -4430,10 +4519,13 @@ function selectAutoFixTargets(jobs, { fixSlugExists, resolveJobRunId = resolveRu
     if (!runId) return false;
     if (isFixPlanBeyondDepthCap(job.slug, job.investigationDepth)) return false;
     if (job.autoFixAttempted) {
-      if (job.autoFixOutcome !== 'no-plan') return false;
+      const retryEligible = job.autoFixOutcome === 'no-plan'
+        || job.autoFixOutcome === 'error'
+        || job.autoFixOutcome == null;
+      if (!retryEligible) return false;
       if ((job.autoFixRetries ?? 0) >= 1) return false;
     }
-    const fixSlug = `${String(job.parallelGroup ?? 99).padStart(2, '0')}-fix-${job.slug.replace(/^\d+-/, '')}`;
+    const fixSlug = fixSlugFor(job);
     if (fixSlugExists(fixSlug)) return false;
     if (slugsInQueue.has(fixSlug)) return false;
     return true;
@@ -4561,20 +4653,29 @@ async function reverifyNeedsReview() {
 
   // Surface needs_review jobs that can never self-heal or get an auto-fix
   // investigation (no runId, no backfillable run dir) instead of leaving
-  // them silently stranded. Also surface no-plan auto-fix jobs whose one
-  // bounded retry is already exhausted. Both are annotated, never looped on.
+  // them silently stranded. Also surface auto-fix jobs whose one bounded
+  // retry is already exhausted (outcome 'no-plan', 'error', or unstamped —
+  // selectAutoFixTargets treats all three as retry-eligible, so all three
+  // must also be annotatable once the retry is spent), and jobs whose
+  // investigation DID produce a fix plan that never became a queue row
+  // (write failed, or reconcile hasn't picked it up for some other reason).
+  // All three classes are annotated, never looped on — a needs_review job
+  // must not exit this pass both un-retried and un-annotated.
   const afterHealForAnnotate = await readQueue();
   const unresolvable = afterHealForAnnotate.jobs.filter(
     (j) => isUnresolvableNeedsReview(j, { hasRunDir: !!resolveRunId(j) }) && j.verifierVerdict !== 'no_run_artifacts',
   );
-  const exhaustedNoPlan = afterHealForAnnotate.jobs.filter(
-    (j) => j.status === 'needs_review'
-      && j.autoFixAttempted && j.autoFixOutcome === 'no-plan' && (j.autoFixRetries ?? 0) >= 1
-      && j.verifierVerdict !== 'autofix_no_plan',
+  const exhaustedAutoFix = afterHealForAnnotate.jobs.filter(
+    (j) => isExhaustedAutoFix(j) && j.verifierVerdict !== 'autofix_no_plan',
+  );
+  const queuedSlugs = new Set(afterHealForAnnotate.jobs.map((j) => j.slug));
+  const planUnqueued = afterHealForAnnotate.jobs.filter(
+    (j) => isPlanUnqueued(j, queuedSlugs) && j.verifierVerdict !== 'autofix_plan_unqueued',
   );
-  if (unresolvable.length || exhaustedNoPlan.length) {
+  if (unresolvable.length || exhaustedAutoFix.length || planUnqueued.length) {
     const unresolvableSet = new Set(unresolvable.map((j) => j.slug));
-    const exhaustedSet = new Set(exhaustedNoPlan.map((j) => j.slug));
+    const exhaustedSet = new Set(exhaustedAutoFix.map((j) => j.slug));
+    const planUnqueuedSet = new Set(planUnqueued.map((j) => j.slug));
     await mutate((s) => {
       for (const j of s.jobs) {
         if (unresolvableSet.has(j.slug)) {
@@ -4583,14 +4684,22 @@ async function reverifyNeedsReview() {
         } else if (exhaustedSet.has(j.slug)) {
           j.verifierVerdict = 'autofix_no_plan';
           j.error = 'auto-fix investigation produced no fix plan after retry — manual review';
+        } else if (planUnqueuedSet.has(j.slug)) {
+          j.verifierVerdict = 'autofix_plan_unqueued';
+          j.error = 'auto-fix investigation produced a fix plan that never reached the queue — manual review';
         }
       }
     });
     if (unresolvable.length) {
       console.log(`[scheduler] boot reverify: no run artifacts for ${unresolvable.map((j) => j.slug).join(', ')} — flagged for manual review`);
     }
-    if (exhaustedNoPlan.length) {
-      console.log(`[scheduler] boot reverify: auto-fix retry exhausted for ${exhaustedNoPlan.map((j) => j.slug).join(', ')} — flagged for manual review`);
+    if (exhaustedAutoFix.length) {
+      console.log(`[scheduler] boot reverify: auto-fix retry exhausted for ${exhaustedAutoFix.map((j) => j.slug).join(', ')} — flagged for manual review`);
+    }
+    if (planUnqueued.length) {
+      for (const j of planUnqueued) {
+        console.log(`[scheduler] boot reverify: auto-fix plan never queued for ${j.slug} — flagged for manual review`);
+      }
     }
     await broadcast();
   }
@@ -4608,7 +4717,7 @@ async function reverifyNeedsReview() {
     for (const job of targets) {
       const runId = job.runId || resolveRunId(job);
       const runDir = path.join(RUNS_DIR, runId);
-      const isNoPlanRetry = job.autoFixAttempted && job.autoFixOutcome === 'no-plan';
+      const isRetryAttempt = job.autoFixAttempted === true;
       // Persist the attempt BEFORE spawning — a crash mid-investigation still
       // counts it (mirrors orphanRetries). Safe even when the slot is busy: the
       // investigation is queued and drained as slots free, so it is genuinely
@@ -4618,13 +4727,13 @@ async function reverifyNeedsReview() {
         if (j) {
           j.autoFixAttempted = true;
           if (!j.runId && runId) j.runId = runId;
-          if (isNoPlanRetry) {
+          if (isRetryAttempt) {
             j.autoFixRetries = (j.autoFixRetries ?? 0) + 1;
             delete j.autoFixOutcome;
           }
         }
       });
-      console.log(`[scheduler] auto-fix: needs_review ${job.slug} → authoring fix-plan (${isNoPlanRetry ? 'retry' : '1/1'})`);
+      console.log(`[scheduler] auto-fix: needs_review ${job.slug} → authoring fix-plan (${isRetryAttempt ? 'retry' : '1/1'})`);
       spawnInvestigation(job, runDir).catch((e) => {
         console.error('[scheduler] auto-fix spawnInvestigation error', job.slug, e);
       });
@@ -5712,4 +5821,4 @@ function registerAdminRoutes(adminHttp, remoteObj = remote) {
   });
 }
 
-module.exports = { findOverrunningJobs, JOB_OVERRUN_FACTOR, JOB_OVERRUN_FLOOR_MS, registerScheduleHandlers, attachWindow, init, ROOT, PRDS_DIR, healRefusalReason, writeQueue, reconcile, reconcileSourcePromptId, allocateParallelGroup, selectHistoryJobs, parsePorcelain, FINISH_PROTOCOL, remote, pickNextBatch, pickForProject, reapDeadRunningJobs, pollRecoveryClearSource, memoryLimitedBatchSize, availableForJobs, reverifyNeedsReview, isRescanCandidate, isPromotableOriginal, selectAutoFixTargets, isEligibleForImmediateAutoFix, resolveRunId, isUnresolvableNeedsReview, healTargetForFix, buildInvestigationPrompt, isGitRepoSync, committedInWindow, computeCommittedDuringRun, classifySigtermWithCommit, isFixPlanSlug, isFixPlanBeyondDepthCap, MAX_INVESTIGATION_DEPTH, forceTickOutcome, applyPauseCleared, detectNetworkErrorInLog, detectRateLimitInLog, classifyFailureOutcome, commitGuardVerdict, TRANSIENT_RETRY_CAP, buildScheduleStatePayload, partitionBootOrphans, applyOrphanOutcome, BOOT_ORPHAN_KILL_GRACE_MS, registerAdminRoutes, notifyOriginatingTab, notifyNeedsReview, isNotifiableTerminalStatus, extractResultTextFromLog, candidatePrdsDirs, candidateArchivedPrdsDirs, resolveArchivedPrdStatus, prdDirForCwd, prdPathForJob, archivedPrdPathForJob, archivedTwinExists, findPrdDir, resolveVerifyPrdPath, resolveNotifyPrd, runPrdMigration, consolidateAllFlatPrds, shouldSkipInvestigationForCleanRun, archiveCompletedPrd, retireCompletedSlugs, SCHEDULER_BOOTED_AT, SCHEDULER_CODE_SHA, resetJobFields, executeJob, prdArchivedSkipResult, spawnJob, listPrdsInternal, computeStallSummary, findStaleQuarantinedJobs, QUARANTINE_ESCALATE_MS };
+module.exports = { findOverrunningJobs, JOB_OVERRUN_FACTOR, JOB_OVERRUN_FLOOR_MS, registerScheduleHandlers, attachWindow, init, ROOT, PRDS_DIR, healRefusalReason, writeQueue, reconcile, reconcileSourcePromptId, allocateParallelGroup, selectHistoryJobs, parsePorcelain, FINISH_PROTOCOL, remote, pickNextBatch, pickForProject, reapDeadRunningJobs, pollRecoveryClearSource, memoryLimitedBatchSize, availableForJobs, reverifyNeedsReview, isRescanCandidate, isPromotableOriginal, selectAutoFixTargets, isEligibleForImmediateAutoFix, resolveRunId, isUnresolvableNeedsReview, isExhaustedAutoFix, isPlanUnqueued, fixSlugFor, healTargetForFix, buildInvestigationPrompt, isGitRepoSync, committedInWindow, computeCommittedDuringRun, classifySigtermWithCommit, isFixPlanSlug, isFixPlanBeyondDepthCap, MAX_INVESTIGATION_DEPTH, forceTickOutcome, applyPauseCleared, detectNetworkErrorInLog, detectRateLimitInLog, classifyFailureOutcome, commitGuardVerdict, TRANSIENT_RETRY_CAP, buildScheduleStatePayload, partitionBootOrphans, applyOrphanOutcome, BOOT_ORPHAN_KILL_GRACE_MS, registerAdminRoutes, notifyOriginatingTab, notifyNeedsReview, isNotifiableTerminalStatus, extractResultTextFromLog, candidatePrdsDirs, candidateArchivedPrdsDirs, resolveArchivedPrdStatus, prdDirForCwd, prdPathForJob, archivedPrdPathForJob, archivedTwinExists, findPrdDir, resolveVerifyPrdPath, resolveFixPlanPath, resolveNotifyPrd, runPrdMigration, consolidateAllFlatPrds, shouldSkipInvestigationForCleanRun, archiveCompletedPrd, retireCompletedSlugs, SCHEDULER_BOOTED_AT, SCHEDULER_CODE_SHA, resetJobFields, executeJob, prdArchivedSkipResult, spawnJob, listPrdsInternal, computeStallSummary, findStaleQuarantinedJobs, QUARANTINE_ESCALATE_MS };

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 };