apps 0.0.1-beta.7 → 0.0.1-beta.70

package/js/{chunk-UESPOTUI.js → chunk-2YSTJMBD.js}

@@ -1,39 +1,45 @@
 import {
   makeCache
-} from "./chunk-NKLWZJLE.js";
+} from "./chunk-RUP4JMKO.js";
 import {
   accountSecrets,
   boundFailureMessage,
   describeFailure,
   failureDetail,
+  leavingProviderError,
+  parseMcpError,
+  parseSkillLoadFailed,
   readCatalog,
   routerSkills
-} from "./chunk-FL2QR3XW.js";
+} from "./chunk-4NCIPADO.js";
+import {
+  appInvocationFetch
+} from "./chunk-MHB7IFG7.js";
 import {
   folderSkillsEffect
-} from "./chunk-IPI4MFSN.js";
+} from "./chunk-XBG7HHXC.js";
 import {
   ResponseStatusError,
-  authorDatabase,
+  declaredEvents,
   isApp,
+  makeEmitter,
   toEffectApp,
-  unavailableStorage
-} from "./chunk-YXQHV65J.js";
-import {
-  parseDatabaseSchema
-} from "./chunk-ZQINWV4W.js";
+  withPlacements
+} from "./chunk-3R3KFCDU.js";
 import {
   declaredOperations,
-  fromPromise,
   locate,
-  nativeOperation,
-  toPromise
-} from "./chunk-Z5M2LQOZ.js";
+  nativeOperation
+} from "./chunk-ZEJ3IKEC.js";
 import {
   accountProviderError,
+  appCode,
+  fromPromise,
   httpProviderError,
-  parseProviderError
-} from "./chunk-MKWZPDR6.js";
+  method,
+  parseProviderError,
+  toPromise
+} from "./chunk-ZR7QAG67.js";
 import {
   AccountCheckResult,
   DeclaredProvider,
@@ -62,9 +68,9 @@ import {
   HostedWebhook,
   HostedWorkflow,
   InvocationDeadline,
+  InvocationTimingSink,
   ManualWebhookSetup,
   ManyAccounts,
-  McpError,
   NonRetryableError,
   OpenapiResponseError,
   ResolvedAccounts,
@@ -80,42 +86,84 @@ import {
   approvalElicitation,
   defaultWebhookTransportLimits,
   maxInputProblems,
+  migrationsDirectory,
+  normalizePlacements,
+  reservedTablePrefix,
+  sqlBindingsLimit,
   workflowDurationMillis
-} from "./chunk-WLE7WX2U.js";
+} from "./chunk-JW5LYSER.js";
 import {
   CacheError
-} from "./chunk-R3EV5FTO.js";
+} from "./chunk-7LMU3ER3.js";
 import {
   AppSkills,
-  SkillFile,
-  SkillLoadFailed
-} from "./chunk-JU7VHODU.js";
-import {
-  captureTelemetry,
-  invocationFetch
-} from "./chunk-RJDDBDSN.js";
+  SkillFile
+} from "./chunk-H72MEDMN.js";
 import {
+  allowedValues,
   decoderOf,
+  echoableKey,
   importedJsonSchema,
+  importedSchemaKeys,
   jsonSchemaDecoder,
-  jsonSchemaDocument
-} from "./chunk-5T57N25Q.js";
+  jsonSchemaDocument,
+  maxAlternativeKeys,
+  missingKey,
+  missingKeyText,
+  objectShape,
+  unionShape
+} from "./chunk-KGCTYL2S.js";
+import {
+  captureTelemetry,
+  makeOwnershipAccounting,
+  measuredSpan,
+  owned
+} from "./chunk-3CVQ3VPP.js";
 import {
   JsonObject,
   JsonValue
-} from "./chunk-27F7W2LG.js";
+} from "./chunk-H2CJWXA3.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-CDL5PM2Q.js";
+} from "./chunk-IFJU5SYQ.js";
+
+// src/implementation/invocation-timing.ts
+var elicitationWaitSpan = "app.elicitation.wait";
+var workflowControlSpan = "app.workflow.control";
+var timedInvocation = (operation) => (effect) => Effect_exports.gen(function* () {
+  const report = yield* InvocationTimingSink;
+  return yield* effect.pipe(
+    measuredSpan(`app.${operation}`, {}, (start) => {
+      const accounting = makeOwnershipAccounting(start, "executor");
+      return {
+        around: accounting.observe,
+        end: (end, span) => {
+          const spent = accounting.read(end);
+          report({
+            elapsedMs: Number(end - start) / 1e6,
+            upstreamMs: spent.upstream,
+            elicitationMs: spent.person,
+            authoredMs: spent.app
+          });
+          span.attribute("executor.upstream.wait_ms", spent.upstream);
+          span.attribute("executor.elicitation.wait_ms", spent.person);
+          span.attribute("executor.authored_ms", spent.app);
+          span.attribute("executor.overhead_ms", spent.executor);
+        }
+      };
+    })
+  );
+});
 
 // src/implementation/elicitation.ts
 var prepareElicitation = (input) => Effect_exports.gen(function* () {
@@ -143,13 +191,17 @@ var prepareElicitation = (input) => Effect_exports.gen(function* () {
   });
   return { request, respond };
 });
