apps 0.0.1-beta.4 → 0.0.1-beta.40

package/js/{chunk-6VRYO2BG.js → chunk-SALJXSS3.js}

@@ -1,24 +1,42 @@
 import {
   makeCache
-} from "./chunk-D47C7KG5.js";
+} from "./chunk-RIXVGVA6.js";
+import {
+  accountSecrets,
+  boundFailureMessage,
+  describeFailure,
+  failureDetail,
+  leavingProviderError,
+  parseMcpError,
+  parseSkillLoadFailed,
+  readCatalog,
+  routerSkills
+} from "./chunk-4TLZGG4B.js";
+import {
+  appInvocationFetch
+} from "./chunk-KIM5HXNK.js";
 import {
   folderSkillsEffect
-} from "./chunk-FDNTX5QJ.js";
+} from "./chunk-CQD3WSYH.js";
 import {
-  authorDatabase,
+  ResponseStatusError,
   isApp,
-  toEffectApp,
-  unavailableStorage
-} from "./chunk-DHUDODG5.js";
+  toEffectApp
+} from "./chunk-XDGUGB2A.js";
 import {
+  declaredOperations,
   fromPromise,
+  locate,
   nativeOperation,
   toPromise
-} from "./chunk-PYUYJRSK.js";
+} from "./chunk-6KABJTDO.js";
 import {
+  accountProviderError,
+  httpProviderError,
   parseProviderError
-} from "./chunk-ZJWDMTE3.js";
+} from "./chunk-EM4UL26F.js";
 import {
+  AccountCheckResult,
   DeclaredProvider,
   DeclaredRequirements,
   ElicitationFailed,
@@ -29,6 +47,7 @@ import {
   HostError,
   HostEvaluationFailed,
   HostInputInvalid,
+  HostKindMismatch,
   HostOperationFailed,
   HostOperationNotFound,
   HostOutputInvalid,
@@ -38,6 +57,7 @@ import {
   HostToolBlocked,
   HostToolNotFound,
   HostToolPolicyFailed,
+  HostedRouter,
   HostedTool,
   HostedToolSummary,
   HostedWebhook,
@@ -45,9 +65,8 @@ import {
   InvocationDeadline,
   ManualWebhookSetup,
   ManyAccounts,
-  McpError,
   NonRetryableError,
-  OperationToolPrefixes,
+  OpenapiResponseError,
   ResolvedAccounts,
   ToolResultObservation,
   TrustedToolApproval,
@@ -61,44 +80,48 @@ import {
   approvalElicitation,
   defaultWebhookTransportLimits,
   maxInputProblems,
+  migrationsDirectory,
+  reservedTablePrefix,
   workflowDurationMillis
-} from "./chunk-3M2MEDNL.js";
+} from "./chunk-OTCLXFLL.js";
 import {
   CacheError
-} from "./chunk-LGIYBDWA.js";
+} from "./chunk-P7MGDPFD.js";
 import {
   AppSkills,
-  SkillFile,
-  SkillLoadFailed
-} from "./chunk-YEJOQEII.js";
-import {
-  OpenapiResponseError
-} from "./chunk-SWPD52J7.js";
+  SkillFile
+} from "./chunk-UOZMSUJ2.js";
 import {
-  captureTelemetry,
-  invocationFetch
-} from "./chunk-ZCAMUXSG.js";
+  captureTelemetry
+} from "./chunk-PNVCCB4L.js";
 import {
+  allowedValues,
   decoderOf,
+  echoableKey,
   importedJsonSchema,
-  jsonSchemaDecoder
-} from "./chunk-WFSQXYUT.js";
+  jsonSchemaDecoder,
+  jsonSchemaDocument,
+  maxAlternativeKeys,
+  objectShape,
+  unionShape
+} from "./chunk-GHXRRFZA.js";
 import {
   JsonObject,
   JsonValue
-} from "./chunk-SATWJKN6.js";
+} from "./chunk-YQ35E7KS.js";
 import {
+  Base64_exports,
   Cause_exports,
   Clock_exports,
   Effect_exports,
-  Encoding_exports,
   Match_exports,
   Option_exports,
   Redacted_exports,
+  SchemaAST_exports,
   SchemaIssue_exports,
   Schema_exports,
   Stream_exports
-} from "./chunk-FW5HBOIK.js";
+} from "./chunk-MXDKXAY4.js";
 
 // src/implementation/elicitation.ts
 var prepareElicitation = (input) => Effect_exports.gen(function* () {
@@ -139,19 +162,29 @@ var makeElicit = (handler, signal) => toPromise(
 var ApprovalDecision = Schema_exports.Literals(["approved", "denied", "user-approval"]);
 
 // src/implementation/workflow-context.ts
-var workflowSafe = (work) => work.pipe(
+var workflowSafe = (work, secrets) => work.pipe(
   Effect_exports.catchCause((cause) => {
     if (Cause_exports.hasInterrupts(cause)) return Effect_exports.interrupt;
     const error = Cause_exports.squash(cause);
     if (Schema_exports.is(WorkflowFailure)(error)) return Effect_exports.fail(error);
+    const { errorName, message } = failureDetail(error, secrets);
     return Effect_exports.fail(
       new WorkflowFailure({
         reason: "execution",
-        retryable: !(error instanceof NonRetryableError)
+        retryable: !(error instanceof NonRetryableError),
+        ...errorName === void 0 ? {} : { errorName },
+        ...message === void 0 ? {} : { message }
       })
     );
   })
 );
+var inStep = (step) => (failure) => failure.step === void 0 ? new WorkflowFailure({
+  reason: failure.reason,
+  retryable: failure.retryable,
+  step: step.slice(0, 200),
+  ...failure.errorName === void 0 ? {} : { errorName: failure.errorName },
+  ...failure.message.length === 0 ? {} : { message: failure.message }
+}) : failure;
 var makeWorkflowContext = (execution, definition, fresh, signal) => Effect_exports.gen(function* () {
   const services = yield* Effect_exports.context();
   const counts = /* @__PURE__ */ new Map();
@@ -206,25 +239,33 @@ var makeWorkflowContext = (execution, definition, fresh, signal) => Effect_expor
               Effect_exports.sync(() => new AbortController()),
               (controller2) => Effect_exports.sync(() => controller2.abort())
             );
-            const ctx = yield* fresh(stepId, AbortSignal.any([signal, controller.signal]));
+            const step2 = yield* fresh(stepId, AbortSignal.any([signal, controller.signal]));
             const result = yield* workflowSafe(
-              Effect_exports.tryPromise({ try: () => callback(ctx), catch: (error) => error })
+              Effect_exports.tryPromise({
+                try: () => callback(step2.context),
+                catch: (error) => error
+              }),
+              step2.secrets
             );
             return yield* Schema_exports.decodeUnknownEffect(WorkflowValue)(result).pipe(
               Effect_exports.mapError(
-                () => new WorkflowFailure({ reason: "output", retryable: false })
+                () => new WorkflowFailure({
+                  reason: "output",
+                  retryable: false,
+                  message: "The step returned a value that is not JSON, such as undefined, or is larger than 1 MiB. Return null for no result."
+                })
               )
             );
           })
         ).pipe(Effect_exports.provideContext(services))
       )
-    );
+    ).pipe(Effect_exports.mapError(inStep(name)));
   });
   const operationStep = (kind, name, operation, input, options) => Effect_exports.gen(function* () {
     const target = nativeOperation(operation);
-    const catalog = kind === "query" ? definition.queries : definition.mutations;
-    const match = Object.entries(catalog ?? {}).find(
-      ([, value]) => value === target && value.kind === kind
+    const root = definition.tools?.kind === "router" ? definition.tools : void 0;
+    const match = declaredOperations(root).find(
+      (entry) => entry.operation === target && entry.operation.kind === kind
     );
     if (target === void 0 || match === void 0)
       return yield* new WorkflowFailure({ reason: "operation", retryable: false });
@@ -243,9 +284,9 @@ var makeWorkflowContext = (execution, definition, fresh, signal) => Effect_expor
       parsed,
       () => attempt(
         parsed,
-        execution.invoke({ kind, name: match[0], input: args, stepId, timeout }).pipe(Effect_exports.provideContext(services))
+        execution.invoke({ kind, name: match.name, input: args, stepId, timeout }).pipe(Effect_exports.provideContext(services))
       )
-    );
+    ).pipe(Effect_exports.mapError(inStep(name)));
   });
   const invoke = (effect) => toPromise(() => effect.pipe(Effect_exports.provideContext(services)), signal)();
   const step = {
@@ -284,14 +325,91 @@ var makeWorkflowContext = (execution, definition, fresh, signal) => Effect_expor
 });
 
 // src/implementation/input-problems.ts
