@teamvibe/poller 0.6.2 → 0.7.0

package/dist/config.d.ts

@@ -15,6 +15,7 @@ declare const configSchema: z.ZodObject<{
     LOCK_RETRY_INTERVAL_MS: z.ZodDefault<z.ZodNumber>;
     IDLE_WATCHDOG_WARN_MS: z.ZodDefault<z.ZodNumber>;
     IDLE_WATCHDOG_KILL_MS: z.ZodDefault<z.ZodNumber>;
+    IDLE_WATCHDOG_COMPACTION_GRACE_MS: z.ZodDefault<z.ZodNumber>;
     NETWORK_ERROR_KILL_MS: z.ZodDefault<z.ZodNumber>;
     MAX_CONSECUTIVE_NET_FAILURES: z.ZodDefault<z.ZodNumber>;
     TEAMVIBE_DATA_DIR: z.ZodDefault<z.ZodString>;
@@ -28,6 +29,11 @@ declare const configSchema: z.ZodObject<{
     BASE_BRAIN_PATH: z.ZodDefault<z.ZodString>;
     BRAIN_AUTO_UPDATE: z.ZodEffects<z.ZodDefault<z.ZodString>, boolean, string | undefined>;
     BRAIN_UPDATE_COOLDOWN_MS: z.ZodDefault<z.ZodNumber>;
+    BRAIN_MAX_BLOB_BYTES: z.ZodDefault<z.ZodNumber>;
+    BRAIN_PUSH_RETRY_MAX: z.ZodDefault<z.ZodNumber>;
+    BRAIN_PUSH_RETRY_BACKOFF_MS: z.ZodDefault<z.ZodNumber>;
+    GIT_LOCK_MAX_AGE_MS: z.ZodDefault<z.ZodNumber>;
+    GIT_SUBMODULE_LOCK_MAX_AGE_MS: z.ZodDefault<z.ZodNumber>;
     POLLER_TZ: z.ZodOptional<z.ZodString>;
     MAINTENANCE_CRON: z.ZodDefault<z.ZodString>;
     MAINTENANCE_ENABLED: z.ZodEffects<z.ZodDefault<z.ZodString>, boolean, string | undefined>;
@@ -47,6 +53,7 @@ declare const configSchema: z.ZodObject<{
     LOCK_RETRY_INTERVAL_MS: number;
     IDLE_WATCHDOG_WARN_MS: number;
     IDLE_WATCHDOG_KILL_MS: number;
+    IDLE_WATCHDOG_COMPACTION_GRACE_MS: number;
     NETWORK_ERROR_KILL_MS: number;
     MAX_CONSECUTIVE_NET_FAILURES: number;
     TEAMVIBE_DATA_DIR: string;
@@ -60,6 +67,11 @@ declare const configSchema: z.ZodObject<{
     BASE_BRAIN_PATH: string;
     BRAIN_AUTO_UPDATE: boolean;
     BRAIN_UPDATE_COOLDOWN_MS: number;
+    BRAIN_MAX_BLOB_BYTES: number;
+    BRAIN_PUSH_RETRY_MAX: number;
+    BRAIN_PUSH_RETRY_BACKOFF_MS: number;
+    GIT_LOCK_MAX_AGE_MS: number;
+    GIT_SUBMODULE_LOCK_MAX_AGE_MS: number;
     MAINTENANCE_CRON: string;
     MAINTENANCE_ENABLED: boolean;
     AUTO_UPDATE_POLICY: "patch" | "minor" | "off";
@@ -85,6 +97,7 @@ declare const configSchema: z.ZodObject<{
     LOCK_RETRY_INTERVAL_MS?: number | undefined;
     IDLE_WATCHDOG_WARN_MS?: number | undefined;
     IDLE_WATCHDOG_KILL_MS?: number | undefined;
+    IDLE_WATCHDOG_COMPACTION_GRACE_MS?: number | undefined;
     NETWORK_ERROR_KILL_MS?: number | undefined;
     MAX_CONSECUTIVE_NET_FAILURES?: number | undefined;
     TEAMVIBE_DATA_DIR?: string | undefined;
@@ -98,6 +111,11 @@ declare const configSchema: z.ZodObject<{
     BASE_BRAIN_PATH?: string | undefined;
     BRAIN_AUTO_UPDATE?: string | undefined;
     BRAIN_UPDATE_COOLDOWN_MS?: number | undefined;
+    BRAIN_MAX_BLOB_BYTES?: number | undefined;
+    BRAIN_PUSH_RETRY_MAX?: number | undefined;
+    BRAIN_PUSH_RETRY_BACKOFF_MS?: number | undefined;
+    GIT_LOCK_MAX_AGE_MS?: number | undefined;
+    GIT_SUBMODULE_LOCK_MAX_AGE_MS?: number | undefined;
     POLLER_TZ?: string | undefined;
     MAINTENANCE_CRON?: string | undefined;
     MAINTENANCE_ENABLED?: string | undefined;
@@ -120,6 +138,7 @@ export declare const config: {
     LOCK_RETRY_INTERVAL_MS: number;
     IDLE_WATCHDOG_WARN_MS: number;
     IDLE_WATCHDOG_KILL_MS: number;
+    IDLE_WATCHDOG_COMPACTION_GRACE_MS: number;
     NETWORK_ERROR_KILL_MS: number;
     MAX_CONSECUTIVE_NET_FAILURES: number;
     TEAMVIBE_DATA_DIR: string;
@@ -133,6 +152,11 @@ export declare const config: {
     BASE_BRAIN_PATH: string;
     BRAIN_AUTO_UPDATE: boolean;
     BRAIN_UPDATE_COOLDOWN_MS: number;
+    BRAIN_MAX_BLOB_BYTES: number;
+    BRAIN_PUSH_RETRY_MAX: number;
+    BRAIN_PUSH_RETRY_BACKOFF_MS: number;
+    GIT_LOCK_MAX_AGE_MS: number;
+    GIT_SUBMODULE_LOCK_MAX_AGE_MS: number;
     MAINTENANCE_CRON: string;
     MAINTENANCE_ENABLED: boolean;
     AUTO_UPDATE_POLICY: "patch" | "minor" | "off";

package/dist/config.js

@@ -20,10 +20,11 @@ const configSchema = z.object({
     VISIBILITY_TIMEOUT_SECONDS: z.coerce.number().default(60),
     HEARTBEAT_INTERVAL_MS: z.coerce.number().default(40000), // 40 seconds
     CLAUDE_TIMEOUT_MS: z.coerce.number().default(3600000), // 60 minutes
-    STALE_LOCK_TIMEOUT_MS: z.coerce.number().default(900000), // 15 minutes (above idle watchdog kill time of 10 min)
+    STALE_LOCK_TIMEOUT_MS: z.coerce.number().default(1800000), // 30 minutes (comfortable margin above the ~15min worst-case compaction kill deadline below)
     LOCK_RETRY_INTERVAL_MS: z.coerce.number().default(30000), // 30 seconds
     IDLE_WATCHDOG_WARN_MS: z.coerce.number().default(300000), // 5 minutes
-    IDLE_WATCHDOG_KILL_MS: z.coerce.number().default(600000), // 10 minutes
+    IDLE_WATCHDOG_KILL_MS: z.coerce.number().default(600000), // 10 minutes (default; on a compact_boundary event, becomes max(this-from-silence-start, event-time + IDLE_WATCHDOG_COMPACTION_GRACE_MS) — tv#32)
+    IDLE_WATCHDOG_COMPACTION_GRACE_MS: z.coerce.number().default(300000), // 5 minutes — fixed grace from compact_boundary arrival, not a large speculative ceiling (compact_boundary only proves compaction STARTED, never that it finishes in bounded time)
     NETWORK_ERROR_KILL_MS: z.coerce.number().default(120000), // Per-session: kill stuck session after 2 min of network errors
     MAX_CONSECUTIVE_NET_FAILURES: z.coerce.number().default(5), // Poll loop: DNS flush at N, exit(1) at 2×N consecutive failures
     // Paths
@@ -43,6 +44,18 @@ const configSchema = z.object({
         .default('true')
         .transform((v) => v.toLowerCase() === 'true'),
     BRAIN_UPDATE_COOLDOWN_MS: z.coerce.number().default(300000), // 5 minutes
+    // Push guard: refuse to push unpushed commits that carry a blob over this size.
+    // Prevents a single oversized scratch file (e.g. agent .local/tmp/ writes) from
+    // getting permanently rejected by GitHub's pre-receive hook (tv#246).
+    BRAIN_MAX_BLOB_BYTES: z.coerce.number().default(50 * 1024 * 1024), // 50 MB
+    // Brain push-race retry (tv#232): fetch+rebase+retry on non-fast-forward push rejection
+    BRAIN_PUSH_RETRY_MAX: z.coerce.number().default(3),
+    BRAIN_PUSH_RETRY_BACKOFF_MS: z.coerce.number().default(500), // linear backoff: backoffMs * attempt
+    // Stale git lock cleanup (tv#76): orphaned locks from killed processes
+    // (e.g. the 2026-05-01 outage) block all future brain updates indefinitely
+    // unless removed. Distinct from STALE_LOCK_TIMEOUT_MS above (DDB session lock).
+    GIT_LOCK_MAX_AGE_MS: z.coerce.number().default(120000), // 2 minutes — .git/index.lock
+    GIT_SUBMODULE_LOCK_MAX_AGE_MS: z.coerce.number().default(300000), // 5 minutes — .git/modules/*/config.lock
     // Brain maintenance (cron-based)
     // POLLER_TZ: optional IANA timezone for MAINTENANCE_CRON.
     // When unset, croner uses the host system timezone (e.g. `Europe/Prague` on

package/dist/cron-telemetry.d.ts

@@ -12,11 +12,14 @@
  */
 export declare function markMaintenanceJobFired(at?: number): void;
 export declare function markMaintenanceJobSuccess(at?: number): void;
+export declare function markMaintenanceJobSkipped(at?: number): void;
 export declare function markAutoUpdateJobFired(at?: number): void;
 export declare function markAutoUpdateJobSuccess(at?: number): void;
 export interface CronJobTimestamps {
     lastMaintenanceJobFiredAt: number | null;
     lastMaintenanceJobSuccessAt: number | null;
+    lastMaintenanceJobSkippedAt: number | null;
+    maintenanceSkippedCountLastRun: number;
     lastAutoUpdateJobFiredAt: number | null;
     lastAutoUpdateJobSuccessAt: number | null;
 }

package/dist/cron-telemetry.js

@@ -14,12 +14,24 @@ let lastMaintenanceJobFiredAt = null;
 let lastMaintenanceJobSuccessAt = null;
 let lastAutoUpdateJobFiredAt = null;
 let lastAutoUpdateJobSuccessAt = null;
+// teamvibeai/teamvibe.ai#131 — activity-based skip observability. Count
+// resets on each markMaintenanceJobFired() (i.e. once per cron run), so it
+// reflects "brains skipped in the most recently started run", not a
+// lifetime total. Without this, a `shouldSkipMaintenance` edge-case bug
+// that over-skips would be invisible short of manual per-brain digging.
+let lastMaintenanceJobSkippedAt = null;
+let maintenanceSkippedCountLastRun = 0;
 export function markMaintenanceJobFired(at = Date.now()) {
     lastMaintenanceJobFiredAt = at;
+    maintenanceSkippedCountLastRun = 0;
 }
 export function markMaintenanceJobSuccess(at = Date.now()) {
     lastMaintenanceJobSuccessAt = at;
 }
+export function markMaintenanceJobSkipped(at = Date.now()) {
+    lastMaintenanceJobSkippedAt = at;
+    maintenanceSkippedCountLastRun += 1;
+}
 export function markAutoUpdateJobFired(at = Date.now()) {
     lastAutoUpdateJobFiredAt = at;
 }
@@ -30,6 +42,8 @@ export function getCronJobTimestamps() {
     return {
         lastMaintenanceJobFiredAt,
         lastMaintenanceJobSuccessAt,
+        lastMaintenanceJobSkippedAt,
+        maintenanceSkippedCountLastRun,
         lastAutoUpdateJobFiredAt,
         lastAutoUpdateJobSuccessAt,
     };
@@ -41,6 +55,8 @@ export function getCronJobTimestamps() {
 export function __resetCronTelemetryForTest() {
     lastMaintenanceJobFiredAt = null;
     lastMaintenanceJobSuccessAt = null;
+    lastMaintenanceJobSkippedAt = null;
+    maintenanceSkippedCountLastRun = 0;
     lastAutoUpdateJobFiredAt = null;
     lastAutoUpdateJobSuccessAt = null;
 }

package/dist/event-queue.d.ts

@@ -1,5 +1,32 @@
 export type ErrorCategory = 'sqs' | 'brain' | 'auth' | 'session' | 'slack' | 'maintenance';
 export type ErrorSeverity = 'warn' | 'error';
+interface ErrorEvent {
+    eventType: 'poller.error';
+    channelId: string;
+    metadata: {
+        category: ErrorCategory;
+        severity: ErrorSeverity;
+        message: string;
+        count: number;
+        context?: Record<string, unknown>;
+    };
+    error: {
+        code: string;
+        message: string;
+    };
+    timestamp: string;
+}
+interface GenericEvent {
+    eventType: string;
+    channelId: string;
+    metadata?: Record<string, unknown>;
+    error?: {
+        code: string;
+        message: string;
+    };
+    timestamp: string;
+}
+type QueuedEvent = ErrorEvent | GenericEvent;
 export declare function emitEvent(eventType: string, channelId: string, metadata?: Record<string, unknown>): void;
 export declare function flush(): Promise<void>;
 export declare function startEventQueue(): void;
@@ -11,5 +38,8 @@ export declare function emitError(category: ErrorCategory, message: string, opti
 }): void;
 /** For testing: get current queue length */
 export declare function getQueueLength(): number;
+/** For testing: inspect queued events (e.g. assert on errorCode/severity) without flushing */
+export declare function peekQueue(): QueuedEvent[];
 /** For testing: clear the queue */
 export declare function clearQueue(): void;
+export {};

package/dist/event-queue.js

@@ -124,6 +124,10 @@ export function emitError(category, message, options) {
 export function getQueueLength() {
     return queue.length;
 }
+/** For testing: inspect queued events (e.g. assert on errorCode/severity) without flushing */
+export function peekQueue() {
+    return [...queue];
+}
 /** For testing: clear the queue */
 export function clearQueue() {
     queue = [];

package/dist/inbox-manager.d.ts

@@ -20,6 +20,31 @@ export declare function markFailed(brainPath: string, threadId: string, filename
  * Delete a message file from processing/ (marks it as done).
  */
 export declare function markProcessed(brainPath: string, threadId: string, filename: string): void;
+/**
+ * Move a message from processing/ back to new/.
+ *
+ * Used specifically for a poller-initiated *shutdown* kill (teamvibe.ai#73,
+ * PR#308 round-5): pickNextMessage() above moves a file to processing/ as
+ * soon as it's picked up, not once it completes, so a message killed
+ * mid-flight by shutdown() is left sitting in processing/. The inbox
+ * watcher's wake condition (hasNewMessage(), inbox-watcher.ts) only scans
+ * new/ — a thread whose only pending message is in processing/ has nothing
+ * to start a fresh runInboxLoop() for it on the next boot, so it could sit
+ * stuck indefinitely. Moving it back to new/ here is what makes the
+ * shutdown-kill notice text ("your message is saved and will resume
+ * automatically", classify-failed-iteration.ts) literally true.
+ *
+ * Deliberately NOT used for timeout/idle/network/zombie kills — those retry
+ * immediately within the same still-running loop iteration (see
+ * isPollerInitiatedFailure() / the loop condition in poller.ts), so the
+ * existing processing/ crash-recovery branch in pickNextMessage() already
+ * covers them; requeueing those too would be redundant.
+ *
+ * Tolerant of the source file already being gone (e.g. a concurrent
+ * markProcessed/markFailed pass, or this being invoked twice for the same
+ * iteration) — that's a no-op, not an error.
+ */
+export declare function requeueMessage(brainPath: string, threadId: string, filename: string): void;
 /**
  * Check if there are unprocessed messages in new/ or processing/.
  */

package/dist/inbox-manager.js

@@ -93,6 +93,53 @@ export function markProcessed(brainPath, threadId, filename) {
         logger.warn(`[Inbox] Failed to delete ${filename}: ${error}`);
     }
 }
+/**
+ * Move a message from processing/ back to new/.
+ *
+ * Used specifically for a poller-initiated *shutdown* kill (teamvibe.ai#73,
+ * PR#308 round-5): pickNextMessage() above moves a file to processing/ as
+ * soon as it's picked up, not once it completes, so a message killed
+ * mid-flight by shutdown() is left sitting in processing/. The inbox
+ * watcher's wake condition (hasNewMessage(), inbox-watcher.ts) only scans
+ * new/ — a thread whose only pending message is in processing/ has nothing
+ * to start a fresh runInboxLoop() for it on the next boot, so it could sit
+ * stuck indefinitely. Moving it back to new/ here is what makes the
+ * shutdown-kill notice text ("your message is saved and will resume
+ * automatically", classify-failed-iteration.ts) literally true.
+ *
+ * Deliberately NOT used for timeout/idle/network/zombie kills — those retry
+ * immediately within the same still-running loop iteration (see
+ * isPollerInitiatedFailure() / the loop condition in poller.ts), so the
+ * existing processing/ crash-recovery branch in pickNextMessage() already
+ * covers them; requeueing those too would be redundant.
+ *
+ * Tolerant of the source file already being gone (e.g. a concurrent
+ * markProcessed/markFailed pass, or this being invoked twice for the same
+ * iteration) — that's a no-op, not an error.
+ */
+export function requeueMessage(brainPath, threadId, filename) {
+    const inbox = getInboxPath(brainPath, threadId);
+    const srcPath = join(inbox, PROCESSING_DIR, filename);
+    const newDir = join(inbox, NEW_DIR);
+    mkdirSync(newDir, { recursive: true });
+    const dstPath = join(newDir, filename);
+    try {
+        if (existsSync(srcPath)) {
+            renameSync(srcPath, dstPath);
+            logger.info(`[Inbox] Requeued shutdown-killed message to new/: ${filename}`);
+        }
+        else {
+            logger.info(`[Inbox] Requeue skipped, ${filename} already gone from processing/`);
+        }
+    }
+    catch (error) {
+        // e.g. ENOENT from a race between the existsSync check above and the
+        // rename itself — same tolerance as the existsSync guard, just covering
+        // the narrower window. Log and continue; never let a requeue failure
+        // crash the shutdown path.
+        logger.warn(`[Inbox] Failed to requeue ${filename} to new/: ${error}`);
+    }
+}
 /**
  * Check if there are unprocessed messages in new/ or processing/.
  */

package/dist/maintenance-activity.d.ts

@@ -0,0 +1,18 @@
+export interface ActivityCheckDeps {
+    statFn: (path: string) => Promise<{
+        mtimeMs: number;
+    }>;
+}
+/**
+ * Poller-side half of teamvibe.ai#131: skip the nightly maintenance trigger
+ * for a brain that has had zero real (non-maintenance-sourced) activity
+ * since its last maintenance run, so a quiet brain doesn't pay for a Claude
+ * spawn just to no-op inside the session's own time-debounce guard.
+ *
+ * `lastRealMessageAt` is set by registerBrain() (maintenance-cron.ts) on
+ * every non-maintenance message. It is undefined when the poller hasn't
+ * seen one since its own last restart (trackedBrains is in-memory, #127) —
+ * in that case we fail open (never skip) rather than risk starving a brain
+ * of maintenance because of a poller restart, not actual inactivity.
+ */
+export declare function shouldSkipMaintenance(brainsPath: string, brainId: string, lastRealMessageAt: number | undefined, deps?: ActivityCheckDeps): Promise<boolean>;

package/dist/maintenance-activity.js

@@ -0,0 +1,28 @@
+import { stat } from 'fs/promises';
+import { join } from 'path';
+const defaultDeps = { statFn: stat };
+/**
+ * Poller-side half of teamvibe.ai#131: skip the nightly maintenance trigger
+ * for a brain that has had zero real (non-maintenance-sourced) activity
+ * since its last maintenance run, so a quiet brain doesn't pay for a Claude
+ * spawn just to no-op inside the session's own time-debounce guard.
+ *
+ * `lastRealMessageAt` is set by registerBrain() (maintenance-cron.ts) on
+ * every non-maintenance message. It is undefined when the poller hasn't
+ * seen one since its own last restart (trackedBrains is in-memory, #127) —
+ * in that case we fail open (never skip) rather than risk starving a brain
+ * of maintenance because of a poller restart, not actual inactivity.
+ */
+export async function shouldSkipMaintenance(brainsPath, brainId, lastRealMessageAt, deps = defaultDeps) {
+    if (lastRealMessageAt === undefined)
+        return false;
+    try {
+        const guardPath = join(brainsPath, brainId, 'memory/.last_consolidation');
+        const s = await deps.statFn(guardPath);
+        return lastRealMessageAt < s.mtimeMs;
+    }
+    catch {
+        // No guard file yet (brand-new brain, never consolidated) — never skip.
+        return false;
+    }
+}

package/dist/maintenance-cron.d.ts

@@ -7,6 +7,7 @@ export interface TrackedBrainInfo {
     botId: string;
     botToken: string;
     channelId: string;
+    lastRealMessageAt?: number;
 }
 /**
  * Read-only view of brains seen so far (via registerBrain). Used by the inbox
@@ -14,6 +15,12 @@ export interface TrackedBrainInfo {
  * workspace/bot credentials to use when starting a session for an idle thread.
  */
 export declare function getTrackedBrains(): ReadonlyMap<string, TrackedBrainInfo>;
+/**
+ * Test-only helper to clear tracked brains between tests (module-scoped
+ * state persists across tests in the same file otherwise).
+ * @internal
+ */
+export declare function __resetTrackedBrainsForTest(): void;
 /**
  * Register a brain from a real message so the maintenance cron knows about it.
  * Called from processMessage() after brain path is resolved.

package/dist/maintenance-cron.js

@@ -6,7 +6,8 @@ import { emitError } from './event-queue.js';
 import { registerBrainForMetrics } from './metrics/scheduler.js';
 import { collectMetrics } from './metrics/collector.js';
 import { sendMetrics } from './metrics/sender.js';
-import { markMaintenanceJobFired, markMaintenanceJobSuccess, } from './cron-telemetry.js';
+import { markMaintenanceJobFired, markMaintenanceJobSuccess, markMaintenanceJobSkipped, } from './cron-telemetry.js';
+import { shouldSkipMaintenance } from './maintenance-activity.js';
 import { join } from 'path';
 const trackedBrains = new Map();
 /**
@@ -17,6 +18,14 @@ const trackedBrains = new Map();
 export function getTrackedBrains() {
     return trackedBrains;
 }
+/**
+ * Test-only helper to clear tracked brains between tests (module-scoped
+ * state persists across tests in the same file otherwise).
+ * @internal
+ */
+export function __resetTrackedBrainsForTest() {
+    trackedBrains.clear();
+}
 let maintenanceJob = null;
 /**
  * Register a brain from a real message so the maintenance cron knows about it.
@@ -38,6 +47,7 @@ export function registerBrain(msg) {
         botId: msg.teamvibe.botId,
         botToken: msg.teamvibe.botToken,
         channelId: msg.teamvibe.channelId,
+        lastRealMessageAt: Date.now(),
     });
     logger.debug(`[Maintenance] Registered brain: ${brain.brainId}`);
     // Metrics pipeline (teamvibe.ai#110): register for hourly collection. On the
@@ -68,6 +78,11 @@ async function triggerAllBrains(processMessageFn) {
             logger.debug(`[Maintenance] At capacity, skipping ${brainId}`);
             continue;
         }
+        if (await shouldSkipMaintenance(config.BRAINS_PATH, brainId, info.lastRealMessageAt)) {
+            markMaintenanceJobSkipped();
+            logger.debug(`[Maintenance] Skipping ${brainId} — no real activity since last maintenance (#131)`);
+            continue;
+        }
         logger.info(`[Maintenance] Triggering maintenance for brain ${brainId}`);
         const syntheticMessage = {
             id: `maintenance_${brainId}_${now}`,

package/dist/metrics/collector.d.ts

@@ -21,6 +21,8 @@ export interface MetricsPayload {
     daysSinceMaintenance?: number;
     lastMaintenanceJobMs?: number;
     lastMaintenanceJobSuccessMs?: number;
+    maintenanceSkippedCountLastRun?: number;
+    lastMaintenanceJobSkippedMs?: number;
     lastAutoUpdateJobMs?: number;
     lastAutoUpdateJobSuccessMs?: number;
     timestamp?: string;

package/dist/metrics/collector.js

@@ -228,6 +228,13 @@ export async function collectMetrics(brainPath, brainId) {
     if (cron.lastMaintenanceJobSuccessAt !== null) {
         payload.lastMaintenanceJobSuccessMs = now - cron.lastMaintenanceJobSuccessAt;
     }
+    // #131 — activity-based skip counter. Always sent (0 is a real "no skips
+    // this run" value, not an omission) so a stuck-high count is visible
+    // fleet-wide without per-brain digging.
+    payload.maintenanceSkippedCountLastRun = cron.maintenanceSkippedCountLastRun;
+    if (cron.lastMaintenanceJobSkippedAt !== null) {
+        payload.lastMaintenanceJobSkippedMs = now - cron.lastMaintenanceJobSkippedAt;
+    }
     if (cron.lastAutoUpdateJobFiredAt !== null) {
         payload.lastAutoUpdateJobMs = now - cron.lastAutoUpdateJobFiredAt;
     }

package/dist/poller.d.ts

@@ -1,4 +1,6 @@
 import { logger } from './logger.js';
+import { type SpawnResult } from './claude-spawner.js';
+import { type KilledByPoller } from './classify-failed-iteration.js';
 import type { TeamVibeQueueMessage } from './types.js';
 interface ReleaseLogger {
     info: (msg: string) => void;
@@ -22,6 +24,13 @@ export declare function runAutoUpdateJob(checkForUpdateFn?: () => Promise<boolea
  * will pick up any new file on its own.
  */
 export declare function isInboxLoopActive(threadId: string): boolean;
+export declare function isIntentionalKillExitCode(exitCode: number | null): boolean;
+export declare function isPollerInitiatedFailure(result: {
+    exitCode: number | null;
+    killedByPoller?: KilledByPoller;
+}): boolean;
+export declare function endOfTurnFallbackText(hasSlackContext: boolean, result: Pick<SpawnResult, 'success' | 'sawSendMessageCall' | 'lastPlainTextContent'>): string | undefined;
 export declare function runInboxLoop(threadId: string, kbPath: string, queueMessage: TeamVibeQueueMessage, sessionLog: ReturnType<typeof logger.createSession>): Promise<void>;
+export declare function __setShuttingDownForTest(value: boolean): void;
 export declare function startPoller(): Promise<void>;
 export {};