-var makeElicit = (handler, signal) => toPromise(
+var makeElicit = (handler, signal, telemetry) => toPromise(
   (input) => Effect_exports.gen(function* () {
     if (handler === void 0) return yield* new ElicitationFailed({ reason: "unavailable" });
     const form = yield* prepareElicitation(input);
-    return yield* handler(form.request, signal).pipe(Effect_exports.flatMap(form.respond));
+    return yield* handler(form.request, signal).pipe(
+      owned("person", elicitationWaitSpan),
+      Effect_exports.flatMap(form.respond)
+    );
   }),
-  signal
+  signal,
+  telemetry
 );
 
 // src/contracts/approval.ts
@@ -235,10 +287,7 @@ var makeWorkflowContext = (execution, definition, fresh, signal) => Effect_expor
             );
             const step2 = yield* fresh(stepId, AbortSignal.any([signal, controller.signal]));
             const result = yield* workflowSafe(
-              Effect_exports.tryPromise({
-                try: () => callback(step2.context),
-                catch: (error) => error
-              }),
+              fromPromise(callback, "step")(step2.context),
               step2.secrets
             );
             return yield* Schema_exports.decodeUnknownEffect(WorkflowValue)(result).pipe(
@@ -319,15 +368,144 @@ 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 unionExpectation = (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 allowedValues(values);
+  return unionShape(
+    [
+      ...values.length === 0 ? [] : [allowedValues(values)],
+      ...new Set(others.map(describeMember))
+    ],
+    memberSelector(members)
+  );
+};
+var expectedUnion = (ast) => `Expected ${unionExpectation(ast)}`;
+var expectedValue = (ast) => {
+  const encoded = SchemaAST_exports.toEncoded(ast);
+  const values = fixedValues(encoded);
+  if (values !== void 0) return allowedValues(values);
+  const members = unionMembers(encoded);
+  const [only] = members;
+  if (only === void 0) return void 0;
+  if (members.length > 1 && SchemaAST_exports.isUnion(encoded)) return unionExpectation(encoded);
+  if (SchemaAST_exports.isObjects(only) && only.propertySignatures.length > 0)
+    return nativeObjectShape(only);
+  const described = describeMember(only);
+  return described === "a value with other constraints" ? void 0 : described;
+};
+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 inputInvalid = (error) => {
+var declaredKey = (parent, key) => parent !== void 0 && SchemaAST_exports.isObjects(parent) ? parent.propertySignatures.find(({ name }) => name === key)?.type : void 0;
+var nativeKeys = (parent) => (key) => parent.indexSignatures.length > 0 || parent.propertySignatures.some(({ name }) => name === key);
+var located = (issue, path, parent) => Match_exports.value(issue).pipe(
+  Match_exports.tag("Pointer", (pointer) => {
+    const declared = pointer.issue._tag === "MissingKey" && pointer.path.length === 1 ? declaredKey(parent, pointer.path[0]) : void 0;
+    return declared === void 0 || parent === void 0 || !SchemaAST_exports.isObjects(parent) ? located(pointer.issue, [...path, ...pointer.path]) : [
+      {
+        path: [...path, ...pointer.path],
+        message: missingKey(expectedValue(declared)),
+        accepts: nativeKeys(parent)
+      }
+    ];
+  }),
+  Match_exports.tag(
+    "Composite",
+    ({ ast, issues }) => issues.flatMap((issue2) => located(issue2, path, ast))
+  ),
+  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) => {
+    const accepts = issue2._tag === "Filter" ? importedSchemaKeys(issue2.filter) : void 0;
+    return format(issue2).issues.map((problem) => ({
+      path: [
+        ...path,
+        ...(problem.path ?? []).map((key) => typeof key === "object" ? key.key : key)
+      ],
+      message: problem.message,
+      ...accepts === void 0 ? {} : { accepts }
+    }));
+  })
+);
+var segment = (key) => typeof key === "number" ? `[${key}]` : typeof key === "string" && echoableKey(key) ? `.${key}` : "[key]";
+var rendered = (path) => `input${path.map(segment).join("")}`;
+var isRecord = (value) => typeof value === "object" && value !== null && !Array.isArray(value);
+var valueAt = (input, path) => path.reduce(
+  (value, key) => Array.isArray(value) && typeof key === "number" ? value[key] : isRecord(value) && typeof key === "string" && Object.hasOwn(value, key) ? value[key] : void 0,
+  input
+);
+var spelling = (key) => key.toLowerCase().replace(/[-_]/g, "");
+var suppliedElsewhere = (input, path, accepts) => {
+  const key = path.at(-1);
+  if (typeof key !== "string" || !echoableKey(key)) return void 0;
+  const at = path.slice(0, -1);
+  const holder = valueAt(input, at);
+  if (!isRecord(holder)) return void 0;
+  const candidates = Object.keys(holder).filter((name) => echoableKey(name) && !accepts(name));
+  const respelled = candidates.find((name) => name !== key && spelling(name) === spelling(key));
+  const deeper = candidates.find((name) => {
+    const child = holder[name];
+    return isRecord(child) && Object.hasOwn(child, key);
+  });
+  const found = respelled !== void 0 ? [...at, respelled] : deeper !== void 0 ? [...at, deeper, key] : void 0;
+  return found === void 0 ? void 0 : `The input has ${String(found.at(-1))} at ${rendered(found)}; did you mean ${rendered(path)}?`;
+};
+var inputInvalid = (error, input) => {
   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));
