@teamvibe/poller 0.8.3 → 0.8.4-rc.2

package/dist/inbox-manager.js

@@ -1,5 +1,6 @@
-import { mkdirSync, writeFileSync, readFileSync, renameSync, unlinkSync, readdirSync, existsSync, rmSync } from 'fs';
+import { constants, copyFileSync, mkdirSync, writeFileSync, readFileSync, renameSync, unlinkSync, readdirSync, existsSync, rmSync } from 'fs';
 import { join } from 'path';
+import { inboxDropId, readThreadRouting, recordProcessedDrop } from './thread-routing.js';
 import { logger } from './logger.js';
 const INBOX_DIR = '.inbox';
 const NEW_DIR = 'new';
@@ -33,6 +34,7 @@ export function writeMessage(brainPath, threadId, content) {
  */
 export function pickNextMessage(brainPath, threadId) {
     ensureInboxDirs(brainPath, threadId);
+    discardHandledInboxDrops(brainPath, threadId);
     const inbox = getInboxPath(brainPath, threadId);
     const processingDir = join(inbox, PROCESSING_DIR);
     const newDir = join(inbox, NEW_DIR);
@@ -68,6 +70,7 @@ export function markFailed(brainPath, threadId, filename) {
     const dstPath = join(failedDir, filename);
     try {
         if (existsSync(srcPath)) {
+            recordProcessedDrop(threadId, filename, readFileSync(srcPath));
             renameSync(srcPath, dstPath);
             logger.info(`[Inbox] Moved exhausted message to failed/: ${filename}`);
         }
@@ -85,6 +88,7 @@ export function markProcessed(brainPath, threadId, filename) {
     const filepath = join(getInboxPath(brainPath, threadId), PROCESSING_DIR, filename);
     try {
         if (existsSync(filepath)) {
+            recordProcessedDrop(threadId, filename, readFileSync(filepath));
             unlinkSync(filepath);
             logger.info(`[Inbox] Deleted processed message: ${filename}`);
         }
@@ -167,19 +171,33 @@ 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) {
+function inboxContextCandidates(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));
+            for (const name of readdirSync(join(root, subdir)).filter(name => name.endsWith('.txt')).sort())
+                candidates.push(join(root, subdir, name));
         }
         catch { }
     }
     candidates.push(join(root, 'context.json'));
-    for (const path of candidates) {
+    return candidates;
+}
+/** Even partial envelopes carrying channel context must never use a singleton guess. */
+export function readInboxChannelContext(brainPath, threadId) {
+    for (const path of inboxContextCandidates(brainPath, threadId)) {
+        try {
+            const msg = JSON.parse(readFileSync(path, 'utf8'));
+            if (msg.teamvibe && 'channelId' in msg.teamvibe)
+                return { workspaceId: msg.teamvibe.workspaceId, channelId: msg.teamvibe.channelId };
+        }
+        catch { /* Not a readable routing envelope; inspect remaining context. */ }
+    }
+    return undefined;
+}
+export function readInboxContext(brainPath, threadId) {
+    for (const path of inboxContextCandidates(brainPath, threadId)) {
         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))
@@ -210,3 +228,80 @@ export function clearInboxRuntime(brainPath, threadId) {
     }
     catch { }
 }
+/** Remove transfer remnants and completed copies before discovery or replay. */
+export function discardHandledInboxDrops(brainPath, threadId) {
+    const processed = new Set(readThreadRouting(threadId)?.processedDropIds ?? []);
+    for (const subdir of [NEW_DIR, PROCESSING_DIR]) {
+        const directory = join(getInboxPath(brainPath, threadId), subdir);
+        if (!existsSync(directory))
+            continue;
+        for (const filename of readdirSync(directory).filter(name => name.endsWith('.txt'))) {
+            const path = join(directory, filename);
+            const id = inboxDropId(threadId, filename, readFileSync(path));
+            const marker = `${path}.moved`;
+            if (processed.has(id) || existsSync(marker) && readFileSync(marker, 'utf8') === id)
+                unlinkSync(path);
+        }
+    }
+}
+/** Move pending content only; a different brain must never inherit continuation state. */
+export function restartInboxInDirectory(source, target, threadId) {
+    ensureInboxDirs(target, threadId);
+    discardHandledInboxDrops(source, threadId);
+    for (const subdir of [PROCESSING_DIR, NEW_DIR]) {
+        const from = join(getInboxPath(source, threadId), subdir);
+        if (!existsSync(from))
+            continue;
+        for (const filename of readdirSync(from).filter(name => name.endsWith('.txt'))) {
+            const original = join(from, filename);
+            const content = readFileSync(original);
+            const id = inboxDropId(threadId, filename, content);
+            const destination = join(getInboxPath(target, threadId), subdir, filename);
+            const existing = [PROCESSING_DIR, NEW_DIR].map(stage => join(getInboxPath(target, threadId), stage, filename)).find(path => existsSync(path));
+            if (existing) {
+                if (inboxDropId(threadId, filename, readFileSync(existing)) !== id)
+                    throw new Error('Inbox transfer destination has different content');
+            }
+            else {
+                try {
+                    renameSync(original, destination);
+                    continue;
+                }
+                catch (error) {
+                    if (error.code !== 'EXDEV')
+                        throw error;
+                }
+                copyFileSync(original, destination, constants.COPYFILE_EXCL);
+            }
+            // Cross-filesystem interruption: discovery can suppress the source even
+            // after the destination has been consumed. Identical existing copies
+            // also cover a crash between the copy and this marker write.
+            writeFileSync(`${original}.moved`, id, { mode: 0o600 });
+            unlinkSync(original);
+        }
+    }
+}
+/** Preserve unroutable work for operator review and remove it from replay queues. */
+export function quarantineInbox(brainPath, threadId, includeFailed = false) {
+    const root = getInboxPath(brainPath, threadId);
+    const quarantine = join(root, 'unroutable');
+    for (const subdir of includeFailed ? [NEW_DIR, PROCESSING_DIR, FAILED_DIR] : [NEW_DIR, PROCESSING_DIR]) {
+        const source = join(root, subdir);
+        if (!existsSync(source))
+            continue;
+        for (const filename of readdirSync(source).filter(name => name.endsWith('.txt'))) {
+            const target = join(quarantine, subdir);
+            mkdirSync(target, { recursive: true });
+            // A later drop may reuse a name; never replace earlier quarantined work.
+            const destination = join(target, filename);
+            copyFileSync(join(source, filename), destination, constants.COPYFILE_EXCL);
+            unlinkSync(join(source, filename));
+        }
+    }
+    for (const name of ['context.json', 'pool-session.json']) {
+        if (!existsSync(join(root, name)))
+            continue;
+        mkdirSync(quarantine, { recursive: true });
+        renameSync(join(root, name), join(quarantine, `${Date.now()}-${name}`));
+    }
+}

package/dist/inbox-watcher.d.ts

@@ -1,5 +1,7 @@
+import { type BrainDirectory } from './brain-directory.js';
 import { SessionLogger } from './logger.js';
 import { type TrackedBrainInfo } from './maintenance-cron.js';
+import { sendSlackMessage } from './slack-client.js';
 import type { TeamVibeQueueMessage } from './types.js';
 /**
  * Everything checkInboxForNewSessions/pruneEmptyInboxDirs read from other
@@ -11,10 +13,13 @@ import type { TeamVibeQueueMessage } from './types.js';
  */
 export interface InboxWatcherDeps {
     brainsPath: string;
+    defaultBrainPath?: string;
     getTrackedBrains: () => ReadonlyMap<string, TrackedBrainInfo>;
     isAtCapacity: () => boolean;
     isInboxLoopActive: (threadId: string) => boolean;
-    runInboxLoop: (threadId: string, kbPath: string, queueMessage: TeamVibeQueueMessage, sessionLog: SessionLogger) => Promise<void>;
+    runInboxLoop: (threadId: string, directory: BrainDirectory | string, queueMessage: TeamVibeQueueMessage, sessionLog: SessionLogger) => Promise<void>;
+    sendSlackMessage?: typeof sendSlackMessage;
+    getSessionStatus?: (threadId: string) => Promise<string | undefined>;
     rmThreadDir: (path: string) => void;
 }
 /**
@@ -36,16 +41,16 @@ 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 queued or retained work but
+ * Scan current and former brain .inbox/ directories 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 declare function checkInboxForNewSessions(deps?: InboxWatcherDeps): void;
+export declare function checkInboxForNewSessions(deps?: InboxWatcherDeps): Promise<void>;
 export declare function isThreadDirEmpty(inboxRoot: string, threadId: string): boolean;
 /**
- * Remove thread dirs whose new/processing/failed subdirs are all empty (or
+ * Remove thread dirs whose new/processing/failed/unroutable subdirs are all empty (or
  * absent) and which have no active loop right now. Safe because
  * writeMessage() always recreates the directory tree via a recursive
  * mkdirSync before writing (inbox-manager.ts) — deleting an empty thread dir

package/dist/inbox-watcher.js

@@ -1,24 +1,34 @@
-import { readInboxContext, readInboxRuntime } from './inbox-manager.js';
+import { executionDirectory } from './brain-directory.js';
+import { discardHandledInboxDrops, markProcessed, quarantineInbox, readInboxChannelContext, readInboxContext, readInboxRuntime, restartInboxInDirectory } from './inbox-manager.js';
+import { listThreadRoutings, readThreadRouting, removeThreadRouting, threadRoutingKey } from './thread-routing.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';
+import { getBrainPath } from './brain-manager.js';
+import { resolveBrainDir, legacyBrainPath } from './brain-path.js';
 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();
+import { emitError } from './event-queue.js';
+import { sendSlackMessage } from './slack-client.js';
+const INBOX_SUBDIRS = ['new', 'processing', 'failed', 'unroutable'];
+const brainWatchers = new Map();
+const recoveringThreads = new Set();
 let fallbackInterval = null;
 let debounceTimer = null;
 function defaultDeps() {
     return {
         brainsPath: config.BRAINS_PATH,
+        defaultBrainPath: config.DEFAULT_BRAIN_PATH,
         getTrackedBrains,
         isAtCapacity,
         isInboxLoopActive,
         runInboxLoop,
+        sendSlackMessage,
+        getSessionStatus: async (threadId) => (await (await import('./session-store.js')).getSession(threadId))?.status,
         rmThreadDir: (path) => rmSync(path, { recursive: true }),
     };
 }
@@ -45,6 +55,15 @@ export function parseSlackThreadId(threadId) {
         return null;
     return { channel, threadTs };
 }
+function platformRouting(info) {
+    return {
+        workspaceId: info.workspaceId,
+        botId: info.botId,
+        botToken: info.botToken,
+        channelId: info.channelId,
+        brain: { brainId: info.brainId, gitRepoUrl: info.gitRepoUrl, branch: info.branch },
+    };
+}
 function buildSyntheticMessage(info, threadId, parsed) {
     return {
         id: `inbox_watch_${threadId}`,
@@ -61,17 +80,7 @@ function buildSyntheticMessage(info, threadId, parsed) {
             },
         },
         type: 'message',
-        teamvibe: {
-            workspaceId: info.workspaceId,
-            botId: info.botId,
-            botToken: info.botToken,
-            channelId: info.channelId,
-            brain: {
-                brainId: info.brainId,
-                gitRepoUrl: info.gitRepoUrl,
-                branch: info.branch,
-            },
-        },
+        teamvibe: platformRouting(info),
     };
 }
 export function listThreadDirs(inboxRoot) {
@@ -97,38 +106,65 @@ export function hasNewMessage(inboxRoot, threadId) {
     return hasMessage(inboxRoot, threadId, 'new');
 }
 /**
- * Scan every tracked brain's .inbox/ for a thread that has queued or retained work but
+ * Scan current and former brain .inbox/ directories 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()) {
-    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);
+export async function checkInboxForNewSessions(deps = defaultDeps()) {
+    const routes = [];
+    const brains = new Set();
+    // This is the full current platform channel map, not routes associated
+    // with a source directory (which may belong to a former assignment).
+    for (const info of deps.getTrackedBrains().values()) {
+        try {
+            const directory = executionDirectory(info.directory, deps.brainsPath);
+            routes.push({ info, directory });
+            brains.add(directory.path);
+        }
+        catch { /* Invalid platform identity was logged and reported; never scan a fallback. */ }
+    }
+    // Discover former locations from disk after restart, including legacy
+    // clones. Only inbox drops are read/removed there; no clone is adopted.
+    for (const workspace of listThreadDirs(deps.brainsPath)) {
+        let legacy;
+        try {
+            legacy = legacyBrainPath(workspace, deps.brainsPath);
+        }
+        catch {
+            continue;
+        }
+        if (existsSync(join(legacy, '.inbox')))
+            brains.add(legacy);
+        for (const brain of listThreadDirs(legacy)) {
+            if (!existsSync(join(legacy, brain, '.inbox')))
+                continue;
+            try {
+                brains.add(resolveBrainDir(workspace, brain, deps.brainsPath));
             }
+            catch { /* Invalid discovered identities are never used for execution. */ }
         }
     }