-var leafHook = (issue) => SchemaIssue_exports.hasInput(issue) ? "Invalid value" : SchemaIssue_exports.defaultLeafHook(issue);
+var nativeObjectShape = (ast, limit) => objectShape(
+  ast.propertySignatures.flatMap(
+    ({ name, type }) => typeof name === "string" ? [{ name, optional: SchemaAST_exports.isOptional(SchemaAST_exports.toEncoded(type)) }] : []
+  ),
+  ast.indexSignatures.length > 0,
+  limit
+);
+var unionMembers = (ast) => SchemaAST_exports.isUnion(ast) ? ast.types.flatMap(unionMembers) : SchemaAST_exports.isUndefined(ast) || SchemaAST_exports.isVoid(ast) ? [] : [ast];
+var fixedValues = (ast) => {
+  if (SchemaAST_exports.isLiteral(ast)) return [ast.literal];
+  if (SchemaAST_exports.isEnum(ast)) return ast.enums.map(([, value]) => value);
+  if (!SchemaAST_exports.isUnion(ast)) return void 0;
+  const members = unionMembers(ast).map(fixedValues);
+  return members.length > 0 && members.every((values) => values !== void 0) ? members.flat() : void 0;
+};
+var describeMember = (ast) => Match_exports.value(ast).pipe(
+  Match_exports.when(
+    SchemaAST_exports.isObjects,
+    (objects) => objects.propertySignatures.length > 0 ? nativeObjectShape(objects, maxAlternativeKeys) : "object"
+  ),
+  Match_exports.when(SchemaAST_exports.isArrays, () => "array"),
+  Match_exports.when(SchemaAST_exports.isTemplateLiteral, () => "a string matching a template"),
+  Match_exports.when(SchemaAST_exports.isString, () => "string"),
+  Match_exports.when(SchemaAST_exports.isNumber, () => "number"),
+  Match_exports.when(SchemaAST_exports.isBoolean, () => "boolean"),
+  Match_exports.when(SchemaAST_exports.isNull, () => "null"),
+  Match_exports.orElse(() => "a value with other constraints")
+);
+var memberSelector = (members) => {
+  const [first] = members;
+  if (members.length < 2 || first === void 0 || !SchemaAST_exports.isObjects(first)) return void 0;
+  return first.propertySignatures.map(({ name }) => name).find(
+    (name) => typeof name === "string" && members.every(
+      (member) => SchemaAST_exports.isObjects(member) && member.propertySignatures.some(
+        (property) => property.name === name && fixedValues(SchemaAST_exports.toEncoded(property.type)) !== void 0
+      )
+    )
+  );
+};
+var expectedUnion = (ast) => {
+  const members = unionMembers(ast);
+  const fixed = members.map(fixedValues);
+  const values = fixed.flatMap((memberValues) => memberValues === void 0 ? [] : memberValues);
+  const others = members.filter((_, index) => fixed[index] === void 0);
+  if (others.length === 0) return `Expected ${allowedValues(values)}`;
+  return `Expected ${unionShape(
+    [
+      ...values.length === 0 ? [] : [allowedValues(values)],
+      ...new Set(others.map(describeMember))
+    ],
+    memberSelector(members)
+  )}`;
+};
+var leafHook = (issue) => SchemaIssue_exports.hasInput(issue) ? "Invalid value" : Match_exports.value(issue).pipe(
+  Match_exports.tag("InvalidType", ({ ast }) => {
+    const values = fixedValues(ast);
+    return values !== void 0 ? `Expected ${allowedValues(values)}` : SchemaAST_exports.isObjects(ast) && ast.propertySignatures.length > 0 ? `Expected ${nativeObjectShape(ast)}` : SchemaIssue_exports.defaultLeafHook(issue);
+  }),
+  Match_exports.orElse(SchemaIssue_exports.defaultLeafHook)
+);
 var checkHook = (issue) => SchemaIssue_exports.hasInput(issue) || SchemaIssue_exports.hasInput(issue.issue) ? SchemaIssue_exports.defaultCheckHook(issue) ?? "Invalid value" : SchemaIssue_exports.defaultCheckHook(issue);
 var format = SchemaIssue_exports.makeFormatterStandardSchemaV1({ leafHook, checkHook });
