@teamvibe/poller 0.8.6-rc.4 → 0.8.6

package/dist/pool-logging.js

@@ -42,6 +42,20 @@ export function logPoolFetch(log, pool) {
     const configured = pool.kind === 'ready' || pool.kind === 'fetch_unavailable' && pool.reason === 'no_usable_accounts' ? 'true' : 'unknown';
     poolInfo(log, `fetch poolConfigured=${configured} enabled=${enabled} usable=${enabled} result=${pool.kind}${pool.kind === 'fetch_unavailable' ? ` reason=${pool.reason}` : ''}${pool.cause ? ` cause=${pool.cause}` : ''} attempts=${pool.attempts ?? 1}`);
 }
+function skippedSelectionReason(candidate, selected) {
+    if (candidate.provenance === 'unknown' && selected.provenance === 'known')
+        return 'known observation preferred';
+    if (candidate.provenance === 'known' && selected.provenance === 'known' && candidate.score < selected.score)
+        return 'lower headroom per hour';
+    if (candidate.provenance === selected.provenance && selected.pinned)
+        return 'pinned thread kept (within tolerance)';
+    if (candidate.provenance === 'known' && selected.provenance === 'known' && candidate.score === selected.score)
+        return 'equal headroom, account id order';
+    if (candidate.provenance === 'unknown' && selected.provenance === 'unknown')
+        return 'no measurements, account id order';
+    // Should be unreachable: the policy explains every available skipped candidate above.
+    return 'deterministic account order';
+}
 /** The log and transport share a single explanation of the same selection snapshot. */
 export function poolSelectionCandidates(pool, states, model, now, selected) {
     if (pool.kind !== 'ready')
@@ -61,7 +75,7 @@ export function poolSelectionCandidates(pool, states, model, now, selected) {
         if (selected.kind === 'selected' && account.accountId === selected.account.accountId)
             return { ...base, ...metrics, outcome: 'selected', reason: 'selected' };
         const reason = candidate.kind === 'selected' && selected.kind === 'selected'
-            ? candidate.provenance === 'unknown' && selected.provenance === 'known' ? 'known observation preferred' : candidate.provenance === 'known' && selected.provenance === 'known' && candidate.score < selected.score ? 'lower headroom per hour' : 'deterministic account order'
+            ? skippedSelectionReason(candidate, selected)
             : 'unavailable';
         return { ...base, ...metrics, reason };
     });

package/dist/subscription-runtime.d.ts

@@ -88,6 +88,7 @@ export declare function preparePool(msg: TeamVibeQueueMessage, resolved: Resolve
         account: SubscriptionAccount;
         provenance: "known";
         source: "passive" | "probe";
+        pinned?: true;
     } & HeadroomScore & {
         model: string | undefined;
         modelSource: import("./claude-spawner.js").ModelSource;
@@ -102,6 +103,7 @@ export declare function preparePool(msg: TeamVibeQueueMessage, resolved: Resolve
         account: SubscriptionAccount;
         provenance: "unknown";
         uncertainApplicability: boolean;
+        pinned?: true;
     } & {
         model: string | undefined;
         modelSource: import("./claude-spawner.js").ModelSource;

package/dist/subscription-selection.d.ts

@@ -63,6 +63,10 @@ export declare function isLegacyReporter(version: string | undefined): boolean;
  * for modern reports, duplicate unknown windows, or an identical global copy.
  */
 export declare function projectLegacyFableUsage<T extends UsageObservation | undefined>(usage: T, version?: string): T;
+/** Genuine Fable data replaces raw uncertain windows observed at or before it.
+ * Deduplicate uncertain windows before splitting measurements from rejections.
+ */
+export declare function supersedeLegacyFableProjections(observations: readonly (UsageObservation | undefined)[], now: number): (UsageObservation | undefined)[];
 /** Latest measurements plus durable genuine rejections; omission or success never clears a genuine hold. */
 export declare function mergeUsageObservations(observations: readonly (UsageObservation | undefined)[], now: number): UsageObservation | undefined;
 /** Preserve last-known meters, projecting legacy identity before its global companion is replaced. */
@@ -85,11 +89,13 @@ export type SelectionOutcome<A extends AccountIdentity = AccountIdentity> = ({
     account: A;
     provenance: 'known';
     source: 'passive' | 'probe';
+    pinned?: true;
 } & HeadroomScore) | {
     kind: 'selected';
     account: A;
     provenance: 'unknown';
     uncertainApplicability: boolean;
+    pinned?: true;
 } | {
     kind: 'deferred';
     eligibleAt: number;

package/dist/subscription-selection.js

@@ -59,24 +59,61 @@ export function projectLegacyFableUsage(usage, version) {
         }),
     };
 }
