agent-dealer 1.2.1 → 1.2.2

package/bundle/server/dist/adapters/linear-inbox.js

@@ -1,5 +1,6 @@
-import { resolveLinearRepoLabels } from "@agent-dealer/shared";
+import { resolveLinearRepoWithMappings } from "@agent-dealer/shared";
 import { DEFAULT_LINEAR_STATE_FILTER, getLinearIntakeConfig } from "../repository/intake-settings.js";
+import { listRepositoryMappings } from "../repository/repository-mappings.js";
 import { linearGraphqlRequest } from "./linear-graphql.js";
 export { DEFAULT_LINEAR_STATE_FILTER };
 const PAGE_SIZE = 50;
@@ -20,7 +21,7 @@ async function linearQuery(operation, query, variables, opts) {
  * deterministic (one valid label resolves, zero is unresolved, several
  * conflict, a bad value is invalid) and never guesses from anything else.
  */
-export function nodeToCandidate(n) {
+export function nodeToCandidate(n, mappings) {
     const labels = n.labels?.nodes.map((l) => l.name) ?? [];
     return {
         id: n.id,
@@ -31,7 +32,7 @@ export function nodeToCandidate(n) {
         state: n.state?.name,
         teamId: n.team?.id,
         labels,
-        repoResolution: resolveLinearRepoLabels(labels),
+        repoResolution: resolveLinearRepoWithMappings(labels, mappings ?? []),
     };
 }
 const ISSUE_FIELDS = `
@@ -106,7 +107,9 @@ export async function listLinearCandidates() {
             break;
         after = data.issues.pageInfo.endCursor;
     }
-    return nodes.map(nodeToCandidate);
+    // NOT-260: mappings load once per list operation, not once per candidate.
+    const mappings = listRepositoryMappings();
+    return nodes.map((n) => nodeToCandidate(n, mappings));
 }
 export async function getLinearIssue(issueId) {
     const data = (await linearQuery("getLinearIssue", `query Issue($id: String!) {
@@ -114,7 +117,8 @@ export async function getLinearIssue(issueId) {
     }`, { id: issueId }));
     if (!data.issue)
         return null;
-    return nodeToCandidate(data.issue);
+    // NOT-260: mappings load once per lookup operation.
+    return nodeToCandidate(data.issue, listRepositoryMappings());
 }
 const RELATION_PAGE_FIELDS = `
   nodes { type issue { id identifier state { name type } } }

package/bundle/server/dist/capacity/adapter.js

@@ -50,6 +50,7 @@ export function normalizeAdapterWindow(runtime, reading, nowMs = Date.now()) {
         source: reading.source,
         unavailableReason,
         evidenceRef: reading.evidenceRef ?? null,
+        criticalRole: reading.criticalRole ?? null,
     };
 }
 /** Normalize one provider failure into the persistable snapshot shape. */
@@ -70,6 +71,7 @@ export function normalizeUnavailableWindow(runtime, reading, nowMs = Date.now())
         source: "unavailable",
         unavailableReason: reading.reason,
         evidenceRef: null,
+        criticalRole: reading.criticalRole ?? null,
     };
 }
 // ---------------------------------------------------------------------------

package/bundle/server/dist/capacity/claude-events.js

@@ -170,6 +170,22 @@ export function inferClaudeDurationMinutes(bucket) {
         return 10080;
     return null;
 }
+/**
+ * The account-wide critical window's identity, decided here — once,
+ * authoritatively — and never re-derived downstream. Deliberately an exact
+ * match, unlike `inferClaudeDurationMinutes`'s loose regex: a model-specific
+ * extra like `seven_day_sonnet`/`seven_day_opus` shares the 10,080-minute
+ * duration with the real account-wide `seven_day`/`weekly` bucket but is
+ * not the critical window, so identity can't reuse that regex.
+ */
+export function claudeCriticalRole(bucket) {
+    const b = bucket.trim().toLowerCase();
+    if (b === "five_hour")
+        return "five_hour";
+    if (b === "seven_day" || b === "weekly")
+        return "weekly";
+    return null;
+}
 function windowReadingFromEntry(bucket, entry, observedAt) {
     const cleanBucket = bucket.trim();
     if (!cleanBucket)
@@ -218,6 +234,7 @@ function windowReadingFromEntry(bucket, entry, observedAt) {
         observedAt,
         source: "observed_event",
         evidenceRef: CLAUDE_UNIFIED_WINDOWS_EVIDENCE_REF,
+        criticalRole: claudeCriticalRole(cleanBucket),
     };
 }
 /**
@@ -350,6 +367,7 @@ export function recordClaudeCapacityFromEvents(events, runtime, nowMs = Date.now
         source: w.source,
         unavailableReason: w.unavailableReason,
         evidenceRef: w.evidenceRef,
+        criticalRole: w.criticalRole,
     })));
     return fresh.length;
 }

package/bundle/server/dist/capacity/claude-events.test.js

@@ -67,6 +67,8 @@ test("five-hour and seven-day windows persist independently", () => {
     assert.equal(fiveHour.remainingPercent, 83);
     assert.equal(sevenDay.remainingPercent, 58);
     assert.notEqual(fiveHour.resetAt, sevenDay.resetAt);
+    assert.equal(fiveHour.criticalRole, "five_hour");
+    assert.equal(sevenDay.criticalRole, "weekly");
     // A later partial observation (five_hour only) upserts its row and leaves
     // the seven-day sibling untouched.
     const partial = [
@@ -94,6 +96,11 @@ test("model-specific and overage windows remain distinguishable", () => {
     assert.equal(overage.durationMinutes, 10080);
     assert.equal(sonnet.remainingPercent, 39);
     assert.equal(overage.remainingPercent, 50);
+    // Same 10,080-minute duration as the real account-wide weekly window, but
+    // neither model-specific/overage extra is ever the critical window.
+    assert.equal(sonnet.criticalRole, null);
+    assert.equal(overage.criticalRole, null);
+    assert.equal(plain.criticalRole, "weekly");
 });
 test("legacy rejected fixture still caps (NOT-111) and fabricates no capacity", () => {
     const events = parseNdjson(legacyRejectedFixture);

package/bundle/server/dist/capacity/codex-app-server.js

@@ -2,6 +2,8 @@
 //
 // NOT-246: Codex capacity adapter over the official App Server interface
 // (https://developers.openai.com/codex/app-server).
+// NOT-263: semantic deduplication of the aggregate `rateLimits` pair against
+// `rateLimitsByLimitId` buckets, plus persisted-row reconciliation.
 //
 // Read-only account operation: the client performs the initialization
 // handshake, then a single `account/rateLimits/read`, and optionally records
@@ -16,6 +18,12 @@
 // Parsing is tolerant (camelCase/snake_case, epoch-second/ms or ISO resets)
 // because only the canonical names above are contractual.
 //
+// When the aggregate primary/secondary pair exactly mirrors one detailed
+// bucket's pair (same used scale, duration, and reset — never the display
+// label alone), the aggregate aliases collapse and the detailed identity
+// wins, so each logical window renders once. Genuinely distinct buckets stay
+// visible even when they share a duration.
+//
 // Failure semantics (shared CapacityUnavailableReason enum only):
 // - App Server unavailable / unauthenticated / timeout -> `missing`
 //   (supported surface, no snapshot recorded). The exact cause stays
@@ -141,8 +149,33 @@ function windowReadingFromEntry(entry, identity, observedAt) {
         resetAt: normalizeCodexResetsAt(w.resetsAt ?? w.resets_at ?? w.resetAt ?? w.reset_at),
         observedAt,
         source: "supported_protocol",
+        criticalRole: identity.criticalRole ?? null,
     };
 }
+/**
+ * Semantic window equality for dedup: same used scale and value, same
+ * duration, same normalized reset. Display labels (`5H`/`1W`) are never
+ * compared — two genuinely distinct buckets may share a duration.
+ */
+export function codexWindowValuesEqual(a, b) {
+    const aPercent = a.usedPercent ?? null;
+    const bPercent = b.usedPercent ?? null;
+    if (aPercent !== null || bPercent !== null) {
+        if (aPercent === null || bPercent === null || aPercent !== bPercent)
+            return false;
+    }
+    else {
+        const aFraction = a.usedFraction ?? null;
+        const bFraction = b.usedFraction ?? null;
+        if (aFraction === null || bFraction === null || aFraction !== bFraction)
+            return false;
+    }
+    if ((a.durationMinutes ?? null) !== (b.durationMinutes ?? null))
+        return false;
+    if ((a.resetAt ?? null) !== (b.resetAt ?? null))
+        return false;
+    return true;
+}
 function nonEmptyString(value) {
     return typeof value === "string" && value.length > 0 ? value : null;
 }
@@ -162,20 +195,34 @@ function nonEmptyString(value) {
  * and whose label is the bucket's `limitName`. A bucket without nested
  * windows still parses as one legacy flat window so older servers keep
  * working.
+ *
+ * Deduplication (NOT-263): when the aggregate `primary`/`secondary` pair
+ * exactly mirrors one detailed bucket's pair (same used scale, duration,
+ * and reset), the aggregate aliases collapse and the detailed identity wins
+ * — each logical window is reported once. The comparison is semantic, never
+ * label-based, so genuinely distinct buckets sharing a duration stay
+ * visible; a partial overlap (only one sub-window matches) never collapses.
  */
 export function codexRateLimitsToReadings(payload, observedAt = new Date().toISOString()) {
     if (!payload || typeof payload !== "object")
         return null;
     const p = payload;
-    const out = [];
+    const aggregate = [];
     const primary = p.rateLimits;
     if (primary && typeof primary === "object") {
         for (const [name, entry] of Object.entries(primary)) {
-            const reading = windowReadingFromEntry(entry, { windowKey: `codex_rate_limit_${sanitizeKeySegment(name)}`, providerBucket: name }, observedAt);
+            // The `rateLimits` aggregate is, by construction, the account-wide
+            // summary — its `primary`/`secondary` entries are the critical 5H/1W
+            // pair whenever present; any other key the provider might add here is
+            // not part of that identity.
+            const criticalRole = name === "primary" ? "five_hour" : name === "secondary" ? "weekly" : null;
+            const reading = windowReadingFromEntry(entry, { windowKey: `codex_rate_limit_${sanitizeKeySegment(name)}`, providerBucket: name, criticalRole }, observedAt);
             if (reading)
-                out.push(reading);
+                aggregate.push(reading);
         }
     }
+    const buckets = new Map();
+    const flat = [];
     const byId = p.rateLimitsByLimitId ?? p.rate_limits_by_limit_id;
     if (byId && typeof byId === "object") {
         for (const [mapKey, bucket] of Object.entries(byId)) {
@@ -185,6 +232,7 @@ export function codexRateLimitsToReadings(payload, observedAt = new Date().toISO
             const limitId = nonEmptyString(b.limitId) ?? nonEmptyString(b.limit_id) ?? mapKey;
             const limitName = nonEmptyString(b.limitName) ?? nonEmptyString(b.limit_name) ?? nonEmptyString(b.name);
             let nested = false;
+            const pair = {};
             for (const sub of ["primary", "secondary"]) {
                 const entry = b[sub];
                 if (!entry || typeof entry !== "object")
@@ -196,20 +244,47 @@ export function codexRateLimitsToReadings(payload, observedAt = new Date().toISO
                     labelOverride: limitName,
                 }, observedAt);
                 if (reading)
-                    out.push(reading);
+                    pair[sub] = reading;
             }
-            if (!nested) {
+            if (nested) {
+                buckets.set(limitId, pair);
+            }
+            else {
                 const reading = windowReadingFromEntry(bucket, {
                     windowKey: `codex_limit_${sanitizeKeySegment(limitId)}`,
                     providerBucket: limitId,
                     labelOverride: limitName,
                 }, observedAt);
                 if (reading)
-                    out.push(reading);
+                    flat.push(reading);
             }
         }
     }
-    return out.length > 0 ? { windows: out } : null;
+    const collapsedAggregateKeys = [];
+    const aggPrimary = aggregate.find((w) => w.windowKey === "codex_rate_limit_primary");
+    const aggSecondary = aggregate.find((w) => w.windowKey === "codex_rate_limit_secondary");
+    if (aggPrimary && aggSecondary) {
+        for (const pair of buckets.values()) {
+            if (pair.primary &&
+                pair.secondary &&
+                codexWindowValuesEqual(aggPrimary, pair.primary) &&
+                codexWindowValuesEqual(aggSecondary, pair.secondary)) {
+                collapsedAggregateKeys.push(aggPrimary.windowKey, aggSecondary.windowKey);
+                // The surviving detailed pair now stands in for the aggregate it
+                // absorbed — it IS the account-wide identity, so it inherits the
+                // aggregate's criticalRole rather than reporting as non-critical.
+                pair.primary = { ...pair.primary, criticalRole: "five_hour" };
+                pair.secondary = { ...pair.secondary, criticalRole: "weekly" };
+                break;
+            }
+        }
+    }
+    const out = [
+        ...aggregate.filter((w) => !collapsedAggregateKeys.includes(w.windowKey)),
+        ...[...buckets.values()].flatMap((pair) => [pair.primary, pair.secondary].filter((w) => w !== undefined)),
+        ...flat,
+    ];
+    return out.length > 0 ? { windows: out, collapsedAggregateKeys } : null;
 }
 export function codexCapacityTimeoutMs() {
     const raw = process.env.AGENT_DEALER_CODEX_CAPACITY_TIMEOUT_MS;
@@ -434,7 +509,7 @@ function unavailableResult(nowMs, reason) {
         reason,
         observedAt: new Date(nowMs).toISOString(),
     };
-    return { runtime: CODEX_RUNTIME, windows: [], unavailable: [reading] };
+    return { runtime: CODEX_RUNTIME, windows: [], unavailable: [reading], collapsedAggregateKeys: [] };
 }
 /**
  * Operator-safe failure log: the static kind only, never server text, tokens,
@@ -516,7 +591,12 @@ export async function readCodexAppServerCapacity(opts = {}) {
         logFailure("malformed");
         return unavailableResult(nowMs, "unparsable");
     }
-    return { runtime: CODEX_RUNTIME, windows, unavailable };
+    return {
+        runtime: CODEX_RUNTIME,
+        windows,
+        unavailable,
+        collapsedAggregateKeys: parsed.collapsedAggregateKeys,
+    };
 }
 /** Live Codex adapter for the shared capacity service (runtime `codex_local`). */
 export function createCodexAppServerAdapter(opts = {}) {
@@ -530,17 +610,27 @@ export function createCodexAppServerAdapter(opts = {}) {
  * Bounded refresh: run the live adapter and ingest into normalized snapshots.
  * Reuses the shared ingest path; failures persist as N/A windows, never as
  * health rows. Imported lazily to keep the adapter module free of DB binds.
+ *
+ * A successful read deletes the failure sentinel plus any aggregate alias
+ * keys the fresh payload collapsed (NOT-263): per-window upserts never
+ * delete siblings, so without this the obsolete `codex_rate_limit_*`
+ * duplicates from older versions would linger next to the surviving
+ * detailed rows indefinitely.
  */
 export async function refreshCodexCapacityFromAppServer(opts = {}) {
     const { ingestAdapterResult, getRuntimeCapacitySnapshot } = await import("./service.js");
     const nowMs = opts.nowMs ?? Date.now();
     const result = await readCodexAppServerCapacity({ ...opts, nowMs });
     await ingestAdapterResult(result);
+    const obsolete = [...result.collapsedAggregateKeys];
     if (result.windows.length > 0) {
         // A successful read supersedes the failure sentinel: without this the
         // N/A row lingers next to fresh windows until its own TTL expires.
+        obsolete.push(SENTINEL_WINDOW_KEY);
+    }
+    if (obsolete.length > 0) {
         const { deleteCapacitySnapshots } = await import("../repository/runtime-capacity.js");
-        deleteCapacitySnapshots(CODEX_RUNTIME, [SENTINEL_WINDOW_KEY]);
+        deleteCapacitySnapshots(CODEX_RUNTIME, obsolete);
     }
     return getRuntimeCapacitySnapshot(nowMs);
 }

package/bundle/server/dist/capacity/codex-app-server.test.js

@@ -6,16 +6,19 @@
 // `rateLimitsByLimitId` buckets stay distinguishable, failure modes map to
 // explicit N/A reasons without touching runtime health, and the recorded
 // protocol traffic proves the client never starts a model turn.
+// NOT-263: an aggregate pair mirroring one detailed bucket collapses to the
+// detailed identity (one 5H + one weekly window); distinct buckets stay
+// visible and refreshes delete obsolete duplicate rows.
 import { test, before } from "node:test";
 import assert from "node:assert/strict";
 import fs from "node:fs";
 import os from "node:os";
 import path from "node:path";
 process.env.AGENT_DEALER_HOME = fs.mkdtempSync(path.join(os.tmpdir(), "dealer-codex-cap-"));
-import { assertReadOnlyMethod, CODEX_CLIENT_VERSION, codexRateLimitsToReadings, createCodexAppServerAdapter, normalizeCodexResetsAt, readCodexAppServerCapacity, readCodexRateLimits, refreshCodexCapacityFromAppServer, refreshCodexCapacityIfStale, } from "./codex-app-server.js";
+import { assertReadOnlyMethod, CODEX_CLIENT_VERSION, codexRateLimitsToReadings, codexWindowValuesEqual, createCodexAppServerAdapter, normalizeCodexResetsAt, readCodexAppServerCapacity, readCodexRateLimits, refreshCodexCapacityFromAppServer, refreshCodexCapacityIfStale, } from "./codex-app-server.js";
 import { normalizeAdapterWindow } from "./adapter.js";
 const { migrate } = await import("../db/index.js");
-const { clearAllCapacitySnapshots, listCapacitySnapshots } = await import("../repository/runtime-capacity.js");
+const { clearAllCapacitySnapshots, listCapacitySnapshots, recordCapacitySnapshots } = await import("../repository/runtime-capacity.js");
 const { createAgent } = await import("../repository/agents.js");
 const { clearAllRuntimeAvailability, runtimeAvailability, } = await import("../repository/runtime-availability.js");
 const { refreshCapacityFromAdapters } = await import("./service.js");
@@ -55,10 +58,13 @@ test("rateLimits windows keep identity, percent, duration, and reset", () => {
     assert.equal(primary.durationMinutes, 300);
     assert.equal(primary.usedPercent, 40);
     assert.equal(primary.resetAt, new Date((Math.floor(now / 1000) + 7200) * 1000).toISOString());
+    assert.equal(primary.criticalRole, "five_hour", "the rateLimits aggregate primary is always the critical 5H window");
     const normalized = normalizeAdapterWindow("codex_local", primary, now);
     assert.equal(normalized.displayLabel, "5H");
     assert.equal(normalized.remainingPercent, 60);
+    assert.equal(normalized.criticalRole, "five_hour");
     const secondary = parsed.windows.find((w) => w.providerBucket === "secondary");
+    assert.equal(secondary.criticalRole, "weekly", "the rateLimits aggregate secondary is always the critical 1W window");
     assert.equal(normalizeAdapterWindow("codex_local", secondary, now).displayLabel, "1W");
     assert.equal(normalizeAdapterWindow("codex_local", secondary, now).remainingPercent, 87.5);
 });
@@ -82,6 +88,7 @@ test("rateLimitsByLimitId buckets never overwrite each other or rateLimits", ()
     });
     assert.ok(parsed);
     assert.equal(parsed.windows.length, 5);
+    assert.deepEqual(parsed.collapsedAggregateKeys, []);
     const keys = parsed.windows.map((w) => w.windowKey);
     assert.equal(new Set(keys).size, 5);
     assert.ok(keys.includes("codex_rate_limit_primary"));
@@ -93,6 +100,11 @@ test("rateLimitsByLimitId buckets never overwrite each other or rateLimits", ()
     assert.equal(aPrimary.providerBucket, "team_a/primary");
     assert.equal(aPrimary.providerLabel, "Team A");
     assert.equal(aPrimary.usedPercent, 70);
+    // No secondary aggregate half at all: no collapse comparison runs, so the
+    // detailed team buckets are never promoted to critical.
+    assert.equal(aPrimary.criticalRole, null);
+    assert.equal(parsed.windows.find((w) => w.windowKey === "codex_limit_team_b_primary").criticalRole, null);
+    assert.equal(parsed.windows.find((w) => w.windowKey === "codex_rate_limit_primary").criticalRole, "five_hour");
 });
 test("nested bucket windows keep per-limit identity when limitId is only the map key", () => {
     const parsed = codexRateLimitsToReadings({
@@ -118,6 +130,127 @@ test("flat legacy buckets without nested windows still parse", () => {
     assert.equal(parsed.windows[0].windowKey, "codex_limit_flat_bucket");
     assert.equal(parsed.windows[0].providerBucket, "flat_bucket");
 });
+test("aggregate pair mirroring one bucket collapses to the detailed identity", () => {
+    const now = Date.now();
+    const observedAt = new Date(now).toISOString();
+    const primary = { usedPercent: 9, windowDurationMins: 300, resetsAt: now + 2 * 3600_000 };
+    const secondary = { usedPercent: 2, windowDurationMins: 10080, resetsAt: now + 3 * 86400_000 };
+    const parsed = codexRateLimitsToReadings({
+        rateLimits: {
+            primary: { ...primary },
+            secondary: { ...secondary },
+        },
+        rateLimitsByLimitId: {
+            codex: {
+                limitId: "codex",
+                limitName: "Codex quota",
+                primary: { ...primary },
+                secondary: { ...secondary },
+            },
+        },
+    }, observedAt);
+    assert.ok(parsed);
+    assert.deepEqual(parsed.windows.map((w) => w.windowKey).sort(), ["codex_limit_codex_primary", "codex_limit_codex_secondary"]);
+    assert.deepEqual(parsed.collapsedAggregateKeys, [
+        "codex_rate_limit_primary",
+        "codex_rate_limit_secondary",
+    ]);
+    const labels = parsed.windows.map((w) => normalizeAdapterWindow("codex_local", w, now));
+    assert.deepEqual(labels.map((w) => w.displayLabel).sort(), ["1W", "5H"]);
+    assert.deepEqual(labels.map((w) => w.remainingPercent).sort((a, b) => (a ?? 0) - (b ?? 0)), [91, 98]);
+    // The surviving detailed pair inherits the collapsed aggregate's identity
+    // rather than reporting as an ordinary non-critical bucket — this is what
+    // lets the client find it without re-deriving "which limit id is real".
+    const primaryOut = parsed.windows.find((w) => w.windowKey === "codex_limit_codex_primary");
+    const secondaryOut = parsed.windows.find((w) => w.windowKey === "codex_limit_codex_secondary");
+    assert.equal(primaryOut.criticalRole, "five_hour");
+    assert.equal(secondaryOut.criticalRole, "weekly");
+});
+test("NOT-264 finding: a second, distinct detailed pair alongside the collapsed one is never tagged critical", () => {
+    // The realistic Codex shape a PR review caught: the aggregate collapses
+    // into "main" (identical values) while an unrelated "extra" pair also
+    // exists. The client can no longer tell these apart by name, but the
+    // server can, by value equality against the aggregate before it is
+    // discarded — so exactly the true survivor gets tagged, never both, never
+    // neither.
+    const now = Date.now();
+    const primary = { usedPercent: 9, windowDurationMins: 300, resetsAt: now + 2 * 3600_000 };
+    const secondary = { usedPercent: 2, windowDurationMins: 10080, resetsAt: now + 3 * 86400_000 };
+    const parsed = codexRateLimitsToReadings({
+        rateLimits: { primary: { ...primary }, secondary: { ...secondary } },
+        rateLimitsByLimitId: {
+            main: { limitId: "main", primary: { ...primary }, secondary: { ...secondary } },
+            extra: {
+                limitId: "extra",
+                primary: { usedPercent: 70, windowDurationMins: 300, resetsAt: now + 3600_000 },
+                secondary: { usedPercent: 55, windowDurationMins: 10080, resetsAt: now + 4 * 86400_000 },
+            },
+        },
+    }, new Date(now).toISOString());
+    assert.ok(parsed);
+    assert.deepEqual(parsed.collapsedAggregateKeys, ["codex_rate_limit_primary", "codex_rate_limit_secondary"]);
+    const byKey = new Map(parsed.windows.map((w) => [w.windowKey, w]));
+    assert.equal(byKey.get("codex_limit_main_primary").criticalRole, "five_hour");
+    assert.equal(byKey.get("codex_limit_main_secondary").criticalRole, "weekly");
+    assert.equal(byKey.get("codex_limit_extra_primary").criticalRole, null);
+    assert.equal(byKey.get("codex_limit_extra_secondary").criticalRole, null);
+});
+test("partial overlap never collapses: only one sub-window matches", () => {
+    const now = Date.now();
+    const parsed = codexRateLimitsToReadings({
+        rateLimits: {
+            primary: { usedPercent: 70, windowDurationMins: 300, resetsAt: now + 3600_000 },
+            secondary: { usedPercent: 12, windowDurationMins: 10080, resetsAt: now + 3 * 86400_000 },
+        },
+        rateLimitsByLimitId: {
+            main: {
+                limitId: "main",
+                primary: { usedPercent: 70, windowDurationMins: 300, resetsAt: now + 3600_000 },
+                secondary: { usedPercent: 5, windowDurationMins: 10080, resetsAt: now + 6 * 86400_000 },
+            },
+        },
+    }, new Date(now).toISOString());
+    assert.ok(parsed);
+    assert.equal(parsed.windows.length, 4);
+    assert.deepEqual(parsed.collapsedAggregateKeys, []);
+});
+test("distinct buckets sharing a duration stay independently visible", () => {
+    const now = Date.now();
+    const parsed = codexRateLimitsToReadings({
+        rateLimitsByLimitId: {
+            team_a: {
+                limitId: "team_a",
+                primary: { usedPercent: 70, windowDurationMins: 300, resetsAt: now + 3600_000 },
+            },
+            team_b: {
+                limitId: "team_b",
+                primary: { usedPercent: 90, windowDurationMins: 300, resetsAt: now + 1800_000 },
+            },
+        },
+    }, new Date(now).toISOString());
+    assert.ok(parsed);
+    assert.equal(parsed.windows.length, 2);
+    const labels = parsed.windows.map((w) => normalizeAdapterWindow("codex_local", w, now));
+    assert.ok(labels.every((w) => w.displayLabel === "5H"), "same label, both still visible");
+    assert.deepEqual(parsed.collapsedAggregateKeys, []);
+    // No rateLimits aggregate at all here, so neither same-duration bucket is
+    // ever tagged critical — an honest "we don't know" rather than a guess.
+    assert.ok(parsed.windows.every((w) => w.criticalRole === null));
+});
+test("window equality compares values, never display labels", () => {
+    const base = {
+        windowKey: "k",
+        providerBucket: "b",
+        providerLabel: "l",
+        source: "supported_protocol",
+    };
+    const a = { ...base, usedPercent: 10, durationMinutes: 300, resetAt: "2026-09-20T12:00:00.000Z" };
+    assert.ok(codexWindowValuesEqual(a, { ...a, windowKey: "other", providerLabel: "5H" }));
+    assert.ok(!codexWindowValuesEqual(a, { ...a, usedPercent: 11 }));
+    assert.ok(!codexWindowValuesEqual(a, { ...a, durationMinutes: 10080 }));
+    assert.ok(!codexWindowValuesEqual(a, { ...a, resetAt: "2026-09-21T12:00:00.000Z" }));
+    assert.ok(!codexWindowValuesEqual(a, { ...a, usedPercent: undefined, usedFraction: 0.1 }));
+});
 test("resetsAt accepts epoch seconds, ms, and ISO; rejects garbage", () => {
     const iso = "2026-09-20T12:00:00.000Z";
     const epochSec = Math.floor(Date.parse(iso) / 1000);
@@ -186,6 +319,66 @@ test("initialize handshake carries a versioned client identity", async () => {
     assert.equal(init.params?.clientInfo?.name, "agent-dealer");
     assert.equal(init.params?.clientInfo?.version, CODEX_CLIENT_VERSION);
 });
+test("mirrored aggregate pair collapses end to end: one 5H, one weekly, distinct bucket kept", async () => {
+    clearAllCapacitySnapshots();
+    const { opts } = fakeOpts("mirror");
+    const result = await readCodexAppServerCapacity(opts);
+    assert.deepEqual(result.collapsedAggregateKeys, [
+        "codex_rate_limit_primary",
+        "codex_rate_limit_secondary",
+    ]);
+    const snap = await refreshCodexCapacityFromAppServer(opts);
+    const codex = snap.runtimes.find((r) => r.runtime === "codex_local");
+    assert.ok(codex, "codex_local entry exists");
+    assert.equal(codex.unavailableReason, null);
+    const keys = codex.windows.map((w) => w.windowKey).sort();
+    assert.deepEqual(keys, [
+        "codex_limit_extra_primary",
+        "codex_limit_extra_secondary",
+        "codex_limit_main_primary",
+        "codex_limit_main_secondary",
+    ]);
+    const mainPrimary = codex.windows.find((w) => w.windowKey === "codex_limit_main_primary");
+    assert.equal(mainPrimary.displayLabel, "5H");
+    assert.equal(mainPrimary.remainingPercent, 30);
+    const mainSecondary = codex.windows.find((w) => w.windowKey === "codex_limit_main_secondary");
+    assert.equal(mainSecondary.displayLabel, "1W");
+    assert.equal(mainSecondary.remainingPercent, 95);
+});
+test("refresh deletes obsolete duplicate aliases persisted by older versions", async () => {
+    clearAllCapacitySnapshots();
+    const seedNow = Date.now();
+    const seedObserved = new Date(seedNow).toISOString();
+    // Legacy shape: aggregate aliases plus the detailed rows describing the
+    // same logical pair (what pre-NOT-263 versions persisted).
+    function seedReading(windowKey, providerBucket, durationMinutes) {
+        return normalizeAdapterWindow("codex_local", {
+            windowKey,
+            providerBucket,
+            durationMinutes,
+            providerLabel: providerBucket,
+            usedValue: 9,
+            usedUnit: "percent",
+            usedPercent: 9,
+            resetAt: new Date(seedNow + 2 * 3600_000).toISOString(),
+            observedAt: seedObserved,
+            source: "supported_protocol",
+        }, seedNow);
+    }
+    recordCapacitySnapshots("codex_local", [
+        seedReading("codex_rate_limit_primary", "primary", 300),
+        seedReading("codex_rate_limit_secondary", "secondary", 10080),
+        seedReading("codex_limit_main_primary", "main/primary", 300),
+        seedReading("codex_limit_main_secondary", "main/secondary", 10080),
+    ]);
+    assert.equal(listCapacitySnapshots("codex_local").length, 4);
+    const { opts } = fakeOpts("mirror");
+    await refreshCodexCapacityFromAppServer(opts);
+    const keys = listCapacitySnapshots("codex_local").map((w) => w.windowKey);
+    assert.ok(!keys.some((k) => k.startsWith("codex_rate_limit_")), `obsolete aliases deleted, got ${keys}`);
+    assert.ok(keys.includes("codex_limit_main_primary"), `detailed identity kept, got ${keys}`);
+    assert.ok(keys.includes("codex_limit_main_secondary"), `detailed identity kept, got ${keys}`);
+});
 test("a successful refresh clears a previously stored failure sentinel", async () => {
     clearAllCapacitySnapshots();
     const crashed = fakeOpts("crash");