-    return `${location.length === 0 ? "input" : `input${location.join("")}`}: ${message}`.slice(
+  const problems = located(error.issue, []).slice(0, maxInputProblems).map(({ path, message, accepts }) => {
+    const elsewhere = accepts !== void 0 && message.startsWith(missingKeyText) ? suppliedElsewhere(input, path, accepts) : void 0;
+    return `${rendered(path)}: ${message}${elsewhere === void 0 ? "" : `. ${elsewhere}`}`.slice(
       0,
       512
     );
@@ -434,7 +612,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)
@@ -467,7 +645,8 @@ var dispatchWebhook = (definition, command, context, accounts) => Effect_exports
             return yield* new HostOutputInvalid();
           chunks.push(chunk);
         })
-      )
+      ),
+      appCode("webhook")
     );
   const bytes = new Uint8Array(size);
   let offset = 0;
@@ -483,30 +662,437 @@ 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 stepEvents = `${reservedTablePrefix}step_events`;
+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 (bindings.length > sqlBindingsLimit)
+      throw refuse(
+        new Error(
+          `A statement can bind at most ${sqlBindingsLimit} values, but this one binds ${bindings.length}. Pass a long list as one JSON array and read it with json_each(?), or split the work into batches.`
+        )
+      );
+    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();
+    const emittedBefore = options.emitted?.length;
+    const discardEmitted = () => {
+      if (options.emitted !== void 0 && emittedBefore !== void 0)
+        options.emitted.length = emittedBefore;
+    };
+    const body = () => {
+      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];
+        storage.sql.exec(
+          `CREATE TABLE IF NOT EXISTS ${stepEvents} (id TEXT PRIMARY KEY, events TEXT NOT NULL) WITHOUT ROWID`
+        );
+        if (saved !== void 0) {
+          if (saved.fingerprint !== step.fingerprint)
+            throw new Error("This workflow step already ran with different input.");
+          const replayed = storage.sql.exec(`SELECT events FROM ${stepEvents} WHERE id = ?`, step.key).toArray()[0];
+          if (replayed !== void 0 && options.emitted !== void 0)
+            options.emitted.push(...JSON.parse(String(replayed.events)));
+          return JSON.parse(String(saved.result));
+        }
+        const encoded = JSON.stringify(complete() ?? null);
+        const emitted = options.emitted?.slice(emittedBefore ?? 0) ?? [];
+        if (emitted.length > 0)
+          storage.sql.exec(
+            `INSERT INTO ${stepEvents} (id, events) VALUES (?, ?)`,
+            step.key,
+            JSON.stringify(emitted)
+          );
+        storage.sql.exec(
+          `INSERT INTO ${receipts} (id, fingerprint, result) VALUES (?, ?, ?)`,
+          step.key,
+          step.fingerprint,
+          encoded
+        );
+        return JSON.parse(encoded);
+      } finally {
+        open = false;
+        handle.end();
+      }
+    };
+    try {
+      return storage.transactionSync(body);
+    } catch (error) {
+      discardEmitted();
+      throw error;
+    }
+  };
+  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) => (
+  // oxlint-disable-next-line executor/authored-code-through-adapter -- Web Crypto
+  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 statementsOf = (script) => {
+  let end = 0;
+  let index = 0;
+  while (index < script.length) {
+    const char = script[index];
+    const next = script[index + 1];
+    if (char === "-" && next === "-") {
+      const newline = script.indexOf("\n", index);
+      index = newline === -1 ? script.length : newline + 1;
+      continue;
+    }
+    if (char === "/" && next === "*") {
+      const close = script.indexOf("*/", index + 2);
+      index = close === -1 ? script.length : close + 2;
+      continue;
+    }
+    const closing = char === "'" || char === '"' || char === "`" ? char : char === "[" ? "]" : void 0;
+    if (closing !== void 0) {
+      let after = index + 1;
+      while (true) {
+        const found = script.indexOf(closing, after);
+        if (found === -1) {
+          after = script.length;
+          break;
+        }
+        if (closing !== "]" && script[found + 1] === closing) {
+          after = found + 2;
+          continue;
+        }
+        after = found + 1;
+        break;
+      }
+      index = after;
+      end = index;
+      continue;
+    }
+    index += 1;
+    if (char !== void 0 && !/\s/u.test(char)) end = index;
+  }
+  return script.slice(0, end);
+};
+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()) {
+        const statements = statementsOf(migration.content);
+        try {
+          if (statements !== "") storage.sql.exec(statements);
+        } 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" })),
   background: () => Effect_exports.die(new Error("Cache background runner is unavailable"))
 };
