@teamvibe/poller 0.8.3 → 0.8.4-rc.1

package/dist/subscription-runtime.js

@@ -39,20 +39,20 @@ export async function preparePool(msg, resolved, pin, fetched, log) {
                         if (other.accountId !== account.accountId)
                             poolInfo(log, `skipped account=${poolLabel(other)} reason=session pinned elsewhere`);
                     }
-                return { account, store, pool };
+                return { account, store, pool, selection: selected };
             }
         }
     }
-    const selected = await selectPoolForResolvedModel(resolved, { workspaceId: msg.teamvibe.workspaceId, pool, store, now: Date.now(), log });
+    const selected = await selectPoolForResolvedModel(resolved, { workspaceId: msg.teamvibe.workspaceId, pool, store, now: Date.now(), log, currentAccountId: pin?.workspaceId === msg.teamvibe.workspaceId ? pin.accountId : undefined });
     if (selected.kind === 'selected') {
         if (log && pool.kind === 'ready' && pin?.workspaceId === msg.teamvibe.workspaceId && pin.accountId !== selected.account.accountId) {
             const previous = pool.accounts.find(a => a.accountId === pin.accountId);
             poolInfo(log, `switch from=${poolLabel(previous ?? {})} to=${poolLabel(selected.account)} reason=pinned account unavailable`);
         }
-        return { account: selected.account, store, pool };
+        return { account: selected.account, store, pool, selection: selected };
     }
     if (selected.kind === 'no_accounts_configured')
