@tangle-network/agent-app 0.45.26 → 0.45.27

package/dist/spend/index.js

@@ -0,0 +1,196 @@
+import {
+  DEFAULT_CEILING_TOLERANCE_MS,
+  SPEND_CHECKS,
+  chargeNanoUsd,
+  computeExpectedCeiling,
+  formatSpendReport,
+  isCharge,
+  parseSandboxGroupKey,
+  parseSettlementReference,
+  reconcileSpend,
+  settlementSandboxId,
+  spendReportToJson
+} from "../chunk-NEJ7OMQS.js";
+
+// src/spend/store.ts
+function foldSpendBoxRecord(record, patch) {
+  let lastActivityAt = record.lastActivityAt;
+  let stoppedAt = record.stoppedAt;
+  let openDetachedRunIds = record.openDetachedRunIds;
+  if (patch.observedActivityAt !== void 0) {
+    lastActivityAt = Math.max(lastActivityAt, patch.observedActivityAt);
+    if (stoppedAt !== null && patch.observedActivityAt > stoppedAt) stoppedAt = null;
+  }
+  if (patch.openDetachedRunAdd !== void 0 && !openDetachedRunIds.includes(patch.openDetachedRunAdd)) {
+    openDetachedRunIds = [...openDetachedRunIds, patch.openDetachedRunAdd];
+  }
+  if (patch.openDetachedRunRemove !== void 0) {
+    openDetachedRunIds = openDetachedRunIds.filter((id) => id !== patch.openDetachedRunRemove);
+  }
+  if (patch.stoppedAt !== void 0) {
+    stoppedAt = patch.stoppedAt >= lastActivityAt ? patch.stoppedAt : stoppedAt;
+  }
+  return {
+    ...record,
+    lastActivityAt,
+    stoppedAt,
+    openDetachedRunIds,
+    // Set-once: a deleted sandbox id never comes back, so a second observation
+    // is a duplicate delivery, not a second deletion.
+    deletedAt: record.deletedAt ?? patch.deletedAt ?? null
+  };
+}
+function createInMemorySpendLedgerStore() {
+  const rows = /* @__PURE__ */ new Map();
+  return {
+    async load(sandboxId) {
+      const row = rows.get(sandboxId);
+      return row ? structuredClone(row) : null;
+    },
+    async insert(record) {
+      const stored = structuredClone(record);
+      rows.set(record.sandboxId, stored);
+      return structuredClone(stored);
+    },
+    async update(sandboxId, patch) {
+      const current = rows.get(sandboxId);
+      if (!current) return null;
+      const next = foldSpendBoxRecord(current, patch);
+      rows.set(sandboxId, next);
+      return structuredClone(next);
+    },
+    records() {
+      return [...rows.values()].map((row) => structuredClone(row));
+    },
+    put(record) {
+      rows.set(record.sandboxId, structuredClone(record));
+    }
+  };
+}
+function createSpendLedger(options) {
+  const { store } = options;
+  const clock = options.now ?? Date.now;
+  return {
+    async observeSandbox(input) {
+      const at = input.at ?? clock();
+      const existing = await store.load(input.sandboxId);
+      if (existing) {
+        const updated = await store.update(input.sandboxId, { observedActivityAt: at });
+        return updated ?? existing;
+      }
+      return await store.insert(
+        {
+          sandboxId: input.sandboxId,
+          workspaceId: input.workspaceId,
+          createdAt: at,
+          idleTimeoutSeconds: input.idleTimeoutSeconds,
+          maxLifetimeSeconds: input.maxLifetimeSeconds ?? null,
+          lastActivityAt: at,
+          openDetachedRunIds: [],
+          stoppedAt: null,
+          deletedAt: null
+        },
+        options.extras
+      );
+    },
+    async recordActivity(sandboxId, at) {
+      return await store.update(sandboxId, { observedActivityAt: at ?? clock() });
+    },
+    async recordDetachedRunStarted(sandboxId, runId, at) {
+      return await store.update(sandboxId, {
+        observedActivityAt: at ?? clock(),
+        openDetachedRunAdd: runId
+      });
+    },
+    async recordDetachedRunEnded(sandboxId, runId, at) {
+      return await store.update(sandboxId, {
+        observedActivityAt: at ?? clock(),
+        openDetachedRunRemove: runId
+      });
+    },
+    async recordStopped(sandboxId, at) {
+      return await store.update(sandboxId, { stoppedAt: at ?? clock() });
+    },
+    async recordDeleted(sandboxId, at) {
+      return await store.update(sandboxId, { deletedAt: at ?? clock() });
+    }
+  };
+}
+
+// src/spend/budget.ts
+var ComputeBudgetExceededError = class extends Error {
+  workspaceId;
+  limitNanoUsd;
+  settledNanoUsd;
+  overageNanoUsd;
+  constructor(refusal) {
+    super(
+      `Compute budget exceeded for workspace ${refusal.workspaceId}: $${(refusal.settledNanoUsd / 1e9).toFixed(2)} settled against a cap of $${(refusal.limitNanoUsd / 1e9).toFixed(2)} (over by $${(refusal.overageNanoUsd / 1e9).toFixed(2)}). No sandbox was provisioned. Raise the cap or reconcile the spend before retrying.`
+    );
+    this.name = "ComputeBudgetExceededError";
+    this.workspaceId = refusal.workspaceId;
+    this.limitNanoUsd = refusal.limitNanoUsd;
+    this.settledNanoUsd = refusal.settledNanoUsd;
+    this.overageNanoUsd = refusal.overageNanoUsd;
+  }
+};
+async function assertComputeBudget(budget, workspaceId) {
+  if (!budget) return;
+  const settledNanoUsd = await budget.settledNanoUsd(workspaceId);
+  if (settledNanoUsd < budget.limitNanoUsd) return;
+  const refusal = {
+    workspaceId,
+    limitNanoUsd: budget.limitNanoUsd,
+    settledNanoUsd,
+    overageNanoUsd: settledNanoUsd - budget.limitNanoUsd,
+    at: (budget.now ?? Date.now)()
+  };
+  budget.onRefusal?.(refusal);
+  throw new ComputeBudgetExceededError(refusal);
+}
+function createSandboxSpendHooks(options) {
+  const { ledger, budget, onError } = options;
+  return {
+    async beforeProvision(input) {
+      await assertComputeBudget(budget, input.workspaceId);
+    },
+    async onProvisioned(observation) {
+      if (!ledger) return;
+      try {
+        await ledger.observeSandbox({
+          sandboxId: observation.sandboxId,
+          workspaceId: observation.workspaceId,
+          idleTimeoutSeconds: observation.idleTimeoutSeconds,
+          maxLifetimeSeconds: observation.maxLifetimeSeconds ?? null,
+          at: observation.at
+        });
+      } catch (err) {
+        onError?.(err);
+      }
+    },
+    onActivity(input) {
+      if (!ledger) return;
+      void ledger.recordActivity(input.sandboxId, input.at).catch((err) => onError?.(err));
+    }
+  };
+}
+export {
+  ComputeBudgetExceededError,
+  DEFAULT_CEILING_TOLERANCE_MS,
+  SPEND_CHECKS,
+  assertComputeBudget,
+  chargeNanoUsd,
+  computeExpectedCeiling,
+  createInMemorySpendLedgerStore,
+  createSandboxSpendHooks,
+  createSpendLedger,
+  foldSpendBoxRecord,
+  formatSpendReport,
+  isCharge,
+  parseSandboxGroupKey,
+  parseSettlementReference,
+  reconcileSpend,
+  settlementSandboxId,
+  spendReportToJson
+};
+//# sourceMappingURL=index.js.map