-var authorCache = (host, accounts, signal, deadline) => {
+var authorCache = (host, accounts, signal, telemetry, deadline) => {
   const scoped = (scope, callerSignal = signal) => {
     const cache = makeCache(host.transport, host.background, scope, deadline);
-    const load = (method, options) => cache[method]({
+    const load = (read, options) => cache[read]({
       key: options.key,
       schema: decoderOf(options.schema),
       freshFor: options.freshFor,
       ...options.staleFor === void 0 ? {} : { staleFor: options.staleFor },
+      ...options.stale === void 0 ? {} : { stale: options.stale },
       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) => fromPromise(
+              method(options, "load"),
+              "loader"
+            )({
               fetch,
               signal: controller.signal,
               cache: scoped(scope, controller.signal)
@@ -516,22 +1102,30 @@ var authorCache = (host, accounts, signal, deadline) => {
         (controller) => Effect_exports.sync(() => controller.abort())
       )
     });
+    const service = (method2, operation) => toPromise(
+      (...args) => operation(...args).pipe(
+        owned("executor", "app.cache.call", { attributes: { "cache.method": method2 } })
+      ),
+      callerSignal,
+      telemetry
+    );
     return {
-      get: toPromise((options) => load("get", options), callerSignal),
-      revalidate: toPromise(
-        (options) => load("revalidate", options),
-        callerSignal
+      get: service("get", (options) => load("get", options)),
+      revalidate: service(
+        "revalidate",
+        (options) => load("revalidate", options)
       ),
-      read: toPromise(
+      read: service(
+        "read",
         (key, schema) => cache.read([key]).pipe(
           Effect_exports.flatMap((entries) => {
             const entry = entries[0];
             return entry === void 0 || entry === null ? Effect_exports.succeed(void 0) : Schema_exports.decodeUnknownEffect(decoderOf(schema))(entry.value);
           })
-        ),
-        callerSignal
+        )
       ),
-      readMany: toPromise(
+      readMany: service(
+        "readMany",
         (keys, schema) => cache.read(keys).pipe(
           Effect_exports.flatMap(
             (entries) => Effect_exports.forEach(
@@ -539,11 +1133,10 @@ var authorCache = (host, accounts, signal, deadline) => {
               (entry) => entry === null ? Effect_exports.succeed(void 0) : Schema_exports.decodeUnknownEffect(decoderOf(schema))(entry.value)
             )
           )
-        ),
-        callerSignal
+        )
       ),
-      write: toPromise(cache.write, callerSignal),
-      invalidate: toPromise(cache.invalidate, callerSignal),
+      write: service("write", cache.write),
+      invalidate: service("invalidate", cache.invalidate),
       forAccount: (account) => {
         const bound = Object.values(accounts).flatMap((value) => Array.isArray(value) ? value : [value]).find((value) => value.id === account.id);
         if (bound === void 0) throw new CacheError({ reason: "invalid" });
@@ -575,9 +1168,9 @@ var evaluationSafe = (work, secrets) => work.pipe(
     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(failureDetail(error, secrets))
+      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))
     );
   })
 );
@@ -594,37 +1187,52 @@ var declarationSafe = (work, summary) => Effect_exports.suspend(work).pipe(
     (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 declaredPlacements(request) {
+  return request === void 0 || request.length === 0 ? {} : { request: normalizePlacements(request) };
+}
 function providerDeclaration(provider) {
   return declarationSafe(
     () => Effect_exports.gen(function* () {
       const auth = /* @__PURE__ */ new Map();
-      for (const [name, method] of Object.entries(provider.auth)) {
-        switch (method._tag) {
+      for (const [name, method2] of Object.entries(provider.auth)) {
+        switch (method2._tag) {
           case "secrets":
             auth.set(name, {
               type: "secrets",
-              label: method.label,
-              fields: yield* jsonSchemaDocument(method.fields)
+              label: method2.label,
+              fields: yield* jsonSchemaDocument(method2.fields),
+              ...declaredExposure(method2.exposure),
+              ...declaredPlacements(method2.request)
             });
             break;
           case "oauth2":
             auth.set(name, {
               type: "oauth2",
-              ...method.config,
-              response: yield* jsonSchemaDocument(method.response)
+              ...method2.config,
+              response: yield* jsonSchemaDocument(method2.response),
+              ...declaredExposure(method2.exposure),
+              ...declaredPlacements(method2.request)
             });
             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() }
       });
     }),
     `Account provider "${provider.name}" has an invalid declaration`
   );
 }
-function requirements(slots, database) {
+function requirements(slots, sql, events) {
   return Effect_exports.gen(function* () {
     const accounts = /* @__PURE__ */ new Map();
     for (const [slot, selection] of Object.entries(slots)) {
@@ -638,10 +1246,16 @@ function requirements(slots, database) {
     return yield* Schema_exports.decodeUnknownEffect(DeclaredRequirements)({
       accounts: Object.fromEntries(accounts),
       capabilities: { skills: true, toolIndex: true, skillSources: true, scheduledTools: true },
-      ...database === void 0 ? {} : { database }
+      ...sql ? { sql: true } : {},
+      ...events === void 0 || Object.keys(events).length === 0 ? {} : {
+        events: yield* declarationSafe(
+          () => declaredEvents(events),
+          "The app's event declarations are invalid"
+        )
+      }
     }).pipe(
       Effect_exports.mapError(
-        (cause) => declarationInvalid("The app's account or database declarations are invalid", cause)
+        (cause) => declarationInvalid("The app's account declarations are invalid", cause)
       )
     );
   });
@@ -653,6 +1267,17 @@ function canonical(value) {
   }
   return JSON.stringify(value);
 }
+function withoutGrants({ hosts: _hosts, ...provider }) {
+  return {
+    ...provider,
+    auth: Object.fromEntries(
+      Object.entries(provider.auth).map(([name, { request: _request, ...method2 }]) => [
+        name,
+        method2
+      ])
+    )
+  };
+}
 function bindAccounts(slots, declarations, context) {
   return safe2(
     () => Effect_exports.gen(function* () {
@@ -678,14 +1303,17 @@ 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(withoutGrants(account.provider)) !== canonical(withoutGrants(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());
+          const method2 = provider.auth[account.method];
+          if (method2 === void 0) return yield* Effect_exports.fail(new HostAccountsInvalid());
           const fields = yield* Schema_exports.decodeUnknownEffect(
-            method._tag === "secrets" ? method.fields : method.response
+            method2._tag === "secrets" ? method2.fields : method2.response
           )(account.fields);
-          values.push({ id: account.id, method: account.method, fields });
+          const granted = Object.hasOwn(account.provider.auth, account.method) ? account.provider.auth[account.method]?.request : void 0;
+          values.push(
+            withPlacements({ id: account.id, method: account.method, fields }, granted)
+          );
         }
         if (many) bound.set(slot, values);
         else {
@@ -699,7 +1327,42 @@ function bindAccounts(slots, declarations, context) {
     new HostAccountsInvalid()
   );
 }
-function dispatch(app, request, context, signal) {
+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, emitted) {
   return Effect_exports.scoped(
     Effect_exports.gen(function* () {
       if (!isApp(app))
@@ -708,28 +1371,52 @@ function dispatch(app, request, context, signal) {
         );
       const native = toEffectApp(app);
       const secrets = accountSecrets(context.accounts);
-      const storageFailure = (error) => Effect_exports.fail(new HostOperationFailed(failureDetail(error, secrets)));
-      const declared = yield* requirements(native.accounts, native.database?.schema);
-      if (request.operation === "requirements") {
-        if (native.database !== void 0)
-          yield* parseDatabaseSchema(native.database.schema).pipe(
-            Effect_exports.catchTag(
-              "AppDatabaseError",
-              (cause) => Effect_exports.fail(
-                declarationInvalid("The app's account or database declarations are invalid", cause)
-              )
-            )
-          );
+      const ownsSql = hasMigrations(context.files ?? []);
+      const declared = yield* requirements(native.accounts, ownsSql, native.events);
+      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,
+            emitted,
+            ...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()
@@ -756,33 +1443,56 @@ function dispatch(app, request, context, signal) {
           declared,
           request.requirement,
           context,
-          invocationSignal
+          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(
-          Effect_exports.withSpan("app.tool.elicitation"),
+        () => running !== void 0 && context.elicitation !== void 0 ? context.elicitation(request2, signal2).pipe(
+          // Delivering the question and waiting for its answer is the person's time.
+          owned("person", "app.tool.elicitation"),
           Effect_exports.provideContext(running.context)
         ) : Effect_exports.fail(new ElicitationFailed({ reason: "unavailable" }))
       );
       const unavailableWorkflow = () => Effect_exports.fail(new WorkflowFailure({ reason: "unavailable", retryable: false }));
+      const telemetry = yield* captureTelemetry;
+      const control = (operation, work) => work.pipe(
+        owned("executor", workflowControlSpan, {
+          attributes: { "executor.workflow.operation": operation }
+        })
+      );
       const workflowControls = {
         start: toPromise(
-          (input2) => context.workflowControls === void 0 ? unavailableWorkflow() : context.workflowControls.start(input2),
-          invocationSignal
+          (input2) => control(
+            "start",
+            context.workflowControls === void 0 ? unavailableWorkflow() : context.workflowControls.start(input2)
+          ),
+          invocationSignal,
+          telemetry.context
         ),
         get: toPromise(
-          (input2) => context.workflowControls === void 0 ? unavailableWorkflow() : context.workflowControls.get(input2),
-          invocationSignal
+          (input2) => control(
+            "get",
+            context.workflowControls === void 0 ? unavailableWorkflow() : context.workflowControls.get(input2)
+          ),
+          invocationSignal,
+          telemetry.context
         ),
         list: toPromise(
-          (input2) => context.workflowControls === void 0 ? unavailableWorkflow() : context.workflowControls.list(input2),
-          invocationSignal
+          (input2) => control(
+            "list",
+            context.workflowControls === void 0 ? unavailableWorkflow() : context.workflowControls.list(input2)
+          ),
+          invocationSignal,
+          telemetry.context
         ),
         terminate: toPromise(
-          (input2) => context.workflowControls === void 0 ? unavailableWorkflow() : context.workflowControls.terminate(input2),
-          invocationSignal
+          (input2) => control(
+            "terminate",
+            context.workflowControls === void 0 ? unavailableWorkflow() : context.workflowControls.terminate(input2)
+          ),
+          invocationSignal,
+          telemetry.context
         )
       };
       const workflowReads = {
@@ -794,6 +1504,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(
           {
@@ -801,10 +1512,12 @@ function dispatch(app, request, context, signal) {
             transport: (command) => {
               cacheCommands += 1;
               return hostCache.transport(command);
-            }
+            },
+            background: fetching.background
           },
           Redacted_exports.value(context.accounts),
           invocationSignal,
+          telemetry.context,
           deadline
         ),
         files,
@@ -813,9 +1526,20 @@ function dispatch(app, request, context, signal) {
         ),
         workflows: workflowReads,
         signal: invocationSignal,
-        fetch: yield* invocationFetch(invocationSignal),
-        elicit: makeElicit(delivery, invocationSignal)
+        fetch: yield* appInvocationFetch(fetching.signal),
+        elicit: makeElicit(delivery, invocationSignal, telemetry.context)
       };
+      const accountIds = Object.values(bound.accounts).flatMap(
+        (selected) => (Array.isArray(selected) ? selected : [selected]).map(
+          (account) => account.id
+        )
+      );
+      const emitter = (sourceAccount) => makeEmitter({
+        events: native.events ?? {},
+        accounts: accountIds,
+        ...sourceAccount === void 0 ? {} : { sourceAccount },
+        emitted
+      });
       const definition = yield* evaluationSafe(native.evaluate(bound), secrets).pipe(
         Effect_exports.withSpan("app.evaluate")
       );
@@ -887,10 +1611,11 @@ function dispatch(app, request, context, signal) {
                 cache: authorCache(
                   context.cache ?? unavailableCache,
                   Redacted_exports.value(current.accounts),
-                  signal2
+                  signal2,
+                  (yield* captureTelemetry).context
                 ),
                 files,
-                fetch: yield* invocationFetch(signal2),
+                fetch: yield* appInvocationFetch(signal2),
                 signal: signal2,
                 runId: execution.runId,
                 stepId,
@@ -938,7 +1663,8 @@ function dispatch(app, request, context, signal) {
         );
       }
       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,
           {
@@ -948,27 +1674,17 @@ 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,
+            events: emitter("sourceAccount" in request ? request.sourceAccount : void 0)
           },
           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: storageFailure,
-            DatabaseLimitExceeded: (error) => Effect_exports.fail(error),
-            AppStorageUnavailable: storageFailure,
-            AppStorageError: storageFailure
-          })
-        );
       }
       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);
+      const tool = location === void 0 ? void 0 : location.kind === "operation" ? location.operation : yield* evaluationSafe(location.source.resolve(location.name), secrets).pipe(
+        Effect_exports.withSpan("app.tool.resolve")
+      );
       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";
@@ -979,7 +1695,7 @@ function dispatch(app, request, context, signal) {
         () => Schema_exports.decodeUnknownEffect(tool.input)(request.input)
       ).pipe(
         Effect_exports.catchCause(
-          (cause) => Cause_exports.hasInterrupts(cause) ? Effect_exports.interrupt : Effect_exports.fail(inputInvalid(Cause_exports.squash(cause)))
+          (cause) => Cause_exports.hasInterrupts(cause) ? Effect_exports.interrupt : Effect_exports.fail(inputInvalid(Cause_exports.squash(cause), request.input))
         )
       );
       if (context.approval !== void 0) {
@@ -1024,24 +1740,23 @@ 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,
+              ...kind === "mutate" ? { events: emitter() } : {}
             },
             input
           );
@@ -1056,14 +1771,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(failureDetail(error, secrets))
+              }) : Option_exports.isSome(mcp) ? mcp.value : Option_exports.isSome(failure) ? failure.value : new HostOperationFailed(failureDetail(error, secrets))
             );
           }),
           Effect_exports.withSpan("app.operation.execute", {
@@ -1080,30 +1796,11 @@ 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: storageFailure,
-          DatabaseLimitExceeded: (error) => Effect_exports.fail(error),
-          AppStorageUnavailable: storageFailure,
-          AppStorageError: storageFailure
-        })
-      );
+      return yield* withinDeadline(execute());
     })
   );
 }
-function checkAccount(slots, declared, requirement, context, signal) {
+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;
@@ -1120,7 +1817,12 @@ function checkAccount(slots, declared, requirement, context, signal) {
     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* invocationFetch(signal), signal });
+        return yield* health.run({
+          account,
+          fetch: yield* appInvocationFetch(signal),
+          signal,
+          ...deadline === void 0 ? {} : { deadline }
+        });
       })
     ).pipe(
       Effect_exports.catchCause((cause) => {
@@ -1128,8 +1830,9 @@ function checkAccount(slots, declared, requirement, context, signal) {
         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) ? accountProviderError(classified.value, account.id) : new HostOperationFailed()
+          Option_exports.isSome(classified) ? leavingProviderError(accountProviderError(classified.value, account.id), secrets) : new HostOperationFailed(failureDetail(error, secrets))
         );
       }),
       Effect_exports.withSpan("app.account.check")
@@ -1143,20 +1846,6 @@ function checkAccount(slots, declared, requirement, context, signal) {
     );
   });
 }