-/** Genuine Fable data supersedes older compatibility projections, using each window's clock. */
-function supersedeLegacyFableProjections(observations, now) {
-    const projected = observations.map(usage => projectLegacyFableUsage(usage));
+/** Genuine Fable data replaces raw uncertain windows observed at or before it.
+ * Deduplicate uncertain windows before splitting measurements from rejections.
+ */
+export function supersedeLegacyFableProjections(observations, now) {
+    // Preserve explicit-scope compatibility for already projected legacy Fable data.
+    let newestFable = -Infinity;
     let newestGenuine = -Infinity;
-    for (const usage of projected) {
+    for (const usage of observations) {
         if (!usage || usage.observedAt > now)
             continue;
         for (const w of usage.windows) {
             const observedAt = w.observedAt ?? usage.observedAt;
             if (w.window === 'seven_day' && w.scope === 'fable' &&
                 w.kind !== 'legacy-uncertain-seven-day' && observedAt <= now)
+                newestFable = Math.max(newestFable, observedAt);
+            if (w.window === 'seven_day' && w.scope === 'fable' &&
+                w.kind === 'seven_day_overage_included' && observedAt <= now)
                 newestGenuine = Math.max(newestGenuine, observedAt);
         }
     }
-    return projected.map(usage => usage && ({
+    // Reporter versions and missing kinds cannot date raw uncertain windows.
+    // Keep newer evidence unprojected so its rejection still holds every family.
+    const projected = observations.map(usage => {
+        const filtered = usage && ({
+            ...usage,
+            windows: usage.windows.filter(w => !(newestGenuine > -Infinity &&
+                w.window === 'seven_day' && w.scope === 'uncertain' &&
+                (w.observedAt ?? usage.observedAt) <= newestGenuine)),
+        });
+        return newestGenuine > -Infinity ? filtered : projectLegacyFableUsage(filtered);
+    });
+    const newestUncertain = new Map();
+    projected.forEach((usage, observation) => {
+        if (!usage || usage.observedAt > now)
+            return;
+        usage.windows.forEach((w, window) => {
+            const observedAt = w.observedAt ?? usage.observedAt;
+            if (w.scope !== 'uncertain' || observedAt > now)
+                return;
+            const previous = newestUncertain.get(w.window);
+            if (!previous || observedAt >= previous.observedAt)
+                newestUncertain.set(w.window, { observation, window, observedAt });
+        });
+    });
+    return projected.map((usage, observation) => usage && ({
         ...usage,
-        windows: usage.windows.filter(w => !(w.window === 'seven_day' && w.scope === 'fable' &&
-            w.kind === 'legacy-uncertain-seven-day' && (w.observedAt ?? usage.observedAt) < newestGenuine)),
+        windows: usage.windows.filter((w, window) => {
+            if (w.window === 'seven_day' && newestFable > -Infinity && (w.scope === 'fable' && w.kind === 'legacy-uncertain-seven-day' &&
+                (w.observedAt ?? usage.observedAt) < newestFable))
+                return false;
+            if (w.scope !== 'uncertain')
+                return true;
+            const newest = newestUncertain.get(w.window);
+            return newest?.observation === observation && newest.window === window;
+        }),
     }));
 }
 /** Latest measurements plus durable genuine rejections; omission or success never clears a genuine hold. */
@@ -316,7 +353,7 @@ export function selectSubscriptionAccount(input) {
             if (input.now < until)
                 blockers.push(until);
         }
-        const usage = projectLegacyFableUsage(state?.usage);
+        const usage = supersedeLegacyFableProjections([state?.usage], input.now)[0];
         // A provider rejection outlives snapshot freshness. Never score it as headroom.
         if (usage && usage.observedAt <= input.now) {
             for (const w of usage.windows) {
@@ -359,19 +396,22 @@ export function selectSubscriptionAccount(input) {
     const current = known.find(candidate => candidate.account.accountId === input.currentAccountId);
     if (current && known[0] && input.currentAccountTolerance !== undefined &&
         known[0].score < current.score * (1 + input.currentAccountTolerance))
-        return { kind: 'selected', provenance: 'known', ...current };
+        return { kind: 'selected', provenance: 'known', ...current, pinned: true };
     // Known-first is only this spawn's transitional fallback: background CLI
     // probes measure non-selected unknowns so the next spawn can score them.
+    // Preserve pin provenance for equal scores (including zero) and unknowns too.
     if (known[0])
-        return { kind: 'selected', provenance: 'known', ...known[0] };
+        return { kind: 'selected', provenance: 'known', ...known[0],
+            ...(known[0].account.accountId === input.currentAccountId ? { pinned: true } : {}) };
     if (unknown[0])
-        return { kind: 'selected', provenance: 'unknown', ...unknown[0] };
+        return { kind: 'selected', provenance: 'unknown', ...unknown[0],
+            ...(input.currentAccountTolerance !== undefined && unknown[0].account.accountId === input.currentAccountId ? { pinned: true } : {}) };
     return { kind: 'deferred', eligibleAt: Math.min(...deadlines) };
 }
 /** Explain actual blockers with the same scope, clocks and thresholds as selection. */
 export function blockingUsageWindows(account, state, model, now) {
     const pool = { kind: 'ready', accounts: [account] };
-    const usage = projectLegacyFableUsage(state?.usage);
+    const usage = supersedeLegacyFableProjections([state?.usage], now)[0];
     const windows = [];
     for (const window of usage?.windows ?? []) {
         const result = selectSubscriptionAccount({ pool, states: { [account.accountId]: { usage: { ...usage, windows: [window] } } }, model, now });

package/dist/subscription-usage-store.js

@@ -3,7 +3,7 @@ import { createHash, randomUUID } from 'node:crypto';
 import { mkdir, readFile, rename, rm, writeFile } from 'node:fs/promises';
 import { join, resolve } from 'node:path';
 import { parseClaudeRateLimitInfo } from './claude-rate-limit.js';
-import { normalizePassiveUsage, mergeUsageObservations, record, reactiveEligibleAt, family } from './subscription-selection.js';
+import { normalizePassiveUsage, mergePersistedUsageObservations, mergeUsageObservations, record, reactiveEligibleAt, family } from './subscription-selection.js';
 export function usageStateForSelection(state, now) {
     return {
         usage: mergeUsageObservations([
@@ -186,9 +186,10 @@ export class FileSubscriptionUsageStore {
             const state = safeVersion(await this.#load(path, {}));
             if (state.passive && state.passive.observedAt > observedAt && !options?.expireFutureObservations)
                 return;
-            const previous = usageStateForSelection({ ...state, reactive: [] }, observedAt).usage;
+            // Retain Fable observation clocks even when the latest report omits its meter.
+            const previous = state.usage ?? usageStateForSelection({ ...state, reactive: [] }, observedAt).usage;
             state.passive = { rateLimitInfo: safeRateLimitInfo(rateLimitInfo), observedAt };
-            state.usage = mergeUsageObservations([previous, normalizePassiveUsage(state.passive.rateLimitInfo, observedAt)], observedAt);
+            state.usage = mergePersistedUsageObservations(previous, normalizePassiveUsage(state.passive.rateLimitInfo, observedAt), observedAt);
             await this.#save(path, state);
         });
     }
@@ -262,9 +263,10 @@ export class FileSubscriptionUsageStore {
             const state = safeVersion(await this.#load(path, {}));
             // Network completion order must not discard a newer stored snapshot.
             const mergeAt = Math.max(observation.observedAt, state.usage?.observedAt ?? 0, state.passive?.observedAt ?? 0);
-            const previous = usageStateForSelection({ ...state, reactive: [] }, mergeAt).usage;
+            // Retain Fable observation clocks even when the latest report omits its meter.
+            const previous = state.usage ?? usageStateForSelection({ ...state, reactive: [] }, mergeAt).usage;
             state.probe = safeProbe(observation);
-            state.usage = mergeUsageObservations([previous, state.probe.usage], mergeAt);
+            state.usage = mergePersistedUsageObservations(previous, state.probe.usage, mergeAt);
             await this.#save(path, state);
         });
     }

package/npm-shrinkwrap.json

@@ -1,12 +1,12 @@
 {
   "name": "@teamvibe/poller",
-  "version": "0.8.6-rc.4",
+  "version": "0.8.6",
   "lockfileVersion": 3,
   "requires": true,
   "packages": {
     "": {
       "name": "@teamvibe/poller",
-      "version": "0.8.6-rc.4",
+      "version": "0.8.6",
       "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.6-rc.4",
+  "version": "0.8.6",
   "type": "module",
   "main": "./dist/index.js",
   "bin": {