@lucid-agents/taskmarket 1.17.1 → 1.17.2

package/dist/{chunk-3S63AB3C.js → chunk-FRV3ZHUR.js}

@@ -586,6 +586,9 @@ var TaskAwardSchema = z6.object({
   rating: z6.number().min(0).max(100).nullable()
 });
 var TaskCreateSchema = z6.object({
+  // Kept through validateBody, which replaces the body with the parsed result before the
+  // payment middleware reads the chain from it. Omitted, the task goes on the default chain.
+  chainId: z6.number().int().positive().optional(),
   description: z6.string().min(1, "Description is required").max(TASK_DESCRIPTION_MAX_LENGTH, "Description is too long"),
   reward: PositiveUsdcBaseUnitsSchema,
   duration: z6.number().positive("Duration must be positive"),
@@ -1279,7 +1282,20 @@ var HealthResponseSchema = z10.object({
     runwayUsd: z10.number().nonnegative().optional(),
     /** True below SERVER_WALLET_MIN_RUNWAY_USD; absent when no minimum applies. */
     belowMinimum: z10.boolean().optional(),
-    measuredAt: z10.string()
+    /** The hard floor in base units, and whether the balance is below it (sponsorship refused). */
+    sponsorFloor: z10.string().optional(),
+    belowSponsorFloor: z10.boolean().optional(),
+    /** When fees fell back to another token, the primary token and its balance (issue #1418). */
+    primaryFeeToken: z10.string().optional(),
+    primaryFeeTokenBalance: z10.string().optional(),
+    /** When the last good measurement was taken. */
+    measuredAt: z10.string(),
+    /**
+     * True when recent reads failed repeatedly or the last good measurement is old (issue
+     * #1418); the other fields are then the last known values.
+     */
+    stale: z10.boolean().optional(),
+    consecutiveFailures: z10.number().int().nonnegative().optional()
   })).optional(),
   /**
    * Each served chain's external dependencies (issue #981): RPC, contracts, payment and fee
@@ -1307,6 +1323,20 @@ var HealthResponseSchema = z10.object({
       ok: z10.boolean(),
       problem: z10.string().optional()
     }))
+  })).optional(),
+  /**
+   * Whether each served chain's platform fee recipient (the Diamond's `feeRecipient()`) can
+   * receive the payment token under its blacklist, TIP-403 transfer policy and receive policy
+   * (#926 I-3), checked at startup and every 15 minutes. `canReceive` is absent when the check
+   * could not reach a verdict; `problem` then says why. Absent before the first check.
+   */
+  feeRecipients: z10.array(z10.object({
+    chainId: z10.number().int(),
+    address: z10.string().optional(),
+    token: z10.string(),
+    canReceive: z10.boolean().optional(),
+    problem: z10.string().optional(),
+    checkedAt: z10.string()
   })).optional()
 });
 
@@ -3571,6 +3601,25 @@ var API_ERROR_REASONS = [
    * another network. Refused before any payment was verified, so nothing was charged.
    */
   "chain_conflict",
+  /**
+   * The server would pay the fee for this transaction and the caller's budget is spent, or the
+   * sender already has a sponsored transaction in flight on this chain. Refused before anything
+   * was co-signed or broadcast, so nothing was charged; retry later.
+   */
+  "sponsorship_rate_limited",
+  /**
+   * Tempo only. The server wallet's fee balance on this chain is below its sponsorship floor, so
+   * the server refuses to co-sign MPP payments and signed-transfer withdrawals until it is
+   * refunded. Refused before anything was co-signed or broadcast, so nothing was charged.
+   */
+  "sponsorship_unavailable",
+  /**
+   * Tempo only. The signed transaction breaks a rule the chain's node enforces, such as a
+   * `validBefore` further past the latest block than the chain allows. Either it was refused
+   * before the server co-signed it, or the node refused it at broadcast; either way nothing was
+   * sent and nothing moved. Sign a new transaction that meets the rule in the message.
+   */
+  "sponsored_transaction_refused",
   /**
    * The error carries no more specific classification. Present so that every error has a
    * reason field and a client's switch is total; not a licence to leave one here.
@@ -4657,13 +4706,13 @@ function usdcToBaseUnits(value, options = {}) {
   const normalized = value.trim();
   const match = USDC_PATTERN.exec(normalized);
   if (!match) {
-    throw new Error(`USDC amount must be a positive decimal with at most ${USDC_DECIMALS} fractional digits`);
+    throw new Error(`Amount must be a positive decimal with at most ${USDC_DECIMALS} fractional digits`);
   }
   const whole = BigInt(match[1]);
   const fraction = BigInt((match[2] ?? "").padEnd(USDC_DECIMALS, "0") || "0");
   const baseUnits = whole * USDC_BASE_UNITS + fraction;
   if (baseUnits < 0n || baseUnits === 0n && !options.allowZero) {
-    throw new Error("USDC amount must be greater than zero");
+    throw new Error("Amount must be greater than zero");
   }
   return baseUnits.toString();
 }
@@ -4682,37 +4731,319 @@ function formatUsdcBaseUnits(value, options = {}) {
   return fraction ? `${sign}${whole}.${fraction}` : `${sign}${whole}`;
 }
 
+// ../../packages/shared/dist/chains/registry.js
+import { base, baseSepolia, foundry, tempo, tempoModerato } from "viem/chains";
+
+// ../../packages/shared/dist/schemas/swarm-chain.schemas.js
+import { z as z38 } from "zod";
+var SwarmChainIdSchema = z38.union([z38.literal(8453), z38.literal(84532)]);
+var SWARM_CONSENT_TEXT_VERSIONS = [
+  "swarm-testnet-v1",
+  "swarm-testnet-pilot-v1",
+  "swarm-mainnet-v1",
+  "swarm-mainnet-pilot-v1",
+  // Implements: ADR-0183. Swarm YOLO mode: any recipient within the caps for a standing period.
+  "swarm-testnet-yolo-v1",
+  "swarm-testnet-yolo-pilot-v1",
+  "swarm-mainnet-yolo-v1",
+  "swarm-mainnet-yolo-pilot-v1",
+  // Implements: ADR-0185. Standing free market actions only: no payment rule of any kind.
+  "swarm-testnet-market-v1",
+  "swarm-mainnet-market-v1",
+  // Per ADR-0212. Standing YOLO: any recipient within the caps, with no end date, until revoked.
+  "swarm-testnet-standing-v1",
+  "swarm-testnet-standing-pilot-v1",
+  "swarm-mainnet-standing-v1",
+  "swarm-mainnet-standing-pilot-v1"
+];
+var SWARM_CHAINS = Object.freeze({
+  8453: Object.freeze({
+    chainId: 8453,
+    caip2: "eip155:8453",
+    name: "Base",
+    testnet: false,
+    usdc: "0x833589fCD6eDb6E08f4c7C32D4f71b54bdA02913",
+    usdcDomainName: "USD Coin",
+    usdcDomainVersion: "2",
+    publicRpcUrl: "https://mainnet.base.org",
+    qualifiedRpcOrigins: Object.freeze([
+      "https://mainnet.base.org",
+      "https://base-mainnet.rpc.privy.systems"
+    ]),
+    explorerUrl: "https://basescan.org",
+    identityRegistry: "0x8004A169FB4a3325136EB29fA0ceB6D2e539a432",
+    consentVersion: "swarm-mainnet-v1",
+    pilotConsentVersion: "swarm-mainnet-pilot-v1",
+    yoloConsentVersion: "swarm-mainnet-yolo-v1",
+    yoloPilotConsentVersion: "swarm-mainnet-yolo-pilot-v1",
+    marketConsentVersion: "swarm-mainnet-market-v1",
+    standingConsentVersion: "swarm-mainnet-standing-v1",
+    standingPilotConsentVersion: "swarm-mainnet-standing-pilot-v1"
+  }),
+  84532: Object.freeze({
+    chainId: 84532,
+    caip2: "eip155:84532",
+    name: "Base Sepolia",
+    testnet: true,
+    usdc: "0x036CbD53842c5426634e7929541eC2318f3dCF7e",
+    usdcDomainName: "USDC",
+    usdcDomainVersion: "2",
+    publicRpcUrl: "https://sepolia.base.org",
+    qualifiedRpcOrigins: Object.freeze([
+      "https://sepolia.base.org",
+      "https://base-sepolia.rpc.privy.systems"
+    ]),
+    explorerUrl: "https://sepolia.basescan.org",
+    identityRegistry: "0x8004A818BFB912233c491871b3d84c89A494BD9e",
+    consentVersion: "swarm-testnet-v1",
+    pilotConsentVersion: "swarm-testnet-pilot-v1",
+    yoloConsentVersion: "swarm-testnet-yolo-v1",
+    yoloPilotConsentVersion: "swarm-testnet-yolo-pilot-v1",
+    marketConsentVersion: "swarm-testnet-market-v1",
+    standingConsentVersion: "swarm-testnet-standing-v1",
+    standingPilotConsentVersion: "swarm-testnet-standing-pilot-v1"
+  })
+});
+function isSwarmChainId(value) {
+  return value === 8453 || value === 84532;
+}
+
+// ../../packages/shared/dist/chains/validity-window.js
+var TEMPO_MAX_VALIDITY_WINDOW_SECONDS = 300;
+var VALIDITY_WINDOW_CLIENT_MARGIN_SECONDS = 60;
+function clampValidityWindowSeconds(preferred, maxValidityWindowSeconds) {
+  if (maxValidityWindowSeconds === void 0)
+    return preferred;
+  return Math.min(preferred, maxValidityWindowSeconds - VALIDITY_WINDOW_CLIENT_MARGIN_SECONDS);
+}
+
+// ../../packages/shared/dist/chains/registry.js
+var TASKMARKET_CHAIN_IDS = [8453, 84532, 4217, 42431, 31337];
+function paymentProtocolFor(method) {
+  return method === "mpp-tempo" ? "mpp" : "x402";
+}
+var ERC8004_MAINNET = {
+  identityRegistry: "0x8004A169FB4a3325136EB29fA0ceB6D2e539a432",
+  reputationRegistry: "0x8004BAa17C55a88189AE136b182e5fdA19dE9b63"
+};
+var ERC8004_TESTNET = {
+  identityRegistry: "0x8004A818BFB912233c491871b3d84c89A494BD9e",
+  reputationRegistry: "0x8004B663056A597Dffe9eCcC1965A193B7388713"
+};
+var OUSD = "0x20c0000000000000000000006a37da5c996874be";
+var PATH_USD = "0x20c0000000000000000000000000000000000000";
+var TEMPO_PROTOCOL = {
+  feeManager: "0xfeEC000000000000000000000000000000000000",
+  tip403Registry: "0x403c000000000000000000000000000000000000",
+  receivePolicyGuard: "0xB10C000000000000000000000000000000000000",
+  stablecoinDex: "0xDEc0000000000000000000000000000000000000"
+};
+var baseFeatures = (chainId) => ({
+  swarmWallets: isSwarmChainId(chainId),
+  catalog: true,
+  cctpFunding: true,
+  relayFunding: chainId === 8453,
+  dreamsRewards: true,
+  receivePolicies: false
+});
+var TEMPO_FEATURES = {
+  swarmWallets: false,
+  catalog: false,
+  cctpFunding: false,
+  relayFunding: false,
+  dreamsRewards: false,
+  receivePolicies: true
+};
+var tempoPayment = {
+  token: OUSD,
+  symbol: "OUSD",
+  decimals: 6,
+  domain: { name: "OpenUSD", version: "1" },
+  method: "mpp-tempo"
+};
+var TEMPO_RATE_TASK_GAS_LIMIT = 4000000n;
+var tempoFees = { kind: "tip20", token: OUSD, fallbackToken: PATH_USD };
+function deepFreeze(value) {
+  for (const [key, nested] of Object.entries(value)) {
+    if (key === "viemChain")
+      continue;
+    if (nested && typeof nested === "object" && !Object.isFrozen(nested))
+      deepFreeze(nested);
+  }
+  return Object.freeze(value);
+}
+function freeze(chain) {
+  return deepFreeze(chain);
+}
+var TASKMARKET_CHAINS = Object.freeze({
+  8453: freeze({
+    chainId: 8453,
+    caip2: "eip155:8453",
+    name: "Base",
+    testnet: false,
+    viemChain: base,
+    publicRpcUrl: SWARM_CHAINS[8453].publicRpcUrl,
+    explorerUrl: SWARM_CHAINS[8453].explorerUrl,
+    payment: {
+      token: SWARM_CHAINS[8453].usdc,
+      symbol: "USDC",
+      decimals: 6,
+      domain: { name: SWARM_CHAINS[8453].usdcDomainName, version: "2" },
+      method: "eip3009"
+    },
+    fees: { kind: "native" },
+    blockTimeMs: 2e3,
+    rateTaskGasLimit: 1500000n,
+    indexer: { head: "latest", logRangeBlocks: 1e4 },
+    erc8004: { ...ERC8004_MAINNET },
+    features: baseFeatures(8453)
+  }),
+  84532: freeze({
+    chainId: 84532,
+    caip2: "eip155:84532",
+    name: "Base Sepolia",
+    testnet: true,
+    viemChain: baseSepolia,
+    publicRpcUrl: SWARM_CHAINS[84532].publicRpcUrl,
+    explorerUrl: SWARM_CHAINS[84532].explorerUrl,
+    payment: {
+      token: SWARM_CHAINS[84532].usdc,
+      symbol: "USDC",
+      decimals: 6,
+      domain: { name: SWARM_CHAINS[84532].usdcDomainName, version: "2" },
+      method: "eip3009"
+    },
+    fees: { kind: "native" },
+    blockTimeMs: 2e3,
+    rateTaskGasLimit: 1500000n,
+    indexer: { head: "latest", logRangeBlocks: 1e4 },
+    erc8004: { ...ERC8004_TESTNET },
+    features: baseFeatures(84532)
+  }),
+  4217: freeze({
+    chainId: 4217,
+    caip2: "eip155:4217",
+    name: "Tempo",
+    testnet: false,
+    viemChain: tempo,
+    publicRpcUrl: tempo.rpcUrls.default.http[0],
+    explorerUrl: "https://explore.tempo.xyz",
+    payment: { ...tempoPayment, domain: { ...tempoPayment.domain } },
+    fees: { ...tempoFees },
+    blockTimeMs: 1e3,
+    rateTaskGasLimit: TEMPO_RATE_TASK_GAS_LIMIT,
+    maxValidityWindowSeconds: TEMPO_MAX_VALIDITY_WINDOW_SECONDS,
+    // Tempo finality is deterministic and fast; until the provider's eth_getLogs limit is
+    // measured (#907), keep the same range as Base.
+    indexer: { head: "finalized", logRangeBlocks: 1e4 },
+    erc8004: { ...ERC8004_MAINNET },
+    features: { ...TEMPO_FEATURES },
+    tempo: { ...TEMPO_PROTOCOL, paymentTokenPolicyId: 2 }
+  }),
+  42431: freeze({
+    chainId: 42431,
+    caip2: "eip155:42431",
+    name: "Tempo Moderato",
+    testnet: true,
+    viemChain: tempoModerato,
+    publicRpcUrl: tempoModerato.rpcUrls.default.http[0],
+    explorerUrl: "https://explore.testnet.tempo.xyz",
+    payment: { ...tempoPayment, domain: { ...tempoPayment.domain } },
+    fees: { ...tempoFees },
+    blockTimeMs: 1e3,
+    rateTaskGasLimit: TEMPO_RATE_TASK_GAS_LIMIT,
+    maxValidityWindowSeconds: TEMPO_MAX_VALIDITY_WINDOW_SECONDS,
+    indexer: { head: "finalized", logRangeBlocks: 1e4 },
+    erc8004: { ...ERC8004_TESTNET },
+    features: { ...TEMPO_FEATURES },
+    tempo: { ...TEMPO_PROTOCOL, paymentTokenPolicyId: 1 }
+  }),
+  31337: freeze({
+    chainId: 31337,
+    caip2: "eip155:31337",
+    name: "Local",
+    testnet: true,
+    viemChain: foundry,
+    publicRpcUrl: "http://127.0.0.1:8545",
+    explorerUrl: "",
+    // The local mock token is deployed per run; its address comes from the environment.
+    payment: {
+      token: void 0,
+      symbol: "USDC",
+      decimals: 6,
+      domain: { name: "USD Coin", version: "2" },
+      method: "eip3009"
+    },
+    fees: { kind: "native" },
+    blockTimeMs: 1e3,
+    rateTaskGasLimit: 1500000n,
+    indexer: { head: "latest", logRangeBlocks: 1e4 },
+    erc8004: void 0,
+    features: {
+      swarmWallets: false,
+      catalog: false,
+      cctpFunding: false,
+      relayFunding: false,
+      dreamsRewards: true,
+      receivePolicies: false
+    }
+  })
+});
+var UnknownChainError = class extends Error {
+  constructor(chainId) {
+    super(`Taskmarket does not support chain ${String(chainId)}`);
+    this.name = "UnknownChainError";
+    this.chainId = chainId;
+  }
+};
+function isTaskmarketChainId(value) {
+  return TASKMARKET_CHAIN_IDS.includes(value);
+}
+function taskmarketChain(chainId) {
+  if (!isTaskmarketChainId(chainId))
+    throw new UnknownChainError(chainId);
+  return TASKMARKET_CHAINS[chainId];
+}
+function clientValidityWindowSeconds(chainId, preferred) {
+  return clampValidityWindowSeconds(preferred, isTaskmarketChainId(chainId) ? TASKMARKET_CHAINS[chainId].maxValidityWindowSeconds : void 0);
+}
+
+// ../../packages/shared/dist/lib/payment-amount.js
+function paymentTokenSymbol(chainId) {
+  return taskmarketChain(chainId).payment.symbol;
+}
+
 // ../../packages/shared/dist/schemas/launcher.schemas.js
-import { z as z40 } from "zod";
+import { z as z41 } from "zod";
 
 // ../../packages/shared/dist/schemas/agent-platform.schemas.js
-import { z as z39 } from "zod";
+import { z as z40 } from "zod";
 
 // ../../packages/shared/dist/schemas/swarm-budget.schemas.js
-import { z as z38 } from "zod";
+import { z as z39 } from "zod";
 var SWARM_USDC_ATOMIC_PATTERN = /^(?:0|[1-9][0-9]{0,17})$/;
-var SwarmUsdcAtomicAmountSchema = z38.string().regex(SWARM_USDC_ATOMIC_PATTERN);
-var SwarmBudgetIdSchema = z38.object({ agentId: z38.string().uuid() }).strict();
+var SwarmUsdcAtomicAmountSchema = z39.string().regex(SWARM_USDC_ATOMIC_PATTERN);
+var SwarmBudgetIdSchema = z39.object({ agentId: z39.string().uuid() }).strict();
 var SwarmBudgetInputSchema = SwarmBudgetIdSchema.extend({
-  requestKey: z38.string().uuid(),
-  enabled: z38.boolean(),
+  requestKey: z39.string().uuid(),
+  enabled: z39.boolean(),
   maxPurchase: SwarmUsdcAtomicAmountSchema,
   rollingDay: SwarmUsdcAtomicAmountSchema,
   period: SwarmUsdcAtomicAmountSchema
 }).strict();
-var SwarmBudgetViewSchema = z38.object({
-  agentId: z38.string().uuid(),
-  configured: z38.boolean(),
-  enabled: z38.boolean(),
-  paused: z38.boolean(),
+var SwarmBudgetViewSchema = z39.object({
+  agentId: z39.string().uuid(),
+  configured: z39.boolean(),
+  enabled: z39.boolean(),
+  paused: z39.boolean(),
   maxPurchase: SwarmUsdcAtomicAmountSchema,
   rollingDay: SwarmUsdcAtomicAmountSchema,
   period: SwarmUsdcAtomicAmountSchema,
-  spendingEnabled: z38.boolean()
+  spendingEnabled: z39.boolean()
 });
-var SwarmBudgetUpdateResultSchema = z38.object({
-  requestKey: z38.string().uuid(),
-  replayed: z38.boolean(),
+var SwarmBudgetUpdateResultSchema = z39.object({
+  requestKey: z39.string().uuid(),
+  replayed: z39.boolean(),
   budget: SwarmBudgetViewSchema
 });
 
@@ -4727,191 +5058,191 @@ var AGENT_PLATFORM_COMPONENTS = [
   "session-reset",
   "memory"
 ];
-var AgentPlatformComponentSchema = z39.enum(AGENT_PLATFORM_COMPONENTS);
+var AgentPlatformComponentSchema = z40.enum(AGENT_PLATFORM_COMPONENTS);
 var AgentPlatformToolInputSchemas = {
-  platform_status: z39.object({}).strict(),
-  ui_show: z39.object({ component: AgentPlatformComponentSchema, reason: z39.string().trim().min(1).max(500) }).strict()
+  platform_status: z40.object({}).strict(),
+  ui_show: z40.object({ component: AgentPlatformComponentSchema, reason: z40.string().trim().min(1).max(500) }).strict()
 };
-var AgentUiCardSchema = z39.object({
+var AgentUiCardSchema = z40.object({
   component: AgentPlatformComponentSchema,
-  reason: z39.string().max(500),
-  tainted: z39.boolean()
-});
-var AgentPlatformStatusSchema = z39.object({
-  version: z39.literal(1),
-  identity: z39.object({
-    agentId: z39.string().uuid(),
-    name: z39.string(),
+  reason: z40.string().max(500),
+  tainted: z40.boolean()
+});
+var AgentPlatformStatusSchema = z40.object({
+  version: z40.literal(1),
+  identity: z40.object({
+    agentId: z40.string().uuid(),
+    name: z40.string(),
     tier: AgentTierSchema,
-    model: z39.string().nullable(),
+    model: z40.string().nullable(),
     nextTier: AgentTierSchema
   }),
-  capabilities: z39.array(z39.object({
-    key: z39.string(),
-    enabled: z39.boolean(),
-    blocked: z39.string().nullable(),
-    ownerAction: z39.string().nullable(),
-    link: z39.string(),
+  capabilities: z40.array(z40.object({
+    key: z40.string(),
+    enabled: z40.boolean(),
+    blocked: z40.string().nullable(),
+    ownerAction: z40.string().nullable(),
+    link: z40.string(),
     component: AgentPlatformComponentSchema.nullable()
   })),
   budget: SwarmBudgetViewSchema,
-  readiness: z39.object({
-    actions: z39.array(z39.string()),
-    blockers: z39.array(z39.string()),
-    legalAccepted: z39.boolean()
+  readiness: z40.object({
+    actions: z40.array(z40.string()),
+    blockers: z40.array(z40.string()),
+    legalAccepted: z40.boolean()
   }).nullable(),
-  connectors: z39.array(z39.object({ provider: z39.string(), state: z39.string(), actions: z39.array(z39.string()) })),
-  channels: z39.object({ connected: z39.boolean(), coordinatorAgentId: z39.string().uuid().nullable() }),
-  toolGroups: z39.array(z39.string()),
-  swarm: z39.object({
-    canCreate: z39.boolean(),
-    canDispatch: z39.boolean(),
-    coordinator: z39.string().uuid().nullable(),
-    siblings: z39.array(z39.object({ agentId: z39.string().uuid() })),
-    limits: z39.object({
-      createsPerJob: z39.number(),
-      sendsPerJob: z39.number(),
-      depth: z39.number(),
-      agentsPerAccount: z39.number()
+  connectors: z40.array(z40.object({ provider: z40.string(), state: z40.string(), actions: z40.array(z40.string()) })),
+  channels: z40.object({ connected: z40.boolean(), coordinatorAgentId: z40.string().uuid().nullable() }),
+  toolGroups: z40.array(z40.string()),
+  swarm: z40.object({
+    canCreate: z40.boolean(),
+    canDispatch: z40.boolean(),
+    coordinator: z40.string().uuid().nullable(),
+    siblings: z40.array(z40.object({ agentId: z40.string().uuid() })),
+    limits: z40.object({
+      createsPerJob: z40.number(),
+      sendsPerJob: z40.number(),
+      depth: z40.number(),
+      agentsPerAccount: z40.number()
     })
   }),
-  market: z39.object({
-    scopes: z39.array(z39.string()),
-    escrowLimit: z39.string(),
-    freeActions: z39.array(z39.string()),
-    freeActionsConditions: z39.string()
+  market: z40.object({
+    scopes: z40.array(z40.string()),
+    escrowLimit: z40.string(),
+    freeActions: z40.array(z40.string()),
+    freeActionsConditions: z40.string()
   }),
-  spending: z39.object({
-    mode: z39.enum(["off", "exact", "yolo", "standing"]),
-    maxPurchase: z39.string().nullable(),
-    rollingDay: z39.string().nullable(),
-    period: z39.string().nullable()
+  spending: z40.object({
+    mode: z40.enum(["off", "exact", "yolo", "standing"]),
+    maxPurchase: z40.string().nullable(),
+    rollingDay: z40.string().nullable(),
+    period: z40.string().nullable()
   }),
-  memoryScopes: z39.array(z39.string())
+  memoryScopes: z40.array(z40.string())
 });
-var AgentDelegationSchema = z39.object({
-  agentId: z39.string().uuid(),
-  name: z39.string(),
-  jobId: z39.string().uuid(),
-  status: z39.enum(["queued", "running", "completed", "failed", "interrupted"]),
-  waiting: z39.boolean()
+var AgentDelegationSchema = z40.object({
+  agentId: z40.string().uuid(),
+  name: z40.string(),
+  jobId: z40.string().uuid(),
+  status: z40.enum(["queued", "running", "completed", "failed", "interrupted"]),
+  waiting: z40.boolean()
 });
 
 // ../../packages/shared/dist/schemas/launcher.schemas.js
-var LauncherAgentIdSchema = z40.object({ agentId: z40.string().uuid() });
-var LauncherAvatarSchema = z40.object({
-  version: z40.literal(1),
-  color: z40.enum(["rose", "mint", "blue", "amber", "mauve", "cocoa"]),
-  face: z40.number().int().min(0).max(5),
+var LauncherAgentIdSchema = z41.object({ agentId: z41.string().uuid() });
+var LauncherAvatarSchema = z41.object({
+  version: z41.literal(1),
+  color: z41.enum(["rose", "mint", "blue", "amber", "mauve", "cocoa"]),
+  face: z41.number().int().min(0).max(5),
   /** Shape 0-6. Values 0-2 predate the wider range and keep their shapes. */
-  head: z40.number().int().min(0).max(6),
-  antenna: z40.number().int().min(0).max(3),
-  ears: z40.number().int().min(0).max(2),
-  markings: z40.number().int().min(0).max(255),
+  head: z41.number().int().min(0).max(6),
+  antenna: z41.number().int().min(0).max(3),
+  ears: z41.number().int().min(0).max(2),
+  markings: z41.number().int().min(0).max(255),
   /**
    * @deprecated Plush is the only companion style. Still accepted so avatars saved with a
    * style parse, but ignored by every renderer; new saves omit it.
    */
-  style: z40.enum(["vinyl", "gummy", "visor", "plush"]).optional()
+  style: z41.enum(["vinyl", "gummy", "visor", "plush"]).optional()
 }).strict();
 var LauncherUpdateAvatarSchema = LauncherAgentIdSchema.extend({
   avatar: LauncherAvatarSchema
 });
