@teamvibe/poller 0.4.3 → 0.5.0

package/dist/brain-manager.d.ts

@@ -4,6 +4,11 @@ interface BrainConfig {
     branch: string;
 }
 export declare function getBrainPath(brain?: BrainConfig, channelId?: string, workspaceId?: string): Promise<string>;
+/**
+ * Update a brain repo (respects cooldown). Exported for testing — production
+ * call sites should go through `getBrainPath` / `ensureBaseBrain`.
+ */
+export declare function updateBrain(brainDir: string, brainId: string, branch: string): Promise<void>;
 /**
  * Ensure base brain repo is cloned and up to date.
  * Uses same cooldown pattern as channel brains.

package/dist/brain-manager.js

@@ -90,15 +90,53 @@ export async function getBrainPath(brain, channelId, workspaceId) {
     return brainDir;
 }
 /**
- * Update a brain repo (respects cooldown)
+ * Update a brain repo (respects cooldown). Exported for testing — production
+ * call sites should go through `getBrainPath` / `ensureBaseBrain`.
  */
-async function updateBrain(brainDir, brainId, branch) {
+export async function updateBrain(brainDir, brainId, branch) {
     const now = Date.now();
     const lastUpdate = lastUpdateTimes.get(brainId) || 0;
     if (now - lastUpdate < config.BRAIN_UPDATE_COOLDOWN_MS) {
         logger.debug(`Brain ${brainId} update skipped - cooldown active (${Math.round((config.BRAIN_UPDATE_COOLDOWN_MS - (now - lastUpdate)) / 1000)}s remaining)`);
         return;
     }
+    // Guard: skip `reset --hard` when the working tree has uncommitted writes or
+    // unpushed commits, otherwise an in-flight session's mid-message memory
+    // writes (e.g. memory/TODAY.md, MEM_REGISTRY.md) get silently wiped on the
+    // next message arrival after the cooldown elapses. Fail-safe direction —
+    // pushBrainChanges at session-end reconciles drift on the happy path; the
+    // structural fix is worktree isolation (see #205). Mirrors no-upstream
+    // handling in pushBrainChanges below.
+    try {
+        const { stdout: dirty } = await gitExec('git status --porcelain', { cwd: brainDir });
+        let hasLocalCommits = false;
+        try {
+            const { stdout: unpushed } = await gitExec('git log @{u}..HEAD --oneline', { cwd: brainDir });
+            hasLocalCommits = !!unpushed.trim();
+        }
+        catch {
+            // No upstream tracking (detached HEAD, mid-rebase, or `git init`-bootstrapped
+            // brain dir; a normal `git clone` always sets up tracking). Broken upstream
+            // tracking → skip aggressively; manual investigation preferred over a silent
+            // --hard reset.
+            const { stdout: commits } = await gitExec('git log --oneline -1', { cwd: brainDir });
+            hasLocalCommits = !!commits.trim();
+        }
+        if (dirty.trim() || hasLocalCommits) {
+            // TODO(#205-followup): emit operational alert if a brain skips reset for > N hours —
+            // long-term skip means pushBrainChanges is persistently failing and the brain is
+            // silently drifting away from base-brain / skills updates.
+            logger.info(`Brain ${brainId} update skipped — local changes present (dirty=${!!dirty.trim()}, hasLocalCommits=${hasLocalCommits})`);
+            return;
+        }
+    }
+    catch (error) {
+        // Pre-check itself failed (e.g. brainDir not a git repo). Fail-safe to skip;
+        // the next iteration will retry.
+        const errorMessage = error instanceof Error ? error.message : String(error);
+        logger.warn(`Brain ${brainId} pre-check failed, skipping update: ${errorMessage}`);
+        return;
+    }
     try {
         logger.info(`Updating brain ${brainId} at ${brainDir}...`);
         await gitExec(`git fetch origin ${branch} && git reset --hard origin/${branch} && git submodule update --init --recursive`, {

package/dist/classify-failed-iteration.d.ts

@@ -0,0 +1,16 @@
+export type KilledByPoller = 'timeout' | 'idle' | 'zombie' | 'network';
+export interface FailedIterationInput {
+    error?: string;
+    exitCode: number | null;
+    killedByPoller?: KilledByPoller;
+}
+export type FailedIterationDecision = {
+    kind: 'neutral';
+    text: string;
+    reaction: string;
+} | {
+    kind: 'error';
+    text: string;
+    reaction: string;
+};
+export declare function classifyFailedIteration(result: FailedIterationInput): FailedIterationDecision;

package/dist/classify-failed-iteration.js

@@ -0,0 +1,53 @@
+// Decides how to surface a failed claude-spawner iteration to the user.
+//
+// Background (teamvibe.ai#193): poller-induced kills (timeout, idle watchdog,
+// network watchdog, zombie cleanup) used to leak as generic
+// "Error processing your request: Process exited with code 143" via
+// sendSlackError. The explicit `killedByPoller` intent marker (set by the
+// spawner before SIGTERM) lets us emit a neutral 1-sentence notice instead —
+// "Session paused — send another message to resume." — which tells the user
+// *what happened* and *what to do*, without false-flagging an internal kill
+// as an application failure.
+//
+// Pattern: explicit intent marker > exit-code pattern matching (143/137).
+// Exit codes are fragile — the Claude binary can legitimately return 143
+// for unrelated reasons; the marker decides on poller intent, not process
+// output.
+export function classifyFailedIteration(result) {
+    switch (result.killedByPoller) {
+        case 'idle':
+            return {
+                kind: 'neutral',
+                text: 'Session paused (idle timeout) — send another message to resume.',
+                reaction: 'zzz',
+            };
+        case 'zombie':
+            return {
+                kind: 'neutral',
+                text: "Process didn't shut down cleanly — send another message to restart.",
+                reaction: 'recycle',
+            };
+        case 'network':
+            return {
+                kind: 'neutral',
+                text: 'Network connectivity lost — send another message to retry.',
+                reaction: 'satellite_antenna',
+            };
+        case 'timeout':
+        case undefined: {
+            // 'timeout' keeps the legacy ":warning: Session timed out after N
+            // minutes..." surface unchanged (the error string is set by the
+            // spawner). undefined = genuine failure → keep current behavior.
+            const text = result.error || `Process exited with code ${result.exitCode}`;
+            const isTimeout = result.killedByPoller === 'timeout' || text.includes('timed out');
+            return { kind: 'error', text, reaction: isTimeout ? 'hourglass' : 'x' };
+        }
+        default: {
+            // Exhaustiveness guard: adding a new member to KilledByPoller without
+            // handling it here will fail to compile (never assignment). Runtime
+            // throw is the fallback for tsconfigs without noImplicitReturns.
+            const _exhaustive = result.killedByPoller;
+            throw new Error(`Unhandled killedByPoller: ${String(_exhaustive)}`);
+        }
+    }
+}

package/dist/claude-spawner.d.ts

@@ -1,14 +1,28 @@
 import type { TeamVibeQueueMessage, SessionMetrics } from './types.js';
 import { type SessionLogger } from './logger.js';
 import type { TypingIndicator } from './slack-client.js';
+import type { KilledByPoller } from './classify-failed-iteration.js';
+export interface ContextHintParams {
+    isFirstMessage: boolean;
+    lastMessageTs?: string;
+    slack?: {
+        channel: string;
+        thread_ts: string;
+        message_ts: string;
+    };
+    countNewSinceTs: (channel: string, threadTs: string, sinceTs: string) => Promise<number>;
+    countPriorBeforeTs: (channel: string, threadTs: string, beforeTs: string) => Promise<number>;
+}
+export declare function buildContextHint(p: ContextHintParams): Promise<string | undefined>;
 export interface SpawnResult {
     success: boolean;
     output: string;
     exitCode: number | null;
     error?: string;
     metrics?: SessionMetrics;
+    killedByPoller?: KilledByPoller;
 }
-export declare function buildPrompt(msg: TeamVibeQueueMessage, resumeHint?: string): string;
+export declare function buildPrompt(msg: TeamVibeQueueMessage, contextHint?: string): string;
 export declare function spawnClaudeCode(msg: TeamVibeQueueMessage, sessionLog: SessionLogger, cwd: string, sessionId?: string, isFirstMessage?: boolean, lastMessageTs?: string, onMessageSent?: () => void, typingIndicator?: TypingIndicator): Promise<SpawnResult & {
     newSessionId?: string;
 }>;

package/dist/claude-spawner.js

@@ -8,6 +8,7 @@ import { getBaseBrainPath } from './brain-manager.js';
 import { getPollerId } from './auth-provider.js';
 import { emitError } from './event-queue.js';
 import { createWorktree, removeWorktree, isWorktreeIsolationEnabled } from './worktree-manager.js';
+import { fetchSecretsForSpawn, buildSecretsReminder } from './secrets-client.js';
 /**
  * Maps tool names (or prefixes) to human-readable status messages.
  * More specific patterns are checked first.
@@ -86,6 +87,68 @@ async function countNewThreadMessages(botToken, channel, threadTs, sinceTs) {
         return 0;
     }
 }
+// Count messages strictly before the message being handled. Used to hint that
+// prior thread context exists when the bot is invoked for the first time on a
+// thread that already has history. Bot-side messages are included — the bot's
+// own past replies are still context the model should be aware of (a fresh
+// session has lost what it said before).
+// TODO: detect has_more to surface a "100+" signal — conversations.replies
+// saturates at limit:100 without telling the caller, so very long threads
+// will be reported as exactly "100 previous messages".
+async function countPriorThreadMessages(botToken, channel, threadTs, currentMessageTs) {
+    try {
+        const slack = getSlackClient(botToken);
+        const result = await slack.conversations.replies({
+            channel,
+            ts: threadTs,
+            limit: 100,
+        });
+        if (!result.messages)
+            return 0;
+        const priorMessages = result.messages.filter((msg) => {
+            if (!msg.ts)
+                return false;
+            return parseFloat(msg.ts) < parseFloat(currentMessageTs);
+        });
+        return priorMessages.length;
+    }
+    catch (error) {
+        logger.warn(`Failed to count prior thread messages: ${error}`);
+        emitError('slack', `Failed to count prior thread messages: ${error instanceof Error ? error.message : String(error)}`, { severity: 'warn' });
+        return 0;
+    }
+}
+// Select and render the context hint that goes into the prompt. Pure aside
+// from the injected counters — extracted from runClaudeCode so the branching
+// (resume vs. thread-context vs. no-hint) can be unit tested without spinning
+// up a Slack WebClient.
+//
+// Branches:
+//  - resumed session (!isFirstMessage && lastMessageTs && slack thread)
+//    → "Resumed session: N new messages …" (or "No new messages" when N=0)
+//  - first-spawn on a thread reply (isFirstMessage && thread_ts !== message_ts)
+//    → "Thread context: N previous messages …" when N>0, else no hint
+//  - everything else (top-level message, resume-without-anchor)
+//    → no hint
+export async function buildContextHint(p) {
+    if (!p.isFirstMessage && p.lastMessageTs && p.slack?.channel && p.slack?.thread_ts) {
+        const newMessageCount = await p.countNewSinceTs(p.slack.channel, p.slack.thread_ts, p.lastMessageTs);
+        return newMessageCount > 0
+            ? `**Resumed session:** ${newMessageCount} new message(s) in the thread since your last response. Consider using \`read_thread\` to see what was discussed before responding.`
+            : `**Resumed session:** No new messages since your last response.`;
+    }
+    if (p.isFirstMessage &&
+        p.slack?.channel &&
+        p.slack?.thread_ts &&
+        p.slack?.message_ts &&
+        p.slack.thread_ts !== p.slack.message_ts) {
+        const priorCount = await p.countPriorBeforeTs(p.slack.channel, p.slack.thread_ts, p.slack.message_ts);
+        if (priorCount > 0) {
+            return `**Thread context:** ${priorCount} previous message(s) in this thread before yours.\nCall \`read_thread\` first to load conversation context.`;
+        }
+    }
+    return undefined;
+}
 /**
  * Read brain settings.json from the brain working directory.
  * Returns parsed settings or empty object if not found.
@@ -104,11 +167,11 @@ function readBrainSettings(cwd) {
         return {};
     }
 }
-export function buildPrompt(msg, resumeHint) {
-    // Heartbeat messages get a minimal prompt — CLAUDE.md/MAINTENANCE.md handle the rest
-    if (msg.source === 'heartbeat') {
-        return 'heartbeat';
-    }
+// Tags procs at SIGTERM time so the close handler can report poller intent.
+// WeakMap auto-cleans when proc is GC'd. Module-scope is required because
+// killZombieForThread fires outside the runClaudeCode closure.
+const killReasonByProc = new WeakMap();
+export function buildPrompt(msg, contextHint) {
     const isEmail = msg.source === 'email';
     const isWebhook = msg.source === 'webhook';
     let prompt = isEmail ? '## Incoming Email\n\n' : isWebhook ? '## Incoming Webhook\n\n' : '## Incoming Slack Message\n\n';
@@ -164,8 +227,8 @@ export function buildPrompt(msg, resumeHint) {
     if (msg.teamvibe.emailHookPrompt) {
         prompt += '\n\n**Channel Instructions:**\n' + msg.teamvibe.emailHookPrompt + '\n';
     }
-    if (resumeHint) {
-        prompt += `\n\n${resumeHint}`;
+    if (contextHint) {
+        prompt += `\n\n${contextHint}`;
     }
     if (isEmail) {
         prompt += `\n\n---\n\nProcess this email and respond appropriately using available tools.`;
@@ -234,31 +297,44 @@ function formatStreamEvent(event) {
 async function runClaudeCode(msg, sessionLog, cwd, sessionId, isFirstMessage = true, lastMessageTs, onMessageSent, typingIndicator) {
     const slackContext = msg.response_context.slack;
     const isCronMessage = msg.source === 'cron';
-    const isHeartbeat = msg.source === 'heartbeat';
     const isMaintenance = msg.source === 'maintenance';
     const isEmailMessage = msg.source === 'email';
     const isWebhookMessage = msg.source === 'webhook';
     if (!slackContext &&
         !isCronMessage &&
-        !isHeartbeat &&
         !isMaintenance &&
         !isEmailMessage &&
         !isWebhookMessage) {
         throw new Error('No Slack context in message');
     }
-    // Build resume hint
-    let resumeHint;
-    if (!isFirstMessage && lastMessageTs && slackContext?.channel && slackContext?.thread_ts) {
-        const newMessageCount = await countNewThreadMessages(msg.teamvibe.botToken, slackContext.channel, slackContext.thread_ts, lastMessageTs);
-        if (newMessageCount > 0) {
-            resumeHint = `**Resumed session:** ${newMessageCount} new message(s) in the thread since your last response. Consider using \`read_thread\` to see what was discussed before responding.`;
-        }
-        else {
-            resumeHint = `**Resumed session:** No new messages since your last response.`;
-        }
-    }
+    // Build context hint — either resume hint (when continuing a session) or
+    // thread context hint (when first-spawning on a thread that already has
+    // prior messages). The two are mutually exclusive: a resume implies the bot
+    // already saw the thread once, so resume's "X new since last response" is
+    // the more informative signal. Logic extracted into buildContextHint for
+    // unit testability — the counters are injected so tests don't need to mock
+    // the Slack WebClient module.
+    const contextHint = await buildContextHint({
+        isFirstMessage,
+        lastMessageTs,
+        slack: slackContext,
+        countNewSinceTs: (ch, tts, since) => countNewThreadMessages(msg.teamvibe.botToken, ch, tts, since),
+        countPriorBeforeTs: (ch, tts, before) => countPriorThreadMessages(msg.teamvibe.botToken, ch, tts, before),
+    });
+    // Fetch secrets for this spawn before entering the Promise constructor —
+    // the executor callback is not async, so awaits must be hoisted out.
+    // Returns an opaque envelope; we unwrap exactly once at the spawn env
+    // construction site below. Reminder metadata (names + scope + expiration
+    // only — never values) feeds the system prompt so the session knows which
+    // ENV variables exist.
+    const spawnSecrets = await fetchSecretsForSpawn({
+        pollerId: getPollerId() || '',
+        workspaceId: msg.teamvibe.workspaceId,
+        channelId: msg.teamvibe.channelId,
+    });
+    const secretsReminder = buildSecretsReminder(spawnSecrets.reminders);
     return new Promise((resolve) => {
-        const prompt = buildPrompt(msg, resumeHint);
+        const prompt = buildPrompt(msg, contextHint);
         // MCP server config passed via --mcp-config flag (no temp files needed)
         const mcpServerPath = join(getBaseBrainPath(), 'mcp', 'slack.mjs');
         const teamvibeApiServerPath = join(getBaseBrainPath(), 'mcp', 'teamvibe-api.mjs');
@@ -302,6 +378,7 @@ async function runClaudeCode(msg, sessionLog, cwd, sessionId, isFirstMessage = t
             `If empty: continue your work.`,
             `You MUST check the inbox: (1) before starting work, (2) after EVERY tool call, (3) after finishing all work.`,
             `Never skip an inbox check. This is how the user communicates with you during long tasks.`,
+            ...(secretsReminder ? ['', secretsReminder] : []),
         ].join('\n'));
         // Handle session continuity
         if (sessionId) {
@@ -323,6 +400,13 @@ async function runClaudeCode(msg, sessionLog, cwd, sessionId, isFirstMessage = t
         const proc = spawn(config.CLAUDE_CLI_PATH, args, {
             cwd,
             env: {
+                // Secrets platform (#105) injection — SOLE call site of
+                // `SpawnSecretsEnvelope.unwrap()` in the entire poller codebase.
+                // Placed FIRST so subsequent spreads can overwrite. Belt-and-
+                // suspenders: even if the API's reserved-prefix validator fails
+                // (`AWS_`, `TEAMVIBE_`, `SLACK_`, `CLAUDE_CODE_`, `ANTHROPIC_`)
+                // a name collision is silently won by the platform variable.
+                ...spawnSecrets.env.unwrap(),
                 ...process.env,
                 CLAUDECODE: undefined,
                 PATH: envPath,
@@ -439,15 +523,14 @@ async function runClaudeCode(msg, sessionLog, cwd, sessionId, isFirstMessage = t
                 networkErrorStart = null;
             }
         });
-        let timedOut = false;
         const timeoutMinutes = Math.round(config.CLAUDE_TIMEOUT_MS / 60000);
         const timeout = setTimeout(() => {
-            timedOut = true;
             logger.error(`Claude Code process timed out after ${timeoutMinutes} minutes`);
             emitError('session', `Claude Code process timed out after ${timeoutMinutes} minutes`, {
                 context: { channelId: msg.teamvibe.channelId, threadId: msg.thread_id },
                 channelId: msg.teamvibe.channelId,
             });
+            killReasonByProc.set(proc, 'timeout');
             proc.kill('SIGTERM');
             setTimeout(() => proc.kill('SIGKILL'), 5000);
         }, config.CLAUDE_TIMEOUT_MS);
@@ -465,6 +548,7 @@ async function runClaudeCode(msg, sessionLog, cwd, sessionId, isFirstMessage = t
                         context: { channelId: msg.teamvibe.channelId, threadId: msg.thread_id },
                         channelId: msg.teamvibe.channelId,
                     });
+                    killReasonByProc.set(proc, 'network');
                     proc.kill('SIGTERM');
                     setTimeout(() => proc.kill('SIGKILL'), 5000);
                     return;
@@ -477,6 +561,7 @@ async function runClaudeCode(msg, sessionLog, cwd, sessionId, isFirstMessage = t
                     context: { channelId: msg.teamvibe.channelId, threadId: msg.thread_id },
                     channelId: msg.teamvibe.channelId,
                 });
+                killReasonByProc.set(proc, 'idle');
                 proc.kill('SIGTERM');
                 setTimeout(() => proc.kill('SIGKILL'), 5000);
             }
@@ -496,15 +581,26 @@ async function runClaudeCode(msg, sessionLog, cwd, sessionId, isFirstMessage = t
             clearInterval(idleWatchdog);
             activeProcesses.delete(msg.id);
             activeProcessesByThread.delete(msg.thread_id);
+            const killReason = killReasonByProc.get(proc);
             const result = {
                 success: code === 0,
                 output: stdout,
                 exitCode: code,
                 metrics,
+                ...(killReason ? { killedByPoller: killReason } : {}),
             };
-            if (timedOut) {
+            if (killReason === 'timeout') {
                 result.error = `Session timed out after ${timeoutMinutes} minutes. The task was still running when the time limit was reached. Consider breaking complex tasks into smaller steps.`;
             }
+            else if (killReason === 'idle') {
+                result.error = `Killed by idle watchdog (no output for >${Math.round(config.IDLE_WATCHDOG_KILL_MS / 60000)} minutes)`;
+            }
+            else if (killReason === 'network') {
+                result.error = 'Killed by network watchdog (sustained network errors)';
+            }
+            else if (killReason === 'zombie') {
+                result.error = 'Killed as zombie process (stale session lock)';
+            }
             else if (code !== 0) {
                 result.error = stderr || `Process exited with code ${code}`;
             }
@@ -532,7 +628,7 @@ async function runClaudeCode(msg, sessionLog, cwd, sessionId, isFirstMessage = t
  * Sources whose sessions should run in an isolated git worktree (teamvibe.ai#120).
  * Foreground Slack messages always run in the main working dir.
  */
-const ISOLATED_SOURCES = new Set(['cron', 'heartbeat', 'maintenance']);
+const ISOLATED_SOURCES = new Set(['cron', 'maintenance']);
 function shouldIsolateInWorktree(msg) {
     return isWorktreeIsolationEnabled() && ISOLATED_SOURCES.has(msg.source);
 }
@@ -603,6 +699,7 @@ export function killZombieForThread(threadId) {
     }
     logger.warn(`Killing zombie process for thread ${threadId} (pid: ${proc.pid})`);
     emitError('session', `Killing zombie process for thread ${threadId}`, { severity: 'warn' });
+    killReasonByProc.set(proc, 'zombie');
     proc.kill('SIGTERM');
     setTimeout(() => {
         if (proc.exitCode === null) {

package/dist/config.d.ts

@@ -28,8 +28,7 @@ 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>;
-    POLLER_TZ: z.ZodDefault<z.ZodString>;
-    HEARTBEAT_CRON: z.ZodDefault<z.ZodString>;
+    POLLER_TZ: z.ZodOptional<z.ZodString>;
     MAINTENANCE_CRON: z.ZodDefault<z.ZodString>;
     MAINTENANCE_ENABLED: z.ZodEffects<z.ZodDefault<z.ZodString>, boolean, string | undefined>;
     AUTO_UPDATE_POLICY: z.ZodDefault<z.ZodEnum<["patch", "minor", "off"]>>;
@@ -59,8 +58,6 @@ declare const configSchema: z.ZodObject<{
     BASE_BRAIN_PATH: string;
     BRAIN_AUTO_UPDATE: boolean;
     BRAIN_UPDATE_COOLDOWN_MS: number;
-    POLLER_TZ: string;
-    HEARTBEAT_CRON: string;
     MAINTENANCE_CRON: string;
     MAINTENANCE_ENABLED: boolean;
     AUTO_UPDATE_POLICY: "patch" | "minor" | "off";
@@ -68,6 +65,7 @@ declare const configSchema: z.ZodObject<{
     SQS_QUEUE_URL?: string | undefined;
     SESSIONS_TABLE?: string | undefined;
     TEAMVIBE_POLLER_TOKEN?: string | undefined;
+    POLLER_TZ?: string | undefined;
 }, {
     AWS_REGION?: string | undefined;
     SQS_QUEUE_URL?: string | undefined;
@@ -97,7 +95,6 @@ declare const configSchema: z.ZodObject<{
     BRAIN_AUTO_UPDATE?: string | undefined;
     BRAIN_UPDATE_COOLDOWN_MS?: number | undefined;
     POLLER_TZ?: string | undefined;
-    HEARTBEAT_CRON?: string | undefined;
     MAINTENANCE_CRON?: string | undefined;
     MAINTENANCE_ENABLED?: string | undefined;
     AUTO_UPDATE_POLICY?: "patch" | "minor" | "off" | undefined;
@@ -130,8 +127,6 @@ export declare const config: {
     BASE_BRAIN_PATH: string;
     BRAIN_AUTO_UPDATE: boolean;
     BRAIN_UPDATE_COOLDOWN_MS: number;
-    POLLER_TZ: string;
-    HEARTBEAT_CRON: string;
     MAINTENANCE_CRON: string;
     MAINTENANCE_ENABLED: boolean;
     AUTO_UPDATE_POLICY: "patch" | "minor" | "off";
@@ -139,5 +134,6 @@ export declare const config: {
     SQS_QUEUE_URL?: string | undefined;
     SESSIONS_TABLE?: string | undefined;
     TEAMVIBE_POLLER_TOKEN?: string | undefined;
+    POLLER_TZ?: string | undefined;
 };
 export {};

package/dist/config.js

@@ -43,14 +43,14 @@ const configSchema = z.object({
         .default('true')
         .transform((v) => v.toLowerCase() === 'true'),
     BRAIN_UPDATE_COOLDOWN_MS: z.coerce.number().default(300000), // 5 minutes
-    // Brain heartbeat & maintenance (cron-based)
-    // POLLER_TZ: IANA timezone used to interpret HEARTBEAT_CRON & MAINTENANCE_CRON.
-    // Default Europe/Prague — current fleet is CZ-based; ensures `30 3 * * *`
-    // means "03:30 local night," not "03:30 UTC = 05:30 CEST." DST is handled
-    // by croner automatically. Override with `POLLER_TZ=UTC` (or any IANA name).
-    POLLER_TZ: z.string().default('Europe/Prague'),
-    HEARTBEAT_CRON: z.string().default('0 */6 * * *'), // Every 6 hours
-    MAINTENANCE_CRON: z.string().default('30 3 * * *'), // Daily at 03:30 in POLLER_TZ
+    // 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
+    // a CZ Mac mini, `UTC` on a default Railway container). Set explicitly
+    // (e.g. `POLLER_TZ=Europe/Prague` on Railway) when the host TZ doesn't match
+    // the intended cron interpretation. DST is handled by croner automatically.
+    POLLER_TZ: z.string().optional(),
+    MAINTENANCE_CRON: z.string().default('30 3 * * *'), // Daily at 03:30 in POLLER_TZ (or host TZ)
     MAINTENANCE_ENABLED: z.string().default('true').transform((v) => v.toLowerCase() === 'true'),
     // Auto-update settings
     AUTO_UPDATE_POLICY: z.enum(['patch', 'minor', 'off']).default('patch'),

package/dist/cron-telemetry.d.ts

@@ -1,24 +1,20 @@
 /**
  * Module-scoped state for poller-level cron-job telemetry.
  *
- * Per teamvibeai/teamvibe.ai#119, the metrics collector reports six measures:
- *   last{Heartbeat,Maintenance,AutoUpdate}Job{,Success}Ms
+ * Per teamvibeai/teamvibe.ai#119, the metrics collector reports four measures:
+ *   last{Maintenance,AutoUpdate}Job{,Success}Ms
  * each computed as `Date.now() - storedTs` at collection time, with the
  * measure omitted entirely when the cron has never fired (storedTs null).
  *
- * Pulled out of heartbeat-manager.ts / poller.ts into a dedicated module to
- * avoid a circular import — the metrics collector reads from these getters,
- * and heartbeat-manager.ts already imports from the collector.
+ * Lives in its own module to avoid a circular import — the metrics collector
+ * reads from these getters, and maintenance-cron.ts already imports from the
+ * collector.
  */
-export declare function markHeartbeatJobFired(at?: number): void;
-export declare function markHeartbeatJobSuccess(at?: number): void;
 export declare function markMaintenanceJobFired(at?: number): void;
 export declare function markMaintenanceJobSuccess(at?: number): void;
 export declare function markAutoUpdateJobFired(at?: number): void;
 export declare function markAutoUpdateJobSuccess(at?: number): void;
 export interface CronJobTimestamps {
-    lastHeartbeatJobFiredAt: number | null;
-    lastHeartbeatJobSuccessAt: number | null;
     lastMaintenanceJobFiredAt: number | null;
     lastMaintenanceJobSuccessAt: number | null;
     lastAutoUpdateJobFiredAt: number | null;

package/dist/cron-telemetry.js

@@ -1,27 +1,19 @@
 /**
  * Module-scoped state for poller-level cron-job telemetry.
  *
- * Per teamvibeai/teamvibe.ai#119, the metrics collector reports six measures:
- *   last{Heartbeat,Maintenance,AutoUpdate}Job{,Success}Ms
+ * Per teamvibeai/teamvibe.ai#119, the metrics collector reports four measures:
+ *   last{Maintenance,AutoUpdate}Job{,Success}Ms
  * each computed as `Date.now() - storedTs` at collection time, with the
  * measure omitted entirely when the cron has never fired (storedTs null).
  *
- * Pulled out of heartbeat-manager.ts / poller.ts into a dedicated module to
- * avoid a circular import — the metrics collector reads from these getters,
- * and heartbeat-manager.ts already imports from the collector.
+ * Lives in its own module to avoid a circular import — the metrics collector
+ * reads from these getters, and maintenance-cron.ts already imports from the
+ * collector.
  */
-let lastHeartbeatJobFiredAt = null;
-let lastHeartbeatJobSuccessAt = null;
 let lastMaintenanceJobFiredAt = null;
 let lastMaintenanceJobSuccessAt = null;
 let lastAutoUpdateJobFiredAt = null;
 let lastAutoUpdateJobSuccessAt = null;
-export function markHeartbeatJobFired(at = Date.now()) {
-    lastHeartbeatJobFiredAt = at;
-}
-export function markHeartbeatJobSuccess(at = Date.now()) {
-    lastHeartbeatJobSuccessAt = at;
-}
 export function markMaintenanceJobFired(at = Date.now()) {
     lastMaintenanceJobFiredAt = at;
 }
@@ -36,8 +28,6 @@ export function markAutoUpdateJobSuccess(at = Date.now()) {
 }
 export function getCronJobTimestamps() {
     return {
-        lastHeartbeatJobFiredAt,
-        lastHeartbeatJobSuccessAt,
         lastMaintenanceJobFiredAt,
         lastMaintenanceJobSuccessAt,
         lastAutoUpdateJobFiredAt,
@@ -49,8 +39,6 @@ export function getCronJobTimestamps() {
  * @internal
  */
 export function __resetCronTelemetryForTest() {
-    lastHeartbeatJobFiredAt = null;
-    lastHeartbeatJobSuccessAt = null;
     lastMaintenanceJobFiredAt = null;
     lastMaintenanceJobSuccessAt = null;
     lastAutoUpdateJobFiredAt = null;

package/dist/{heartbeat-manager.d.ts → maintenance-cron.d.ts}

@@ -1,39 +1,28 @@
 import type { TeamVibeQueueMessage } from './types.js';
 /**
- * Register a brain from a real message so we know about it for heartbeats.
+ * Register a brain from a real message so the maintenance cron knows about it.
  * Called from processMessage() after brain path is resolved.
  */
 export declare function registerBrain(msg: TeamVibeQueueMessage): void;
 /**
- * Start the cron-based heartbeat and maintenance schedules.
- *
- * - Heartbeat: lightweight, frequent (default: every 5 min)
- * - Maintenance: heavy, daily (default: 03:30 UTC)
+ * Start the cron-based maintenance schedule (default: daily 03:30 in POLLER_TZ).
  */
-export declare function startHeartbeatLoop(processMessageFn: (msg: {
+export declare function startMaintenanceLoop(processMessageFn: (msg: {
     queueMessage: TeamVibeQueueMessage;
     receiptHandle: string;
     messageId: string;
 }) => Promise<void>): void;
 /**
- * Run the heartbeat cron handler with telemetry instrumentation (#119).
+ * Run the maintenance cron handler with telemetry instrumentation (#119).
  * Records last-fire timestamp on entry and last-success timestamp on completion.
  * Exported for use by the cron registration above and tests that fire it manually.
  */
-export declare function runHeartbeatJob(processMessageFn: (msg: {
-    queueMessage: TeamVibeQueueMessage;
-    receiptHandle: string;
-    messageId: string;
-}) => Promise<void>): Promise<void>;
-/**
- * Run the maintenance cron handler with telemetry instrumentation (#119).
- */
 export declare function runMaintenanceJob(processMessageFn: (msg: {
     queueMessage: TeamVibeQueueMessage;
     receiptHandle: string;
     messageId: string;
 }) => Promise<void>): Promise<void>;
 /**
- * Stop the heartbeat and maintenance crons (for shutdown).
+ * Stop the maintenance cron (for shutdown).
  */
-export declare function stopHeartbeatLoop(): void;
+export declare function stopMaintenanceLoop(): void;