@tangle-network/agent-app 0.45.25 → 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/types-U7Nz-txa.d.ts

@@ -0,0 +1,233 @@
+/**
+ * The vocabulary of a local sign-off run: what a repo declares, and what the
+ * run produces as proof.
+ *
+ * A sign-off gate replaces CI as the merge gate, so it has to reproduce what CI
+ * does structurally (a pristine dependency tree) and then do more than CI does
+ * (randomized suite order, recorded seeds, a dependency graph run in parallel).
+ * Both halves are declared here rather than hardcoded, because the three
+ * workflows this must express — agent-app, legal-agent, tax-agent — differ in
+ * install filter, step list, language (one has a Python step) and repo-specific
+ * gates.
+ */
+/** Which bytes get verified. */
+type SignoffSource = 
+/** Exactly the commit that would merge. Uncommitted work is NOT included. */
+'head'
+/** HEAD plus the working tree: tracked modifications applied as a patch and
+ *  untracked, non-ignored files copied in. What you are about to commit. */
+ | 'working-tree';
+/**
+ * How a step is re-run under different suite orders.
+ *
+ * CI runs one arbitrary order. The `node:sqlite` bundling failure that started
+ * this was scheduling-dependent: it reproduced in CI's clean install under CI's
+ * worker sharding and not in a warm local run, so a single fixed order can miss
+ * it in either direction. Every seed used is recorded in the report, which is
+ * what makes a shuffled failure reproducible rather than folklore.
+ */
+interface SignoffShuffleSpec {
+    /** How many times to run the step, each with its own seed. Default 2. */
+    readonly runs?: number;
+    /** Exact seeds to use. Wins over `runs`; use it to replay a known failure. */
+    readonly seeds?: readonly number[];
+    /** Arguments appended to the command, with `{seed}` substituted. Defaults to
+     *  vitest's file-order shuffle; override for another runner. */
+    readonly args?: readonly string[];
+}
+/** One verification step — a CI step, declared by the repo. */
+interface SignoffStepSpec {
+    /** Unique within the config. Names the failure in the report. */
+    readonly name: string;
+    /** Shell command, run from `cwd` inside the clean tree. */
+    readonly run: string;
+    /** Relative to the clean tree root. Defaults to the root. */
+    readonly cwd?: string;
+    /** Extra environment for this step only. */
+    readonly env?: Readonly<Record<string, string>>;
+    /** Step names that must pass first. Anything not named here may run in
+     *  parallel with this step — that is the whole speed lever, so an omitted
+     *  dependency is a correctness bug, not a tuning knob. */
+    readonly needs?: readonly string[];
+    /** Kill the step after this long. No default — an unbounded step is the
+     *  repo's choice to make. */
+    readonly timeoutMs?: number;
+    /** `true` for the default shuffle spec, or an explicit one. */
+    readonly shuffle?: boolean | SignoffShuffleSpec;
+}
+/** The hermetic install that precedes every step. */
+interface SignoffInstallSpec {
+    /** Default `pnpm install --frozen-lockfile`. tax-agent needs
+     *  `--filter web...` because `server/` depends on a sibling repo by `file:`. */
+    readonly run?: string;
+    /** Flag used to point the package manager at the pristine store. Default
+     *  `--store-dir`. `null` passes no flag (the env var still applies). */
+    readonly storeDirFlag?: string | null;
+    /** Env var used for the same. Default `NPM_CONFIG_STORE_DIR`, which is what
+     *  the tax-agent and legal-agent workflows set. `null` sets none. */
+    readonly storeEnv?: string | null;
+    /** Relative to the clean tree root. Defaults to the root. */
+    readonly cwd?: string;
+    readonly timeoutMs?: number;
+    /** Extra environment for the install only. */
+    readonly env?: Readonly<Record<string, string>>;
+}
+/** What a repo declares in `signoff.config.mjs` or a package.json `signoff` key. */
+interface SignoffConfig {
+    readonly install?: SignoffInstallSpec;
+    readonly steps: readonly SignoffStepSpec[];
+    /** Cap on concurrently running steps. Defaults to the host's parallelism. */
+    readonly maxParallel?: number;
+    /** Environment applied to every step and the install. */
+    readonly env?: Readonly<Record<string, string>>;
+    /** Node version the product ships on, e.g. `'22'`. Falls back to `.nvmrc`.
+     *  A mismatch REFUSES the run — see `node-version.ts`. */
+    readonly nodeVersion?: string;
+    /** Gitignored files the run genuinely needs (a private-registry `.npmrc`).
+     *  Explicit and fail-loud: a missing one aborts rather than installing from
+     *  a different registry than the developer thinks. */
+    readonly carryFiles?: readonly string[];
+    /** Root for the clean tree and the pristine stores. Default
+     *  `~/.cache/agent-app-signoff`. Both live under it so they share a
+     *  filesystem — pnpm hardlinks from the store into `node_modules`, and a
+     *  cross-device store silently degrades to copying. */
+    readonly cacheDir?: string;
+    /** Pristine store generations to keep. Default 4, so flipping between a
+     *  branch and main stays warm on both. */
+    readonly storeGenerations?: number;
+}
+/** Where a config came from. Printed in the proof — a run against a derived
+ *  default is a weaker claim than one against a declared step list. */
+type SignoffConfigOrigin = {
+    readonly kind: 'file';
+    readonly path: string;
+} | {
+    readonly kind: 'package-json';
+    readonly path: string;
+} | {
+    readonly kind: 'derived';
+    readonly path: string;
+    readonly scripts: readonly string[];
+};
+interface LoadedSignoffConfig {
+    readonly config: SignoffConfig;
+    readonly origin: SignoffConfigOrigin;
+}
+/** One execution of a step's command. A shuffled step has several. */
+interface SignoffAttempt {
+    readonly command: string;
+    /** The suite-order seed, or `null` for an unshuffled step. */
+    readonly seed: number | null;
+    readonly exitCode: number;
+    readonly signal: string | null;
+    readonly durationMs: number;
+    readonly timedOut: boolean;
+    /** Captured stdout+stderr, interleaved. Retained on failure; on success only
+     *  the tail is kept, so a passing 3,000-test run does not bloat the proof. */
+    readonly output: string;
+    readonly outputTruncated: boolean;
+}
+type SignoffStepStatus = 'passed' | 'failed'
+/** Never started — an earlier failure stopped the schedule. */
+ | 'skipped'
+/** Started, then killed when another step failed under fail-fast. */
+ | 'cancelled'
+/** A dependency failed, so this step could not be judged. */
+ | 'blocked';
+interface SignoffStepResult {
+    readonly name: string;
+    readonly status: SignoffStepStatus;
+    readonly attempts: readonly SignoffAttempt[];
+    readonly durationMs: number;
+    /** Milliseconds from schedule start, so the report can show the real overlap
+     *  rather than asserting a speedup it did not measure. */
+    readonly startedAtMs: number | null;
+    readonly finishedAtMs: number | null;
+}
+interface SignoffInstallResult {
+    readonly command: string;
+    readonly storeDir: string;
+    readonly cacheKey: string;
+    readonly cacheHit: boolean;
+    /** The files whose bytes produced `cacheKey`. Named so a surprise cold
+     *  install is explainable rather than mysterious. */
+    readonly keyedOn: readonly string[];
+    readonly exitCode: number;
+    readonly durationMs: number;
+    readonly output: string;
+    readonly outputTruncated: boolean;
+}
+interface SignoffRepoFacts {
+    readonly root: string;
+    readonly head: string;
+    readonly branch: string;
+    readonly source: SignoffSource;
+    readonly dirty: boolean;
+    /** sha256 of the applied working-tree patch, `null` when nothing was applied.
+     *  This is what makes the proof specific to the bytes that were verified. */
+    readonly diffSha256: string | null;
+    readonly untrackedFiles: readonly string[];
+    readonly carriedFiles: readonly string[];
+}
+interface SignoffHostFacts {
+    readonly node: string;
+    /** The pin the repo declares, and where it came from. `null` when the repo
+     *  pins nothing — stated in the proof, because an unpinned runtime is a
+     *  weaker claim than a pinned one. */
+    readonly nodePinned: string | null;
+    readonly nodePinSource: string | null;
+    readonly packageManager: string;
+    readonly platform: string;
+    readonly arch: string;
+    readonly cpus: number;
+}
+interface SignoffReport {
+    readonly ok: boolean;
+    readonly startedAt: string;
+    readonly repo: SignoffRepoFacts;
+    readonly configOrigin: SignoffConfigOrigin;
+    readonly workspace: string;
+    readonly workspaceRetained: boolean;
+    readonly host: SignoffHostFacts;
+    readonly install: SignoffInstallResult;
+    readonly steps: readonly SignoffStepResult[];
+    /** Base seed. Passing it back via `--seed` reproduces every step's seeds. */
+    readonly seedBase: number;
+    readonly wallClockMs: number;
+    /** Install + the sum of step durations: what the same work costs in series. */
+    readonly serialMs: number;
+    readonly keepGoing: boolean;
+    /** The exact command that reproduces this run. */
+    readonly reproduce: string;
+}
+/** Progress, for a CLI that prints as it goes rather than at the end. */
+type SignoffEvent = {
+    readonly kind: 'tree';
+    readonly path: string;
+    readonly head: string;
+    readonly dirty: boolean;
+} | {
+    readonly kind: 'store';
+    readonly storeDir: string;
+    readonly cacheHit: boolean;
+    readonly cacheKey: string;
+} | {
+    readonly kind: 'install-start';
+    readonly command: string;
+} | {
+    readonly kind: 'install-end';
+    readonly exitCode: number;
+    readonly durationMs: number;
+} | {
+    readonly kind: 'step-start';
+    readonly name: string;
+    readonly command: string;
+    readonly seed: number | null;
+} | {
+    readonly kind: 'step-end';
+    readonly name: string;
+    readonly status: SignoffStepStatus;
+    readonly durationMs: number;
+};
+
+export type { LoadedSignoffConfig as L, SignoffSource as S, SignoffEvent as a, SignoffReport as b, SignoffConfig as c, SignoffStepResult as d, SignoffStepSpec as e, SignoffRepoFacts as f, SignoffAttempt as g, SignoffConfigOrigin as h, SignoffHostFacts as i, SignoffInstallResult as j, SignoffInstallSpec as k, SignoffShuffleSpec as l, SignoffStepStatus as m };

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.25",
+  "version": "0.45.27",
   "packageManager": "pnpm@11.17.0",
   "description": "Build agent applications with typed chat, tools, sandboxes, integrations, billing, and evaluation.",
   "keywords": [
@@ -35,10 +35,23 @@
     "agent-app-theme-check": "./dist/theme-contract/cli.js",
     "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-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"
   },
   "exports": {
     "./package.json": "./package.json",
+    "./signoff": {
+      "types": "./dist/signoff/index.d.ts",
+      "import": "./dist/signoff/index.js",
+      "default": "./dist/signoff/index.js"
+    },
+    "./signoff/proof": {
+      "types": "./dist/signoff/proof.d.ts",
+      "import": "./dist/signoff/proof.js",
+      "default": "./dist/signoff/proof.js"
+    },
     "./tools": {
       "types": "./dist/tools/index.d.ts",
       "import": "./dist/tools/index.js",
@@ -470,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": {
@@ -482,7 +500,8 @@
     "test:watch": "vitest",
     "typecheck": "tsc --noEmit",
     "docs:gen": "agent-docs",
-    "knip": "knip"
+    "knip": "knip",
+    "signoff": "node dist/signoff/cli.js"
   },
   "devDependencies": {
     "@cloudflare/workers-types": "5.20260722.1",