agent-dealer 1.2.1 → 1.2.3

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),
     };
 }
 /**
@@ -303,20 +320,21 @@ export function extractClaudeCapacityFromEvents(events, nowMs = Date.now(), fall
     return { runtime: CLAUDE_RUNTIME, windows: [...byKey.values()], unavailable: [] };
 }
 /**
- * Persist naturally observed unified windows as normalized capacity
- * snapshots (per-window upserts — siblings not in this observation are left
- * untouched, and a stored row newer than the incoming reading is never
- * overwritten). Returns the number of windows persisted, or null when the
- * runtime is not Claude or no usable windows were observed. Never touches
- * `runtime_availability`.
+ * Persist Claude window readings as normalized capacity snapshots
+ * (per-window upserts — siblings not in this observation are left untouched,
+ * and a stored row newer than the incoming reading is never overwritten).
+ * Shared by session-event ingestion and the local-cache/probe path (NOT-268):
+ * both sources write the same `claude_unified_*` window keys, so the freshest
+ * observation wins per window regardless of which source produced it.
+ * Returns the number of windows persisted, or null when no usable window was
+ * observed. Never touches `runtime_availability`.
  */
-export function recordClaudeCapacityFromEvents(events, runtime, nowMs = Date.now(), fallbackObservedAtMs = nowMs) {
+export function recordClaudeWindowReadings(readings, runtime, nowMs = Date.now()) {
     if (runtime !== CLAUDE_RUNTIME)
         return null;
-    const result = extractClaudeCapacityFromEvents(events, nowMs, fallbackObservedAtMs);
-    if (!result)
+    if (readings.length === 0)
         return null;
-    const normalized = result.windows.map((w) => normalizeAdapterWindow(runtime, w, nowMs));
+    const normalized = readings.map((w) => normalizeAdapterWindow(runtime, w, nowMs));
     const persistable = normalized.filter((n) => n.unavailableReason === null && n.remainingPercent !== null);
     if (persistable.length === 0)
         return null;
@@ -350,9 +368,26 @@ export function recordClaudeCapacityFromEvents(events, runtime, nowMs = Date.now
         source: w.source,
         unavailableReason: w.unavailableReason,
         evidenceRef: w.evidenceRef,
+        criticalRole: w.criticalRole,
     })));
     return fresh.length;
 }
+/**
+ * Persist naturally observed unified windows as normalized capacity
+ * snapshots. Status is irrelevant — allowed events carry the utilization
+ * signal; rejected ones additionally drive NOT-111 elsewhere. Thin wrapper
+ * over `recordClaudeWindowReadings`: per-window upserts, newer-wins, never
+ * touches `runtime_availability`. Returns the number of windows persisted,
+ * or null when the runtime is not Claude or no usable windows were observed.
+ */
+export function recordClaudeCapacityFromEvents(events, runtime, nowMs = Date.now(), fallbackObservedAtMs = nowMs) {
+    if (runtime !== CLAUDE_RUNTIME)
+        return null;
+    const result = extractClaudeCapacityFromEvents(events, nowMs, fallbackObservedAtMs);
+    if (!result)
+        return null;
+    return recordClaudeWindowReadings(result.windows, runtime, nowMs);
+}
 /**
  * File variant for session-end ingestion from a Dealer-managed Claude log.
  * `fallbackObservedAtMs` is the session's spawn start. Returns the persisted

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);