-var LauncherLaunchSchema = z40.object({
-  requestKey: z40.string().uuid(),
-  name: z40.string().trim().min(1).max(100),
-  prompt: z40.string().trim().min(1).max(32768),
+var LauncherLaunchSchema = z41.object({
+  requestKey: z41.string().uuid(),
+  name: z41.string().trim().min(1).max(100),
+  prompt: z41.string().trim().min(1).max(32768),
   avatar: LauncherAvatarSchema.optional(),
   /** Capability tier for the new agent. Absent is light. */
   tier: AgentTierSchema.optional()
 }).strict();
-var LauncherSessionResetSchema = z40.object({ version: z40.number().int().positive(), requestedAt: z40.string().datetime() }).strict();
+var LauncherSessionResetSchema = z41.object({ version: z41.number().int().positive(), requestedAt: z41.string().datetime() }).strict();
 var LauncherMessageSchema = LauncherAgentIdSchema.extend({
-  requestKey: z40.string().uuid(),
-  prompt: z40.string().trim().min(1).max(32768)
+  requestKey: z41.string().uuid(),
+  prompt: z41.string().trim().min(1).max(32768)
 }).strict();
-var LauncherJobStatusSchema = z40.enum([
+var LauncherJobStatusSchema = z41.enum([
   "queued",
   "running",
   "completed",
   "failed",
   "interrupted"
 ]);
-var LauncherJobSchema = z40.object({
-  id: z40.string().uuid(),
+var LauncherJobSchema = z41.object({
+  id: z41.string().uuid(),
   status: LauncherJobStatusSchema,
-  runId: z40.string().uuid().nullable(),
-  output: z40.string().nullable(),
-  errorCode: z40.string().nullable(),
-  createdAt: z40.string(),
-  finishedAt: z40.string().nullable()
+  runId: z41.string().uuid().nullable(),
+  output: z41.string().nullable(),
+  errorCode: z41.string().nullable(),
+  createdAt: z41.string(),
+  finishedAt: z41.string().nullable()
 });
-var LauncherAcceptedSchema = z40.object({
-  agentId: z40.string().uuid(),
-  jobId: z40.string().uuid(),
+var LauncherAcceptedSchema = z41.object({
+  agentId: z41.string().uuid(),
+  jobId: z41.string().uuid(),
   status: LauncherJobStatusSchema
 });
-var LauncherAgentSchema = z40.object({
-  id: z40.string().uuid(),
-  name: z40.string(),
+var LauncherAgentSchema = z41.object({
+  id: z41.string().uuid(),
+  name: z41.string(),
   avatar: LauncherAvatarSchema.nullish(),
-  paused: z40.boolean(),
+  paused: z41.boolean(),
   /**
    * The agent's capability tier. A change applies from its next job; a running job keeps the tier
    * it was admitted under. Absent only from a backend that predates tiers, which ran every agent
    * as light.
    */
   tier: AgentTierSchema.default("light"),
-  controlVersion: z40.number().int(),
-  workspaceReady: z40.boolean(),
-  usage: z40.object({
-    available: z40.number(),
-    reserved: z40.number(),
-    spent: z40.number(),
-    unit: z40.literal("tokens")
+  controlVersion: z41.number().int(),
+  workspaceReady: z41.boolean(),
+  usage: z41.object({
+    available: z41.number(),
+    reserved: z41.number(),
+    spent: z41.number(),
+    unit: z41.literal("tokens")
   })
 });
-var LauncherStatusSchema = z40.object({
+var LauncherStatusSchema = z41.object({
   agent: LauncherAgentSchema,
-  jobs: z40.array(LauncherJobSchema)
+  jobs: z41.array(LauncherJobSchema)
 });
 var LauncherEventsInputSchema = LauncherAgentIdSchema.extend({
-  after: z40.number().int().nonnegative().default(0),
-  limit: z40.number().int().min(1).max(100).default(50)
-});
-var LauncherEventsSchema = z40.object({
-  events: z40.array(z40.object({
-    id: z40.number().int(),
-    runId: z40.string().uuid(),
-    type: z40.string(),
-    createdAt: z40.string()
+  after: z41.number().int().nonnegative().default(0),
+  limit: z41.number().int().min(1).max(100).default(50)
+});
+var LauncherEventsSchema = z41.object({
+  events: z41.array(z41.object({
+    id: z41.number().int(),
+    runId: z41.string().uuid(),
+    type: z41.string(),
+    createdAt: z41.string()
   })),
-  nextCursor: z40.number().int()
+  nextCursor: z41.number().int()
 });
 var LauncherArtifactInputSchema = LauncherAgentIdSchema.extend({
-  artifactId: z40.string().uuid()
-});
-var LauncherArtifactsSchema = z40.object({
-  artifacts: z40.array(z40.object({
-    id: z40.string().uuid(),
-    runId: z40.string().uuid(),
-    path: z40.string(),
-    displayName: z40.string().optional(),
-    sha256: z40.string(),
-    bytes: z40.number(),
-    createdAt: z40.string()
+  artifactId: z41.string().uuid()
+});
+var LauncherArtifactsSchema = z41.object({
+  artifacts: z41.array(z41.object({
+    id: z41.string().uuid(),
+    runId: z41.string().uuid(),
+    path: z41.string(),
+    displayName: z41.string().optional(),
+    sha256: z41.string(),
+    bytes: z41.number(),
+    createdAt: z41.string()
   }))
 });
-var LauncherArtifactUrlSchema = z40.object({
-  url: z40.string().url(),
-  expiresIn: z40.number().int()
+var LauncherArtifactUrlSchema = z41.object({
+  url: z41.string().url(),
+  expiresIn: z41.number().int()
 });
-var LauncherAccountSchema = z40.object({
-  enabled: z40.boolean(),
-  agentId: z40.string().uuid().nullable(),
-  initialTokens: z40.number().int().nonnegative(),
-  agentCount: z40.number().int().nonnegative(),
-  maxAgents: z40.number().int().positive(),
+var LauncherAccountSchema = z41.object({
+  enabled: z41.boolean(),
+  agentId: z41.string().uuid().nullable(),
+  initialTokens: z41.number().int().nonnegative(),
+  agentCount: z41.number().int().nonnegative(),
+  maxAgents: z41.number().int().positive(),
   /**
    * @deprecated Kept for one release so a web bundle built before its removal, which reads
    * `account.usage.available` without a guard, does not crash during a deploy or in a stale tab.
@@ -4919,145 +5250,145 @@ var LauncherAccountSchema = z40.object({
    * allowance, and the shared token balance lives on each agent's `usage`. Remove next release.
    */
   usage: LauncherAgentSchema.shape.usage.optional(),
-  providerUsage: z40.object({
-    basis: z40.literal("recorded_provider_turns"),
-    provisional: z40.literal(true),
-    inputTokens: z40.string().regex(/^\d+$/),
-    outputTokens: z40.string().regex(/^\d+$/),
-    totalTokens: z40.string().regex(/^\d+$/),
-    cachedInputTokens: z40.string().regex(/^\d+$/),
-    reasoningTokens: z40.string().regex(/^\d+$/),
-    reportedTurns: z40.number().int().nonnegative(),
-    unknownTurns: z40.number().int().nonnegative(),
-    invalidObservations: z40.number().int().nonnegative(),
-    missingCachedDetails: z40.number().int().nonnegative(),
-    missingReasoningDetails: z40.number().int().nonnegative(),
-    truncated: z40.boolean()
+  providerUsage: z41.object({
+    basis: z41.literal("recorded_provider_turns"),
+    provisional: z41.literal(true),
+    inputTokens: z41.string().regex(/^\d+$/),
+    outputTokens: z41.string().regex(/^\d+$/),
+    totalTokens: z41.string().regex(/^\d+$/),
+    cachedInputTokens: z41.string().regex(/^\d+$/),
+    reasoningTokens: z41.string().regex(/^\d+$/),
+    reportedTurns: z41.number().int().nonnegative(),
+    unknownTurns: z41.number().int().nonnegative(),
+    invalidObservations: z41.number().int().nonnegative(),
+    missingCachedDetails: z41.number().int().nonnegative(),
+    missingReasoningDetails: z41.number().int().nonnegative(),
+    truncated: z41.boolean()
   }).optional()
 });
 var LauncherTurnSchema = LauncherJobSchema.extend({
-  uiCards: z40.array(AgentUiCardSchema).max(3).optional(),
-  delegations: z40.array(AgentDelegationSchema).optional(),
-  sequence: z40.number().int(),
-  requestKey: z40.string().uuid(),
-  prompt: z40.string(),
-  senderAgentId: z40.string().uuid().nullable().default(null),
-  automaticContinuation: z40.boolean().optional(),
-  channelRequest: z40.object({ id: z40.string().uuid(), reference: z40.string() }).nullable().optional()
+  uiCards: z41.array(AgentUiCardSchema).max(3).optional(),
+  delegations: z41.array(AgentDelegationSchema).optional(),
+  sequence: z41.number().int(),
+  requestKey: z41.string().uuid(),
+  prompt: z41.string(),
+  senderAgentId: z41.string().uuid().nullable().default(null),
+  automaticContinuation: z41.boolean().optional(),
+  channelRequest: z41.object({ id: z41.string().uuid(), reference: z41.string() }).nullable().optional()
 });
 var LauncherHistoryInputSchema = LauncherAgentIdSchema.extend({
-  before: z40.number().int().positive().optional(),
-  limit: z40.number().int().min(1).max(50).default(20)
+  before: z41.number().int().positive().optional(),
+  limit: z41.number().int().min(1).max(50).default(20)
+});
+var LauncherHistorySchema = z41.object({
+  turns: z41.array(LauncherTurnSchema),
+  nextBefore: z41.number().int().nullable()
+});
+var LauncherJobInputSchema = LauncherAgentIdSchema.extend({ jobId: z41.string().uuid() });
+var LauncherActivitySchema = z41.object({
+  id: z41.number().int(),
+  version: z41.literal(1),
+  runId: z41.string().uuid(),
+  type: z41.string(),
+  label: z41.string(),
+  outcome: z41.enum(["started", "completed", "failed", "info"]),
+  createdAt: z41.string()
 });
-var LauncherHistorySchema = z40.object({
-  turns: z40.array(LauncherTurnSchema),
-  nextBefore: z40.number().int().nullable()
+var LauncherActivityPageSchema = z41.object({
+  events: z41.array(LauncherActivitySchema),
+  nextBefore: z41.number().int().nullable()
 });
-var LauncherJobInputSchema = LauncherAgentIdSchema.extend({ jobId: z40.string().uuid() });
-var LauncherActivitySchema = z40.object({
-  id: z40.number().int(),
-  version: z40.literal(1),
-  runId: z40.string().uuid(),
-  type: z40.string(),
-  label: z40.string(),
-  outcome: z40.enum(["started", "completed", "failed", "info"]),
-  createdAt: z40.string()
-});
-var LauncherActivityPageSchema = z40.object({
-  events: z40.array(LauncherActivitySchema),
-  nextBefore: z40.number().int().nullable()
-});
-var LauncherViewSchema = z40.object({
-  agentUiEnabled: z40.boolean().optional(),
-  trial: z40.boolean().optional(),
+var LauncherViewSchema = z41.object({
+  agentUiEnabled: z41.boolean().optional(),
+  trial: z41.boolean().optional(),
   agent: LauncherAgentSchema,
-  accessEnabled: z40.boolean(),
-  state: z40.enum(["ready", "queued", "working", "paused", "recovering", "interrupted", "exhausted"]),
-  compute: z40.enum(["not_created", "starting", "running", "stopped", "unknown"]),
-  queuedCount: z40.number().int(),
+  accessEnabled: z41.boolean(),
+  state: z41.enum(["ready", "queued", "working", "paused", "recovering", "interrupted", "exhausted"]),
+  compute: z41.enum(["not_created", "starting", "running", "stopped", "unknown"]),
+  queuedCount: z41.number().int(),
   history: LauncherHistorySchema,
   activity: LauncherActivityPageSchema
 });
-var LauncherPreviewSchema = z40.discriminatedUnion("kind", [
-  z40.object({
-    kind: z40.literal("text"),
-    content: z40.string().max(65536),
-    fileName: z40.string().optional()
+var LauncherPreviewSchema = z41.discriminatedUnion("kind", [
+  z41.object({
+    kind: z41.literal("text"),
+    content: z41.string().max(65536),
+    fileName: z41.string().optional()
   }),
-  z40.object({
-    kind: z40.literal("html"),
-    content: z40.string().max(5 * 1024 * 1024),
-    fileName: z40.string()
+  z41.object({
+    kind: z41.literal("html"),
+    content: z41.string().max(5 * 1024 * 1024),
+    fileName: z41.string()
   }),
-  z40.object({
-    kind: z40.literal("image"),
-    content: z40.string().max(7e5),
-    mimeType: z40.enum(["image/png", "image/jpeg", "image/gif", "image/webp"]),
-    fileName: z40.string().optional()
+  z41.object({
+    kind: z41.literal("image"),
+    content: z41.string().max(7e5),
+    mimeType: z41.enum(["image/png", "image/jpeg", "image/gif", "image/webp"]),
+    fileName: z41.string().optional()
   }),
-  z40.object({ kind: z40.literal("download"), reason: z40.string() })
+  z41.object({ kind: z41.literal("download"), reason: z41.string() })
 ]);
 var MAX_LAUNCHER_DOWNLOAD_BYTES = 16 * 1024 * 1024;
 var LauncherSessionSendSchema = LauncherAgentIdSchema.extend({
-  recipientAgentId: z40.string().uuid(),
-  requestKey: z40.string().uuid(),
-  message: z40.string().trim().min(1).max(16e3)
+  recipientAgentId: z41.string().uuid(),
+  requestKey: z41.string().uuid(),
+  message: z41.string().trim().min(1).max(16e3)
 }).strict();
 var LauncherSessionHistoryInputSchema = LauncherAgentIdSchema.extend({
-  peerAgentId: z40.string().uuid().optional(),
-  before: z40.number().int().positive().optional(),
-  limit: z40.number().int().min(1).max(50).default(20)
+  peerAgentId: z41.string().uuid().optional(),
+  before: z41.number().int().positive().optional(),
+  limit: z41.number().int().min(1).max(50).default(20)
 });
 var LauncherSessionMessageSchema = LauncherTurnSchema.extend({
-  agentId: z40.string().uuid(),
-  senderAgentId: z40.string().uuid()
-});
-var LauncherSessionHistorySchema = z40.object({
-  messages: z40.array(LauncherSessionMessageSchema),
-  nextBefore: z40.number().int().nullable()
-});
-var LauncherMarketOperationSchema = z40.object({
-  id: z40.string().uuid(),
-  action: z40.string(),
-  state: z40.enum(["pending", "completed", "failed"]),
-  taskId: z40.string().nullable(),
-  taskTitle: z40.string().nullable(),
+  agentId: z41.string().uuid(),
+  senderAgentId: z41.string().uuid()
+});
+var LauncherSessionHistorySchema = z41.object({
+  messages: z41.array(LauncherSessionMessageSchema),
+  nextBefore: z41.number().int().nullable()
+});
+var LauncherMarketOperationSchema = z41.object({
+  id: z41.string().uuid(),
+  action: z41.string(),
+  state: z41.enum(["pending", "completed", "failed"]),
+  taskId: z41.string().nullable(),
+  taskTitle: z41.string().nullable(),
   /** USDC base units: the payment when one was quoted, else the reward or price the action named. */
-  amount: z40.string().regex(/^\d+$/).nullable(),
+  amount: z41.string().regex(/^\d+$/).nullable(),
   /** True once the payment for this action settled on chain. */
-  paid: z40.boolean(),
-  transactionHash: z40.string().nullable(),
-  submissionId: z40.string().nullable(),
+  paid: z41.boolean(),
+  transactionHash: z41.string().nullable(),
+  submissionId: z41.string().nullable(),
   /** A bounded upper-case error code when the action failed. */
-  errorCode: z40.string().nullable(),
-  createdAt: z40.string(),
-  updatedAt: z40.string()
-});
-var LauncherMarketSummarySchema = z40.object({
-  activeTasks: z40.number().int().nonnegative(),
-  submissions: z40.number().int().nonnegative(),
-  tasksPublished: z40.number().int().nonnegative(),
-  wins: z40.number().int().nonnegative(),
-  pending: z40.number().int().nonnegative(),
-  failed: z40.number().int().nonnegative(),
+  errorCode: z41.string().nullable(),
+  createdAt: z41.string(),
+  updatedAt: z41.string()
+});
+var LauncherMarketSummarySchema = z41.object({
+  activeTasks: z41.number().int().nonnegative(),
+  submissions: z41.number().int().nonnegative(),
+  tasksPublished: z41.number().int().nonnegative(),
+  wins: z41.number().int().nonnegative(),
+  pending: z41.number().int().nonnegative(),
+  failed: z41.number().int().nonnegative(),
   /** Settled market payments in USDC base units (fees, and escrow for published tasks). */
-  spent: z40.string().regex(/^\d+$/),
+  spent: z41.string().regex(/^\d+$/),
   /** Worker payouts for tasks this agent worked, in USDC base units. */
-  earnings: z40.string().regex(/^\d+$/)
+  earnings: z41.string().regex(/^\d+$/)
 });
 var LauncherAgentMarketInputSchema = LauncherAgentIdSchema.extend({
-  limit: z40.number().int().min(1).max(100).default(50)
+  limit: z41.number().int().min(1).max(100).default(50)
 });
-var LauncherAgentMarketSchema = z40.object({
-  operations: z40.array(LauncherMarketOperationSchema),
+var LauncherAgentMarketSchema = z41.object({
+  operations: z41.array(LauncherMarketOperationSchema),
   summary: LauncherMarketSummarySchema
 });
-var LauncherAgentMarketTasksInputSchema = z40.object({
-  agentId: z40.string().uuid(),
-  view: z40.enum(["both", "posted", "attempted"]).default("both"),
-  limit: z40.number().int().min(1).max(50).default(5),
+var LauncherAgentMarketTasksInputSchema = z41.object({
+  agentId: z41.string().uuid(),
+  view: z41.enum(["both", "posted", "attempted"]).default("both"),
+  limit: z41.number().int().min(1).max(50).default(5),
   /** Opaque, per list. Only accepted with view 'posted' or 'attempted'. */
-  cursor: z40.string().max(200).optional()
+  cursor: z41.string().max(200).optional()
 }).strict();
 var LAUNCHER_POSTED_TASK_STATUSES = [
   // A create approval is pending or approving; the row carries `approvalId` for Review.
@@ -5082,9 +5413,9 @@ var LAUNCHER_POSTED_TASK_STATUSES = [
   "expired",
   "cancelled"
 ];
-var LauncherPostedTaskStatusSchema = z40.enum(LAUNCHER_POSTED_TASK_STATUSES);
+var LauncherPostedTaskStatusSchema = z41.enum(LAUNCHER_POSTED_TASK_STATUSES);
 var LAUNCHER_ATTEMPT_KINDS = ["claim", "pitch", "bid", "proof", "submit"];
-var LauncherAttemptKindSchema = z40.enum(LAUNCHER_ATTEMPT_KINDS);
+var LauncherAttemptKindSchema = z41.enum(LAUNCHER_ATTEMPT_KINDS);
 var LAUNCHER_ATTEMPT_OUTCOMES = [
   // A paid worker write (pitch, bid, paid submission) awaits the owner; `approvalId` set.
   "awaiting_approval",
@@ -5111,43 +5442,43 @@ var LAUNCHER_ATTEMPT_OUTCOMES = [
   // A sibling made a later worker write on the task, or holds its worker role now.
   "continued_by_sibling"
 ];
-var LauncherAttemptOutcomeSchema = z40.enum(LAUNCHER_ATTEMPT_OUTCOMES);
-var UsdcUnitsSchema = z40.string().regex(/^\d+$/);
-var LauncherPostedTaskSchema = z40.object({
+var LauncherAttemptOutcomeSchema = z41.enum(LAUNCHER_ATTEMPT_OUTCOMES);
+var UsdcUnitsSchema = z41.string().regex(/^\d+$/);
+var LauncherPostedTaskSchema = z41.object({
   /** Stable per row: `task:<taskId>`, `approval:<id>`, `operation:<id>` or `refusal:<id>`. */
-  key: z40.string(),
+  key: z41.string(),
   /** Null for drafts, refusals and publishes not resolved to a task yet. */
-  taskId: z40.string().nullable(),
-  title: z40.string().nullable(),
+  taskId: z41.string().nullable(),
+  title: z41.string().nullable(),
   /** The task mode as stored on tasks.mode, or as drafted. */
-  mode: z40.string().nullable(),
+  mode: z41.string().nullable(),
   /** USDC base units. */
   rewardUnits: UsdcUnitsSchema.nullable(),
   status: LauncherPostedTaskStatusSchema,
   /** Set while status is awaiting_approval. */
-  approvalId: z40.string().uuid().nullable(),
-  approvalExpiresAt: z40.string().nullable(),
+  approvalId: z41.string().uuid().nullable(),
+  approvalExpiresAt: z41.string().nullable(),
   /** Submissions; pitches for pitch mode; bids for auction mode. Null with no task. */
-  submissions: z40.number().int().nonnegative().nullable(),
+  submissions: z41.number().int().nonnegative().nullable(),
   /** The deadline that matters for the current status. */
-  deadlineAt: z40.string().nullable(),
+  deadlineAt: z41.string().nullable(),
   /** The rank-1 award recipient once completed; `memberName` when it is a hosted swarm member. */
-  winner: z40.object({ hosted: z40.boolean(), memberName: z40.string().nullable() }).nullable(),
+  winner: z41.object({ hosted: z41.boolean(), memberName: z41.string().nullable() }).nullable(),
   /** What publishing cost the swarm once the payment settled, in USDC base units. */
   paidUnits: UsdcUnitsSchema.nullable(),
   /** A machine code (HOSTED_MARKET_* or a marketplace error code) for the unpublished states. */
-  reasonCode: z40.string().nullable(),
+  reasonCode: z41.string().nullable(),
   /** The publishing transaction (the task's escrow transaction) when known. */
-  transactionHash: z40.string().nullable(),
-  createdAt: z40.string(),
-  updatedAt: z40.string()
+  transactionHash: z41.string().nullable(),
+  createdAt: z41.string(),
+  updatedAt: z41.string()
 });
-var LauncherAttemptedTaskSchema = z40.object({
+var LauncherAttemptedTaskSchema = z41.object({
   /** Stable per row: `task:<taskId>`, `approval:<id>` or `refusal:<id>`. */
-  key: z40.string(),
-  taskId: z40.string().nullable(),
-  title: z40.string().nullable(),
-  mode: z40.string().nullable(),
+  key: z41.string(),
+  taskId: z41.string().nullable(),
+  title: z41.string().nullable(),
+  mode: z41.string().nullable(),
   rewardUnits: UsdcUnitsSchema.nullable(),
   /** The kind of the agent's latest attempt on the task. */
   attempt: LauncherAttemptKindSchema,
@@ -5155,70 +5486,70 @@ var LauncherAttemptedTaskSchema = z40.object({
   /** The bid amount, or what was earned when won, in USDC base units. */
   amountUnits: UsdcUnitsSchema.nullable(),
   /** The sibling that continued the task or holds its worker role now. */
-  continuedBy: z40.object({ agentId: z40.string(), name: z40.string() }).nullable(),
-  approvalId: z40.string().uuid().nullable(),
+  continuedBy: z41.object({ agentId: z41.string(), name: z41.string() }).nullable(),
+  approvalId: z41.string().uuid().nullable(),
   /** A machine code for not_approved, blocked and did_not_go_through. */
-  reasonCode: z40.string().nullable(),
-  transactionHash: z40.string().nullable(),
-  createdAt: z40.string(),
-  updatedAt: z40.string()
+  reasonCode: z41.string().nullable(),
+  transactionHash: z41.string().nullable(),
+  createdAt: z41.string(),
+  updatedAt: z41.string()
 });
-var LauncherAgentMarketTasksSchema = z40.object({
-  counts: z40.object({
+var LauncherAgentMarketTasksSchema = z41.object({
+  counts: z41.object({
     /** Every Posted row, drafts and refused creates included. */
-    posted: z40.number().int().nonnegative(),
+    posted: z41.number().int().nonnegative(),
     /** awaiting_approval, publishing, open, in_progress, in_review, appealing and disputed. */
-    postedOpen: z40.number().int().nonnegative(),
+    postedOpen: z41.number().int().nonnegative(),
     /** Every Attempted row. */
-    attempted: z40.number().int().nonnegative(),
+    attempted: z41.number().int().nonnegative(),
     /** awaiting_approval, working and awaiting_result. */
-    attemptedActive: z40.number().int().nonnegative(),
-    won: z40.number().int().nonnegative(),
+    attemptedActive: z41.number().int().nonnegative(),
+    won: z41.number().int().nonnegative(),
     /** The sum of amountUnits over won rows. */
     earnedUnits: UsdcUnitsSchema
   }),
   /** Empty when view is 'attempted'. */
-  posted: z40.object({
-    items: z40.array(LauncherPostedTaskSchema),
-    nextCursor: z40.string().nullable()
+  posted: z41.object({
+    items: z41.array(LauncherPostedTaskSchema),
+    nextCursor: z41.string().nullable()
   }),
   /** Empty when view is 'posted'. */
-  attempted: z40.object({
-    items: z40.array(LauncherAttemptedTaskSchema),
-    nextCursor: z40.string().nullable()
+  attempted: z41.object({
+    items: z41.array(LauncherAttemptedTaskSchema),
+    nextCursor: z41.string().nullable()
   })
 });
-var LauncherMarketOverviewSchema = z40.object({
-  agents: z40.array(z40.object({ agentId: z40.string(), activeTasks: z40.number().int().nonnegative() }))
+var LauncherMarketOverviewSchema = z41.object({
+  agents: z41.array(z41.object({ agentId: z41.string(), activeTasks: z41.number().int().nonnegative() }))
 });
 
 // ../../packages/shared/dist/schemas/launcher-schedule.schemas.js
-import { z as z41 } from "zod";
+import { z as z42 } from "zod";
 var SCHEDULE_SCAN_SECONDS = 300;
-var LauncherScheduleControlSchema = z41.object({
-  agentId: z41.string().uuid(),
-  requestKey: z41.string().uuid(),
-  enabled: z41.boolean()
+var LauncherScheduleControlSchema = z42.object({
+  agentId: z42.string().uuid(),
+  requestKey: z42.string().uuid(),
+  enabled: z42.boolean()
 }).strict();
-var LauncherNextStepSchema = z41.discriminatedUnion("state", [
-  z41.object({
-    state: z41.literal("scheduled"),
-    delaySeconds: z41.number().int().min(SCHEDULE_SCAN_SECONDS).max(30 * 86400),
-    prompt: z41.string().trim().min(1).max(32768)
+var LauncherNextStepSchema = z42.discriminatedUnion("state", [
+  z42.object({
+    state: z42.literal("scheduled"),
+    delaySeconds: z42.number().int().min(SCHEDULE_SCAN_SECONDS).max(30 * 86400),
+    prompt: z42.string().trim().min(1).max(32768)
   }).strict(),
-  z41.object({
-    state: z41.literal("waiting"),
-    reason: z41.enum(["external", "owner", "funds"]),
-    prompt: z41.string().trim().min(1).max(32768)
+  z42.object({
+    state: z42.literal("waiting"),
+    reason: z42.enum(["external", "owner", "funds"]),
+    prompt: z42.string().trim().min(1).max(32768)
   }).strict(),
-  z41.object({ state: z41.literal("idle") }).strict()
+  z42.object({ state: z42.literal("idle") }).strict()
 ]);
-var LauncherScheduleNextSchema = z41.object({
-  agentId: z41.string().uuid(),
-  requestKey: z41.string().uuid(),
+var LauncherScheduleNextSchema = z42.object({
+  agentId: z42.string().uuid(),
+  requestKey: z42.string().uuid(),
   step: LauncherNextStepSchema
 }).strict();
-var LauncherScheduleStatusSchema = z41.enum([
+var LauncherScheduleStatusSchema = z42.enum([
   "disabled",
   "idle",
   "scheduled",
@@ -5233,65 +5564,65 @@ var LauncherScheduleStatusSchema = z41.enum([
   "waiting_funds",
   "source_failed"
 ]);
-var LauncherScheduleViewSchema = z41.object({
-  agentId: z41.string().uuid(),
-  enabled: z41.boolean(),
-  revision: z41.number().int(),
-  generation: z41.number().int(),
-  nextRunAt: z41.string().nullable(),
-  prompt: z41.string().nullable(),
-  waitingFor: z41.enum(["external", "owner", "funds"]).nullable(),
+var LauncherScheduleViewSchema = z42.object({
+  agentId: z42.string().uuid(),
+  enabled: z42.boolean(),
+  revision: z42.number().int(),
+  generation: z42.number().int(),
+  nextRunAt: z42.string().nullable(),
+  prompt: z42.string().nullable(),
+  waitingFor: z42.enum(["external", "owner", "funds"]).nullable(),
   status: LauncherScheduleStatusSchema,
-  label: z41.string(),
-  lastJobId: z41.string().nullable(),
-  asOf: z41.string(),
-  scanEverySeconds: z41.literal(SCHEDULE_SCAN_SECONDS)
+  label: z42.string(),
+  lastJobId: z42.string().nullable(),
+  asOf: z42.string(),
+  scanEverySeconds: z42.literal(SCHEDULE_SCAN_SECONDS)
 });
 
 // ../../packages/shared/dist/schemas/swarm-coordination.schemas.js
-import { z as z42 } from "zod";
-var SwarmCoordinationPermissionsSchema = z42.object({
-  create: z42.boolean().default(false),
-  dispatch: z42.boolean().default(false),
-  resume: z42.boolean().default(false)
+import { z as z43 } from "zod";
+var SwarmCoordinationPermissionsSchema = z43.object({
+  create: z43.boolean().default(false),
+  dispatch: z43.boolean().default(false),
+  resume: z43.boolean().default(false)
 }).strict();
-var SwarmProfileInputSchema = z42.object({
-  agentId: z42.string().uuid(),
-  requestKey: z42.string().uuid(),
-  name: z42.string().trim().min(1).max(100),
-  responsibility: z42.string().trim().max(500),
+var SwarmProfileInputSchema = z43.object({
+  agentId: z43.string().uuid(),
+  requestKey: z43.string().uuid(),
+  name: z43.string().trim().min(1).max(100),
+  responsibility: z43.string().trim().max(500),
   /**
    * The agent's instructions.md memory document (SM-24). Omit to leave it unchanged, e.g. when
    * it was written in the Memory tab beyond this editor's limit.
    */
-  instructions: z42.string().trim().max(16e3).optional(),
+  instructions: z43.string().trim().max(16e3).optional(),
   /**
    * The instructions.md version the editor loaded (`SwarmProfile.instructionsVersion`); a save
    * whose text differs is refused with MEMORY_VERSION_CONFLICT if the document moved on since.
    */
-  instructionsVersion: z42.number().int().min(0).optional(),
+  instructionsVersion: z43.number().int().min(0).optional(),
   permissions: SwarmCoordinationPermissionsSchema
 }).strict();
-var SwarmProfileSchema = z42.object({
-  available: z42.boolean().default(false),
-  agentId: z42.string().uuid(),
-  name: z42.string(),
-  responsibility: z42.string(),
-  instructions: z42.string(),
+var SwarmProfileSchema = z43.object({
+  available: z43.boolean().default(false),
+  agentId: z43.string().uuid(),
+  name: z43.string(),
+  responsibility: z43.string(),
+  instructions: z43.string(),
   /** Version of the live instructions.md memory document; 0 when there is none. */
-  instructionsVersion: z42.number().int().default(0),
-  version: z42.number().int(),
-  generation: z42.number().int(),
-  creatorAgentId: z42.string().uuid().nullable(),
-  creatorJobId: z42.string().uuid().nullable(),
+  instructionsVersion: z43.number().int().default(0),
+  version: z43.number().int(),
+  generation: z43.number().int(),
+  creatorAgentId: z43.string().uuid().nullable(),
+  creatorJobId: z43.string().uuid().nullable(),
   permissions: SwarmCoordinationPermissionsSchema
 });
-var SwarmMemberSchema = z42.object({
-  agentId: z42.string().uuid(),
-  name: z42.string(),
-  responsibility: z42.string(),
-  creatorAgentId: z42.string().uuid().nullable(),
-  state: z42.enum([
+var SwarmMemberSchema = z43.object({
+  agentId: z43.string().uuid(),
+  name: z43.string(),
+  responsibility: z43.string(),
+  creatorAgentId: z43.string().uuid().nullable(),
+  state: z43.enum([
     "idle",
     "queued",
     "working",
@@ -5302,95 +5633,95 @@ var SwarmMemberSchema = z42.object({
     "waiting",
     "failed"
   ]),
-  queuedCount: z42.number().int(),
-  jobId: z42.string().uuid().nullable(),
-  runId: z42.string().uuid().nullable(),
-  headline: z42.string().nullable(),
-  progress: z42.string().nullable(),
-  updatedAt: z42.string().nullable(),
-  freshness: z42.enum(["current", "stale", "unpublished"]),
-  waitingFor: z42.array(z42.string().uuid()),
-  nextRunAt: z42.string().nullable(),
-  lastResult: z42.object({
-    jobId: z42.string().uuid(),
-    summary: z42.string(),
-    artifacts: z42.array(z42.object({ artifactId: z42.string().uuid(), sha256: z42.string(), path: z42.string() })).optional(),
-    finishedAt: z42.string().nullable()
+  queuedCount: z43.number().int(),
+  jobId: z43.string().uuid().nullable(),
+  runId: z43.string().uuid().nullable(),
+  headline: z43.string().nullable(),
+  progress: z43.string().nullable(),
+  updatedAt: z43.string().nullable(),
+  freshness: z43.enum(["current", "stale", "unpublished"]),
+  waitingFor: z43.array(z43.string().uuid()),
+  nextRunAt: z43.string().nullable(),
+  lastResult: z43.object({
+    jobId: z43.string().uuid(),
+    summary: z43.string(),
+    artifacts: z43.array(z43.object({ artifactId: z43.string().uuid(), sha256: z43.string(), path: z43.string() })).optional(),
+    finishedAt: z43.string().nullable()
   }).nullable(),
   /**
    * The agent's most recently finished job, whatever its outcome. `lastResult` covers only a
    * completed job that published a summary; this is what an owner's "finished, come look" signal
    * reads. Optional so an overview from an older backend still parses.
    */
-  lastFinished: z42.object({
-    jobId: z42.string().uuid(),
+  lastFinished: z43.object({
+    jobId: z43.string().uuid(),
     status: LauncherJobStatusSchema.extract(["completed", "failed", "interrupted"]),
-    finishedAt: z42.string().nullable()
+    finishedAt: z43.string().nullable()
   }).nullable().optional(),
-  asOf: z42.string()
+  asOf: z43.string()
 });
-var SwarmOverviewSchema = z42.object({
-  members: z42.array(SwarmMemberSchema).max(10),
-  asOf: z42.string()
+var SwarmOverviewSchema = z43.object({
+  members: z43.array(SwarmMemberSchema).max(10),
+  asOf: z43.string()
 });
-var artifactIds = z42.array(z42.string().uuid()).max(8).default([]);
+var artifactIds = z43.array(z43.string().uuid()).max(8).default([]);
 var SwarmToolInputSchemas = {
-  sessions_list: z42.object({}).strict(),
-  sessions_inspect: z42.object({ agentId: z42.string().uuid() }).strict(),
-  sessions_create: z42.object({
-    intentKey: z42.string().trim().min(1).max(100),
-    name: z42.string().trim().min(1).max(100),
-    responsibility: z42.string().trim().min(1).max(500),
-    instructions: z42.string().trim().min(1).max(16e3),
-    prompt: z42.string().trim().min(1).max(16e3)
+  sessions_list: z43.object({}).strict(),
+  sessions_inspect: z43.object({ agentId: z43.string().uuid() }).strict(),
+  sessions_create: z43.object({
+    intentKey: z43.string().trim().min(1).max(100),
+    name: z43.string().trim().min(1).max(100),
+    responsibility: z43.string().trim().min(1).max(500),
+    instructions: z43.string().trim().min(1).max(16e3),
+    prompt: z43.string().trim().min(1).max(16e3)
   }).strict(),
-  sessions_send: z42.object({
-    agentId: z42.string().uuid(),
-    requestKey: z42.string().uuid(),
-    message: z42.string().trim().min(1).max(16e3),
+  sessions_send: z43.object({
+    agentId: z43.string().uuid(),
+    requestKey: z43.string().uuid(),
+    message: z43.string().trim().min(1).max(16e3),
     artifactIds
   }).strict(),
-  sessions_history: z42.object({
-    agentId: z42.string().uuid().optional(),
-    before: z42.number().int().positive().optional()
+  sessions_history: z43.object({
+    agentId: z43.string().uuid().optional(),
+    before: z43.number().int().positive().optional()
   }).strict(),
-  sessions_result: z42.object({ jobId: z42.string().uuid() }).strict(),
-  sessions_wait: z42.object({
-    jobIds: z42.array(z42.string().uuid()).min(1).max(8),
-    mode: z42.enum(["any", "all"]),
-    prompt: z42.string().trim().min(1).max(16e3),
-    timeoutSeconds: z42.number().int().min(60).max(604800)
+  sessions_result: z43.object({ jobId: z43.string().uuid() }).strict(),
+  sessions_wait: z43.object({
+    jobIds: z43.array(z43.string().uuid()).min(1).max(8),
+    mode: z43.enum(["any", "all"]),
+    prompt: z43.string().trim().min(1).max(16e3),
+    timeoutSeconds: z43.number().int().min(60).max(604800)
   }).strict(),
-  sessions_update_status: z42.object({
-    headline: z42.string().trim().min(1).max(200),
-    progress: z42.string().trim().max(1e3),
-    resultSummary: z42.string().trim().max(1e3).optional(),
+  sessions_update_status: z43.object({
+    headline: z43.string().trim().min(1).max(200),
+    progress: z43.string().trim().max(1e3),
+    resultSummary: z43.string().trim().max(1e3).optional(),
     artifactIds
   }).strict(),
-  sessions_read_artifact: z42.object({ artifactId: z42.string().uuid() }).strict()
+  sessions_read_artifact: z43.object({ artifactId: z43.string().uuid() }).strict()
 };
-var SwarmWaitSchema = z42.object({
-  id: z42.string().uuid(),
-  sourceJobId: z42.string().uuid(),
-  jobIds: z42.array(z42.string().uuid()),
-  state: z42.enum(["pending", "delivered", "cancelled"]),
-  reason: z42.string().nullable(),
-  deadline: z42.string(),
-  continuationJobId: z42.string().uuid().nullable()
+var SwarmWaitSchema = z43.object({
+  id: z43.string().uuid(),
+  sourceJobId: z43.string().uuid(),
+  jobIds: z43.array(z43.string().uuid()),
+  state: z43.enum(["pending", "delivered", "cancelled"]),
+  reason: z43.string().nullable(),
+  deadline: z43.string(),
+  continuationJobId: z43.string().uuid().nullable()
 });
 
 // ../../packages/shared/dist/schemas/direct-agent-checkpoint.schemas.js
-import { z as z46 } from "zod";
+import { z as z47 } from "zod";
 
 // ../../packages/shared/dist/schemas/turn-attribution.schemas.js
-import { z as z43 } from "zod";
+import { z as z44 } from "zod";
 var TURN_ATTRIBUTION_RECORD_VERSION = 1;
-var TurnAttributionIdentitySchema = z43.object({
-  sessionId: z43.string().min(1).max(256),
-  turnId: z43.string().min(1).max(256),
+var TurnAttributionIdentitySchema = z44.object({
+  sessionId: z44.string().min(1).max(256),
+  turnId: z44.string().min(1).max(256),
   /** Non-null exactly for native helpers; a root or maintenance turn has no subagent. */
-  subagentId: z43.string().min(1).max(256).nullable(),
-  role: z43.enum(ROUTING_EXECUTION_ROLES)
+  subagentId: z44.string().min(1).max(256).nullable(),
+  role: z44.enum(ROUTING_EXECUTION_ROLES)
 }).strict().superRefine((identity, ctx) => {
   if (identity.role === "native_helper" && identity.subagentId === null)
     ctx.addIssue({ code: "custom", message: "A native helper identity needs its subagent id" });
@@ -5398,18 +5729,18 @@ var TurnAttributionIdentitySchema = z43.object({
     ctx.addIssue({ code: "custom", message: "Only a native helper identity carries a subagent" });
 });
 var PinnedTurnAttributionSchema = RoutingAttributionSchema.extend({
-  operationId: z43.string().uuid().nullable(),
-  inheritedFrom: z43.string().min(1).max(1024).nullable()
+  operationId: z44.string().uuid().nullable(),
+  inheritedFrom: z44.string().min(1).max(1024).nullable()
 }).strict();
 var MAX_ATTRIBUTION_EPOCHS = 32;
 var TurnAttributionEpochSchema = PinnedTurnAttributionSchema.extend({
-  epoch: z43.number().int().positive().max(MAX_ATTRIBUTION_EPOCHS)
+  epoch: z44.number().int().positive().max(MAX_ATTRIBUTION_EPOCHS)
 }).strict();
-var TurnAttributionLedgerSchema = z43.object({
-  version: z43.literal(TURN_ATTRIBUTION_RECORD_VERSION),
-  epochs: z43.array(TurnAttributionEpochSchema).max(MAX_ATTRIBUTION_EPOCHS),
+var TurnAttributionLedgerSchema = z44.object({
+  version: z44.literal(TURN_ATTRIBUTION_RECORD_VERSION),
+  epochs: z44.array(TurnAttributionEpochSchema).max(MAX_ATTRIBUTION_EPOCHS),
   /** `turnAttributionKey()` to epoch number. Bounded by the provider's own history limit. */
-  turns: z43.record(z43.number().int().positive().max(MAX_ATTRIBUTION_EPOCHS))
+  turns: z44.record(z44.number().int().positive().max(MAX_ATTRIBUTION_EPOCHS))
 }).strict().superRefine((ledger, ctx) => {
   const ids = ledger.epochs.map((entry) => entry.epoch);
   if (new Set(ids).size !== ids.length)
@@ -5418,13 +5749,13 @@ var TurnAttributionLedgerSchema = z43.object({
     if (!ids.includes(epoch))
       ctx.addIssue({ code: "custom", message: `Turn references unknown epoch ${epoch}` });
 });
-var ManagedTurnUsageSchema = z43.object({
-  inputTokens: z43.number().int().nonnegative(),
-  outputTokens: z43.number().int().nonnegative(),
-  totalTokens: z43.number().int().nonnegative(),
-  cacheReadTokens: z43.number().int().nonnegative().nullable(),
-  cacheWriteTokens: z43.number().int().nonnegative().nullable(),
-  reasoningTokens: z43.number().int().nonnegative().nullable()
+var ManagedTurnUsageSchema = z44.object({
+  inputTokens: z44.number().int().nonnegative(),
+  outputTokens: z44.number().int().nonnegative(),
+  totalTokens: z44.number().int().nonnegative(),
+  cacheReadTokens: z44.number().int().nonnegative().nullable(),
+  cacheWriteTokens: z44.number().int().nonnegative().nullable(),
+  reasoningTokens: z44.number().int().nonnegative().nullable()
 }).strict().superRefine((usage, ctx) => {
   if (usage.totalTokens !== usage.inputTokens + usage.outputTokens)
     ctx.addIssue({ code: "custom", message: "Total tokens must equal input plus output" });
@@ -5433,14 +5764,14 @@ var ManagedTurnUsageSchema = z43.object({
   if ((usage.reasoningTokens ?? 0) > usage.outputTokens)
     ctx.addIssue({ code: "custom", message: "Reasoning cannot exceed output" });
 });
-var TurnAttributionStampSchema = z43.object({
-  recordVersion: z43.literal(TURN_ATTRIBUTION_RECORD_VERSION),
+var TurnAttributionStampSchema = z44.object({
+  recordVersion: z44.literal(TURN_ATTRIBUTION_RECORD_VERSION),
   identity: TurnAttributionIdentitySchema,
   attribution: PinnedTurnAttributionSchema
 }).strict();
 
 // ../../packages/shared/dist/schemas/user-skills.schemas.js
-import { z as z44 } from "zod";
+import { z as z45 } from "zod";
 import { parseDocument } from "yaml";
 var USER_SKILL_LIMITS = {
   files: 20,
@@ -5451,18 +5782,18 @@ var USER_SKILL_LIMITS = {
   assignedFiles: 100
 };
 var bytes = (value) => new TextEncoder().encode(value).length;
-var UserSkillPathSchema = z44.string().min(1).max(240).refine((path8) => {
+var UserSkillPathSchema = z45.string().min(1).max(240).refine((path8) => {
   const parts = path8.split("/");
   return parts.length <= 8 && parts.every((part) => part && part !== "." && part !== ".." && bytes(part) <= 255 && !part.startsWith(".") && ![...part].some((c) => c === "\\" || c.charCodeAt(0) < 32 || c.charCodeAt(0) === 127)) && /\.(md|txt|json|yaml|yml)$/i.test(path8) && (path8 === "SKILL.md" || !parts.some((p) => p.toLowerCase() === "skill.md"));
 }, "Use a relative text-file path; only the main SKILL.md entrypoint is allowed");
-var UserSkillFileSchema = z44.object({
+var UserSkillFileSchema = z45.object({
   path: UserSkillPathSchema,
-  content: z44.string().max(USER_SKILL_LIMITS.bytes).refine((s) => ![...s].some((c) => c.charCodeAt(0) < 32 && ![9, 10, 13].includes(c.charCodeAt(0))) && bytes(s) <= USER_SKILL_LIMITS.bytes, "File exceeds 1 MiB or contains binary data")
+  content: z45.string().max(USER_SKILL_LIMITS.bytes).refine((s) => ![...s].some((c) => c.charCodeAt(0) < 32 && ![9, 10, 13].includes(c.charCodeAt(0))) && bytes(s) <= USER_SKILL_LIMITS.bytes, "File exceeds 1 MiB or contains binary data")
 }).strict();
-var UserSkillDraftBundleSchema = z44.object({
-  name: z44.string().trim().max(100),
-  description: z44.string().trim().max(300),
-  files: z44.array(UserSkillFileSchema).min(1).max(USER_SKILL_LIMITS.files)
+var UserSkillDraftBundleSchema = z45.object({
+  name: z45.string().trim().max(100),
+  description: z45.string().trim().max(300),
+  files: z45.array(UserSkillFileSchema).min(1).max(USER_SKILL_LIMITS.files)
 }).strict().superRefine((bundle, ctx) => {
   const paths = bundle.files.map((f) => f.path.toLowerCase());
   if (new Set(paths).size !== paths.length || paths.some((p) => paths.some((other) => other.startsWith(p + "/"))))
@@ -5473,103 +5804,103 @@ var UserSkillDraftBundleSchema = z44.object({
   if (bundle.files.reduce((total, f) => total + bytes(f.content), 0) > USER_SKILL_LIMITS.bytes)
     ctx.addIssue({ code: "custom", message: "A skill can contain at most 1 MiB of text" });
 });
-var UserSkillPinSchema = z44.object({
-  skillId: z44.string().uuid(),
-  version: z44.number().int().positive(),
-  digest: z44.string().regex(/^[a-f0-9]{64}$/)
+var UserSkillPinSchema = z45.object({
+  skillId: z45.string().uuid(),
+  version: z45.number().int().positive(),
+  digest: z45.string().regex(/^[a-f0-9]{64}$/)
 }).strict();
-var UserSkillPinsSchema = z44.array(UserSkillPinSchema).max(USER_SKILL_LIMITS.assigned);
-var UserSkillIdSchema = z44.object({ skillId: z44.string().uuid() });
+var UserSkillPinsSchema = z45.array(UserSkillPinSchema).max(USER_SKILL_LIMITS.assigned);
+var UserSkillIdSchema = z45.object({ skillId: z45.string().uuid() });
 var UserSkillDraftInputSchema = UserSkillIdSchema.extend({
-  requestKey: z44.string().uuid(),
-  expectedRevision: z44.number().int().nonnegative(),
+  requestKey: z45.string().uuid(),
+  expectedRevision: z45.number().int().nonnegative(),
   bundle: UserSkillDraftBundleSchema
 });
 var UserSkillSaveVersionSchema = UserSkillIdSchema.extend({
-  requestKey: z44.string().uuid(),
-  expectedRevision: z44.number().int().nonnegative(),
-  note: z44.string().trim().max(500).default(""),
-  restoreVersion: z44.number().int().positive().optional()
+  requestKey: z45.string().uuid(),
+  expectedRevision: z45.number().int().nonnegative(),
+  note: z45.string().trim().max(500).default(""),
+  restoreVersion: z45.number().int().positive().optional()
 });
 var UserSkillAssignSchema = UserSkillIdSchema.extend({
-  requestKey: z44.string().uuid(),
-  version: z44.number().int().positive().nullable(),
-  agents: z44.array(z44.object({ agentId: z44.string().uuid(), expectedRevision: z44.number().int().nonnegative() })).min(1).max(100)
+  requestKey: z45.string().uuid(),
+  version: z45.number().int().positive().nullable(),
+  agents: z45.array(z45.object({ agentId: z45.string().uuid(), expectedRevision: z45.number().int().nonnegative() })).min(1).max(100)
 });
 var UserSkillArchiveSchema = UserSkillIdSchema.extend({
-  requestKey: z44.string().uuid(),
-  expectedRevision: z44.number().int().nonnegative(),
-  archived: z44.boolean(),
-  removeAssignments: z44.boolean().default(false)
-});
-var UserSkillSummarySchema = z44.object({
-  id: z44.string().uuid(),
-  name: z44.string(),
-  description: z44.string(),
-  archived: z44.boolean(),
-  latestVersion: z44.number().int(),
-  revision: z44.number().int(),
-  hasDraft: z44.boolean(),
-  assignedCount: z44.number().int(),
-  outdatedCount: z44.number().int(),
-  updatedAt: z44.string()
-});
-var UserSkillAgentSchema = z44.object({
-  agentId: z44.string().uuid(),
-  name: z44.string(),
-  managed: z44.boolean().optional(),
-  paused: z44.boolean(),
-  working: z44.boolean(),
-  revision: z44.number().int(),
+  requestKey: z45.string().uuid(),
+  expectedRevision: z45.number().int().nonnegative(),
+  archived: z45.boolean(),
+  removeAssignments: z45.boolean().default(false)
+});
+var UserSkillSummarySchema = z45.object({
+  id: z45.string().uuid(),
+  name: z45.string(),
+  description: z45.string(),
+  archived: z45.boolean(),
+  latestVersion: z45.number().int(),
+  revision: z45.number().int(),
+  hasDraft: z45.boolean(),
+  assignedCount: z45.number().int(),
+  outdatedCount: z45.number().int(),
+  updatedAt: z45.string()
+});
+var UserSkillAgentSchema = z45.object({
+  agentId: z45.string().uuid(),
+  name: z45.string(),
+  managed: z45.boolean().optional(),
+  paused: z45.boolean(),
+  working: z45.boolean(),
+  revision: z45.number().int(),
   desired: UserSkillPinsSchema,
   observed: UserSkillPinsSchema,
-  state: z44.enum(["pending", "applying", "ready", "error"]),
-  errorCode: z44.string().nullable(),
-  sessionId: z44.string().nullable()
-});
-var UserSkillLibrarySchema = z44.object({
-  skills: z44.array(UserSkillSummarySchema),
-  agents: z44.array(UserSkillAgentSchema)
-});
-var UserSkillVersionSchema = z44.object({
-  version: z44.number().int(),
-  digest: z44.string(),
-  name: z44.string(),
-  description: z44.string(),
-  bytes: z44.number().int(),
-  fileCount: z44.number().int(),
-  note: z44.string(),
-  createdAt: z44.string()
-});
-var UserSkillDetailSchema = z44.object({
+  state: z45.enum(["pending", "applying", "ready", "error"]),
+  errorCode: z45.string().nullable(),
+  sessionId: z45.string().nullable()
+});
+var UserSkillLibrarySchema = z45.object({
+  skills: z45.array(UserSkillSummarySchema),
+  agents: z45.array(UserSkillAgentSchema)
+});
+var UserSkillVersionSchema = z45.object({
+  version: z45.number().int(),
+  digest: z45.string(),
+  name: z45.string(),
+  description: z45.string(),
+  bytes: z45.number().int(),
+  fileCount: z45.number().int(),
+  note: z45.string(),
+  createdAt: z45.string()
+});
+var UserSkillDetailSchema = z45.object({
   skill: UserSkillSummarySchema,
   draft: UserSkillDraftBundleSchema.nullable(),
-  versions: z44.array(UserSkillVersionSchema),
-  agents: z44.array(UserSkillAgentSchema)
+  versions: z45.array(UserSkillVersionSchema),
+  agents: z45.array(UserSkillAgentSchema)
 });
 
 // ../../packages/shared/dist/schemas/managed-billing.schemas.js
-import { z as z45 } from "zod";
-var id = z45.string().min(1).max(256);
-var usd = z45.string().regex(/^(0|[1-9]\d{0,9})(\.\d{1,6})?$/);
+import { z as z46 } from "zod";
+var id = z46.string().min(1).max(256);
+var usd = z46.string().regex(/^(0|[1-9]\d{0,9})(\.\d{1,6})?$/);
 var SANDBOX_CONTAINER_SIZES = ["small", "medium", "large"];
-var ManagedCostPolicySchema = z45.object({
+var ManagedCostPolicySchema = z46.object({
   version: id,
-  region: z45.enum(["global", "regional"]),
+  region: z46.enum(["global", "regional"]),
   ownerDailyUsd: usd,
   platformDailyUsd: usd,
   computeReserveUsd: usd,
   retainedResourceDailyUsd: usd,
-  maxConcurrentOperations: z45.number().int().min(1).max(64),
-  maxUnresolvedOperations: z45.number().int().min(1).max(1e4),
-  maxUnresolvedAgeMs: z45.number().int().min(6e4).max(6048e5),
-  reconciliationMaxAgeMs: z45.number().int().min(6e4).max(6048e5),
+  maxConcurrentOperations: z46.number().int().min(1).max(64),
+  maxUnresolvedOperations: z46.number().int().min(1).max(1e4),
+  maxUnresolvedAgeMs: z46.number().int().min(6e4).max(6048e5),
+  reconciliationMaxAgeMs: z46.number().int().min(6e4).max(6048e5),
   /**
    * The models this policy qualifies. Each must have a published supplier rate, which supplier
    * exposure is reserved and settled from; a policy stored before a model was added still
    * parses to exactly its stored JSON.
    */
-  models: z45.array(z45.enum([
+  models: z46.array(z46.enum([
     "gpt-5.6-luna",
     "gpt-5.6-sol",
     "gpt-6-astra",
@@ -5577,27 +5908,27 @@ var ManagedCostPolicySchema = z45.object({
     "gpt-6-sol",
     "gpt-6.1-sol"
   ])).min(1),
-  nativeHelpersQualified: z45.boolean(),
-  corrections: z45.enum(["manual", "refund_downward"]),
-  approvalEvidence: z45.string().trim().min(1).max(256),
+  nativeHelpersQualified: z46.boolean(),
+  corrections: z46.enum(["manual", "refund_downward"]),
+  approvalEvidence: z46.string().trim().min(1).max(256),
   /**
    * Hosted sandbox pricing terms. Optional, and deliberately without schema defaults: a policy
    * stored before these terms existed must parse to exactly its stored JSON, or its immutable
    * digest would no longer match. `managedSandboxTerms` supplies the defaults at use.
    */
-  sandbox: z45.object({
-    memory: z45.enum(SANDBOX_MEMORY_TIERS).optional(),
-    granularity: z45.enum(SANDBOX_BILLING_GRANULARITIES).optional(),
+  sandbox: z46.object({
+    memory: z46.enum(SANDBOX_MEMORY_TIERS).optional(),
+    granularity: z46.enum(SANDBOX_BILLING_GRANULARITIES).optional(),
     /** Assumed provider deletion after activity and keep-alives stop; not configurable there. */
-    idleExpiryMs: z45.number().int().min(6e4).max(864e5).optional(),
+    idleExpiryMs: z46.number().int().min(6e4).max(864e5).optional(),
     /**
      * The memory tier each container size is billed at (ADR-0192). Optional per size and
      * without defaults, for the same digest reason; `managedSandboxTerms` supplies them.
      */
-    sizes: z45.object({
-      small: z45.enum(SANDBOX_MEMORY_TIERS).optional(),
-      medium: z45.enum(SANDBOX_MEMORY_TIERS).optional(),
-      large: z45.enum(SANDBOX_MEMORY_TIERS).optional()
+    sizes: z46.object({
+      small: z46.enum(SANDBOX_MEMORY_TIERS).optional(),
+      medium: z46.enum(SANDBOX_MEMORY_TIERS).optional(),
+      large: z46.enum(SANDBOX_MEMORY_TIERS).optional()
     }).strict().optional()
   }).strict().optional()
 }).strict().refine((p) => usdToMicro(p.ownerDailyUsd) > 0n && usdToMicro(p.platformDailyUsd) > 0n && usdToMicro(p.computeReserveUsd) > 0n && usdToMicro(p.retainedResourceDailyUsd) > 0n, {
@@ -5607,11 +5938,11 @@ function usdToMicro(value) {
   const [whole, fractional = ""] = usd.parse(value).split(".");
   return BigInt(whole + fractional.padEnd(6, "0"));
 }
-var ManagedTurnEvidenceSchema = z45.object({
+var ManagedTurnEvidenceSchema = z46.object({
   sessionId: id,
   turnId: id,
   subagentId: id.nullable(),
-  status: z45.enum([
+  status: z46.enum([
     "completed",
     "failed",
     "cancelled",
@@ -5621,11 +5952,11 @@ var ManagedTurnEvidenceSchema = z45.object({
   ]),
   usage: AllowanceReportedUsageSchema.nullable()
 }).strict();
-var ManagedWorkEvidenceSchema = z45.object({
+var ManagedWorkEvidenceSchema = z46.object({
   sessionId: id,
   rootTurnId: id,
-  complete: z45.boolean(),
-  turns: z45.array(ManagedTurnEvidenceSchema).min(1).max(2e3)
+  complete: z46.boolean(),
+  turns: z46.array(ManagedTurnEvidenceSchema).min(1).max(2e3)
 }).strict();
 
 // ../../packages/shared/dist/schemas/taskmarket-mcp.schemas.js
@@ -5644,124 +5975,124 @@ var DIRECT_TOOL_GROUPS = [
   "memory"
 ];
 var DIRECT_TURN_RETRY_LIMIT = 1;
-var DirectRuntimeConfigurationSchema = z46.object({
-  platformToolsVersion: z46.literal(1).optional(),
-  swarm: z46.boolean(),
-  userSkills: z46.object({ revision: z46.number().int().nonnegative(), pins: UserSkillPinsSchema }).optional(),
-  integrations: z46.literal(true).optional(),
-  taskmarketToolsVersion: z46.literal(1).optional(),
-  integrationToolsVersion: z46.literal(2).optional(),
+var DirectRuntimeConfigurationSchema = z47.object({
+  platformToolsVersion: z47.literal(1).optional(),
+  swarm: z47.boolean(),
+  userSkills: z47.object({ revision: z47.number().int().nonnegative(), pins: UserSkillPinsSchema }).optional(),
+  integrations: z47.literal(true).optional(),
+  taskmarketToolsVersion: z47.literal(1).optional(),
+  integrationToolsVersion: z47.literal(2).optional(),
   /**
    * Memory tools and the memory contract (SM-20, SM-25); a new version replaces the session.
    * 2: swarm writes (proposals under taint, SM-51) and `memory_search` history (SM-61).
    */
-  memoryToolsVersion: z46.union([z46.literal(1), z46.literal(2)]).optional(),
+  memoryToolsVersion: z47.union([z47.literal(1), z47.literal(2)]).optional(),
   /**
    * The memory contract describes the core.md template (#726, MEMORY_CORE_TEMPLATE_ENABLED).
    * Absent when off, so turning it on or off replaces the session like any contract change.
    */
-  memoryCoreTemplate: z46.literal(true).optional(),
-  nativeSubagents: z46.literal(2).optional(),
-  inbox: z46.literal(1).optional(),
+  memoryCoreTemplate: z47.literal(true).optional(),
+  nativeSubagents: z47.literal(2).optional(),
+  inbox: z47.literal(1).optional(),
   /**
    * The hosted container size the session is created with (ADR-0192). Absent on configurations
    * written before sizes, whose sessions request none and run at the provider's medium default;
    * a change of size replaces the session like any configuration change.
    */
-  containerSize: z46.enum(SANDBOX_CONTAINER_SIZES).optional(),
+  containerSize: z47.enum(SANDBOX_CONTAINER_SIZES).optional(),
   /**
    * The session runs with no sandbox (ADR-0194): no shell, no files, and its first input sent
    * with the create. Absent is a hosted sandbox, as every session had before; a change replaces
    * the session like any configuration change.
    */
-  workspace: z46.literal("none").optional(),
-  profile: z46.object({
-    version: z46.number().int().nonnegative(),
-    responsibility: z46.string().max(500),
+  workspace: z47.literal("none").optional(),
+  profile: z47.object({
+    version: z47.number().int().nonnegative(),
+    responsibility: z47.string().max(500),
     /**
      * Standing instructions frozen into the session. Absent when memory tools are on (SM-24):
      * they then reach the model through the pinned memory core, so editing them does not
      * replace the session. Bounded by the memory document cap, their source of truth.
      */
-    instructions: z46.string().max(65536).optional()
+    instructions: z47.string().max(65536).optional()
   }).optional(),
   /**
    * Tool groups the session defers behind tool search, in `DIRECT_TOOL_GROUPS` order. Only groups
    * the session actually has are listed, so deferring a group an agent does not use changes
    * nothing for it; a change to the list replaces the session like any tool change.
    */
-  deferredTools: z46.array(z46.enum(DIRECT_TOOL_GROUPS)).min(1).max(DIRECT_TOOL_GROUPS.length).optional(),
+  deferredTools: z47.array(z47.enum(DIRECT_TOOL_GROUPS)).min(1).max(DIRECT_TOOL_GROUPS.length).optional(),
   /**
    * The session reaches the read-only Taskmarket MCP server (ADR-0207): the server URL
    * and the vault its credential is in, both fixed when the session is created, and the tools it
    * may call. Absent when not attached; a change replaces the session like any configuration
    * change.
    */
-  mcp: z46.object({
-    serverUrl: z46.string().url().max(2048),
-    vaultId: z46.string().min(1).max(256),
-    tools: z46.array(z46.string().regex(/^[a-z][a-z0-9_]{0,63}$/)).min(1).max(16)
+  mcp: z47.object({
+    serverUrl: z47.string().url().max(2048),
+    vaultId: z47.string().min(1).max(256),
+    tools: z47.array(z47.string().regex(/^[a-z][a-z0-9_]{0,63}$/)).min(1).max(16)
   }).strict().optional()
 });
-var DirectMcpCredentialSchema = z46.object({
-  vaultId: z46.string().min(1).max(256),
+var DirectMcpCredentialSchema = z47.object({
+  vaultId: z47.string().min(1).max(256),
   /** The server URL the credential is bound to; the provider cannot change it in place. */
-  serverUrl: z46.string().url().max(2048),
-  credentialId: z46.string().min(1).max(256),
-  tokenId: z46.string().uuid(),
-  tokenExpiresAt: z46.string().datetime(),
+  serverUrl: z47.string().url().max(2048),
+  credentialId: z47.string().min(1).max(256),
+  tokenId: z47.string().uuid(),
+  tokenExpiresAt: z47.string().datetime(),
   /** What the current token may read: never more than the deployment allows the agent now. */
-  scopes: z46.array(z46.enum(TASKMARKET_MCP_TOKEN_SCOPES)).min(1).max(TASKMARKET_MCP_TOKEN_SCOPES.length),
+  scopes: z47.array(z47.enum(TASKMARKET_MCP_TOKEN_SCOPES)).min(1).max(TASKMARKET_MCP_TOKEN_SCOPES.length),
   /** Tokens the credential held before, kept until their revocation is recorded. */
-  retiring: z46.array(z46.string().uuid()).min(1).max(16).optional(),
+  retiring: z47.array(z47.string().uuid()).min(1).max(16).optional(),
   /**
    * MCP was turned off while a session that names the credential was kept: every token of the
    * agent is revoked, and the credential holds none that works until a fresh one is rotated in.
    */
-  suspended: z46.literal(true).optional()
+  suspended: z47.literal(true).optional()
 }).strict();
-var DirectFunctionCallSchema = z46.object({
-  name: z46.string().min(1).max(100),
-  argumentHash: z46.string().regex(/^[a-f0-9]{64}$/),
-  state: z46.enum(["prepared", "executing", "answered"]),
-  reply: z46.object({
-    success: z46.boolean(),
-    output: z46.string().max(131072).optional(),
-    error: z46.string().max(512).optional()
+var DirectFunctionCallSchema = z47.object({
+  name: z47.string().min(1).max(100),
+  argumentHash: z47.string().regex(/^[a-f0-9]{64}$/),
+  state: z47.enum(["prepared", "executing", "answered"]),
+  reply: z47.object({
+    success: z47.boolean(),
+    output: z47.string().max(131072).optional(),
+    error: z47.string().max(512).optional()
   }).optional()
 });
-var DirectRouteSelectionSchema = z46.object({
-  operationId: z46.string().uuid(),
+var DirectRouteSelectionSchema = z47.object({
+  operationId: z47.string().uuid(),
   mechanism: RoutingMechanismSchema,
   selected: ExecutorSettingsSchema,
-  policyVersion: z46.string().min(1).max(200),
-  rateVersion: z46.string().min(1).max(200)
+  policyVersion: z47.string().min(1).max(200),
+  rateVersion: z47.string().min(1).max(200)
 }).strict();
-var DirectRouteConfirmationSchema = z46.object({
+var DirectRouteConfirmationSchema = z47.object({
   /** The routing operation whose selection this confirms, never another operation's. */
-  operationId: z46.string().uuid(),
+  operationId: z47.string().uuid(),
   /** The job whose dispatch fence produced it. */
-  jobId: z46.string(),
+  jobId: z47.string(),
   settings: ExecutorSettingsSchema,
-  observedAt: z46.string().datetime(),
+  observedAt: z47.string().datetime(),
   /**
    * Whether the same settings were still observed after the provider accepted the input.
    *
    * False is not a failure: it is the state between the confirming read and the verification,
    * and the state a worker that crashed in that window resumes into.
    */
-  verifiedAfterDispatch: z46.boolean()
+  verifiedAfterDispatch: z47.boolean()
 }).strict();
 var DIRECT_ROUTE_DISPATCH_BINDINGS = ["not_dispatched", "bound", "contested"];
 var DirectPendingRouteSchema = DirectRouteSelectionSchema.extend({
   /** The job this route was selected for. A route never travels to another job. */
-  jobId: z46.string(),
-  settingsPhase: z46.enum(ROUTING_SETTINGS_TRANSITION_STATES),
-  requestedAt: z46.string().datetime().nullable(),
-  confirmedAt: z46.string().datetime().nullable(),
+  jobId: z47.string(),
+  settingsPhase: z47.enum(ROUTING_SETTINGS_TRANSITION_STATES),
+  requestedAt: z47.string().datetime().nullable(),
+  confirmedAt: z47.string().datetime().nullable(),
   /** Readback is evidence about the session, never a source of attribution. */
-  readbackModelId: z46.string().min(1).max(256).nullable(),
-  lostResponse: z46.boolean(),
+  readbackModelId: z47.string().min(1).max(256).nullable(),
+  lostResponse: z47.boolean(),
   /**
    * SPEC-0018 R3.4. How far this job's input binding got.
    *
@@ -5769,27 +6100,27 @@ var DirectPendingRouteSchema = DirectRouteSelectionSchema.extend({
    * `not_dispatched` -- the honest reading of a record that predates the check -- instead of
    * decoding as a binding nobody verified.
    */
-  dispatchBinding: z46.enum(DIRECT_ROUTE_DISPATCH_BINDINGS).default("not_dispatched")
+  dispatchBinding: z47.enum(DIRECT_ROUTE_DISPATCH_BINDINGS).default("not_dispatched")
 }).strict();
-var DirectUsageOperationSchema = z46.object({
-  operationId: z46.string().min(1).max(200),
-  purpose: z46.enum(["work", "maintenance", "retry"]),
-  tokenCeiling: z46.number().int().positive(),
-  turnId: z46.string().min(1).max(256).nullable(),
-  phase: z46.enum(["reserving", "reserved", "dispatched", "settled", "unresolved"]),
-  billingBaseline: z46.array(z46.string().min(1).max(256)).max(2e3).optional()
+var DirectUsageOperationSchema = z47.object({
+  operationId: z47.string().min(1).max(200),
+  purpose: z47.enum(["work", "maintenance", "retry"]),
+  tokenCeiling: z47.number().int().positive(),
+  turnId: z47.string().min(1).max(256).nullable(),
+  phase: z47.enum(["reserving", "reserved", "dispatched", "settled", "unresolved"]),
+  billingBaseline: z47.array(z47.string().min(1).max(256)).max(2e3).optional()
 }).strict();
-var DirectProjectSnapshotSchema = z46.object({
-  id: z46.string().regex(/^[a-f0-9]{64}$/),
-  key: z46.string().max(512),
-  sha256: z46.string().regex(/^[a-f0-9]{64}$/),
-  sessionId: z46.string().min(1).max(256),
-  turnId: z46.string().min(1).max(256),
-  setupHash: z46.string().regex(/^[a-f0-9]{64}$/)
+var DirectProjectSnapshotSchema = z47.object({
+  id: z47.string().regex(/^[a-f0-9]{64}$/),
+  key: z47.string().max(512),
+  sha256: z47.string().regex(/^[a-f0-9]{64}$/),
+  sessionId: z47.string().min(1).max(256),
+  turnId: z47.string().min(1).max(256),
+  setupHash: z47.string().regex(/^[a-f0-9]{64}$/)
 }).strict();
-var DirectPendingSchema = z46.object({
-  jobId: z46.string(),
-  baseline: z46.array(z46.string()),
+var DirectPendingSchema = z47.object({
+  jobId: z47.string(),
+  baseline: z47.array(z47.string()),
   /**
    * The run's dispatch-group identity, carried on every usage event this job writes.
    *
@@ -5797,7 +6128,7 @@ var DirectPendingSchema = z46.object({
    * holds live in `operations` below, one per turn. This stays because the out-of-band
    * reconciler's stored observations are keyed on it, and renaming it would orphan them.
    */
-  reservationId: z46.string(),
+  reservationId: z47.string(),
   /**
    * SPEC-0015 M4.2. The metered model operations this job has taken, in dispatch order.
    *
@@ -5809,27 +6140,27 @@ var DirectPendingSchema = z46.object({
    * Bounded at four: a job dispatches at most one work turn and one checkpoint-maintenance
    * turn, and the bound is what stops a recovery loop from growing the checkpoint.
    */
-  operations: z46.array(DirectUsageOperationSchema).max(4).optional(),
-  runId: z46.string().uuid().optional(),
-  phase: z46.enum(["creating", "preparing", "dispatching", "following"]).optional(),
-  deadline: z46.number().optional(),
+  operations: z47.array(DirectUsageOperationSchema).max(4).optional(),
+  runId: z47.string().uuid().optional(),
+  phase: z47.enum(["creating", "preparing", "dispatching", "following"]).optional(),
+  deadline: z47.number().optional(),
   // Exact ordinary input, saved before dispatch. Legacy checkpoints cannot be replayed.
-  dispatch: z46.object({
-    text: z46.string(),
-    key: z46.string(),
-    attempts: z46.number().int().min(0).max(2),
-    acknowledged: z46.boolean(),
-    cancelled: z46.boolean()
+  dispatch: z47.object({
+    text: z47.string(),
+    key: z47.string(),
+    attempts: z47.number().int().min(0).max(2),
+    acknowledged: z47.boolean(),
+    cancelled: z47.boolean()
   }).optional(),
-  turnId: z46.string().optional(),
-  creationInput: z46.boolean().optional(),
+  turnId: z47.string().optional(),
+  creationInput: z47.boolean().optional(),
   /**
    * The skill files the session this job creates is sent (ADR-0203), saved before the
    * create, so a create whose response is lost is recovered with them as its `skillBundle`.
    */
-  skillBundle: z46.object({
-    docsHash: z46.string().regex(/^[a-f0-9]{64}$/),
-    inventoryHash: z46.string().regex(/^[a-f0-9]{64}$/)
+  skillBundle: z47.object({
+    docsHash: z47.string().regex(/^[a-f0-9]{64}$/),
+    inventoryHash: z47.string().regex(/^[a-f0-9]{64}$/)
   }).strict().optional(),
   // `contextRetry` (a context-overflow retry) and `memoryTainted` were removed; checkpoints
   // that still carry them parse, and the unknown keys are dropped on the next save.
@@ -5838,18 +6169,18 @@ var DirectPendingSchema = z46.object({
    * from that turn are added to it as they are seen, so `sessionUsage` stays current on every
    * save and a resumed job never counts the same turn twice.
    */
-  sessionItems: z46.number().int().nonnegative().optional(),
-  checkpointRepair: z46.object({
-    workTurnId: z46.string().min(1),
-    finalText: z46.string().min(1).max(65536),
-    nativeTurnIds: z46.array(z46.string()).max(2e3).optional()
+  sessionItems: z47.number().int().nonnegative().optional(),
+  checkpointRepair: z47.object({
+    workTurnId: z47.string().min(1),
+    finalText: z47.string().min(1).max(65536),
+    nativeTurnIds: z47.array(z47.string()).max(2e3).optional()
   }).optional(),
-  replies: z46.record(z46.object({
-    success: z46.boolean(),
-    output: z46.string().optional(),
-    error: z46.string().optional()
+  replies: z47.record(z47.object({
+    success: z47.boolean(),
+    output: z47.string().optional(),
+    error: z47.string().optional()
   })).optional(),
-  calls: z46.record(DirectFunctionCallSchema).optional(),
+  calls: z47.record(DirectFunctionCallSchema).optional(),
   /**
    * SPEC-0018 R3.1. The route this job was dispatched under, and its transition phase.
    * Absent on every unrouted job, which is every job until routing is enabled.
@@ -5860,36 +6191,36 @@ var DirectPendingSchema = z46.object({
    * dispatching again. The retry's input is the original text under its own idempotency key
    * and its own `retry` operation; `attempt` never exceeds DIRECT_TURN_RETRY_LIMIT.
    */
-  retry: z46.object({
-    attempt: z46.number().int().min(1).max(DIRECT_TURN_RETRY_LIMIT),
-    code: z46.string().min(1).max(100),
-    turnId: z46.string().min(1).max(256)
+  retry: z47.object({
+    attempt: z47.number().int().min(1).max(DIRECT_TURN_RETRY_LIMIT),
+    code: z47.string().min(1).max(100),
+    turnId: z47.string().min(1).max(256)
   }).strict().optional(),
   /**
    * Why the host itself cancelled this job's turn: its run bound expired, or its recovery
    * deadline passed. A turn found cancelled with this set ended on the host's own limit, not on
    * an owner or operator pause.
    */
-  cancelledBy: z46.enum(["run_bound", "deadline"]).optional(),
+  cancelledBy: z47.enum(["run_bound", "deadline"]).optional(),
   /**
    * ADR-0204. The native helper call in this job's turn that asked for a model other
    * than the one the turn was pinned to. The helper model guard cancelled the turn on seeing it,
    * so the turn ends the job with `DIRECT_HELPER_MODEL_REFUSED`, and the helper turns observed
    * under it are attributed to the requested model rather than inherited from the root turn.
    */
-  helperModel: z46.object({
-    turnId: z46.string().min(1).max(256),
-    itemId: z46.string().min(1).max(256),
-    model: z46.string().min(1).max(256),
-    reasoningEffort: z46.string().min(1).max(64).nullable(),
-    sessionModel: z46.string().min(1).max(256)
+  helperModel: z47.object({
+    turnId: z47.string().min(1).max(256),
+    itemId: z47.string().min(1).max(256),
+    model: z47.string().min(1).max(256),
+    reasoningEffort: z47.string().min(1).max(64).nullable(),
+    sessionModel: z47.string().min(1).max(256)
   }).strict().optional(),
   /**
    * ADR-0196 (proposed). This job's turns run on the flex service tier. Chosen once per run and
    * kept here, so a resumed attempt dispatches on the same tier under the same idempotency key.
    * Absent is the default tier.
    */
-  serviceTier: z46.literal("flex").optional(),
+  serviceTier: z47.literal("flex").optional(),
   /**
    * ADR-0200. The wall-clock bound of the turn being followed when the worker may
    * release its slot while the model works: set at each dispatch, in epoch milliseconds. A bound
@@ -5898,18 +6229,18 @@ var DirectPendingSchema = z46.object({
    * `deadline` keeps its meaning (the latest the dispatch was made), which the unbought proof's
    * bracket depends on.
    */
-  turnDeadline: z46.number().int().positive().optional(),
+  turnDeadline: z47.number().int().positive().optional(),
   /**
    * ADR-0200. This job's run released its worker slot while its turn ran: how many
    * times, and when last. A later claim resumes it through the ordinary recovery path, which
    * does not announce again the items of the turn listed in `announced`, nor record its usage
    * again while it still reads as `usageHash`.
    */
-  parked: z46.object({
-    count: z46.number().int().min(1),
-    at: z46.string().datetime(),
-    announced: z46.array(z46.string().min(1).max(512)).max(DIRECT_PARKED_ANNOUNCED_MAX).optional(),
-    usageHash: z46.string().regex(/^[a-f0-9]{64}$/).optional()
+  parked: z47.object({
+    count: z47.number().int().min(1),
+    at: z47.string().datetime(),
+    announced: z47.array(z47.string().min(1).max(512)).max(DIRECT_PARKED_ANNOUNCED_MAX).optional(),
+    usageHash: z47.string().regex(/^[a-f0-9]{64}$/).optional()
   }).strict().optional()
 }).superRefine((pending, ctx) => {
   if (pending.route && pending.route.jobId !== pending.jobId)
@@ -5920,48 +6251,48 @@ var DirectPendingSchema = z46.object({
     });
 });
 var DIRECT_DETACHED_MAX = 8;
-var DirectDetachedSessionSchema = z46.object({
+var DirectDetachedSessionSchema = z47.object({
   /** The provider session, or null when the job was still creating it. */
-  sessionId: z46.string().min(1).max(256).nullable(),
+  sessionId: z47.string().min(1).max(256).nullable(),
   /** The reset request this entry was detached under. */
-  resetVersion: z46.number().int().positive(),
-  detachedAt: z46.string().datetime(),
+  resetVersion: z47.number().int().positive(),
+  detachedAt: z47.string().datetime(),
   /** The session's model and tier when it was detached, for the settlement record. */
-  model: z46.string(),
-  tier: z46.object({
+  model: z47.string(),
+  tier: z47.object({
     tier: AgentTierSchema,
-    mappingVersion: z46.string().min(1).max(200),
-    reasoningEffort: z46.enum(EXECUTOR_REASONING_EFFORTS).optional()
+    mappingVersion: z47.string().min(1).max(200),
+    reasoningEffort: z47.enum(EXECUTOR_REASONING_EFFORTS).optional()
   }).optional(),
   /** The pending block exactly as the job left it: its run, operations, baseline and deadline. */
   pending: DirectPendingSchema.nullable(),
   /** A cancellation was sent to the session for the job's turn. Never sent twice. */
-  cancelRequested: z46.boolean().optional(),
+  cancelRequested: z47.boolean().optional(),
   /**
    * Sessions the checkpoint had retired when this entry was detached. A job still `creating`
    * may have replaced one of them earlier in the same job, so it carries the job's metadata
    * too; settlement never adopts one as the session its lost create made. Optional: entries
    * detached before it was recorded exclude nothing more than they did.
    */
-  excludedSessions: z46.array(z46.string().min(1).max(256)).max(100).optional(),
+  excludedSessions: z47.array(z47.string().min(1).max(256)).max(100).optional(),
   /** Why the last settlement attempt left the entry in place, for the operator. */
-  unresolved: z46.object({ reason: z46.string().min(1).max(100), at: z46.string().datetime() }).optional(),
+  unresolved: z47.object({ reason: z47.string().min(1).max(100), at: z47.string().datetime() }).optional(),
   /** Settlement attempts that left the entry in place, which sets the backoff below. */
-  attempts: z46.number().int().nonnegative().optional(),
+  attempts: z47.number().int().nonnegative().optional(),
   /** No settlement attempt is made before this: a stuck entry is not re-read every tick. */
-  retryAt: z46.string().datetime().optional(),
+  retryAt: z47.string().datetime().optional(),
   /**
    * Every operation of the entry is closed, and only the provider deletion of its session is
    * still owed. Set only on a checkpoint with no `project` block, which has no
    * `sessionsToDelete` to put the session on; the session sweeper deletes the session under its
    * usual evidence gates and then drops the entry.
    */
-  settledAt: z46.string().datetime().optional()
+  settledAt: z47.string().datetime().optional()
 }).strict();
-var DirectAgentCheckpointSchema = z46.object({
-  kind: z46.literal("openai-preview-v1"),
-  sessionId: z46.string().nullable(),
-  model: z46.string(),
+var DirectAgentCheckpointSchema = z47.object({
+  kind: z47.literal("openai-preview-v1"),
+  sessionId: z47.string().nullable(),
+  model: z47.string(),
   /**
    * The capability tier and tier-mapping version the current `model` was resolved from, and the
    * reasoning effort that mapping set, if any. Session-scoped like `model`. A later job whose
@@ -5970,25 +6301,25 @@ var DirectAgentCheckpointSchema = z46.object({
    * updates the live one. Absent on checkpoints written before tiers, which ran as light on the
    * managed default settings.
    */
-  tier: z46.object({
+  tier: z47.object({
     tier: AgentTierSchema,
-    mappingVersion: z46.string().min(1).max(200),
-    reasoningEffort: z46.enum(EXECUTOR_REASONING_EFFORTS).optional()
+    mappingVersion: z47.string().min(1).max(200),
+    reasoningEffort: z47.enum(EXECUTOR_REASONING_EFFORTS).optional()
   }).optional(),
   /**
    * ADR-0196 (proposed). The live session runs on the flex service tier. Session-scoped like
    * `model`; absent is the managed default tier.
    */
-  serviceTier: z46.literal("flex").optional(),
+  serviceTier: z47.literal("flex").optional(),
   /**
    * ADR-0196 (proposed). A flex turn the provider could not serve paused flex for this agent: no
    * job selects flex before `until`, and the job that fell back never does.
    */
-  flexUnavailable: z46.object({ until: z46.string().datetime(), jobId: z46.string().min(1) }).strict().optional(),
-  networkAccess: z46.enum(["disabled", "enabled"]).optional(),
-  toolProfile: z46.enum(["base", "purchases-v1"]).optional(),
+  flexUnavailable: z47.object({ until: z47.string().datetime(), jobId: z47.string().min(1) }).strict().optional(),
+  networkAccess: z47.enum(["disabled", "enabled"]).optional(),
+  toolProfile: z47.enum(["base", "purchases-v1"]).optional(),
   configuration: DirectRuntimeConfigurationSchema.optional(),
-  helperUsageHashes: z46.record(z46.string().regex(/^[a-f0-9]{64}$/)).optional(),
+  helperUsageHashes: z47.record(z47.string().regex(/^[a-f0-9]{64}$/)).optional(),
   /**
    * SPEC-0018 R2.5. Attribution pinned at dispatch, per turn. Optional so existing checkpoints
    * still decode; an absent ledger means the turn is unattributed, never that the session's
@@ -6018,10 +6349,10 @@ var DirectAgentCheckpointSchema = z46.object({
    * because a confirmation is only worth anything for the dispatch it immediately preceded.
    */
   routeConfirmation: DirectRouteConfirmationSchema.optional(),
-  purchaseOperations: z46.array(z46.object({
-    operationId: z46.string().uuid(),
-    jobId: z46.string(),
-    financialPhase: z46.enum([
+  purchaseOperations: z47.array(z47.object({
+    operationId: z47.string().uuid(),
+    jobId: z47.string(),
+    financialPhase: z47.enum([
       "not_started",
       "pending",
       "unknown",
@@ -6029,202 +6360,128 @@ var DirectAgentCheckpointSchema = z46.object({
       "released",
       "failed"
     ]),
-    resultStatus: z46.enum(["pending", "received", "failed"])
+    resultStatus: z47.enum(["pending", "received", "failed"])
   })).max(64).optional(),
   /**
    * The pinned memory core last sent into this session (SM-21): the combined pinned version and
    * the session it was sent to. The core is sent again when its version moves or the session
    * changes, and never on a turn where both are unchanged.
    */
-  memoryInjectedVersion: z46.object({ sessionId: z46.string().min(1).max(256), version: z46.string().min(1).max(64) }).optional(),
+  memoryInjectedVersion: z47.object({ sessionId: z47.string().min(1).max(256), version: z47.string().min(1).max(64) }).optional(),
   /**
    * The owner's forget count (#714, `hosted_agents.memory_forget_version`) the session was created
    * under. A higher count at the start of a later job means memory this session may hold was
    * forgotten since, and the job moves the agent to a new session (`memory_forgotten`). Absent for
    * a session created before it was recorded, which then counts as created under 0.
    */
-  memoryForgetVersion: z46.object({ sessionId: z46.string().min(1).max(256), version: z46.number().int().nonnegative() }).optional(),
+  memoryForgetVersion: z47.object({ sessionId: z47.string().min(1).max(256), version: z47.number().int().nonnegative() }).optional(),
   // `memoryTaintedSessionId` (session-wide pinned taint) was removed; checkpoints that still carry
   // it parse, and the unknown key is dropped on the next save.
   /**
    * Items the host has seen in the current session (SM-32), counted as each turn's items are read,
-   * including turns of jobs that failed. Keyed by session, so a new session starts from zero with
-   * no reset code. The next job rolls over once it passes the threshold (never above the per-turn
-   * scan cap), or when the session ran out of context.
-   */
-  sessionUsage: z46.object({
-    sessionId: z46.string().min(1).max(256),
-    items: z46.number().int().nonnegative(),
-    contextExceeded: z46.boolean().optional(),
-    /**
-     * The provider refused this session further work: a safety system blocked its conversation
-     * (`policy_blocked`) or it reached its usage budget (`session_budget`). Or the host refused a
-     * native helper that asked for another model (`helper_model`, ADR-0204), which
-     * stays open in it. The next job starts a new session with this as the rollover reason, the
-     * way `contextExceeded` does.
-     */
-    retire: z46.enum(["policy_blocked", "session_budget", "helper_model"]).optional()
-  }).optional(),
-  /**
-   * The live session the idle sweeper deleted at the provider (parked) after the agent's last job
-   * went idle. `sessionId` above is null while this is set, so the agent's next job takes the
-   * new-session path: its project is restored from the verified backup and its first turn carries
-   * memory and recent episodes. That job records the rollover (reason `idle_parked`) and clears
-   * this. Optional, so a worker that predates parking drops it and still takes the same path.
-   */
-  parkedSession: z46.object({
-    sessionId: z46.string().min(1).max(256),
-    parkedAt: z46.string().datetime(),
-    items: z46.number().int().nonnegative()
-  }).optional(),
-  /**
-   * The agent asked for a workspace from a session with no sandbox (`request_workspace`,
-   * ADR-0194), so its sessions keep a sandbox from its next job on. Never cleared by the runtime.
-   */
-  workspaceRequested: z46.literal(true).optional(),
-  /**
-   * The agent's Taskmarket MCP credential (ADR-0207), kept across sessions. Cleared once
-   * a session without the server is created and the credential is retired.
-   */
-  mcpCredential: DirectMcpCredentialSchema.optional(),
-  /**
-   * The hosted sandbox under the current session (ADR-0192, ADR-0193). Keyed by session, so a new
-   * session starts with none, and a session created before it was recorded keeps the behaviour it
-   * had until it is replaced.
-   */
-  sandbox: z46.object({
-    sessionId: z46.string().min(1).max(256),
-    /** The container size the session was created with; absent when it requested none. */
-    requestedSize: z46.enum(SANDBOX_CONTAINER_SIZES).optional(),
-    /** The effective size the provider reports for it, or null while it reports none. */
-    reportedSize: z46.enum(SANDBOX_CONTAINER_SIZES).nullable().optional(),
-    /** The session was created with the identity sentinel's setup command. */
-    sentinel: z46.literal(true).optional(),
-    /** The sentinel's file name in the sandbox the session's work is known to be on. */
-    identity: z46.string().uuid().optional()
-  }).optional(),
-  /**
-   * The platform skill files the current session was created with (ADR-0203): what they
-   * hold (`docsHash`) and the sizes its sandbox lists them at (`inventoryHash`). A deploy that
-   * changes only those files keeps the session on them; the next session records its own. Keyed
-   * by session, so a session created before it was recorded is checked against the deployed bundle,
-   * as before. A session with no sandbox has none.
-   */
-  skillBundle: z46.object({
-    sessionId: z46.string().min(1).max(256),
-    docsHash: z46.string().regex(/^[a-f0-9]{64}$/),
-    inventoryHash: z46.string().regex(/^[a-f0-9]{64}$/)
-  }).optional(),
-  /**
-   * The owner's session reset (`hosted_agents.session_reset_version`) this checkpoint has handled.
-   * A higher version on the agent means the next job, or the session sweeper, detaches the
-   * current session and any pending job into `detached` and the agent starts a new session.
-   */
-  sessionReset: z46.object({ version: z46.number().int().nonnegative(), at: z46.string().datetime() }).optional(),
-  /** Sessions a reset detached that are not settled yet (see `DirectDetachedSessionSchema`). */
-  detached: z46.array(DirectDetachedSessionSchema).max(DIRECT_DETACHED_MAX).optional(),
-  turns: z46.number().int().nonnegative(),
-  expiresAt: z46.number(),
-  persistent: z46.boolean().optional(),
-  project: z46.object({
-    version: z46.literal(1),
-    setupHash: z46.string().regex(/^[a-f0-9]{64}$/),
-    snapshot: DirectProjectSnapshotSchema.nullable(),
-    restoring: z46.boolean().default(false),
-    restoreSetupHash: z46.string().regex(/^[a-f0-9]{64}$/).optional(),
-    restoreConfiguration: DirectRuntimeConfigurationSchema.optional(),
-    // `contextPending` and `context` (conversation excerpts) were removed by SM-35; checkpoints
-    // that still carry them parse, and the unknown keys are dropped on the next save.
-    /** Recent retired session ids, newest last (at most DIRECT_RETIRED_SESSIONS_KEPT kept). */
-    retiredSessions: z46.array(z46.string().min(1).max(256)).max(100).default([]),
-    /**
-     * Retired sessions still to delete at the provider (SM-34). Absent in checkpoints written
-     * before deletion existed; those start from their `retiredSessions`.
-     */
-    sessionsToDelete: z46.array(z46.string().min(1).max(256)).max(DIRECT_SESSIONS_TO_DELETE_MAX).optional()
-  }).optional(),
-  pending: DirectPendingSchema.nullable(),
-  result: z46.object({
-    jobId: z46.string(),
-    runId: z46.string().uuid(),
-    text: z46.string().max(65536),
-    errorCode: z46.string().optional()
-  }).optional()
-});
-
-// ../../packages/shared/dist/schemas/swarm-chain.schemas.js
-import { z as z47 } from "zod";
-var SwarmChainIdSchema = z47.union([z47.literal(8453), z47.literal(84532)]);
-var SWARM_CONSENT_TEXT_VERSIONS = [
-  "swarm-testnet-v1",
-  "swarm-testnet-pilot-v1",
-  "swarm-mainnet-v1",
-  "swarm-mainnet-pilot-v1",
-  // Implements: ADR-0183. Swarm YOLO mode: any recipient within the caps for a standing period.
-  "swarm-testnet-yolo-v1",
-  "swarm-testnet-yolo-pilot-v1",
-  "swarm-mainnet-yolo-v1",
-  "swarm-mainnet-yolo-pilot-v1",
-  // Implements: ADR-0185. Standing free market actions only: no payment rule of any kind.
-  "swarm-testnet-market-v1",
-  "swarm-mainnet-market-v1",
-  // Per ADR-0212. Standing YOLO: any recipient within the caps, with no end date, until revoked.
-  "swarm-testnet-standing-v1",
-  "swarm-testnet-standing-pilot-v1",
-  "swarm-mainnet-standing-v1",
-  "swarm-mainnet-standing-pilot-v1"
-];
-var SWARM_CHAINS = Object.freeze({
-  8453: Object.freeze({
-    chainId: 8453,
-    caip2: "eip155:8453",
-    name: "Base",
-    testnet: false,
-    usdc: "0x833589fCD6eDb6E08f4c7C32D4f71b54bdA02913",
-    usdcDomainName: "USD Coin",
-    usdcDomainVersion: "2",
-    publicRpcUrl: "https://mainnet.base.org",
-    qualifiedRpcOrigins: Object.freeze([
-      "https://mainnet.base.org",
-      "https://base-mainnet.rpc.privy.systems"
-    ]),
-    explorerUrl: "https://basescan.org",
-    identityRegistry: "0x8004A169FB4a3325136EB29fA0ceB6D2e539a432",
-    consentVersion: "swarm-mainnet-v1",
-    pilotConsentVersion: "swarm-mainnet-pilot-v1",
-    yoloConsentVersion: "swarm-mainnet-yolo-v1",
-    yoloPilotConsentVersion: "swarm-mainnet-yolo-pilot-v1",
-    marketConsentVersion: "swarm-mainnet-market-v1",
-    standingConsentVersion: "swarm-mainnet-standing-v1",
-    standingPilotConsentVersion: "swarm-mainnet-standing-pilot-v1"
-  }),
-  84532: Object.freeze({
-    chainId: 84532,
-    caip2: "eip155:84532",
-    name: "Base Sepolia",
-    testnet: true,
-    usdc: "0x036CbD53842c5426634e7929541eC2318f3dCF7e",
-    usdcDomainName: "USDC",
-    usdcDomainVersion: "2",
-    publicRpcUrl: "https://sepolia.base.org",
-    qualifiedRpcOrigins: Object.freeze([
-      "https://sepolia.base.org",
-      "https://base-sepolia.rpc.privy.systems"
-    ]),
-    explorerUrl: "https://sepolia.basescan.org",
-    identityRegistry: "0x8004A818BFB912233c491871b3d84c89A494BD9e",
-    consentVersion: "swarm-testnet-v1",
-    pilotConsentVersion: "swarm-testnet-pilot-v1",
-    yoloConsentVersion: "swarm-testnet-yolo-v1",
-    yoloPilotConsentVersion: "swarm-testnet-yolo-pilot-v1",
-    marketConsentVersion: "swarm-testnet-market-v1",
-    standingConsentVersion: "swarm-testnet-standing-v1",
-    standingPilotConsentVersion: "swarm-testnet-standing-pilot-v1"
-  })
+   * including turns of jobs that failed. Keyed by session, so a new session starts from zero with
+   * no reset code. The next job rolls over once it passes the threshold (never above the per-turn
+   * scan cap), or when the session ran out of context.
+   */
+  sessionUsage: z47.object({
+    sessionId: z47.string().min(1).max(256),
+    items: z47.number().int().nonnegative(),
+    contextExceeded: z47.boolean().optional(),
+    /**
+     * The provider refused this session further work: a safety system blocked its conversation
+     * (`policy_blocked`) or it reached its usage budget (`session_budget`). Or the host refused a
+     * native helper that asked for another model (`helper_model`, ADR-0204), which
+     * stays open in it. The next job starts a new session with this as the rollover reason, the
+     * way `contextExceeded` does.
+     */
+    retire: z47.enum(["policy_blocked", "session_budget", "helper_model"]).optional()
+  }).optional(),
+  /**
+   * The live session the idle sweeper deleted at the provider (parked) after the agent's last job
+   * went idle. `sessionId` above is null while this is set, so the agent's next job takes the
+   * new-session path: its project is restored from the verified backup and its first turn carries
+   * memory and recent episodes. That job records the rollover (reason `idle_parked`) and clears
+   * this. Optional, so a worker that predates parking drops it and still takes the same path.
+   */
+  parkedSession: z47.object({
+    sessionId: z47.string().min(1).max(256),
+    parkedAt: z47.string().datetime(),
+    items: z47.number().int().nonnegative()
+  }).optional(),
+  /**
+   * The agent asked for a workspace from a session with no sandbox (`request_workspace`,
+   * ADR-0194), so its sessions keep a sandbox from its next job on. Never cleared by the runtime.
+   */
+  workspaceRequested: z47.literal(true).optional(),
+  /**
+   * The agent's Taskmarket MCP credential (ADR-0207), kept across sessions. Cleared once
+   * a session without the server is created and the credential is retired.
+   */
+  mcpCredential: DirectMcpCredentialSchema.optional(),
+  /**
+   * The hosted sandbox under the current session (ADR-0192, ADR-0193). Keyed by session, so a new
+   * session starts with none, and a session created before it was recorded keeps the behaviour it
+   * had until it is replaced.
+   */
+  sandbox: z47.object({
+    sessionId: z47.string().min(1).max(256),
+    /** The container size the session was created with; absent when it requested none. */
+    requestedSize: z47.enum(SANDBOX_CONTAINER_SIZES).optional(),
+    /** The effective size the provider reports for it, or null while it reports none. */
+    reportedSize: z47.enum(SANDBOX_CONTAINER_SIZES).nullable().optional(),
+    /** The session was created with the identity sentinel's setup command. */
+    sentinel: z47.literal(true).optional(),
+    /** The sentinel's file name in the sandbox the session's work is known to be on. */
+    identity: z47.string().uuid().optional()
+  }).optional(),
+  /**
+   * The platform skill files the current session was created with (ADR-0203): what they
+   * hold (`docsHash`) and the sizes its sandbox lists them at (`inventoryHash`). A deploy that
+   * changes only those files keeps the session on them; the next session records its own. Keyed
+   * by session, so a session created before it was recorded is checked against the deployed bundle,
+   * as before. A session with no sandbox has none.
+   */
+  skillBundle: z47.object({
+    sessionId: z47.string().min(1).max(256),
+    docsHash: z47.string().regex(/^[a-f0-9]{64}$/),
+    inventoryHash: z47.string().regex(/^[a-f0-9]{64}$/)
+  }).optional(),
+  /**
+   * The owner's session reset (`hosted_agents.session_reset_version`) this checkpoint has handled.
+   * A higher version on the agent means the next job, or the session sweeper, detaches the
+   * current session and any pending job into `detached` and the agent starts a new session.
+   */
+  sessionReset: z47.object({ version: z47.number().int().nonnegative(), at: z47.string().datetime() }).optional(),
+  /** Sessions a reset detached that are not settled yet (see `DirectDetachedSessionSchema`). */
+  detached: z47.array(DirectDetachedSessionSchema).max(DIRECT_DETACHED_MAX).optional(),
+  turns: z47.number().int().nonnegative(),
+  expiresAt: z47.number(),
+  persistent: z47.boolean().optional(),
+  project: z47.object({
+    version: z47.literal(1),
+    setupHash: z47.string().regex(/^[a-f0-9]{64}$/),
+    snapshot: DirectProjectSnapshotSchema.nullable(),
+    restoring: z47.boolean().default(false),
+    restoreSetupHash: z47.string().regex(/^[a-f0-9]{64}$/).optional(),
+    restoreConfiguration: DirectRuntimeConfigurationSchema.optional(),
+    // `contextPending` and `context` (conversation excerpts) were removed by SM-35; checkpoints
+    // that still carry them parse, and the unknown keys are dropped on the next save.
+    /** Recent retired session ids, newest last (at most DIRECT_RETIRED_SESSIONS_KEPT kept). */
+    retiredSessions: z47.array(z47.string().min(1).max(256)).max(100).default([]),
+    /**
+     * Retired sessions still to delete at the provider (SM-34). Absent in checkpoints written
+     * before deletion existed; those start from their `retiredSessions`.
+     */
+    sessionsToDelete: z47.array(z47.string().min(1).max(256)).max(DIRECT_SESSIONS_TO_DELETE_MAX).optional()
+  }).optional(),
+  pending: DirectPendingSchema.nullable(),
+  result: z47.object({
+    jobId: z47.string(),
+    runId: z47.string().uuid(),
+    text: z47.string().max(65536),
+    errorCode: z47.string().optional()
+  }).optional()
 });
-function isSwarmChainId(value) {
-  return value === 8453 || value === 84532;
-}
 
 // ../../packages/shared/dist/schemas/swarm-wallet.schemas.js
 import { z as z48 } from "zod";
@@ -8246,193 +8503,6 @@ var MemoryMaintenanceEnvironmentSchema = z69.object({
   PROJECT_BACKUP_KEEP_SNAPSHOTS: z69.coerce.number().int().min(1).max(1e3).default(PROJECT_BACKUP_KEEP_SNAPSHOTS)
 });
 
-// ../../packages/shared/dist/chains/registry.js
-import { base, baseSepolia, foundry, tempo, tempoModerato } from "viem/chains";
-var TASKMARKET_CHAIN_IDS = [8453, 84532, 4217, 42431, 31337];
-function paymentProtocolFor(method) {
-  return method === "mpp-tempo" ? "mpp" : "x402";
-}
-var ERC8004_MAINNET = {
-  identityRegistry: "0x8004A169FB4a3325136EB29fA0ceB6D2e539a432",
-  reputationRegistry: "0x8004BAa17C55a88189AE136b182e5fdA19dE9b63"
-};
-var ERC8004_TESTNET = {
-  identityRegistry: "0x8004A818BFB912233c491871b3d84c89A494BD9e",
-  reputationRegistry: "0x8004B663056A597Dffe9eCcC1965A193B7388713"
-};
-var OUSD = "0x20c0000000000000000000006a37da5c996874be";
-var PATH_USD = "0x20c0000000000000000000000000000000000000";
-var TEMPO_PROTOCOL = {
-  feeManager: "0xfeEC000000000000000000000000000000000000",
-  tip403Registry: "0x403c000000000000000000000000000000000000",
-  receivePolicyGuard: "0xB10C000000000000000000000000000000000000",
-  stablecoinDex: "0xDEc0000000000000000000000000000000000000"
-};
-var baseFeatures = (chainId) => ({
-  swarmWallets: isSwarmChainId(chainId),
-  catalog: true,
-  cctpFunding: true,
-  relayFunding: chainId === 8453,
-  dreamsRewards: true,
-  receivePolicies: false
-});
-var TEMPO_FEATURES = {
-  swarmWallets: false,
-  catalog: false,
-  cctpFunding: false,
-  relayFunding: false,
-  dreamsRewards: false,
-  receivePolicies: true
-};
-var tempoPayment = {
-  token: OUSD,
-  symbol: "OUSD",
-  decimals: 6,
-  domain: { name: "OpenUSD", version: "1" },
-  method: "mpp-tempo"
-};
-var TEMPO_RATE_TASK_GAS_LIMIT = 1500000n;
-var tempoFees = { kind: "tip20", token: OUSD, fallbackToken: PATH_USD };
-function deepFreeze(value) {
-  for (const [key, nested] of Object.entries(value)) {
-    if (key === "viemChain")
-      continue;
-    if (nested && typeof nested === "object" && !Object.isFrozen(nested))
-      deepFreeze(nested);
-  }
-  return Object.freeze(value);
-}
-function freeze(chain) {
-  return deepFreeze(chain);
-}
-var TASKMARKET_CHAINS = Object.freeze({
-  8453: freeze({
-    chainId: 8453,
-    caip2: "eip155:8453",
-    name: "Base",
-    testnet: false,
-    viemChain: base,
-    publicRpcUrl: SWARM_CHAINS[8453].publicRpcUrl,
-    explorerUrl: SWARM_CHAINS[8453].explorerUrl,
-    payment: {
-      token: SWARM_CHAINS[8453].usdc,
-      symbol: "USDC",
-      decimals: 6,
-      domain: { name: SWARM_CHAINS[8453].usdcDomainName, version: "2" },
-      method: "eip3009"
-    },
-    fees: { kind: "native" },
-    blockTimeMs: 2e3,
-    rateTaskGasLimit: 1500000n,
-    indexer: { head: "latest", logRangeBlocks: 1e4 },
-    erc8004: { ...ERC8004_MAINNET },
-    features: baseFeatures(8453)
-  }),
-  84532: freeze({
-    chainId: 84532,
-    caip2: "eip155:84532",
-    name: "Base Sepolia",
-    testnet: true,
-    viemChain: baseSepolia,
-    publicRpcUrl: SWARM_CHAINS[84532].publicRpcUrl,
-    explorerUrl: SWARM_CHAINS[84532].explorerUrl,
-    payment: {
-      token: SWARM_CHAINS[84532].usdc,
-      symbol: "USDC",
-      decimals: 6,
-      domain: { name: SWARM_CHAINS[84532].usdcDomainName, version: "2" },
-      method: "eip3009"
-    },
-    fees: { kind: "native" },
-    blockTimeMs: 2e3,
-    rateTaskGasLimit: 1500000n,
-    indexer: { head: "latest", logRangeBlocks: 1e4 },
-    erc8004: { ...ERC8004_TESTNET },
-    features: baseFeatures(84532)
-  }),
-  4217: freeze({
-    chainId: 4217,
-    caip2: "eip155:4217",
-    name: "Tempo",
-    testnet: false,
-    viemChain: tempo,
-    publicRpcUrl: tempo.rpcUrls.default.http[0],
-    explorerUrl: "https://explore.tempo.xyz",
-    payment: { ...tempoPayment, domain: { ...tempoPayment.domain } },
-    fees: { ...tempoFees },
-    blockTimeMs: 1e3,
-    rateTaskGasLimit: TEMPO_RATE_TASK_GAS_LIMIT,
-    // Tempo finality is deterministic and fast; until the provider's eth_getLogs limit is
-    // measured (#907), keep the same range as Base.
-    indexer: { head: "finalized", logRangeBlocks: 1e4 },
-    erc8004: { ...ERC8004_MAINNET },
-    features: { ...TEMPO_FEATURES },
-    tempo: { ...TEMPO_PROTOCOL, paymentTokenPolicyId: 2 }
-  }),
-  42431: freeze({
-    chainId: 42431,
-    caip2: "eip155:42431",
-    name: "Tempo Moderato",
-    testnet: true,
-    viemChain: tempoModerato,
-    publicRpcUrl: tempoModerato.rpcUrls.default.http[0],
-    explorerUrl: "https://explore.testnet.tempo.xyz",
-    payment: { ...tempoPayment, domain: { ...tempoPayment.domain } },
-    fees: { ...tempoFees },
-    blockTimeMs: 1e3,
-    rateTaskGasLimit: TEMPO_RATE_TASK_GAS_LIMIT,
-    indexer: { head: "finalized", logRangeBlocks: 1e4 },
-    erc8004: { ...ERC8004_TESTNET },
-    features: { ...TEMPO_FEATURES },
-    tempo: { ...TEMPO_PROTOCOL, paymentTokenPolicyId: 1 }
-  }),
-  31337: freeze({
-    chainId: 31337,
-    caip2: "eip155:31337",
-    name: "Local",
-    testnet: true,
-    viemChain: foundry,
-    publicRpcUrl: "http://127.0.0.1:8545",
-    explorerUrl: "",
-    // The local mock token is deployed per run; its address comes from the environment.
-    payment: {
-      token: void 0,
-      symbol: "USDC",
-      decimals: 6,
-      domain: { name: "USD Coin", version: "2" },
-      method: "eip3009"
-    },
-    fees: { kind: "native" },
-    blockTimeMs: 1e3,
-    rateTaskGasLimit: 1500000n,
-    indexer: { head: "latest", logRangeBlocks: 1e4 },
-    erc8004: void 0,
-    features: {
-      swarmWallets: false,
-      catalog: false,
-      cctpFunding: false,
-      relayFunding: false,
-      dreamsRewards: true,
-      receivePolicies: false
-    }
-  })
-});
-var UnknownChainError = class extends Error {
-  constructor(chainId) {
-    super(`Taskmarket does not support chain ${String(chainId)}`);
-    this.name = "UnknownChainError";
-    this.chainId = chainId;
-  }
-};
-function isTaskmarketChainId(value) {
-  return TASKMARKET_CHAIN_IDS.includes(value);
-}
-function taskmarketChain(chainId) {
-  if (!isTaskmarketChainId(chainId))
-    throw new UnknownChainError(chainId);
-  return TASKMARKET_CHAINS[chainId];
-}
-
 // src/lib/home.ts
 import os from "os";
 import path from "path";
@@ -15892,7 +15962,8 @@ async function createMppTempoCredential(input2) {
   const expiresSeconds = Math.floor(Date.parse(challenge.expires) / 1e3);
   if (!Number.isFinite(expiresSeconds) || expiresSeconds <= nowSeconds)
     throw challengeRefused("The Payment challenge has expired");
-  const validBefore = Math.min(nowSeconds + (input2.validitySeconds ?? MPP_TEMPO_DEFAULT_VALIDITY_SECONDS), expiresSeconds + 30);
+  const validitySeconds = clampValidityWindowSeconds(input2.validitySeconds ?? MPP_TEMPO_DEFAULT_VALIDITY_SECONDS, TEMPO_MAX_VALIDITY_WINDOW_SECONDS);
+  const validBefore = Math.min(nowSeconds + validitySeconds, expiresSeconds + 30);
   const memo = mppAttributionMemo({
     realm: challenge.realm,
     challengeId: challenge.id,
@@ -15992,9 +16063,11 @@ export {
   buildSponsoredTaskVaultReviewRequestMessage,
   usdcToBaseUnits,
   formatUsdcBaseUnits,
+  taskmarketChain,
+  clientValidityWindowSeconds,
+  paymentTokenSymbol,
   buildLegalReceiptHeaders,
   buildWalletLegalAcceptanceMessage,
-  taskmarketChain,
   getTaskmarketHome,
   generateKeypair,
   encryptPrivateKey,