claude-code-session-manager 0.111.0 → 0.113.0

package/src/main/lib/{jobDirtFilter.cjs → scheduler/jobDirtFilter.cjs}

@@ -33,7 +33,7 @@
  * rather than a second hardcoded literal — this file matches git-porcelain
  * RELATIVE paths, never builds an fs path, so opsPath() itself doesn't apply.
  */
-const { OPS_ROOT_DIR: OPS_ROOT_SEGMENT } = require('./opsOwnership.cjs');
+const { OPS_ROOT_DIR: OPS_ROOT_SEGMENT } = require('../opsOwnership.cjs');
 
 /** True when `p` lives under an app-owned operations root. Pure. */
 function isAppOwnedChurn(p) {

package/src/main/lib/{jobSupervisorRecord.cjs → scheduler/jobSupervisorRecord.cjs}

@@ -20,7 +20,7 @@
 const fs = require('node:fs');
 const path = require('node:path');
 const { writeJsonAtomicSync } = require('./queueStore.cjs');
-const { isDifferentProcess } = require('./procIdentity.cjs');
+const { isDifferentProcess } = require('../process/procIdentity.cjs');
 
 const SUFFIX = '.supervisor.json';
 const META_SUFFIX = '.meta.json';

package/src/main/lib/{launchFailure.cjs → scheduler/launchFailure.cjs}

@@ -39,8 +39,8 @@
 
 const fs = require('node:fs');
 const path = require('node:path');
-const { readTail } = require('./fileTail.cjs');
-const atomicFs = require('./atomicFs.cjs');
+const { readTail } = require('../util/fileTail.cjs');
+const atomicFs = require('../util/atomicFs.cjs');
 
 const LAUNCH_FAILURE_KINDS = Object.freeze({
   /** HTTP 400 naming a thinking/effort/config parameter the model rejects — the issue-#11 signature. */

package/src/main/lib/{queueStore.cjs → scheduler/queueStore.cjs}

@@ -32,9 +32,9 @@ const fs = require('node:fs');
 const fsp = require('node:fs/promises');
 const path = require('node:path');
 const crypto = require('node:crypto');
-const { allProjectCwds, activeProjectCwds, bustProjectCwdCache } = require('./activeSessions.cjs');
-const { classifyCwd } = require('./cwdClassify.cjs');
-const { assertOpsWrite, resolveOpsRoot, OPS_ROOT_DIR } = require('./opsOwnership.cjs');
+const { allProjectCwds, activeProjectCwds, bustProjectCwdCache } = require('../activeSessions.cjs');
+const { classifyCwd } = require('../cwdClassify.cjs');
+const { assertOpsWrite, resolveOpsRoot, OPS_ROOT_DIR } = require('../opsOwnership.cjs');
 const { ScheduleJobSchema } = require('./scheduleJobSchema.cjs');
 const schedulerPaths = require('./schedulerPaths.cjs');
 
@@ -238,11 +238,11 @@ function shapeMachine(data) {
     // classifyQueueStarvation's header for why the two must never merge.
     lastDispatchAttemptAt: data.lastDispatchAttemptAt ?? null,
     paused: data.paused ?? null,
-    // Upgrade-drain state (lib/upgradeDrain.cjs): deliberately NOT part of
+    // Upgrade-drain state (lib/scheduler/upgradeDrain.cjs): deliberately NOT part of
     // `paused`, so a rate-limit pause can neither overwrite it nor have the
     // manual-clear cooldown swallow it.
     drain: data.drain && typeof data.drain === 'object' ? data.drain : null,
-    // Launch circuit breaker (lib/launchFailure.cjs): per-persona blocks and
+    // Launch circuit breaker (lib/scheduler/launchFailure.cjs): per-persona blocks and
     // the degraded-mode env a persona is currently launching with. Machine
     // state, not per-project: the broken thing is the installed CLI.
     launchBlocks: data.launchBlocks && typeof data.launchBlocks === 'object' ? data.launchBlocks : {},
@@ -315,7 +315,7 @@ const PAUSED_HINT_RE = /"paused"|resumeAt/;
 
 function logMachineStateRecovery({ level, message, meta }) {
   try {
-    const { appendError } = require('./opsErrorLog.cjs');
+    const { appendError } = require('../telemetry/opsErrorLog.cjs');
     appendError({ cwd: schedulerPaths.machineStateLogCwd(), scope: 'scheduler', level, message, meta });
   } catch { /* durable logging must never block recovery */ }
   console.error(`[queueStore] ${message}`);

package/src/main/lib/{quietMachineLease.cjs → scheduler/quietMachineLease.cjs}

@@ -12,7 +12,7 @@
  */
 'use strict';
 
-const { appendAuditEvent } = require('./auditLog.cjs');
+const { appendAuditEvent } = require('../telemetry/auditLog.cjs');
 const { isProvablyDead, DEFAULT_GRACE_MS } = require('./reservationExpiry.cjs');
 
 // slug of the job currently holding the lease, or null.

package/src/main/lib/{rcaReport.cjs → scheduler/rcaReport.cjs}

@@ -32,10 +32,10 @@
 
 const fs = require('node:fs');
 const path = require('node:path');
-const { splitFrontmatter } = require('./prdFrontmatter.cjs');
-const { readTail } = require('./fileTail.cjs');
-const { resolvePrdWriteDir } = require('./prdLocations.cjs');
-const atomicFs = require('./atomicFs.cjs');
+const { splitFrontmatter } = require('../prd/prdFrontmatter.cjs');
+const { readTail } = require('../util/fileTail.cjs');
+const { resolvePrdWriteDir } = require('../prd/prdLocations.cjs');
+const atomicFs = require('../util/atomicFs.cjs');
 
 // ─── VERDICT_LABELS — deliberate duplicate ──────────────────────────────────
 // Mirrors src/renderer/components/tabs/scheduler/sched-primitives.tsx:123-131.

package/src/main/lib/{reaperHelpers.cjs → scheduler/reaperHelpers.cjs}

@@ -9,9 +9,9 @@
 
 const fs = require('node:fs');
 const path = require('node:path');
-const { readTail } = require('./fileTail.cjs');
-const { detectRateLimitInLog } = require('./rateLimitDetect.cjs');
-const { pidAlive } = require('./pidAlive.cjs');
+const { readTail } = require('../util/fileTail.cjs');
+const { detectRateLimitInLog } = require('../claude/rateLimitDetect.cjs');
+const { pidAlive } = require('../process/pidAlive.cjs');
 
 /**
  * Return true if pid is alive AND its cmdline looks like a claude process.

package/src/main/lib/{reservationExpiry.cjs → scheduler/reservationExpiry.cjs}

@@ -9,27 +9,20 @@
  */
 'use strict';
 
-const { pidAlive } = require('./pidAlive.cjs');
+const { pidAlive } = require('../process/pidAlive.cjs');
 
 const DEFAULT_GRACE_MS = 10 * 60 * 1000;
 
-// Thin alias over pidAlive.cjs's shared pidAlive() — kept as its own named
-// export (rather than inlining the require at every call site) so existing
-// imports of `defaultPidAlive` from this module keep working unchanged.
-function defaultPidAlive(pid) {
-  return pidAlive(pid);
-}
-
 /**
  * @param {{ claimedAt: number, pid: number|null }} res
  * @param {{ live: boolean, pidAlive?: (pid:number)=>boolean, now: number, graceMs?: number }} ctx
  */
-function isProvablyDead(res, { live, pidAlive = defaultPidAlive, now, graceMs = DEFAULT_GRACE_MS }) {
+function isProvablyDead(res, { live, pidAlive: isAlive = pidAlive, now, graceMs = DEFAULT_GRACE_MS }) {
   if (live) return false;
   // Made after the pass began (i.e. this tick) — never expire it.
   if (!Number.isFinite(res.claimedAt) || res.claimedAt > now) return false;
-  if (Number.isInteger(res.pid) && res.pid > 0) return !pidAlive(res.pid);
+  if (Number.isInteger(res.pid) && res.pid > 0) return !isAlive(res.pid);
   return now - res.claimedAt > graceMs;
 }
 
-module.exports = { isProvablyDead, defaultPidAlive, DEFAULT_GRACE_MS };
+module.exports = { isProvablyDead, DEFAULT_GRACE_MS };

package/src/main/lib/{reviewNotice.cjs → scheduler/reviewNotice.cjs}

@@ -43,7 +43,7 @@ const DEFAULT_HOLD_MINUTES = 240;
 // `NN-`) — reused here, not reimplemented, so formatReviewNotice's "blocks"
 // wording can never disagree with what actually holds a dependent `pending`
 // row in the real queue.
-const { bareSlug } = require('./depSlugResolve.cjs');
+const { bareSlug } = require('../prd/depSlugResolve.cjs');
 
 /**
  * buildReviewNotice({ job, report, epicId, now, prior }) → ReviewNotice

package/src/main/lib/{runLogRetention.cjs → scheduler/runLogRetention.cjs}

@@ -1,8 +1,7 @@
 'use strict';
 
 /**
- * runLogRetention.cjs — computes (and, only when explicitly opted in,
- * applies) a retention policy over `scheduled-plans/runs/`.
+ * runLogRetention.cjs — computes and applies a retention policy over `scheduled-plans/runs/`.
  *
  * That directory is a machine-level Session-Manager runtime artifact store
  * (execution logs of the scheduler's own `claude -p` runs), not anything
@@ -26,10 +25,10 @@
  * slug's own files.
  *
  * SAFETY MODEL (the point of this module — see the PRD that added it):
- *   - Nothing is ever deleted unless the caller passes settings with
- *     `schedulerRunLogRetention.enabled === true` AND a non-empty policy.
- *     Everywhere else (computeReport, and applyRetention with no opt-in)
- *     this module only READS the filesystem.
+ *   - Retention is ON by default (DEFAULT_RUN_LOG_RETENTION) when settings
+ *     carry no `schedulerRunLogRetention`. An explicit `enabled: false` (or a
+ *     config with no non-empty policy) opts out: computeReport, and
+ *     applyRetention when opted out, only READ the filesystem.
  *   - An entry belonging to a job that is currently live — status `pending`
  *     (queued), `running`, `needs_review`, or `investigating` (the exact
  *     literals scheduler.cjs uses; see LIVE_STATUSES) — is never eligible,
@@ -51,6 +50,16 @@ const schedulerPaths = require('./schedulerPaths.cjs');
 // checks) — 'completed' and 'failed' are the only terminal ones.
 const LIVE_STATUSES = new Set(['pending', 'running', 'needs_review', 'investigating']);
 
+/**
+ * Built-in policy applied when settings carry no `schedulerRunLogRetention`:
+ * drop runs older than 14 days but always keep each slug's newest 3.
+ * (Policy keys follow the module's own names: maxAgeDays / keepPerSlug.)
+ */
+const DEFAULT_RUN_LOG_RETENTION = Object.freeze({
+  enabled: true,
+  policy: Object.freeze({ maxAgeDays: 14, keepPerSlug: 3 }),
+});
+
 const META_SUFFIX = '.meta.json';
 const DAY_MS = 24 * 60 * 60 * 1000;
 
@@ -259,11 +268,21 @@ function computeReport(runsDir, policy, opts) {
 }
 
 /**
- * True only when settings carry an explicit, well-formed opt-in:
- * `schedulerRunLogRetention.enabled === true` plus a non-empty policy.
+ * The effective retention config: the caller's `schedulerRunLogRetention`
+ * when present, else DEFAULT_RUN_LOG_RETENTION.
  */
-function isRetentionEnabled(settings) {
+function resolveRetentionConfig(settings) {
   const cfg = settings && settings.schedulerRunLogRetention;
+  return cfg == null ? DEFAULT_RUN_LOG_RETENTION : cfg;
+}
+
+/**
+ * True when the effective config (see resolveRetentionConfig) has
+ * `enabled === true` plus a non-empty policy. An absent setting resolves to
+ * the default (enabled); an explicit `enabled: false` opts out.
+ */
+function isRetentionEnabled(settings) {
+  const cfg = resolveRetentionConfig(settings);
   if (!cfg || cfg.enabled !== true) return false;
   const policy = cfg.policy;
   return !!policy && (policy.maxAgeDays != null || policy.keepPerSlug != null);
@@ -372,7 +391,7 @@ function sweepOrphanDirs(runsDir, runningRunIds, errors) {
  * nothing removed.
  */
 function applyRetention(runsDir, settings, opts) {
-  const cfg = (settings && settings.schedulerRunLogRetention) || null;
+  const cfg = resolveRetentionConfig(settings);
   const policy = (cfg && cfg.policy) || {};
   const enabled = isRetentionEnabled(settings);
   const liveKeys = resolveLiveKeysForApply(runsDir, opts, enabled);
@@ -381,7 +400,7 @@ function applyRetention(runsDir, settings, opts) {
   if (!enabled) {
     return {
       deleted: false,
-      reason: 'dry-run: schedulerRunLogRetention.enabled is not true (or has no policy)',
+      reason: 'dry-run: schedulerRunLogRetention is disabled (enabled !== true, or has no policy)',
       report,
     };
   }
@@ -424,8 +443,8 @@ function applyRetention(runsDir, settings, opts) {
  * applyRetention's own internal queueStore fallback (resolveLiveKeysForApply
  * above), which exists only as a defensive net for callers who forget to
  * thread live-job info through, not as this module's primary path. Deletion
- * still only happens when the read config carries an explicit
- * schedulerRunLogRetention.enabled === true (see isRetentionEnabled).
+ * happens unless the read config opts out with
+ * schedulerRunLogRetention.enabled === false (see isRetentionEnabled).
  *
  * Intended to be called once per app boot (see index.cjs's deferred 30s
  * startup timer, alongside finalizeClosedDays) — never on its own timer.
@@ -438,6 +457,8 @@ function runBootSweep(opts) {
 }
 
 module.exports = {
+  DEFAULT_RUN_LOG_RETENTION,
+  resolveRetentionConfig,
   LIVE_STATUSES,
   isLiveJob,
   liveKeysFromJobs,

package/src/main/lib/{scheduleJobTransitions.cjs → scheduler/scheduleJobTransitions.cjs}

@@ -30,8 +30,8 @@
  */
 'use strict';
 
-const { appendAuditEvent } = require('./auditLog.cjs');
-const telemetryCounters = require('./telemetryCounters.cjs');
+const { appendAuditEvent } = require('../telemetry/auditLog.cjs');
+const telemetryCounters = require('../telemetry/telemetryCounters.cjs');
 const queueHistory = require('./queueHistory.cjs');
 const { buildNeedsReviewEntryLine, buildNeedsReviewResolutionLine } = require('./needsReviewLedger.cjs');
 
@@ -42,7 +42,7 @@ const { buildNeedsReviewEntryLine, buildNeedsReviewResolutionLine } = require('.
 const FINISH_STATUSES = new Set(['completed', 'failed', 'skipped', 'needs_review']);
 
 // Bounded so queue.json (mutation cost, broadcast payload, pickNextBatch
-// scan) stays small — same rationale as lib/queueHistory.cjs's retention
+// scan) stays small — same rationale as lib/scheduler/queueHistory.cjs's retention
 // window.
 const STATUS_HISTORY_CAP = 20;
 

package/src/main/lib/{schedulerBatch.cjs → scheduler/schedulerBatch.cjs}

@@ -15,7 +15,7 @@
 const path = require('node:path');
 const os = require('node:os');
 const { projectJobCap, quietMachineWaitMs } = require('./schedulerConfig.cjs');
-const { bareSlug } = require('./depSlugResolve.cjs');
+const { bareSlug, isSatisfiedDepRow } = require('../prd/depSlugResolve.cjs');
 
 const DEFAULT_PROJECT_CWD = path.join(os.homedir(), 'Projects', 'session-manager');
 
@@ -127,20 +127,16 @@ function findUnresolvableDepRoots(projectJobs, satisfiedSlugs = new Set()) {
 
 function findBlockingDep(job, projectJobs, satisfiedSlugs = new Set()) {
   const { rowsForDep, isKnownSatisfied } = makeDepResolver(projectJobs, satisfiedSlugs);
-  // A dep row is blocking unless it's 'completed', OR it's a 'skipped' row
-  // stamped `needsReviewAutoResolvedSkip` — the bounded needs_review
-  // auto-resolve terminal decision (scheduler.cjs's
-  // applyNeedsReviewAutoResolve). That skip is deliberately NOT the
+  // A dep row is blocking unless isSatisfiedDepRow — 'completed', or a
+  // `needsReviewAutoResolvedSkip` skip. That skip is deliberately NOT the
   // "PRD source vanished, a human must author a fresh PRD" skip the
-  // heldBySkippedDep messaging above describes — it already got every
-  // bounded chance to resolve itself, so treating it as a permanent
-  // dependsOn block would defeat the whole point of that auto-resolve pass
-  // (a chain that never drains without an operator).
-  const isSatisfiedRow = (dep) => dep.status === 'completed'
-    || (dep.status === 'skipped' && dep.needsReviewAutoResolvedSkip === true);
+  // heldBySkippedDep messaging describes — it already got every bounded
+  // chance to resolve itself, so treating it as a permanent dependsOn block
+  // would defeat the auto-resolve pass. runVerify.checkDeps MUST use the same
+  // predicate, or every run of the dependent is downgraded and re-dispatched.
   return (job.dependsOn ?? []).find((slug) => {
     const rows = rowsForDep(slug);
-    if (rows.length > 0) return rows.some((dep) => !isSatisfiedRow(dep));
+    if (rows.length > 0) return rows.some((dep) => !isSatisfiedDepRow(dep));
     return !isKnownSatisfied(slug);
   });
 }
@@ -250,7 +246,7 @@ function pickForProject(projectJobs, runningSlugsInProject, slots, heldSlugs = n
   // (evaluated before this function is ever called) is the only path that
   // can fire one, since dispatching one is a whole-tick, all-projects
   // exclusive decision this per-project function can't see.
-  // Launch-gate holds (lib/launchFailure.cjs, issue #11): a pending row
+  // Launch-gate holds (lib/scheduler/launchFailure.cjs, issue #11): a pending row
   // whose launch persona is circuit-broken is NOT a candidate this tick and
   // must not shadow a pickable sibling behind it. It still gets a per-row
   // hold record so the Queue UI says why it is waiting.

package/src/main/lib/{schedulerConfig.cjs → scheduler/schedulerConfig.cjs}

@@ -68,7 +68,7 @@ module.exports = {
   RECONCILE_SLOW_PASS_MS: 2_000,
   // Terminal (completed/failed) jobs older than this move from queue.json's
   // hot jobs[] into the append-only history.jsonl sidecar. See
-  // src/main/lib/queueHistory.cjs.
+  // src/main/lib/scheduler/queueHistory.cjs.
   HISTORY_RETENTION_MS: 7 * 24 * 60 * 60_000,
   // Cadence for the in-app intraday refresher that keeps TODAY's History
   // rollup line current (see historyAggregator.cjs's refreshIntradayToday).

package/src/main/lib/{schedulerRuntimeState.cjs → scheduler/schedulerRuntimeState.cjs}

@@ -7,7 +7,7 @@
  */
 'use strict';
 
-const { appendAuditEvent } = require('./auditLog.cjs');
+const { appendAuditEvent } = require('../telemetry/auditLog.cjs');
 const { isProvablyDead, DEFAULT_GRACE_MS } = require('./reservationExpiry.cjs');
 
 const investigations = new Map(); // slug -> { claimedAt, pid }

package/src/main/lib/{sessionSlots.cjs → scheduler/sessionSlots.cjs}

@@ -27,8 +27,8 @@ const crypto = require('node:crypto');
 const fs = require('node:fs');
 const path = require('node:path');
 const { sessionSlotsConfigPath } = require('./schedulerPaths.cjs');
-const { appendAuditEvent } = require('./auditLog.cjs');
-const atomicFs = require('./atomicFs.cjs');
+const { appendAuditEvent } = require('../telemetry/auditLog.cjs');
+const atomicFs = require('../util/atomicFs.cjs');
 const { isProvablyDead, DEFAULT_GRACE_MS } = require('./reservationExpiry.cjs');
 
 const MIN_SLOTS = 0;

package/src/main/lib/{upgradeDrain.cjs → scheduler/upgradeDrain.cjs}

@@ -24,7 +24,7 @@
 const fs = require('node:fs');
 const path = require('node:path');
 const schedulerPaths = require('./schedulerPaths.cjs');
-const atomicFs = require('./atomicFs.cjs');
+const atomicFs = require('../util/atomicFs.cjs');
 
 // Observed max job run is 240 min; 4 h converts a stuck drain to an abort.
 const DEFAULT_DRAIN_DEADLINE_MS = 4 * 60 * 60_000;
@@ -32,11 +32,8 @@ const DEFAULT_DRAIN_DEADLINE_MS = 4 * 60 * 60_000;
 // relaunch is picked up by the watchdog again.
 const RESTARTING_MARKER_TTL_MS = 5 * 60_000;
 
-function writeJsonAtomicSync(file, value) {
-  atomicFs.writeJsonAtomicSync(file, value);
-}
-
-function readJsonSafe(file) {
+/** Object-or-null view over atomicFs.readJsonOrSync (arrays/scalars → null). */
+function readJsonObject(file) {
   const v = atomicFs.readJsonOrSync(file, null);
   return v && typeof v === 'object' ? v : null;
 }
@@ -44,7 +41,7 @@ function readJsonSafe(file) {
 // ---------- request file ----------
 
 function readRestartRequest(file = schedulerPaths.restartRequestPath()) {
-  return readJsonSafe(file);
+  return readJsonObject(file);
 }
 
 /**
@@ -60,7 +57,7 @@ function requestRestart({ reason, requestedBy } = {}, { file = schedulerPaths.re
     requestedBy: typeof requestedBy === 'string' && requestedBy ? requestedBy : 'unknown',
     requestedAt: new Date(now).toISOString(),
   };
-  writeJsonAtomicSync(file, request);
+  atomicFs.writeJsonAtomicSync(file, request);
   return request;
 }
 
@@ -69,7 +66,7 @@ function stampDrainCompleted(now = Date.now(), file = schedulerPaths.restartRequ
   const existing = readRestartRequest(file);
   if (!existing) return null;
   const stamped = { ...existing, drainCompletedAt: new Date(now).toISOString() };
-  writeJsonAtomicSync(file, stamped);
+  atomicFs.writeJsonAtomicSync(file, stamped);
   return stamped;
 }
 
@@ -151,7 +148,7 @@ function installedBuildDiffers({ running, installed } = {}) {
 // ---------- restarting marker (watchdog) ----------
 
 function markRestarting({ file = schedulerPaths.restartingMarkerPath(), now = Date.now(), ttlMs = RESTARTING_MARKER_TTL_MS } = {}) {
-  writeJsonAtomicSync(file, { pid: process.pid, at: now, expiresAt: now + ttlMs });
+  atomicFs.writeJsonAtomicSync(file, { pid: process.pid, at: now, expiresAt: now + ttlMs });
 }
 
 function clearRestartingMarker(file = schedulerPaths.restartingMarkerPath()) {
@@ -160,7 +157,7 @@ function clearRestartingMarker(file = schedulerPaths.restartingMarkerPath()) {
 
 /** True while the marker exists and has not expired (bounded lifetime). */
 function isRestartingMarkerActive({ file = schedulerPaths.restartingMarkerPath(), now = Date.now() } = {}) {
-  const m = readJsonSafe(file);
+  const m = readJsonObject(file);
   return Boolean(m) && typeof m.expiresAt === 'number' && now < m.expiresAt;
 }
 

package/src/main/lib/{watchdogHelpers.cjs → scheduler/watchdogHelpers.cjs}

@@ -7,9 +7,9 @@ const fs = require('node:fs');
 const path = require('node:path');
 const schedulerPaths = require('./schedulerPaths.cjs');
 const { isRestartingMarkerActive } = require('./upgradeDrain.cjs');
-const { pidAlive: pidAliveCore } = require('./pidAlive.cjs');
-const atomicFs = require('./atomicFs.cjs');
-const { isPackagedApp } = require('./appRuntime.cjs');
+const { pidAlive } = require('../process/pidAlive.cjs');
+const atomicFs = require('../util/atomicFs.cjs');
+const { isPackagedApp } = require('../appRuntime.cjs');
 
 
 
@@ -142,19 +142,6 @@ function evaluateDispatchLiveness(entry, now = Date.now(), { deadMs = DEFAULT_DI
   return { dead: true, reason: 'dispatch-dead' };
 }
 
-/**
- * isPidAlive(pid) → boolean
- *
- * Thin alias over pidAlive.cjs's shared pidAlive() — single source of truth
- * for the "is this recorded pid still alive" check used by
- * checkAppLiveness's defense-in-depth relaunch gate. Kept as a named export
- * here (rather than inlining the require at every call site) so existing
- * imports of `isPidAlive` from this module keep working unchanged.
- */
-function isPidAlive(pid) {
-  return pidAliveCore(pid);
-}
-
 // Offline queue.json reconciliation (orphaned 'running' jobs whose pid died
 // while Electron wasn't running) used to live here as reconcileQueueOffline().
 // PRD 686 moved that responsibility into src/main/scheduler.cjs's own boot
@@ -188,7 +175,7 @@ function checkAppLiveness({
     return { alive: true, reason: 'heartbeat-fresh' };
   }
   const last = readLastHeartbeat(heartbeatPath);
-  if (last !== null && typeof last.pid === 'number' && isPidAlive(last.pid)) {
+  if (last !== null && typeof last.pid === 'number' && pidAlive(last.pid)) {
     return { alive: true, reason: 'pid-alive-heartbeat-stale' };
   }
   return { alive: false, reason: 'stale-and-dead' };
@@ -408,7 +395,7 @@ function releaseLock(lockPath) {
  *  dependency fails inside maybeFinalizeHistory's try/catch, not at require
  *  time for the whole watchdog script. */
 function defaultFinalizeClosedDays(opts) {
-  const { finalizeClosedDays } = require('../historyAggregator.cjs');
+  const { finalizeClosedDays } = require('../../historyAggregator.cjs');
   return finalizeClosedDays(opts);
 }
 
@@ -470,7 +457,6 @@ module.exports = {
   readLastHeartbeatTs,
   heartbeatFresh,
   evaluateDispatchLiveness,
-  isPidAlive,
   localDateStr,
   maybeFinalizeHistory,
   tryAcquireLock,

package/src/main/lib/{auditLog.cjs → telemetry/auditLog.cjs}

@@ -18,7 +18,7 @@
 const fs = require('node:fs');
 const path = require('node:path');
 
-const { auditLogPath } = require('./schedulerPaths.cjs');
+const { auditLogPath } = require('../scheduler/schedulerPaths.cjs');
 
 /**
  * Best-effort identity of the process making this call — there is no

package/src/main/lib/{opsErrorLog.cjs → telemetry/opsErrorLog.cjs}

@@ -14,8 +14,8 @@
 const fs = require('node:fs');
 const os = require('node:os');
 const path = require('node:path');
-const { assertOpsWrite } = require('./opsOwnership.cjs');
-const { isEphemeralCwd } = require('./ephemeralCwd.cjs');
+const { assertOpsWrite } = require('../opsOwnership.cjs');
+const { isEphemeralCwd } = require('../ephemeralCwd.cjs');
 
 // Same redaction policy as logs.cjs's sanitizeMeta — kept independent (not
 // shared/required) so this module has no dependency on the Electron `app`
@@ -33,7 +33,7 @@ function sanitizeMeta(meta) {
 }
 
 function logsDir(cwd) {
-  const { opsPath } = require('./opsOwnership.cjs');
+  const { opsPath } = require('../opsOwnership.cjs');
   return opsPath(cwd, 'logs');
 }
 
@@ -108,7 +108,7 @@ function writeLocalLine({ cwd, scope, level, tabId, epicId, tags, message, meta
 function reportToTelemetry({ cwd, scope, level, tabId, epicId, tags, message }) {
   try {
     const telemetryClient = require('./telemetryClient.cjs');
-    const { projectRootOf } = require('./activeSessions.cjs');
+    const { projectRootOf } = require('../activeSessions.cjs');
     const normalizedCwd = projectRootOf(cwd) || cwd;
     const autoTags = [
       `scope:${scope || 'unknown'}`,

package/src/main/lib/{telemetryBacklog.cjs → telemetry/telemetryBacklog.cjs}

@@ -70,7 +70,7 @@ const os = require('node:os');
 const path = require('node:path');
 const crypto = require('node:crypto');
 
-const config = require('../config.cjs');
+const config = require('../../config.cjs');
 
 const DEFAULT_LIMIT = 500;
 const RETENTION_DAYS = 30;
@@ -97,9 +97,9 @@ function watermarksPath() {
 
 function resolveDeps(deps = {}) {
   return {
-    sessionsStore: deps.sessionsStore || require('../sessionsStore.cjs'),
-    isEphemeralCwd: deps.isEphemeralCwd || require('./ephemeralCwd.cjs').isEphemeralCwd,
-    resolveProjectContext: deps.resolveProjectContext || require('./projectRootResolve.cjs').resolveProjectContext,
+    sessionsStore: deps.sessionsStore || require('../../sessionsStore.cjs'),
+    isEphemeralCwd: deps.isEphemeralCwd || require('../ephemeralCwd.cjs').isEphemeralCwd,
+    resolveProjectContext: deps.resolveProjectContext || require('../projectRootResolve.cjs').resolveProjectContext,
     telemetryClient: deps.telemetryClient || require('./telemetryClient.cjs'),
     opsErrorLog: deps.opsErrorLog || require('./opsErrorLog.cjs'),
     config: deps.config || config,

package/src/main/lib/{telemetryBoot.cjs → telemetry/telemetryBoot.cjs}

@@ -22,7 +22,7 @@ function resolveDeps(deps = {}) {
   return {
     telemetrySettings: deps.telemetrySettings || require('./telemetrySettings.cjs'),
     telemetryClient: deps.telemetryClient || require('./telemetryClient.cjs'),
-    buildMachineProfile: deps.buildMachineProfile || require('./machineProfile.cjs').buildMachineProfile,
+    buildMachineProfile: deps.buildMachineProfile || require('../machineProfile.cjs').buildMachineProfile,
     telemetryCounters: deps.telemetryCounters || require('./telemetryCounters.cjs'),
   };
 }

package/src/main/lib/{telemetryClient.cjs → telemetry/telemetryClient.cjs}

@@ -20,7 +20,7 @@
  * returned promise resolves once accepted/dropped, but callers are free to
  * not await it). Telemetry failing must stay invisible to the user.
  *
- * Single-writer precedent (../lib/instanceLock.cjs): this module assumes the
+ * Single-writer precedent (../lib/process/instanceLock.cjs): this module assumes the
  * app's main process is the only writer of the queue/sent-set files for a
  * given machine. It does not itself arbitrate multiple OS processes.
  *
@@ -35,9 +35,9 @@ const os = require('node:os');
 const path = require('node:path');
 const crypto = require('node:crypto');
 
-const config = require('../config.cjs');
+const config = require('../../config.cjs');
 const telemetrySettings = require('./telemetrySettings.cjs');
-const machineProfile = require('./machineProfile.cjs');
+const machineProfile = require('../machineProfile.cjs');
 
 const MAX_BATCH = 50;
 const QUEUE_CAP_COUNT = 5000;
@@ -104,7 +104,7 @@ const S = {
  */
 function logWarn(message, meta) {
   try {
-    const fn = S.logger || require('../logs.cjs').writeLine;
+    const fn = S.logger || require('../../logs.cjs').writeLine;
     fn({ scope: 'telemetry', level: 'warn', message, meta });
   } catch { /* logs unavailable outside an Electron runtime */ }
 }
@@ -647,18 +647,20 @@ function describeFailureStatus(status) {
   return status === 0 ? 'network error' : `HTTP ${status}`;
 }
 
-function applyFailureBackoff(status) {
+function applyFailureBackoff(status, channel) {
   if (status === 429 || status === 0 || status >= 500) {
     S.consecutiveFailures += 1;
     const ms = Math.min(BACKOFF_BASE_MS * (2 ** (S.consecutiveFailures - 1)), BACKOFF_MAX_MS);
     S.backoffUntil = Date.now() + ms;
     S.lastError = { status, message: describeFailureStatus(status), at: Date.now() };
+    logWarn('telemetry send failed', { channel, status, consecutiveFailures: S.consecutiveFailures, backoffMs: ms });
     return;
   }
   if (status >= 400 && status < 500) {
     // Malformed-contract circuit breaker (includes 401) — not retried.
     S.disabledForProcess = true;
     S.lastError = { status, message: describeFailureStatus(status), at: Date.now() };
+    logWarn('telemetry disabled for process', { status });
   }
 }
 
@@ -705,7 +707,7 @@ async function flushImpl(reason) {
             result.sent.push(r.recordId);
           } else {
             result.failed.push(r.recordId);
-            applyFailureBackoff(res.status);
+            applyFailureBackoff(res.status, channel);
             sawFailure = true;
             break;
           }
@@ -726,7 +728,7 @@ async function flushImpl(reason) {
           }
         } else {
           for (const r of batch) result.failed.push(r.recordId);
-          applyFailureBackoff(res.status);
+          applyFailureBackoff(res.status, channel);
           sawFailure = true;
           break;
         }
@@ -739,7 +741,9 @@ async function flushImpl(reason) {
     if (safeReason === 'daily' && result.failed.length === 0) {
       S.settings = await telemetrySettings.save({ lastDailyFlushAt: new Date().toISOString() });
     }
-  } catch { /* fail-inert */ }
+  } catch (e) {
+    logWarn('telemetry flush threw', { error: e && e.message ? e.message : String(e) });
+  }
   S.lastFlushAt = Date.now();
   S.lastFlushReason = safeReason;
   return result;

package/src/main/lib/{telemetrySettings.cjs → telemetry/telemetrySettings.cjs}

@@ -26,7 +26,7 @@ const fsp = require('node:fs/promises');
 const path = require('node:path');
 const os = require('node:os');
 const crypto = require('node:crypto');
-const config = require('../config.cjs');
+const config = require('../../config.cjs');
 
 const SCHEMA_VERSION = 1;
 const DAY_MS = 24 * 60 * 60 * 1000;