@lucid-agents/taskmarket 1.18.0 → 1.18.1

package/dist/{chunk-75LS6XS6.js → chunk-YB2B5DPR.js}

@@ -5730,7 +5730,7 @@ function formatPaymentAmount(value, chainId, options = { trimTrailingZeros: true
 }
 
 // ../../packages/shared/dist/schemas/launcher.schemas.js
-import { z as z43 } from "zod";
+import { z as z44 } from "zod";
 
 // ../../packages/shared/dist/schemas/agent-platform.schemas.js
 import { z as z42 } from "zod";
@@ -5844,133 +5844,549 @@ var AgentDelegationSchema = z42.object({
   waiting: z42.boolean()
 });
 
+// ../../packages/shared/dist/schemas/memory.schemas.js
+import { z as z43 } from "zod";
+var MEMORY_DOCUMENT_MAX_BYTES = 65536;
+var MEMORY_ARCHIVE_RETENTION_DAYS = 30;
+var MEMORY_PATH_MAX_LENGTH = 200;
+var MEMORY_PATH_MAX_DEPTH = 6;
+var MEMORY_PATH_SEGMENT_MAX_BYTES = 100;
+var MEMORY_SEARCH_QUERY_MAX_LENGTH = 200;
+var MEMORY_SEARCH_MAX_RESULTS = 20;
+var MEMORY_HISTORY_MAX_RESULTS = 50;
+var MEMORY_REASON_MAX_LENGTH = 500;
+var MemoryScopeSchema = z43.enum(["agent", "swarm"]);
+var MemoryTrustSchema = z43.enum(["owner", "agent", "tainted"]);
+var MemoryRevisionStatusSchema = z43.enum(["applied", "proposed", "approved", "rejected"]);
+var MemoryActorSchema = z43.enum(["owner", "agent"]);
+var MemoryOperationSchema = z43.enum([
+  "create",
+  "replace",
+  "append",
+  "edit",
+  "archive",
+  "rollback",
+  "restore",
+  "promote"
+]);
+var MemoryWriteModeSchema = z43.enum(["replace", "append"]);
+var MemoryWriteOutcomeSchema = z43.enum(["applied", "proposed"]);
+var LauncherJobSourceSchema = z43.enum([
+  "dashboard",
+  "imessage",
+  "peer",
+  "schedule",
+  "wait",
+  "inbox",
+  // Implements: ADR-0182. A backend-owned job that executes an owner-approved purchase; it runs
+  // no model turn.
+  "purchase",
+  // ADR-0189. A market event relevant to the swarm wallet woke the responsible agent.
+  "market"
+]);
+var MEMORY_CORE_TEMPLATE_SECTIONS = [
+  "Owner",
+  "Preferences",
+  "Commitments",
+  "Open threads"
+];
+var MEMORY_CORE_TEMPLATE = MEMORY_CORE_TEMPLATE_SECTIONS.map((section2) => `## ${section2}
+`).join("\n");
+var MemoryCoreTemplateEnabledSchema = z43.enum(["true", "false"]).default("false").transform((value) => value === "true");
+function utf8ByteLength(value) {
+  let bytes2 = 0;
+  for (let i = 0; i < value.length; i++) {
+    const code = value.charCodeAt(i);
+    if (code < 128)
+      bytes2 += 1;
+    else if (code < 2048)
+      bytes2 += 2;
+    else if (code >= 55296 && code <= 56319 && i + 1 < value.length && (value.charCodeAt(i + 1) & 64512) === 56320) {
+      bytes2 += 4;
+      i++;
+    } else
+      bytes2 += 3;
+  }
+  return bytes2;
+}
+var SEGMENT = /^[\p{L}\p{N}][\p{L}\p{N} ._-]*$/u;
+var forbiddenPathCharacter = (value) => [...value].some((c) => {
+  const code = c.charCodeAt(0);
+  return code < 32 || code >= 127 && code <= 159 || c === "\\";
+});
+var memoryContentIsText = (value) => ![...value].some((c) => {
+  const code = c.charCodeAt(0);
+  return code < 32 && code !== 9 && code !== 10 && code !== 13 || code === 127;
+});
+function normalizeMemoryPath(raw) {
+  const value = raw.normalize("NFC").trim();
+  if (!value)
+    return { ok: false, reason: "Path is empty" };
+  if (forbiddenPathCharacter(value))
+    return { ok: false, reason: "Path contains control characters or backslashes" };
+  if (value.startsWith("/") || value.startsWith("~"))
+    return { ok: false, reason: "Path must be relative to its scope" };
+  const segments = value.split("/").filter((part) => part !== "" && part !== ".");
+  if (segments.some((part) => part === ".."))
+    return { ok: false, reason: 'Path must not contain ".."' };
+  if (!segments.length)
+    return { ok: false, reason: "Path is empty" };
+  if (segments.length > MEMORY_PATH_MAX_DEPTH)
+    return { ok: false, reason: `Path is deeper than ${MEMORY_PATH_MAX_DEPTH} segments` };
+  for (const part of segments) {
+    if (!SEGMENT.test(part) || part.endsWith(" ") || part.endsWith("."))
+      return {
+        ok: false,
+        reason: 'Path segments use letters, digits, spaces, ".", "-" and "_" and start with a letter or digit'
+      };
+    if (utf8ByteLength(part) > MEMORY_PATH_SEGMENT_MAX_BYTES)
+      return { ok: false, reason: "Path segment is too long" };
+  }
+  const path3 = segments.join("/");
+  if (path3.length > MEMORY_PATH_MAX_LENGTH)
+    return { ok: false, reason: "Path is too long" };
+  if (!path3.endsWith(".md"))
+    return { ok: false, reason: "Memory documents are markdown (.md)" };
+  return { ok: true, path: path3 };
+}
+var MemoryPathSchema = z43.string().max(MEMORY_PATH_MAX_LENGTH * 2).transform((raw, ctx) => {
+  const result = normalizeMemoryPath(raw);
+  if (!result.ok) {
+    ctx.addIssue({ code: "custom", message: result.reason });
+    return z43.NEVER;
+  }
+  return result.path;
+});
+var MemoryContentSchema = z43.string().max(MEMORY_DOCUMENT_MAX_BYTES).refine(memoryContentIsText, "Memory content must be text").refine((value) => utf8ByteLength(value) <= MEMORY_DOCUMENT_MAX_BYTES, `Memory documents are limited to ${MEMORY_DOCUMENT_MAX_BYTES} bytes`);
+var ReasonSchema = z43.string().trim().max(MEMORY_REASON_MAX_LENGTH).optional();
+var VersionSchema = z43.number().int().min(0).max(2147483647);
+var AgentIdSchema = z43.string().uuid();
+var target = {
+  agentId: AgentIdSchema.optional(),
+  scope: MemoryScopeSchema,
+  path: MemoryPathSchema
+};
+var agentScopeNeedsAgent = (value) => value.scope !== "agent" || Boolean(value.agentId);
+var agentScopeMessage = { message: "agentId is required for the agent scope", path: ["agentId"] };
+var MemoryTargetInputSchema = z43.object(target).strict().refine(agentScopeNeedsAgent, agentScopeMessage);
+var MemoryTreeInputSchema = z43.object({ agentId: AgentIdSchema.optional(), scope: MemoryScopeSchema.optional() }).strict().refine((value) => value.scope !== "agent" || Boolean(value.agentId), agentScopeMessage);
+var MemoryWriteInputSchema = z43.object({
+  ...target,
+  content: MemoryContentSchema,
+  mode: MemoryWriteModeSchema.default("replace"),
+  expectedVersion: VersionSchema.optional(),
+  reason: ReasonSchema,
+  /**
+   * The owner was warned that the content looks like a secret (#713) and saves it anyway.
+   * Without it, a write that adds a seed phrase, private key or credential is refused.
+   */
+  confirmSecrets: z43.boolean().optional()
+}).strict().refine(agentScopeNeedsAgent, agentScopeMessage);
+var MemoryArchiveInputSchema = z43.object({ ...target, expectedVersion: VersionSchema.optional(), reason: ReasonSchema }).strict().refine(agentScopeNeedsAgent, agentScopeMessage);
+var MemoryHistoryInputSchema = z43.object({
+  ...target,
+  limit: z43.number().int().min(1).max(MEMORY_HISTORY_MAX_RESULTS).default(20),
+  beforeVersion: VersionSchema.optional()
+}).strict().refine(agentScopeNeedsAgent, agentScopeMessage);
+var MemoryRollbackInputSchema = z43.object({
+  ...target,
+  version: VersionSchema.min(1),
+  expectedVersion: VersionSchema.optional(),
+  reason: ReasonSchema
+}).strict().refine(agentScopeNeedsAgent, agentScopeMessage);
+var MemorySearchInputSchema = z43.object({
+  agentId: AgentIdSchema.optional(),
+  scope: MemoryScopeSchema.optional(),
+  query: z43.string().trim().min(1).max(MEMORY_SEARCH_QUERY_MAX_LENGTH),
+  limit: z43.number().int().min(1).max(MEMORY_SEARCH_MAX_RESULTS).default(10),
+  /** Also search the agent's own past jobs (SM-61); needs `agentId`. */
+  includeHistory: z43.boolean().optional()
+}).strict().refine((value) => value.scope !== "agent" || Boolean(value.agentId), agentScopeMessage);
+var MemoryForgetInputSchema = z43.object({ agentId: AgentIdSchema.optional(), scope: MemoryScopeSchema, reason: ReasonSchema }).strict().refine(agentScopeNeedsAgent, agentScopeMessage);
+var MemoryPromoteInputSchema = z43.object({
+  agentId: AgentIdSchema,
+  scope: MemoryScopeSchema.default("agent"),
+  path: MemoryPathSchema,
+  targetPath: MemoryPathSchema.optional(),
+  expectedVersion: VersionSchema.optional(),
+  reason: ReasonSchema
+}).strict();
+var MemoryDocumentSummarySchema = z43.object({
+  documentId: z43.string().uuid(),
+  scope: MemoryScopeSchema,
+  path: z43.string(),
+  version: z43.number().int(),
+  bytes: z43.number().int(),
+  pinned: z43.boolean(),
+  readOnly: z43.boolean(),
+  updatedAt: z43.string()
+});
+var MemoryTreeSchema = z43.object({
+  documents: z43.array(MemoryDocumentSummarySchema),
+  limits: z43.object({
+    documentBytes: z43.number().int(),
+    scopeDocuments: z43.number().int(),
+    pinnedRenderBytes: z43.number().int()
+  })
+});
+var MemoryDocumentSchema = MemoryDocumentSummarySchema.extend({
+  content: z43.string(),
+  createdAt: z43.string(),
+  archivedAt: z43.string().nullable(),
+  /** Actor and trust of the revision that produced the current content. */
+  lastActor: MemoryActorSchema.nullable(),
+  lastTrust: MemoryTrustSchema.nullable()
+});
+var MemoryRevisionSchema = z43.object({
+  id: z43.string().uuid(),
+  /** Null only for a proposal to create a document that does not exist (yet). */
+  documentId: z43.string().uuid().nullable(),
+  version: z43.number().int(),
+  content: z43.string(),
+  operation: MemoryOperationSchema,
+  status: MemoryRevisionStatusSchema,
+  actor: MemoryActorSchema,
+  actorAgentId: z43.string().nullable(),
+  jobId: z43.string().nullable(),
+  sessionId: z43.string().nullable(),
+  trust: MemoryTrustSchema,
+  /** Why an agent turn had this trust, e.g. the tool that tainted it (SM-51). */
+  trustReason: z43.string().nullable(),
+  reason: z43.string().nullable(),
+  sourceDocumentId: z43.string().uuid().nullable(),
+  sourceVersion: z43.number().int().nullable(),
+  createdAt: z43.string(),
+  decidedAt: z43.string().nullable()
+});
+var MemoryHistorySchema = z43.object({
+  document: MemoryDocumentSummarySchema.extend({ archivedAt: z43.string().nullable() }),
+  revisions: z43.array(MemoryRevisionSchema)
+});
+var MemoryMutationResultSchema = z43.object({
+  outcome: z43.literal("applied"),
+  document: MemoryDocumentSchema,
+  revision: MemoryRevisionSchema
+});
+var MemoryProposedResultSchema = z43.object({
+  outcome: z43.literal("proposed"),
+  scope: MemoryScopeSchema,
+  path: z43.string(),
+  /** The version the proposal was made against; 0 = the document does not exist. */
+  baseVersion: z43.number().int(),
+  document: MemoryDocumentSchema.nullable(),
+  revision: MemoryRevisionSchema
+});
+var MemoryHistoryHitSchema = z43.object({
+  jobId: z43.string(),
+  source: LauncherJobSourceSchema.nullable(),
+  status: z43.string(),
+  /** Trust of the job the text came from (its source, the tools its run called, tainted reads). */
+  trust: MemoryTrustSchema,
+  snippet: z43.string(),
+  score: z43.number(),
+  createdAt: z43.string(),
+  finishedAt: z43.string().nullable()
+});
+var MemorySearchResultSchema = z43.object({
+  results: z43.array(z43.object({
+    documentId: z43.string().uuid(),
+    scope: MemoryScopeSchema,
+    path: z43.string(),
+    version: z43.number().int(),
+    /** When the document last changed. */
+    updatedAt: z43.string(),
+    snippet: z43.string(),
+    score: z43.number(),
+    /** Trust of the revision that produced the current content. */
+    trust: MemoryTrustSchema.nullable()
+  })),
+  /** Present only when history was requested. */
+  history: z43.array(MemoryHistoryHitSchema).optional()
+});
+var MemoryForgetResultSchema = z43.object({ archived: z43.number().int() });
+var MemoryProposalsInputSchema = z43.object({ agentId: AgentIdSchema.optional(), scope: MemoryScopeSchema.optional() }).strict().refine((value) => value.scope !== "agent" || Boolean(value.agentId), agentScopeMessage);
+var MemoryProposalDecisionInputSchema = z43.object({ proposalId: z43.string().uuid() }).strict();
+var MemoryProposalSchema = z43.object({
+  id: z43.string().uuid(),
+  scope: MemoryScopeSchema,
+  /** The private scope's agent; null for the swarm scope. */
+  agentId: z43.string().nullable(),
+  path: z43.string(),
+  documentId: z43.string().uuid().nullable(),
+  operation: MemoryOperationSchema,
+  /** The full proposed content (for `archive`, the content that would be archived). */
+  content: z43.string(),
+  /** The document version the proposal was made against; 0 = the document did not exist. */
+  baseVersion: z43.number().int(),
+  /** The live document now, to diff against; null when there is none. */
+  current: z43.object({
+    version: z43.number().int(),
+    content: z43.string(),
+    lastTrust: MemoryTrustSchema.nullable()
+  }).nullable(),
+  /** The document changed since the proposal: approving it would conflict. */
+  stale: z43.boolean(),
+  actor: MemoryActorSchema,
+  actorAgentId: z43.string().nullable(),
+  trust: MemoryTrustSchema,
+  trustReason: z43.string().nullable(),
+  reason: z43.string().nullable(),
+  sessionId: z43.string().nullable(),
+  job: z43.object({
+    id: z43.string(),
+    /** The agent that ran the job: the proposer, or its creator for a seeded instructions.md. */
+    agentId: z43.string(),
+    source: LauncherJobSourceSchema.nullable(),
+    prompt: z43.string(),
+    createdAt: z43.string()
+  }).nullable(),
+  createdAt: z43.string(),
+  /**
+   * When the retention purge removes the proposal undecided, or null when it never does. Only
+   * proposals with no live document to wait on expire: one to create a document (the archive
+   * window after it was made) and one on a forgotten document (purged with that document).
+   */
+  expiresAt: z43.string().nullable(),
+  /** `expiresAt` is within MEMORY_PROPOSAL_EXPIRY_WARNING_DAYS. */
+  expiresSoon: z43.boolean()
+});
+var MemoryProposalListSchema = z43.object({ proposals: z43.array(MemoryProposalSchema) });
+var MemoryProposalSummaryInputSchema = z43.object({}).strict();
+var MemoryProposalCountSchema = z43.object({
+  pending: z43.number().int(),
+  /** Pending proposals flagged `expiresSoon`. */
+  expiringSoon: z43.number().int()
+});
+var MemoryProposalSummarySchema = MemoryProposalCountSchema.extend({
+  /** Proposals to shared memory: every agent's Memory tab lists them. */
+  swarm: MemoryProposalCountSchema,
+  /**
+   * Proposals to each agent's private memory, for agents that have any. An agent's Memory tab
+   * lists its own and the shared ones.
+   */
+  agents: z43.array(MemoryProposalCountSchema.extend({ agentId: z43.string() }))
+});
+var MemoryProposalRejectionSchema = z43.object({ revision: MemoryRevisionSchema });
+var MemoryArchivedInputSchema = z43.object({ agentId: AgentIdSchema.optional(), scope: MemoryScopeSchema }).strict().refine(agentScopeNeedsAgent, agentScopeMessage);
+var MemoryArchivedDocumentSchema = z43.object({
+  documentId: z43.string().uuid(),
+  scope: MemoryScopeSchema,
+  path: z43.string(),
+  /** The archive revision's version; restoring rolls back to it (its content is the last text). */
+  version: z43.number().int(),
+  bytes: z43.number().int(),
+  pinned: z43.boolean(),
+  archivedAt: z43.string(),
+  /** When the hard purge removes it for good. */
+  purgeAt: z43.string()
+});
+var MemoryArchivedListSchema = z43.object({
+  documents: z43.array(MemoryArchivedDocumentSchema)
+});
+var MemoryExportInputSchema = z43.object({ cursor: z43.string().min(1).max(512).optional() }).strict();
+var MemoryExportDocumentSchema = z43.object({
+  documentId: z43.string().uuid(),
+  scope: MemoryScopeSchema,
+  /** The private scope's agent; null for shared memory. */
+  agentId: z43.string().nullable(),
+  path: z43.string(),
+  /** `live` is what agents read now; `forgotten` is archived and purged at `purgeAt`. */
+  status: z43.enum(["live", "forgotten"]),
+  pinned: z43.boolean(),
+  version: z43.number().int(),
+  bytes: z43.number().int(),
+  /** The current text, or the last text of a forgotten document. */
+  content: z43.string(),
+  createdAt: z43.string(),
+  updatedAt: z43.string(),
+  archivedAt: z43.string().nullable(),
+  purgeAt: z43.string().nullable()
+});
+var MemoryExportRevisionSchema = MemoryRevisionSchema.extend({
+  scope: MemoryScopeSchema,
+  agentId: z43.string().nullable(),
+  path: z43.string()
+});
+var MemoryExportPageSchema = z43.object({
+  /** The owner's agents, to name each private scope. */
+  agents: z43.array(z43.object({ agentId: z43.string(), name: z43.string() })),
+  /** Documents first seen on this page; their revisions may continue on later pages. */
+  documents: z43.array(MemoryExportDocumentSchema),
+  revisions: z43.array(MemoryExportRevisionSchema),
+  nextCursor: z43.string().nullable()
+});
+var ToolPathSchema = z43.string().min(1).max(MEMORY_PATH_MAX_LENGTH * 2);
+var ToolReasonSchema = z43.string().trim().min(1).max(MEMORY_REASON_MAX_LENGTH);
+var MemoryToolInputSchemas = {
+  memory_view: z43.object({
+    scope: MemoryScopeSchema.optional(),
+    path: ToolPathSchema.optional(),
+    offset: z43.number().int().min(0).max(MEMORY_DOCUMENT_MAX_BYTES).optional()
+  }).strict(),
+  memory_search: z43.object({
+    query: z43.string().trim().min(1).max(MEMORY_SEARCH_QUERY_MAX_LENGTH),
+    scope: MemoryScopeSchema.optional(),
+    limit: z43.number().int().min(1).max(MEMORY_SEARCH_MAX_RESULTS).optional(),
+    /** Also search this agent's own past jobs (SM-61). */
+    include_history: z43.boolean().optional()
+  }).strict(),
+  memory_write: z43.object({
+    scope: MemoryScopeSchema.optional(),
+    path: ToolPathSchema,
+    content: z43.string().max(MEMORY_DOCUMENT_MAX_BYTES),
+    mode: MemoryWriteModeSchema.optional(),
+    expected_version: VersionSchema.optional()
+  }).strict(),
+  memory_edit: z43.object({
+    scope: MemoryScopeSchema.optional(),
+    path: ToolPathSchema,
+    old_text: z43.string().min(1).max(MEMORY_DOCUMENT_MAX_BYTES),
+    new_text: z43.string().max(MEMORY_DOCUMENT_MAX_BYTES),
+    expected_version: VersionSchema
+  }).strict(),
+  memory_delete: z43.object({ scope: MemoryScopeSchema.optional(), path: ToolPathSchema, reason: ToolReasonSchema }).strict()
+};
+var MEMORY_TOOL_NAMES = Object.keys(MemoryToolInputSchemas);
+
 // ../../packages/shared/dist/schemas/launcher.schemas.js
-var LauncherAgentIdSchema = z43.object({ agentId: z43.string().uuid() });
-var LauncherAvatarSchema = z43.object({
-  version: z43.literal(1),
-  color: z43.enum(["rose", "mint", "blue", "amber", "mauve", "cocoa"]),
-  face: z43.number().int().min(0).max(5),
+var LauncherAgentIdSchema = z44.object({ agentId: z44.string().uuid() });
+var SANDBOX_TOOL_SETS = ["minimal", "full"];
+var SandboxToolSetSchema = z44.enum(SANDBOX_TOOL_SETS);
+var DEFAULT_SANDBOX_TOOL_SET = "minimal";
+var LauncherSetSandboxToolsSchema = LauncherAgentIdSchema.extend({
+  sandboxTools: SandboxToolSetSchema
+}).strict();
+var LauncherAvatarSchema = z44.object({
+  version: z44.literal(1),
+  color: z44.enum(["rose", "mint", "blue", "amber", "mauve", "cocoa"]),
+  face: z44.number().int().min(0).max(5),
   /** Shape 0-6. Values 0-2 predate the wider range and keep their shapes. */
-  head: z43.number().int().min(0).max(6),
-  antenna: z43.number().int().min(0).max(3),
-  ears: z43.number().int().min(0).max(2),
-  markings: z43.number().int().min(0).max(255),
+  head: z44.number().int().min(0).max(6),
+  antenna: z44.number().int().min(0).max(3),
+  ears: z44.number().int().min(0).max(2),
+  markings: z44.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: z43.enum(["vinyl", "gummy", "visor", "plush"]).optional()
+  style: z44.enum(["vinyl", "gummy", "visor", "plush"]).optional()
 }).strict();
 var LauncherUpdateAvatarSchema = LauncherAgentIdSchema.extend({
   avatar: LauncherAvatarSchema
 });
-var LauncherLaunchSchema = z43.object({
-  requestKey: z43.string().uuid(),
-  name: z43.string().trim().min(1).max(100),
-  prompt: z43.string().trim().min(1).max(32768),
+var LauncherLaunchSchema = z44.object({
+  requestKey: z44.string().uuid(),
+  name: z44.string().trim().min(1).max(100),
+  prompt: z44.string().trim().min(1).max(32768),
   avatar: LauncherAvatarSchema.optional(),
   /** Capability tier for the new agent. Absent is light. */
   tier: AgentTierSchema.optional()
 }).strict();
-var LauncherSessionResetSchema = z43.object({ version: z43.number().int().positive(), requestedAt: z43.string().datetime() }).strict();
-var LauncherArchiveResultSchema = z43.object({
-  agentId: z43.string().uuid(),
-  archivedAt: z43.string().datetime(),
-  cancelledJobs: z43.number().int().nonnegative(),
-  disabledSchedule: z43.boolean(),
-  updatedChannels: z43.number().int().nonnegative(),
-  disconnectedChannels: z43.number().int().nonnegative(),
-  deniedApprovals: z43.number().int().nonnegative(),
-  revokedMcpTokens: z43.number().int().nonnegative()
+var LauncherSessionResetSchema = z44.object({ version: z44.number().int().positive(), requestedAt: z44.string().datetime() }).strict();
+var LauncherArchiveResultSchema = z44.object({
+  agentId: z44.string().uuid(),
+  archivedAt: z44.string().datetime(),
+  cancelledJobs: z44.number().int().nonnegative(),
+  disabledSchedule: z44.boolean(),
+  updatedChannels: z44.number().int().nonnegative(),
+  disconnectedChannels: z44.number().int().nonnegative(),
+  deniedApprovals: z44.number().int().nonnegative(),
+  revokedMcpTokens: z44.number().int().nonnegative()
 }).strict();
 var LauncherMessageSchema = LauncherAgentIdSchema.extend({
-  requestKey: z43.string().uuid(),
-  prompt: z43.string().trim().min(1).max(32768)
+  requestKey: z44.string().uuid(),
+  prompt: z44.string().trim().min(1).max(32768)
 }).strict();
-var LauncherJobStatusSchema = z43.enum([
+var LauncherJobStatusSchema = z44.enum([
   "queued",
   "running",
   "completed",
   "failed",
   "interrupted"
 ]);
-var LauncherJobSchema = z43.object({
-  id: z43.string().uuid(),
+var LauncherJobSchema = z44.object({
+  id: z44.string().uuid(),
   status: LauncherJobStatusSchema,
-  runId: z43.string().uuid().nullable(),
-  output: z43.string().nullable(),
-  errorCode: z43.string().nullable(),
-  createdAt: z43.string(),
-  finishedAt: z43.string().nullable()
+  runId: z44.string().uuid().nullable(),
+  output: z44.string().nullable(),
+  errorCode: z44.string().nullable(),
+  createdAt: z44.string(),
+  finishedAt: z44.string().nullable()
 });
-var LauncherAcceptedSchema = z43.object({
-  agentId: z43.string().uuid(),
-  jobId: z43.string().uuid(),
+var LauncherAcceptedSchema = z44.object({
+  agentId: z44.string().uuid(),
+  jobId: z44.string().uuid(),
   status: LauncherJobStatusSchema
 });
-var LauncherAgentSchema = z43.object({
-  id: z43.string().uuid(),
-  name: z43.string(),
+var LauncherAgentSchema = z44.object({
+  id: z44.string().uuid(),
+  name: z44.string(),
   avatar: LauncherAvatarSchema.nullish(),
-  paused: z43.boolean(),
+  paused: z44.boolean(),
   /** True once the owner deleted the agent; only a direct read by id returns such an agent. */
-  archived: z43.boolean().optional(),
+  archived: z44.boolean().optional(),
   /**
    * 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: z43.number().int(),
-  workspaceReady: z43.boolean(),
-  usage: z43.object({
-    available: z43.number(),
-    reserved: z43.number(),
-    spent: z43.number(),
-    unit: z43.literal("tokens")
+  /**
+   * The tools the agent's sandbox is created with. A change moves the agent to a new session at
+   * its next task, once its project files are backed up; absent only from a backend that predates
+   * the setting.
+   */
+  sandboxTools: SandboxToolSetSchema.default(DEFAULT_SANDBOX_TOOL_SET),
+  controlVersion: z44.number().int(),
+  workspaceReady: z44.boolean(),
+  usage: z44.object({
+    available: z44.number(),
+    reserved: z44.number(),
+    spent: z44.number(),
+    unit: z44.literal("tokens")
   })
 });
-var LauncherStatusSchema = z43.object({
+var LauncherStatusSchema = z44.object({
   agent: LauncherAgentSchema,
-  jobs: z43.array(LauncherJobSchema)
+  jobs: z44.array(LauncherJobSchema)
 });
 var LauncherEventsInputSchema = LauncherAgentIdSchema.extend({
-  after: z43.number().int().nonnegative().default(0),
-  limit: z43.number().int().min(1).max(100).default(50)
-});
-var LauncherEventsSchema = z43.object({
-  events: z43.array(z43.object({
-    id: z43.number().int(),
-    runId: z43.string().uuid(),
-    type: z43.string(),
-    createdAt: z43.string()
+  after: z44.number().int().nonnegative().default(0),
+  limit: z44.number().int().min(1).max(100).default(50)
+});
+var LauncherEventsSchema = z44.object({
+  events: z44.array(z44.object({
+    id: z44.number().int(),
+    runId: z44.string().uuid(),
+    type: z44.string(),
+    createdAt: z44.string()
   })),
-  nextCursor: z43.number().int()
+  nextCursor: z44.number().int()
 });
 var LauncherArtifactInputSchema = LauncherAgentIdSchema.extend({
-  artifactId: z43.string().uuid()
-});
-var LauncherArtifactsSchema = z43.object({
-  artifacts: z43.array(z43.object({
-    id: z43.string().uuid(),
-    runId: z43.string().uuid(),
-    path: z43.string(),
-    displayName: z43.string().optional(),
-    sha256: z43.string(),
-    bytes: z43.number(),
-    createdAt: z43.string()
+  artifactId: z44.string().uuid()
+});
+var LauncherArtifactsSchema = z44.object({
+  artifacts: z44.array(z44.object({
+    id: z44.string().uuid(),
+    runId: z44.string().uuid(),
+    path: z44.string(),
+    displayName: z44.string().optional(),
+    sha256: z44.string(),
+    bytes: z44.number(),
+    createdAt: z44.string()
   }))
 });
-var LauncherArtifactUrlSchema = z43.object({
-  url: z43.string().url(),
-  expiresIn: z43.number().int()
+var LauncherArtifactUrlSchema = z44.object({
+  url: z44.string().url(),
+  expiresIn: z44.number().int()
 });
-var LauncherAccountSchema = z43.object({
-  enabled: z43.boolean(),
-  agentId: z43.string().uuid().nullable(),
-  initialTokens: z43.number().int().nonnegative(),
-  agentCount: z43.number().int().nonnegative(),
-  maxAgents: z43.number().int().positive(),
+var LauncherAccountSchema = z44.object({
+  enabled: z44.boolean(),
+  agentId: z44.string().uuid().nullable(),
+  initialTokens: z44.number().int().nonnegative(),
+  agentCount: z44.number().int().nonnegative(),
+  maxAgents: z44.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.
@@ -5978,145 +6394,151 @@ var LauncherAccountSchema = z43.object({
    * allowance, and the shared token balance lives on each agent's `usage`. Remove next release.
    */
   usage: LauncherAgentSchema.shape.usage.optional(),
-  providerUsage: z43.object({
-    basis: z43.literal("recorded_provider_turns"),
-    provisional: z43.literal(true),
-    inputTokens: z43.string().regex(/^\d+$/),
-    outputTokens: z43.string().regex(/^\d+$/),
-    totalTokens: z43.string().regex(/^\d+$/),
-    cachedInputTokens: z43.string().regex(/^\d+$/),
-    reasoningTokens: z43.string().regex(/^\d+$/),
-    reportedTurns: z43.number().int().nonnegative(),
-    unknownTurns: z43.number().int().nonnegative(),
-    invalidObservations: z43.number().int().nonnegative(),
-    missingCachedDetails: z43.number().int().nonnegative(),
-    missingReasoningDetails: z43.number().int().nonnegative(),
-    truncated: z43.boolean()
+  providerUsage: z44.object({
+    basis: z44.literal("recorded_provider_turns"),
+    provisional: z44.literal(true),
+    inputTokens: z44.string().regex(/^\d+$/),
+    outputTokens: z44.string().regex(/^\d+$/),
+    totalTokens: z44.string().regex(/^\d+$/),
+    cachedInputTokens: z44.string().regex(/^\d+$/),
+    reasoningTokens: z44.string().regex(/^\d+$/),
+    reportedTurns: z44.number().int().nonnegative(),
+    unknownTurns: z44.number().int().nonnegative(),
+    invalidObservations: z44.number().int().nonnegative(),
+    missingCachedDetails: z44.number().int().nonnegative(),
+    missingReasoningDetails: z44.number().int().nonnegative(),
+    truncated: z44.boolean()
   }).optional()
 });
 var LauncherTurnSchema = LauncherJobSchema.extend({
-  uiCards: z43.array(AgentUiCardSchema).max(3).optional(),
-  delegations: z43.array(AgentDelegationSchema).optional(),
-  sequence: z43.number().int(),
-  requestKey: z43.string().uuid(),
-  prompt: z43.string(),
-  senderAgentId: z43.string().uuid().nullable().default(null),
-  automaticContinuation: z43.boolean().optional(),
-  channelRequest: z43.object({ id: z43.string().uuid(), reference: z43.string() }).nullable().optional()
+  uiCards: z44.array(AgentUiCardSchema).max(3).optional(),
+  delegations: z44.array(AgentDelegationSchema).optional(),
+  sequence: z44.number().int(),
+  requestKey: z44.string().uuid(),
+  prompt: z44.string(),
+  senderAgentId: z44.string().uuid().nullable().default(null),
+  automaticContinuation: z44.boolean().optional(),
+  channelRequest: z44.object({ id: z44.string().uuid(), reference: z44.string() }).nullable().optional()
 });
 var LauncherHistoryInputSchema = LauncherAgentIdSchema.extend({
-  before: z43.number().int().positive().optional(),
-  limit: z43.number().int().min(1).max(50).default(20)
-});
-var LauncherHistorySchema = z43.object({
-  turns: z43.array(LauncherTurnSchema),
-  nextBefore: z43.number().int().nullable()
-});
-var LauncherJobInputSchema = LauncherAgentIdSchema.extend({ jobId: z43.string().uuid() });
-var LauncherActivitySchema = z43.object({
-  id: z43.number().int(),
-  version: z43.literal(1),
-  runId: z43.string().uuid(),
-  type: z43.string(),
-  label: z43.string(),
-  outcome: z43.enum(["started", "completed", "failed", "info"]),
-  createdAt: z43.string()
-});
-var LauncherActivityPageSchema = z43.object({
-  events: z43.array(LauncherActivitySchema),
-  nextBefore: z43.number().int().nullable()
-});
-var LauncherViewSchema = z43.object({
-  agentUiEnabled: z43.boolean().optional(),
-  trial: z43.boolean().optional(),
+  before: z44.number().int().positive().optional(),
+  limit: z44.number().int().min(1).max(50).default(20)
+});
+var LauncherHistorySchema = z44.object({
+  turns: z44.array(LauncherTurnSchema),
+  nextBefore: z44.number().int().nullable()
+});
+var LauncherJobInputSchema = LauncherAgentIdSchema.extend({ jobId: z44.string().uuid() });
+var LauncherActivitySchema = z44.object({
+  id: z44.number().int(),
+  version: z44.literal(1),
+  runId: z44.string().uuid(),
+  type: z44.string(),
+  label: z44.string(),
+  outcome: z44.enum(["started", "completed", "failed", "info"]),
+  createdAt: z44.string()
+});
+var LauncherActivityPageSchema = z44.object({
+  events: z44.array(LauncherActivitySchema),
+  nextBefore: z44.number().int().nullable()
+});
+var LauncherViewSchema = z44.object({
+  agentUiEnabled: z44.boolean().optional(),
+  trial: z44.boolean().optional(),
   agent: LauncherAgentSchema,
-  accessEnabled: z43.boolean(),
-  state: z43.enum(["ready", "queued", "working", "paused", "recovering", "interrupted", "exhausted"]),
-  compute: z43.enum(["not_created", "starting", "running", "stopped", "unknown"]),
-  queuedCount: z43.number().int(),
+  accessEnabled: z44.boolean(),
+  state: z44.enum(["ready", "queued", "working", "paused", "recovering", "interrupted", "exhausted"]),
+  compute: z44.enum(["not_created", "starting", "running", "stopped", "unknown"]),
+  queuedCount: z44.number().int(),
+  /**
+   * The agent's running or parked job, which every queued job waits behind until it finishes
+   * (#2030). Its source tells the owner what a message is waiting for. Optional so a web bundle
+   * newer than the backend still reads an older view.
+   */
+  blockedBy: z44.object({ jobId: z44.string().uuid(), source: LauncherJobSourceSchema.nullable() }).nullable().optional(),
   history: LauncherHistorySchema,
   activity: LauncherActivityPageSchema
 });
-var LauncherPreviewSchema = z43.discriminatedUnion("kind", [
-  z43.object({
-    kind: z43.literal("text"),
-    content: z43.string().max(65536),
-    fileName: z43.string().optional()
+var LauncherPreviewSchema = z44.discriminatedUnion("kind", [
+  z44.object({
+    kind: z44.literal("text"),
+    content: z44.string().max(65536),
+    fileName: z44.string().optional()
   }),
-  z43.object({
-    kind: z43.literal("html"),
-    content: z43.string().max(5 * 1024 * 1024),
-    fileName: z43.string()
+  z44.object({
+    kind: z44.literal("html"),
+    content: z44.string().max(5 * 1024 * 1024),
+    fileName: z44.string()
   }),
-  z43.object({
-    kind: z43.literal("image"),
-    content: z43.string().max(7e5),
-    mimeType: z43.enum(["image/png", "image/jpeg", "image/gif", "image/webp"]),
-    fileName: z43.string().optional()
+  z44.object({
+    kind: z44.literal("image"),
+    content: z44.string().max(7e5),
+    mimeType: z44.enum(["image/png", "image/jpeg", "image/gif", "image/webp"]),
+    fileName: z44.string().optional()
   }),
-  z43.object({ kind: z43.literal("download"), reason: z43.string() })
+  z44.object({ kind: z44.literal("download"), reason: z44.string() })
 ]);
 var MAX_LAUNCHER_DOWNLOAD_BYTES = 16 * 1024 * 1024;
 var LauncherSessionSendSchema = LauncherAgentIdSchema.extend({
-  recipientAgentId: z43.string().uuid(),
-  requestKey: z43.string().uuid(),
-  message: z43.string().trim().min(1).max(16e3)
+  recipientAgentId: z44.string().uuid(),
+  requestKey: z44.string().uuid(),
+  message: z44.string().trim().min(1).max(16e3)
 }).strict();
 var LauncherSessionHistoryInputSchema = LauncherAgentIdSchema.extend({
-  peerAgentId: z43.string().uuid().optional(),
-  before: z43.number().int().positive().optional(),
-  limit: z43.number().int().min(1).max(50).default(20)
+  peerAgentId: z44.string().uuid().optional(),
+  before: z44.number().int().positive().optional(),
+  limit: z44.number().int().min(1).max(50).default(20)
 });
 var LauncherSessionMessageSchema = LauncherTurnSchema.extend({
-  agentId: z43.string().uuid(),
-  senderAgentId: z43.string().uuid()
-});
-var LauncherSessionHistorySchema = z43.object({
-  messages: z43.array(LauncherSessionMessageSchema),
-  nextBefore: z43.number().int().nullable()
-});
-var LauncherMarketOperationSchema = z43.object({
-  id: z43.string().uuid(),
-  action: z43.string(),
-  state: z43.enum(["pending", "completed", "failed"]),
-  taskId: z43.string().nullable(),
-  taskTitle: z43.string().nullable(),
+  agentId: z44.string().uuid(),
+  senderAgentId: z44.string().uuid()
+});
+var LauncherSessionHistorySchema = z44.object({
+  messages: z44.array(LauncherSessionMessageSchema),
+  nextBefore: z44.number().int().nullable()
+});
+var LauncherMarketOperationSchema = z44.object({
+  id: z44.string().uuid(),
+  action: z44.string(),
+  state: z44.enum(["pending", "completed", "failed"]),
+  taskId: z44.string().nullable(),
+  taskTitle: z44.string().nullable(),
   /** USDC base units: the payment when one was quoted, else the reward or price the action named. */
-  amount: z43.string().regex(/^\d+$/).nullable(),
+  amount: z44.string().regex(/^\d+$/).nullable(),
   /** True once the payment for this action settled on chain. */
-  paid: z43.boolean(),
-  transactionHash: z43.string().nullable(),
-  submissionId: z43.string().nullable(),
+  paid: z44.boolean(),
+  transactionHash: z44.string().nullable(),
+  submissionId: z44.string().nullable(),
   /** A bounded upper-case error code when the action failed. */
-  errorCode: z43.string().nullable(),
-  createdAt: z43.string(),
-  updatedAt: z43.string()
-});
-var LauncherMarketSummarySchema = z43.object({
-  activeTasks: z43.number().int().nonnegative(),
-  submissions: z43.number().int().nonnegative(),
-  tasksPublished: z43.number().int().nonnegative(),
-  wins: z43.number().int().nonnegative(),
-  pending: z43.number().int().nonnegative(),
-  failed: z43.number().int().nonnegative(),
+  errorCode: z44.string().nullable(),
+  createdAt: z44.string(),
+  updatedAt: z44.string()
+});
+var LauncherMarketSummarySchema = z44.object({
+  activeTasks: z44.number().int().nonnegative(),
+  submissions: z44.number().int().nonnegative(),
+  tasksPublished: z44.number().int().nonnegative(),
+  wins: z44.number().int().nonnegative(),
+  pending: z44.number().int().nonnegative(),
+  failed: z44.number().int().nonnegative(),
   /** Settled market payments in USDC base units (fees, and escrow for published tasks). */
-  spent: z43.string().regex(/^\d+$/),
+  spent: z44.string().regex(/^\d+$/),
   /** Worker payouts for tasks this agent worked, in USDC base units. */
-  earnings: z43.string().regex(/^\d+$/)
+  earnings: z44.string().regex(/^\d+$/)
 });
 var LauncherAgentMarketInputSchema = LauncherAgentIdSchema.extend({
-  limit: z43.number().int().min(1).max(100).default(50)
+  limit: z44.number().int().min(1).max(100).default(50)
 });
-var LauncherAgentMarketSchema = z43.object({
-  operations: z43.array(LauncherMarketOperationSchema),
+var LauncherAgentMarketSchema = z44.object({
+  operations: z44.array(LauncherMarketOperationSchema),
   summary: LauncherMarketSummarySchema
 });
-var LauncherAgentMarketTasksInputSchema = z43.object({
-  agentId: z43.string().uuid(),
-  view: z43.enum(["both", "posted", "attempted"]).default("both"),
-  limit: z43.number().int().min(1).max(50).default(5),
+var LauncherAgentMarketTasksInputSchema = z44.object({
+  agentId: z44.string().uuid(),
+  view: z44.enum(["both", "posted", "attempted"]).default("both"),
+  limit: z44.number().int().min(1).max(50).default(5),
   /** Opaque, per list. Only accepted with view 'posted' or 'attempted'. */
-  cursor: z43.string().max(200).optional()
+  cursor: z44.string().max(200).optional()
 }).strict();
 var LAUNCHER_POSTED_TASK_STATUSES = [
   // A create approval is pending or approving; the row carries `approvalId` for Review.
@@ -6141,9 +6563,9 @@ var LAUNCHER_POSTED_TASK_STATUSES = [
   "expired",
   "cancelled"
 ];
-var LauncherPostedTaskStatusSchema = z43.enum(LAUNCHER_POSTED_TASK_STATUSES);
+var LauncherPostedTaskStatusSchema = z44.enum(LAUNCHER_POSTED_TASK_STATUSES);
 var LAUNCHER_ATTEMPT_KINDS = ["claim", "pitch", "bid", "proof", "submit"];
-var LauncherAttemptKindSchema = z43.enum(LAUNCHER_ATTEMPT_KINDS);
+var LauncherAttemptKindSchema = z44.enum(LAUNCHER_ATTEMPT_KINDS);
 var LAUNCHER_ATTEMPT_OUTCOMES = [
   // A paid worker write (pitch, bid, paid submission) awaits the owner; `approvalId` set.
   "awaiting_approval",
@@ -6170,43 +6592,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 = z43.enum(LAUNCHER_ATTEMPT_OUTCOMES);
-var UsdcUnitsSchema = z43.string().regex(/^\d+$/);
-var LauncherPostedTaskSchema = z43.object({
+var LauncherAttemptOutcomeSchema = z44.enum(LAUNCHER_ATTEMPT_OUTCOMES);
+var UsdcUnitsSchema = z44.string().regex(/^\d+$/);
+var LauncherPostedTaskSchema = z44.object({
   /** Stable per row: `task:<taskId>`, `approval:<id>`, `operation:<id>` or `refusal:<id>`. */
-  key: z43.string(),
+  key: z44.string(),
   /** Null for drafts, refusals and publishes not resolved to a task yet. */
-  taskId: z43.string().nullable(),
-  title: z43.string().nullable(),
+  taskId: z44.string().nullable(),
+  title: z44.string().nullable(),
   /** The task mode as stored on tasks.mode, or as drafted. */
-  mode: z43.string().nullable(),
+  mode: z44.string().nullable(),
   /** USDC base units. */
   rewardUnits: UsdcUnitsSchema.nullable(),
   status: LauncherPostedTaskStatusSchema,
   /** Set while status is awaiting_approval. */
-  approvalId: z43.string().uuid().nullable(),
-  approvalExpiresAt: z43.string().nullable(),
+  approvalId: z44.string().uuid().nullable(),
+  approvalExpiresAt: z44.string().nullable(),
   /** Submissions; pitches for pitch mode; bids for auction mode. Null with no task. */
-  submissions: z43.number().int().nonnegative().nullable(),
+  submissions: z44.number().int().nonnegative().nullable(),
   /** The deadline that matters for the current status. */
-  deadlineAt: z43.string().nullable(),
+  deadlineAt: z44.string().nullable(),
   /** The rank-1 award recipient once completed; `memberName` when it is a hosted swarm member. */
-  winner: z43.object({ hosted: z43.boolean(), memberName: z43.string().nullable() }).nullable(),
+  winner: z44.object({ hosted: z44.boolean(), memberName: z44.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: z43.string().nullable(),
+  reasonCode: z44.string().nullable(),
   /** The publishing transaction (the task's escrow transaction) when known. */
-  transactionHash: z43.string().nullable(),
-  createdAt: z43.string(),
-  updatedAt: z43.string()
+  transactionHash: z44.string().nullable(),
+  createdAt: z44.string(),
+  updatedAt: z44.string()
 });
-var LauncherAttemptedTaskSchema = z43.object({
+var LauncherAttemptedTaskSchema = z44.object({
   /** Stable per row: `task:<taskId>`, `approval:<id>` or `refusal:<id>`. */
-  key: z43.string(),
-  taskId: z43.string().nullable(),
-  title: z43.string().nullable(),
-  mode: z43.string().nullable(),
+  key: z44.string(),
+  taskId: z44.string().nullable(),
+  title: z44.string().nullable(),
+  mode: z44.string().nullable(),
   rewardUnits: UsdcUnitsSchema.nullable(),
   /** The kind of the agent's latest attempt on the task. */
   attempt: LauncherAttemptKindSchema,
@@ -6214,70 +6636,70 @@ var LauncherAttemptedTaskSchema = z43.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: z43.object({ agentId: z43.string(), name: z43.string() }).nullable(),
-  approvalId: z43.string().uuid().nullable(),
+  continuedBy: z44.object({ agentId: z44.string(), name: z44.string() }).nullable(),
+  approvalId: z44.string().uuid().nullable(),
   /** A machine code for not_approved, blocked and did_not_go_through. */
-  reasonCode: z43.string().nullable(),
-  transactionHash: z43.string().nullable(),
-  createdAt: z43.string(),
-  updatedAt: z43.string()
+  reasonCode: z44.string().nullable(),
+  transactionHash: z44.string().nullable(),
+  createdAt: z44.string(),
+  updatedAt: z44.string()
 });
-var LauncherAgentMarketTasksSchema = z43.object({
-  counts: z43.object({
+var LauncherAgentMarketTasksSchema = z44.object({
+  counts: z44.object({
     /** Every Posted row, drafts and refused creates included. */
-    posted: z43.number().int().nonnegative(),
+    posted: z44.number().int().nonnegative(),
     /** awaiting_approval, publishing, open, in_progress, in_review, appealing and disputed. */
-    postedOpen: z43.number().int().nonnegative(),
+    postedOpen: z44.number().int().nonnegative(),
     /** Every Attempted row. */
-    attempted: z43.number().int().nonnegative(),
+    attempted: z44.number().int().nonnegative(),
     /** awaiting_approval, working and awaiting_result. */
-    attemptedActive: z43.number().int().nonnegative(),
-    won: z43.number().int().nonnegative(),
+    attemptedActive: z44.number().int().nonnegative(),
+    won: z44.number().int().nonnegative(),
     /** The sum of amountUnits over won rows. */
     earnedUnits: UsdcUnitsSchema
   }),
   /** Empty when view is 'attempted'. */
-  posted: z43.object({
-    items: z43.array(LauncherPostedTaskSchema),
-    nextCursor: z43.string().nullable()
+  posted: z44.object({
+    items: z44.array(LauncherPostedTaskSchema),
+    nextCursor: z44.string().nullable()
   }),
   /** Empty when view is 'posted'. */
-  attempted: z43.object({
-    items: z43.array(LauncherAttemptedTaskSchema),
-    nextCursor: z43.string().nullable()
+  attempted: z44.object({
+    items: z44.array(LauncherAttemptedTaskSchema),
+    nextCursor: z44.string().nullable()
   })
 });
-var LauncherMarketOverviewSchema = z43.object({
-  agents: z43.array(z43.object({ agentId: z43.string(), activeTasks: z43.number().int().nonnegative() }))
+var LauncherMarketOverviewSchema = z44.object({
+  agents: z44.array(z44.object({ agentId: z44.string(), activeTasks: z44.number().int().nonnegative() }))
 });
 
 // ../../packages/shared/dist/schemas/launcher-schedule.schemas.js
-import { z as z44 } from "zod";
+import { z as z45 } from "zod";
 var SCHEDULE_SCAN_SECONDS = 300;
-var LauncherScheduleControlSchema = z44.object({
-  agentId: z44.string().uuid(),
-  requestKey: z44.string().uuid(),
-  enabled: z44.boolean()
+var LauncherScheduleControlSchema = z45.object({
+  agentId: z45.string().uuid(),
+  requestKey: z45.string().uuid(),
+  enabled: z45.boolean()
 }).strict();
-var LauncherNextStepSchema = z44.discriminatedUnion("state", [
-  z44.object({
-    state: z44.literal("scheduled"),
-    delaySeconds: z44.number().int().min(SCHEDULE_SCAN_SECONDS).max(30 * 86400),
-    prompt: z44.string().trim().min(1).max(32768)
+var LauncherNextStepSchema = z45.discriminatedUnion("state", [
+  z45.object({
+    state: z45.literal("scheduled"),
+    delaySeconds: z45.number().int().min(SCHEDULE_SCAN_SECONDS).max(30 * 86400),
+    prompt: z45.string().trim().min(1).max(32768)
   }).strict(),
-  z44.object({
-    state: z44.literal("waiting"),
-    reason: z44.enum(["external", "owner", "funds"]),
-    prompt: z44.string().trim().min(1).max(32768)
+  z45.object({
+    state: z45.literal("waiting"),
+    reason: z45.enum(["external", "owner", "funds"]),
+    prompt: z45.string().trim().min(1).max(32768)
   }).strict(),
-  z44.object({ state: z44.literal("idle") }).strict()
+  z45.object({ state: z45.literal("idle") }).strict()
 ]);
-var LauncherScheduleNextSchema = z44.object({
-  agentId: z44.string().uuid(),
-  requestKey: z44.string().uuid(),
+var LauncherScheduleNextSchema = z45.object({
+  agentId: z45.string().uuid(),
+  requestKey: z45.string().uuid(),
   step: LauncherNextStepSchema
 }).strict();
-var LauncherScheduleStatusSchema = z44.enum([
+var LauncherScheduleStatusSchema = z45.enum([
   "disabled",
   "idle",
   "scheduled",
@@ -6292,65 +6714,65 @@ var LauncherScheduleStatusSchema = z44.enum([
   "waiting_funds",
   "source_failed"
 ]);
-var LauncherScheduleViewSchema = z44.object({
-  agentId: z44.string().uuid(),
-  enabled: z44.boolean(),
-  revision: z44.number().int(),
-  generation: z44.number().int(),
-  nextRunAt: z44.string().nullable(),
-  prompt: z44.string().nullable(),
-  waitingFor: z44.enum(["external", "owner", "funds"]).nullable(),
+var LauncherScheduleViewSchema = z45.object({
+  agentId: z45.string().uuid(),
+  enabled: z45.boolean(),
+  revision: z45.number().int(),
+  generation: z45.number().int(),
+  nextRunAt: z45.string().nullable(),
+  prompt: z45.string().nullable(),
+  waitingFor: z45.enum(["external", "owner", "funds"]).nullable(),
   status: LauncherScheduleStatusSchema,
-  label: z44.string(),
-  lastJobId: z44.string().nullable(),
-  asOf: z44.string(),
-  scanEverySeconds: z44.literal(SCHEDULE_SCAN_SECONDS)
+  label: z45.string(),
+  lastJobId: z45.string().nullable(),
+  asOf: z45.string(),
+  scanEverySeconds: z45.literal(SCHEDULE_SCAN_SECONDS)
 });
 
 // ../../packages/shared/dist/schemas/swarm-coordination.schemas.js
-import { z as z45 } from "zod";
-var SwarmCoordinationPermissionsSchema = z45.object({
-  create: z45.boolean().default(false),
-  dispatch: z45.boolean().default(false),
-  resume: z45.boolean().default(false)
+import { z as z46 } from "zod";
+var SwarmCoordinationPermissionsSchema = z46.object({
+  create: z46.boolean().default(false),
+  dispatch: z46.boolean().default(false),
+  resume: z46.boolean().default(false)
 }).strict();
-var SwarmProfileInputSchema = z45.object({
-  agentId: z45.string().uuid(),
-  requestKey: z45.string().uuid(),
-  name: z45.string().trim().min(1).max(100),
-  responsibility: z45.string().trim().max(500),
+var SwarmProfileInputSchema = z46.object({
+  agentId: z46.string().uuid(),
+  requestKey: z46.string().uuid(),
+  name: z46.string().trim().min(1).max(100),
+  responsibility: z46.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: z45.string().trim().max(16e3).optional(),
+  instructions: z46.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: z45.number().int().min(0).optional(),
+  instructionsVersion: z46.number().int().min(0).optional(),
   permissions: SwarmCoordinationPermissionsSchema
 }).strict();
-var SwarmProfileSchema = z45.object({
-  available: z45.boolean().default(false),
-  agentId: z45.string().uuid(),
-  name: z45.string(),
-  responsibility: z45.string(),
-  instructions: z45.string(),
+var SwarmProfileSchema = z46.object({
+  available: z46.boolean().default(false),
+  agentId: z46.string().uuid(),
+  name: z46.string(),
+  responsibility: z46.string(),
+  instructions: z46.string(),
   /** Version of the live instructions.md memory document; 0 when there is none. */
-  instructionsVersion: z45.number().int().default(0),
-  version: z45.number().int(),
-  generation: z45.number().int(),
-  creatorAgentId: z45.string().uuid().nullable(),
-  creatorJobId: z45.string().uuid().nullable(),
+  instructionsVersion: z46.number().int().default(0),
+  version: z46.number().int(),
+  generation: z46.number().int(),
+  creatorAgentId: z46.string().uuid().nullable(),
+  creatorJobId: z46.string().uuid().nullable(),
   permissions: SwarmCoordinationPermissionsSchema
 });
-var SwarmMemberSchema = z45.object({
-  agentId: z45.string().uuid(),
-  name: z45.string(),
-  responsibility: z45.string(),
-  creatorAgentId: z45.string().uuid().nullable(),
-  state: z45.enum([
+var SwarmMemberSchema = z46.object({
+  agentId: z46.string().uuid(),
+  name: z46.string(),
+  responsibility: z46.string(),
+  creatorAgentId: z46.string().uuid().nullable(),
+  state: z46.enum([
     "idle",
     "queued",
     "working",
@@ -6361,95 +6783,95 @@ var SwarmMemberSchema = z45.object({
     "waiting",
     "failed"
   ]),
-  queuedCount: z45.number().int(),
-  jobId: z45.string().uuid().nullable(),
-  runId: z45.string().uuid().nullable(),
-  headline: z45.string().nullable(),
-  progress: z45.string().nullable(),
-  updatedAt: z45.string().nullable(),
-  freshness: z45.enum(["current", "stale", "unpublished"]),
-  waitingFor: z45.array(z45.string().uuid()),
-  nextRunAt: z45.string().nullable(),
-  lastResult: z45.object({
-    jobId: z45.string().uuid(),
-    summary: z45.string(),
-    artifacts: z45.array(z45.object({ artifactId: z45.string().uuid(), sha256: z45.string(), path: z45.string() })).optional(),
-    finishedAt: z45.string().nullable()
+  queuedCount: z46.number().int(),
+  jobId: z46.string().uuid().nullable(),
+  runId: z46.string().uuid().nullable(),
+  headline: z46.string().nullable(),
+  progress: z46.string().nullable(),
+  updatedAt: z46.string().nullable(),
+  freshness: z46.enum(["current", "stale", "unpublished"]),
+  waitingFor: z46.array(z46.string().uuid()),
+  nextRunAt: z46.string().nullable(),
+  lastResult: z46.object({
+    jobId: z46.string().uuid(),
+    summary: z46.string(),
+    artifacts: z46.array(z46.object({ artifactId: z46.string().uuid(), sha256: z46.string(), path: z46.string() })).optional(),
+    finishedAt: z46.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: z45.object({
-    jobId: z45.string().uuid(),
+  lastFinished: z46.object({
+    jobId: z46.string().uuid(),
     status: LauncherJobStatusSchema.extract(["completed", "failed", "interrupted"]),
-    finishedAt: z45.string().nullable()
+    finishedAt: z46.string().nullable()
   }).nullable().optional(),
-  asOf: z45.string()
+  asOf: z46.string()
 });
-var SwarmOverviewSchema = z45.object({
-  members: z45.array(SwarmMemberSchema).max(10),
-  asOf: z45.string()
+var SwarmOverviewSchema = z46.object({
+  members: z46.array(SwarmMemberSchema).max(10),
+  asOf: z46.string()
 });
-var artifactIds = z45.array(z45.string().uuid()).max(8).default([]);
+var artifactIds = z46.array(z46.string().uuid()).max(8).default([]);
 var SwarmToolInputSchemas = {
-  sessions_list: z45.object({}).strict(),
-  sessions_inspect: z45.object({ agentId: z45.string().uuid() }).strict(),
-  sessions_create: z45.object({
-    intentKey: z45.string().trim().min(1).max(100),
-    name: z45.string().trim().min(1).max(100),
-    responsibility: z45.string().trim().min(1).max(500),
-    instructions: z45.string().trim().min(1).max(16e3),
-    prompt: z45.string().trim().min(1).max(16e3)
+  sessions_list: z46.object({}).strict(),
+  sessions_inspect: z46.object({ agentId: z46.string().uuid() }).strict(),
+  sessions_create: z46.object({
+    intentKey: z46.string().trim().min(1).max(100),
+    name: z46.string().trim().min(1).max(100),
+    responsibility: z46.string().trim().min(1).max(500),
+    instructions: z46.string().trim().min(1).max(16e3),
+    prompt: z46.string().trim().min(1).max(16e3)
   }).strict(),
-  sessions_send: z45.object({
-    agentId: z45.string().uuid(),
-    requestKey: z45.string().uuid(),
-    message: z45.string().trim().min(1).max(16e3),
+  sessions_send: z46.object({
+    agentId: z46.string().uuid(),
+    requestKey: z46.string().uuid(),
+    message: z46.string().trim().min(1).max(16e3),
     artifactIds
   }).strict(),
-  sessions_history: z45.object({
-    agentId: z45.string().uuid().optional(),
-    before: z45.number().int().positive().optional()
+  sessions_history: z46.object({
+    agentId: z46.string().uuid().optional(),
+    before: z46.number().int().positive().optional()
   }).strict(),
-  sessions_result: z45.object({ jobId: z45.string().uuid() }).strict(),
-  sessions_wait: z45.object({
-    jobIds: z45.array(z45.string().uuid()).min(1).max(8),
-    mode: z45.enum(["any", "all"]),
-    prompt: z45.string().trim().min(1).max(16e3),
-    timeoutSeconds: z45.number().int().min(60).max(604800)
+  sessions_result: z46.object({ jobId: z46.string().uuid() }).strict(),
+  sessions_wait: z46.object({
+    jobIds: z46.array(z46.string().uuid()).min(1).max(8),
+    mode: z46.enum(["any", "all"]),
+    prompt: z46.string().trim().min(1).max(16e3),
+    timeoutSeconds: z46.number().int().min(60).max(604800)
   }).strict(),
-  sessions_update_status: z45.object({
-    headline: z45.string().trim().min(1).max(200),
-    progress: z45.string().trim().max(1e3),
-    resultSummary: z45.string().trim().max(1e3).optional(),
+  sessions_update_status: z46.object({
+    headline: z46.string().trim().min(1).max(200),
+    progress: z46.string().trim().max(1e3),
+    resultSummary: z46.string().trim().max(1e3).optional(),
     artifactIds
   }).strict(),
-  sessions_read_artifact: z45.object({ artifactId: z45.string().uuid() }).strict()
+  sessions_read_artifact: z46.object({ artifactId: z46.string().uuid() }).strict()
 };
-var SwarmWaitSchema = z45.object({
-  id: z45.string().uuid(),
-  sourceJobId: z45.string().uuid(),
-  jobIds: z45.array(z45.string().uuid()),
-  state: z45.enum(["pending", "delivered", "cancelled"]),
-  reason: z45.string().nullable(),
-  deadline: z45.string(),
-  continuationJobId: z45.string().uuid().nullable()
+var SwarmWaitSchema = z46.object({
+  id: z46.string().uuid(),
+  sourceJobId: z46.string().uuid(),
+  jobIds: z46.array(z46.string().uuid()),
+  state: z46.enum(["pending", "delivered", "cancelled"]),
+  reason: z46.string().nullable(),
+  deadline: z46.string(),
+  continuationJobId: z46.string().uuid().nullable()
 });
 
 // ../../packages/shared/dist/schemas/direct-agent-checkpoint.schemas.js
-import { z as z49 } from "zod";
+import { z as z50 } from "zod";
 
 // ../../packages/shared/dist/schemas/turn-attribution.schemas.js
-import { z as z46 } from "zod";
+import { z as z47 } from "zod";
 var TURN_ATTRIBUTION_RECORD_VERSION = 1;
-var TurnAttributionIdentitySchema = z46.object({
-  sessionId: z46.string().min(1).max(256),
-  turnId: z46.string().min(1).max(256),
+var TurnAttributionIdentitySchema = z47.object({
+  sessionId: z47.string().min(1).max(256),
+  turnId: z47.string().min(1).max(256),
   /** Non-null exactly for native helpers; a root or maintenance turn has no subagent. */
-  subagentId: z46.string().min(1).max(256).nullable(),
-  role: z46.enum(ROUTING_EXECUTION_ROLES)
+  subagentId: z47.string().min(1).max(256).nullable(),
+  role: z47.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" });
@@ -6457,18 +6879,18 @@ var TurnAttributionIdentitySchema = z46.object({
     ctx.addIssue({ code: "custom", message: "Only a native helper identity carries a subagent" });
 });
 var PinnedTurnAttributionSchema = RoutingAttributionSchema.extend({
-  operationId: z46.string().uuid().nullable(),
-  inheritedFrom: z46.string().min(1).max(1024).nullable()
+  operationId: z47.string().uuid().nullable(),
+  inheritedFrom: z47.string().min(1).max(1024).nullable()
 }).strict();
 var MAX_ATTRIBUTION_EPOCHS = 32;
 var TurnAttributionEpochSchema = PinnedTurnAttributionSchema.extend({
-  epoch: z46.number().int().positive().max(MAX_ATTRIBUTION_EPOCHS)
+  epoch: z47.number().int().positive().max(MAX_ATTRIBUTION_EPOCHS)
 }).strict();
-var TurnAttributionLedgerSchema = z46.object({
-  version: z46.literal(TURN_ATTRIBUTION_RECORD_VERSION),
-  epochs: z46.array(TurnAttributionEpochSchema).max(MAX_ATTRIBUTION_EPOCHS),
+var TurnAttributionLedgerSchema = z47.object({
+  version: z47.literal(TURN_ATTRIBUTION_RECORD_VERSION),
+  epochs: z47.array(TurnAttributionEpochSchema).max(MAX_ATTRIBUTION_EPOCHS),
   /** `turnAttributionKey()` to epoch number. Bounded by the provider's own history limit. */
-  turns: z46.record(z46.number().int().positive().max(MAX_ATTRIBUTION_EPOCHS))
+  turns: z47.record(z47.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)
@@ -6477,13 +6899,13 @@ var TurnAttributionLedgerSchema = z46.object({
     if (!ids.includes(epoch))
       ctx.addIssue({ code: "custom", message: `Turn references unknown epoch ${epoch}` });
 });
-var ManagedTurnUsageSchema = z46.object({
-  inputTokens: z46.number().int().nonnegative(),
-  outputTokens: z46.number().int().nonnegative(),
-  totalTokens: z46.number().int().nonnegative(),
-  cacheReadTokens: z46.number().int().nonnegative().nullable(),
-  cacheWriteTokens: z46.number().int().nonnegative().nullable(),
-  reasoningTokens: z46.number().int().nonnegative().nullable()
+var ManagedTurnUsageSchema = z47.object({
+  inputTokens: z47.number().int().nonnegative(),
+  outputTokens: z47.number().int().nonnegative(),
+  totalTokens: z47.number().int().nonnegative(),
+  cacheReadTokens: z47.number().int().nonnegative().nullable(),
+  cacheWriteTokens: z47.number().int().nonnegative().nullable(),
+  reasoningTokens: z47.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" });
@@ -6492,14 +6914,14 @@ var ManagedTurnUsageSchema = z46.object({
   if ((usage.reasoningTokens ?? 0) > usage.outputTokens)
     ctx.addIssue({ code: "custom", message: "Reasoning cannot exceed output" });
 });
-var TurnAttributionStampSchema = z46.object({
-  recordVersion: z46.literal(TURN_ATTRIBUTION_RECORD_VERSION),
+var TurnAttributionStampSchema = z47.object({
+  recordVersion: z47.literal(TURN_ATTRIBUTION_RECORD_VERSION),
   identity: TurnAttributionIdentitySchema,
   attribution: PinnedTurnAttributionSchema
 }).strict();
 
 // ../../packages/shared/dist/schemas/user-skills.schemas.js
-import { z as z47 } from "zod";
+import { z as z48 } from "zod";
 import { parseDocument } from "yaml";
 var USER_SKILL_LIMITS = {
   files: 20,
@@ -6510,18 +6932,18 @@ var USER_SKILL_LIMITS = {
   assignedFiles: 100
 };
 var bytes = (value) => new TextEncoder().encode(value).length;
-var UserSkillPathSchema = z47.string().min(1).max(240).refine((path3) => {
+var UserSkillPathSchema = z48.string().min(1).max(240).refine((path3) => {
   const parts = path3.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(path3) && (path3 === "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 = z47.object({
+var UserSkillFileSchema = z48.object({
   path: UserSkillPathSchema,
-  content: z47.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: z48.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 = z47.object({
-  name: z47.string().trim().max(100),
-  description: z47.string().trim().max(300),
-  files: z47.array(UserSkillFileSchema).min(1).max(USER_SKILL_LIMITS.files)
+var UserSkillDraftBundleSchema = z48.object({
+  name: z48.string().trim().max(100),
+  description: z48.string().trim().max(300),
+  files: z48.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 + "/"))))
@@ -6532,104 +6954,104 @@ var UserSkillDraftBundleSchema = z47.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 = z47.object({
-  skillId: z47.string().uuid(),
-  version: z47.number().int().positive(),
-  digest: z47.string().regex(/^[a-f0-9]{64}$/)
+var UserSkillPinSchema = z48.object({
+  skillId: z48.string().uuid(),
+  version: z48.number().int().positive(),
+  digest: z48.string().regex(/^[a-f0-9]{64}$/)
 }).strict();
-var UserSkillPinsSchema = z47.array(UserSkillPinSchema).max(USER_SKILL_LIMITS.assigned);
-var UserSkillIdSchema = z47.object({ skillId: z47.string().uuid() });
+var UserSkillPinsSchema = z48.array(UserSkillPinSchema).max(USER_SKILL_LIMITS.assigned);
+var UserSkillIdSchema = z48.object({ skillId: z48.string().uuid() });
 var UserSkillDraftInputSchema = UserSkillIdSchema.extend({
-  requestKey: z47.string().uuid(),
-  expectedRevision: z47.number().int().nonnegative(),
+  requestKey: z48.string().uuid(),
+  expectedRevision: z48.number().int().nonnegative(),
   bundle: UserSkillDraftBundleSchema
 });
 var UserSkillSaveVersionSchema = UserSkillIdSchema.extend({
-  requestKey: z47.string().uuid(),
-  expectedRevision: z47.number().int().nonnegative(),
-  note: z47.string().trim().max(500).default(""),
-  restoreVersion: z47.number().int().positive().optional()
+  requestKey: z48.string().uuid(),
+  expectedRevision: z48.number().int().nonnegative(),
+  note: z48.string().trim().max(500).default(""),
+  restoreVersion: z48.number().int().positive().optional()
 });
 var UserSkillAssignSchema = UserSkillIdSchema.extend({
-  requestKey: z47.string().uuid(),
-  version: z47.number().int().positive().nullable(),
-  agents: z47.array(z47.object({ agentId: z47.string().uuid(), expectedRevision: z47.number().int().nonnegative() })).min(1).max(100)
+  requestKey: z48.string().uuid(),
+  version: z48.number().int().positive().nullable(),
+  agents: z48.array(z48.object({ agentId: z48.string().uuid(), expectedRevision: z48.number().int().nonnegative() })).min(1).max(100)
 });
 var UserSkillArchiveSchema = UserSkillIdSchema.extend({
-  requestKey: z47.string().uuid(),
-  expectedRevision: z47.number().int().nonnegative(),
-  archived: z47.boolean(),
-  removeAssignments: z47.boolean().default(false)
-});
-var UserSkillSummarySchema = z47.object({
-  id: z47.string().uuid(),
-  name: z47.string(),
-  description: z47.string(),
-  archived: z47.boolean(),
-  latestVersion: z47.number().int(),
-  revision: z47.number().int(),
-  hasDraft: z47.boolean(),
-  assignedCount: z47.number().int(),
-  outdatedCount: z47.number().int(),
-  updatedAt: z47.string()
-});
-var UserSkillAgentSchema = z47.object({
-  agentId: z47.string().uuid(),
-  name: z47.string(),
-  managed: z47.boolean().optional(),
-  paused: z47.boolean(),
-  working: z47.boolean(),
-  revision: z47.number().int(),
+  requestKey: z48.string().uuid(),
+  expectedRevision: z48.number().int().nonnegative(),
+  archived: z48.boolean(),
+  removeAssignments: z48.boolean().default(false)
+});
+var UserSkillSummarySchema = z48.object({
+  id: z48.string().uuid(),
+  name: z48.string(),
+  description: z48.string(),
+  archived: z48.boolean(),
+  latestVersion: z48.number().int(),
+  revision: z48.number().int(),
+  hasDraft: z48.boolean(),
+  assignedCount: z48.number().int(),
+  outdatedCount: z48.number().int(),
+  updatedAt: z48.string()
+});
+var UserSkillAgentSchema = z48.object({
+  agentId: z48.string().uuid(),
+  name: z48.string(),
+  managed: z48.boolean().optional(),
+  paused: z48.boolean(),
+  working: z48.boolean(),
+  revision: z48.number().int(),
   desired: UserSkillPinsSchema,
   observed: UserSkillPinsSchema,
-  state: z47.enum(["pending", "applying", "ready", "error"]),
-  errorCode: z47.string().nullable(),
-  sessionId: z47.string().nullable()
-});
-var UserSkillLibrarySchema = z47.object({
-  skills: z47.array(UserSkillSummarySchema),
-  agents: z47.array(UserSkillAgentSchema)
-});
-var UserSkillVersionSchema = z47.object({
-  version: z47.number().int(),
-  digest: z47.string(),
-  name: z47.string(),
-  description: z47.string(),
-  bytes: z47.number().int(),
-  fileCount: z47.number().int(),
-  note: z47.string(),
-  createdAt: z47.string()
-});
-var UserSkillDetailSchema = z47.object({
+  state: z48.enum(["pending", "applying", "ready", "error"]),
+  errorCode: z48.string().nullable(),
+  sessionId: z48.string().nullable()
+});
+var UserSkillLibrarySchema = z48.object({
+  skills: z48.array(UserSkillSummarySchema),
+  agents: z48.array(UserSkillAgentSchema)
+});
+var UserSkillVersionSchema = z48.object({
+  version: z48.number().int(),
+  digest: z48.string(),
+  name: z48.string(),
+  description: z48.string(),
+  bytes: z48.number().int(),
+  fileCount: z48.number().int(),
+  note: z48.string(),
+  createdAt: z48.string()
+});
+var UserSkillDetailSchema = z48.object({
   skill: UserSkillSummarySchema,
   draft: UserSkillDraftBundleSchema.nullable(),
-  versions: z47.array(UserSkillVersionSchema),
-  agents: z47.array(UserSkillAgentSchema)
+  versions: z48.array(UserSkillVersionSchema),
+  agents: z48.array(UserSkillAgentSchema)
 });
 
 // ../../packages/shared/dist/schemas/managed-billing.schemas.js
-import { z as z48 } from "zod";
-var id = z48.string().min(1).max(256);
-var usd = z48.string().regex(/^(0|[1-9]\d{0,9})(\.\d{1,6})?$/);
+import { z as z49 } from "zod";
+var id = z49.string().min(1).max(256);
+var usd = z49.string().regex(/^(0|[1-9]\d{0,9})(\.\d{1,6})?$/);
 var SANDBOX_CONTAINER_SIZES = ["small", "medium", "large"];
-var ManagedCostPolicySchema = z48.object({
+var ManagedCostPolicySchema = z49.object({
   version: id,
-  region: z48.enum(["global", "regional"]),
+  region: z49.enum(["global", "regional"]),
   ownerDailyUsd: usd,
   platformDailyUsd: usd,
   computeReserveUsd: usd,
   retainedResourceDailyUsd: usd,
-  maxConcurrentOperations: z48.number().int().min(1).max(64),
-  maxUnresolvedOperations: z48.number().int().min(1).max(1e4),
-  maxUnresolvedAgeMs: z48.number().int().min(6e4).max(6048e5),
+  maxConcurrentOperations: z49.number().int().min(1).max(64),
+  maxUnresolvedOperations: z49.number().int().min(1).max(1e4),
+  maxUnresolvedAgeMs: z49.number().int().min(6e4).max(6048e5),
   /** Supplier invoice age advisory threshold; does not stop otherwise authorized work. */
-  reconciliationMaxAgeMs: z48.number().int().min(6e4).max(6048e5),
+  reconciliationMaxAgeMs: z49.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: z48.array(z48.enum([
+  models: z49.array(z49.enum([
     "gpt-5.6-luna",
     "gpt-5.6-sol",
     "gpt-6-astra",
@@ -6637,42 +7059,42 @@ var ManagedCostPolicySchema = z48.object({
     "gpt-6-sol",
     "gpt-6.1-sol"
   ])).min(1),
-  nativeHelpersQualified: z48.boolean(),
+  nativeHelpersQualified: z49.boolean(),
   /** Explicit estimate for bounded native review processing/storage, including recovery. */
-  nativeReviewProcessing: z48.object({
+  nativeReviewProcessing: z49.object({
     usdPerRun: usd,
-    qualificationEvidence: z48.string().trim().min(1).max(256)
+    qualificationEvidence: z49.string().trim().min(1).max(256)
   }).strict().optional(),
   /** ADR-0283: direct evaluator calls require separately qualified, pinned rates and bounds. */
-  nativeModels: z48.array(z48.object({
-    provider: z48.enum(["openai-responses", "typesafe"]),
+  nativeModels: z49.array(z49.object({
+    provider: z49.enum(["openai-responses", "typesafe"]),
     rate: RoutingPublishedRateSchema,
-    maxInputTokens: z48.number().int().positive().max(262144),
-    maxOutputTokens: z48.number().int().nonnegative().max(16e3),
+    maxInputTokens: z49.number().int().positive().max(262144),
+    maxOutputTokens: z49.number().int().nonnegative().max(16e3),
     /** Qualified upper bound for one 2048px review derivative, required for vision calls. */
-    maxImageTokens: z48.number().int().positive().max(262144).optional(),
-    qualificationEvidence: z48.string().trim().min(1).max(256)
+    maxImageTokens: z49.number().int().positive().max(262144).optional(),
+    qualificationEvidence: z49.string().trim().min(1).max(256)
   }).strict()).max(8).optional(),
-  corrections: z48.enum(["manual", "refund_downward"]),
-  approvalEvidence: z48.string().trim().min(1).max(256),
+  corrections: z49.enum(["manual", "refund_downward"]),
+  approvalEvidence: z49.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: z48.object({
-    memory: z48.enum(SANDBOX_MEMORY_TIERS).optional(),
-    granularity: z48.enum(SANDBOX_BILLING_GRANULARITIES).optional(),
+  sandbox: z49.object({
+    memory: z49.enum(SANDBOX_MEMORY_TIERS).optional(),
+    granularity: z49.enum(SANDBOX_BILLING_GRANULARITIES).optional(),
     /** Assumed provider deletion after activity and keep-alives stop; not configurable there. */
-    idleExpiryMs: z48.number().int().min(6e4).max(864e5).optional(),
+    idleExpiryMs: z49.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: z48.object({
-      small: z48.enum(SANDBOX_MEMORY_TIERS).optional(),
-      medium: z48.enum(SANDBOX_MEMORY_TIERS).optional(),
-      large: z48.enum(SANDBOX_MEMORY_TIERS).optional()
+    sizes: z49.object({
+      small: z49.enum(SANDBOX_MEMORY_TIERS).optional(),
+      medium: z49.enum(SANDBOX_MEMORY_TIERS).optional(),
+      large: z49.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, {
@@ -6682,11 +7104,11 @@ function usdToMicro(value) {
   const [whole, fractional = ""] = usd.parse(value).split(".");
   return BigInt(whole + fractional.padEnd(6, "0"));
 }
-var ManagedTurnEvidenceSchema = z48.object({
+var ManagedTurnEvidenceSchema = z49.object({
   sessionId: id,
   turnId: id,
   subagentId: id.nullable(),
-  status: z48.enum([
+  status: z49.enum([
     "completed",
     "failed",
     "cancelled",
@@ -6696,11 +7118,11 @@ var ManagedTurnEvidenceSchema = z48.object({
   ]),
   usage: AllowanceReportedUsageSchema.nullable()
 }).strict();
-var ManagedWorkEvidenceSchema = z48.object({
+var ManagedWorkEvidenceSchema = z49.object({
   sessionId: id,
   rootTurnId: id,
-  complete: z48.boolean(),
-  turns: z48.array(ManagedTurnEvidenceSchema).min(1).max(2e3)
+  complete: z49.boolean(),
+  turns: z49.array(ManagedTurnEvidenceSchema).min(1).max(2e3)
 }).strict();
 
 // ../../packages/shared/dist/schemas/taskmarket-mcp.schemas.js
@@ -6719,124 +7141,124 @@ var DIRECT_TOOL_GROUPS = [
   "memory"
 ];
 var DIRECT_TURN_RETRY_LIMIT = 1;
-var DirectRuntimeConfigurationSchema = z49.object({
-  platformToolsVersion: z49.literal(1).optional(),
-  swarm: z49.boolean(),
-  userSkills: z49.object({ revision: z49.number().int().nonnegative(), pins: UserSkillPinsSchema }).optional(),
-  integrations: z49.literal(true).optional(),
-  taskmarketToolsVersion: z49.literal(1).optional(),
-  integrationToolsVersion: z49.literal(2).optional(),
+var DirectRuntimeConfigurationSchema = z50.object({
+  platformToolsVersion: z50.literal(1).optional(),
+  swarm: z50.boolean(),
+  userSkills: z50.object({ revision: z50.number().int().nonnegative(), pins: UserSkillPinsSchema }).optional(),
+  integrations: z50.literal(true).optional(),
+  taskmarketToolsVersion: z50.literal(1).optional(),
+  integrationToolsVersion: z50.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: z49.union([z49.literal(1), z49.literal(2)]).optional(),
+  memoryToolsVersion: z50.union([z50.literal(1), z50.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: z49.literal(true).optional(),
-  nativeSubagents: z49.literal(2).optional(),
-  inbox: z49.literal(1).optional(),
+  memoryCoreTemplate: z50.literal(true).optional(),
+  nativeSubagents: z50.literal(2).optional(),
+  inbox: z50.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: z49.enum(SANDBOX_CONTAINER_SIZES).optional(),
+  containerSize: z50.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: z49.literal("none").optional(),
-  profile: z49.object({
-    version: z49.number().int().nonnegative(),
-    responsibility: z49.string().max(500),
+  workspace: z50.literal("none").optional(),
+  profile: z50.object({
+    version: z50.number().int().nonnegative(),
+    responsibility: z50.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: z49.string().max(65536).optional()
+    instructions: z50.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: z49.array(z49.enum(DIRECT_TOOL_GROUPS)).min(1).max(DIRECT_TOOL_GROUPS.length).optional(),
+  deferredTools: z50.array(z50.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: z49.object({
-    serverUrl: z49.string().url().max(2048),
-    vaultId: z49.string().min(1).max(256),
-    tools: z49.array(z49.string().regex(/^[a-z][a-z0-9_]{0,63}$/)).min(1).max(16)
+  mcp: z50.object({
+    serverUrl: z50.string().url().max(2048),
+    vaultId: z50.string().min(1).max(256),
+    tools: z50.array(z50.string().regex(/^[a-z][a-z0-9_]{0,63}$/)).min(1).max(16)
   }).strict().optional()
 });
-var DirectMcpCredentialSchema = z49.object({
-  vaultId: z49.string().min(1).max(256),
+var DirectMcpCredentialSchema = z50.object({
+  vaultId: z50.string().min(1).max(256),
   /** The server URL the credential is bound to; the provider cannot change it in place. */
-  serverUrl: z49.string().url().max(2048),
-  credentialId: z49.string().min(1).max(256),
-  tokenId: z49.string().uuid(),
-  tokenExpiresAt: z49.string().datetime(),
+  serverUrl: z50.string().url().max(2048),
+  credentialId: z50.string().min(1).max(256),
+  tokenId: z50.string().uuid(),
+  tokenExpiresAt: z50.string().datetime(),
   /** What the current token may read: never more than the deployment allows the agent now. */
-  scopes: z49.array(z49.enum(TASKMARKET_MCP_TOKEN_SCOPES)).min(1).max(TASKMARKET_MCP_TOKEN_SCOPES.length),
+  scopes: z50.array(z50.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: z49.array(z49.string().uuid()).min(1).max(16).optional(),
+  retiring: z50.array(z50.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: z49.literal(true).optional()
+  suspended: z50.literal(true).optional()
 }).strict();
-var DirectFunctionCallSchema = z49.object({
-  name: z49.string().min(1).max(100),
-  argumentHash: z49.string().regex(/^[a-f0-9]{64}$/),
-  state: z49.enum(["prepared", "executing", "answered"]),
-  reply: z49.object({
-    success: z49.boolean(),
-    output: z49.string().max(131072).optional(),
-    error: z49.string().max(512).optional()
+var DirectFunctionCallSchema = z50.object({
+  name: z50.string().min(1).max(100),
+  argumentHash: z50.string().regex(/^[a-f0-9]{64}$/),
+  state: z50.enum(["prepared", "executing", "answered"]),
+  reply: z50.object({
+    success: z50.boolean(),
+    output: z50.string().max(131072).optional(),
+    error: z50.string().max(512).optional()
   }).optional()
 });
-var DirectRouteSelectionSchema = z49.object({
-  operationId: z49.string().uuid(),
+var DirectRouteSelectionSchema = z50.object({
+  operationId: z50.string().uuid(),
   mechanism: RoutingMechanismSchema,
   selected: ExecutorSettingsSchema,
-  policyVersion: z49.string().min(1).max(200),
-  rateVersion: z49.string().min(1).max(200)
+  policyVersion: z50.string().min(1).max(200),
+  rateVersion: z50.string().min(1).max(200)
 }).strict();
-var DirectRouteConfirmationSchema = z49.object({
+var DirectRouteConfirmationSchema = z50.object({
   /** The routing operation whose selection this confirms, never another operation's. */
-  operationId: z49.string().uuid(),
+  operationId: z50.string().uuid(),
   /** The job whose dispatch fence produced it. */
-  jobId: z49.string(),
+  jobId: z50.string(),
   settings: ExecutorSettingsSchema,
-  observedAt: z49.string().datetime(),
+  observedAt: z50.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: z49.boolean()
+  verifiedAfterDispatch: z50.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: z49.string(),
-  settingsPhase: z49.enum(ROUTING_SETTINGS_TRANSITION_STATES),
-  requestedAt: z49.string().datetime().nullable(),
-  confirmedAt: z49.string().datetime().nullable(),
+  jobId: z50.string(),
+  settingsPhase: z50.enum(ROUTING_SETTINGS_TRANSITION_STATES),
+  requestedAt: z50.string().datetime().nullable(),
+  confirmedAt: z50.string().datetime().nullable(),
   /** Readback is evidence about the session, never a source of attribution. */
-  readbackModelId: z49.string().min(1).max(256).nullable(),
-  lostResponse: z49.boolean(),
+  readbackModelId: z50.string().min(1).max(256).nullable(),
+  lostResponse: z50.boolean(),
   /**
    * SPEC-0018 R3.4. How far this job's input binding got.
    *
@@ -6844,27 +7266,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: z49.enum(DIRECT_ROUTE_DISPATCH_BINDINGS).default("not_dispatched")
+  dispatchBinding: z50.enum(DIRECT_ROUTE_DISPATCH_BINDINGS).default("not_dispatched")
 }).strict();
-var DirectUsageOperationSchema = z49.object({
-  operationId: z49.string().min(1).max(200),
-  purpose: z49.enum(["work", "maintenance", "retry"]),
-  tokenCeiling: z49.number().int().positive(),
-  turnId: z49.string().min(1).max(256).nullable(),
-  phase: z49.enum(["reserving", "reserved", "dispatched", "settled", "unresolved"]),
-  billingBaseline: z49.array(z49.string().min(1).max(256)).max(2e3).optional()
+var DirectUsageOperationSchema = z50.object({
+  operationId: z50.string().min(1).max(200),
+  purpose: z50.enum(["work", "maintenance", "retry"]),
+  tokenCeiling: z50.number().int().positive(),
+  turnId: z50.string().min(1).max(256).nullable(),
+  phase: z50.enum(["reserving", "reserved", "dispatched", "settled", "unresolved"]),
+  billingBaseline: z50.array(z50.string().min(1).max(256)).max(2e3).optional()
 }).strict();
-var DirectProjectSnapshotSchema = z49.object({
-  id: z49.string().regex(/^[a-f0-9]{64}$/),
-  key: z49.string().max(512),
-  sha256: z49.string().regex(/^[a-f0-9]{64}$/),
-  sessionId: z49.string().min(1).max(256),
-  turnId: z49.string().min(1).max(256),
-  setupHash: z49.string().regex(/^[a-f0-9]{64}$/)
+var DirectProjectSnapshotSchema = z50.object({
+  id: z50.string().regex(/^[a-f0-9]{64}$/),
+  key: z50.string().max(512),
+  sha256: z50.string().regex(/^[a-f0-9]{64}$/),
+  sessionId: z50.string().min(1).max(256),
+  turnId: z50.string().min(1).max(256),
+  setupHash: z50.string().regex(/^[a-f0-9]{64}$/)
 }).strict();
-var DirectPendingSchema = z49.object({
-  jobId: z49.string(),
-  baseline: z49.array(z49.string()),
+var DirectPendingSchema = z50.object({
+  jobId: z50.string(),
+  baseline: z50.array(z50.string()),
   /**
    * The run's dispatch-group identity, carried on every usage event this job writes.
    *
@@ -6872,7 +7294,7 @@ var DirectPendingSchema = z49.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: z49.string(),
+  reservationId: z50.string(),
   /**
    * SPEC-0015 M4.2. The metered model operations this job has taken, in dispatch order.
    *
@@ -6884,27 +7306,27 @@ var DirectPendingSchema = z49.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: z49.array(DirectUsageOperationSchema).max(4).optional(),
-  runId: z49.string().uuid().optional(),
-  phase: z49.enum(["creating", "preparing", "dispatching", "following"]).optional(),
-  deadline: z49.number().optional(),
+  operations: z50.array(DirectUsageOperationSchema).max(4).optional(),
+  runId: z50.string().uuid().optional(),
+  phase: z50.enum(["creating", "preparing", "dispatching", "following"]).optional(),
+  deadline: z50.number().optional(),
   // Exact ordinary input, saved before dispatch. Legacy checkpoints cannot be replayed.
-  dispatch: z49.object({
-    text: z49.string(),
-    key: z49.string(),
-    attempts: z49.number().int().min(0).max(2),
-    acknowledged: z49.boolean(),
-    cancelled: z49.boolean()
+  dispatch: z50.object({
+    text: z50.string(),
+    key: z50.string(),
+    attempts: z50.number().int().min(0).max(2),
+    acknowledged: z50.boolean(),
+    cancelled: z50.boolean()
   }).optional(),
-  turnId: z49.string().optional(),
-  creationInput: z49.boolean().optional(),
+  turnId: z50.string().optional(),
+  creationInput: z50.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: z49.object({
-    docsHash: z49.string().regex(/^[a-f0-9]{64}$/),
-    inventoryHash: z49.string().regex(/^[a-f0-9]{64}$/)
+  skillBundle: z50.object({
+    docsHash: z50.string().regex(/^[a-f0-9]{64}$/),
+    inventoryHash: z50.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.
@@ -6913,18 +7335,18 @@ var DirectPendingSchema = z49.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: z49.number().int().nonnegative().optional(),
-  checkpointRepair: z49.object({
-    workTurnId: z49.string().min(1),
-    finalText: z49.string().min(1).max(65536),
-    nativeTurnIds: z49.array(z49.string()).max(2e3).optional()
+  sessionItems: z50.number().int().nonnegative().optional(),
+  checkpointRepair: z50.object({
+    workTurnId: z50.string().min(1),
+    finalText: z50.string().min(1).max(65536),
+    nativeTurnIds: z50.array(z50.string()).max(2e3).optional()
   }).optional(),
-  replies: z49.record(z49.object({
-    success: z49.boolean(),
-    output: z49.string().optional(),
-    error: z49.string().optional()
+  replies: z50.record(z50.object({
+    success: z50.boolean(),
+    output: z50.string().optional(),
+    error: z50.string().optional()
   })).optional(),
-  calls: z49.record(DirectFunctionCallSchema).optional(),
+  calls: z50.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.
@@ -6935,36 +7357,36 @@ var DirectPendingSchema = z49.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: z49.object({
-    attempt: z49.number().int().min(1).max(DIRECT_TURN_RETRY_LIMIT),
-    code: z49.string().min(1).max(100),
-    turnId: z49.string().min(1).max(256)
+  retry: z50.object({
+    attempt: z50.number().int().min(1).max(DIRECT_TURN_RETRY_LIMIT),
+    code: z50.string().min(1).max(100),
+    turnId: z50.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: z49.enum(["run_bound", "deadline"]).optional(),
+  cancelledBy: z50.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: z49.object({
-    turnId: z49.string().min(1).max(256),
-    itemId: z49.string().min(1).max(256),
-    model: z49.string().min(1).max(256),
-    reasoningEffort: z49.string().min(1).max(64).nullable(),
-    sessionModel: z49.string().min(1).max(256)
+  helperModel: z50.object({
+    turnId: z50.string().min(1).max(256),
+    itemId: z50.string().min(1).max(256),
+    model: z50.string().min(1).max(256),
+    reasoningEffort: z50.string().min(1).max(64).nullable(),
+    sessionModel: z50.string().min(1).max(256)
   }).strict().optional(),
   /**
    * ADR-0196 (Accepted). 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: z49.literal("flex").optional(),
+  serviceTier: z50.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
@@ -6973,18 +7395,18 @@ var DirectPendingSchema = z49.object({
    * `deadline` keeps its meaning (the latest the dispatch was made), which the unbought proof's
    * bracket depends on.
    */
-  turnDeadline: z49.number().int().positive().optional(),
+  turnDeadline: z50.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: z49.object({
-    count: z49.number().int().min(1),
-    at: z49.string().datetime(),
-    announced: z49.array(z49.string().min(1).max(512)).max(DIRECT_PARKED_ANNOUNCED_MAX).optional(),
-    usageHash: z49.string().regex(/^[a-f0-9]{64}$/).optional()
+  parked: z50.object({
+    count: z50.number().int().min(1),
+    at: z50.string().datetime(),
+    announced: z50.array(z50.string().min(1).max(512)).max(DIRECT_PARKED_ANNOUNCED_MAX).optional(),
+    usageHash: z50.string().regex(/^[a-f0-9]{64}$/).optional()
   }).strict().optional()
 }).superRefine((pending, ctx) => {
   if (pending.route && pending.route.jobId !== pending.jobId)
@@ -6995,48 +7417,48 @@ var DirectPendingSchema = z49.object({
     });
 });
 var DIRECT_DETACHED_MAX = 8;
-var DirectDetachedSessionSchema = z49.object({
+var DirectDetachedSessionSchema = z50.object({
   /** The provider session, or null when the job was still creating it. */
-  sessionId: z49.string().min(1).max(256).nullable(),
+  sessionId: z50.string().min(1).max(256).nullable(),
   /** The reset request this entry was detached under. */
-  resetVersion: z49.number().int().positive(),
-  detachedAt: z49.string().datetime(),
+  resetVersion: z50.number().int().positive(),
+  detachedAt: z50.string().datetime(),
   /** The session's model and tier when it was detached, for the settlement record. */
-  model: z49.string(),
-  tier: z49.object({
+  model: z50.string(),
+  tier: z50.object({
     tier: AgentTierSchema,
-    mappingVersion: z49.string().min(1).max(200),
-    reasoningEffort: z49.enum(EXECUTOR_REASONING_EFFORTS).optional()
+    mappingVersion: z50.string().min(1).max(200),
+    reasoningEffort: z50.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: z49.boolean().optional(),
+  cancelRequested: z50.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: z49.array(z49.string().min(1).max(256)).max(100).optional(),
+  excludedSessions: z50.array(z50.string().min(1).max(256)).max(100).optional(),
   /** Why the last settlement attempt left the entry in place, for the operator. */
-  unresolved: z49.object({ reason: z49.string().min(1).max(100), at: z49.string().datetime() }).optional(),
+  unresolved: z50.object({ reason: z50.string().min(1).max(100), at: z50.string().datetime() }).optional(),
   /** Settlement attempts that left the entry in place, which sets the backoff below. */
-  attempts: z49.number().int().nonnegative().optional(),
+  attempts: z50.number().int().nonnegative().optional(),
   /** No settlement attempt is made before this: a stuck entry is not re-read every tick. */
-  retryAt: z49.string().datetime().optional(),
+  retryAt: z50.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: z49.string().datetime().optional()
+  settledAt: z50.string().datetime().optional()
 }).strict();
-var DirectAgentCheckpointSchema = z49.object({
-  kind: z49.literal("openai-preview-v1"),
-  sessionId: z49.string().nullable(),
-  model: z49.string(),
+var DirectAgentCheckpointSchema = z50.object({
+  kind: z50.literal("openai-preview-v1"),
+  sessionId: z50.string().nullable(),
+  model: z50.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
@@ -7045,25 +7467,25 @@ var DirectAgentCheckpointSchema = z49.object({
    * updates the live one. Absent on checkpoints written before tiers, which ran as light on the
    * managed default settings.
    */
-  tier: z49.object({
+  tier: z50.object({
     tier: AgentTierSchema,
-    mappingVersion: z49.string().min(1).max(200),
-    reasoningEffort: z49.enum(EXECUTOR_REASONING_EFFORTS).optional()
+    mappingVersion: z50.string().min(1).max(200),
+    reasoningEffort: z50.enum(EXECUTOR_REASONING_EFFORTS).optional()
   }).optional(),
   /**
    * ADR-0196 (Accepted). The live session runs on the flex service tier. Session-scoped like
    * `model`; absent is the managed default tier.
    */
-  serviceTier: z49.literal("flex").optional(),
+  serviceTier: z50.literal("flex").optional(),
   /**
    * ADR-0196 (Accepted). 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: z49.object({ until: z49.string().datetime(), jobId: z49.string().min(1) }).strict().optional(),
-  networkAccess: z49.enum(["disabled", "enabled"]).optional(),
-  toolProfile: z49.enum(["base", "purchases-v1"]).optional(),
+  flexUnavailable: z50.object({ until: z50.string().datetime(), jobId: z50.string().min(1) }).strict().optional(),
+  networkAccess: z50.enum(["disabled", "enabled"]).optional(),
+  toolProfile: z50.enum(["base", "purchases-v1"]).optional(),
   configuration: DirectRuntimeConfigurationSchema.optional(),
-  helperUsageHashes: z49.record(z49.string().regex(/^[a-f0-9]{64}$/)).optional(),
+  helperUsageHashes: z50.record(z50.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
@@ -7093,10 +7515,10 @@ var DirectAgentCheckpointSchema = z49.object({
    * because a confirmation is only worth anything for the dispatch it immediately preceded.
    */
   routeConfirmation: DirectRouteConfirmationSchema.optional(),
-  purchaseOperations: z49.array(z49.object({
-    operationId: z49.string().uuid(),
-    jobId: z49.string(),
-    financialPhase: z49.enum([
+  purchaseOperations: z50.array(z50.object({
+    operationId: z50.string().uuid(),
+    jobId: z50.string(),
+    financialPhase: z50.enum([
       "not_started",
       "pending",
       "unknown",
@@ -7104,21 +7526,21 @@ var DirectAgentCheckpointSchema = z49.object({
       "released",
       "failed"
     ]),
-    resultStatus: z49.enum(["pending", "received", "failed"])
+    resultStatus: z50.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: z49.object({ sessionId: z49.string().min(1).max(256), version: z49.string().min(1).max(64) }).optional(),
+  memoryInjectedVersion: z50.object({ sessionId: z50.string().min(1).max(256), version: z50.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: z49.object({ sessionId: z49.string().min(1).max(256), version: z49.number().int().nonnegative() }).optional(),
+  memoryForgetVersion: z50.object({ sessionId: z50.string().min(1).max(256), version: z50.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.
   /**
@@ -7127,10 +7549,10 @@ var DirectAgentCheckpointSchema = z49.object({
    * 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: z49.object({
-    sessionId: z49.string().min(1).max(256),
-    items: z49.number().int().nonnegative(),
-    contextExceeded: z49.boolean().optional(),
+  sessionUsage: z50.object({
+    sessionId: z50.string().min(1).max(256),
+    items: z50.number().int().nonnegative(),
+    contextExceeded: z50.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
@@ -7138,7 +7560,7 @@ var DirectAgentCheckpointSchema = z49.object({
      * stays open in it. The next job starts a new session with this as the rollover reason, the
      * way `contextExceeded` does.
      */
-    retire: z49.enum(["policy_blocked", "session_budget", "helper_model"]).optional()
+    retire: z50.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
@@ -7147,16 +7569,16 @@ var DirectAgentCheckpointSchema = z49.object({
    * 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: z49.object({
-    sessionId: z49.string().min(1).max(256),
-    parkedAt: z49.string().datetime(),
-    items: z49.number().int().nonnegative()
+  parkedSession: z50.object({
+    sessionId: z50.string().min(1).max(256),
+    parkedAt: z50.string().datetime(),
+    items: z50.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: z49.literal(true).optional(),
+  workspaceRequested: z50.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.
@@ -7167,16 +7589,16 @@ var DirectAgentCheckpointSchema = z49.object({
    * session starts with none, and a session created before it was recorded keeps the behaviour it
    * had until it is replaced.
    */
-  sandbox: z49.object({
-    sessionId: z49.string().min(1).max(256),
+  sandbox: z50.object({
+    sessionId: z50.string().min(1).max(256),
     /** The container size the session was created with; absent when it requested none. */
-    requestedSize: z49.enum(SANDBOX_CONTAINER_SIZES).optional(),
+    requestedSize: z50.enum(SANDBOX_CONTAINER_SIZES).optional(),
     /** The effective size the provider reports for it, or null while it reports none. */
-    reportedSize: z49.enum(SANDBOX_CONTAINER_SIZES).nullable().optional(),
+    reportedSize: z50.enum(SANDBOX_CONTAINER_SIZES).nullable().optional(),
     /** The session was created with the identity sentinel's setup command. */
-    sentinel: z49.literal(true).optional(),
+    sentinel: z50.literal(true).optional(),
     /** The sentinel's file name in the sandbox the session's work is known to be on. */
-    identity: z49.string().uuid().optional()
+    identity: z50.string().uuid().optional()
   }).optional(),
   /**
    * The platform skill files the current session was created with (ADR-0203): what they
@@ -7185,114 +7607,114 @@ var DirectAgentCheckpointSchema = z49.object({
    * 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: z49.object({
-    sessionId: z49.string().min(1).max(256),
-    docsHash: z49.string().regex(/^[a-f0-9]{64}$/),
-    inventoryHash: z49.string().regex(/^[a-f0-9]{64}$/)
+  skillBundle: z50.object({
+    sessionId: z50.string().min(1).max(256),
+    docsHash: z50.string().regex(/^[a-f0-9]{64}$/),
+    inventoryHash: z50.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: z49.object({ version: z49.number().int().nonnegative(), at: z49.string().datetime() }).optional(),
+  sessionReset: z50.object({ version: z50.number().int().nonnegative(), at: z50.string().datetime() }).optional(),
   /** Sessions a reset detached that are not settled yet (see `DirectDetachedSessionSchema`). */
-  detached: z49.array(DirectDetachedSessionSchema).max(DIRECT_DETACHED_MAX).optional(),
-  turns: z49.number().int().nonnegative(),
-  expiresAt: z49.number(),
-  persistent: z49.boolean().optional(),
-  project: z49.object({
-    version: z49.literal(1),
-    setupHash: z49.string().regex(/^[a-f0-9]{64}$/),
+  detached: z50.array(DirectDetachedSessionSchema).max(DIRECT_DETACHED_MAX).optional(),
+  turns: z50.number().int().nonnegative(),
+  expiresAt: z50.number(),
+  persistent: z50.boolean().optional(),
+  project: z50.object({
+    version: z50.literal(1),
+    setupHash: z50.string().regex(/^[a-f0-9]{64}$/),
     snapshot: DirectProjectSnapshotSchema.nullable(),
-    restoring: z49.boolean().default(false),
-    restoreSetupHash: z49.string().regex(/^[a-f0-9]{64}$/).optional(),
+    restoring: z50.boolean().default(false),
+    restoreSetupHash: z50.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: z49.array(z49.string().min(1).max(256)).max(100).default([]),
+    retiredSessions: z50.array(z50.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: z49.array(z49.string().min(1).max(256)).max(DIRECT_SESSIONS_TO_DELETE_MAX).optional()
+    sessionsToDelete: z50.array(z50.string().min(1).max(256)).max(DIRECT_SESSIONS_TO_DELETE_MAX).optional()
   }).optional(),
   pending: DirectPendingSchema.nullable(),
-  result: z49.object({
-    jobId: z49.string(),
-    runId: z49.string().uuid(),
-    text: z49.string().max(65536),
-    errorCode: z49.string().optional()
+  result: z50.object({
+    jobId: z50.string(),
+    runId: z50.string().uuid(),
+    text: z50.string().max(65536),
+    errorCode: z50.string().optional()
   }).optional()
 });
 
 // ../../packages/shared/dist/schemas/swarm-wallet.schemas.js
-import { z as z50 } from "zod";
-var SwarmWalletSetupSchema = z50.object({ requestKey: z50.string().uuid() }).strict();
+import { z as z51 } from "zod";
+var SwarmWalletSetupSchema = z51.object({ requestKey: z51.string().uuid() }).strict();
 var SwarmWalletBindSchema = SwarmWalletSetupSchema.extend({
-  walletId: z50.string().regex(/^[A-Za-z0-9_-]{1,128}$/),
-  address: z50.string().regex(/^0x[0-9a-fA-F]{40}$/),
-  walletIndex: z50.number().int().min(1).max(1e6)
+  walletId: z51.string().regex(/^[A-Za-z0-9_-]{1,128}$/),
+  address: z51.string().regex(/^0x[0-9a-fA-F]{40}$/),
+  walletIndex: z51.number().int().min(1).max(1e6)
 }).strict();
-var SwarmWalletStatusSchema = z50.object({
-  status: z50.enum([
+var SwarmWalletStatusSchema = z51.object({
+  status: z51.enum([
     "not_started",
     "pending_binding",
     "binding_unknown",
     "binding_rejected",
     "ready"
   ]),
-  requestKey: z50.string().uuid().nullable(),
-  verifiedAt: z50.string().datetime().nullable(),
-  wallet: z50.object({
-    walletId: z50.string(),
-    address: z50.string().regex(/^0x[0-9a-f]{40}$/),
-    walletIndex: z50.number().int().min(1),
+  requestKey: z51.string().uuid().nullable(),
+  verifiedAt: z51.string().datetime().nullable(),
+  wallet: z51.object({
+    walletId: z51.string(),
+    address: z51.string().regex(/^0x[0-9a-f]{40}$/),
+    walletIndex: z51.number().int().min(1),
     chainId: SwarmChainIdSchema
   }).nullable(),
-  spendingEnabled: z50.boolean(),
-  creationEnabled: z50.literal(false)
+  spendingEnabled: z51.boolean(),
+  creationEnabled: z51.literal(false)
 });
-var SwarmWalletCandidateSchema = z50.object({
-  walletId: z50.string().regex(/^[A-Za-z0-9_-]{1,128}$/),
-  address: z50.string().regex(/^0x[0-9a-fA-F]{40}$/),
-  walletIndex: z50.number().int().min(0).max(1e6)
+var SwarmWalletCandidateSchema = z51.object({
+  walletId: z51.string().regex(/^[A-Za-z0-9_-]{1,128}$/),
+  address: z51.string().regex(/^0x[0-9a-fA-F]{40}$/),
+  walletIndex: z51.number().int().min(0).max(1e6)
 }).strict();
 var SwarmWalletCreationConfirmSchema = SwarmWalletSetupSchema.extend({
-  attemptId: z50.string().uuid(),
+  attemptId: z51.string().uuid(),
   walletId: SwarmWalletCandidateSchema.shape.walletId,
-  ownerConfirmed: z50.literal(true)
+  ownerConfirmed: z51.literal(true)
 }).strict();
 var SwarmWalletCreationCompleteSchema = SwarmWalletSetupSchema.extend({
-  attemptId: z50.string().uuid(),
-  signature: z50.string().regex(/^0x[0-9a-fA-F]{130}$/)
+  attemptId: z51.string().uuid(),
+  signature: z51.string().regex(/^0x[0-9a-fA-F]{130}$/)
 }).strict();
-var SwarmWalletInventorySchema = z50.object({
+var SwarmWalletInventorySchema = z51.object({
   wallet: SwarmWalletStatusSchema,
-  setup: z50.object({
-    requestKey: z50.string().uuid(),
-    attemptId: z50.string().uuid(),
-    stage: z50.enum(["prerequisite", "dedicated"]),
-    status: z50.enum(["creation_unknown", "candidate_selected", "completed"]),
+  setup: z51.object({
+    requestKey: z51.string().uuid(),
+    attemptId: z51.string().uuid(),
+    stage: z51.enum(["prerequisite", "dedicated"]),
+    status: z51.enum(["creation_unknown", "candidate_selected", "completed"]),
     candidate: SwarmWalletCandidateSchema.nullable(),
-    challenge: z50.string().nullable()
+    challenge: z51.string().nullable()
   }).nullable(),
-  candidates: z50.array(SwarmWalletCandidateSchema)
+  candidates: z51.array(SwarmWalletCandidateSchema)
 });
 var SwarmWalletCreationPreparedSchema = SwarmWalletInventorySchema.extend({
-  creationGrant: z50.object({ attemptId: z50.string().uuid(), operation: z50.enum(["first", "additional"]) }).nullable()
+  creationGrant: z51.object({ attemptId: z51.string().uuid(), operation: z51.enum(["first", "additional"]) }).nullable()
 });
 var SwarmWalletSelectExistingSchema = SwarmWalletSetupSchema.extend({
   walletId: SwarmWalletCandidateSchema.shape.walletId,
-  ownerConfirmed: z50.literal(true)
+  ownerConfirmed: z51.literal(true)
 }).strict();
 
 // ../../packages/shared/dist/schemas/swarm-consent.schemas.js
-import { z as z52 } from "zod";
+import { z as z53 } from "zod";
 
 // ../../packages/shared/dist/schemas/hosted-market.schemas.js
-import { z as z51 } from "zod";
+import { z as z52 } from "zod";
 var HOSTED_MARKET_READ_ACTIONS = [
   "capabilities",
   "list",
@@ -7347,12 +7769,12 @@ var HOSTED_MARKET_WRITE_ACTIONS = [
   "uninvite",
   "identity-register"
 ];
-var HostedMarketActionSchema = z51.enum([
+var HostedMarketActionSchema = z52.enum([
   ...HOSTED_MARKET_READ_ACTIONS,
   ...HOSTED_MARKET_WRITE_ACTIONS
 ]);
-var HostedMarketActionsSchema = z51.array(HostedMarketActionSchema).max(64).refine((actions) => new Set(actions).size === actions.length, "Duplicate Taskmarket actions");
-var input = z51.record(z51.unknown()).default({}).refine((value) => {
+var HostedMarketActionsSchema = z52.array(HostedMarketActionSchema).max(64).refine((actions) => new Set(actions).size === actions.length, "Duplicate Taskmarket actions");
+var input = z52.record(z52.unknown()).default({}).refine((value) => {
   try {
     return new TextEncoder().encode(JSON.stringify(value)).byteLength <= 65536;
   } catch {
@@ -7360,61 +7782,61 @@ var input = z51.record(z51.unknown()).default({}).refine((value) => {
   }
 }, "Taskmarket input is too large");
 var HostedMarketToolInputSchemas = {
-  taskmarket_read: z51.object({ action: z51.enum(HOSTED_MARKET_READ_ACTIONS), input }).strict(),
-  taskmarket_execute: z51.object({ action: z51.enum(HOSTED_MARKET_WRITE_ACTIONS), requestKey: z51.string().uuid(), input }).strict(),
-  taskmarket_status: z51.object({ requestKey: z51.string().uuid() }).strict()
+  taskmarket_read: z52.object({ action: z52.enum(HOSTED_MARKET_READ_ACTIONS), input }).strict(),
+  taskmarket_execute: z52.object({ action: z52.enum(HOSTED_MARKET_WRITE_ACTIONS), requestKey: z52.string().uuid(), input }).strict(),
+  taskmarket_status: z52.object({ requestKey: z52.string().uuid() }).strict()
 };
-var HostedMarketReadySchema = z51.object({
-  enabled: z51.boolean(),
-  walletAddress: z51.string().nullable(),
-  chainId: z51.number().int().positive(),
-  apiOrigin: z51.string().url(),
+var HostedMarketReadySchema = z52.object({
+  enabled: z52.boolean(),
+  walletAddress: z52.string().nullable(),
+  chainId: z52.number().int().positive(),
+  apiOrigin: z52.string().url(),
   actions: HostedMarketActionsSchema,
   /** False once the owner's consent window closed: free actions and reads still work. */
-  signingWindowOpen: z51.boolean().optional(),
+  signingWindowOpen: z52.boolean().optional(),
   /**
    * ADR-0277. Present when standing free market access, or an exact consent's approved market
    * actions, predate the market namespace rules: the listed actions are refused until the owner
    * renews, as the note says.
    */
-  marketAccess: z51.object({
-    needsRenewal: z51.literal(true),
+  marketAccess: z52.object({
+    needsRenewal: z52.literal(true),
     renewalRequiredFor: HostedMarketActionsSchema,
-    note: z51.string()
+    note: z52.string()
   }).optional(),
-  legalAccepted: z51.boolean(),
-  legalRequired: z51.boolean().optional(),
-  blockers: z51.array(z51.string()),
+  legalAccepted: z52.boolean(),
+  legalRequired: z52.boolean().optional(),
+  blockers: z52.array(z52.string()),
   budget: SwarmBudgetViewSchema.nullable()
 });
-var HostedMarketApiOriginSchema = z51.string().url().refine((value) => {
+var HostedMarketApiOriginSchema = z52.string().url().refine((value) => {
   const url = new URL(value);
   return url.protocol === "https:" && !url.username && !url.password && !url.search && !url.hash && url.pathname === "/";
 }, "Taskmarket requires an explicit HTTPS API origin");
-var HostedMarketEnvironmentSchema = z51.object({
-  LAUNCHER_AGENT_UI_ENABLED: z51.enum(["true", "false"]).default("false").transform((value) => value === "true"),
-  LAUNCHER_TASKMARKET_ENABLED: z51.enum(["true", "false"]).default("false").transform((value) => value === "true"),
-  TASKMARKET_API_URL: z51.string().url().optional(),
+var HostedMarketEnvironmentSchema = z52.object({
+  LAUNCHER_AGENT_UI_ENABLED: z52.enum(["true", "false"]).default("false").transform((value) => value === "true"),
+  LAUNCHER_TASKMARKET_ENABLED: z52.enum(["true", "false"]).default("false").transform((value) => value === "true"),
+  TASKMARKET_API_URL: z52.string().url().optional(),
   /**
    * ADR-0189. Market events relevant to a swarm wallet start `market` jobs for the
    * responsible agent. Off by default; effective only with LAUNCHER_TASKMARKET_ENABLED.
    */
-  AGENT_MARKET_WAKEUPS_ENABLED: z51.enum(["true", "false"]).default("false").transform((value) => value === "true"),
+  AGENT_MARKET_WAKEUPS_ENABLED: z52.enum(["true", "false"]).default("false").transform((value) => value === "true"),
   /** ADR-0284. Enable only after all consumer replicas understand pending wakeups. */
-  AGENT_MARKET_WAKEUP_RETRIES_ENABLED: z51.enum(["true", "false"]).default("false").transform((value) => value === "true")
+  AGENT_MARKET_WAKEUP_RETRIES_ENABLED: z52.enum(["true", "false"]).default("false").transform((value) => value === "true")
 });
-var HostedMarketDownloadSchema = z51.object({
-  kind: z51.literal("hosted_market_download"),
-  artifactId: z51.string().uuid(),
-  fileName: z51.string().min(1).max(255),
-  sha256: z51.string().regex(/^[0-9a-f]{64}$/),
-  bytes: z51.number().int().positive().max(5 * 1024 * 1024)
+var HostedMarketDownloadSchema = z52.object({
+  kind: z52.literal("hosted_market_download"),
+  artifactId: z52.string().uuid(),
+  fileName: z52.string().min(1).max(255),
+  sha256: z52.string().regex(/^[0-9a-f]{64}$/),
+  bytes: z52.number().int().positive().max(5 * 1024 * 1024)
 });
 
 // ../../packages/shared/dist/schemas/swarm-consent.schemas.js
 var SWARM_TESTNET_CONSENT_TEXT = "I approve a new testnet authorization period for the displayed wallet, signer, recipient and HTTPS merchant. Signing authority lasts four minutes; issued USDC authorizations expire five minutes after the displayed start. The displayed purchase, rolling 24-hour and period limits apply. Taskmarket enforces aggregate spending limits. Revocation stops new local authorizations, but already signed authorizations may still settle until they expire. Hosted purchases remain disabled until qualification is complete.";
 var SWARM_TESTNET_PILOT_CONSENT_TEXT = SWARM_TESTNET_CONSENT_TEXT.replace("Hosted purchases remain disabled until qualification is complete.", "I authorize my eligible hosted agents to make these bounded testnet purchases while pilot purchases are enabled and this approval is valid.");
-var SwarmConsentTextVersionSchema = z52.enum(SWARM_CONSENT_TEXT_VERSIONS);
+var SwarmConsentTextVersionSchema = z53.enum(SWARM_CONSENT_TEXT_VERSIONS);
 var SWARM_MAINNET_CONSENT_TEXT = "I approve a new Base mainnet authorization period for the displayed wallet, signer, recipient and HTTPS merchant. Payments use real USDC. Signing authority lasts four minutes; issued USDC authorizations expire five minutes after the displayed start. The displayed purchase, rolling 24-hour and period limits apply; they are the limits I set, and Taskmarket applies no other spending ceiling. Taskmarket enforces aggregate spending limits. Revocation stops new local authorizations, but already signed authorizations may still settle until they expire. Hosted purchases remain disabled until qualification is complete.";
 var SWARM_MAINNET_PILOT_CONSENT_TEXT = SWARM_MAINNET_CONSENT_TEXT.replace("Hosted purchases remain disabled until qualification is complete.", "I authorize my eligible hosted agents to make these purchases with real USDC, up to the limits I set, while pilot purchases are enabled and this approval is valid.");
 var SWARM_MAINNET_YOLO_CONSENT_TEXT = "I turn on YOLO mode for the displayed Base mainnet shared wallet and signer until the displayed period end. My hosted agents may pay any x402 merchant and any recipient, with no further prompt, using real USDC. Each payment is at most the displayed per-purchase limit, and Privy enforces only that limit, the chain, the USDC contract, this wallet and the period. Taskmarket, not Privy, enforces the displayed rolling 24-hour and period limits and each agent budget. A prompt-injected agent can pay an attacker up to those limits; a compromise of the signer or Taskmarket can pay up to the per-purchase limit repeatedly until I revoke or the period ends, so the wallet balance is what is at risk. Taskmarket market actions are not included. Revocation stops new payments, but already signed authorizations may still settle for up to five minutes. Hosted purchases remain disabled until qualification is complete.";
@@ -7430,48 +7852,48 @@ var SWARM_TESTNET_FREE_MARKET_CONSENT_TEXT_V1 = SWARM_MAINNET_FREE_MARKET_CONSEN
 var SWARM_MAINNET_FREE_MARKET_CONSENT_TEXT = `I let my hosted agents work the Taskmarket market with the displayed Base mainnet shared wallet and signer until I revoke or replace this approval: authenticated reads, and signing Taskmarket market action messages (those beginning taskmarket:market:), including claim, submit, forfeit, release, request revisions, reject a delivery and settle, and any market action Taskmarket adds later under the same terms. These signatures move USDC only as a task's own terms already committed, such as returning or forfeiting a stake or paying a reject fee from escrow. This approves no new payment of any kind: the wallet's policy allows only those message signatures, never a USDC authorization or a transaction. Submissions beyond a task's free allowance, task creation and any other paid action still need my separate approval. Revoking removes the signer from the wallet.`;
 var SWARM_TESTNET_FREE_MARKET_CONSENT_TEXT = SWARM_MAINNET_FREE_MARKET_CONSENT_TEXT.replace("Base mainnet", "Base Sepolia testnet");
 var SWARM_CONSENT_CATALOG_TIERS = ["curated", "verified"];
-var merchantCatalogTiers = z52.array(z52.enum(SWARM_CONSENT_CATALOG_TIERS)).min(1).max(2).optional();
-var address = z52.string().regex(/^0x[0-9a-fA-F]{40}$/);
+var merchantCatalogTiers = z53.array(z53.enum(SWARM_CONSENT_CATALOG_TIERS)).min(1).max(2).optional();
+var address = z53.string().regex(/^0x[0-9a-fA-F]{40}$/);
 var purchaseAmount = SwarmUsdcAtomicAmountSchema.refine((value) => value !== "0");
 var aggregateAmount = SwarmUsdcAtomicAmountSchema.refine((value) => value !== "0");
-var merchantOrigin = z52.string().url().max(2048).refine((value) => {
+var merchantOrigin = z53.string().url().max(2048).refine((value) => {
   const url = new URL(value);
   return url.protocol === "https:" && url.origin === value;
 }, "An HTTPS origin without a path or credentials is required");
-var SwarmConsentPrepareSchema = z52.object({
-  requestKey: z52.string().uuid(),
-  previousConsentId: z52.string().uuid().nullable(),
+var SwarmConsentPrepareSchema = z53.object({
+  requestKey: z53.string().uuid(),
+  previousConsentId: z53.string().uuid().nullable(),
   payee: address,
   merchantOrigin,
   // When present, consent approves merchantOrigin plus every active catalog origin in these tiers.
   merchantCatalogTiers,
   marketActions: HostedMarketActionsSchema.optional(),
   /** ADR-0185: keep (or grant) standing free market actions on this consent's policy. */
-  freeMarket: z52.literal(true).optional(),
+  freeMarket: z53.literal(true).optional(),
   maxPurchase: purchaseAmount,
   rollingDay: aggregateAmount,
   period: aggregateAmount
 }).strict();
-var SwarmFreeMarketPrepareSchema = z52.object({
-  requestKey: z52.string().uuid(),
-  previousConsentId: z52.string().uuid().nullable()
+var SwarmFreeMarketPrepareSchema = z53.object({
+  requestKey: z53.string().uuid(),
+  previousConsentId: z53.string().uuid().nullable()
 }).strict();
 var SWARM_STANDING_PERIOD = "until_revoked";
-var SwarmYoloPrepareSchema = z52.object({
-  requestKey: z52.string().uuid(),
-  previousConsentId: z52.string().uuid().nullable(),
-  periodDays: z52.union([
-    z52.literal(1),
-    z52.literal(7),
-    z52.literal(30),
-    z52.literal(SWARM_STANDING_PERIOD)
+var SwarmYoloPrepareSchema = z53.object({
+  requestKey: z53.string().uuid(),
+  previousConsentId: z53.string().uuid().nullable(),
+  periodDays: z53.union([
+    z53.literal(1),
+    z53.literal(7),
+    z53.literal(30),
+    z53.literal(SWARM_STANDING_PERIOD)
   ]),
-  freeMarket: z52.literal(true).optional(),
+  freeMarket: z53.literal(true).optional(),
   maxPurchase: purchaseAmount,
   rollingDay: aggregateAmount,
   period: aggregateAmount
 }).strict();
-var SwarmConsentIdSchema = z52.object({ consentId: z52.string().uuid() }).strict();
+var SwarmConsentIdSchema = z53.object({ consentId: z53.string().uuid() }).strict();
 var SwarmLimitsLowerSchema = SwarmConsentIdSchema.extend({
   maxPurchase: purchaseAmount,
   rollingDay: aggregateAmount,
@@ -7480,9 +7902,9 @@ var SwarmLimitsLowerSchema = SwarmConsentIdSchema.extend({
 var SwarmConsentConfirmSchema = SwarmConsentIdSchema.extend({
   consentTextVersion: SwarmConsentTextVersionSchema
 }).strict();
-var SwarmConsentSchema = z52.object({
-  id: z52.string().uuid(),
-  status: z52.enum([
+var SwarmConsentSchema = z53.object({
+  id: z53.string().uuid(),
+  status: z53.enum([
     "prepared",
     "policy_unknown",
     "policy_ready",
@@ -7491,121 +7913,121 @@ var SwarmConsentSchema = z52.object({
     "revoked",
     "expired"
   ]),
-  requestKey: z52.string().uuid(),
-  previousConsentId: z52.string().uuid().nullable(),
-  wallet: z52.object({ walletId: z52.string(), address, chainId: SwarmChainIdSchema }),
-  terms: z52.object({
+  requestKey: z53.string().uuid(),
+  previousConsentId: z53.string().uuid().nullable(),
+  wallet: z53.object({ walletId: z53.string(), address, chainId: SwarmChainIdSchema }),
+  terms: z53.object({
     // Implements: ADR-0183. A YOLO consent has no pinned recipient or origin; it carries its
     // `mode` and `periodEnd` (unix seconds) instead.
     // ADR-0185: `market` is a free-market-only consent with no payment terms at all.
-    mode: z52.enum(["yolo", "market"]).optional(),
-    periodEnd: z52.number().int().positive().optional(),
+    mode: z53.enum(["yolo", "market"]).optional(),
+    periodEnd: z53.number().int().positive().optional(),
     /** ADR-0212: a YOLO consent with no `periodEnd` that stands until revoked. */
-    untilRevoked: z52.literal(true).optional(),
+    untilRevoked: z53.literal(true).optional(),
     payee: address.optional(),
     merchantOrigin: merchantOrigin.optional(),
     merchantCatalogTiers,
     marketActions: HostedMarketActionsSchema.optional(),
-    freeMarket: z52.literal(true).optional(),
+    freeMarket: z53.literal(true).optional(),
     maxPurchase: purchaseAmount.optional(),
     rollingDay: aggregateAmount.optional(),
     period: aggregateAmount.optional()
   }),
-  signerId: z52.string(),
-  policyId: z52.string().nullable(),
-  policyHash: z52.string().nullable(),
+  signerId: z53.string(),
+  policyId: z53.string().nullable(),
+  policyHash: z53.string().nullable(),
   consentTextVersion: SwarmConsentTextVersionSchema,
-  issuedAt: z52.string().datetime(),
-  consentText: z52.string().min(1),
-  issuanceExpiresAt: z52.string().datetime(),
-  authorizationExpiresAt: z52.string().datetime(),
-  providerRevocation: z52.enum(["not_requested", "pending", "confirmed"]),
+  issuedAt: z53.string().datetime(),
+  consentText: z53.string().min(1),
+  issuanceExpiresAt: z53.string().datetime(),
+  authorizationExpiresAt: z53.string().datetime(),
+  providerRevocation: z53.enum(["not_requested", "pending", "confirmed"]),
   /**
    * ADR-0277. A market consent whose wallet policy predates the market namespace rules: standing
    * free market actions, or an exact consent's approved actions, are refused until the owner renews it.
    */
-  needsRenewal: z52.boolean().optional(),
-  spendingEnabled: z52.boolean()
-});
-var SwarmYoloPurchaseSchema = z52.object({
-  operationId: z52.string().uuid(),
-  agentId: z52.string(),
-  agentName: z52.string().nullable(),
-  origin: z52.string(),
-  payTo: z52.string().nullable(),
-  amount: z52.string().nullable(),
-  phase: z52.string(),
-  resultStatus: z52.string().nullable(),
-  transactionHash: z52.string().nullable(),
-  createdAt: z52.string()
-});
-var SwarmSpendInputSchema = z52.object({
-  agentId: z52.string().uuid().optional(),
+  needsRenewal: z53.boolean().optional(),
+  spendingEnabled: z53.boolean()
+});
+var SwarmYoloPurchaseSchema = z53.object({
+  operationId: z53.string().uuid(),
+  agentId: z53.string(),
+  agentName: z53.string().nullable(),
+  origin: z53.string(),
+  payTo: z53.string().nullable(),
+  amount: z53.string().nullable(),
+  phase: z53.string(),
+  resultStatus: z53.string().nullable(),
+  transactionHash: z53.string().nullable(),
+  createdAt: z53.string()
+});
+var SwarmSpendInputSchema = z53.object({
+  agentId: z53.string().uuid().optional(),
   /** How many recent purchases to return, newest first. */
-  limit: z52.number().int().min(1).max(20).optional()
+  limit: z53.number().int().min(1).max(20).optional()
 }).strict();
-var spentAmount = z52.string().regex(/^(0|[1-9][0-9]{0,77})$/);
-var SwarmSpendLimitsSchema = z52.object({
+var spentAmount = z53.string().regex(/^(0|[1-9][0-9]{0,77})$/);
+var SwarmSpendLimitsSchema = z53.object({
   maxPurchase: spentAmount,
   rollingDay: spentAmount,
   period: spentAmount
 });
-var SwarmSpendPurchaseSchema = z52.object({
-  operationId: z52.string().uuid(),
-  agentId: z52.string(),
-  jobId: z52.string(),
-  merchant: z52.string(),
+var SwarmSpendPurchaseSchema = z53.object({
+  operationId: z53.string().uuid(),
+  agentId: z53.string(),
+  jobId: z53.string(),
+  merchant: z53.string(),
   amount: spentAmount,
-  status: z52.enum(["pending", "settled", "released"]),
-  createdAt: z52.string().datetime(),
-  settledAt: z52.string().datetime().nullable()
-});
-var SwarmSpendSummarySchema = z52.object({
-  approval: z52.enum(["active", "inactive", "none"]),
-  periodKind: z52.enum(["calendar_month", "consent"]),
-  periodStartsAt: z52.string().datetime(),
-  swarm: z52.object({
+  status: z53.enum(["pending", "settled", "released"]),
+  createdAt: z53.string().datetime(),
+  settledAt: z53.string().datetime().nullable()
+});
+var SwarmSpendSummarySchema = z53.object({
+  approval: z53.enum(["active", "inactive", "none"]),
+  periodKind: z53.enum(["calendar_month", "consent"]),
+  periodStartsAt: z53.string().datetime(),
+  swarm: z53.object({
     spentDay: spentAmount,
     spentPeriod: spentAmount,
     limits: SwarmSpendLimitsSchema.nullable()
   }),
-  agent: z52.object({
-    agentId: z52.string(),
+  agent: z53.object({
+    agentId: z53.string(),
     spentDay: spentAmount,
     spentPeriod: spentAmount,
-    enabled: z52.boolean(),
-    paused: z52.boolean(),
+    enabled: z53.boolean(),
+    paused: z53.boolean(),
     budget: SwarmSpendLimitsSchema.nullable()
   }).nullable(),
-  purchases: z52.array(SwarmSpendPurchaseSchema)
+  purchases: z53.array(SwarmSpendPurchaseSchema)
 });
 
 // ../../packages/shared/dist/schemas/swarm-balance.schemas.js
-import { z as z53 } from "zod";
-var SwarmBalanceViewSchema = z53.object({
-  status: z53.enum(["unavailable", "fresh", "stale"]),
-  balance: z53.object({
-    amountAtomic: z53.string().regex(/^(0|[1-9][0-9]{0,77})$/),
-    blockNumber: z53.string().regex(/^(0|[1-9][0-9]*)$/),
-    blockHash: z53.string().regex(/^0x[0-9a-fA-F]{64}$/),
-    observedAt: z53.string().datetime(),
-    blockTimestamp: z53.string().datetime(),
+import { z as z54 } from "zod";
+var SwarmBalanceViewSchema = z54.object({
+  status: z54.enum(["unavailable", "fresh", "stale"]),
+  balance: z54.object({
+    amountAtomic: z54.string().regex(/^(0|[1-9][0-9]{0,77})$/),
+    blockNumber: z54.string().regex(/^(0|[1-9][0-9]*)$/),
+    blockHash: z54.string().regex(/^0x[0-9a-fA-F]{64}$/),
+    observedAt: z54.string().datetime(),
+    blockTimestamp: z54.string().datetime(),
     chainId: SwarmChainIdSchema,
-    token: z53.string().regex(/^0x[0-9a-fA-F]{40}$/)
+    token: z54.string().regex(/^0x[0-9a-fA-F]{40}$/)
   }).nullable(),
-  dispatchAllowed: z53.literal(false)
+  dispatchAllowed: z54.literal(false)
 });
 
 // ../../packages/shared/dist/schemas/swarm-purchase.schemas.js
-import { z as z54 } from "zod";
-var SwarmPurchaseIdSchema = z54.object({ purchaseId: z54.string().uuid() }).strict();
-var SwarmPurchaseViewSchema = z54.object({
-  id: z54.string().uuid(),
-  phase: z54.enum(["quoting", "quoted", "payment", "unknown", "free_result", "failed"]),
-  resultReference: z54.string().nullable(),
-  purchase: z54.object({
-    id: z54.string().uuid(),
-    phase: z54.enum([
+import { z as z55 } from "zod";
+var SwarmPurchaseIdSchema = z55.object({ purchaseId: z55.string().uuid() }).strict();
+var SwarmPurchaseViewSchema = z55.object({
+  id: z55.string().uuid(),
+  phase: z55.enum(["quoting", "quoted", "payment", "unknown", "free_result", "failed"]),
+  resultReference: z55.string().nullable(),
+  purchase: z55.object({
+    id: z55.string().uuid(),
+    phase: z55.enum([
       "prepared",
       "signing",
       "signed",
@@ -7614,16 +8036,16 @@ var SwarmPurchaseViewSchema = z54.object({
       "settled",
       "released"
     ]),
-    resultStatus: z54.enum(["pending", "received", "failed"]),
-    transactionHash: z54.string().nullable(),
-    resultReference: z54.string().nullable(),
-    dispatchAllowed: z54.literal(false)
+    resultStatus: z55.enum(["pending", "received", "failed"]),
+    transactionHash: z55.string().nullable(),
+    resultReference: z55.string().nullable(),
+    dispatchAllowed: z55.literal(false)
   }).nullable(),
-  dispatchAllowed: z54.literal(false)
+  dispatchAllowed: z55.literal(false)
 });
 
 // ../../packages/shared/dist/schemas/swarm-purchase-approval.schemas.js
-import { z as z55 } from "zod";
+import { z as z56 } from "zod";
 var SWARM_PURCHASE_APPROVAL_TTL_MS = 30 * 6e4;
 var SWARM_PURCHASE_APPROVAL_STATUSES = [
   "pending",
@@ -7635,47 +8057,47 @@ var SWARM_PURCHASE_APPROVAL_STATUSES = [
   "denied",
   "expired"
 ];
-var SwarmPurchaseApprovalWarningSchema = z55.enum(["non_catalog", "unexpected_recipient"]);
-var SwarmPurchaseApprovalSchema = z55.object({
-  id: z55.string().uuid(),
-  agentId: z55.string(),
-  agentName: z55.string().nullable(),
-  jobId: z55.string().uuid().optional(),
-  status: z55.enum(SWARM_PURCHASE_APPROVAL_STATUSES),
+var SwarmPurchaseApprovalWarningSchema = z56.enum(["non_catalog", "unexpected_recipient"]);
+var SwarmPurchaseApprovalSchema = z56.object({
+  id: z56.string().uuid(),
+  agentId: z56.string(),
+  agentName: z56.string().nullable(),
+  jobId: z56.string().uuid().optional(),
+  status: z56.enum(SWARM_PURCHASE_APPROVAL_STATUSES),
   /** The final code the agent reads, e.g. SWARM_PURCHASE_APPROVAL_DENIED or SWARM_QUOTE_CHANGED. */
-  code: z55.string().nullable(),
-  origin: z55.string().url(),
-  url: z55.string().url(),
-  method: z55.enum(["GET", "POST"]),
-  payTo: z55.string().regex(/^0x[0-9a-fA-F]{40}$/),
+  code: z56.string().nullable(),
+  origin: z56.string().url(),
+  url: z56.string().url(),
+  method: z56.enum(["GET", "POST"]),
+  payTo: z56.string().regex(/^0x[0-9a-fA-F]{40}$/),
   /** USDC base units. */
-  amount: z55.string().regex(/^[1-9][0-9]{0,17}$/),
-  asset: z55.string().regex(/^0x[0-9a-fA-F]{40}$/),
-  network: z55.string(),
-  resource: z55.object({
-    url: z55.string().nullable(),
-    description: z55.string().nullable(),
-    mimeType: z55.string().nullable()
+  amount: z56.string().regex(/^[1-9][0-9]{0,17}$/),
+  asset: z56.string().regex(/^0x[0-9a-fA-F]{40}$/),
+  network: z56.string(),
+  resource: z56.object({
+    url: z56.string().nullable(),
+    description: z56.string().nullable(),
+    mimeType: z56.string().nullable()
   }),
-  catalog: z55.object({ entryId: z55.string(), name: z55.string(), verified: z55.boolean() }).nullable(),
+  catalog: z56.object({ entryId: z56.string(), name: z56.string(), verified: z56.boolean() }).nullable(),
   warning: SwarmPurchaseApprovalWarningSchema.nullable(),
   /** Financial phase of the executed purchase, once there is one. */
-  purchasePhase: z55.string().nullable(),
-  resultStatus: z55.enum(["pending", "received", "failed"]).nullable(),
-  createdAt: z55.string(),
-  expiresAt: z55.string(),
-  decidedAt: z55.string().nullable()
-});
-var SwarmPurchaseApprovalListInputSchema = z55.object({ agentId: z55.string().uuid().optional() }).strict();
-var SwarmPurchaseApprovalListSchema = z55.object({
-  enabled: z55.boolean(),
-  approvals: z55.array(SwarmPurchaseApprovalSchema)
-});
-var SwarmPurchaseApprovalIdSchema = z55.object({ approvalId: z55.string().uuid() }).strict();
+  purchasePhase: z56.string().nullable(),
+  resultStatus: z56.enum(["pending", "received", "failed"]).nullable(),
+  createdAt: z56.string(),
+  expiresAt: z56.string(),
+  decidedAt: z56.string().nullable()
+});
+var SwarmPurchaseApprovalListInputSchema = z56.object({ agentId: z56.string().uuid().optional() }).strict();
+var SwarmPurchaseApprovalListSchema = z56.object({
+  enabled: z56.boolean(),
+  approvals: z56.array(SwarmPurchaseApprovalSchema)
+});
+var SwarmPurchaseApprovalIdSchema = z56.object({ approvalId: z56.string().uuid() }).strict();
 var SwarmPurchaseApprovalConfirmSchema = SwarmPurchaseApprovalIdSchema.extend({
   consentTextVersion: SwarmConsentTextVersionSchema
 }).strict();
-var SwarmPurchaseApprovalPreparedSchema = z55.object({
+var SwarmPurchaseApprovalPreparedSchema = z56.object({
   approval: SwarmPurchaseApprovalSchema,
   consent: SwarmConsentSchema
 });
@@ -8110,37 +8532,37 @@ ${LEGAL_ACCEPTANCE_STATEMENT}`;
 }
 
 // ../../packages/shared/dist/schemas/swarm-identity.schemas.js
-import { z as z56 } from "zod";
-var SwarmIdentityPerformanceSchema = z56.object({
-  completedTasks: z56.number().int().nonnegative().safe(),
-  ratedTasks: z56.number().int().nonnegative().safe(),
-  totalStars: z56.number().int().nonnegative().safe(),
+import { z as z57 } from "zod";
+var SwarmIdentityPerformanceSchema = z57.object({
+  completedTasks: z57.number().int().nonnegative().safe(),
+  ratedTasks: z57.number().int().nonnegative().safe(),
+  totalStars: z57.number().int().nonnegative().safe(),
   // Exact USDC base units from the canonical projection; never a floating-point amount.
-  totalEarnings: z56.string().regex(/^(0|[1-9][0-9]{0,77})$/)
+  totalEarnings: z57.string().regex(/^(0|[1-9][0-9]{0,77})$/)
 });
-var SwarmIdentityViewSchema = z56.object({
-  status: z56.enum([
+var SwarmIdentityViewSchema = z57.object({
+  status: z57.enum([
     "wallet_not_ready",
     "unregistered",
     "deployment_mismatch",
     "profile_conflict",
     "registered"
   ]),
-  walletAddress: z56.string().regex(/^0x[0-9a-f]{40}$/).nullable(),
-  identity: z56.object({
-    agentId: z56.string().regex(/^(0|[1-9][0-9]*)$/),
-    chainId: z56.number().int().positive(),
-    registryAddress: z56.string().regex(/^0x[0-9a-f]{40}$/),
-    actorType: z56.literal("agent")
+  walletAddress: z57.string().regex(/^0x[0-9a-f]{40}$/).nullable(),
+  identity: z57.object({
+    agentId: z57.string().regex(/^(0|[1-9][0-9]*)$/),
+    chainId: z57.number().int().positive(),
+    registryAddress: z57.string().regex(/^0x[0-9a-f]{40}$/),
+    actorType: z57.literal("agent")
   }).nullable(),
   performance: SwarmIdentityPerformanceSchema.nullable().optional(),
   // This is the existing indexer's projection, not a fresh registry ownership check.
-  source: z56.literal("database_projection"),
-  registrationEnabled: z56.literal(false)
+  source: z57.literal("database_projection"),
+  registrationEnabled: z57.literal(false)
 });
 
 // ../../packages/shared/dist/schemas/catalog.schemas.js
-import { z as z57 } from "zod";
+import { z as z58 } from "zod";
 var CATALOG_FORMAT_VERSION = 1;
 var CATALOG_KINDS = ["x402-endpoint"];
 var CATALOG_TRUST_TIERS = ["curated", "verified", "community"];
@@ -8163,372 +8585,372 @@ var CATALOG_CAPABILITIES = [
   "evaluation",
   "agent-hosting"
 ];
-var catalogId = z57.string().min(3).max(80).regex(/^[a-z0-9]+(?:-[a-z0-9]+)*\.[a-z0-9]+(?:[.-][a-z0-9]+)*$/, "Catalog ids are lowercase, dot-namespaced by capability, e.g. domains.namecheap-x402");
-var CatalogOriginSchema = z57.string().url().max(2048).refine((value) => {
+var catalogId = z58.string().min(3).max(80).regex(/^[a-z0-9]+(?:-[a-z0-9]+)*\.[a-z0-9]+(?:[.-][a-z0-9]+)*$/, "Catalog ids are lowercase, dot-namespaced by capability, e.g. domains.namecheap-x402");
+var CatalogOriginSchema = z58.string().url().max(2048).refine((value) => {
   const url = new URL(value);
   return url.protocol === "https:" && url.origin === value;
 }, "An HTTPS origin without a path or credentials is required");
-var isoDate = z57.string().regex(/^\d{4}-\d{2}-\d{2}$/, "Expected an ISO date (YYYY-MM-DD)");
-var atomicAmount = z57.string().regex(/^(?:0|[1-9][0-9]*)$/, "Expected an integer atomic amount");
-var CatalogEndpointSchema = z57.object({
-  method: z57.enum(["GET", "POST"]),
-  path: z57.string().min(1).max(512).regex(/^\//, "Endpoint paths start with /"),
-  summary: z57.string().min(1).max(200)
+var isoDate = z58.string().regex(/^\d{4}-\d{2}-\d{2}$/, "Expected an ISO date (YYYY-MM-DD)");
+var atomicAmount = z58.string().regex(/^(?:0|[1-9][0-9]*)$/, "Expected an integer atomic amount");
+var CatalogEndpointSchema = z58.object({
+  method: z58.enum(["GET", "POST"]),
+  path: z58.string().min(1).max(512).regex(/^\//, "Endpoint paths start with /"),
+  summary: z58.string().min(1).max(200)
 }).strict();
-var CatalogProviderSchema = z57.object({
-  name: z57.string().min(1).max(120),
-  url: z57.string().url().max(2048)
+var CatalogProviderSchema = z58.object({
+  name: z58.string().min(1).max(120),
+  url: z58.string().url().max(2048)
 }).strict();
-var CatalogPricingSchema = z57.object({
-  chainId: z57.union([z57.literal(8453), z57.literal(84532)]),
-  token: z57.literal("USDC"),
+var CatalogPricingSchema = z58.object({
+  chainId: z58.union([z58.literal(8453), z58.literal(84532)]),
+  token: z58.literal("USDC"),
   // Highest per-call price we expect this provider to quote, in atomic units.
   // `make catalog probe` compares the live 402 quote against it.
   typicalMax: atomicAmount,
   // Reviewed x402 recipients for this origin (ADR-0182). An in-chat purchase approval shows the
   // catalog verification badge only when both the origin and the quoted recipient match.
-  payTo: z57.array(z57.string().regex(/^0x[0-9a-fA-F]{40}$/)).min(1).max(8).optional()
+  payTo: z58.array(z58.string().regex(/^0x[0-9a-fA-F]{40}$/)).min(1).max(8).optional()
 }).strict();
-var CatalogTrustSchema = z57.object({
-  tier: z57.enum(CATALOG_TRUST_TIERS),
-  reviewedBy: z57.string().min(1).max(120),
+var CatalogTrustSchema = z58.object({
+  tier: z58.enum(CATALOG_TRUST_TIERS),
+  reviewedBy: z58.string().min(1).max(120),
   reviewedAt: isoDate,
-  notes: z57.string().max(2e3).optional()
+  notes: z58.string().max(2e3).optional()
 }).strict();
-var catalogEntryBase = z57.object({
+var catalogEntryBase = z58.object({
   id: catalogId,
-  name: z57.string().min(1).max(120),
+  name: z58.string().min(1).max(120),
   provider: CatalogProviderSchema,
-  capabilities: z57.array(z57.enum(CATALOG_CAPABILITIES)).min(1).max(8),
+  capabilities: z58.array(z58.enum(CATALOG_CAPABILITIES)).min(1).max(8),
   // Prose that gets embedded for semantic search. Write it for retrieval.
-  description: z57.string().min(20).max(2e3),
+  description: z58.string().min(20).max(2e3),
   // Short, exact how-to shown to the agent verbatim.
-  usage: z57.string().min(10).max(4e3),
-  docsUrl: z57.string().url().max(2048),
+  usage: z58.string().min(10).max(4e3),
+  docsUrl: z58.string().url().max(2048),
   trust: CatalogTrustSchema,
-  status: z57.enum(CATALOG_STATUSES),
+  status: z58.enum(CATALOG_STATUSES),
   addedAt: isoDate
 });
 var CatalogX402EndpointEntrySchema = catalogEntryBase.extend({
-  kind: z57.literal("x402-endpoint"),
+  kind: z58.literal("x402-endpoint"),
   origin: CatalogOriginSchema,
-  endpoints: z57.array(CatalogEndpointSchema).min(1).max(32),
+  endpoints: z58.array(CatalogEndpointSchema).min(1).max(32),
   pricing: CatalogPricingSchema
 }).strict();
-var CatalogEntrySchema = z57.discriminatedUnion("kind", [CatalogX402EndpointEntrySchema]);
-var CatalogFileSchema = z57.object({
-  formatVersion: z57.literal(CATALOG_FORMAT_VERSION),
-  generatedAt: z57.string().datetime(),
-  entries: z57.array(CatalogEntrySchema)
+var CatalogEntrySchema = z58.discriminatedUnion("kind", [CatalogX402EndpointEntrySchema]);
+var CatalogFileSchema = z58.object({
+  formatVersion: z58.literal(CATALOG_FORMAT_VERSION),
+  generatedAt: z58.string().datetime(),
+  entries: z58.array(CatalogEntrySchema)
 }).strict();
-var CatalogSearchInputSchema = z57.object({
-  query: z57.string().trim().min(1).max(500),
-  kind: z57.enum(CATALOG_KINDS).optional(),
-  capabilities: z57.array(z57.enum(CATALOG_CAPABILITIES)).max(8).optional(),
-  tiers: z57.array(z57.enum(CATALOG_TRUST_TIERS)).max(3).optional(),
-  limit: z57.number().int().min(1).max(20).default(5)
+var CatalogSearchInputSchema = z58.object({
+  query: z58.string().trim().min(1).max(500),
+  kind: z58.enum(CATALOG_KINDS).optional(),
+  capabilities: z58.array(z58.enum(CATALOG_CAPABILITIES)).max(8).optional(),
+  tiers: z58.array(z58.enum(CATALOG_TRUST_TIERS)).max(3).optional(),
+  limit: z58.number().int().min(1).max(20).default(5)
 }).strict();
-var CatalogSearchHitSchema = z57.object({
+var CatalogSearchHitSchema = z58.object({
   entry: CatalogEntrySchema,
-  score: z57.number(),
-  matchedCapabilities: z57.array(z57.enum(CATALOG_CAPABILITIES))
+  score: z58.number(),
+  matchedCapabilities: z58.array(z58.enum(CATALOG_CAPABILITIES))
 }).strict();
-var CatalogSearchOutputSchema = z57.object({
-  hits: z57.array(CatalogSearchHitSchema),
-  total: z57.number().int().nonnegative()
+var CatalogSearchOutputSchema = z58.object({
+  hits: z58.array(CatalogSearchHitSchema),
+  total: z58.number().int().nonnegative()
 }).strict();
-var CatalogGetInputSchema = z57.object({ id: catalogId }).strict();
+var CatalogGetInputSchema = z58.object({ id: catalogId }).strict();
 
 // ../../packages/shared/dist/schemas/launcher-pilot.schemas.js
-import { z as z58 } from "zod";
-var LauncherPilotConfigSchema = z58.object({
-  LAUNCHER_PILOT_WALLET_ENABLED: z58.enum(["true", "false"]).default("false").transform((v) => v === "true"),
-  LAUNCHER_PILOT_PURCHASES_ENABLED: z58.enum(["true", "false"]).default("false").transform((v) => v === "true"),
+import { z as z59 } from "zod";
+var LauncherPilotConfigSchema = z59.object({
+  LAUNCHER_PILOT_WALLET_ENABLED: z59.enum(["true", "false"]).default("false").transform((v) => v === "true"),
+  LAUNCHER_PILOT_PURCHASES_ENABLED: z59.enum(["true", "false"]).default("false").transform((v) => v === "true"),
   // Implements: ADR-0182. Owners approve an agent's x402 purchase in chat; off by default.
-  LAUNCHER_PURCHASE_APPROVALS_ENABLED: z58.enum(["true", "false"]).default("false").transform((v) => v === "true"),
+  LAUNCHER_PURCHASE_APPROVALS_ENABLED: z59.enum(["true", "false"]).default("false").transform((v) => v === "true"),
   // Implements: ADR-0183. Swarm YOLO mode (any recipient within caps for a standing period);
   // off by default, and refused unless pilot purchases are on.
-  LAUNCHER_SWARM_YOLO_ENABLED: z58.enum(["true", "false"]).default("false").transform((v) => v === "true"),
+  LAUNCHER_SWARM_YOLO_ENABLED: z59.enum(["true", "false"]).default("false").transform((v) => v === "true"),
   /**
    * Per ADR-0212. Standing swarm spending: a YOLO consent with no end date, until the owner turns
    * it off. Off by default; it takes effect only with pilot purchases, YOLO and in-chat purchase
    * approvals all on (see `swarmStandingSpendEnabled`), so missing authority always becomes an
    * approval card in chat rather than a failure.
    */
-  LAUNCHER_SWARM_STANDING_SPEND_ENABLED: z58.enum(["true", "false"]).default("false").transform((v) => v === "true"),
+  LAUNCHER_SWARM_STANDING_SPEND_ENABLED: z59.enum(["true", "false"]).default("false").transform((v) => v === "true"),
   /**
    * ADR-0183. Recipients (0x addresses) and merchant origins (https://host) a YOLO purchase never
    * pays, checked before signing. A JSON array; empty by default.
    */
-  LAUNCHER_SWARM_YOLO_BLOCKLIST: z58.string().default("[]").transform((value, ctx) => {
+  LAUNCHER_SWARM_YOLO_BLOCKLIST: z59.string().default("[]").transform((value, ctx) => {
     try {
       return JSON.parse(value);
     } catch {
       ctx.addIssue({
-        code: z58.ZodIssueCode.custom,
+        code: z59.ZodIssueCode.custom,
         message: "Use a JSON array of addresses and https origins"
       });
-      return z58.NEVER;
+      return z59.NEVER;
     }
-  }).pipe(z58.array(z58.union([
-    z58.string().regex(/^0x[0-9a-fA-F]{40}$/),
-    z58.string().url().refine((v) => new URL(v).protocol === "https:" && new URL(v).origin === v)
+  }).pipe(z59.array(z59.union([
+    z59.string().regex(/^0x[0-9a-fA-F]{40}$/),
+    z59.string().url().refine((v) => new URL(v).protocol === "https:" && new URL(v).origin === v)
   ])).max(1e3)).transform((values) => values.map((value) => value.toLowerCase())),
-  LAUNCHER_PILOT_ENABLED: z58.enum(["true", "false"]).default("false").transform((v) => v === "true"),
-  LAUNCHER_PILOT_OWNER_IDS: z58.string().default("[]").transform((value, ctx) => {
+  LAUNCHER_PILOT_ENABLED: z59.enum(["true", "false"]).default("false").transform((v) => v === "true"),
+  LAUNCHER_PILOT_OWNER_IDS: z59.string().default("[]").transform((value, ctx) => {
     try {
       return JSON.parse(value);
     } catch {
       ctx.addIssue({
-        code: z58.ZodIssueCode.custom,
+        code: z59.ZodIssueCode.custom,
         message: "Use a JSON array of Privy user IDs"
       });
-      return z58.NEVER;
+      return z59.NEVER;
     }
-  }).pipe(z58.array(z58.string().regex(/^did:privy:[A-Za-z0-9_-]{1,200}$/)).max(20)).transform((ids) => [...new Set(ids)])
+  }).pipe(z59.array(z59.string().regex(/^did:privy:[A-Za-z0-9_-]{1,200}$/)).max(20)).transform((ids) => [...new Set(ids)])
 });
-var LauncherPrivyConfigSchema = z58.object({
-  PRIVY_APP_ID: z58.string().min(1).optional(),
-  PRIVY_APP_SECRET: z58.string().min(1).optional(),
-  PRIVY_AUTHORIZATION_KEY_ID: z58.string().regex(/^[A-Za-z0-9_-]{1,128}$/).optional(),
-  PRIVY_AUTHORIZATION_PRIVATE_KEY: z58.string().min(1).optional()
+var LauncherPrivyConfigSchema = z59.object({
+  PRIVY_APP_ID: z59.string().min(1).optional(),
+  PRIVY_APP_SECRET: z59.string().min(1).optional(),
+  PRIVY_AUTHORIZATION_KEY_ID: z59.string().regex(/^[A-Za-z0-9_-]{1,128}$/).optional(),
+  PRIVY_AUTHORIZATION_PRIVATE_KEY: z59.string().min(1).optional()
 });
 
 // ../../packages/shared/dist/schemas/integration.schemas.js
-import { z as z59 } from "zod";
-var IntegrationProviderSchema = z59.literal("github");
-var IntegrationActionSchema = z59.enum([
+import { z as z60 } from "zod";
+var IntegrationProviderSchema = z60.literal("github");
+var IntegrationActionSchema = z60.enum([
   "github.repository.read",
   "github.repository.create",
   "github.change.propose"
 ]);
-var IntegrationConnectionSchema = z59.object({
-  id: z59.string().uuid(),
+var IntegrationConnectionSchema = z60.object({
+  id: z60.string().uuid(),
   provider: IntegrationProviderSchema,
-  label: z59.string(),
-  state: z59.enum(["active", "disconnected", "needs_reconnect"]),
-  generation: z59.number().int(),
-  externalAccount: z59.string(),
-  createdAt: z59.string()
-});
-var IntegrationResourceSchema = z59.object({
-  id: z59.string().uuid(),
-  connectionId: z59.string().uuid(),
-  externalId: z59.string(),
-  name: z59.string(),
-  description: z59.string(),
-  approved: z59.boolean(),
-  allowSwarmSharing: z59.boolean()
-});
-var IntegrationGrantSchema = z59.object({
-  agentId: z59.string().uuid(),
-  connectionId: z59.string().uuid(),
-  allApproved: z59.boolean(),
-  resourceIds: z59.array(z59.string().uuid()).max(100),
-  actions: z59.array(IntegrationActionSchema).max(3),
-  revision: z59.number().int().nonnegative()
-});
-var IntegrationConnectionInputSchema = z59.object({ connectionId: z59.string().uuid() });
+  label: z60.string(),
+  state: z60.enum(["active", "disconnected", "needs_reconnect"]),
+  generation: z60.number().int(),
+  externalAccount: z60.string(),
+  createdAt: z60.string()
+});
+var IntegrationResourceSchema = z60.object({
+  id: z60.string().uuid(),
+  connectionId: z60.string().uuid(),
+  externalId: z60.string(),
+  name: z60.string(),
+  description: z60.string(),
+  approved: z60.boolean(),
+  allowSwarmSharing: z60.boolean()
+});
+var IntegrationGrantSchema = z60.object({
+  agentId: z60.string().uuid(),
+  connectionId: z60.string().uuid(),
+  allApproved: z60.boolean(),
+  resourceIds: z60.array(z60.string().uuid()).max(100),
+  actions: z60.array(IntegrationActionSchema).max(3),
+  revision: z60.number().int().nonnegative()
+});
+var IntegrationConnectionInputSchema = z60.object({ connectionId: z60.string().uuid() });
 var IntegrationGrantInputSchema = IntegrationGrantSchema.omit({ revision: true }).extend({
-  requestKey: z59.string().uuid(),
-  expectedRevision: z59.number().int().nonnegative()
+  requestKey: z60.string().uuid(),
+  expectedRevision: z60.number().int().nonnegative()
 });
 var IntegrationApprovalInputSchema = IntegrationConnectionInputSchema.extend({
-  resourceId: z59.string().uuid(),
-  approved: z59.boolean(),
-  allowSwarmSharing: z59.boolean().default(false)
+  resourceId: z60.string().uuid(),
+  approved: z60.boolean(),
+  allowSwarmSharing: z60.boolean().default(false)
 });
-var IntegrationReadInputSchema = z59.object({
-  resourceId: z59.string().uuid(),
-  path: z59.string().max(1024).default(""),
-  ref: z59.string().min(1).max(256).optional()
+var IntegrationReadInputSchema = z60.object({
+  resourceId: z60.string().uuid(),
+  path: z60.string().max(1024).default(""),
+  ref: z60.string().min(1).max(256).optional()
 });
 var IntegrationResourcePageInputSchema = IntegrationConnectionInputSchema.extend({
-  page: z59.number().int().min(1).max(100).default(1)
+  page: z60.number().int().min(1).max(100).default(1)
 });
-var IntegrationCreateInputSchema = z59.object({
-  connectionId: z59.string().uuid(),
-  requestKey: z59.string().uuid(),
-  name: z59.string().min(1).max(100).regex(/^[A-Za-z0-9][A-Za-z0-9_.-]*$/),
-  description: z59.string().max(350).default("")
+var IntegrationCreateInputSchema = z60.object({
+  connectionId: z60.string().uuid(),
+  requestKey: z60.string().uuid(),
+  name: z60.string().min(1).max(100).regex(/^[A-Za-z0-9][A-Za-z0-9_.-]*$/),
+  description: z60.string().max(350).default("")
 }).strict();
-var repositoryPath = z59.string().min(1).max(512).refine((path3) => path3.split("/").every((part) => part && part !== "." && part !== ".." && part.toLowerCase() !== ".git" && part.toLowerCase() !== ".gitmodules" && ![...part].some((char) => char === "\\" || char.charCodeAt(0) < 32 || char.charCodeAt(0) === 127)) && !path3.toLowerCase().startsWith(".github/workflows/"), "Unsupported repository path");
-var IntegrationPublishInputSchema = z59.object({
-  resourceId: z59.string().uuid(),
-  requestKey: z59.string().uuid(),
-  branch: z59.string().min(1).max(80).regex(/^[a-z0-9]+(?:-[a-z0-9]+)*$/),
-  expectedHeadOid: z59.string().regex(/^[a-f0-9]{40}$/),
-  title: z59.string().min(1).max(200),
-  body: z59.string().max(1e4).default(""),
-  files: z59.array(z59.object({
+var repositoryPath = z60.string().min(1).max(512).refine((path3) => path3.split("/").every((part) => part && part !== "." && part !== ".." && part.toLowerCase() !== ".git" && part.toLowerCase() !== ".gitmodules" && ![...part].some((char) => char === "\\" || char.charCodeAt(0) < 32 || char.charCodeAt(0) === 127)) && !path3.toLowerCase().startsWith(".github/workflows/"), "Unsupported repository path");
+var IntegrationPublishInputSchema = z60.object({
+  resourceId: z60.string().uuid(),
+  requestKey: z60.string().uuid(),
+  branch: z60.string().min(1).max(80).regex(/^[a-z0-9]+(?:-[a-z0-9]+)*$/),
+  expectedHeadOid: z60.string().regex(/^[a-f0-9]{40}$/),
+  title: z60.string().min(1).max(200),
+  body: z60.string().max(1e4).default(""),
+  files: z60.array(z60.object({
     path: repositoryPath,
-    content: z59.string().max(65536).refine((value) => !value.includes("\0"), "Binary content is unsupported").nullable()
+    content: z60.string().max(65536).refine((value) => !value.includes("\0"), "Binary content is unsupported").nullable()
   }).strict()).min(1).max(50)
 }).strict().superRefine((input2, ctx) => {
   const paths = input2.files.map((file) => file.path);
   if (new Set(paths).size !== paths.length || paths.some((path3) => paths.some((other) => other.startsWith(path3 + "/"))))
-    ctx.addIssue({ code: z59.ZodIssueCode.custom, message: "Duplicate or overlapping paths" });
+    ctx.addIssue({ code: z60.ZodIssueCode.custom, message: "Duplicate or overlapping paths" });
   if (new TextEncoder().encode(JSON.stringify(input2)).length > 262144)
-    ctx.addIssue({ code: z59.ZodIssueCode.custom, message: "Publish exceeds 256 KiB" });
+    ctx.addIssue({ code: z60.ZodIssueCode.custom, message: "Publish exceeds 256 KiB" });
 });
 var IntegrationToolInputSchemas = {
-  integrations_list: z59.object({}),
-  integrations_resources: z59.object({
-    connectionId: z59.string().uuid().optional(),
-    after: z59.string().uuid().optional()
+  integrations_list: z60.object({}),
+  integrations_resources: z60.object({
+    connectionId: z60.string().uuid().optional(),
+    after: z60.string().uuid().optional()
   }),
   github_read: IntegrationReadInputSchema,
-  github_repository: z59.object({
-    resourceId: z59.string().uuid(),
-    branch: z59.string().max(80).regex(/^[a-z0-9]+(?:-[a-z0-9]+)*$/).optional()
+  github_repository: z60.object({
+    resourceId: z60.string().uuid(),
+    branch: z60.string().max(80).regex(/^[a-z0-9]+(?:-[a-z0-9]+)*$/).optional()
   }).strict(),
   github_create_repository: IntegrationCreateInputSchema,
   github_publish: IntegrationPublishInputSchema,
-  github_operation: z59.object({ operationId: z59.string().regex(/^[a-f0-9]{64}$/) }).strict()
+  github_operation: z60.object({ operationId: z60.string().regex(/^[a-f0-9]{64}$/) }).strict()
 };
-var IntegrationEnvironmentSchema = z59.object({
-  INTEGRATIONS_ENABLED: z59.enum(["true", "false"]).default("false").transform((v) => v === "true"),
-  INTEGRATION_KEY_ID: z59.string().regex(/^[A-Za-z0-9_-]{1,64}$/).optional(),
-  INTEGRATION_CREDENTIAL_KEYS: z59.string().max(4096).optional(),
-  GITHUB_APP_CLIENT_ID: z59.string().min(1).max(200).optional(),
-  GITHUB_APP_CLIENT_SECRET: z59.string().min(1).max(4096).optional(),
-  GITHUB_APP_SLUG: z59.string().regex(/^[a-z0-9][a-z0-9-]{0,99}$/).optional(),
-  GITHUB_APP_CALLBACK_URL: z59.string().url().refine((v) => {
+var IntegrationEnvironmentSchema = z60.object({
+  INTEGRATIONS_ENABLED: z60.enum(["true", "false"]).default("false").transform((v) => v === "true"),
+  INTEGRATION_KEY_ID: z60.string().regex(/^[A-Za-z0-9_-]{1,64}$/).optional(),
+  INTEGRATION_CREDENTIAL_KEYS: z60.string().max(4096).optional(),
+  GITHUB_APP_CLIENT_ID: z60.string().min(1).max(200).optional(),
+  GITHUB_APP_CLIENT_SECRET: z60.string().min(1).max(4096).optional(),
+  GITHUB_APP_SLUG: z60.string().regex(/^[a-z0-9][a-z0-9-]{0,99}$/).optional(),
+  GITHUB_APP_CALLBACK_URL: z60.string().url().refine((v) => {
     const u = new URL(v);
     return !u.username && !u.password && !u.search && !u.hash && (u.protocol === "https:" || u.protocol === "http:" && ["localhost", "127.0.0.1"].includes(u.hostname));
   }).optional()
 });
-var IntegrationViewSchema = z59.object({
-  configured: z59.boolean(),
-  installationUrl: z59.string().url().nullable(),
-  connections: z59.array(IntegrationConnectionSchema),
-  resources: z59.array(IntegrationResourceSchema),
-  grants: z59.array(IntegrationGrantSchema),
-  truncated: z59.boolean()
+var IntegrationViewSchema = z60.object({
+  configured: z60.boolean(),
+  installationUrl: z60.string().url().nullable(),
+  connections: z60.array(IntegrationConnectionSchema),
+  resources: z60.array(IntegrationResourceSchema),
+  grants: z60.array(IntegrationGrantSchema),
+  truncated: z60.boolean()
 });
 
 // ../../packages/shared/dist/schemas/launcher-stream.schemas.js
-import { z as z60 } from "zod";
-var LauncherLiveTextSchema = z60.object({
-  order: z60.number().int().min(0).max(63),
-  itemId: z60.string().min(1).max(200),
-  phase: z60.enum(["commentary", "final_answer"]),
-  text: z60.string().max(65536),
-  complete: z60.boolean()
-});
-var LauncherStreamSnapshotSchema = z60.object({
-  revision: z60.number().int().nonnegative(),
-  jobId: z60.string().uuid().nullable(),
-  runId: z60.string().uuid().nullable(),
-  messages: z60.array(LauncherLiveTextSchema).max(16),
-  activity: z60.array(LauncherActivitySchema).max(20)
+import { z as z61 } from "zod";
+var LauncherLiveTextSchema = z61.object({
+  order: z61.number().int().min(0).max(63),
+  itemId: z61.string().min(1).max(200),
+  phase: z61.enum(["commentary", "final_answer"]),
+  text: z61.string().max(65536),
+  complete: z61.boolean()
+});
+var LauncherStreamSnapshotSchema = z61.object({
+  revision: z61.number().int().nonnegative(),
+  jobId: z61.string().uuid().nullable(),
+  runId: z61.string().uuid().nullable(),
+  messages: z61.array(LauncherLiveTextSchema).max(16),
+  activity: z61.array(LauncherActivitySchema).max(20)
 });
 
 // ../../packages/shared/dist/schemas/channel.schemas.js
-import { z as z61 } from "zod";
-var ChannelTransportSchema = z61.enum(["iMessage", "RCS", "SMS"]);
-var ChannelSettingsSchema = z61.object({
-  memberIds: z61.array(z61.string().uuid()).min(1).max(10),
-  defaultAgentId: z61.string().uuid(),
-  coordinatorAgentId: z61.string().uuid().nullable(),
-  replyMode: z61.enum(["full", "notification"]),
-  transport: z61.enum(["auto", "imessage"])
+import { z as z62 } from "zod";
+var ChannelTransportSchema = z62.enum(["iMessage", "RCS", "SMS"]);
+var ChannelSettingsSchema = z62.object({
+  memberIds: z62.array(z62.string().uuid()).min(1).max(10),
+  defaultAgentId: z62.string().uuid(),
+  coordinatorAgentId: z62.string().uuid().nullable(),
+  replyMode: z62.enum(["full", "notification"]),
+  transport: z62.enum(["auto", "imessage"])
 });
 var ChannelPairBeginSchema = ChannelSettingsSchema.extend({
-  phone: z61.string().regex(/^\+[1-9]\d{7,14}$/, "Enter a phone number with its country code"),
-  requestKey: z61.string().uuid(),
-  authorityConsent: z61.literal(true)
+  phone: z62.string().regex(/^\+[1-9]\d{7,14}$/, "Enter a phone number with its country code"),
+  requestKey: z62.string().uuid(),
+  authorityConsent: z62.literal(true)
 });
-var ChannelAttemptInputSchema = z61.object({ attemptId: z61.string().uuid() });
-var ChannelPairStatusSchema = z61.object({
-  attemptId: z61.string().uuid(),
-  state: z61.enum(["pending", "proven", "expired", "completed"]),
-  maskedPhone: z61.string(),
-  expiresAt: z61.string()
+var ChannelAttemptInputSchema = z62.object({ attemptId: z62.string().uuid() });
+var ChannelPairStatusSchema = z62.object({
+  attemptId: z62.string().uuid(),
+  state: z62.enum(["pending", "proven", "expired", "completed"]),
+  maskedPhone: z62.string(),
+  expiresAt: z62.string()
 });
 var ChannelPairBeginResultSchema = ChannelPairStatusSchema.extend({
-  contactPhone: z61.string(),
-  phrase: z61.string(),
-  composeUrl: z61.string()
+  contactPhone: z62.string(),
+  phrase: z62.string(),
+  composeUrl: z62.string()
 });
 var ChannelBindingSchema = ChannelSettingsSchema.extend({
-  id: z61.string().uuid(),
-  state: z61.enum(["active", "paused", "opted_out", "disconnected", "needs_reverification"]),
-  revision: z61.number().int().nonnegative(),
-  generation: z61.number().int().nonnegative(),
-  maskedPhone: z61.string(),
-  contactPhone: z61.string(),
-  lastActivityAt: z61.string().nullable(),
-  recoveryGap: z61.string().nullable().optional(),
-  deliveryIssue: z61.string().nullable().optional(),
-  routes: z61.array(z61.object({ agentId: z61.string().uuid(), name: z61.string(), alias: z61.string() }))
-});
-var ChannelViewSchema = z61.object({
-  configured: z61.boolean(),
-  admissionEnabled: z61.boolean(),
-  deliveryEnabled: z61.boolean(),
+  id: z62.string().uuid(),
+  state: z62.enum(["active", "paused", "opted_out", "disconnected", "needs_reverification"]),
+  revision: z62.number().int().nonnegative(),
+  generation: z62.number().int().nonnegative(),
+  maskedPhone: z62.string(),
+  contactPhone: z62.string(),
+  lastActivityAt: z62.string().nullable(),
+  recoveryGap: z62.string().nullable().optional(),
+  deliveryIssue: z62.string().nullable().optional(),
+  routes: z62.array(z62.object({ agentId: z62.string().uuid(), name: z62.string(), alias: z62.string() }))
+});
+var ChannelViewSchema = z62.object({
+  configured: z62.boolean(),
+  admissionEnabled: z62.boolean(),
+  deliveryEnabled: z62.boolean(),
   binding: ChannelBindingSchema.nullable()
 });
 var ChannelUpdateSchema = ChannelSettingsSchema.extend({
-  bindingId: z61.string().uuid(),
-  expectedRevision: z61.number().int().nonnegative()
-});
-var ChannelDisconnectSchema = z61.object({
-  bindingId: z61.string().uuid(),
-  expectedRevision: z61.number().int().nonnegative()
-});
-var ChannelRequestsInputSchema = z61.object({
-  before: z61.string().uuid().optional(),
-  limit: z61.number().int().min(1).max(50).default(20)
-});
-var ChannelRequestSchema = z61.object({
-  id: z61.string().uuid(),
-  reference: z61.string(),
-  agentId: z61.string().uuid().nullable(),
-  jobId: z61.string().uuid().nullable(),
-  state: z61.string(),
-  reason: z61.string().nullable(),
-  deliveryState: z61.string().nullable(),
-  deliveryReason: z61.string().nullable().optional(),
+  bindingId: z62.string().uuid(),
+  expectedRevision: z62.number().int().nonnegative()
+});
+var ChannelDisconnectSchema = z62.object({
+  bindingId: z62.string().uuid(),
+  expectedRevision: z62.number().int().nonnegative()
+});
+var ChannelRequestsInputSchema = z62.object({
+  before: z62.string().uuid().optional(),
+  limit: z62.number().int().min(1).max(50).default(20)
+});
+var ChannelRequestSchema = z62.object({
+  id: z62.string().uuid(),
+  reference: z62.string(),
+  agentId: z62.string().uuid().nullable(),
+  jobId: z62.string().uuid().nullable(),
+  state: z62.string(),
+  reason: z62.string().nullable(),
+  deliveryState: z62.string().nullable(),
+  deliveryReason: z62.string().nullable().optional(),
   incomingTransport: ChannelTransportSchema.nullable().optional(),
   deliveryTransport: ChannelTransportSchema.nullable().optional(),
-  outboxId: z61.string().uuid().nullable(),
-  createdAt: z61.string()
-});
-var ChannelRequestsSchema = z61.object({
-  requests: z61.array(ChannelRequestSchema),
-  nextCursor: z61.string().uuid().nullable()
-});
-var ChannelResendSchema = z61.object({
-  outboxId: z61.string().uuid(),
-  requestKey: z61.string().uuid(),
-  acknowledgeDuplicate: z61.literal(true)
-});
-var ChannelEnvironmentSchema = z61.object({
-  CHANNEL_INGRESS_ENABLED: z61.enum(["true", "false"]).default("false").transform((v) => v === "true"),
-  CHANNEL_ADMISSION_ENABLED: z61.enum(["true", "false"]).default("false").transform((v) => v === "true"),
-  CHANNEL_DELIVERY_ENABLED: z61.enum(["true", "false"]).default("false").transform((v) => v === "true"),
-  CHANNEL_ENVIRONMENT: z61.string().min(1).max(100).default("development"),
+  outboxId: z62.string().uuid().nullable(),
+  createdAt: z62.string()
+});
+var ChannelRequestsSchema = z62.object({
+  requests: z62.array(ChannelRequestSchema),
+  nextCursor: z62.string().uuid().nullable()
+});
+var ChannelResendSchema = z62.object({
+  outboxId: z62.string().uuid(),
+  requestKey: z62.string().uuid(),
+  acknowledgeDuplicate: z62.literal(true)
+});
+var ChannelEnvironmentSchema = z62.object({
+  CHANNEL_INGRESS_ENABLED: z62.enum(["true", "false"]).default("false").transform((v) => v === "true"),
+  CHANNEL_ADMISSION_ENABLED: z62.enum(["true", "false"]).default("false").transform((v) => v === "true"),
+  CHANNEL_DELIVERY_ENABLED: z62.enum(["true", "false"]).default("false").transform((v) => v === "true"),
+  CHANNEL_ENVIRONMENT: z62.string().min(1).max(100).default("development"),
   /** Key ID recorded in new ciphertext; must name an entry in CHANNEL_KEYS. */
-  CHANNEL_KEY_ID: z61.string().regex(/^[A-Za-z0-9_-]{1,64}$/).optional(),
+  CHANNEL_KEY_ID: z62.string().regex(/^[A-Za-z0-9_-]{1,64}$/).optional(),
   /** JSON map of key ID to 64-hex key. Retired keys stay while ciphertext still uses them. */
-  CHANNEL_KEYS: z61.string().max(4096).optional(),
-  CHANNEL_LOOKUP_KEY: z61.string().regex(/^[a-f0-9]{64}$/i).optional(),
-  CHANNEL_DASHBOARD_URL: z61.string().max(2048).url().refine((value) => {
+  CHANNEL_KEYS: z62.string().max(4096).optional(),
+  CHANNEL_LOOKUP_KEY: z62.string().regex(/^[a-f0-9]{64}$/i).optional(),
+  CHANNEL_DASHBOARD_URL: z62.string().max(2048).url().refine((value) => {
     const url = new URL(value);
     return !url.username && !url.password && !url.search && !url.hash && url.pathname === "/" && (url.protocol === "https:" || url.protocol === "http:" && ["localhost", "127.0.0.1"].includes(url.hostname));
   }).optional(),
-  LINQ_API_TOKEN: z61.string().min(1).optional(),
-  LINQ_WEBHOOK_SECRET: z61.string().min(1).optional(),
-  LINQ_ACCOUNT_ID: z61.string().min(1).max(200).optional(),
-  LINQ_LINE_ID: z61.string().min(1).max(200).optional(),
-  LINQ_LINE_PHONE: z61.string().regex(/^\+[1-9]\d{7,14}$/).optional()
+  LINQ_API_TOKEN: z62.string().min(1).optional(),
+  LINQ_WEBHOOK_SECRET: z62.string().min(1).optional(),
+  LINQ_ACCOUNT_ID: z62.string().min(1).max(200).optional(),
+  LINQ_LINE_ID: z62.string().min(1).max(200).optional(),
+  LINQ_LINE_PHONE: z62.string().regex(/^\+[1-9]\d{7,14}$/).optional()
 });
 
 // ../../packages/shared/dist/schemas/launcher-access.schemas.js
-import { z as z62 } from "zod";
-var LauncherAccessStatusSchema = z62.enum(["requested", "approved", "declined", "revoked"]);
-var LauncherAccessStateSchema = z62.enum([
+import { z as z63 } from "zod";
+var LauncherAccessStatusSchema = z63.enum(["requested", "approved", "declined", "revoked"]);
+var LauncherAccessStateSchema = z63.enum([
   "member",
   "requested",
   "declined",
@@ -8536,32 +8958,32 @@ var LauncherAccessStateSchema = z62.enum([
   "none"
 ]);
 var LAUNCHER_ACCESS_USE_CASE_MAX = 1e3;
-var LauncherAccessStatusResultSchema = z62.object({ state: LauncherAccessStateSchema, xLinked: z62.boolean() }).strict();
-var LauncherAccessRequestInputSchema = z62.object({
-  useCase: z62.string().trim().min(1).max(LAUNCHER_ACCESS_USE_CASE_MAX),
-  source: z62.string().trim().min(1).max(100).optional()
+var LauncherAccessStatusResultSchema = z63.object({ state: LauncherAccessStateSchema, xLinked: z63.boolean() }).strict();
+var LauncherAccessRequestInputSchema = z63.object({
+  useCase: z63.string().trim().min(1).max(LAUNCHER_ACCESS_USE_CASE_MAX),
+  source: z63.string().trim().min(1).max(100).optional()
 }).strict();
 
 // ../../packages/shared/dist/schemas/managed-unmetered.schemas.js
-import { z as z63 } from "zod";
-var id2 = z63.string().min(1).max(256);
-var TurnTraceUsageSchema = z63.object({
+import { z as z64 } from "zod";
+var id2 = z64.string().min(1).max(256);
+var TurnTraceUsageSchema = z64.object({
   sessionId: id2,
   turnId: id2,
-  spans: z63.number().int().nonnegative(),
+  spans: z64.number().int().nonnegative(),
   /** `chat` spans: the model calls the trace shows, finished or not. */
-  modelCalls: z63.number().int().nonnegative(),
+  modelCalls: z64.number().int().nonnegative(),
   rootOnly: AllowanceReportedUsageSchema.nullable(),
   total: AllowanceReportedUsageSchema.nullable(),
-  helpers: z63.array(z63.object({ subagentId: id2, usage: AllowanceReportedUsageSchema.nullable() }).strict()).max(256),
-  invalid: z63.boolean()
+  helpers: z64.array(z64.object({ subagentId: id2, usage: AllowanceReportedUsageSchema.nullable() }).strict()).max(256),
+  invalid: z64.boolean()
 }).strict();
 
 // ../../packages/shared/dist/schemas/hosted-credit-plans.schemas.js
-import { z as z65 } from "zod";
+import { z as z66 } from "zod";
 
 // ../../packages/shared/dist/schemas/hosted-subscription.schemas.js
-import { z as z64 } from "zod";
+import { z as z65 } from "zod";
 var STRIPE_ENVIRONMENTS = ["test", "live"];
 var STRIPE_CHECKOUT_STATUSES = ["open", "completed", "expired", "abandoned"];
 var STRIPE_SUBSCRIPTION_STATUSES = [
@@ -8574,42 +8996,42 @@ var STRIPE_SUBSCRIPTION_STATUSES = [
   "unpaid",
   "paused"
 ];
-var StripeCheckoutSessionSchema = z64.object({
-  operationId: z64.string(),
-  status: z64.enum(STRIPE_CHECKOUT_STATUSES),
-  url: z64.string().url().nullable(),
-  expiresAt: z64.string().datetime().nullable(),
-  reused: z64.boolean()
-});
-var StripePortalSessionSchema = z64.object({
-  url: z64.string().url(),
-  returnUrl: z64.string().url(),
-  configurationId: z64.string()
-});
-var StripeSubscriptionSummarySchema = z64.object({
-  asOf: z64.string().datetime(),
-  environment: z64.enum(STRIPE_ENVIRONMENTS),
-  planVersion: z64.string(),
-  hasCustomer: z64.boolean(),
-  subscription: z64.object({
-    status: z64.enum(STRIPE_SUBSCRIPTION_STATUSES),
-    cancelAtPeriodEnd: z64.boolean(),
-    currentPeriodStart: z64.string().datetime().nullable(),
-    currentPeriodEnd: z64.string().datetime().nullable(),
-    duplicateFlagged: z64.boolean()
+var StripeCheckoutSessionSchema = z65.object({
+  operationId: z65.string(),
+  status: z65.enum(STRIPE_CHECKOUT_STATUSES),
+  url: z65.string().url().nullable(),
+  expiresAt: z65.string().datetime().nullable(),
+  reused: z65.boolean()
+});
+var StripePortalSessionSchema = z65.object({
+  url: z65.string().url(),
+  returnUrl: z65.string().url(),
+  configurationId: z65.string()
+});
+var StripeSubscriptionSummarySchema = z65.object({
+  asOf: z65.string().datetime(),
+  environment: z65.enum(STRIPE_ENVIRONMENTS),
+  planVersion: z65.string(),
+  hasCustomer: z65.boolean(),
+  subscription: z65.object({
+    status: z65.enum(STRIPE_SUBSCRIPTION_STATUSES),
+    cancelAtPeriodEnd: z65.boolean(),
+    currentPeriodStart: z65.string().datetime().nullable(),
+    currentPeriodEnd: z65.string().datetime().nullable(),
+    duplicateFlagged: z65.boolean()
   }).nullable(),
   /** The furthest paid-until across unrevoked access periods; distinct from lifecycle state. */
-  paidUntil: z64.string().datetime().nullable(),
-  accessActive: z64.boolean(),
-  blockingReasons: z64.array(z64.object({
-    reason: z64.string(),
-    detail: z64.string()
+  paidUntil: z65.string().datetime().nullable(),
+  accessActive: z65.boolean(),
+  blockingReasons: z65.array(z65.object({
+    reason: z65.string(),
+    detail: z65.string()
   }))
 });
 
 // ../../packages/shared/dist/schemas/hosted-credit-plans.schemas.js
-var HostedCreditPlanIdSchema = z65.enum(["starter", "pro", "scale"]);
-var HostedCreditPackIdSchema = z65.enum(["credits_500", "credits_1000", "credits_2000"]);
+var HostedCreditPlanIdSchema = z66.enum(["starter", "pro", "scale"]);
+var HostedCreditPackIdSchema = z66.enum(["credits_500", "credits_1000", "credits_2000"]);
 var HOSTED_CREDIT_PLANS = Object.freeze({
   starter: {
     id: "starter",
@@ -8635,63 +9057,63 @@ var HOSTED_CREDIT_OPERATION_STATUSES = [
   "expired",
   "cancelled"
 ];
-var HostedCreditOperationStatusSchema = z65.enum(HOSTED_CREDIT_OPERATION_STATUSES);
-var HostedCreditPlanRefreshDeferralSchema = z65.enum([
+var HostedCreditOperationStatusSchema = z66.enum(HOSTED_CREDIT_OPERATION_STATUSES);
+var HostedCreditPlanRefreshDeferralSchema = z66.enum([
   "trial_reservation_held",
   "legacy_migration_required",
   "environment_ambiguous"
 ]);
-var HostedCreditChangeSchema = z65.object({
-  operationId: z65.string(),
+var HostedCreditChangeSchema = z66.object({
+  operationId: z66.string(),
   target: HostedCreditPlanIdSchema,
   status: HostedCreditOperationStatusSchema,
-  effectiveAt: z65.string().datetime(),
-  credits: z65.string(),
-  estimatedPriceMinorUnits: z65.number().int(),
-  paymentUrl: z65.string().url().nullable()
+  effectiveAt: z66.string().datetime(),
+  credits: z66.string(),
+  estimatedPriceMinorUnits: z66.number().int(),
+  paymentUrl: z66.string().url().nullable()
 });
-var HostedCreditCatalogSchema = z65.object({
+var HostedCreditCatalogSchema = z66.object({
   pendingTopup: StripeCheckoutSessionSchema.nullable(),
-  version: z65.string(),
-  enabled: z65.boolean(),
-  salesAvailable: z65.boolean(),
-  blockingReason: z65.string().nullable(),
-  plans: z65.array(z65.object({
+  version: z66.string(),
+  enabled: z66.boolean(),
+  salesAvailable: z66.boolean(),
+  blockingReason: z66.string().nullable(),
+  plans: z66.array(z66.object({
     id: HostedCreditPlanIdSchema,
-    name: z65.string(),
-    priceMinorUnits: z65.number().int(),
-    credits: z65.string(),
-    concurrency: z65.number().int(),
-    usdcMinorUnits: z65.string()
+    name: z66.string(),
+    priceMinorUnits: z66.number().int(),
+    credits: z66.string(),
+    concurrency: z66.number().int(),
+    usdcMinorUnits: z66.string()
   })),
-  packs: z65.array(z65.object({
+  packs: z66.array(z66.object({
     id: HostedCreditPackIdSchema,
-    priceMinorUnits: z65.number().int(),
-    credits: z65.string()
+    priceMinorUnits: z66.number().int(),
+    credits: z66.string()
   })),
   activePlan: HostedCreditPlanIdSchema.nullable(),
   /** Set when the paid plan could not be applied during this read; see the deferral schema. */
   planRefreshDeferred: HostedCreditPlanRefreshDeferralSchema.nullable().optional(),
   pendingChange: HostedCreditChangeSchema.nullable()
 });
-var HostedCreditUsageSchema = z65.object({
-  id: z65.string(),
-  agentName: z65.string().nullable(),
-  createdAt: z65.string().datetime(),
-  status: z65.enum(["held", "settled", "released"]),
-  rateCardVersion: z65.string(),
-  reserved: z65.string(),
-  charged: z65.string().nullable(),
-  restored: z65.string(),
+var HostedCreditUsageSchema = z66.object({
+  id: z66.string(),
+  agentName: z66.string().nullable(),
+  createdAt: z66.string().datetime(),
+  status: z66.enum(["held", "settled", "released"]),
+  rateCardVersion: z66.string(),
+  reserved: z66.string(),
+  charged: z66.string().nullable(),
+  restored: z66.string(),
   usage: AllowanceReportedUsageSchema.nullable(),
-  helperTurns: z65.number().int().nonnegative()
+  helperTurns: z66.number().int().nonnegative()
 });
 
 // ../../packages/shared/dist/schemas/routing-kill-switch.schemas.js
-import { z as z66 } from "zod";
-var ReasonSchema = z66.string().trim().min(1).max(500);
-var ActorSchema = z66.string().trim().min(1).max(200);
-var TimestampSchema = z66.string().datetime();
+import { z as z67 } from "zod";
+var ReasonSchema2 = z67.string().trim().min(1).max(500);
+var ActorSchema = z67.string().trim().min(1).max(200);
+var TimestampSchema = z67.string().datetime();
 var ROUTING_KILL_SWITCH_SOURCES = [
   /** Process configuration. Survives nothing being reachable, and cannot be released at runtime. */
   "environment",
@@ -8701,18 +9123,18 @@ var ROUTING_KILL_SWITCH_SOURCES = [
   "alert_action"
 ];
 var ROUTING_KILL_SWITCH_ACTION = "engage_routing_kill_switch";
-var RoutingKillSwitchDirectiveSchema = z66.object({
-  action: z66.literal(ROUTING_KILL_SWITCH_ACTION),
+var RoutingKillSwitchDirectiveSchema = z67.object({
+  action: z67.literal(ROUTING_KILL_SWITCH_ACTION),
   /** The alert id, so the record names the measurement that asked for the stop. */
-  alert: z66.string().trim().min(1).max(128),
-  reason: ReasonSchema,
+  alert: z67.string().trim().min(1).max(128),
+  reason: ReasonSchema2,
   raisedBy: ActorSchema,
   raisedAt: TimestampSchema
 }).strict();
-var RoutingKillSwitchStateSchema = z66.object({
-  engaged: z66.boolean(),
-  source: z66.enum(ROUTING_KILL_SWITCH_SOURCES).nullable(),
-  reason: ReasonSchema.nullable(),
+var RoutingKillSwitchStateSchema = z67.object({
+  engaged: z67.boolean(),
+  source: z67.enum(ROUTING_KILL_SWITCH_SOURCES).nullable(),
+  reason: ReasonSchema2.nullable(),
   engagedBy: ActorSchema.nullable(),
   engagedAt: TimestampSchema.nullable()
 }).strict().superRefine((state, ctx) => {
@@ -8737,12 +9159,12 @@ var ROUTING_KILL_SWITCH_RELEASED = Object.freeze({
 });
 
 // ../../packages/shared/dist/schemas/hosted-market-approval.schemas.js
-import { z as z67 } from "zod";
+import { z as z68 } from "zod";
 var HOSTED_MARKET_SCOPES = ["work", "publish", "judge"];
-var HostedMarketScopeSchema = z67.enum(HOSTED_MARKET_SCOPES);
-var HostedMarketScopesSchema = z67.array(HostedMarketScopeSchema).max(HOSTED_MARKET_SCOPES.length).refine((scopes) => new Set(scopes).size === scopes.length, "Duplicate market scopes");
-var HostedMarketAgentSettingsSchema = z67.object({
-  agentId: z67.string(),
+var HostedMarketScopeSchema = z68.enum(HOSTED_MARKET_SCOPES);
+var HostedMarketScopesSchema = z68.array(HostedMarketScopeSchema).max(HOSTED_MARKET_SCOPES.length).refine((scopes) => new Set(scopes).size === scopes.length, "Duplicate market scopes");
+var HostedMarketAgentSettingsSchema = z68.object({
+  agentId: z68.string(),
   scopes: HostedMarketScopesSchema,
   /** USDC base units an agent may lock in task rewards per window; '0' publishes nothing. */
   escrowLimit: SwarmUsdcAtomicAmountSchema,
@@ -8754,60 +9176,60 @@ var HostedMarketAgentSettingsSchema = z67.object({
   /** Of the rewards funded this window, how much refunds and earned rewards gave back. */
   escrowRestored: SwarmUsdcAtomicAmountSchema.optional()
 });
-var HostedMarketAgentSettingsInputSchema = z67.object({
-  agentId: z67.string().uuid(),
+var HostedMarketAgentSettingsInputSchema = z68.object({
+  agentId: z68.string().uuid(),
   scopes: HostedMarketScopesSchema,
   escrowLimit: SwarmUsdcAtomicAmountSchema
 }).strict();
 var HOSTED_MARKET_APPROVAL_TTL_MS = 30 * 6e4;
-var HostedMarketApprovalPreviewSchema = z67.object({
-  taskId: z67.string().nullable(),
-  title: z67.string().nullable(),
-  description: z67.string().nullable(),
-  mode: z67.string().nullable(),
+var HostedMarketApprovalPreviewSchema = z68.object({
+  taskId: z68.string().nullable(),
+  title: z68.string().nullable(),
+  description: z68.string().nullable(),
+  mode: z68.string().nullable(),
   /** USDC base units: the reward a create escrows, or the bid amount. */
-  reward: z67.string().nullable(),
-  deadline: z67.string().nullable()
-});
-var HostedMarketApprovalSchema = z67.object({
-  id: z67.string().uuid(),
-  agentId: z67.string(),
-  agentName: z67.string().nullable(),
-  jobId: z67.string().uuid().optional(),
-  action: z67.enum(HOSTED_MARKET_WRITE_ACTIONS),
-  status: z67.enum(SWARM_PURCHASE_APPROVAL_STATUSES),
-  code: z67.string().nullable(),
+  reward: z68.string().nullable(),
+  deadline: z68.string().nullable()
+});
+var HostedMarketApprovalSchema = z68.object({
+  id: z68.string().uuid(),
+  agentId: z68.string(),
+  agentName: z68.string().nullable(),
+  jobId: z68.string().uuid().optional(),
+  action: z68.enum(HOSTED_MARKET_WRITE_ACTIONS),
+  status: z68.enum(SWARM_PURCHASE_APPROVAL_STATUSES),
+  code: z68.string().nullable(),
   /** The agent's request key; the approved write runs under it, so it is idempotent. */
-  requestKey: z67.string().uuid(),
-  apiOrigin: z67.string().url(),
+  requestKey: z68.string().uuid(),
+  apiOrigin: z68.string().url(),
   /** The market x402 recipient, fixed when the owner approves. */
-  payTo: z67.string().regex(/^0x[0-9a-fA-F]{40}$/).nullable(),
+  payTo: z68.string().regex(/^0x[0-9a-fA-F]{40}$/).nullable(),
   /** The x402 price of the write, USDC base units. */
-  amount: z67.string().regex(/^[1-9][0-9]{0,17}$/),
+  amount: z68.string().regex(/^[1-9][0-9]{0,17}$/),
   /** The part of `amount` that funds a task reward (ADR-0187); '0' for a plain fee. */
-  escrowAmount: z67.string().regex(/^[0-9]{1,18}$/),
+  escrowAmount: z68.string().regex(/^[0-9]{1,18}$/),
   preview: HostedMarketApprovalPreviewSchema,
   /** The write's recorded outcome once it ran: completed, pending or failed. */
-  outcome: z67.enum(["completed", "pending", "failed"]).nullable(),
-  createdAt: z67.string(),
-  expiresAt: z67.string(),
-  decidedAt: z67.string().nullable()
+  outcome: z68.enum(["completed", "pending", "failed"]).nullable(),
+  createdAt: z68.string(),
+  expiresAt: z68.string(),
+  decidedAt: z68.string().nullable()
 });
-var HostedMarketApprovalListSchema = z67.object({
-  enabled: z67.boolean(),
-  approvals: z67.array(HostedMarketApprovalSchema)
+var HostedMarketApprovalListSchema = z68.object({
+  enabled: z68.boolean(),
+  approvals: z68.array(HostedMarketApprovalSchema)
 });
-var HostedMarketApprovalIdSchema = z67.object({ approvalId: z67.string().uuid() }).strict();
+var HostedMarketApprovalIdSchema = z68.object({ approvalId: z68.string().uuid() }).strict();
 var HostedMarketApprovalConfirmSchema = HostedMarketApprovalIdSchema.extend({
   consentTextVersion: SwarmConsentTextVersionSchema
 }).strict();
-var HostedMarketApprovalPreparedSchema = z67.object({
+var HostedMarketApprovalPreparedSchema = z68.object({
   approval: HostedMarketApprovalSchema,
   consent: SwarmConsentSchema
 });
 
 // ../../packages/shared/dist/schemas/market-wakeup.schemas.js
-import { z as z68 } from "zod";
+import { z as z69 } from "zod";
 var MARKET_WAKEUP_KINDS = [
   "pitch_selected",
   "bid_won",
@@ -8825,430 +9247,26 @@ var MARKET_WAKEUP_KINDS = [
   "claim_release_cost_rising",
   "new_task"
 ];
-var MarketWakeupKindSchema = z68.enum(MARKET_WAKEUP_KINDS);
+var MarketWakeupKindSchema = z69.enum(MARKET_WAKEUP_KINDS);
 var MARKET_WATCH_MODES = ["bounty", "claim", "pitch", "benchmark", "auction"];
-var MarketWatchModeSchema = z68.enum(MARKET_WATCH_MODES);
+var MarketWatchModeSchema = z69.enum(MARKET_WATCH_MODES);
 var MARKET_WATCH_MAX_WAKEUPS_PER_DAY = 48;
-var MarketWatchSchema = z68.object({
-  enabled: z68.boolean(),
-  modes: z68.array(MarketWatchModeSchema).max(MARKET_WATCH_MODES.length),
+var MarketWatchSchema = z69.object({
+  enabled: z69.boolean(),
+  modes: z69.array(MarketWatchModeSchema).max(MARKET_WATCH_MODES.length),
   /** Minimum reward in USDC, as a decimal string with at most six decimal places. */
-  minRewardUsdc: z68.string().regex(/^\d{1,12}(\.\d{1,6})?$/).default("0"),
+  minRewardUsdc: z69.string().regex(/^\d{1,12}(\.\d{1,6})?$/).default("0"),
   /** Case-insensitive; a task matches when its description or tags contain any keyword. */
-  keywords: z68.array(z68.string().trim().min(2).max(40)).max(10),
-  maxWakeupsPerDay: z68.number().int().min(1).max(MARKET_WATCH_MAX_WAKEUPS_PER_DAY)
+  keywords: z69.array(z69.string().trim().min(2).max(40)).max(10),
+  maxWakeupsPerDay: z69.number().int().min(1).max(MARKET_WATCH_MAX_WAKEUPS_PER_DAY)
 }).strict();
 var MarketWatchInputSchema = MarketWatchSchema.extend({
-  agentId: z68.string().uuid()
+  agentId: z69.string().uuid()
 }).strict();
 var MarketWatchViewSchema = MarketWatchSchema.extend({
-  agentId: z68.string().uuid(),
-  updatedAt: z68.string().nullable()
-});
-
-// ../../packages/shared/dist/schemas/memory.schemas.js
-import { z as z69 } from "zod";
-var MEMORY_DOCUMENT_MAX_BYTES = 65536;
-var MEMORY_ARCHIVE_RETENTION_DAYS = 30;
-var MEMORY_PATH_MAX_LENGTH = 200;
-var MEMORY_PATH_MAX_DEPTH = 6;
-var MEMORY_PATH_SEGMENT_MAX_BYTES = 100;
-var MEMORY_SEARCH_QUERY_MAX_LENGTH = 200;
-var MEMORY_SEARCH_MAX_RESULTS = 20;
-var MEMORY_HISTORY_MAX_RESULTS = 50;
-var MEMORY_REASON_MAX_LENGTH = 500;
-var MemoryScopeSchema = z69.enum(["agent", "swarm"]);
-var MemoryTrustSchema = z69.enum(["owner", "agent", "tainted"]);
-var MemoryRevisionStatusSchema = z69.enum(["applied", "proposed", "approved", "rejected"]);
-var MemoryActorSchema = z69.enum(["owner", "agent"]);
-var MemoryOperationSchema = z69.enum([
-  "create",
-  "replace",
-  "append",
-  "edit",
-  "archive",
-  "rollback",
-  "restore",
-  "promote"
-]);
-var MemoryWriteModeSchema = z69.enum(["replace", "append"]);
-var MemoryWriteOutcomeSchema = z69.enum(["applied", "proposed"]);
-var LauncherJobSourceSchema = z69.enum([
-  "dashboard",
-  "imessage",
-  "peer",
-  "schedule",
-  "wait",
-  "inbox",
-  // Implements: ADR-0182. A backend-owned job that executes an owner-approved purchase; it runs
-  // no model turn.
-  "purchase",
-  // ADR-0189. A market event relevant to the swarm wallet woke the responsible agent.
-  "market"
-]);
-var MEMORY_CORE_TEMPLATE_SECTIONS = [
-  "Owner",
-  "Preferences",
-  "Commitments",
-  "Open threads"
-];
-var MEMORY_CORE_TEMPLATE = MEMORY_CORE_TEMPLATE_SECTIONS.map((section2) => `## ${section2}
-`).join("\n");
-var MemoryCoreTemplateEnabledSchema = z69.enum(["true", "false"]).default("false").transform((value) => value === "true");
-function utf8ByteLength(value) {
-  let bytes2 = 0;
-  for (let i = 0; i < value.length; i++) {
-    const code = value.charCodeAt(i);
-    if (code < 128)
-      bytes2 += 1;
-    else if (code < 2048)
-      bytes2 += 2;
-    else if (code >= 55296 && code <= 56319 && i + 1 < value.length && (value.charCodeAt(i + 1) & 64512) === 56320) {
-      bytes2 += 4;
-      i++;
-    } else
-      bytes2 += 3;
-  }
-  return bytes2;
-}
-var SEGMENT = /^[\p{L}\p{N}][\p{L}\p{N} ._-]*$/u;
-var forbiddenPathCharacter = (value) => [...value].some((c) => {
-  const code = c.charCodeAt(0);
-  return code < 32 || code >= 127 && code <= 159 || c === "\\";
-});
-var memoryContentIsText = (value) => ![...value].some((c) => {
-  const code = c.charCodeAt(0);
-  return code < 32 && code !== 9 && code !== 10 && code !== 13 || code === 127;
-});
-function normalizeMemoryPath(raw) {
-  const value = raw.normalize("NFC").trim();
-  if (!value)
-    return { ok: false, reason: "Path is empty" };
-  if (forbiddenPathCharacter(value))
-    return { ok: false, reason: "Path contains control characters or backslashes" };
-  if (value.startsWith("/") || value.startsWith("~"))
-    return { ok: false, reason: "Path must be relative to its scope" };
-  const segments = value.split("/").filter((part) => part !== "" && part !== ".");
-  if (segments.some((part) => part === ".."))
-    return { ok: false, reason: 'Path must not contain ".."' };
-  if (!segments.length)
-    return { ok: false, reason: "Path is empty" };
-  if (segments.length > MEMORY_PATH_MAX_DEPTH)
-    return { ok: false, reason: `Path is deeper than ${MEMORY_PATH_MAX_DEPTH} segments` };
-  for (const part of segments) {
-    if (!SEGMENT.test(part) || part.endsWith(" ") || part.endsWith("."))
-      return {
-        ok: false,
-        reason: 'Path segments use letters, digits, spaces, ".", "-" and "_" and start with a letter or digit'
-      };
-    if (utf8ByteLength(part) > MEMORY_PATH_SEGMENT_MAX_BYTES)
-      return { ok: false, reason: "Path segment is too long" };
-  }
-  const path3 = segments.join("/");
-  if (path3.length > MEMORY_PATH_MAX_LENGTH)
-    return { ok: false, reason: "Path is too long" };
-  if (!path3.endsWith(".md"))
-    return { ok: false, reason: "Memory documents are markdown (.md)" };
-  return { ok: true, path: path3 };
-}
-var MemoryPathSchema = z69.string().max(MEMORY_PATH_MAX_LENGTH * 2).transform((raw, ctx) => {
-  const result = normalizeMemoryPath(raw);
-  if (!result.ok) {
-    ctx.addIssue({ code: "custom", message: result.reason });
-    return z69.NEVER;
-  }
-  return result.path;
-});
-var MemoryContentSchema = z69.string().max(MEMORY_DOCUMENT_MAX_BYTES).refine(memoryContentIsText, "Memory content must be text").refine((value) => utf8ByteLength(value) <= MEMORY_DOCUMENT_MAX_BYTES, `Memory documents are limited to ${MEMORY_DOCUMENT_MAX_BYTES} bytes`);
-var ReasonSchema2 = z69.string().trim().max(MEMORY_REASON_MAX_LENGTH).optional();
-var VersionSchema = z69.number().int().min(0).max(2147483647);
-var AgentIdSchema = z69.string().uuid();
-var target = {
-  agentId: AgentIdSchema.optional(),
-  scope: MemoryScopeSchema,
-  path: MemoryPathSchema
-};
-var agentScopeNeedsAgent = (value) => value.scope !== "agent" || Boolean(value.agentId);
-var agentScopeMessage = { message: "agentId is required for the agent scope", path: ["agentId"] };
-var MemoryTargetInputSchema = z69.object(target).strict().refine(agentScopeNeedsAgent, agentScopeMessage);
-var MemoryTreeInputSchema = z69.object({ agentId: AgentIdSchema.optional(), scope: MemoryScopeSchema.optional() }).strict().refine((value) => value.scope !== "agent" || Boolean(value.agentId), agentScopeMessage);
-var MemoryWriteInputSchema = z69.object({
-  ...target,
-  content: MemoryContentSchema,
-  mode: MemoryWriteModeSchema.default("replace"),
-  expectedVersion: VersionSchema.optional(),
-  reason: ReasonSchema2,
-  /**
-   * The owner was warned that the content looks like a secret (#713) and saves it anyway.
-   * Without it, a write that adds a seed phrase, private key or credential is refused.
-   */
-  confirmSecrets: z69.boolean().optional()
-}).strict().refine(agentScopeNeedsAgent, agentScopeMessage);
-var MemoryArchiveInputSchema = z69.object({ ...target, expectedVersion: VersionSchema.optional(), reason: ReasonSchema2 }).strict().refine(agentScopeNeedsAgent, agentScopeMessage);
-var MemoryHistoryInputSchema = z69.object({
-  ...target,
-  limit: z69.number().int().min(1).max(MEMORY_HISTORY_MAX_RESULTS).default(20),
-  beforeVersion: VersionSchema.optional()
-}).strict().refine(agentScopeNeedsAgent, agentScopeMessage);
-var MemoryRollbackInputSchema = z69.object({
-  ...target,
-  version: VersionSchema.min(1),
-  expectedVersion: VersionSchema.optional(),
-  reason: ReasonSchema2
-}).strict().refine(agentScopeNeedsAgent, agentScopeMessage);
-var MemorySearchInputSchema = z69.object({
-  agentId: AgentIdSchema.optional(),
-  scope: MemoryScopeSchema.optional(),
-  query: z69.string().trim().min(1).max(MEMORY_SEARCH_QUERY_MAX_LENGTH),
-  limit: z69.number().int().min(1).max(MEMORY_SEARCH_MAX_RESULTS).default(10),
-  /** Also search the agent's own past jobs (SM-61); needs `agentId`. */
-  includeHistory: z69.boolean().optional()
-}).strict().refine((value) => value.scope !== "agent" || Boolean(value.agentId), agentScopeMessage);
-var MemoryForgetInputSchema = z69.object({ agentId: AgentIdSchema.optional(), scope: MemoryScopeSchema, reason: ReasonSchema2 }).strict().refine(agentScopeNeedsAgent, agentScopeMessage);
-var MemoryPromoteInputSchema = z69.object({
-  agentId: AgentIdSchema,
-  scope: MemoryScopeSchema.default("agent"),
-  path: MemoryPathSchema,
-  targetPath: MemoryPathSchema.optional(),
-  expectedVersion: VersionSchema.optional(),
-  reason: ReasonSchema2
-}).strict();
-var MemoryDocumentSummarySchema = z69.object({
-  documentId: z69.string().uuid(),
-  scope: MemoryScopeSchema,
-  path: z69.string(),
-  version: z69.number().int(),
-  bytes: z69.number().int(),
-  pinned: z69.boolean(),
-  readOnly: z69.boolean(),
-  updatedAt: z69.string()
-});
-var MemoryTreeSchema = z69.object({
-  documents: z69.array(MemoryDocumentSummarySchema),
-  limits: z69.object({
-    documentBytes: z69.number().int(),
-    scopeDocuments: z69.number().int(),
-    pinnedRenderBytes: z69.number().int()
-  })
-});
-var MemoryDocumentSchema = MemoryDocumentSummarySchema.extend({
-  content: z69.string(),
-  createdAt: z69.string(),
-  archivedAt: z69.string().nullable(),
-  /** Actor and trust of the revision that produced the current content. */
-  lastActor: MemoryActorSchema.nullable(),
-  lastTrust: MemoryTrustSchema.nullable()
-});
-var MemoryRevisionSchema = z69.object({
-  id: z69.string().uuid(),
-  /** Null only for a proposal to create a document that does not exist (yet). */
-  documentId: z69.string().uuid().nullable(),
-  version: z69.number().int(),
-  content: z69.string(),
-  operation: MemoryOperationSchema,
-  status: MemoryRevisionStatusSchema,
-  actor: MemoryActorSchema,
-  actorAgentId: z69.string().nullable(),
-  jobId: z69.string().nullable(),
-  sessionId: z69.string().nullable(),
-  trust: MemoryTrustSchema,
-  /** Why an agent turn had this trust, e.g. the tool that tainted it (SM-51). */
-  trustReason: z69.string().nullable(),
-  reason: z69.string().nullable(),
-  sourceDocumentId: z69.string().uuid().nullable(),
-  sourceVersion: z69.number().int().nullable(),
-  createdAt: z69.string(),
-  decidedAt: z69.string().nullable()
-});
-var MemoryHistorySchema = z69.object({
-  document: MemoryDocumentSummarySchema.extend({ archivedAt: z69.string().nullable() }),
-  revisions: z69.array(MemoryRevisionSchema)
-});
-var MemoryMutationResultSchema = z69.object({
-  outcome: z69.literal("applied"),
-  document: MemoryDocumentSchema,
-  revision: MemoryRevisionSchema
-});
-var MemoryProposedResultSchema = z69.object({
-  outcome: z69.literal("proposed"),
-  scope: MemoryScopeSchema,
-  path: z69.string(),
-  /** The version the proposal was made against; 0 = the document does not exist. */
-  baseVersion: z69.number().int(),
-  document: MemoryDocumentSchema.nullable(),
-  revision: MemoryRevisionSchema
-});
-var MemoryHistoryHitSchema = z69.object({
-  jobId: z69.string(),
-  source: LauncherJobSourceSchema.nullable(),
-  status: z69.string(),
-  /** Trust of the job the text came from (its source, the tools its run called, tainted reads). */
-  trust: MemoryTrustSchema,
-  snippet: z69.string(),
-  score: z69.number(),
-  createdAt: z69.string(),
-  finishedAt: z69.string().nullable()
-});
-var MemorySearchResultSchema = z69.object({
-  results: z69.array(z69.object({
-    documentId: z69.string().uuid(),
-    scope: MemoryScopeSchema,
-    path: z69.string(),
-    version: z69.number().int(),
-    /** When the document last changed. */
-    updatedAt: z69.string(),
-    snippet: z69.string(),
-    score: z69.number(),
-    /** Trust of the revision that produced the current content. */
-    trust: MemoryTrustSchema.nullable()
-  })),
-  /** Present only when history was requested. */
-  history: z69.array(MemoryHistoryHitSchema).optional()
-});
-var MemoryForgetResultSchema = z69.object({ archived: z69.number().int() });
-var MemoryProposalsInputSchema = z69.object({ agentId: AgentIdSchema.optional(), scope: MemoryScopeSchema.optional() }).strict().refine((value) => value.scope !== "agent" || Boolean(value.agentId), agentScopeMessage);
-var MemoryProposalDecisionInputSchema = z69.object({ proposalId: z69.string().uuid() }).strict();
-var MemoryProposalSchema = z69.object({
-  id: z69.string().uuid(),
-  scope: MemoryScopeSchema,
-  /** The private scope's agent; null for the swarm scope. */
-  agentId: z69.string().nullable(),
-  path: z69.string(),
-  documentId: z69.string().uuid().nullable(),
-  operation: MemoryOperationSchema,
-  /** The full proposed content (for `archive`, the content that would be archived). */
-  content: z69.string(),
-  /** The document version the proposal was made against; 0 = the document did not exist. */
-  baseVersion: z69.number().int(),
-  /** The live document now, to diff against; null when there is none. */
-  current: z69.object({
-    version: z69.number().int(),
-    content: z69.string(),
-    lastTrust: MemoryTrustSchema.nullable()
-  }).nullable(),
-  /** The document changed since the proposal: approving it would conflict. */
-  stale: z69.boolean(),
-  actor: MemoryActorSchema,
-  actorAgentId: z69.string().nullable(),
-  trust: MemoryTrustSchema,
-  trustReason: z69.string().nullable(),
-  reason: z69.string().nullable(),
-  sessionId: z69.string().nullable(),
-  job: z69.object({
-    id: z69.string(),
-    /** The agent that ran the job: the proposer, or its creator for a seeded instructions.md. */
-    agentId: z69.string(),
-    source: LauncherJobSourceSchema.nullable(),
-    prompt: z69.string(),
-    createdAt: z69.string()
-  }).nullable(),
-  createdAt: z69.string(),
-  /**
-   * When the retention purge removes the proposal undecided, or null when it never does. Only
-   * proposals with no live document to wait on expire: one to create a document (the archive
-   * window after it was made) and one on a forgotten document (purged with that document).
-   */
-  expiresAt: z69.string().nullable(),
-  /** `expiresAt` is within MEMORY_PROPOSAL_EXPIRY_WARNING_DAYS. */
-  expiresSoon: z69.boolean()
-});
-var MemoryProposalListSchema = z69.object({ proposals: z69.array(MemoryProposalSchema) });
-var MemoryProposalSummaryInputSchema = z69.object({}).strict();
-var MemoryProposalCountSchema = z69.object({
-  pending: z69.number().int(),
-  /** Pending proposals flagged `expiresSoon`. */
-  expiringSoon: z69.number().int()
-});
-var MemoryProposalSummarySchema = MemoryProposalCountSchema.extend({
-  /** Proposals to shared memory: every agent's Memory tab lists them. */
-  swarm: MemoryProposalCountSchema,
-  /**
-   * Proposals to each agent's private memory, for agents that have any. An agent's Memory tab
-   * lists its own and the shared ones.
-   */
-  agents: z69.array(MemoryProposalCountSchema.extend({ agentId: z69.string() }))
-});
-var MemoryProposalRejectionSchema = z69.object({ revision: MemoryRevisionSchema });
-var MemoryArchivedInputSchema = z69.object({ agentId: AgentIdSchema.optional(), scope: MemoryScopeSchema }).strict().refine(agentScopeNeedsAgent, agentScopeMessage);
-var MemoryArchivedDocumentSchema = z69.object({
-  documentId: z69.string().uuid(),
-  scope: MemoryScopeSchema,
-  path: z69.string(),
-  /** The archive revision's version; restoring rolls back to it (its content is the last text). */
-  version: z69.number().int(),
-  bytes: z69.number().int(),
-  pinned: z69.boolean(),
-  archivedAt: z69.string(),
-  /** When the hard purge removes it for good. */
-  purgeAt: z69.string()
-});
-var MemoryArchivedListSchema = z69.object({
-  documents: z69.array(MemoryArchivedDocumentSchema)
-});
-var MemoryExportInputSchema = z69.object({ cursor: z69.string().min(1).max(512).optional() }).strict();
-var MemoryExportDocumentSchema = z69.object({
-  documentId: z69.string().uuid(),
-  scope: MemoryScopeSchema,
-  /** The private scope's agent; null for shared memory. */
-  agentId: z69.string().nullable(),
-  path: z69.string(),
-  /** `live` is what agents read now; `forgotten` is archived and purged at `purgeAt`. */
-  status: z69.enum(["live", "forgotten"]),
-  pinned: z69.boolean(),
-  version: z69.number().int(),
-  bytes: z69.number().int(),
-  /** The current text, or the last text of a forgotten document. */
-  content: z69.string(),
-  createdAt: z69.string(),
-  updatedAt: z69.string(),
-  archivedAt: z69.string().nullable(),
-  purgeAt: z69.string().nullable()
+  agentId: z69.string().uuid(),
+  updatedAt: z69.string().nullable()
 });
-var MemoryExportRevisionSchema = MemoryRevisionSchema.extend({
-  scope: MemoryScopeSchema,
-  agentId: z69.string().nullable(),
-  path: z69.string()
-});
-var MemoryExportPageSchema = z69.object({
-  /** The owner's agents, to name each private scope. */
-  agents: z69.array(z69.object({ agentId: z69.string(), name: z69.string() })),
-  /** Documents first seen on this page; their revisions may continue on later pages. */
-  documents: z69.array(MemoryExportDocumentSchema),
-  revisions: z69.array(MemoryExportRevisionSchema),
-  nextCursor: z69.string().nullable()
-});
-var ToolPathSchema = z69.string().min(1).max(MEMORY_PATH_MAX_LENGTH * 2);
-var ToolReasonSchema = z69.string().trim().min(1).max(MEMORY_REASON_MAX_LENGTH);
-var MemoryToolInputSchemas = {
-  memory_view: z69.object({
-    scope: MemoryScopeSchema.optional(),
-    path: ToolPathSchema.optional(),
-    offset: z69.number().int().min(0).max(MEMORY_DOCUMENT_MAX_BYTES).optional()
-  }).strict(),
-  memory_search: z69.object({
-    query: z69.string().trim().min(1).max(MEMORY_SEARCH_QUERY_MAX_LENGTH),
-    scope: MemoryScopeSchema.optional(),
-    limit: z69.number().int().min(1).max(MEMORY_SEARCH_MAX_RESULTS).optional(),
-    /** Also search this agent's own past jobs (SM-61). */
-    include_history: z69.boolean().optional()
-  }).strict(),
-  memory_write: z69.object({
-    scope: MemoryScopeSchema.optional(),
-    path: ToolPathSchema,
-    content: z69.string().max(MEMORY_DOCUMENT_MAX_BYTES),
-    mode: MemoryWriteModeSchema.optional(),
-    expected_version: VersionSchema.optional()
-  }).strict(),
-  memory_edit: z69.object({
-    scope: MemoryScopeSchema.optional(),
-    path: ToolPathSchema,
-    old_text: z69.string().min(1).max(MEMORY_DOCUMENT_MAX_BYTES),
-    new_text: z69.string().max(MEMORY_DOCUMENT_MAX_BYTES),
-    expected_version: VersionSchema
-  }).strict(),
-  memory_delete: z69.object({ scope: MemoryScopeSchema.optional(), path: ToolPathSchema, reason: ToolReasonSchema }).strict()
-};
-var MEMORY_TOOL_NAMES = Object.keys(MemoryToolInputSchemas);
 
 // ../../packages/shared/dist/schemas/memory-secrets.schemas.js
 import { sha256 } from "viem";