package/dist/spend/index.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../../src/spend/store.ts","../../src/spend/budget.ts"],"sourcesContent":["import type { SpendBoxPatch, SpendBoxRecord } from './types'\n\n/**\n * Persistence seam for the expectation ledger — the product implements it over\n * its own tables.\n *\n * Deliberately NOT compare-and-set, unlike `MissionStorePort`. A mission has one\n * serialized owner and a lost write corrupts a state machine; a box record is a\n * MONOTONIC FOLD (activity takes a max, a detached-run id joins or leaves a set,\n * delete is set-once) so concurrent writers converge no matter what order they\n * land in. The worst a lost race can do here is leave `lastActivityAt` behind\n * the truth — which makes the derived ceiling TIGHTER, so the failure mode is a\n * false alarm a human dismisses, never a missed charge. That asymmetry is the\n * whole reason the fold is shaped this way.\n *\n * `update` returns null when the row does not exist, never a throw.\n */\nexport interface SpendLedgerStorePort {\n  load(sandboxId: string): Promise<SpendBoxRecord | null>\n  /** `extras` are the opaque product-column values — write them in the SAME\n   *  statement as the record, or ignore them if the table has no extra columns. */\n  insert(record: SpendBoxRecord, extras?: Record<string, unknown>): Promise<SpendBoxRecord>\n  update(sandboxId: string, patch: SpendBoxPatch): Promise<SpendBoxRecord | null>\n}\n\n/**\n * Apply one fold step. Exported so a SQL implementation and an in-memory one\n * reach the same record, and so a product can unit-test its own store against\n * the canonical answer.\n *\n * The two rules worth stating out loud:\n *\n * - `observedActivityAt` only ever moves `lastActivityAt` FORWARD. A replayed\n *   or out-of-order event cannot rewind the ceiling.\n * - activity later than a recorded `stoppedAt` CLEARS the stop. A box that\n *   worked after the product thought it stopped is running again, and keeping\n *   the stale stop would make the ceiling too tight — inventing an over-ceiling\n *   finding out of the product's own bookkeeping rather than the platform's.\n */\nexport function foldSpendBoxRecord(record: SpendBoxRecord, patch: SpendBoxPatch): SpendBoxRecord {\n  let lastActivityAt = record.lastActivityAt\n  let stoppedAt = record.stoppedAt\n  let openDetachedRunIds = record.openDetachedRunIds\n\n  if (patch.observedActivityAt !== undefined) {\n    lastActivityAt = Math.max(lastActivityAt, patch.observedActivityAt)\n    if (stoppedAt !== null && patch.observedActivityAt > stoppedAt) stoppedAt = null\n  }\n  if (patch.openDetachedRunAdd !== undefined && !openDetachedRunIds.includes(patch.openDetachedRunAdd)) {\n    openDetachedRunIds = [...openDetachedRunIds, patch.openDetachedRunAdd]\n  }\n  if (patch.openDetachedRunRemove !== undefined) {\n    openDetachedRunIds = openDetachedRunIds.filter((id) => id !== patch.openDetachedRunRemove)\n  }\n  if (patch.stoppedAt !== undefined) {\n    // Latest-wins, but never behind observed activity: a stop we are told about\n    // that predates work we watched is not the stop that closed this box.\n    stoppedAt = patch.stoppedAt >= lastActivityAt ? patch.stoppedAt : stoppedAt\n  }\n\n  return {\n    ...record,\n    lastActivityAt,\n    stoppedAt,\n    openDetachedRunIds,\n    // Set-once: a deleted sandbox id never comes back, so a second observation\n    // is a duplicate delivery, not a second deletion.\n    deletedAt: record.deletedAt ?? patch.deletedAt ?? null,\n  }\n}\n\n/** An in-memory store that also lets a test inspect and force state. */\nexport interface InMemorySpendLedgerStore extends SpendLedgerStorePort {\n  /** Every record, insertion order. */\n  records(): SpendBoxRecord[]\n  /** Unguarded direct write — simulates a crash-shaped or platform-seeded row. */\n  put(record: SpendBoxRecord): void\n}\n\n/** Create an in-memory expectation ledger. Production writers use the same port. */\nexport function createInMemorySpendLedgerStore(): InMemorySpendLedgerStore {\n  const rows = new Map<string, SpendBoxRecord>()\n  return {\n    async load(sandboxId) {\n      const row = rows.get(sandboxId)\n      return row ? structuredClone(row) : null\n    },\n    async insert(record) {\n      const stored = structuredClone(record)\n      rows.set(record.sandboxId, stored)\n      return structuredClone(stored)\n    },\n    async update(sandboxId, patch) {\n      const current = rows.get(sandboxId)\n      if (!current) return null\n      const next = foldSpendBoxRecord(current, patch)\n      rows.set(sandboxId, next)\n      return structuredClone(next)\n    },\n    records() {\n      return [...rows.values()].map((row) => structuredClone(row))\n    },\n    put(record) {\n      rows.set(record.sandboxId, structuredClone(record))\n    },\n  }\n}\n\n/** What the product tells the ledger when it first sees a box. */\nexport interface ObserveSandboxInput {\n  readonly sandboxId: string\n  readonly workspaceId: string\n  /** The idle timeout the product asked the platform for, seconds. */\n  readonly idleTimeoutSeconds: number\n  /** The max lifetime the product asked for, seconds, when it asked for one. */\n  readonly maxLifetimeSeconds?: number | null\n  /** Defaults to the ledger's clock. */\n  readonly at?: number\n}\n\nexport interface SpendLedgerOptions {\n  readonly store: SpendLedgerStorePort\n  /** Injectable clock (epoch ms). Default `Date.now`. */\n  readonly now?: () => number\n  /** Product columns written verbatim on every insert. */\n  readonly extras?: Record<string, unknown>\n}\n\n/**\n * The recording half of spend verification: the product's own account of what\n * it asked the platform for.\n *\n * Every method is best-effort from the caller's point of view — a product wires\n * these into paths that must not fail because bookkeeping failed. They still\n * reject on a store error rather than swallowing it, so a caller that wants\n * fire-and-forget says so at the call site (`/sandbox`'s hook does).\n */\nexport interface SpendLedger {\n  /**\n   * Record that a box exists and is billable from now. Inserts on first sight,\n   * and otherwise records activity — reuse and resume are both \"the platform is\n   * charging for this box again\", and the record's own existence is what\n   * distinguishes them, so no caller has to know which happened.\n   */\n  observeSandbox(input: ObserveSandboxInput): Promise<SpendBoxRecord>\n  /** Record that the product saw this box do work. */\n  recordActivity(sandboxId: string, at?: number): Promise<SpendBoxRecord | null>\n  /**\n   * Record that the product handed the platform work it will NOT watch finish.\n   * Until the matching end is recorded, this box's ceiling cannot rest on\n   * observed activity — see `computeExpectedCeiling`.\n   */\n  recordDetachedRunStarted(sandboxId: string, runId: string, at?: number): Promise<SpendBoxRecord | null>\n  /** Record that a detached run was confirmed finished. */\n  recordDetachedRunEnded(sandboxId: string, runId: string, at?: number): Promise<SpendBoxRecord | null>\n  /** Record that the product knows this box stopped. */\n  recordStopped(sandboxId: string, at?: number): Promise<SpendBoxRecord | null>\n  /** Record that the product knows this box was deleted. */\n  recordDeleted(sandboxId: string, at?: number): Promise<SpendBoxRecord | null>\n}\n\n/** Create the recording half over a product-supplied store. */\nexport function createSpendLedger(options: SpendLedgerOptions): SpendLedger {\n  const { store } = options\n  const clock = options.now ?? Date.now\n\n  return {\n    async observeSandbox(input) {\n      const at = input.at ?? clock()\n      const existing = await store.load(input.sandboxId)\n      if (existing) {\n        const updated = await store.update(input.sandboxId, { observedActivityAt: at })\n        return updated ?? existing\n      }\n      return await store.insert(\n        {\n          sandboxId: input.sandboxId,\n          workspaceId: input.workspaceId,\n          createdAt: at,\n          idleTimeoutSeconds: input.idleTimeoutSeconds,\n          maxLifetimeSeconds: input.maxLifetimeSeconds ?? null,\n          lastActivityAt: at,\n          openDetachedRunIds: [],\n          stoppedAt: null,\n          deletedAt: null,\n        },\n        options.extras,\n      )\n    },\n    async recordActivity(sandboxId, at) {\n      return await store.update(sandboxId, { observedActivityAt: at ?? clock() })\n    },\n    async recordDetachedRunStarted(sandboxId, runId, at) {\n      return await store.update(sandboxId, {\n        observedActivityAt: at ?? clock(),\n        openDetachedRunAdd: runId,\n      })\n    },\n    async recordDetachedRunEnded(sandboxId, runId, at) {\n      return await store.update(sandboxId, {\n        observedActivityAt: at ?? clock(),\n        openDetachedRunRemove: runId,\n      })\n    },\n    async recordStopped(sandboxId, at) {\n      return await store.update(sandboxId, { stoppedAt: at ?? clock() })\n    },\n    async recordDeleted(sandboxId, at) {\n      return await store.update(sandboxId, { deletedAt: at ?? clock() })\n    },\n  }\n}\n","import type { SpendLedger } from './store'\n\n/** Why provisioning was refused, with every number the decision used. */\nexport interface ComputeBudgetRefusal {\n  readonly workspaceId: string\n  /** The cap, unsigned nanodollars. */\n  readonly limitNanoUsd: number\n  /** Cumulative settled compute spend for this workspace, unsigned nanodollars. */\n  readonly settledNanoUsd: number\n  /** How far past the cap it already is. */\n  readonly overageNanoUsd: number\n  readonly at: number\n}\n\n/**\n * Provisioning refused because the workspace is already past its compute cap.\n *\n * Correctable by design: every number the decision used is on the error, so a\n * product can render \"this workspace has spent $X of its $Y compute budget\" and\n * an operator can raise the cap or investigate without reading logs.\n *\n * This is the failure mode the module exists to produce. A platform billing\n * defect that used to end in a silent negative balance now ends in provisioning\n * stopping and something loud happening instead.\n */\nexport class ComputeBudgetExceededError extends Error {\n  readonly workspaceId: string\n  readonly limitNanoUsd: number\n  readonly settledNanoUsd: number\n  readonly overageNanoUsd: number\n\n  constructor(refusal: ComputeBudgetRefusal) {\n    super(\n      `Compute budget exceeded for workspace ${refusal.workspaceId}: ` +\n        `$${(refusal.settledNanoUsd / 1_000_000_000).toFixed(2)} settled against a cap of ` +\n        `$${(refusal.limitNanoUsd / 1_000_000_000).toFixed(2)} ` +\n        `(over by $${(refusal.overageNanoUsd / 1_000_000_000).toFixed(2)}). ` +\n        'No sandbox was provisioned. Raise the cap or reconcile the spend before retrying.',\n    )\n    this.name = 'ComputeBudgetExceededError'\n    this.workspaceId = refusal.workspaceId\n    this.limitNanoUsd = refusal.limitNanoUsd\n    this.settledNanoUsd = refusal.settledNanoUsd\n    this.overageNanoUsd = refusal.overageNanoUsd\n  }\n}\n\n/**\n * A per-workspace cap on sandbox compute.\n *\n * `/billing`'s budget primitive caps MODEL keys, and it works because the\n * platform enforces the cap at the key it minted. Sandbox compute has no such\n * key: a box bills the shared company wallet, so nothing upstream refuses. This\n * carries the same shape to the one place a consumer can still act — the moment\n * before it asks for another box.\n *\n * `settledNanoUsd` is a callback rather than a number because the authority is\n * the platform ledger, not this package: the product reads the same rows it\n * hands the reconciler. Cache it if the read is expensive; a cap is a\n * coarse-grained control and a slightly stale total still refuses.\n */\nexport interface ComputeBudget {\n  /** The cap, unsigned nanodollars. */\n  readonly limitNanoUsd: number\n  /** Cumulative settled compute spend for the workspace, unsigned nanodollars. */\n  readonly settledNanoUsd: (workspaceId: string) => Promise<number> | number\n  /**\n   * Called on every refusal, before the error is thrown. This is the alert\n   * seam: a refusal nobody hears is a product that silently stopped working.\n   */\n  readonly onRefusal?: (refusal: ComputeBudgetRefusal) => void\n  /** Injectable clock (epoch ms). Default `Date.now`. */\n  readonly now?: () => number\n}\n\n/**\n * Throw {@link ComputeBudgetExceededError} when the workspace is already past\n * its cap. Returns normally — and reads nothing — when no budget is configured.\n *\n * Deliberately a pre-check against spend ALREADY SETTLED, not a reservation\n * against spend about to happen: settlement lags provisioning by design (the\n * platform's durable settlement queue), so there is no instant at which a\n * consumer could hold an accurate running total. The cap therefore overshoots by\n * at most the unsettled tail, which is bounded by the box's own idle timeout.\n * A cap that refuses one box late is worth far more than one that cannot be\n * implemented honestly.\n */\nexport async function assertComputeBudget(\n  budget: ComputeBudget | undefined,\n  workspaceId: string,\n): Promise<void> {\n  if (!budget) return\n  const settledNanoUsd = await budget.settledNanoUsd(workspaceId)\n  if (settledNanoUsd < budget.limitNanoUsd) return\n\n  const refusal: ComputeBudgetRefusal = {\n    workspaceId,\n    limitNanoUsd: budget.limitNanoUsd,\n    settledNanoUsd,\n    overageNanoUsd: settledNanoUsd - budget.limitNanoUsd,\n    at: (budget.now ?? Date.now)(),\n  }\n  budget.onRefusal?.(refusal)\n  throw new ComputeBudgetExceededError(refusal)\n}\n\n// ── the /sandbox seam ─────────────────────────────────────────────────────────\n\n/**\n * What `/sandbox` reports once a box is provisioned, reused or resumed.\n *\n * Structurally identical to `SandboxProvisionedObservation` in `/sandbox`, and\n * deliberately re-declared rather than imported: `/spend` composes `/sandbox`,\n * so a type import in the other direction would invert the dependency. The two\n * are pinned together by a compile-time assignment in this module's tests.\n */\nexport interface SpendProvisionObservation {\n  readonly workspaceId: string\n  readonly userId?: string\n  readonly sandboxId: string\n  readonly boxKey?: string | undefined\n  readonly idleTimeoutSeconds: number\n  readonly maxLifetimeSeconds?: number | undefined\n  readonly at: number\n}\n\n/**\n * The optional seam `EnsureWorkspaceSandboxOptions.spend` and the turn\n * primitives' `spend` option both accept. One object, wired in both places.\n */\nexport interface SandboxSpendSeam {\n  beforeProvision?(input: { workspaceId: string; userId?: string }): Promise<void> | void\n  onProvisioned?(observation: SpendProvisionObservation): Promise<void> | void\n  /** Synchronous by contract — it sits on the turn path. See `createSandboxSpendHooks`. */\n  onActivity?(input: { sandboxId: string; at: number }): void\n}\n\nexport interface SandboxSpendHooksOptions {\n  /** Records box lifecycle. Omit to run the budget guard alone. */\n  readonly ledger?: SpendLedger\n  /** Refuses provisioning past a cap. Omit to record alone. */\n  readonly budget?: ComputeBudget\n  /**\n   * Called when RECORDING fails. Recording is best-effort — a bookkeeping\n   * failure must never take down the provisioning it is bookkeeping — so this\n   * is the only place such a failure is visible. A refusal is NOT routed here;\n   * refusals throw, by design.\n   */\n  readonly onError?: (error: unknown) => void\n}\n\n/**\n * Build the object to hand `ensureWorkspaceSandbox`'s `spend` option.\n *\n * Wiring it is the entire adoption cost: one field, and the product's boxes are\n * both budget-capped and recorded.\n */\nexport function createSandboxSpendHooks(options: SandboxSpendHooksOptions): SandboxSpendSeam {\n  const { ledger, budget, onError } = options\n  return {\n    async beforeProvision(input) {\n      await assertComputeBudget(budget, input.workspaceId)\n    },\n    async onProvisioned(observation) {\n      if (!ledger) return\n      try {\n        await ledger.observeSandbox({\n          sandboxId: observation.sandboxId,\n          workspaceId: observation.workspaceId,\n          idleTimeoutSeconds: observation.idleTimeoutSeconds,\n          maxLifetimeSeconds: observation.maxLifetimeSeconds ?? null,\n          at: observation.at,\n        })\n      } catch (err) {\n        onError?.(err)\n      }\n    },\n    onActivity(input) {\n      if (!ledger) return\n      // The turn path calls this synchronously and does not await it, so the\n      // promise is settled here rather than escaping as an unhandled rejection.\n      // Recording activity is a monotonic max, so a write that lands late — or\n      // out of order against another turn's — still converges.\n      void ledger.recordActivity(input.sandboxId, input.at).catch((err: unknown) => onError?.(err))\n    },\n  }\n}\n"],"mappings":"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","names":[]}

package/dist/stream/index.js

@@ -4,20 +4,6 @@ import {
   normalizeClientTurnId,
   resolveChatTurn
 } from "../chunk-JEZJ6HTF.js";
-import {
-  DEFAULT_RUNNING_TURN_LEASE_MS,
-  DEFAULT_RUNNING_TURN_RENEW_INTERVAL_MS,
-  TURN_EVENTS_MIGRATION_SQL,
-  TURN_STATUS_SCOPE_MIGRATION_SQL,
-  coalesceChatStreamEvents,
-  coalesceDeltas,
-  createBufferedTurnTap,
-  createD1TurnEventStore,
-  createMemoryTurnEventStore,
-  pumpBufferedTurn,
-  replayTurnEvents,
-  stampReplaySeq
-} from "../chunk-SDEADFHZ.js";
 import {
   MISSING_TOOL_TERMINAL_ERROR,
   MISSING_TOOL_TERMINAL_REASON,
@@ -42,6 +28,20 @@ import {
 } from "../chunk-XZ27ENOZ.js";
 import "../chunk-M3K2HVQD.js";
 import "../chunk-YJMCRXQQ.js";
+import {
+  DEFAULT_RUNNING_TURN_LEASE_MS,
+  DEFAULT_RUNNING_TURN_RENEW_INTERVAL_MS,
+  TURN_EVENTS_MIGRATION_SQL,
+  TURN_STATUS_SCOPE_MIGRATION_SQL,
+  coalesceChatStreamEvents,
+  coalesceDeltas,
+  createBufferedTurnTap,
+  createD1TurnEventStore,
+  createMemoryTurnEventStore,
+  pumpBufferedTurn,
+  replayTurnEvents,
+  stampReplaySeq
+} from "../chunk-SDEADFHZ.js";
 export {
   DEFAULT_RUNNING_TURN_LEASE_MS,
   DEFAULT_RUNNING_TURN_RENEW_INTERVAL_MS,

package/dist/teams/index.js

@@ -1,3 +1,12 @@
+import {
+  INVITATION_EXPIRY_DAYS,
+  generateInvitationToken,
+  getInvitationExpiresAt,
+  inviteUrlForToken,
+  normalizeInvitationEmail,
+  parseInvitationPermission,
+  renderInvitationEmail
+} from "../chunk-2DRYTJHI.js";
 import {
   generateInviteToken,
   isInviteTokenShape,
@@ -18,15 +27,6 @@ import {
   workspaceRoleToCollaborationAccess,
   workspaceRoleToSandboxRole
 } from "../chunk-6XIAPIW6.js";
-import {
-  INVITATION_EXPIRY_DAYS,
-  generateInvitationToken,
-  getInvitationExpiresAt,
-  inviteUrlForToken,
-  normalizeInvitationEmail,
-  parseInvitationPermission,
-  renderInvitationEmail
-} from "../chunk-2DRYTJHI.js";
 export {
   ASSIGNABLE_WORKSPACE_ROLES,
   INVITATION_EXPIRY_DAYS,

package/dist/teams/invitations-api.js

@@ -1,10 +1,3 @@
-import {
-  SeatLimitError
-} from "../chunk-MEUNTJL5.js";
-import "../chunk-DJ4VJIH5.js";
-import {
-  hasWorkspaceRole
-} from "../chunk-6XIAPIW6.js";
 import {
   generateInvitationToken,
   getInvitationExpiresAt,
@@ -12,6 +5,13 @@ import {
   normalizeInvitationEmail,
   parseInvitationPermission
 } from "../chunk-2DRYTJHI.js";
+import {
+  SeatLimitError
+} from "../chunk-MEUNTJL5.js";
+import "../chunk-DJ4VJIH5.js";
+import {
+  hasWorkspaceRole
+} from "../chunk-6XIAPIW6.js";
 
 // src/teams/invitations-api.ts
 import { and, eq, lte, sql } from "drizzle-orm";

package/dist/web-react/index.js

@@ -117,16 +117,8 @@ import {
   withoutRecordGridCreated,
   withoutRecordGridRemoved,
   withoutRecordGridUpdate
-} from "../chunk-KOMP6NDW.js";
+} from "../chunk-ODYE4A7L.js";
 import "../chunk-FBVLEGEG.js";
-import {
-  useComposerAttachments
-} from "../chunk-E4DHYENH.js";
-import {
-  tabTerminalConnectionId,
-  useSandboxTerminalConnection
-} from "../chunk-BATKJP3P.js";
-import "../chunk-PC2WYTK7.js";
 import {
   EvidenceLineageTable,
   ExceptionList,
@@ -142,6 +134,14 @@ import {
 import {
   parseReviewQueueItem
 } from "../chunk-GEYACSFW.js";
+import {
+  useComposerAttachments
+} from "../chunk-E4DHYENH.js";
+import {
+  tabTerminalConnectionId,
+  useSandboxTerminalConnection
+} from "../chunk-BATKJP3P.js";
+import "../chunk-PC2WYTK7.js";
 import "../chunk-QY4BRKRJ.js";
 import {
   ATTACHMENT_ACCEPT
@@ -153,7 +153,8 @@ import {
   isChatAttachmentPart,
   mentionInputToPart,
   mentionPartsFromMessageParts
-} from "../chunk-B2UEW62O.js";
+} from "../chunk-5ZTFZBS6.js";
+import "../chunk-ZVEEWGDK.js";
 import {
   DISPATCH_MAX_MEDIA_PARTS,
   DISPATCH_MAX_PARTS,
@@ -166,7 +167,6 @@ import {
   mediaTypeForMentionPath,
   mentionKindForPath
 } from "../chunk-KWXUBMXU.js";
-import "../chunk-ZVEEWGDK.js";
 import {
   attachmentPartKey
 } from "../chunk-XZ27ENOZ.js";

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@tangle-network/agent-app",
-  "version": "0.45.26",
+  "version": "0.45.27",
   "packageManager": "pnpm@11.17.0",
   "description": "Build agent applications with typed chat, tools, sandboxes, integrations, billing, and evaluation.",
   "keywords": [
@@ -36,6 +36,7 @@
     "agent-app-legibility-check": "./dist/legibility/cli.js",
     "agent-app-preflight": "./dist/preflight/cli.js",
     "agent-app-peer-check": "./dist/peer-floors/cli.js",
+    "agent-app-spend-check": "./dist/spend/cli.js",
     "agent-app-signoff": "./dist/signoff/cli.js",
     "agent-app-verify-proof": "./dist/signoff/proof-cli.js"
   },
@@ -482,6 +483,11 @@
       "types": "./dist/peer-floors/check.d.ts",
       "import": "./dist/peer-floors/check.js",
       "default": "./dist/peer-floors/check.js"
+    },
+    "./spend": {
+      "types": "./dist/spend/index.d.ts",
+      "import": "./dist/spend/index.js",
+      "default": "./dist/spend/index.js"
     }
   },
   "scripts": {