agent-relay-server 0.75.0 → 0.77.0

package/src/db/migrations.ts

@@ -602,13 +602,103 @@ export function applyMigrations(): void {
   getDb().run(`
     CREATE TABLE IF NOT EXISTS quota_snapshots (
       id INTEGER PRIMARY KEY AUTOINCREMENT,
-      agent_id TEXT NOT NULL REFERENCES agents(id) ON DELETE CASCADE,
+      provider TEXT NOT NULL,
+      account_key TEXT NOT NULL,
+      agent_id TEXT REFERENCES agents(id) ON DELETE SET NULL,
       windows TEXT NOT NULL,
       source TEXT NOT NULL,
       quota_state TEXT NOT NULL,
       captured_at INTEGER NOT NULL
     )
   `);
+  const quotaSnapshotCols = (getDb().query("PRAGMA table_info(quota_snapshots)").all() as Array<{ name: string }>).map((col) => col.name);
+  if (!quotaSnapshotCols.includes("provider") || !quotaSnapshotCols.includes("account_key")) {
+    getDb().run("ALTER TABLE quota_snapshots RENAME TO quota_snapshots_legacy_agent");
+    getDb().run(`
+      CREATE TABLE quota_snapshots (
+        id INTEGER PRIMARY KEY AUTOINCREMENT,
+        provider TEXT NOT NULL,
+        account_key TEXT NOT NULL,
+        agent_id TEXT REFERENCES agents(id) ON DELETE SET NULL,
+        windows TEXT NOT NULL,
+        source TEXT NOT NULL,
+        quota_state TEXT NOT NULL,
+        captured_at INTEGER NOT NULL
+      )
+    `);
+    getDb().run(`
+      INSERT INTO quota_snapshots (id, provider, account_key, agent_id, windows, source, quota_state, captured_at)
+      SELECT
+        qs.id,
+        CASE
+          WHEN json_extract(a.meta, '$.provider') IS NOT NULL THEN lower(json_extract(a.meta, '$.provider'))
+          WHEN a.tags LIKE '%"codex"%' OR lower(a.id) LIKE '%codex%' OR lower(a.name) LIKE '%codex%' THEN 'codex'
+          ELSE 'claude'
+        END,
+        coalesce(
+          nullif(json_extract(a.meta, '$.accountKey'), ''),
+          nullif(json_extract(a.meta, '$.accountId'), ''),
+          nullif(json_extract(a.meta, '$.orgId'), ''),
+          'host:' || coalesce(a.machine, a.rig, 'unknown')
+        ),
+        qs.agent_id,
+        qs.windows,
+        qs.source,
+        qs.quota_state,
+        qs.captured_at
+      FROM quota_snapshots_legacy_agent qs
+      LEFT JOIN agents a ON a.id = qs.agent_id
+    `);
+    getDb().run("DROP TABLE quota_snapshots_legacy_agent");
+  }
+  getDb().run(`
+    CREATE TABLE IF NOT EXISTS provider_quotas (
+      provider TEXT NOT NULL,
+      account_key TEXT NOT NULL,
+      quota_state TEXT,
+      source_agent_ids TEXT NOT NULL DEFAULT '[]',
+      last_updated_at INTEGER,
+      last_attempt_at INTEGER NOT NULL,
+      last_error TEXT,
+      updated_at INTEGER NOT NULL,
+      created_at INTEGER NOT NULL,
+      PRIMARY KEY (provider, account_key)
+    )
+  `);
+  getDb().run(`
+    INSERT INTO provider_quotas (
+      provider, account_key, quota_state, source_agent_ids, last_updated_at,
+      last_attempt_at, last_error, updated_at, created_at
+    )
+    SELECT
+      CASE
+        WHEN json_extract(meta, '$.provider') IS NOT NULL THEN lower(json_extract(meta, '$.provider'))
+        WHEN tags LIKE '%"codex"%' OR lower(id) LIKE '%codex%' OR lower(name) LIKE '%codex%' THEN 'codex'
+        ELSE 'claude'
+      END AS provider,
+      coalesce(
+        nullif(json_extract(meta, '$.accountKey'), ''),
+        nullif(json_extract(meta, '$.accountId'), ''),
+        nullif(json_extract(meta, '$.orgId'), ''),
+        'host:' || coalesce(machine, rig, 'unknown')
+      ) AS account_key,
+      quota_state,
+      json_array(id),
+      coalesce(json_extract(quota_state, '$.updatedAt'), last_seen),
+      coalesce(json_extract(quota_state, '$.updatedAt'), last_seen),
+      NULL,
+      last_seen,
+      created_at
+    FROM agents
+    WHERE quota_state IS NOT NULL
+    ON CONFLICT(provider, account_key) DO UPDATE SET
+      quota_state = excluded.quota_state,
+      source_agent_ids = excluded.source_agent_ids,
+      last_updated_at = max(coalesce(provider_quotas.last_updated_at, 0), coalesce(excluded.last_updated_at, 0)),
+      last_attempt_at = max(provider_quotas.last_attempt_at, excluded.last_attempt_at),
+      updated_at = max(provider_quotas.updated_at, excluded.updated_at)
+  `);
+  getDb().run("CREATE INDEX IF NOT EXISTS idx_quota_snapshots_account_time ON quota_snapshots(provider, account_key, captured_at DESC)");
   getDb().run("CREATE INDEX IF NOT EXISTS idx_quota_snapshots_agent_time ON quota_snapshots(agent_id, captured_at DESC)");
 
   getDb().run(`

package/src/db/provider-quotas.ts

@@ -0,0 +1,220 @@
+import { DAY_MS } from "../config";
+import { parseJson } from "../utils";
+import { getDb } from "./connection.ts";
+import { parseStringArray } from "./shared.ts";
+import type { AgentCard, ProviderQuotaError, ProviderQuotaMatrix, ProviderQuotaRecord, ProviderQuotaSnapshot, ProviderQuotaUpdateInput, QuotaState } from "../types";
+
+const PROVIDER_QUOTA_STALE_AFTER_MS = 10 * 60_000;
+
+type ProviderQuotaRow = {
+  provider: string;
+  account_key: string;
+  quota_state?: string | null;
+  source_agent_ids?: string | null;
+  last_updated_at?: number | null;
+  last_attempt_at: number;
+  last_error?: string | null;
+};
+
+type ProviderQuotaSnapshotRow = {
+  provider: string;
+  account_key: string;
+  agent_id?: string | null;
+  quota_state: string;
+  captured_at: number;
+};
+
+function cleanKey(value: string): string {
+  return value.trim();
+}
+
+function normalizeProvider(value: string): string {
+  return cleanKey(value).toLowerCase();
+}
+
+function normalizeSourceAgentIds(value: unknown): string[] {
+  return [...new Set(parseStringArray(typeof value === "string" ? value : JSON.stringify(value ?? [])).filter(Boolean))];
+}
+
+function quotaFingerprint(quota: QuotaState): string {
+  return JSON.stringify(quota.windows.map((window) => ({
+    name: window.name,
+    unit: window.unit,
+    utilization: window.utilization,
+  })).sort((a, b) => a.name.localeCompare(b.name) || a.unit.localeCompare(b.unit)));
+}
+
+function rowToSnapshot(row: ProviderQuotaSnapshotRow): ProviderQuotaSnapshot {
+  return {
+    provider: row.provider,
+    accountKey: row.account_key,
+    capturedAt: row.captured_at,
+    ...(row.agent_id ? { sourceAgentId: row.agent_id } : {}),
+    quota: parseJson<QuotaState>(row.quota_state, { windows: [], source: "probe", updatedAt: row.captured_at }),
+  };
+}
+
+function rowToRecord(row: ProviderQuotaRow, history: ProviderQuotaSnapshot[], now: number): ProviderQuotaRecord {
+  const lastError = parseJson<ProviderQuotaError | undefined>(row.last_error, undefined);
+  const lastUpdatedAt = row.last_updated_at ?? undefined;
+  return {
+    provider: row.provider,
+    accountKey: row.account_key,
+    ...(row.quota_state ? { quota: parseJson<QuotaState>(row.quota_state, { windows: [], source: "probe", updatedAt: lastUpdatedAt ?? row.last_attempt_at }) } : {}),
+    sourceAgentIds: normalizeSourceAgentIds(row.source_agent_ids),
+    ...(lastUpdatedAt !== undefined ? { lastUpdatedAt } : {}),
+    lastAttemptAt: row.last_attempt_at,
+    ...(lastError ? { lastError } : {}),
+    stale: lastUpdatedAt === undefined || now - lastUpdatedAt > PROVIDER_QUOTA_STALE_AFTER_MS,
+    history,
+  };
+}
+
+function latestSnapshotFingerprint(provider: string, accountKey: string): string | undefined {
+  const row = getDb().query(`
+    SELECT quota_state FROM quota_snapshots
+    WHERE provider = ? AND account_key = ?
+    ORDER BY captured_at DESC, id DESC
+    LIMIT 1
+  `).get(provider, accountKey) as { quota_state: string } | undefined;
+  return row ? quotaFingerprint(parseJson<QuotaState>(row.quota_state, { windows: [], source: "probe", updatedAt: 0 })) : undefined;
+}
+
+function providerQuotaIdentityForAgent(agent: Pick<AgentCard, "id" | "name" | "tags" | "machine" | "rig" | "meta">): { provider: string; accountKey: string } {
+  const meta = agent.meta ?? {};
+  const provider = typeof meta.provider === "string" && meta.provider.trim()
+    ? meta.provider
+    : agent.tags.includes("codex") || agent.id.toLowerCase().includes("codex") || agent.name.toLowerCase().includes("codex")
+      ? "codex"
+      : "claude";
+  const accountKey = typeof meta.accountKey === "string" && meta.accountKey.trim()
+    ? meta.accountKey
+    : typeof meta.accountId === "string" && meta.accountId.trim()
+      ? meta.accountId
+      : typeof meta.orgId === "string" && meta.orgId.trim()
+        ? meta.orgId
+        : `host:${agent.machine ?? agent.rig ?? "unknown"}`;
+  return { provider: normalizeProvider(provider), accountKey: cleanKey(accountKey) };
+}
+
+export function upsertProviderQuota(input: ProviderQuotaUpdateInput, now = Date.now()): ProviderQuotaRecord {
+  const provider = normalizeProvider(input.provider);
+  const accountKey = cleanKey(input.accountKey);
+  if (!provider) throw new Error("provider required");
+  if (!accountKey) throw new Error("accountKey required");
+  const existing = getDb().query("SELECT * FROM provider_quotas WHERE provider = ? AND account_key = ?").get(provider, accountKey) as ProviderQuotaRow | undefined;
+  const sourceAgentIds = normalizeSourceAgentIds(existing?.source_agent_ids);
+  if (input.sourceAgentId && !sourceAgentIds.includes(input.sourceAgentId)) sourceAgentIds.push(input.sourceAgentId);
+  const lastUpdatedAt = input.quota ? input.quota.updatedAt : existing?.last_updated_at ?? undefined;
+  const lastAttemptAt = input.lastAttemptAt ?? input.quota?.updatedAt ?? now;
+  const lastError = input.lastError === undefined
+    ? input.quota ? null : existing?.last_error ?? null
+    : input.lastError;
+  const quotaState = input.quota ? JSON.stringify(input.quota) : existing?.quota_state ?? null;
+
+  getDb().query(`
+    INSERT INTO provider_quotas (
+      provider, account_key, quota_state, source_agent_ids, last_updated_at,
+      last_attempt_at, last_error, updated_at, created_at
+    )
+    VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?)
+    ON CONFLICT(provider, account_key) DO UPDATE SET
+      quota_state = excluded.quota_state,
+      source_agent_ids = excluded.source_agent_ids,
+      last_updated_at = excluded.last_updated_at,
+      last_attempt_at = excluded.last_attempt_at,
+      last_error = excluded.last_error,
+      updated_at = excluded.updated_at
+  `).run(
+    provider,
+    accountKey,
+    quotaState,
+    JSON.stringify(sourceAgentIds),
+    lastUpdatedAt ?? null,
+    lastAttemptAt,
+    lastError ? JSON.stringify(lastError) : null,
+    now,
+    now,
+  );
+
+  if (input.quota && latestSnapshotFingerprint(provider, accountKey) !== quotaFingerprint(input.quota)) {
+    recordProviderQuotaSnapshot({ provider, accountKey, quota: input.quota, sourceAgentId: input.sourceAgentId }, now);
+  }
+
+  return listProviderQuotas({ provider, accountKey, historyLimit: 24, now }).quotas[0]!;
+}
+
+function recordProviderQuotaSnapshot(input: { provider: string; accountKey: string; quota: QuotaState; sourceAgentId?: string }, now: number): void {
+  const sourceAgentId = input.sourceAgentId && getDb().query("SELECT 1 FROM agents WHERE id = ?").get(input.sourceAgentId)
+    ? input.sourceAgentId
+    : undefined;
+  getDb().query(`
+    INSERT INTO quota_snapshots (provider, account_key, agent_id, windows, source, quota_state, captured_at)
+    VALUES (?, ?, ?, ?, ?, ?, ?)
+  `).run(
+    input.provider,
+    input.accountKey,
+    sourceAgentId ?? null,
+    JSON.stringify(input.quota.windows),
+    input.quota.source,
+    JSON.stringify(input.quota),
+    now,
+  );
+  pruneProviderQuotaSnapshots(input.provider, input.accountKey, now - DAY_MS);
+}
+
+function pruneProviderQuotaSnapshots(provider?: string, accountKey?: string, olderThan = Date.now() - DAY_MS): number {
+  const result = provider && accountKey
+    ? getDb().query("DELETE FROM quota_snapshots WHERE provider = ? AND account_key = ? AND captured_at < ?").run(provider, accountKey, olderThan)
+    : getDb().query("DELETE FROM quota_snapshots WHERE captured_at < ?").run(olderThan);
+  return result.changes;
+}
+
+function listProviderQuotaSnapshots(provider: string, accountKey: string, options: { since?: number; limit?: number } = {}): ProviderQuotaSnapshot[] {
+  const limit = Math.max(1, Math.min(options.limit ?? 288, 1000));
+  const params: any[] = [normalizeProvider(provider), cleanKey(accountKey)];
+  let sql = "SELECT * FROM quota_snapshots WHERE provider = ? AND account_key = ?";
+  if (options.since !== undefined) {
+    sql += " AND captured_at >= ?";
+    params.push(options.since);
+  }
+  sql += " ORDER BY captured_at ASC, id ASC LIMIT ?";
+  params.push(limit);
+  return (getDb().query(sql).all(...params) as ProviderQuotaSnapshotRow[]).map(rowToSnapshot);
+}
+
+export function listAgentQuotaSnapshotsFromProviderStore(agent: AgentCard, options: { since?: number; limit?: number } = {}) {
+  const identity = providerQuotaIdentityForAgent(agent);
+  return listProviderQuotaSnapshots(identity.provider, identity.accountKey, options).map((snapshot) => ({
+    agentId: agent.id,
+    capturedAt: snapshot.capturedAt,
+    windows: snapshot.quota.windows,
+    source: snapshot.quota.source,
+    updatedAt: snapshot.quota.updatedAt,
+  }));
+}
+
+export function listProviderQuotas(options: { provider?: string; accountKey?: string; since?: number; historyLimit?: number; now?: number } = {}): ProviderQuotaMatrix {
+  const historyLimit = Math.max(0, Math.min(options.historyLimit ?? 24, 288));
+  const now = options.now ?? Date.now();
+  const params: any[] = [];
+  let sql = "SELECT * FROM provider_quotas WHERE 1=1";
+  if (options.provider) {
+    sql += " AND provider = ?";
+    params.push(normalizeProvider(options.provider));
+  }
+  if (options.accountKey) {
+    sql += " AND account_key = ?";
+    params.push(cleanKey(options.accountKey));
+  }
+  sql += " ORDER BY provider ASC, account_key ASC";
+  const rows = getDb().query(sql).all(...params) as ProviderQuotaRow[];
+  return {
+    staleAfterMs: PROVIDER_QUOTA_STALE_AFTER_MS,
+    quotas: rows.map((row) => rowToRecord(
+      row,
+      historyLimit > 0 ? listProviderQuotaSnapshots(row.provider, row.account_key, { since: options.since, limit: historyLimit }) : [],
+      now,
+    )),
+  };
+}

package/src/db/schema.ts

@@ -292,7 +292,9 @@ export function initDb(path: string = "agent-relay.db"): Database {
 
     CREATE TABLE IF NOT EXISTS quota_snapshots (
       id INTEGER PRIMARY KEY AUTOINCREMENT,
-      agent_id TEXT NOT NULL REFERENCES agents(id) ON DELETE CASCADE,
+      provider TEXT NOT NULL,
+      account_key TEXT NOT NULL,
+      agent_id TEXT REFERENCES agents(id) ON DELETE SET NULL,
       windows TEXT NOT NULL,
       source TEXT NOT NULL,
       quota_state TEXT NOT NULL,
@@ -300,6 +302,19 @@ export function initDb(path: string = "agent-relay.db"): Database {
     );
     CREATE INDEX IF NOT EXISTS idx_quota_snapshots_agent_time ON quota_snapshots(agent_id, captured_at DESC);
 
+    CREATE TABLE IF NOT EXISTS provider_quotas (
+      provider TEXT NOT NULL,
+      account_key TEXT NOT NULL,
+      quota_state TEXT,
+      source_agent_ids TEXT NOT NULL DEFAULT '[]',
+      last_updated_at INTEGER,
+      last_attempt_at INTEGER NOT NULL,
+      last_error TEXT,
+      updated_at INTEGER NOT NULL,
+      created_at INTEGER NOT NULL,
+      PRIMARY KEY (provider, account_key)
+    );
+
     CREATE TABLE IF NOT EXISTS agent_continuations (
       agent_id TEXT PRIMARY KEY REFERENCES agents(id) ON DELETE CASCADE,
       objective TEXT NOT NULL,

package/src/lifecycle-context-pressure.ts

@@ -0,0 +1,98 @@
+import { createCommand } from "./commands-db";
+import { getAgent, listAgents } from "./db";
+import { getManagedAgentState } from "./config-store";
+import { emitCommandEvent } from "./command-events";
+import { handleContextPressure } from "./context-advisory";
+import type { AgentCard, Command, SpawnPolicy } from "./types";
+
+interface LifecycleContextPressureInput {
+  policies: SpawnPolicy[];
+  now: () => number;
+  hasActiveCommand: (target: string, type: string) => boolean;
+}
+
+interface CompactAgentInput {
+  agent: AgentCard;
+  reason: string;
+  policyName?: string;
+  alwaysReload?: string[];
+  now: () => number;
+  hasActiveCommand: (target: string, type: string) => boolean;
+}
+
+export function reconcileLifecycleContextPressure(input: LifecycleContextPressureInput): Set<string> {
+  const byPolicy = new Map(input.policies.map((policy) => [policy.name, policy]));
+  const candidates = new Map<string, { agent: AgentCard; policy?: SpawnPolicy }>();
+
+  for (const policy of input.policies) {
+    const state = getManagedAgentState(policy.name);
+    if (state?.status !== "running" || !state.agentId) continue;
+    const agent = getAgent(state.agentId);
+    if (!agent || agent.status === "offline") continue;
+    candidates.set(agent.id, { agent, policy });
+  }
+
+  for (const agent of listAgents()) {
+    if (!isLiveRunnerManagedAgent(agent) || candidates.has(agent.id)) continue;
+    const policyName = typeof agent.meta?.policyName === "string" ? agent.meta.policyName : undefined;
+    candidates.set(agent.id, { agent, policy: policyName ? byPolicy.get(policyName) : undefined });
+  }
+
+  const handled = new Set<string>();
+  for (const { agent, policy } of candidates.values()) {
+    if (handleContextPressure({
+      agent,
+      now: input.now,
+      hasActiveCommand: input.hasActiveCommand,
+      compact: (reason) => requestAgentCompact({
+        agent,
+        reason,
+        policyName: policy?.name,
+        alwaysReload: alwaysReloadTags(agent.tags),
+        now: input.now,
+        hasActiveCommand: input.hasActiveCommand,
+      }),
+    })) {
+      handled.add(agent.id);
+    }
+  }
+  return handled;
+}
+
+export function requestAgentCompact(input: CompactAgentInput): Command | null {
+  if (input.hasActiveCommand(input.agent.id, "agent.compact")) return null;
+  const spawnRequestId = typeof input.agent.meta?.spawnRequestId === "string" ? input.agent.meta.spawnRequestId : undefined;
+  const sessionName = typeof input.agent.meta?.sessionName === "string" ? input.agent.meta.sessionName : undefined;
+  const tmuxSession = typeof input.agent.meta?.tmuxSession === "string" ? input.agent.meta.tmuxSession : undefined;
+  const command = createCommand({
+    type: "agent.compact",
+    source: "system",
+    target: input.agent.id,
+    correlationId: spawnRequestId,
+    params: {
+      action: "compact",
+      agentId: input.agent.id,
+      ...(input.policyName ? { policyName: input.policyName } : {}),
+      ...(spawnRequestId ? { spawnRequestId } : {}),
+      ...(sessionName ? { sessionName } : {}),
+      ...(tmuxSession ? { tmuxSession } : {}),
+      reason: input.reason,
+      memory: input.alwaysReload?.length ? { alwaysReload: input.alwaysReload } : undefined,
+      requestedBy: "lifecycle-manager",
+      requestedAt: input.now(),
+    },
+  });
+  emitCommandEvent(command, "command.requested");
+  return command;
+}
+
+export function alwaysReloadTags(tags: string[]): string[] {
+  return tags
+    .filter((tag) => tag.startsWith("memory-reload:"))
+    .map((tag) => tag.slice("memory-reload:".length).trim())
+    .filter(Boolean);
+}
+
+function isLiveRunnerManagedAgent(agent: AgentCard): boolean {
+  return agent.meta?.runnerManaged === true && agent.status !== "offline" && agent.status !== "stale";
+}

package/src/lifecycle-manager.ts

@@ -9,7 +9,7 @@ import {
   upsertManagedAgentState,
 } from "./config-store";
 import { emitRelayEvent } from "./events";
-import { handleContextPressure } from "./context-advisory";
+import { alwaysReloadTags, reconcileLifecycleContextPressure, requestAgentCompact } from "./lifecycle-context-pressure";
 import { markManagedAgentRunning, emitManagedState } from "./services/managed-running";
 import { authContextFromSystem } from "./services/auth-context";
 import { emitCommandEvent } from "./command-events";
@@ -66,8 +66,10 @@ export class LifecycleManager {
   }
 
   async tick(): Promise<void> {
-    for (const policy of this.loadPolicies()) {
-      this.reconcilePolicy(policy);
+    const policies = this.loadPolicies();
+    const contextHandled = this.reconcileContextPressure(policies);
+    for (const policy of policies) {
+      this.reconcilePolicy(policy, contextHandled);
     }
   }
 
@@ -175,7 +177,7 @@ export class LifecycleManager {
   onConfigChanged(namespace: string, key: string): void {
     if (namespace !== "spawn-policy") return;
     const policy = this.loadPolicies().find((item) => item.name === key);
-    if (policy) this.reconcilePolicy(policy);
+    if (policy) this.reconcilePolicy(policy, this.reconcileContextPressure([policy]));
   }
 
   onRelayUpdated(_newVersion: string): void {
@@ -309,7 +311,7 @@ export class LifecycleManager {
     return command;
   }
 
-  private reconcilePolicy(policy: SpawnPolicy): void {
+  private reconcilePolicy(policy: SpawnPolicy, contextHandled = new Set<string>()): void {
     const state = getManagedAgentState(policy.name);
     const enabled = policy.enabled !== false;
     if (!state) {
@@ -354,9 +356,16 @@ export class LifecycleManager {
         this.stopAgent(policy, true, "idle-timeout");
         return;
       }
-      if (handleContextPressure({ agent, now: this.now, hasActiveCommand: (target, type) => this.hasActiveCommand(target, type), compact: (reason) => this.compactAgent(policy, agent.id, reason, alwaysReloadTags(agent.tags)) })) return;
+      if (contextHandled.has(agent.id)) return;
       if (this.shouldCompact(agent)) {
-        this.compactAgent(policy, agent.id, "context-threshold", alwaysReloadTags(agent.tags));
+        requestAgentCompact({
+          agent,
+          reason: "context-threshold",
+          policyName: policy.name,
+          alwaysReload: alwaysReloadTags(agent.tags),
+          now: this.now,
+          hasActiveCommand: (target, type) => this.hasActiveCommand(target, type),
+        });
         return;
       }
       if (policy.scheduledDailyRestart && this.dailyRestartDue(policy, state) && this.isIdle(policy, state, 3600)) {
@@ -384,24 +393,12 @@ export class LifecycleManager {
     }
   }
 
-  private compactAgent(policy: SpawnPolicy, agentId: string, reason: string, alwaysReload: string[] = []): Command | null {
-    if (this.hasActiveCommand(agentId, "agent.compact")) return null;
-    const command = createCommand({
-      type: "agent.compact",
-      source: "system",
-      target: agentId,
-      params: {
-        action: "compact",
-        agentId,
-        policyName: policy.name,
-        reason,
-        memory: alwaysReload.length ? { alwaysReload } : undefined,
-        requestedBy: "lifecycle-manager",
-        requestedAt: this.now(),
-      },
+  private reconcileContextPressure(policies: SpawnPolicy[]): Set<string> {
+    return reconcileLifecycleContextPressure({
+      policies,
+      now: this.now,
+      hasActiveCommand: (target, type) => this.hasActiveCommand(target, type),
     });
-    emitCommandEvent(command, "command.requested");
-    return command;
   }
 
   private ensureStoppedState(policy: SpawnPolicy): void {
@@ -654,10 +651,3 @@ function agentTerminalFailureMessage(agent: ReturnType<typeof getAgent> | null):
 function isPlainRecord(value: unknown): value is Record<string, unknown> {
   return Boolean(value) && typeof value === "object" && !Array.isArray(value);
 }
-
-function alwaysReloadTags(tags: string[]): string[] {
-  return tags
-    .filter((tag) => tag.startsWith("memory-reload:"))
-    .map((tag) => tag.slice("memory-reload:".length).trim())
-    .filter(Boolean);
-}

package/src/quota.ts

@@ -1,5 +1,5 @@
 import { isRecord } from "agent-relay-sdk";
-import type { QuotaState, QuotaWindowName, QuotaSource, QuotaUnit } from "./types";
+import type { ProviderQuotaError, QuotaState, QuotaWindowName, QuotaSource, QuotaUnit } from "./types";
 
 const QUOTA_SOURCES = new Set<QuotaSource>(["header", "probe", "ingest"]);
 const QUOTA_UNITS = new Set<QuotaUnit>(["tokens", "requests", "%"]);
@@ -38,3 +38,16 @@ export function quotaStateFromUnknown(value: unknown): QuotaState | undefined {
   if (windows.length === 0) return undefined;
   return { windows, source, updatedAt };
 }
+
+export function providerQuotaErrorFromUnknown(value: unknown): ProviderQuotaError | undefined {
+  if (!isRecord(value)) return undefined;
+  const type = typeof value.type === "string" && value.type.trim() ? value.type.trim() : undefined;
+  const message = typeof value.message === "string" && value.message.trim() ? value.message.trim() : undefined;
+  if (!type || !message) return undefined;
+  const retryAfterMs = numberValue(value.retryAfterMs);
+  return {
+    type,
+    message,
+    ...(retryAfterMs !== undefined && retryAfterMs >= 0 ? { retryAfterMs } : {}),
+  };
+}

package/src/routes/index.ts

@@ -5,6 +5,7 @@ import { deleteAgentTerminalSession, postAgentAction, postAgentPermissionDecisio
 import { deleteArtifactById, getArtifactById, getArtifactContent, getArtifacts, headArtifactContent, postArtifact } from "./artifacts";
 import { deleteAutomationById, getAutomationById, getAutomationRuns, getAutomations, patchAutomation, postAutomation, postAutomationRun } from "./automations";
 import { deleteCommandById, deleteProviderModelRoute, getProviderConfigRoute, getProviderConfigsRoute, getProvidersRoute, patchProviderModelRoute, postProviderConfigTestRoute, putProviderConfigRoute, putProviderModelRoute } from "./provider-config";
+import { getProviderQuotasRoute, postProviderQuotaRoute } from "./provider-quotas";
 import { deleteConfigKey, getConfigKey, getConfigKeyHistory, getConfigNamespace, putConfigKey } from "./config";
 import { deleteInboxDraftRoute, getChatHistoryImportsRoute, getInboxStateRoute, patchInboxThreadState, postChatHistoryImportRoute, putInboxDraft } from "./inbox";
 import { deleteMemoryRoute, getMemories, getMemoryBrokerInfo, getMemoryById, getMemoryStats, patchMemory, postMemory, postMemoryInject, postMemorySearch } from "./memory";
@@ -87,6 +88,8 @@ const routes: Route[] = [
   route("GET", "/api/agents", getAgents),
   route("GET", "/api/agents/find", findAgents),
   route("POST", "/api/route", postRouteAdvice),
+  route("GET", "/api/provider-quotas", getProviderQuotasRoute),
+  route("POST", "/api/provider-quotas", postProviderQuotaRoute),
   route("GET", "/api/agents/spawn/directories", getHostDirectories),
   route("GET", "/api/agents/:id/chat", getAgentChatHistory),
   route("GET", "/api/agents/:id/context-snapshots", getAgentContextSnapshots),

package/src/routes/provider-quotas.ts

@@ -0,0 +1,48 @@
+import { isRecord } from "agent-relay-sdk";
+import { listProviderQuotas, upsertProviderQuota } from "../db";
+import { quotaStateFromUnknown, providerQuotaErrorFromUnknown } from "../quota";
+import { cleanString } from "../validation";
+import { error, json, parseBody, parseQueryInt, type Handler } from "./_shared";
+import type { ProviderQuotaUpdateInput } from "../types";
+
+function cleanProviderQuotaUpdate(body: unknown): ProviderQuotaUpdateInput | string {
+  if (!isRecord(body)) return "JSON object body required";
+  const provider = cleanString(body.provider, "provider", { required: true, max: 80 })!;
+  const accountKey = cleanString(body.accountKey, "accountKey", { required: true, max: 240 })!;
+  const quota = quotaStateFromUnknown(body.quota);
+  const lastAttemptAt = typeof body.lastAttemptAt === "number" && Number.isFinite(body.lastAttemptAt) ? body.lastAttemptAt : undefined;
+  const lastError = body.lastError === null ? null : providerQuotaErrorFromUnknown(body.lastError);
+  if (!quota && lastError === undefined) return "quota or lastError required";
+  const sourceAgentId = cleanString(body.sourceAgentId, "sourceAgentId", { max: 200 });
+  return {
+    provider,
+    accountKey,
+    ...(quota ? { quota } : {}),
+    ...(lastAttemptAt !== undefined ? { lastAttemptAt } : {}),
+    ...(lastError !== undefined ? { lastError } : {}),
+    ...(sourceAgentId ? { sourceAgentId } : {}),
+  };
+}
+
+export const getProviderQuotasRoute: Handler = (req) => {
+  const url = new URL(req.url);
+  const historyLimit = parseQueryInt(url.searchParams.get("historyLimit") ?? url.searchParams.get("limit"), { min: 0, max: 288, clamp: true });
+  if (Number.isNaN(historyLimit)) return error("historyLimit must be an integer between 0 and 288");
+  const sinceRaw = url.searchParams.get("since");
+  const since = sinceRaw ? Number(sinceRaw) : undefined;
+  if (sinceRaw && (!Number.isFinite(since) || since! < 0)) return error("since must be a positive timestamp");
+  return json(listProviderQuotas({
+    provider: url.searchParams.get("provider") ?? undefined,
+    accountKey: url.searchParams.get("accountKey") ?? undefined,
+    since,
+    historyLimit: historyLimit ?? undefined,
+  }));
+};
+
+export const postProviderQuotaRoute: Handler = async (req) => {
+  const parsed = await parseBody<unknown>(req);
+  if (!parsed.ok) return error(parsed.error, parsed.status);
+  const input = cleanProviderQuotaUpdate(parsed.body);
+  if (typeof input === "string") return error(input);
+  return json(upsertProviderQuota(input), 201);
+};

package/src/security.ts

@@ -274,6 +274,7 @@ export function requiredComponentScopeFor(method: string, pathname: string): str
   // Spawn requires the spawn capability (see requiredScopeFor above) — matches the in-service gate.
   if (pathname === "/api/agents/spawn") return "command:spawn";
   if (pathname.startsWith("/api/agents")) return method === "GET" ? "agent:read" : "agent:write";
+  if (pathname === "/api/provider-quotas") return method === "GET" ? "agent:read" : "quota:write";
   if (pathname.startsWith("/api/messages") || pathname.startsWith("/api/inbox")) return method === "GET" ? "message:read" : "message:send";
   if (pathname.startsWith("/api/agent-profiles")) return method === "GET" ? "agent:read" : "agent:write";
   if (pathname.startsWith("/api/tasks")) return method === "GET" ? "task:read" : "task:write";