-var segment = (key) => typeof key === "number" ? `[${key}]` : typeof key === "string" && /^[A-Za-z_$][\w$-]{0,63}$/.test(key) ? `.${key}` : "[key]";
+var located = (issue, path) => Match_exports.value(issue).pipe(
+  Match_exports.tag("Pointer", (pointer) => located(pointer.issue, [...path, ...pointer.path])),
+  Match_exports.tag("Composite", ({ issues }) => issues.flatMap((issue2) => located(issue2, path))),
+  Match_exports.tag("Encoding", (encoding) => located(encoding.issue, path)),
+  Match_exports.tag(
+    "AnyOf",
+    ({ ast, issues }) => issues.length === 0 ? [{ path, message: expectedUnion(ast) }] : issues.flatMap((issue2) => located(issue2, path))
+  ),
+  Match_exports.orElse(
+    (issue2) => format(issue2).issues.map((problem) => ({
+      path: [
+        ...path,
+        ...(problem.path ?? []).map((key) => typeof key === "object" ? key.key : key)
+      ],
+      message: problem.message
+    }))
+  )
+);
+var segment = (key) => typeof key === "number" ? `[${key}]` : typeof key === "string" && echoableKey(key) ? `.${key}` : "[key]";
 var inputInvalid = (error) => {
   if (!Schema_exports.isSchemaError(error)) return new HostInputInvalid();
-  const problems = format(error.issue).issues.slice(0, maxInputProblems).map(({ path, message }) => {
-    const location = (path ?? []).map((key) => segment(typeof key === "object" ? key.key : key));
+  const problems = located(error.issue, []).slice(0, maxInputProblems).map(({ path, message }) => {
+    const location = path.map(segment);
     return `${location.length === 0 ? "input" : `input${location.join("")}`}: ${message}`.slice(
       0,
       512
@@ -399,7 +517,7 @@ var dispatchWebhook = (definition, command, context, accounts) => Effect_exports
     yield* invoke(hook.unregister, { ...input, state });
     return null;
   }
-  const body = yield* Effect_exports.fromResult(Encoding_exports.decodeBase64(command.request.body)).pipe(
+  const body = yield* Effect_exports.fromResult(Base64_exports.decode(command.request.body)).pipe(
     Effect_exports.mapError(() => new HostInputInvalid())
   );
   if (body.byteLength > defaultWebhookTransportLimits.maxBodyBytes)
@@ -448,12 +566,339 @@ var dispatchWebhook = (definition, command, context, accounts) => Effect_exports
     () => Schema_exports.decodeUnknownEffect(WebhookResponseData)({
       status: response.status,
       headers,
-      body: Encoding_exports.encodeBase64(new Uint8Array(bytes))
+      body: Base64_exports.encode(new Uint8Array(bytes))
     }),
     new HostOutputInvalid()
   );
 });
 
+// src/implementation/sql.ts
+var receipts = `${reservedTablePrefix}step_receipts`;
+var migrationsTable = `${reservedTablePrefix}migrations`;
+var legacyRows = `${reservedTablePrefix}legacy_rows`;
+var materialize = (cursor) => {
+  const rows = cursor.toArray();
+  return {
+    columnNames: cursor.columnNames,
+    rowsRead: cursor.rowsRead,
+    rowsWritten: cursor.rowsWritten,
+    toArray: () => [...rows],
+    one: () => {
+      if (rows.length !== 1)
+        throw new Error(`Expected exactly one row, but the statement returned ${rows.length}.`);
+      return rows[0];
+    },
+    [Symbol.iterator]: () => rows[Symbol.iterator]()
+  };
+};
+var isThenable = (value) => (typeof value === "object" || typeof value === "function") && value !== null && "then" in value && typeof value.then === "function";
+var missingDatabase = () => {
+  throw new Error(
+    `This app has no database. Add its first migration, such as ${migrationsDirectory}/0001_create_notes.sql with a CREATE TABLE statement, and deploy again.`
+  );
+};
+var noDatabase = { exec: missingDatabase, transaction: missingDatabase };
+var settings = [
+  "foreign_keys",
+  "defer_foreign_keys",
+  "ignore_check_constraints",
+  "legacy_alter_table",
+  "recursive_triggers",
+  "reverse_unordered_selects"
+];
+var readSettings = (storage) => new Map(
+  settings.map((name) => [name, Number(storage.sql.exec(`PRAGMA ${name}`).toArray()[0]?.[name])])
+);
+var changedSetting = (storage, baseline) => {
+  const current = readSettings(storage);
+  return settings.find((name) => current.get(name) !== baseline.get(name));
+};
+var restoreSettings = (storage, baseline) => {
+  const current = readSettings(storage);
+  for (const [name, value] of baseline)
+    if (current.get(name) !== value) storage.sql.exec(`PRAGMA ${name} = ${value}`);
+  storage.sql.exec("PRAGMA case_sensitive_like = OFF");
+};
+var ReadRolledBack = class extends Error {
+};
+var authorSql = (storage, options) => {
+  let closed = false;
+  const live = () => {
+    if (closed || options.signal.aborted)
+      throw new Error("This call has ended, so its ctx.sql no longer runs statements.");
+  };
+  let open = false;
+  let transactions = 0;
+  const baseline = readSettings(storage);
+  const checkSettings = () => {
+    const changed = changedSetting(storage, baseline);
+    if (changed !== void 0)
+      throw refuse(
+        new Error(
+          `SQLite connection settings belong to Executor, so app code cannot change PRAGMA ${changed}; the statement was rolled back. Migrations may change settings while they run.`
+        )
+      );
+  };
+  const changes = () => Number(storage.sql.exec("SELECT total_changes() AS n").toArray()[0]?.n);
+  let violation;
+  const refuse = (error) => {
+    if (open) violation ??= error;
+    return error;
+  };
+  const run = (query, bindings, mode) => {
+    try {
+      return runStatement(query, bindings, mode);
+    } finally {
+      restoreSettings(storage, baseline);
+    }
+  };
+  const runStatement = (query, bindings, mode) => {
+    live();
+    if (mode === "write") {
+      const statement = () => {
+        const cursor = materialize(storage.sql.exec(query, ...bindings));
+        checkSettings();
+        return cursor;
+      };
+      if (!open) return storage.transactionSync(statement);
+      try {
+        return statement();
+      } catch (error) {
+        refuse(error instanceof Error ? error : new Error(String(error)));
+        throw error;
+      }
+    }
+    if (open) {
+      return runStatement(query, bindings, "write");
+    }
+    const before = changes();
+    let read;
+    let changed = false;
+    try {
+      storage.transactionSync(() => {
+        read = materialize(storage.sql.exec(query, ...bindings));
+        changed = changes() !== before;
+        checkSettings();
+        throw new ReadRolledBack();
+      });
+    } catch (error) {
+      if (!(error instanceof ReadRolledBack)) throw error;
+    }
+    if (changed || read === void 0)
+      throw new Error(
+        options.step !== void 0 ? "A workflow step mutation writes only inside ctx.sql.transaction(...), so a retried step applies its writes once." : "Queries are read-only. Change data from a mutation."
+      );
+    return read;
+  };
+  const reader = {
+    exec: (query, ...bindings) => run(query, bindings, "read")
+  };
+  const transactionHandle = () => {
+    let active = true;
+    const tx = {
+      exec: (query, ...bindings) => {
+        if (!active)
+          throw new Error("This transaction has ended, so its tx no longer runs statements.");
+        return run(query, bindings, "write");
+      }
+    };
+    return {
+      tx,
+      end: () => {
+        active = false;
+      }
+    };
+  };
+  const transaction = (work) => {
+    live();
+    if (open) throw new Error("ctx.sql.transaction(...) cannot be nested.");
+    const step = options.step;
+    if (step !== void 0 && transactions > 0)
+      throw new Error(
+        "A workflow step mutation opens at most one ctx.sql.transaction(...), which records the step's result."
+      );
+    transactions += 1;
+    violation = void 0;
+    const handle = transactionHandle();
+    return storage.transactionSync(() => {
+      open = true;
+      try {
+        const complete = () => {
+          const value = work(handle.tx);
+          if (isThenable(value))
+            throw new Error(
+              "ctx.sql.transaction(...) callbacks are synchronous and cannot await. Call outside services before or after the transaction."
+            );
+          if (violation !== void 0) throw violation;
+          return value;
+        };
+        if (step === void 0) return complete();
+        storage.sql.exec(
+          `CREATE TABLE IF NOT EXISTS ${receipts} (id TEXT PRIMARY KEY, fingerprint TEXT NOT NULL, result TEXT NOT NULL) WITHOUT ROWID`
+        );
+        const saved = storage.sql.exec(`SELECT fingerprint, result FROM ${receipts} WHERE id = ?`, step.key).toArray()[0];
+        if (saved !== void 0) {
+          if (saved.fingerprint !== step.fingerprint)
+            throw new Error("This workflow step already ran with different input.");
+          return JSON.parse(String(saved.result));
+        }
+        const encoded = JSON.stringify(complete() ?? null);
+        storage.sql.exec(
+          `INSERT INTO ${receipts} (id, fingerprint, result) VALUES (?, ?, ?)`,
+          step.key,
+          step.fingerprint,
+          encoded
+        );
+        return JSON.parse(encoded);
+      } finally {
+        open = false;
+        handle.end();
+      }
+    });
+  };
+  const writer = {
+    // A step's writes go through its one transaction, which also records its receipt.
+    exec: (query, ...bindings) => run(query, bindings, options.step ? "read" : "write"),
+    transaction
+  };
+  return {
+    reader,
+    writer,
+    close: () => {
+      closed = true;
+    }
+  };
+};
+var MigrationFileInvalid = class extends Schema_exports.TaggedError()(
+  "MigrationFileInvalid",
+  { path: Schema_exports.String, reason: Schema_exports.String }
+) {
+  get message() {
+    return `${this.path}: ${this.reason}`;
+  }
+};
+var MigrationHistoryChanged = class extends Schema_exports.TaggedError()(
+  "MigrationHistoryChanged",
+  { reason: Schema_exports.String }
+) {
+  get message() {
+    return `${this.reason} Applied migrations cannot change: restore the original file and add a new migration instead. Nothing was applied; the previous deployment is still active.`;
+  }
+};
+var MigrationFailed = class extends Schema_exports.TaggedError()("MigrationFailed", {
+  path: Schema_exports.String,
+  reason: Schema_exports.String
+}) {
+  get message() {
+    return `${this.path} failed: ${this.reason}. No migrations were applied; the previous deployment is still active.`;
+  }
+};
+var migrationName = /^(\d+)_[A-Za-z0-9_-]+\.sql$/;
+var sha256 = (text) => Effect_exports.promise(() => crypto.subtle.digest("SHA-256", new TextEncoder().encode(text))).pipe(
+  Effect_exports.map(
+    (digest) => Array.from(new Uint8Array(digest), (byte) => byte.toString(16).padStart(2, "0")).join("")
+  )
+);
+var hasMigrations = (files) => files.some(
+  (file) => file.path.startsWith(`${migrationsDirectory}/`) && file.path.endsWith(".sql")
+);
+var migrationsOf = (files) => Effect_exports.gen(function* () {
+  const found = [];
+  for (const file of files) {
+    if (!file.path.startsWith(`${migrationsDirectory}/`) || !file.path.endsWith(".sql")) continue;
+    const name = file.path.slice(migrationsDirectory.length + 1);
+    const match = migrationName.exec(name);
+    if (name.includes("/") || match === null)
+      return yield* new MigrationFileInvalid({
+        path: file.path,
+        reason: "migrations are files directly in migrations/ named like 0001_create_notes.sql: a number that orders them, an underscore, then a name."
+      });
+    const content = file.content.replaceAll("\r\n", "\n");
+    found.push({
+      path: file.path,
+      order: Number(match[1]),
+      content,
+      hash: yield* sha256(content)
+    });
+  }
+  const ordered = [...found].sort((left, right) => left.order - right.order);
+  for (const [index, migration] of ordered.entries()) {
+    const previous = ordered[index - 1];
+    if (previous !== void 0 && previous.order === migration.order)
+      return yield* new MigrationFileInvalid({
+        path: migration.path,
+        reason: `it has the same number as ${previous.path}; give each migration its own number.`
+      });
+  }
+  return ordered;
+});
+var History = Schema_exports.Array(
+  Schema_exports.Struct({ id: Schema_exports.Number, path: Schema_exports.String, hash: Schema_exports.String })
+);
+var migrate = (storage, files) => Effect_exports.gen(function* () {
+  const migrations = yield* migrationsOf(files);
+  const baseline = readSettings(storage);
+  return yield* Effect_exports.sync(
+    () => storage.transactionSync(() => {
+      storage.sql.exec(
+        `CREATE TABLE IF NOT EXISTS ${migrationsTable} (id INTEGER PRIMARY KEY, path TEXT NOT NULL, hash TEXT NOT NULL, applied_at TEXT NOT NULL)`
+      );
+      const stored = storage.sql.exec("SELECT 1 FROM sqlite_master WHERE type = 'table' AND name = 'app_rows'").toArray().length > 0;
+      storage.sql.exec(`DROP VIEW IF EXISTS ${legacyRows}`);
+      storage.sql.exec(
+        `CREATE VIEW ${legacyRows} (table_name, id, body) AS ${stored ? "SELECT table_name, id, body FROM app_rows" : "SELECT '', '', '' WHERE 0"}`
+      );
+      const history = Schema_exports.decodeUnknownSync(History)(
+        storage.sql.exec(`SELECT id, path, hash FROM ${migrationsTable} ORDER BY id`).toArray()
+      );
+      for (const [index, applied] of history.entries()) {
+        const current = migrations[index];
+        if (current === void 0)
+          throw new MigrationHistoryChanged({
+            reason: `${applied.path} was applied to this app's database but is no longer in migrations/.`
+          });
+        if (current.path !== applied.path)
+          throw new MigrationHistoryChanged({
+            reason: `Migration ${index + 1} was applied as ${applied.path}, but the build has ${current.path} in its place.`
+          });
+        if (current.hash !== applied.hash)
+          throw new MigrationHistoryChanged({
+            reason: `${applied.path} changed after it was applied to this app's database.`
+          });
+      }
+      const pending = migrations.slice(history.length);
+      const appliedAt = (/* @__PURE__ */ new Date()).toISOString();
+      for (const [offset, migration] of pending.entries()) {
+        try {
+          storage.sql.exec(migration.content);
+        } catch (error) {
+          throw new MigrationFailed({
+            path: migration.path,
+            reason: error instanceof Error ? error.message : String(error)
+          });
+        }
+        storage.sql.exec(
+          `INSERT INTO ${migrationsTable} (id, path, hash, applied_at) VALUES (?, ?, ?, ?)`,
+          history.length + offset + 1,
+          migration.path,
+          migration.hash,
+          appliedAt
+        );
+      }
+      return pending.map((migration, offset) => ({
+        id: history.length + offset + 1,
+        name: migration.path
+      }));
+    })
+  ).pipe(
+    // Both are thrown inside the transaction so that it rolls back; they are expected failures.
+    Effect_exports.catchDefect(
+      (defect) => Schema_exports.is(MigrationFailed)(defect) || Schema_exports.is(MigrationHistoryChanged)(defect) ? Effect_exports.fail(defect) : Effect_exports.die(defect)
+    ),
+    Effect_exports.ensuring(Effect_exports.sync(() => restoreSettings(storage, baseline)))
+  );
+});
+
 // src/implementation/cache.ts
 var unavailableCache = {
   transport: () => Effect_exports.fail(new CacheError({ reason: "unavailable" })),
@@ -469,7 +914,7 @@ var authorCache = (host, accounts, signal, deadline) => {
       ...options.staleFor === void 0 ? {} : { staleFor: options.staleFor },
       load: Effect_exports.acquireUseRelease(
         Effect_exports.sync(() => new AbortController()),
-        (controller) => invocationFetch(controller.signal).pipe(
+        (controller) => appInvocationFetch(controller.signal).pipe(
           Effect_exports.flatMap(
             (fetch) => fromPromise(options.load)({
               fetch,
@@ -523,6 +968,10 @@ var authorCache = (host, accounts, signal, deadline) => {
 };
 
 // src/implementation/host.ts
+var WireCatalog = Schema_exports.Struct({
+  tools: Schema_exports.Array(Schema_exports.Union([HostedTool, HostedToolSummary])),
+  routers: Schema_exports.Array(HostedRouter)
+});
 function safe2(work, failure) {
   return Effect_exports.suspend(work).pipe(
     Effect_exports.catchCause(
@@ -530,30 +979,39 @@ function safe2(work, failure) {
     )
   );
 }
-var evaluationSafe = (work) => work.pipe(
+var evaluationSafe = (work, secrets) => work.pipe(
   Effect_exports.catchCause((cause) => {
     if (Cause_exports.hasInterrupts(cause)) return Effect_exports.interrupt;
     const error = Cause_exports.squash(cause);
     const provider = parseProviderError(error);
     const skills = parseSkillLoadFailed(error);
-    const mcp = parseMcpError(error);
+    const mcp = parseMcpError(error, secrets);
     return Effect_exports.fail(
-      Option_exports.isSome(provider) ? provider.value : Option_exports.isSome(skills) ? skills.value : Option_exports.isSome(mcp) ? mcp.value : new HostEvaluationFailed()
+      Option_exports.isSome(provider) ? leavingProviderError(provider.value, secrets, "discover") : Option_exports.isSome(skills) ? skills.value : Option_exports.isSome(mcp) ? mcp.value : new HostEvaluationFailed(failureDetail(error, secrets))
     );
   })
 );
-function jsonSchema(decoder) {
-  const imported = importedJsonSchema(decoder);
-  if (imported !== void 0) return Schema_exports.decodeUnknownEffect(JsonObject)(imported);
-  const document = Schema_exports.toJsonSchemaDocument(decoder);
-  return Schema_exports.decodeUnknownEffect(JsonObject)({
-    ...document.schema,
-    $defs: document.definitions,
-    $schema: "https://json-schema.org/draft/2020-12/schema"
-  });
+var declarationInvalid = (summary, cause, secrets = []) => new HostDeclarationInvalid({
+  source: "app",
+  errorName: "HostDeclarationInvalid",
+  message: boundFailureMessage(
+    cause === void 0 ? summary : `${summary}: ${describeFailure(cause)}`,
+    secrets
+  )
+});
+var declarationSafe = (work, summary) => Effect_exports.suspend(work).pipe(
+  Effect_exports.catchCause(
+    (cause) => Cause_exports.hasInterrupts(cause) ? Effect_exports.interrupt : Effect_exports.fail(declarationInvalid(summary, Cause_exports.squash(cause)))
+  )
+);
+function declaredExposure(exposure) {
+  const named = (kind) => Object.entries(exposure ?? {}).filter(([, value]) => value === kind).map(([field]) => field).sort();
+  const plain = named("plain");
+  const raw = named("raw");
+  return { ...plain.length === 0 ? {} : { plain }, ...raw.length === 0 ? {} : { raw } };
 }
 function providerDeclaration(provider) {
-  return safe2(
+  return declarationSafe(
     () => Effect_exports.gen(function* () {
       const auth = /* @__PURE__ */ new Map();
       for (const [name, method] of Object.entries(provider.auth)) {
@@ -562,42 +1020,50 @@ function providerDeclaration(provider) {
             auth.set(name, {
               type: "secrets",
               label: method.label,
-              fields: yield* jsonSchema(method.fields)
+              fields: yield* jsonSchemaDocument(method.fields),
+              ...declaredExposure(method.exposure)
             });
             break;
           case "oauth2":
             auth.set(name, {
               type: "oauth2",
               ...method.config,
-              response: yield* jsonSchema(method.response)
+              response: yield* jsonSchemaDocument(method.response),
+              ...declaredExposure(method.exposure)
             });
             break;
         }
       }
       return yield* Schema_exports.decodeUnknownEffect(DeclaredProvider)({
         name: provider.name,
-        auth: Object.fromEntries(auth)
+        auth: Object.fromEntries(auth),
+        // Order and repetition carry no meaning, so neither changes the provider's identity.
+        ...provider.hosts === void 0 ? {} : { hosts: [...new Set(provider.hosts)].sort() }
       });
     }),
-    new HostDeclarationInvalid()
+    `Account provider "${provider.name}" has an invalid declaration`
   );
 }
-function requirements(slots, database) {
+function requirements(slots, sql) {
   return Effect_exports.gen(function* () {
     const accounts = /* @__PURE__ */ new Map();
     for (const [slot, selection] of Object.entries(slots)) {
+      const provider = selection instanceof ManyAccounts ? selection.provider : selection;
       accounts.set(slot, {
         cardinality: selection instanceof ManyAccounts ? "many" : "one",
-        definition: yield* providerDeclaration(
-          selection instanceof ManyAccounts ? selection.provider : selection
-        )
+        definition: yield* providerDeclaration(provider),
+        ...provider.health === void 0 ? {} : { health: true }
       });
     }
     return yield* Schema_exports.decodeUnknownEffect(DeclaredRequirements)({
       accounts: Object.fromEntries(accounts),
       capabilities: { skills: true, toolIndex: true, skillSources: true, scheduledTools: true },
-      ...database === void 0 ? {} : { database }
-    }).pipe(Effect_exports.mapError(() => new HostDeclarationInvalid()));
+      ...sql ? { sql: true } : {}
+    }).pipe(
+      Effect_exports.mapError(
+        (cause) => declarationInvalid("The app's account declarations are invalid", cause)
+      )
+    );
   });
 }
 function canonical(value) {
@@ -607,6 +1073,9 @@ function canonical(value) {
   }
   return JSON.stringify(value);
 }
+function withoutHosts({ hosts: _hosts, ...provider }) {
+  return provider;
+}
 function bindAccounts(slots, declarations, context) {
   return safe2(
     () => Effect_exports.gen(function* () {
@@ -632,7 +1101,7 @@ function bindAccounts(slots, declarations, context) {
         for (const account of accounts) {
           if (ids.has(account.id)) return yield* Effect_exports.fail(new HostAccountsInvalid());
           ids.add(account.id);
-          if (canonical(account.provider) !== canonical(requirement.definition) || !Object.hasOwn(provider.auth, account.method))
+          if (canonical(withoutHosts(account.provider)) !== canonical(withoutHosts(requirement.definition)) || !Object.hasOwn(provider.auth, account.method))
             return yield* Effect_exports.fail(new HostAccountsInvalid());
           const method = provider.auth[account.method];
           if (method === void 0) return yield* Effect_exports.fail(new HostAccountsInvalid());
@@ -653,22 +1122,95 @@ function bindAccounts(slots, declarations, context) {
     new HostAccountsInvalid()
   );
 }
+var fetchLifetime = (signal, background) => Effect_exports.acquireRelease(
+  Effect_exports.sync(() => {
+    const controller = new AbortController();
+    let refreshes = 0;
+    let ended = false;
+    const settle = () => {
+      if (ended && refreshes === 0) controller.abort();
+    };
+    const end = () => {
+      ended = true;
+      settle();
+    };
+    signal.addEventListener("abort", end, { once: true });
+    if (signal.aborted) end();
+    const settled = Effect_exports.sync(() => {
+      refreshes -= 1;
+      settle();
+    });
+    return {
+      signal: controller.signal,
+      close: () => {
+        signal.removeEventListener("abort", end);
+        end();
+      },
+      /** Counted from the hand-off, so a refresh that has not started yet keeps the fetch. */
+      background: (task) => Effect_exports.suspend(() => {
+        refreshes += 1;
+        return background(task.pipe(Effect_exports.ensuring(settled))).pipe(
+          Effect_exports.onError(() => settled)
+        );
+      })
+    };
+  }),
+  (lifetime) => Effect_exports.sync(lifetime.close)
+);
 function dispatch(app, request, context, signal) {
   return Effect_exports.scoped(
     Effect_exports.gen(function* () {
-      if (!isApp(app)) return yield* Effect_exports.fail(new HostDeclarationInvalid());
+      if (!isApp(app))
+        return yield* Effect_exports.fail(
+          declarationInvalid("The app module's default export is not an app created by defineApp")
+        );
       const native = toEffectApp(app);
-      const declared = yield* requirements(native.accounts, native.database?.schema);
+      const secrets = accountSecrets(context.accounts);
+      const ownsSql = hasMigrations(context.files ?? []);
+      const declared = yield* requirements(native.accounts, ownsSql);
       if (request.operation === "requirements")
         return yield* safe2(
           () => Schema_exports.decodeUnknownEffect(JsonValue)(declared),
           new HostDeclarationInvalid()
         );
+      if (request.operation === "migrate") {
+        if (!ownsSql) return yield* new HostOperationNotFound();
+        const storage2 = context.storage;
+        if (storage2 === void 0)
+          return yield* new HostOperationFailed(
+            failureDetail(new Error("This host gave the app no SQL storage."), secrets)
+          );
+        const sources = yield* Schema_exports.decodeUnknownEffect(Schema_exports.Array(SkillFile))(
+          context.files ?? []
+        ).pipe(Effect_exports.mapError(() => new HostDeclarationInvalid()));
+        const applied = yield* migrate(storage2, sources).pipe(
+          Effect_exports.mapError((error) => new HostOperationFailed(failureDetail(error, secrets))),
+          Effect_exports.withSpan("app.sql.migrate")
+        );
+        return yield* safe2(
+          () => Schema_exports.decodeUnknownEffect(JsonValue)(applied),
+          new HostOutputInvalid()
+        );
+      }
       const lifetime = yield* Effect_exports.acquireRelease(
         Effect_exports.sync(() => new AbortController()),
         (controller) => Effect_exports.sync(() => controller.abort())
       );
       const invocationSignal = AbortSignal.any([signal, lifetime.signal]);
+      const storage = context.storage;
+      const sqlSession = (step) => !ownsSql ? Effect_exports.succeed({ reader: noDatabase, writer: noDatabase }) : storage === void 0 ? Effect_exports.fail(
+        new HostOperationFailed(
+          failureDetail(new Error("This host gave the app no SQL storage."), secrets)
+        )
+      ) : Effect_exports.acquireRelease(
+        Effect_exports.sync(
+          () => authorSql(storage, {
+            signal: invocationSignal,
+            ...step === void 0 ? {} : { step }
+          })
+        ),
+        (session2) => Effect_exports.sync(session2.close)
+      );
       const deadline = context.deadline === void 0 ? void 0 : yield* safe2(
         () => Schema_exports.decodeUnknownEffect(InvocationDeadline)(context.deadline),
         new HostInputInvalid()
@@ -689,10 +1231,18 @@ function dispatch(app, request, context, signal) {
           return yield* new WorkflowFailure({ reason: "engine", retryable: true });
         return result;
       });
+      if (request.operation === "account-check")
+        return yield* checkAccount(
+          native.accounts,
+          declared,
+          request.requirement,
+          context,
+          invocationSignal,
+          deadline
+        ).pipe(withinDeadline);
       let running;
-      let transactionOpen = false;
       const delivery = (request2, signal2) => Effect_exports.suspend(
-        () => transactionOpen ? Effect_exports.fail(new ElicitationFailed({ reason: "transaction" })) : running !== void 0 && context.elicitation !== void 0 ? context.elicitation(request2, signal2).pipe(
+        () => running !== void 0 && context.elicitation !== void 0 ? context.elicitation(request2, signal2).pipe(
           Effect_exports.withSpan("app.tool.elicitation"),
           Effect_exports.provideContext(running.context)
         ) : Effect_exports.fail(new ElicitationFailed({ reason: "unavailable" }))
@@ -725,6 +1275,7 @@ function dispatch(app, request, context, signal) {
       ).pipe(Effect_exports.mapError(() => new HostDeclarationInvalid()));
       let cacheCommands = 0;
       const hostCache = context.cache ?? unavailableCache;
+      const fetching = yield* fetchLifetime(signal, hostCache.background);
       const bound = {
         cache: authorCache(
           {
@@ -732,7 +1283,8 @@ function dispatch(app, request, context, signal) {
             transport: (command) => {
               cacheCommands += 1;
               return hostCache.transport(command);
-            }
+            },
+            background: fetching.background
           },
           Redacted_exports.value(context.accounts),
           invocationSignal,
@@ -744,37 +1296,43 @@ function dispatch(app, request, context, signal) {
         ),
         workflows: workflowReads,
         signal: invocationSignal,
-        fetch: yield* invocationFetch(invocationSignal),
+        fetch: yield* appInvocationFetch(fetching.signal),
         elicit: makeElicit(delivery, invocationSignal)
       };
-      const definition = yield* evaluationSafe(native.evaluate(bound)).pipe(
+      const definition = yield* evaluationSafe(native.evaluate(bound), secrets).pipe(
         Effect_exports.withSpan("app.evaluate")
       );
       if (request.operation === "skills") {
         const declared2 = definition.skills ?? (yield* folderSkillsEffect({ files }).pipe(
           Effect_exports.mapError(() => new HostDeclarationInvalid())
         ));
-        const source2 = definition.dynamicSkills;
+        const source = definition.dynamicSkills;
         const before = cacheCommands;
-        const dynamic = source2 === void 0 ? [] : yield* evaluationSafe(Effect_exports.suspend(source2.list)).pipe(
+        const dynamic = source === void 0 ? [] : yield* evaluationSafe(Effect_exports.suspend(source.list), secrets).pipe(
           Effect_exports.withSpan("app.skills.load")
         );
-        const cached = source2 !== void 0 && cacheCommands > before;
-        const skills = yield* Schema_exports.decodeUnknownEffect(AppSkills)([...declared2, ...dynamic]).pipe(
-          Effect_exports.mapError(() => new HostDeclarationInvalid())
-        );
-        return request.sources === true ? { skills, dynamic: source2 !== void 0, cached } : skills;
+        const cached = source !== void 0 && cacheCommands > before;
+        const authored = new Set([...declared2, ...dynamic].map((skill) => skill.name));
+        const routed = (yield* routerSkills(definition.tools).pipe(
+          Effect_exports.withSpan("app.skills.routers")
+        )).filter((skill) => !authored.has(skill.name));
+        const skills = yield* Schema_exports.decodeUnknownEffect(AppSkills)([
+          ...declared2,
+          ...dynamic,
+          ...routed
+        ]).pipe(Effect_exports.mapError(() => new HostDeclarationInvalid()));
+        return request.sources === true ? { skills, dynamic: source !== void 0, cached } : skills;
       }
       if (request.operation === "workflows") {
         return yield* Effect_exports.forEach(
           Object.entries(definition.workflows ?? {}),
-          ([name2, entry]) => safe2(
+          ([name, entry]) => safe2(
             () => Effect_exports.gen(function* () {
               return yield* Schema_exports.decodeUnknownEffect(HostedWorkflow)({
-                name: name2,
+                name,
                 ...entry.description === void 0 ? {} : { description: entry.description },
-                inputSchema: yield* jsonSchema(entry.input),
-                ...entry.output === void 0 ? {} : { outputSchema: yield* jsonSchema(entry.output) }
+                inputSchema: yield* jsonSchemaDocument(entry.input),
+                ...entry.output === void 0 ? {} : { outputSchema: yield* jsonSchemaDocument(entry.output) }
               });
             }),
             new HostDeclarationInvalid()
@@ -807,111 +1365,64 @@ function dispatch(app, request, context, signal) {
               new WorkflowFailure({ reason: "credentials", retryable: false })
             );
             return {
-              ...accounts,
-              cache: authorCache(
-                context.cache ?? unavailableCache,
-                Redacted_exports.value(current.accounts),
-                signal2
-              ),
-              files,
-              fetch: yield* invocationFetch(signal2),
-              signal: signal2,
-              runId: execution.runId,
-              stepId,
-              idempotencyKey: stepId
+              context: {
+                ...accounts,
+                cache: authorCache(
+                  context.cache ?? unavailableCache,
+                  Redacted_exports.value(current.accounts),
+                  signal2
+                ),
+                files,
+                fetch: yield* appInvocationFetch(signal2),
+                signal: signal2,
+                runId: execution.runId,
+                stepId,
+                idempotencyKey: stepId
+              },
+              // The resolved values, not the app's decoded fields, which may be `Redacted`.
+              secrets: accountSecrets(current.accounts)
             };
           }),
           invocationSignal
         );
-        const output = yield* workflowSafe(entry.run(workflowContext, input2));
+        const output = yield* workflowSafe(entry.run(workflowContext, input2), secrets);
         const outputSchema = entry.output;
         const decoded = outputSchema === void 0 ? output : yield* safe2(
           () => Schema_exports.decodeUnknownEffect(outputSchema)(output),
-          new WorkflowFailure({ reason: "output", retryable: false })
+          new WorkflowFailure({
+            reason: "output",
+            retryable: false,
+            message: "The workflow's result does not match its declared output schema."
+          })
         );
         return yield* safe2(
           () => Schema_exports.decodeUnknownEffect(WorkflowValue)(decoded),
-          new WorkflowFailure({ reason: "output", retryable: false })
+          new WorkflowFailure({
+            reason: "output",
+            retryable: false,
+            message: "The workflow returned a value that is not JSON, such as undefined, or is larger than 1 MiB. Return null for no result."
+          })
         );
       }
       if (request.operation === "inspect") {
         const summary = request.detail === "summary";
-        const wanted = request.tools === void 0 ? void 0 : new Set(request.tools);
-        const metadata = [];
-        for (const [prefix, readOnly, catalog2] of [
-          [OperationToolPrefixes.query, true, definition.queries],
-          [OperationToolPrefixes.mutate, false, definition.mutations]
-        ]) {
-          for (const [name2, operation] of Object.entries(catalog2 ?? {})) {
-            if (wanted !== void 0 && !wanted.has(`${prefix}${name2}`)) continue;
-            const schedules = Object.entries(definition.schedules ?? {}).filter(([, schedule]) => schedule.tool === `${prefix}${name2}`).map(([name3, { tool: _tool, ...schedule }]) => ({ name: name3, ...schedule }));
-            if (request.scheduled === true && schedules.length === 0) continue;
-            metadata.push(
-              yield* safe2(
-                () => Effect_exports.gen(function* () {
-                  const fields = {
-                    name: `${prefix}${name2}`,
-                    schedules,
-                    description: operation.description ?? `${readOnly ? "Query" : "Mutate"} ${name2}`,
-                    ...operation.title === void 0 ? {} : { title: operation.title },
-                    readOnly,
-                    annotations: { ...operation.annotations, readOnlyHint: readOnly }
-                  };
-                  if (summary)
-                    return yield* Schema_exports.decodeUnknownEffect(HostedToolSummary)(fields);
-                  return yield* Schema_exports.decodeUnknownEffect(HostedTool)({
-                    ...fields,
-                    inputSchema: yield* jsonSchema(operation.input),
-                    ...operation.output === void 0 ? operation.outputSchema === void 0 ? {} : { outputSchema: operation.outputSchema } : { outputSchema: yield* jsonSchema(operation.output) },
-                    ...operation._meta === void 0 ? {} : { _meta: operation._meta }
-                  });
-                }),
-                new HostDeclarationInvalid()
-              )
-            );
-          }
-        }
-        const dynamic = request.scheduled === true ? void 0 : definition.dynamicTools;
-        if (dynamic !== void 0 && (wanted === void 0 || metadata.length < wanted.size)) {
-          const declared2 = new Set(metadata.map((tool2) => tool2.name));
-          const discover = () => {
-            if (summary && dynamic.summaries !== void 0) return dynamic.summaries();
-            if (wanted !== void 0 && dynamic.describe !== void 0) {
-              const describe = dynamic.describe;
-              return Effect_exports.forEach(
-                [...wanted].filter((name2) => !declared2.has(name2)),
-                (name2) => describe(name2),
-                { concurrency: "unbounded" }
-              ).pipe(Effect_exports.map((tools) => tools.filter((tool2) => tool2 !== void 0)));
-            }
-            return dynamic.list();
-          };
-          const discovered = yield* evaluationSafe(discover()).pipe(
-            Effect_exports.flatMap(
-              (value) => safe2(
-                () => summary ? Schema_exports.decodeUnknownEffect(Schema_exports.Array(HostedToolSummary))(value) : Schema_exports.decodeUnknownEffect(Schema_exports.Array(HostedTool))(value),
-                new HostDeclarationInvalid()
-              )
-            )
-          );
-          const names = new Set(declared2);
-          for (const tool2 of discovered) {
-            const readOnly = tool2.name.startsWith(OperationToolPrefixes.query);
-            if (!readOnly && !tool2.name.startsWith(OperationToolPrefixes.mutate) || tool2.name === OperationToolPrefixes.query || tool2.name === OperationToolPrefixes.mutate || names.has(tool2.name))
-              return yield* new HostDeclarationInvalid();
-            names.add(tool2.name);
-            if (wanted !== void 0 && !wanted.has(tool2.name)) continue;
-            metadata.push({
-              ...tool2,
-              readOnly,
-              annotations: { ...tool2.annotations, readOnlyHint: readOnly }
-            });
-          }
-        }
-        return metadata;
+        const catalog = yield* readCatalog(definition.tools, {
+          summary,
+          secrets,
+          ...request.tools === void 0 ? {} : { wanted: new Set(request.tools) },
+          ...request.scheduled === true ? { scheduled: true } : {},
+          schedules: (name) => Object.entries(definition.schedules ?? {}).filter(([, schedule]) => schedule.tool === name).map(([name2, { tool: _tool, ...schedule }]) => ({ name: name2, ...schedule }))
+        }).pipe(Effect_exports.withSpan("app.catalog.read"));
+        return yield* safe2(
+          () => Schema_exports.encodeEffect(WireCatalog)(catalog).pipe(
+            Effect_exports.flatMap(Schema_exports.decodeUnknownEffect(JsonValue))
+          ),
+          new HostDeclarationInvalid()
+        );
       }
       if (request.operation === "webhook-complete" || request.operation === "webhook-validate" || request.operation === "webhooks" || request.operation === "webhook-register" || request.operation === "webhook-handle" || request.operation === "webhook-unregister") {
-        const executeWebhook = (db) => dispatchWebhook(
+        const session2 = yield* sqlSession();
+        return yield* dispatchWebhook(
           definition,
           request,
           {
@@ -921,36 +1432,20 @@ function dispatch(app, request, context, signal) {
             workflows: workflowControls,
             signal: bound.signal,
             fetch: bound.fetch,
-            ...db === void 0 || native.database === void 0 ? {} : {
-              db: authorDatabase(native.database.tables, db, invocationSignal, true)
-            }
+            sql: session2.writer
           },
           Redacted_exports.value(context.accounts)
         );
-        if (native.database === void 0 || !["webhook-register", "webhook-handle", "webhook-unregister"].includes(request.operation))
-          return yield* executeWebhook();
-        const storage2 = context.storage ?? unavailableStorage;
-        return yield* storage2.mutate(native.database.schema, executeWebhook).pipe(
-          Effect_exports.catchTags({
-            AppDatabaseError: () => Effect_exports.fail(new HostOperationFailed()),
-            AppStorageUnavailable: () => Effect_exports.fail(new HostOperationFailed()),
-            AppStorageError: () => Effect_exports.fail(new HostOperationFailed())
-          })
-        );
       }
-      const kind = request.operation === "call" ? request.tool.startsWith(OperationToolPrefixes.query) ? "query" : request.tool.startsWith(OperationToolPrefixes.mutate) ? "mutate" : void 0 : request.operation;
-      if (kind === void 0) return yield* new HostToolNotFound();
-      const name = request.operation === "call" ? request.tool.slice(OperationToolPrefixes[kind].length) : request.name;
-      const toolName = `${OperationToolPrefixes[kind]}${name}`;
-      const catalog = kind === "query" ? definition.queries : definition.mutations;
-      const declaredTool = catalog !== void 0 && Object.hasOwn(catalog, name) ? catalog[name] : void 0;
-      const source = definition.dynamicTools;
-      const resolvedTool = source === void 0 || declaredTool !== void 0 ? void 0 : yield* evaluationSafe(source.resolve(toolName));
-      const tool = declaredTool ?? resolvedTool;
-      if (tool !== void 0 && tool.kind !== (kind === "query" ? "query" : "mutation"))
-        return yield* new HostDeclarationInvalid();
+      const toolName = request.operation === "call" ? request.tool : request.name;
+      const location = locate(definition.tools, toolName);
+      const tool = location === void 0 ? void 0 : location.kind === "operation" ? location.operation : yield* evaluationSafe(location.source.resolve(location.name), secrets);
       if (tool === void 0)
         return yield* request.operation === "call" ? new HostToolNotFound() : new HostOperationNotFound();
+      const requested = request.operation === "call" ? request.kind : request.operation === "query" ? "query" : "mutation";
+      if (requested !== void 0 && tool.kind !== requested)
+        return yield* new HostKindMismatch({ tool: toolName, requested, actual: tool.kind });
+      const kind = tool.kind === "query" ? "query" : "mutate";
       const input = yield* Effect_exports.suspend(
         () => Schema_exports.decodeUnknownEffect(tool.input)(request.input)
       ).pipe(
@@ -1000,24 +1495,22 @@ function dispatch(app, request, context, signal) {
           Match_exports.exhaustive
         );
       }
-      const execute = (db) => Effect_exports.gen(function* () {
-        transactionOpen = db !== void 0;
+      const replay = context.replay === void 0 ? void 0 : yield* safe2(
+        () => Schema_exports.decodeUnknownEffect(WorkflowReplay)(context.replay),
+        new HostInputInvalid()
+      );
+      if (replay !== void 0 && kind !== "mutate") return yield* new HostInputInvalid();
+      const session = yield* sqlSession(replay);
+      const execute = () => Effect_exports.gen(function* () {
         const output = yield* Effect_exports.gen(function* () {
           running = yield* captureTelemetry;
-          const fetch = yield* invocationFetch(invocationSignal);
+          const fetch = yield* appInvocationFetch(fetching.signal);
           return yield* tool.run(
             {
               ...bound,
               fetch,
               workflows: kind === "mutate" ? workflowControls : workflowReads,
-              ...db === void 0 || native.database === void 0 ? {} : {
-                db: authorDatabase(
-                  native.database.tables,
-                  db,
-                  invocationSignal,
-                  kind === "mutate"
-                )
-              }
+              sql: kind === "mutate" ? session.writer : session.reader
             },
             input
           );
@@ -1032,14 +1525,15 @@ function dispatch(app, request, context, signal) {
             const error = Cause_exports.squash(cause);
             const provider = parseProviderError(error);
             const response = Schema_exports.decodeUnknownOption(OpenapiResponseError)(error);
+            const mcp = parseMcpError(error, secrets);
             const failure = Schema_exports.decodeUnknownOption(ElicitationFailed)(error);
             return Effect_exports.fail(
-              Option_exports.isSome(provider) ? provider.value : Option_exports.isSome(response) ? new OpenapiResponseError({
+              Option_exports.isSome(provider) ? leavingProviderError(provider.value, secrets, "call") : Option_exports.isSome(response) ? new OpenapiResponseError({
                 code: response.value.code,
                 status: response.value.status,
                 message: response.value.message,
                 ...response.value.recovery === void 0 ? {} : { recovery: response.value.recovery }
-              }) : Option_exports.isSome(failure) ? failure.value : new HostOperationFailed()
+              }) : Option_exports.isSome(mcp) ? mcp.value : Option_exports.isSome(failure) ? failure.value : new HostOperationFailed(failureDetail(error, secrets))
             );
           }),
           Effect_exports.withSpan("app.operation.execute", {
@@ -1056,42 +1550,56 @@ function dispatch(app, request, context, signal) {
           new HostOutputInvalid()
         );
       });
-      const replay = context.replay === void 0 ? void 0 : yield* safe2(
-        () => Schema_exports.decodeUnknownEffect(WorkflowReplay)(context.replay),
-        new HostInputInvalid()
-      );
-      if (replay !== void 0 && kind !== "mutate") return yield* new HostInputInvalid();
-      if (native.database === void 0) return yield* withinDeadline(execute());
-      const storage = context.storage ?? unavailableStorage;
-      return yield* storage[kind === "query" ? "read" : "mutate"](
-        native.database.schema,
-        (db) => withinDeadline(
-          replay === void 0 ? execute(db) : db.once(replay.key, replay.fingerprint, () => execute(db))
-        )
-      ).pipe(
-        Effect_exports.catchTags({
-          AppDatabaseError: () => Effect_exports.fail(new HostOperationFailed()),
-          AppStorageUnavailable: () => Effect_exports.fail(new HostOperationFailed()),
-          AppStorageError: () => Effect_exports.fail(new HostOperationFailed())
-        })
-      );
+      return yield* withinDeadline(execute());
     })
   );
 }
-var parseSkillLoadFailed = (error) => Schema_exports.decodeUnknownOption(SkillLoadFailed)(error).pipe(
-  Option_exports.map(
-    ({ reason, message, status }) => new SkillLoadFailed({
-      reason,
-      ...message ? { message } : {},
-      ...status === void 0 ? {} : { status }
-    })
-  )
-);
-var parseMcpError = (error) => Schema_exports.decodeUnknownOption(McpError)(error).pipe(
-  Option_exports.map(
-    ({ phase, reason, status }) => new McpError({ phase, reason, ...status === void 0 ? {} : { status } })
-  )
-);
+function checkAccount(slots, declared, requirement, context, signal, deadline) {
+  return Effect_exports.gen(function* () {
+    const selection = Object.hasOwn(slots, requirement) ? slots[requirement] : void 0;
+    const slot = Object.hasOwn(declared.accounts, requirement) ? declared.accounts[requirement] : void 0;
+    if (selection === void 0 || slot === void 0) return yield* new HostAccountsInvalid();
+    const provider = selection instanceof ManyAccounts ? selection.provider : selection;
+    const health = provider.health;
+    if (health === void 0) return yield* new HostOperationNotFound();
+    const { accounts } = yield* bindAccounts(
+      { [requirement]: provider },
+      { accounts: { [requirement]: { ...slot, cardinality: "one" } } },
+      context
+    ).pipe(Effect_exports.withSpan("app.accounts.bind"));
+    const account = accounts[requirement];
+    if (account === void 0 || !("id" in account)) return yield* new HostAccountsInvalid();
+    const result = yield* Effect_exports.suspend(
+      () => Effect_exports.gen(function* () {
+        return yield* health.run({
+          account,
+          fetch: yield* appInvocationFetch(signal),
+          signal,
+          ...deadline === void 0 ? {} : { deadline }
+        });
+      })
+    ).pipe(
+      Effect_exports.catchCause((cause) => {
+        if (Cause_exports.hasInterrupts(cause)) return Effect_exports.interrupt;
+        const error = Cause_exports.squash(cause);
+        const status = Schema_exports.decodeUnknownOption(ResponseStatusError)(error);
+        const classified = Option_exports.isSome(status) ? Option_exports.fromNullishOr(httpProviderError(status.value.status)) : parseProviderError(error);
+        const secrets = accountSecrets(context.accounts);
+        return Effect_exports.fail(
+          Option_exports.isSome(classified) ? leavingProviderError(accountProviderError(classified.value, account.id), secrets) : new HostOperationFailed(failureDetail(error, secrets))
+        );
+      }),
+      Effect_exports.withSpan("app.account.check")
+    );
+    return yield* safe2(
+      () => Schema_exports.decodeUnknownEffect(AccountCheckResult)(result ?? {}).pipe(
+        Effect_exports.flatMap(Schema_exports.encodeEffect(AccountCheckResult)),
+        Effect_exports.flatMap(Schema_exports.decodeUnknownEffect(JsonValue))
+      ),
+      new HostOutputInvalid()
+    );
+  });
+}
 var errorStatus = Match_exports.type().pipe(
   Match_exports.tagsExhaustive({
     ProviderError: () => 502,
@@ -1103,11 +1611,14 @@ var errorStatus = Match_exports.type().pipe(
     HostAccountsInvalid: () => 422,
     HostInputInvalid: () => 422,
     HostOperationNotFound: () => 404,
+    HostKindMismatch: () => 409,
     HostToolNotFound: () => 404,
     HostToolBlocked: () => 403,
     HostToolApprovalRequired: () => 409,
     HostToolPolicyFailed: () => 500,
     HostOperationFailed: () => 500,
+    DatabaseLimitExceeded: () => 422,
+    DatabaseFieldReserved: () => 422,
     HostDeclarationInvalid: () => 500,
     HostEvaluationFailed: () => 500,
     HostOutputInvalid: () => 500,
@@ -1134,6 +1645,15 @@ var createAppHandler = (app) => (request, context) => Effect_exports.gen(functio
         toolError = true;
       }
     }),
+    // Name what failed on the span; the bounded message stays in the reply only. The host
+    // records an app's own error names and codes as `unrecognized` (telemetry `app-records`).
+    Effect_exports.tapError(
+      (error) => (error._tag === "HostEvaluationFailed" || error._tag === "HostOperationFailed" || error._tag === "HostDeclarationInvalid") && error.errorName !== void 0 ? Effect_exports.annotateCurrentSpan({
+        "error.type": error.errorName,
+        ...error.source === void 0 ? {} : { "executor.failure.source": error.source },
+        ...error.code === void 0 ? {} : { "executor.failure.code": error.code }
+      }) : Effect_exports.void
+    ),
     Effect_exports.withSpan(`app.${command.operation}`)
   );
   if (toolError)
@@ -1152,12 +1672,20 @@ var createAppHandler = (app) => (request, context) => Effect_exports.gen(functio
     )
   ),
   Effect_exports.catchCause(
-    (cause) => Cause_exports.hasInterrupts(cause) ? Effect_exports.interrupt : Effect_exports.logError(cause).pipe(
-      Effect_exports.as(
-        Response.json(
-          { ok: false, error: { _tag: "HostDeclarationInvalid" } },
-          { status: 500 }
-        )
+    (cause) => Cause_exports.hasInterrupts(cause) ? Effect_exports.interrupt : (
+      // The cause can carry any text the app threw; its caller receives that, not the log.
+      Effect_exports.logError("The app's request failed unexpectedly").pipe(
+        Effect_exports.andThen(
+          Schema_exports.encodeEffect(HostError)(
+            declarationInvalid(
+              "The app failed while it was loaded",
+              Cause_exports.squash(cause),
+              accountSecrets(context.accounts)
+            )
+          )
+        ),
+        Effect_exports.map((error) => Response.json({ ok: false, error }, { status: 500 })),
+        Effect_exports.orDie
       )
     )
   )