-    catch { }
-    for (const [brainPath, info] of brains) {
+    if (deps.defaultBrainPath)
+        brains.add(deps.defaultBrainPath);
+    const expired = await sweepThreadRouting(deps, brains);
+    const started = new Set();
+    const recoveries = [];
+    scan: for (const brainPath of brains) {
         if (deps.isAtCapacity())
-            return;
+            break;
         const inboxRoot = join(brainPath, '.inbox');
         for (const threadId of listThreadDirs(inboxRoot)) {
             if (deps.isAtCapacity())
-                return;
-            if (deps.isInboxLoopActive(threadId) || isPoolDeferred(threadId))
+                break scan;
+            if (expired.has(threadRoutingKey(threadId)))
+                continue;
+            if (started.has(threadId) || recoveringThreads.has(threadId) || deps.isInboxLoopActive(threadId) || isPoolDeferred(threadId))
                 continue;
-            const completion = readInboxRuntime(brainPath, threadId)?.completed;
+            discardHandledInboxDrops(brainPath, threadId);
+            const runtime = readInboxRuntime(brainPath, threadId);
+            const completion = runtime?.completed;
             const retryCompletion = completion && (Date.now() < completion.observedAt || Date.now() >= completion.retryAt);
             if (!hasNewMessage(inboxRoot, threadId) && !hasMessage(inboxRoot, threadId, 'processing') && !retryCompletion)
                 continue;
@@ -136,15 +172,148 @@ export function checkInboxForNewSessions(deps = defaultDeps()) {
                 continue;
             const durable = readInboxContext(brainPath, threadId);
             const parsed = parseSlackThreadId(threadId);
-            const message = durable ?? (info && parsed ? buildSyntheticMessage(info, threadId, parsed) : undefined);
-            if (!message)
+            // Context or poller-owned per-thread routing selects a channel in the
+            // full map. Never infer ownership from a directory's current channels.
+            const storedRoute = readInboxChannelContext(brainPath, threadId) ?? readThreadRouting(threadId);
+            const route = storedRoute
+                ? routes.find(({ info }) => info.workspaceId === storedRoute.workspaceId && info.channelId === storedRoute.channelId)
+                : undefined;
+            if (!route) {
+                quarantineRetainedThread(deps, brainPath, threadId, durable);
                 continue;
-            const sessionLog = logger.createSession(`iw_${Math.random().toString(36).slice(2, 10)}`);
-            deps.runInboxLoop(threadId, brainPath, message, sessionLog).catch(() => {
-                logger.error('[InboxWatcher] Retained inbox run failed; work remains saved');
-            });
+            }
+            const info = route.info;
+            const directory = route.directory;
+            const current = parsed ? buildSyntheticMessage(info, threadId, parsed) : undefined;
+            // Stored context supplies content, never the selected directory identity.
+            const message = durable
+                ? { ...durable, teamvibe: platformRouting(info) }
+                : current;
+            if (!message) {
+                quarantineRetainedThread(deps, brainPath, threadId, durable);
+                continue;
+            }
+            started.add(threadId);
+            recoveringThreads.add(threadId);
+            recoveries.push((async () => {
+                try {
+                    // A newly assigned brain may never have been used on this poller.
+                    // Clone before relocation creates .inbox/, so clone reuse cannot
+                    // mistake that inbox-only directory for an existing repository.
+                    if (directory.workspaceId && !existsSync(directory.path)) {
+                        await getBrainPath(message.teamvibe.brain, undefined, directory.workspaceId);
+                    }
+                    if (directory.path !== brainPath) {
+                        // A completed prompt must never run again in the new brain. Its old
+                        // bookkeeping stays at the old location; move only pending content.
+                        if (completion)
+                            markProcessed(brainPath, threadId, runtime.filename);
+                        if (!hasNewMessage(inboxRoot, threadId) && !hasMessage(inboxRoot, threadId, 'processing'))
+                            return;
+                        try {
+                            restartInboxInDirectory(brainPath, directory.path, threadId);
+                        }
+                        catch {
+                            logger.error('[InboxWatcher] Could not move retained work to the current brain; work remains saved');
+                            return;
+                        }
+                        logger.warn(`[InboxWatcher] Restarting retained work for channel ${info.channelId} in its current brain ${info.brainId}; former continuation is not resumed`);
+                    }
+                    if (deps.isAtCapacity())
+                        return;
+                    const sessionLog = logger.createSession(`iw_${Math.random().toString(36).slice(2, 10)}`);
+                    await deps.runInboxLoop(threadId, directory, message, sessionLog);
+                }
+                finally {
+                    recoveringThreads.delete(threadId);
+                }
+            })().catch(() => {
+                logger.error('[InboxWatcher] Retained inbox recovery failed; work remains saved');
+            }));
+        }
+    }
+    await Promise.all(recoveries);
+}
+/** Expiry precedes capacity/quota gates: stale work is preserved, never executed. */
+async function sweepThreadRouting(deps, brains) {
+    const discovered = new Map();
+    for (const brain of brains) {
+        for (const thread of listThreadDirs(join(brain, '.inbox')))
+            discovered.set(threadRoutingKey(thread), thread);
+    }
+    const expired = new Set();
+    for (const record of listThreadRoutings()) {
+        const thread = record.threadId ?? discovered.get(record.key);
+        const isExpired = Date.now() - record.modifiedAt >= config.INBOX_ROUTING_TTL_DAYS * 86_400_000;
+        if (isExpired)
+            expired.add(record.key);
+        if (thread && (deps.isInboxLoopActive(thread) || recoveringThreads.has(thread)))
+            continue;
+        if (isExpired) {
+            let quarantined = true;
+            if (thread) {
+                for (const brain of brains) {
+                    if (!existsSync(join(brain, '.inbox', thread)))
+                        continue;
+                    if (!quarantineRetainedThread(deps, brain, thread, readInboxContext(brain, thread), true))
+                        quarantined = false;
+                }
+            }
+            if (quarantined)
+                removeThreadRouting(record.key);
+            continue;
+        }
+        if (!thread || !deps.getSessionStatus)
+            continue;
+        try {
+            const status = await deps.getSessionStatus(thread);
+            if (!status || !['completed', 'failed', 'aborted'].includes(status))
+                continue;
+            if (deps.isInboxLoopActive(thread) || recoveringThreads.has(thread))
+                continue;
+            // Inspect every discovered location, including interrupted transfer sources.
+            if ([...brains].some(brain => hasInboxDrops(join(brain, '.inbox', thread)) || readInboxRuntime(brain, thread)?.completed))
+                continue;
+            removeThreadRouting(record.key);
+        }
+        catch {
+            logger.debug('[InboxWatcher] Routing cleanup deferred; session status unavailable');
         }
     }
+    return expired;
+}
+/** Fail closed on unreadable inboxes; metadata and .moved markers are not drops. */
+function hasInboxDrops(path) {
+    try {
+        return readdirSync(path, { withFileTypes: true }).some(entry => entry.isDirectory()
+            ? hasInboxDrops(join(path, entry.name)) : entry.name.endsWith('.txt'));
+    }
+    catch (error) {
+        return error.code !== 'ENOENT';
+    }
+}
+function quarantineRetainedThread(deps, brainPath, threadId, durable, expired = false) {
+    try {
+        quarantineInbox(brainPath, threadId, expired);
+    }
+    catch {
+        logger.error('[InboxWatcher] Could not quarantine unroutable inbox; work remains saved');
+        emitError('session', 'Could not quarantine unroutable inbox', { context: { threadId, reason: 'unroutable_inbox' } });
+        return false;
+    }
+    const detail = expired ? 'Expired thread routing; retained inbox saved in unroutable/ for operator review' : 'Retained inbox has no unambiguous current channel; saved in unroutable/ for operator review';
+    logger.error(`[InboxWatcher] ${detail}: ${threadId}`);
+    emitError('session', detail, { channelId: durable?.teamvibe.channelId, context: { threadId, reason: expired ? 'expired_inbox_routing' : 'unroutable_inbox' } });
+    const parsed = parseSlackThreadId(threadId);
+    if (!parsed || !deps.sendSlackMessage)
+        return true;
+    // Slack ids are used only for notification, never to choose a platform channel.
+    const info = [...deps.getTrackedBrains().values()].find(info => info.botId === threadId.split(':')[0] && (!durable || info.workspaceId === durable.teamvibe.workspaceId));
+    if (!info)
+        return true;
+    void deps.sendSlackMessage(buildSyntheticMessage(info, threadId, parsed), 'A retained background result could not be routed to a current channel. It has been saved for operator review; please contact your poller operator.')
+        .catch(() => logger.error('[InboxWatcher] Could not send unroutable inbox notice'));
+    return true;
 }
 export function isThreadDirEmpty(inboxRoot, threadId) {
     for (const sub of INBOX_SUBDIRS) {
@@ -162,7 +331,7 @@ export function isThreadDirEmpty(inboxRoot, threadId) {
     return true;
 }
 /**
- * Remove thread dirs whose new/processing/failed subdirs are all empty (or
+ * Remove thread dirs whose new/processing/failed/unroutable subdirs are all empty (or
  * absent) and which have no active loop right now. Safe because
  * writeMessage() always recreates the directory tree via a recursive
  * mkdirSync before writing (inbox-manager.ts) — deleting an empty thread dir
@@ -173,13 +342,13 @@ export function isThreadDirEmpty(inboxRoot, threadId) {
  */
 export function pruneEmptyInboxDirs(deps = defaultDeps()) {
     for (const [, info] of deps.getTrackedBrains()) {
-        const inboxRoot = join(deps.brainsPath, info.brainId, '.inbox');
+        const inboxRoot = join(info.directory.path, '.inbox');
         if (!existsSync(inboxRoot))
             continue;
         for (const threadId of listThreadDirs(inboxRoot)) {
             if (deps.isInboxLoopActive(threadId) || isPoolDeferred(threadId))
                 continue;
-            if (readInboxRuntime(join(deps.brainsPath, info.brainId), threadId)?.completed)
+            if (readInboxRuntime(info.directory.path, threadId)?.completed)
                 continue;
             if (!isThreadDirEmpty(inboxRoot, threadId))
                 continue;
@@ -202,7 +371,7 @@ function scheduleCheck(deps) {
         return;
     debounceTimer = setTimeout(() => {
         debounceTimer = null;
-        checkInboxForNewSessions(deps);
+        void checkInboxForNewSessions(deps).catch(() => logger.error('[InboxWatcher] Inbox scan failed; work remains saved'));
     }, config.INBOX_WATCH_DEBOUNCE_MS);
 }
 /**
@@ -223,19 +392,20 @@ function scheduleCheck(deps) {
 function syncBrainWatchers(deps) {
     const seen = new Set();
     for (const [, info] of deps.getTrackedBrains()) {
-        seen.add(info.brainId);
-        if (brainWatchers.has(info.brainId))
+        const key = info.directory.path;
+        seen.add(key);
+        if (brainWatchers.has(key))
             continue;
-        const inboxRoot = join(deps.brainsPath, info.brainId, '.inbox');
+        const inboxRoot = join(info.directory.path, '.inbox');
         if (!existsSync(inboxRoot))
             continue;
         try {
             const watcher = fsWatch(inboxRoot, { recursive: true }, () => scheduleCheck(deps));
             watcher.on('error', (error) => {
                 logger.warn(`[InboxWatcher] Watch error for brain ${info.brainId}, dropping watcher: ${error.message}`);
-                brainWatchers.delete(info.brainId);
+                brainWatchers.delete(key);
             });
-            brainWatchers.set(info.brainId, watcher);
+            brainWatchers.set(key, watcher);
             logger.debug(`[InboxWatcher] Watching ${inboxRoot}`);
         }
         catch (error) {
@@ -265,7 +435,7 @@ export function startInboxWatcher(deps = defaultDeps()) {
     logger.info(`[InboxWatcher] Started (fs.watch on ${brainWatchers.size} brain inbox dir(s), fallback sweep every ${fallbackMs}ms)`);
     fallbackInterval = setInterval(() => {
         syncBrainWatchers(deps);
-        checkInboxForNewSessions(deps);
+        void checkInboxForNewSessions(deps).catch(() => logger.error('[InboxWatcher] Inbox scan failed; work remains saved'));
         pruneEmptyInboxDirs(deps);
     }, fallbackMs);
 }

package/dist/maintenance-cron.d.ts

@@ -1,5 +1,7 @@
+import { type BrainDirectory } from './brain-directory.js';
 import type { TeamVibeQueueMessage } from './types.js';
 export interface TrackedBrainInfo {
+    directory: BrainDirectory;
     brainId: string;
     gitRepoUrl: string;
     branch: string;
@@ -51,7 +53,7 @@ export interface BootstrapBrainInfo {
  * opposite bug — a genuinely-quiet brain wrongly evaluated as "nothing new,
  * skip" on its very first post-restart cron tick.
  *
- * Skips (rather than overwrites) any brainId already present in
+ * Skips (rather than overwrites) any workspace/channel already present in
  * trackedBrains. This guard is load-bearing, not just defensive (DevGuru
  * review, round 4): since round 3's critical-path detachment
  * (brains-bootstrap.ts's `void (async () => {...})()` retry), the retry
@@ -91,7 +93,7 @@ export declare function seedTrackedBrains(brains: readonly BootstrapBrainInfo[])
  * 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;
+export declare function registerBrain(msg: TeamVibeQueueMessage, directory?: BrainDirectory): void;
 /**
  * Start the cron-based maintenance schedule (default: daily 03:30 in POLLER_TZ).
  */