-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 } })
-  )
-);
 var errorStatus = Match_exports.type().pipe(
   Match_exports.tagsExhaustive({
     ProviderError: () => 502,
@@ -1196,20 +1885,37 @@ var createAppHandler = (app) => (request, context) => Effect_exports.gen(functio
     ...command.operation === "call" ? { "executor.tool.name": command.tool } : {}
   });
   let toolError = false;
-  const value = yield* dispatch(app, command, context, request.signal).pipe(
+  const emitted = [];
+  const value = yield* dispatch(app, command, context, request.signal, emitted).pipe(
     Effect_exports.provideService(ToolResultObservation, {
       failed: () => {
         toolError = true;
       }
     }),
-    Effect_exports.withSpan(`app.${command.operation}`)
+    // 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
+    ),
+    // Tool operations time themselves, dividing their time by who owned the work in progress.
+    // Other operations do not.
+    command.operation === "call" || command.operation === "query" || command.operation === "mutate" ? timedInvocation(command.operation) : Effect_exports.withSpan(`app.${command.operation}`)
   );
   if (toolError)
     yield* Effect_exports.annotateCurrentSpan({
       "executor.outcome": "failed",
       "error.type": "McpToolError"
     });
-  return Response.json({ ok: true, value, ...toolError ? { toolError: true } : {} });
+  return Response.json({
+    ok: true,
+    value,
+    ...toolError ? { toolError: true } : {},
+    ...emitted.length === 0 ? {} : { events: emitted }
+  });
 }).pipe(
   Effect_exports.catch(
     (error) => Schema_exports.encodeEffect(HostError)(error).pipe(
@@ -1220,18 +1926,21 @@ 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.andThen(
-        Schema_exports.encodeEffect(HostError)(
-          declarationInvalid(
-            "The app failed while it was loaded",
-            Cause_exports.squash(cause),
-            accountSecrets(context.accounts)
+    (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
+        ),
+        Effect_exports.map((error) => Response.json({ ok: false, error }, { status: 500 })),
+        Effect_exports.orDie
+      )
     )
   )
 );