claude-code-session-manager 0.75.1 → 0.75.2

package/src/main/ipcSchemas.cjs

@@ -369,6 +369,16 @@ const adminListPrdsQuery = z.object({
   cwd: z.string().min(1).max(4096).optional(),
   epicId: z.string().min(1).max(200).optional(),
   status: z.string().min(1).max(40).optional(),
+  // Page size — default 100, hard max 500 so an agent can't accidentally
+  // re-request the full unbounded list (PRD: the 353KB/120s-timeout
+  // incident this pagination exists to fix). Query strings arrive as text,
+  // so these coerce before the int/range checks run.
+  limit: z.coerce.number().int().min(1).max(500).optional().default(100),
+  offset: z.coerce.number().int().min(0).optional().default(0),
+  // 'compact' (default) omits the secondary detail fields (parallelGroup,
+  // estimateMinutes, sourcePromptId, epicId, archivedStatus) that aren't
+  // needed to answer "what PRDs are there"; 'full' restores them.
+  fields: z.enum(['compact', 'full']).optional().default('compact'),
 });
 
 const adminGetPrdQuery = z.object({

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

@@ -93,6 +93,18 @@ test('a FAILED bare-named dep holds the dependent and reports an explicit reason
   assert.match(reason, /874-nav-face-project-home <- leftnav-two-face-framework/);
 });
 
+test('a SKIPPED (never-ran) bare-named dep holds the dependent and reports an explicit reason', () => {
+  const jobs = [
+    job('873-leftnav-two-face-framework', 'skipped'),
+    job('874-nav-face-project-home', 'pending', { dependsOn: ['leftnav-two-face-framework'] }),
+  ];
+  const { batch, reason } = pick(jobs);
+  assert.deepEqual(batch, []);
+  assert.match(reason, /depends-gate/);
+  assert.match(reason, /never-ran dependencies/);
+  assert.match(reason, /874-nav-face-project-home <- leftnav-two-face-framework/);
+});
+
 // ---------------------------------------------------------------------------
 // Parallelism regression coverage.
 //
@@ -209,6 +221,20 @@ test('hold record carries a failed dep status alongside the depends-gate reason'
   ]);
 });
 