-        return { account: undefined, store, pool };
+        return { account: undefined, store, pool, selection: undefined };
     throw await poolDeferredError(pool, resolved, store, selected.kind === 'deferred' ? selected.eligibleAt : undefined);
 }
 export function accountPin(account, resolved) {

package/dist/subscription-selection.d.ts

@@ -1,3 +1,4 @@
+import type { AccountProbeFailureReason } from './usage-probe-contract.js';
 import type { ClaudeQuotaFailure } from './claude-quota.js';
 export declare const USAGE_THRESHOLD_PERCENT = 90;
 /** Passive snapshots are useful for five minutes, then become unknown. */
@@ -14,6 +15,9 @@ export interface AccountIdentity {
 export type PoolFetchResult<A extends AccountIdentity = AccountIdentity> = {
     kind: 'ready';
     accounts: readonly A[];
+} | {
+    kind: 'probe_account_unavailable';
+    reason: AccountProbeFailureReason;
 } | {
     kind: 'no_accounts_configured';
 } | {
@@ -46,13 +50,17 @@ export interface AccountUsageState {
     usage?: UsageObservation;
     reactive?: readonly ReactiveExhaustion[];
 }
-export type SelectionOutcome<A extends AccountIdentity = AccountIdentity> = {
+export interface HeadroomScore {
+    score: number;
+    rateWindow: UsageWindow;
+    reason: 'headroom_per_hour';
+}
+export type SelectionOutcome<A extends AccountIdentity = AccountIdentity> = ({
     kind: 'selected';
     account: A;
     provenance: 'known';
-    score: number;
     source: 'passive' | 'probe';
-} | {
+} & HeadroomScore) | {
     kind: 'selected';
     account: A;
     provenance: 'unknown';
@@ -73,5 +81,7 @@ export declare function selectSubscriptionAccount<A extends AccountIdentity>(inp
     /** Stable account ID within the pool's single workspace. */
     states: Readonly<Record<string, AccountUsageState | undefined>>;
     model: string | undefined;
+    /** Tie preference only; session pins are enforced separately by the runtime. */
+    currentAccountId?: string;
     now: number;
 }): SelectionOutcome<A>;

package/dist/subscription-selection.js

@@ -92,7 +92,7 @@ export function normalizeProbeUsage(value, observedAt) {
     return { source: 'probe', observedAt, windows };
 }
 function family(model) {
-    return model?.toLowerCase().match(/^(?:claude-)?(sonnet|opus|haiku)(?:-\d[\w.-]*)?(?:\[1m\])?$/)?.[1];
+    return model?.toLowerCase().match(/^(?:claude-)?(sonnet|opus|haiku|fable)(?:-\d[\w.-]*)?(?:\[1m\])?$/)?.[1];
 }
 function applicable(scope, model) {
     return scope === 'global' || scope === 'uncertain' || family(model) === undefined || scope === family(model);
@@ -101,6 +101,21 @@ export function reactiveEligibleAt(reactive) {
     const parsed = reactive.quota.resetAt ? Date.parse(reactive.quota.resetAt) : NaN;
     return Number.isFinite(parsed) && parsed > reactive.observedAt ? parsed : reactive.observedAt + POOL_RECHECK_MS;
 }
+/** Called only for nonempty, applicable known windows after all blockers are ruled out.
+ * The minimum rate is the account's binding window; retain its numbers for explanation.
+ */
+function scoreHeadroom(windows, threshold, now) {
+    let score = Infinity;
+    let rateWindow = windows[0];
+    for (const window of windows) {
+        const rate = (threshold - window.percent) / Math.max((window.resetAt - now) / 3600_000, 0.25);
+        if (rate < score) {
+            score = rate;
+            rateWindow = window;
+        }
+    }
+    return { score, rateWindow, reason: 'headroom_per_hour' };
+}
 /** Pure policy. Unknown is eligible after every known/reactive blocker is ruled out. */
 export function selectSubscriptionAccount(input) {
     if (input.pool.kind !== 'ready')
@@ -140,14 +155,14 @@ export function selectSubscriptionAccount(input) {
             deadlines.push(Math.max(...blockers));
         }
         else if (windows.length && !uncertain && windows.every(w => w.percent !== undefined && w.resetAt !== undefined)) {
-            known.push({ account, score: Math.max(...windows.map(w => w.percent)), source: usage.source });
+            known.push({ account, ...scoreHeadroom(windows, account.useFullQuota ? 100 : USAGE_THRESHOLD_PERCENT, input.now), source: usage.source });
         }
         else {
             unknown.push({ account, uncertainApplicability: uncertain });
         }
     }
     const compare = (a, b) => a.accountId < b.accountId ? -1 : a.accountId > b.accountId ? 1 : 0;
-    known.sort((a, b) => a.score - b.score || compare(a.account, b.account));
+    known.sort((a, b) => b.score - a.score || Number(b.account.accountId === input.currentAccountId) - Number(a.account.accountId === input.currentAccountId) || compare(a.account, b.account));
     unknown.sort((a, b) => compare(a.account, b.account));
     if (known[0])
         return { kind: 'selected', provenance: 'known', ...known[0] };

package/dist/thread-routing.d.ts

@@ -0,0 +1,23 @@
+export interface ThreadRouting {
+    workspaceId: string;
+    channelId: string;
+    brainId?: string;
+    /** Historical evidence only. Recovery always derives the current directory. */
+    directory: string;
+    threadId?: string;
+    processedDropIds?: string[];
+}
+/** Poller state survives inbox pruning and process restarts; contains no credentials. */
+export declare function saveThreadRouting(threadId: string, routing: ThreadRouting): void;
+export declare function readThreadRouting(threadId: string): ThreadRouting | undefined;
+export declare function inboxDropId(threadId: string, filename: string, content: string | Uint8Array): string;
+export declare function recordProcessedDrop(threadId: string, filename: string, content: string | Uint8Array): void;
+export interface StoredThreadRouting {
+    key: string;
+    threadId?: string;
+    modifiedAt: number;
+}
+/** Older records have no threadId; discovery can match their hashed file name. */
+export declare function listThreadRoutings(): StoredThreadRouting[];
+export declare function threadRoutingKey(threadId: string): string;
+export declare function removeThreadRouting(key: string): void;

package/dist/thread-routing.js

@@ -0,0 +1,81 @@
+import { createHash, randomUUID } from 'node:crypto';
+import { mkdirSync, readdirSync, readFileSync, renameSync, rmSync, statSync, writeFileSync } from 'node:fs';
+import { join } from 'node:path';
+import { config } from './config.js';
+function routingPath(threadId) {
+    return join(config.TEAMVIBE_DATA_DIR, 'thread-routing', threadRoutingKey(threadId));
+}
+/** Poller state survives inbox pruning and process restarts; contains no credentials. */
+export function saveThreadRouting(threadId, routing) {
+    mkdirSync(join(config.TEAMVIBE_DATA_DIR, 'thread-routing'), { recursive: true, mode: 0o700 });
+    const path = routingPath(threadId);
+    const temporary = `${path}.${randomUUID()}.tmp`;
+    try {
+        writeFileSync(temporary, JSON.stringify({ ...readThreadRouting(threadId), ...routing, threadId, updatedAt: Date.now() }), { mode: 0o600 });
+        renameSync(temporary, path);
+    }
+    finally {
+        rmSync(temporary, { force: true });
+    }
+}
+export function readThreadRouting(threadId) {
+    try {
+        const routing = JSON.parse(readFileSync(routingPath(threadId), 'utf8'));
+        if (typeof routing.workspaceId !== 'string' || typeof routing.channelId !== 'string' || typeof routing.directory !== 'string' || routing.brainId !== undefined && typeof routing.brainId !== 'string')
+            return undefined;
+        if (routing.processedDropIds !== undefined && (!Array.isArray(routing.processedDropIds) || !routing.processedDropIds.every((id) => typeof id === 'string')))
+            return undefined;
+        return routing;
+    }
+    catch {
+        return undefined;
+    }
+}
+export function inboxDropId(threadId, filename, content) {
+    return createHash('sha256').update(JSON.stringify([threadId, filename, createHash('sha256').update(content).digest('hex')])).digest('hex');
+}
+export function recordProcessedDrop(threadId, filename, content) {
+    const routing = readThreadRouting(threadId);
+    if (!routing)
+        return;
+    const id = inboxDropId(threadId, filename, content);
+    saveThreadRouting(threadId, { ...routing, processedDropIds: [...new Set([...(routing.processedDropIds ?? []), id])] });
+}
+/** Older records have no threadId; discovery can match their hashed file name. */
+export function listThreadRoutings() {
+    const root = join(config.TEAMVIBE_DATA_DIR, 'thread-routing');
+    let names;
+    try {
+        names = readdirSync(root);
+    }
+    catch {
+        return [];
+    }
+    return names.filter(name => /^[a-f0-9]{64}\.json$/.test(name)).flatMap(name => {
+        try {
+            const path = join(root, name);
+            let modifiedAt = statSync(path).mtimeMs;
+            let threadId;
+            try {
+                const value = JSON.parse(readFileSync(path, 'utf8'));
+                if (typeof value.updatedAt === 'number' && Number.isFinite(value.updatedAt))
+                    modifiedAt = value.updatedAt;
+                if (typeof value.threadId === 'string' && routingPath(value.threadId) === path)
+                    threadId = value.threadId;
+            }
+            catch { /* Corrupt records still expire; match any drops by the hash. */ }
+            return [{ key: name, threadId, modifiedAt }];
+        }
+        catch {
+            return [];
+        }
+    });
+}
+export function threadRoutingKey(threadId) {
+    return `${createHash('sha256').update(threadId).digest('hex')}.json`;
+}
+export function removeThreadRouting(key) {
+    if (!/^[a-f0-9]{64}\.json$/.test(key))
+        throw new Error('Invalid routing key');
+    rmSync(join(config.TEAMVIBE_DATA_DIR, 'thread-routing', key), { force: true });
+}

package/dist/types.d.ts

@@ -1,3 +1,5 @@
+import type { UsageProbeMessage } from './usage-probe-contract.js';
+export type { UsageProbeMessage, UsageProbeFailureReason } from './usage-probe-contract.js';
 export interface ControlMessage {
     id: string;
     source: 'control';
@@ -69,6 +71,7 @@ export interface TeamVibeQueueMessage {
 export interface SubscriptionPin {
     inboxFilename?: string;
     resumePending?: boolean;
+    /** Comparison evidence only; replay derives execution paths from current routing. */
     effectiveCwd?: string;
     claudeConfigDir?: string;
     sawSendMessageCall?: boolean;
@@ -92,7 +95,7 @@ export interface SessionRecord {
     last_message_ts?: string;
     ttl: number;
 }
-export type SessionStatus = 'processing' | 'idle' | 'waiting_for_input';
+export type SessionStatus = 'processing' | 'idle' | 'waiting_for_input' | 'completed' | 'failed' | 'aborted';
 export interface SessionMetrics {
     /** Input occupancy of the last assistant message, independent of run totals. */
     context_tokens?: number;
@@ -107,12 +110,3 @@ export interface SessionMetrics {
     cache_creation_input_tokens?: number;
     model?: string;
 }
-export interface UsageProbeMessage {
-    kind: 'usage_probe';
-    id: string;
-    workspaceId: string;
-    accountId: string;
-    credentialVersion: string;
-    requestId: string;
-    expiresAt: number;
-}

package/dist/usage-limit-messages.d.ts

@@ -1,5 +1,5 @@
 /** Owner-facing account policy location. */
-export declare const FULL_QUOTA_SETTINGS_PATH = "Settings \u2192 Connections (account menu \u2192 Use until exhausted)";
+export declare const FULL_QUOTA_SETTINGS_PATH = "Connections (account menu \u2192 Use until exhausted)";
 export interface UsageResetTiming {
     resetAt?: number;
     now?: number;

package/dist/usage-limit-messages.js

@@ -1,5 +1,5 @@
 /** Owner-facing account policy location. */
-export const FULL_QUOTA_SETTINGS_PATH = 'Settings → Connections (account menu → Use until exhausted)';
+export const FULL_QUOTA_SETTINGS_PATH = 'Connections (account menu → Use until exhausted)';
 export function formatUsageReset(input) {
     if (input.resetAt === undefined || !Number.isFinite(input.resetAt))
         return undefined;

package/dist/usage-probe-contract.d.ts

@@ -0,0 +1,15 @@
+/** Shared wire contract for request-scoped usage probes. */
+export declare const ACCOUNT_PROBE_FAILURE_REASONS: readonly ["account_changed", "account_disabled", "account_missing"];
+export declare const USAGE_PROBE_FAILURE_REASONS: readonly ["account_changed", "account_disabled", "account_missing", "token_rejected", "cli_at_capacity", "timeout", "unknown"];
+export type AccountProbeFailureReason = (typeof ACCOUNT_PROBE_FAILURE_REASONS)[number];
+export type UsageProbeFailureReason = (typeof USAGE_PROBE_FAILURE_REASONS)[number];
+export declare const USAGE_UPDATE_TTL_MS: number;
+export interface UsageProbeMessage {
+    kind: 'usage_probe';
+    id: string;
+    workspaceId: string;
+    accountId: string;
+    credentialVersion: string;
+    requestId: string;
+    expiresAt: number;
+}

package/dist/usage-probe-contract.js

@@ -0,0 +1,14 @@
+/** Shared wire contract for request-scoped usage probes. */
+export const ACCOUNT_PROBE_FAILURE_REASONS = [
+    'account_changed',
+    'account_disabled',
+    'account_missing',
+];
+export const USAGE_PROBE_FAILURE_REASONS = [
+    ...ACCOUNT_PROBE_FAILURE_REASONS,
+    'token_rejected',
+    'cli_at_capacity',
+    'timeout',
+    'unknown',
+];
+export const USAGE_UPDATE_TTL_MS = 10 * 60_000;

package/dist/usage-probe-job.js

@@ -40,12 +40,25 @@ export async function handleUsageProbe(job, options) {
         const pool = await options.fetchPool();
         const account = pool.kind === 'ready'
             ? pool.accounts.find((a) => a.workspaceId === job.workspaceId &&
-                a.accountId === job.accountId &&
-                a.credentialVersion === job.credentialVersion &&
-                a.enabled)
+                a.accountId === job.accountId)
             : undefined;
-        if (!account)
+        if (!account) {
+            result =
+                pool.kind === 'probe_account_unavailable'
+                    ? pool.reason
+                    : pool.kind === 'ready' || pool.kind === 'no_accounts_configured'
+                        ? 'account_missing'
+                        : 'unknown';
             return;
+        }
+        if (!account.enabled) {
+            result = 'account_disabled';
+            return;
+        }
+        if (account.credentialVersion !== job.credentialVersion) {
+            result = 'account_changed';
+            return;
+        }
         if (options.isAtCapacity()) {
             result = 'cli_at_capacity';
             return;
@@ -181,6 +194,6 @@ export async function handleUsageProbe(job, options) {
                 reason: result,
             });
         if (!duplicate)
-            options.log(`[Pool] usage probe account=${job.accountId} result=${result}`);
+            options.log(`[Pool] usage probe request=${job.requestId} result=${result}`);
     }
 }

package/dist/worktree-manager.d.ts

@@ -21,7 +21,8 @@ export declare function cleanupOrphanWorktrees(brainPath: string, maxAgeMs?: num
     removed: string[];
 }>;
 /**
- * Sweep orphan worktrees across every brain directory under `brainsRoot`.
+ * Sweep orphan worktrees under `brainsRoot/<workspaceId>/<brainId>`.
+ * Top-level legacy clones are left untouched.
  * Intended to run once at poller startup. Tolerates the entries that aren't
  * brain repos (no `.git` subdir) by skipping them silently.
  */

package/dist/worktree-manager.js

@@ -1,7 +1,9 @@
+import { existsSync } from 'fs';
 import { mkdir, readdir, stat, appendFile, readFile } from 'fs/promises';
 import { join } from 'path';
 import { execFile } from 'child_process';
 import { promisify } from 'util';
+import { validateBrainId, resolveBrainDir } from './brain-path.js';
 import { readInboxRuntime } from './inbox-manager.js';
 const execFileAsync = promisify(execFile);
 const WORKTREES_SUBDIR = '.worktrees';
@@ -112,7 +114,8 @@ export async function cleanupOrphanWorktrees(brainPath, maxAgeMs = 24 * 60 * 60
     return { removed };
 }
 /**
- * Sweep orphan worktrees across every brain directory under `brainsRoot`.
+ * Sweep orphan worktrees under `brainsRoot/<workspaceId>/<brainId>`.
+ * Top-level legacy clones are left untouched.
  * Intended to run once at poller startup. Tolerates the entries that aren't
  * brain repos (no `.git` subdir) by skipping them silently.
  */
@@ -126,19 +129,44 @@ export async function cleanupOrphanWorktreesForAllBrains(brainsRoot, maxAgeMs =
     }
     let scanned = 0;
     let removed = 0;
-    for (const entry of entries) {
-        const brainPath = join(brainsRoot, entry);
+    for (const workspace of entries) {
         try {
-            const gitStat = await stat(join(brainPath, '.git'));
-            if (!gitStat.isDirectory())
-                continue;
+            validateBrainId(workspace);
+        }
+        catch {
+            continue;
+        }
+        const workspacePath = join(brainsRoot, workspace);
+        // A top-level repo is a legacy clone and must remain untouched.
+        if (existsSync(join(workspacePath, '.git')))
+            continue;
+        let brains;
+        try {
+            brains = await readdir(workspacePath);
         }
         catch {
-            continue; // not a brain repo
+            continue;
+        }
+        for (const brain of brains) {
+            let brainPath;
+            try {
+                brainPath = resolveBrainDir(workspace, brain, brainsRoot);
+            }
+            catch {
+                continue;
+            }
+            try {
+                const gitStat = await stat(join(brainPath, '.git'));
+                if (!gitStat.isDirectory())
+                    continue;
+            }
+            catch {
+                continue;
+            }
+            scanned++;
+            const { removed: gone } = await cleanupOrphanWorktrees(brainPath, maxAgeMs);
+            removed += gone.length;
         }
-        scanned++;
-        const { removed: gone } = await cleanupOrphanWorktrees(brainPath, maxAgeMs);
-        removed += gone.length;
     }
     return { scanned, removed };
 }

package/npm-shrinkwrap.json

@@ -1,12 +1,12 @@
 {
   "name": "@teamvibe/poller",
-  "version": "0.8.3",
+  "version": "0.8.4-rc.1",
   "lockfileVersion": 3,
   "requires": true,
   "packages": {
     "": {
       "name": "@teamvibe/poller",
-      "version": "0.8.3",
+      "version": "0.8.4-rc.1",
       "dependencies": {
         "@aws-sdk/client-dynamodb": "3.1108.0",
         "@aws-sdk/client-sqs": "3.1108.0",

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@teamvibe/poller",
-  "version": "0.8.3",
+  "version": "0.8.4-rc.1",
   "type": "module",
   "main": "./dist/index.js",
   "bin": {