@teamvibe/poller 0.8.2-rc.2 → 0.8.3-rc.4

package/dist/inbox-manager.js

@@ -1,4 +1,4 @@
-import { mkdirSync, writeFileSync, readFileSync, renameSync, unlinkSync, readdirSync, existsSync } from 'fs';
+import { mkdirSync, writeFileSync, readFileSync, renameSync, unlinkSync, readdirSync, existsSync, rmSync } from 'fs';
 import { join } from 'path';
 import { logger } from './logger.js';
 const INBOX_DIR = '.inbox';
@@ -96,7 +96,7 @@ export function markProcessed(brainPath, threadId, filename) {
 /**
  * Move a message from processing/ back to new/.
  *
- * Used specifically for a poller-initiated *shutdown* kill (teamvibe.ai#73,
+ * Used for quota-paused spawn preparation and 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
@@ -126,7 +126,7 @@ export function requeueMessage(brainPath, threadId, filename) {
     try {
         if (existsSync(srcPath)) {
             renameSync(srcPath, dstPath);
-            logger.info(`[Inbox] Requeued shutdown-killed message to new/: ${filename}`);
+            logger.info(`[Inbox] Requeued pending message to new/: ${filename}`);
         }
         else {
             logger.info(`[Inbox] Requeue skipped, ${filename} already gone from processing/`);
@@ -156,3 +156,57 @@ export function hasUnprocessed(brainPath, threadId) {
         return false;
     }
 }
+// Context and continuation state live beside inbox files, independently of the pause marker.
+function writeInboxState(brainPath, threadId, name, value) {
+    ensureInboxDirs(brainPath, threadId);
+    const path = join(getInboxPath(brainPath, threadId), name);
+    writeFileSync(`${path}.tmp`, JSON.stringify(value), { mode: 0o600 });
+    renameSync(`${path}.tmp`, path);
+}
+export function saveInboxContext(brainPath, msg) {
+    const { botToken: _token, ...teamvibe } = msg.teamvibe;
+    writeInboxState(brainPath, msg.thread_id, 'context.json', { ...msg, teamvibe });
+}
+export function readInboxContext(brainPath, threadId) {
+    const root = getInboxPath(brainPath, threadId);
+    const candidates = [];
+    for (const subdir of [PROCESSING_DIR, NEW_DIR]) {
+        try {
+            const first = readdirSync(join(root, subdir)).filter(name => name.endsWith('.txt')).sort()[0];
+            if (first)
+                candidates.push(join(root, subdir, first));
+        }
+        catch { }
+    }
+    candidates.push(join(root, 'context.json'));
+    for (const path of candidates) {
+        try {
+            const msg = JSON.parse(readFileSync(path, 'utf8'));
+            if (msg.thread_id !== threadId || !['slack', 'email', 'cron', 'maintenance', 'webhook'].includes(msg.source) || typeof msg.teamvibe?.workspaceId !== 'string' || typeof msg.teamvibe?.channelId !== 'string' || !msg.response_context || typeof msg.text !== 'string' || !msg.sender || !Array.isArray(msg.attachments))
+                continue;
+            return { ...msg, teamvibe: { ...msg.teamvibe, botToken: '' } };
+        }
+        catch { }
+    }
+    return undefined;
+}
+export function saveInboxRuntime(brainPath, threadId, state) {
+    writeInboxState(brainPath, threadId, 'pool-session.json', state);
+}
+export function readInboxRuntime(brainPath, threadId) {
+    try {
+        const state = JSON.parse(readFileSync(join(getInboxPath(brainPath, threadId), 'pool-session.json'), 'utf8'));
+        if (typeof state.sessionId !== 'string' || typeof state.filename !== 'string' || !state.pin?.workspaceId || !state.pin?.accountId || !state.pin?.credentialVersion)
+            return undefined;
+        return state;
+    }
+    catch {
+        return undefined;
+    }
+}
+export function clearInboxRuntime(brainPath, threadId) {
+    try {
+        rmSync(join(getInboxPath(brainPath, threadId), 'pool-session.json'), { force: true });
+    }
+    catch { }
+}

package/dist/inbox-watcher.d.ts

@@ -36,7 +36,7 @@ export declare function parseSlackThreadId(threadId: string): {
 export declare function listThreadDirs(inboxRoot: string): string[];
 export declare function hasNewMessage(inboxRoot: string, threadId: string): boolean;
 /**
- * Scan every tracked brain's .inbox/ for a thread that has a new message but
+ * Scan every tracked brain's .inbox/ for a thread that has queued or retained work but
  * no active runInboxLoop, and start one. This is the only config-only path
  * that can wake a fully idle session (teamvibe.ai#242) — a file dropped into
  * .inbox/ by e.g. a background task otherwise sits inert until the next SQS

package/dist/inbox-watcher.js

@@ -1,3 +1,5 @@
+import { readInboxContext, readInboxRuntime } from './inbox-manager.js';
+import { isPoolDeferred, readPoolDefer } from './pool-defer.js';
 import { existsSync, readdirSync, rmSync, watch as fsWatch } from 'fs';
 import { join } from 'path';
 import { config } from './config.js';
@@ -5,6 +7,7 @@ import { logger } from './logger.js';
 import { isAtCapacity } from './claude-spawner.js';
 import { getTrackedBrains } from './maintenance-cron.js';
 import { runInboxLoop, isInboxLoopActive } from './poller.js';
+import { isQuotaPaused } from './quota-pause.js';
 const INBOX_SUBDIRS = ['new', 'processing', 'failed'];
 let brainWatchers = new Map();
 let fallbackInterval = null;
@@ -81,8 +84,8 @@ export function listThreadDirs(inboxRoot) {
         return [];
     }
 }
-export function hasNewMessage(inboxRoot, threadId) {
-    const newDir = join(inboxRoot, threadId, 'new');
+function hasMessage(inboxRoot, threadId, subdir) {
+    const newDir = join(inboxRoot, threadId, subdir);
     try {
         return existsSync(newDir) && readdirSync(newDir).some((f) => f.endsWith('.txt'));
     }
@@ -90,38 +93,55 @@ export function hasNewMessage(inboxRoot, threadId) {
         return false;
     }
 }
+export function hasNewMessage(inboxRoot, threadId) {
+    return hasMessage(inboxRoot, threadId, 'new');
+}
 /**
- * Scan every tracked brain's .inbox/ for a thread that has a new message but
+ * Scan every tracked brain's .inbox/ for a thread that has queued or retained work but
  * no active runInboxLoop, and start one. This is the only config-only path
  * that can wake a fully idle session (teamvibe.ai#242) — a file dropped into
  * .inbox/ by e.g. a background task otherwise sits inert until the next SQS
  * message for that thread, which may never come.
  */
 export function checkInboxForNewSessions(deps = defaultDeps()) {
-    for (const [, info] of deps.getTrackedBrains()) {
-        if (deps.isAtCapacity()) {
-            logger.debug('[InboxWatcher] At capacity, pausing scan until next tick');
-            return;
+    const brains = new Map();
+    for (const [, info] of deps.getTrackedBrains())
+        brains.set(join(deps.brainsPath, info.brainId), info);
+    // Durable inbox context discovers retained work even with empty bootstrap maps,
+    // absent/corrupt pause markers, or a non-Slack thread ID.
+    try {
+        for (const entry of readdirSync(deps.brainsPath, { withFileTypes: true })) {
+            if (entry.isDirectory()) {
+                const path = join(deps.brainsPath, entry.name);
+                if (existsSync(join(path, '.inbox')) && !brains.has(path))
+                    brains.set(path, undefined);
+            }
         }
-        const brainPath = join(deps.brainsPath, info.brainId);
+    }
+    catch { }
+    for (const [brainPath, info] of brains) {
+        if (deps.isAtCapacity())
+            return;
         const inboxRoot = join(brainPath, '.inbox');
-        if (!existsSync(inboxRoot))
-            continue;
         for (const threadId of listThreadDirs(inboxRoot)) {
-            if (deps.isInboxLoopActive(threadId))
+            if (deps.isAtCapacity())
+                return;
+            if (deps.isInboxLoopActive(threadId) || isPoolDeferred(threadId))
                 continue;
-            if (!hasNewMessage(inboxRoot, threadId))
+            const completion = readInboxRuntime(brainPath, threadId)?.completed;
+            const retryCompletion = completion && (Date.now() < completion.observedAt || Date.now() >= completion.retryAt);
+            if (!hasNewMessage(inboxRoot, threadId) && !hasMessage(inboxRoot, threadId, 'processing') && !retryCompletion)
                 continue;
+            if (isQuotaPaused() && !readInboxRuntime(brainPath, threadId) && !readPoolDefer(threadId))
+                continue;
+            const durable = readInboxContext(brainPath, threadId);
             const parsed = parseSlackThreadId(threadId);
-            if (!parsed) {
-                logger.debug(`[InboxWatcher] Skipping ${threadId}: not a slack-shaped threadId`);
+            const message = durable ?? (info && parsed ? buildSyntheticMessage(info, threadId, parsed) : undefined);
+            if (!message)
                 continue;
-            }
-            logger.info(`[InboxWatcher] New message for idle thread ${threadId}, starting session`);
             const sessionLog = logger.createSession(`iw_${Math.random().toString(36).slice(2, 10)}`);
-            const syntheticMessage = buildSyntheticMessage(info, threadId, parsed);
-            deps.runInboxLoop(threadId, brainPath, syntheticMessage, sessionLog).catch((error) => {
-                logger.error(`[InboxWatcher] runInboxLoop failed for ${threadId}: ${error instanceof Error ? error.message : error}`);
+            deps.runInboxLoop(threadId, brainPath, message, sessionLog).catch(() => {
+                logger.error('[InboxWatcher] Retained inbox run failed; work remains saved');
             });
         }
     }
@@ -157,7 +177,9 @@ export function pruneEmptyInboxDirs(deps = defaultDeps()) {
         if (!existsSync(inboxRoot))
             continue;
         for (const threadId of listThreadDirs(inboxRoot)) {
-            if (deps.isInboxLoopActive(threadId))
+            if (deps.isInboxLoopActive(threadId) || isPoolDeferred(threadId))
+                continue;
+            if (readInboxRuntime(join(deps.brainsPath, info.brainId), threadId)?.completed)
                 continue;
             if (!isThreadDirEmpty(inboxRoot, threadId))
                 continue;

package/dist/poller.d.ts

@@ -33,6 +33,7 @@ export declare function describeFailureReason(killedByPoller: KilledByPoller | u
 export declare const END_OF_TURN_NO_FURTHER_RESPONSE_SENTINEL = "NO_FURTHER_RESPONSE_NEEDED";
 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 pollLoop(): Promise<void>;
 export declare function __setSleepForTest(impl: (ms: number) => Promise<void>): void;
 export declare function __setShuttingDownForTest(value: boolean): void;
 export declare function startPoller(): Promise<void>;