+test('hold record carries a skipped dep status alongside the depends-gate reason', () => {
+  const jobs = [
+    job('985-foundation', 'skipped'),
+    job('986-dependent', 'pending', { dependsOn: ['foundation'] }),
+  ];
+  const { batch, reason, holds } = pick(jobs, new Set(), 5);
+  assert.deepEqual(batch, []);
+  assert.match(reason, /depends-gate/);
+  assert.match(reason, /never-ran dependencies/);
+  assert.deepEqual(holds, [
+    { slug: '986-dependent', dep: 'foundation', depStatus: 'skipped' },
+  ]);
+});
+
 test('no holds when nothing is dependency-blocked', () => {
   const jobs = [job('988-a', 'pending'), job('989-b', 'pending')];
   const { batch, holds } = pick(jobs, new Set(), 5);

package/src/main/lib/prdAdminRoutes.cjs

@@ -45,6 +45,16 @@ function parseJsonBody(raw) {
  * scheduler.cjs's own registerAdminRoute(s) pattern.
  */
 function registerAdminRoute(adminHttp, remote) {
+  // GET /admin/scheduler/prds — paginated PRD listing (PRD: 353KB/120s
+  // fix). Sort order is stable and explicit: slug ascending via
+  // String.localeCompare(..., { numeric: true }) (listPrdsInternal in
+  // scheduler.cjs), so offset paging can't skip or duplicate an entry
+  // between calls as long as the underlying PRD set is unchanged.
+  // `limit`/`offset` default to 100/0 (hard max limit 500); `total` is the
+  // filtered count BEFORE the page slice, and `hasMore` is derived from
+  // `total`, not from whether the page came back full. `fields=full` opts
+  // into the secondary detail fields (parallelGroup, estimateMinutes,
+  // sourcePromptId, epicId, archivedStatus) omitted by default.
   adminHttp.registerRoute('GET', '/admin/scheduler/prds', async (req, res, query) => {
     let input;
     try {
@@ -53,8 +63,8 @@ function registerAdminRoute(adminHttp, remote) {
       sendJson(res, 400, { ok: false, error: 'invalid query', details: e?.issues ?? e?.message });
       return;
     }
-    const prds = await remote.listPrds(input);
-    sendJson(res, 200, { ok: true, prds });
+    const { prds, total, limit, offset, hasMore } = await remote.listPrds(input);
+    sendJson(res, 200, { ok: true, prds, total, limit, offset, hasMore });
   });
 
   adminHttp.registerRoute('GET', '/admin/scheduler/prd', async (req, res, query) => {

package/src/main/lib/queueHistory.cjs

@@ -62,9 +62,11 @@ function jobKey(job) {
 
 /**
  * O(n) over `jobs`. Splits terminal jobs into `hot` (stays in queue.json)
- * and `toArchive` (moves to history.jsonl). A completed/failed job archives
- * only when ALL of:
- *   - status is 'completed' or 'failed'
+ * and `toArchive` (moves to history.jsonl). A completed/failed/skipped job
+ * archives only when ALL of:
+ *   - status is 'completed', 'failed', or 'skipped' (skipped: a job whose
+ *     PRD source vanished before dispatch — never ran, but still terminal,
+ *     and must age out of the hot queue the same as any other finished row)
  *   - finishedAt parses and is older than opts.retentionMs (default
  *     HISTORY_RETENTION_MS)
  *   - it is not the healTargetForFix() parent of a pending/running fix-plan
@@ -90,7 +92,7 @@ function partitionJobs(jobs, nowMs, opts = {}) {
     if (!j) continue;
     const finishedMs = j.finishedAt ? Date.parse(j.finishedAt) : NaN;
     const archivable =
-      (j.status === 'completed' || j.status === 'failed') &&
+      (j.status === 'completed' || j.status === 'failed' || j.status === 'skipped') &&
       Number.isFinite(finishedMs) &&
       (nowMs - finishedMs) > retentionMs &&
       !protectedSlugs.has(j.slug);

package/src/main/lib/scheduleJobSchema.cjs

@@ -24,7 +24,7 @@
 
 const { z } = require('zod');
 
-const JOB_STATUSES = ['pending', 'running', 'investigating', 'completed', 'failed', 'needs_review', 'quarantined'];
+const JOB_STATUSES = ['pending', 'running', 'investigating', 'completed', 'skipped', 'failed', 'needs_review', 'quarantined'];
 
 const ScheduleJobStatusSchema = z.enum(JOB_STATUSES);
 

package/src/main/lib/scheduleJobTransitions.cjs

@@ -44,7 +44,10 @@ const STATUS_HISTORY_CAP = 20;
  *    manual archive of an already-shipped PRD), pending->failed (admin
  *    cancelJob on a not-yet-started job)
  *  - running->completed|failed|needs_review (normal run outcomes, reaper),
- *    running->pending (halt/rate-limit reset, transient-failure retry)
+ *    running->skipped (spawnJob:skip-archived's 'prd-missing' case — no
+ *    executor ever ran; kept distinct from 'completed' so unrun work can't
+ *    read as shipped), running->pending (halt/rate-limit reset,
+ *    transient-failure retry)
  *  - investigating->failed|needs_review (restore prior status once the
  *    investigation probe exits), investigating->completed (defensive: the
  *    restored prior status could in principle be 'completed' if a caller
@@ -58,20 +61,30 @@ const STATUS_HISTORY_CAP = 20;
  *  - completed->pending (force-only reset, gated separately by
  *    resetJobFields' own guard — this table only says the edge is
  *    structurally legal, not that every caller may take it unconditionally)
+ *  - skipped->pending (force-only reset, same resetJobFields guard as
+ *    completed->pending — 'skipped' is otherwise terminal: no further
+ *    transitions out)
  *  - quarantined->pending (reconcile()'s adopt path, PRD-authoring lockdown:
  *    a PRD discovered with no `createdVia` provenance stamp is queued
  *    'quarantined' instead of 'pending'; the ONLY way out is the PRD being
  *    stamped via the update-prd API — reconcile() detects the stamp on its
  *    next pass and promotes the row)
+ *  - pending|investigating|needs_review|quarantined -> skipped
+ *    (schedule:clear-queue: a manual queue clear force-terminates any
+ *    non-running victim row so it can leave a durable history.jsonl record
+ *    instead of vanishing — same 'never ran, don't call it completed'
+ *    rationale as running->skipped, just reachable from every pre-dispatch
+ *    or unresolved status a queued row can be sitting in)
  */
 const LEGAL_TRANSITIONS = {
-  pending: ['running', 'completed', 'failed'],
-  running: ['completed', 'failed', 'needs_review', 'pending'],
-  investigating: ['failed', 'needs_review', 'completed', 'pending'],
+  pending: ['running', 'completed', 'failed', 'skipped'],
+  running: ['completed', 'failed', 'needs_review', 'skipped', 'pending'],
+  investigating: ['failed', 'needs_review', 'completed', 'pending', 'skipped'],
   failed: ['investigating', 'pending', 'completed'],
-  needs_review: ['investigating', 'pending', 'completed'],
+  needs_review: ['investigating', 'pending', 'completed', 'skipped'],
   completed: ['pending'],
-  quarantined: ['pending'],
+  skipped: ['pending'],
+  quarantined: ['pending', 'skipped'],
 };
 
 let refusedTransitionCount = 0;

package/src/main/lib/schedulerBatch.cjs

@@ -97,6 +97,12 @@ function pickForProject(projectJobs, runningSlugsInProject, slots) {
 
   const pending = [];
   const heldByFailedDep = [];
+  // A dep that never ran (its PRD source vanished before dispatch — see
+  // scheduleJobSchema.cjs's 'skipped' status) is just as blocking as a
+  // failed one and deserves the same explicit reason, not a silent fall into
+  // the generic `holds` bucket — resetting won't help here (the source file
+  // is gone), so the guidance differs from the failed-dep case.
+  const heldBySkippedDep = [];
   // Per-job hold records, surfaced to the UI so a `pending` row can say WHICH
   // dep is holding it instead of leaving the reason in console.log.
   const holds = [];
@@ -105,7 +111,9 @@ function pickForProject(projectJobs, runningSlugsInProject, slots) {
     if (!dep) { pending.push(j); continue; }
     const depRows = rowsForDep(dep);
     const failed = depRows.some((d) => d.status === 'failed');
+    const skipped = depRows.some((d) => d.status === 'skipped');
     if (failed) heldByFailedDep.push({ job: j, dep });
+    else if (skipped) heldBySkippedDep.push({ job: j, dep });
     holds.push({
       slug: j.slug,
       dep,
@@ -114,9 +122,17 @@ function pickForProject(projectJobs, runningSlugsInProject, slots) {
     // running/pending/needs_review dep — simply not eligible this tick.
   }
   if (pending.length === 0) {
+    const reasons = [];
     if (heldByFailedDep.length > 0) {
       const detail = heldByFailedDep.map(({ job, dep }) => `${job.slug} <- ${dep}`).join(', ');
-      const reason = `[scheduler] depends-gate [${projectCwd}]: holding ${heldByFailedDep.length} job(s) behind failed dependencies [${detail}]. Reset or archive the dep to unblock.`;
+      reasons.push(`holding ${heldByFailedDep.length} job(s) behind failed dependencies [${detail}]. Reset or archive the dep to unblock.`);
+    }
+    if (heldBySkippedDep.length > 0) {
+      const detail = heldBySkippedDep.map(({ job, dep }) => `${job.slug} <- ${dep}`).join(', ');
+      reasons.push(`holding ${heldBySkippedDep.length} job(s) behind never-ran dependencies [${detail}]. The dep's PRD source is gone — author a fresh PRD for that work to unblock.`);
+    }
+    if (reasons.length > 0) {
+      const reason = `[scheduler] depends-gate [${projectCwd}]: ${reasons.join(' ')}`;
       console.log(reason);
       return { batch: [], reason, holds };
     }

package/src/main/scheduler.cjs

@@ -100,7 +100,7 @@ const queueOps = require('./queueOps.cjs');
 // home-dir layout.
 const { resolvePrdsDirs, resolveArchivedPrdsDirs, resolvePrdWriteDir, listEpicPrdDirs, listArchivedPrdDirs } = require('./lib/prdLocations.cjs');
 const { ensureEpic, appendPrdCreatedEvent, readActiveIndex } = require('./lib/epicMint.cjs');
-const { transitionJob } = require('./lib/scheduleJobTransitions.cjs');
+const { transitionJob, STATUS_HISTORY_CAP } = require('./lib/scheduleJobTransitions.cjs');
 const { buildContextDigest, composeExecutorPrompt } = require('./lib/epicContextDigest.cjs');
 const { JOB_STATUSES } = require('./lib/scheduleJobSchema.cjs');
 const { appendAuditEvent } = require('./lib/auditLog.cjs');
@@ -1424,7 +1424,7 @@ async function reconcile(state) {
         seen.add(job.slug);
         next.push({ ...job });
         console.warn(`[scheduler] reconcile: keeping ${job.status} job ${job.slug} — PRD source not visible in any candidate dir`);
-      } else if (job.status === 'completed' || job.status === 'failed') {
+      } else if (job.status === 'completed' || job.status === 'failed' || job.status === 'skipped') {
         terminalDroppedNeedingHistoryCheck.push(job);
       }
       continue;
@@ -2104,7 +2104,7 @@ async function clearPause(source) {
  * already-'completed' job, and that path is exactly what this guards.
  */
 function resetJobFields(job, errorMsg, opts = {}) {
-  if (job.status === 'completed' && opts.force !== true) return false;
+  if ((job.status === 'completed' || job.status === 'skipped') && opts.force !== true) return false;
   if (!transitionJob(job, 'pending', { reason: errorMsg ?? 'reset to pending', source: opts.source ?? 'resetJobFields' })) return false;
   job.runId = null;
   job.startedAt = null;
@@ -3486,13 +3486,18 @@ async function spawnJob(job, runId, runDir, defaultCwd) {
     // Stale queue entry: the PRD was archived (already shipped) or is gone
     // from disk entirely (deleted before dispatch). Both are retire-not-fail
     // results from prdArchivedSkipResult with exitCode 0 and no transcript —
-    // treat any truthy skip reason as a plain completion: no verify pass, no
-    // commit guard, no RCA feedback item.
+    // no verify pass, no commit guard, no RCA feedback item — but only
+    // 'prd-archived' actually means the work shipped (archivedTwinExists
+    // found the file under a prds-archived/ dir). 'prd-missing' means no
+    // executor ever ran at all, so it must NOT land on the same 'completed'
+    // status a genuine successful run produces — that conflation is what let
+    // 20 never-executed sigma PRDs read as shipped (2026-08-30 incident).
     if (res.skipped) {
+      const targetStatus = res.skipped === 'prd-missing' ? 'skipped' : 'completed';
       await mutate((s) => {
         const idx = s.jobs.findIndex((x) => x.slug === job.slug);
         if (idx >= 0) {
-          transitionJob(s.jobs[idx], 'completed', { reason: res.note ?? 'PRD archived or missing — treated as already-shipped', source: 'spawnJob:skip-archived' });
+          transitionJob(s.jobs[idx], targetStatus, { reason: res.note ?? 'PRD archived or missing — treated as already-shipped', source: 'spawnJob:skip-archived' });
           s.jobs[idx].finishedAt = new Date().toISOString();
           s.jobs[idx].exitCode = 0;
           s.jobs[idx].error = null;
@@ -4297,7 +4302,7 @@ async function pollLoop() {
 // callers/tests that only pass `jobs` are unaffected.
 function selectHistoryJobs(jobs, limit, historyEntries = []) {
   const cap = Math.max(1, Math.min(500, Number.isFinite(limit) ? Math.floor(limit) : 50));
-  const hot = (Array.isArray(jobs) ? jobs : []).filter((j) => j && (j.status === 'completed' || j.status === 'failed'));
+  const hot = (Array.isArray(jobs) ? jobs : []).filter((j) => j && (j.status === 'completed' || j.status === 'failed' || j.status === 'skipped'));
   const seen = new Set(hot.map((j) => `${j.slug}|${j.runId ?? ''}`));
   const archived = (Array.isArray(historyEntries) ? historyEntries : []).filter((j) => {
     if (!j) return false;
@@ -4743,6 +4748,43 @@ async function reverifyNeedsReview() {
   return { rescanned: candidates.length, healed, leftForReview };
 }
 
+/**
+ * schedule:clear-queue's core state mutation, split out so it's testable
+ * without ipcMain/electron: every victim (non-running job whose slug is in
+ * `victimSlugs`) must leave a durable history.jsonl record before it
+ * disappears from queue.json — a manual clear used to just filter the row
+ * out with no trace (a job could vanish with zero audit trail; see the
+ * 2026-08-30 sigma `788-pr-sweep-final-gate` incident). Non-terminal victims
+ * (pending/investigating/needs_review/quarantined) are force-transitioned to
+ * 'skipped' — never 'completed', since a manually-cleared job did not ship.
+ * Victims already terminal (completed/failed/skipped) keep their real
+ * status; they just get a statusHistory note + a history row so they don't
+ * silently drop before aging past HISTORY_RETENTION_MS.
+ *
+ * Mutates `state.jobs` in place (drops the victims, same contract as
+ * reconcile()) and returns the job snapshots to append to history.jsonl.
+ */
+function applyClearQueueVictims(state, victimSlugs, archiveNoteBySlug, archiveDir) {
+  const historyEntries = [];
+  for (const job of state.jobs) {
+    if (!victimSlugs.has(job.slug)) continue;
+    const reason = archiveNoteBySlug?.get(job.slug) ?? `PRD archived to ${archiveDir}`;
+    if (job.status === 'completed' || job.status === 'failed' || job.status === 'skipped') {
+      // Already terminal — keep the real status, just record the clear.
+      const history = Array.isArray(job.statusHistory) ? job.statusHistory : [];
+      history.push({ from: job.status, to: job.status, reason, source: 'clear-queue', at: new Date().toISOString() });
+      while (history.length > STATUS_HISTORY_CAP) history.shift();
+      job.statusHistory = history;
+    } else {
+      transitionJob(job, 'skipped', { reason, source: 'clear-queue' });
+    }
+    if (!job.finishedAt) job.finishedAt = new Date().toISOString();
+    historyEntries.push({ ...job });
+  }
+  state.jobs = state.jobs.filter((j) => !victimSlugs.has(j.slug));
+  return historyEntries;
+}
+
 function registerScheduleHandlers() {
   ensureDirs();
   supervisor.registerHandlers();
@@ -4905,10 +4947,6 @@ function registerScheduleHandlers() {
     return { ok: true, kind: 'info', message };
   });
 
-  // Archive every non-running PRD and drop its entry from queue.json.
-  // Running entries are kept (would orphan an in-flight job). PRD files are
-  // moved (not deleted) to prds-archived/<ISO>/ so the user can recover them.
-  // Path containment is enforced — only files inside PRDS_DIR are moved.
   ipcMain.handle('schedule:clear-queue', async () => {
     ensureDirs();
     const ts = new Date().toISOString().replace(/[:.]/g, '-');
@@ -4920,6 +4958,7 @@ function registerScheduleHandlers() {
     }
     await fsp.mkdir(archiveDir, { recursive: true });
     let archived = 0;
+    const archiveNoteBySlug = new Map();
     for (const job of victims) {
       const srcDir = await findPrdDir(job.slug) ?? prdDirForCwd(job.cwd);
       const src = path.resolve(path.join(srcDir, `${job.slug}.md`));
@@ -4928,17 +4967,27 @@ function registerScheduleHandlers() {
       try {
         await fsp.rename(src, dst);
         archived++;
+        archiveNoteBySlug.set(job.slug, `PRD file archived to ${archiveDir}`);
       } catch (e) {
         // ENOENT: the .md is already gone (reconcile would drop it on next
         // read anyway). Either way, fall through and remove from queue.
         if (e?.code !== 'ENOENT') {
           logs.writeLine({ level: 'warn', scope: 'scheduler', message: 'clear-queue: rename failed', meta: { slug: job.slug, error: e?.message } });
         }
+        archiveNoteBySlug.set(job.slug, `PRD file already gone (ENOENT) when archiving to ${archiveDir}`);
       }
     }
     await mutate(async (s) => {
       const victimSlugs = new Set(victims.map((j) => j.slug));
-      s.jobs = s.jobs.filter((j) => !victimSlugs.has(j.slug));
+      const historyEntries = applyClearQueueVictims(s, victimSlugs, archiveNoteBySlug, archiveDir);
+      // Append BEFORE this mutate's writeQueue persists s.jobs without the
+      // victims (mutate() only writes after this callback resolves) — same
+      // append-before-drop ordering queueHistory.cjs's reconcile() callers
+      // use, so a crash right after this handler returns can never leave a
+      // row gone from queue.json with nothing in history.jsonl yet.
+      if (historyEntries.length > 0) {
+        await queueHistory.appendHistory(historyEntries);
+      }
       await reconcile(s);
       return null;
     });
@@ -5353,6 +5402,20 @@ async function init() {
   }
 }
 
+// Measured against this repo's own live+archived PRD set (868 entries
+// across every local project — the admin route has no cwd filter by
+// default): no single field dominates a listPrdsInternal() entry: title is
+// the largest at ~30% of payload bytes, followed by slug/cwd/sourcePromptId/
+// epicId at 12-14% each — the 353KB the route was shipping came from
+// returning the full unbounded row count, not from one oversized field.
+// This trims the fields an agent doesn't need to answer "what PRDs are
+// there" (parallelGroup/estimateMinutes/sourcePromptId/epicId/
+// archivedStatus); `fields=full` restores them.
+function toCompactPrdEntry(entry) {
+  const { slug, title, cwd, mtimeMs, archived, status } = entry;
+  return { slug, title, cwd, mtimeMs, archived, status };
+}
+
 /**
  * listPrdsInternal() → every live + archived PRD across every project,
  * with each entry's real job status folded in (`status`: the live queue
@@ -5612,15 +5675,25 @@ const remote = {
 
   // Every live+archived PRD across every project (listPrdsInternal, shared
   // with the renderer's schedule:list-prds IPC handler), filtered by the
-  // admin route's cwd/epicId/status query params.
+  // admin route's cwd/epicId/status query params and paged by
+  // limit/offset. Sort order is listPrdsInternal's own slug.localeCompare
+  // (numeric) — stable across calls since it's a pure string sort, so
+  // paging by offset can't skip or duplicate an entry between requests as
+  // long as the underlying PRD set doesn't change mid-page.
   async listPrds(filter = {}) {
     const all = await listPrdsInternal();
-    return all.filter((entry) => {
+    const filtered = all.filter((entry) => {
       if (filter.cwd && entry.cwd !== filter.cwd) return false;
       if (filter.epicId && entry.epicId !== filter.epicId) return false;
       if (filter.status && entry.status !== filter.status) return false;
       return true;
     });
+    const total = filtered.length;
+    const limit = filter.limit ?? 100;
+    const offset = filter.offset ?? 0;
+    const page = filtered.slice(offset, offset + limit);
+    const prds = filter.fields === 'full' ? page : page.map(toCompactPrdEntry);
+    return { prds, total, limit, offset, hasMore: offset + page.length < total };
   },
 
   // Full body + parsed frontmatter for one PRD, live or archived. Mirrors
@@ -5759,7 +5832,7 @@ const remote = {
     const state = await readQueue();
     const job = state.jobs.find((j) => j.slug === slug);
     if (!job) return { ok: false, error: 'not found' };
-    if (job.status === 'completed' || job.status === 'failed' || job.status === 'needs_review') {
+    if (job.status === 'completed' || job.status === 'failed' || job.status === 'needs_review' || job.status === 'skipped') {
       return { ok: false, error: `job already terminal (status: "${job.status}") — nothing to cancel` };
     }
     const wasRunning = job.status === 'running';
@@ -5821,4 +5894,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, 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 };
+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, applyClearQueueVictims };

package/src/preload/api.d.ts

@@ -391,7 +391,7 @@ export interface ScheduleConfig {
  *  so this union is a manually-kept copy; drift from JOB_STATUSES (and from
  *  the renderer's own mirrors in StatusBadge.tsx/SchedulePanel.tsx) is
  *  caught by src/main/__tests__/scheduleJobStatusDrift.test.cjs. */
-export type ScheduleJobStatus = 'pending' | 'running' | 'investigating' | 'completed' | 'failed' | 'needs_review' | 'quarantined';
+export type ScheduleJobStatus = 'pending' | 'running' | 'investigating' | 'completed' | 'skipped' | 'failed' | 'needs_review' | 'quarantined';
 
 export interface ScheduleJobRuntime {
   pid: number;