@pylonsync/create-pylon 0.20.0 → 0.22.0

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@pylonsync/create-pylon",
-  "version": "0.20.0",
+  "version": "0.22.0",
   "description": "Scaffold a new Pylon app — realtime backend + web/mobile/expo frontends in one command. Run via `npm create @pylonsync/pylon@latest`.",
   "publishConfig": {
     "access": "public"

package/templates/_root/AGENTS.md

@@ -54,7 +54,7 @@ this pass before the user has to ask.
 - **`serverData` (SSR) is READ-ONLY.** No write methods; the runtime rejects write frames (`SSR_WRITE_FORBIDDEN`). Mutations belong in actions/functions, never in a page render.
 - **`response.*` / `response.redirect()` / `response.notFound()` must fire in the synchronous shell render**, before any `await` or `<Suspense>`. The HTTP head commits when the shell is ready. Status, headers, and cookies set from a suspended subtree are lost, and `redirect` or `notFound` thrown below a Suspense boundary are swallowed.
 - **`ctx.llm`, `ctx.rooms`, and `ctx.connections` are available on mutations and actions, not queries.** An `action` has no direct `ctx.db`; use `ctx.runQuery` or `ctx.runMutation`.
-- **`ctx.llm.stream(request, onEvent)` streams tokens as they generate** and still resolves with the full response, so `stop_reason === "tool_use"` drives an agent tool loop. Events are `text_delta` / `tool_use_start` / `tool_input_delta` / `done`. Same auth + model-allowlist gating as `ctx.llm.complete`. Streaming does NOT extend the call deadline (`PYLON_FN_CALL_TIMEOUT`, 30s default) — set `timeout: <secs>` on the def for a long run.
+- **`ctx.llm.stream(request, onEvent)` streams tokens as they generate** and still resolves with the full response, so `stop_reason === "tool_use"` drives an agent tool loop. Events are `text_delta` / `tool_use_start` / `tool_input_delta` / `done`. Same auth + model-allowlist gating as `ctx.llm.complete`. The call timeout is an idle timeout (`PYLON_FN_CALL_TIMEOUT`, 30s default; Stack0 Cloud 300s): each stream event resets it, and the total run is capped at 10× the timeout. Set `timeout: <secs>` on the def when a step (a slow tool call) can be silent longer than that.
 - **`ctx.stream.write(text)` streams to the caller — and every fn stream is RESUMABLE**: the server buffers frames under a stream id (`streamFn`'s `onStreamId`), so a dropped connection or closed tab catches up via `resumeStream(id)`, including the final result after the handler finished. `ctx.rooms.broadcast(room, topic, data)` fans out to every CURRENTLY-CONNECTED subscriber (second device, second tab) but does not replay missed messages — use the stream id for anything that must survive a gap. Broadcast resolves `{ delivered: false }` when the room has no members — a no-op, not an error. Clients receive with `useRoomMessages(room, cb)` from `@pylonsync/react`; `useRoom` is the send side.
 - **It's `db.useQueryOne`, not `useOne`.** Validators and field types have aliases: `v.bool`/`v.boolean`, `v.float`/`v.number`.
 - **There is no `ctx.files` or `defineWorkflow`/`defineJob`.** Files go through `<FileUpload>` + `/api/files/*`; an upload is readable by its uploader only, so pass `visibility: "public"` to `uploadFile` or `<FileUpload>` for files every visitor sees; deferred execution is `ctx.scheduler.runAfter/runAt/cancel`.

package/templates/agency/AGENTS.md

@@ -62,7 +62,7 @@ this pass before the user has to ask.
 - **`serverData` (SSR) is READ-ONLY.** No write methods; the runtime rejects write frames (`SSR_WRITE_FORBIDDEN`). Mutations belong in actions/functions, never in a page render.
 - **`response.*` / `response.redirect()` / `response.notFound()` must fire in the synchronous shell render**, before any `await` / `<Suspense>`. The HTTP head commits when the shell is ready; status/headers/cookies set from a suspended subtree are lost, and `redirect`/`notFound` thrown below a Suspense boundary are swallowed.
 - **`ctx.llm`, `ctx.rooms`, and `ctx.connections` are on mutation + action only, NOT query** (reactive purity). `action` has no direct `ctx.db`; use `ctx.runQuery` / `ctx.runMutation`.
-- **`ctx.llm.stream(request, onEvent)` streams tokens as they generate** and still resolves with the full response, so `stop_reason === "tool_use"` drives an agent tool loop. Events are `text_delta` / `tool_use_start` / `tool_input_delta` / `done`. Same auth + model-allowlist gating as `ctx.llm.complete`. Streaming does NOT extend the call deadline (`PYLON_FN_CALL_TIMEOUT`, 30s default) — set `timeout: <secs>` on the def for a long run.
+- **`ctx.llm.stream(request, onEvent)` streams tokens as they generate** and still resolves with the full response, so `stop_reason === "tool_use"` drives an agent tool loop. Events are `text_delta` / `tool_use_start` / `tool_input_delta` / `done`. Same auth + model-allowlist gating as `ctx.llm.complete`. The call timeout is an idle timeout (`PYLON_FN_CALL_TIMEOUT`, 30s default; Stack0 Cloud 300s): each stream event resets it, and the total run is capped at 10× the timeout. Set `timeout: <secs>` on the def when a step (a slow tool call) can be silent longer than that.
 - **`ctx.stream.write(text)` streams to the caller — and every fn stream is RESUMABLE**: the server buffers frames under a stream id (`streamFn`'s `onStreamId`), so a dropped connection or closed tab catches up via `resumeStream(id)`, including the final result after the handler finished. `ctx.rooms.broadcast(room, topic, data)` fans out to every CURRENTLY-CONNECTED subscriber (second device, second tab) but does not replay missed messages — use the stream id for anything that must survive a gap. Broadcast resolves `{ delivered: false }` when the room has no members — a no-op, not an error. Clients receive with `useRoomMessages(room, cb)` from `@pylonsync/react`; `useRoom` is the send side.
 - **It's `db.useQueryOne`, not `useOne`.** Validators and field types have aliases: `v.bool`/`v.boolean`, `v.float`/`v.number`.
 - **Use the supported file and scheduling APIs.** Files go through `<FileUpload>` and `/api/files/*`; an upload is readable by its uploader only, so pass `visibility: "public"` to `uploadFile` or `<FileUpload>` for files every visitor sees; there is no `ctx.files`. One-shot work uses `ctx.scheduler.runAfter`, `runAt`, or `cancel`; there is no `defineWorkflow` or `defineJob`. Recurring work uses `cron("0 * * * *", "fnName")` in `buildManifest({ crons: [...] })`, imported from `@pylonsync/sdk`. Make the target function `internal: true`. It runs with anonymous auth, but its own `ctx.db.*` calls are server-side and bypass policies. Use `ctx.auth.elevate({ admin: true, reason: "..." })`, with a mandatory reason, only when chaining another internal function through `ctx.scheduler`.

package/templates/ai-chat/AGENTS.md

@@ -62,7 +62,7 @@ this pass before the user has to ask.
 - **`serverData` (SSR) is READ-ONLY.** No write methods; the runtime rejects write frames (`SSR_WRITE_FORBIDDEN`). Mutations belong in actions/functions, never in a page render.
 - **`response.*` / `response.redirect()` / `response.notFound()` must fire in the synchronous shell render**, before any `await` / `<Suspense>`. The HTTP head commits when the shell is ready; status/headers/cookies set from a suspended subtree are lost, and `redirect`/`notFound` thrown below a Suspense boundary are swallowed.
 - **`ctx.llm`, `ctx.rooms`, and `ctx.connections` are on mutation + action only, NOT query** (reactive purity). `action` has no direct `ctx.db`; use `ctx.runQuery` / `ctx.runMutation`.
-- **`ctx.llm.stream(request, onEvent)` streams tokens as they generate** and still resolves with the full response, so `stop_reason === "tool_use"` drives an agent tool loop. Events are `text_delta` / `tool_use_start` / `tool_input_delta` / `done`. Same auth + model-allowlist gating as `ctx.llm.complete`. Streaming does NOT extend the call deadline (`PYLON_FN_CALL_TIMEOUT`, 30s default) — set `timeout: <secs>` on the def for a long run.
+- **`ctx.llm.stream(request, onEvent)` streams tokens as they generate** and still resolves with the full response, so `stop_reason === "tool_use"` drives an agent tool loop. Events are `text_delta` / `tool_use_start` / `tool_input_delta` / `done`. Same auth + model-allowlist gating as `ctx.llm.complete`. The call timeout is an idle timeout (`PYLON_FN_CALL_TIMEOUT`, 30s default; Stack0 Cloud 300s): each stream event resets it, and the total run is capped at 10× the timeout. Set `timeout: <secs>` on the def when a step (a slow tool call) can be silent longer than that.
 - **`ctx.stream.write(text)` streams to the caller — and every fn stream is RESUMABLE**: the server buffers frames under a stream id (`streamFn`'s `onStreamId`), so a dropped connection or closed tab catches up via `resumeStream(id)`, including the final result after the handler finished. `ctx.rooms.broadcast(room, topic, data)` fans out to every CURRENTLY-CONNECTED subscriber (second device, second tab) but does not replay missed messages — use the stream id for anything that must survive a gap. Broadcast resolves `{ delivered: false }` when the room has no members — a no-op, not an error. Clients receive with `useRoomMessages(room, cb)` from `@pylonsync/react`; `useRoom` is the send side.
 
 Streaming agent turn — tokens to the caller, and to every device watching:

package/templates/ai-studio/AGENTS.md

@@ -62,7 +62,7 @@ this pass before the user has to ask.
 - **`serverData` (SSR) is READ-ONLY.** No write methods; the runtime rejects write frames (`SSR_WRITE_FORBIDDEN`). Mutations belong in actions/functions, never in a page render.
 - **`response.*` / `response.redirect()` / `response.notFound()` must fire in the synchronous shell render**, before any `await` / `<Suspense>`. The HTTP head commits when the shell is ready; status/headers/cookies set from a suspended subtree are lost, and `redirect`/`notFound` thrown below a Suspense boundary are swallowed.
 - **`ctx.llm`, `ctx.rooms`, and `ctx.connections` are on mutation + action only, NOT query** (reactive purity). `action` has no direct `ctx.db`; use `ctx.runQuery` / `ctx.runMutation`.
-- **`ctx.llm.stream(request, onEvent)` streams tokens as they generate** and still resolves with the full response, so `stop_reason === "tool_use"` drives an agent tool loop. Events are `text_delta` / `tool_use_start` / `tool_input_delta` / `done`. Same auth + model-allowlist gating as `ctx.llm.complete`. Streaming does NOT extend the call deadline (`PYLON_FN_CALL_TIMEOUT`, 30s default) — set `timeout: <secs>` on the def for a long run.
+- **`ctx.llm.stream(request, onEvent)` streams tokens as they generate** and still resolves with the full response, so `stop_reason === "tool_use"` drives an agent tool loop. Events are `text_delta` / `tool_use_start` / `tool_input_delta` / `done`. Same auth + model-allowlist gating as `ctx.llm.complete`. The call timeout is an idle timeout (`PYLON_FN_CALL_TIMEOUT`, 30s default; Stack0 Cloud 300s): each stream event resets it, and the total run is capped at 10× the timeout. Set `timeout: <secs>` on the def when a step (a slow tool call) can be silent longer than that.
 - **`ctx.stream.write(text)` streams to the caller — and every fn stream is RESUMABLE**: the server buffers frames under a stream id (`streamFn`'s `onStreamId`), so a dropped connection or closed tab catches up via `resumeStream(id)`, including the final result after the handler finished. `ctx.rooms.broadcast(room, topic, data)` fans out to every CURRENTLY-CONNECTED subscriber (second device, second tab) but does not replay missed messages — use the stream id for anything that must survive a gap. Broadcast resolves `{ delivered: false }` when the room has no members — a no-op, not an error. Clients receive with `useRoomMessages(room, cb)` from `@pylonsync/react`; `useRoom` is the send side.
 
 Streaming agent turn — tokens to the caller, and to every device watching:

package/templates/barebones/AGENTS.md

@@ -62,7 +62,7 @@ this pass before the user has to ask.
 - **`serverData` (SSR) is READ-ONLY.** No write methods; the runtime rejects write frames (`SSR_WRITE_FORBIDDEN`). Mutations belong in actions/functions, never in a page render.
 - **`response.*` / `response.redirect()` / `response.notFound()` must fire in the synchronous shell render**, before any `await` / `<Suspense>`. The HTTP head commits when the shell is ready; status/headers/cookies set from a suspended subtree are lost, and `redirect`/`notFound` thrown below a Suspense boundary are swallowed.
 - **`ctx.llm`, `ctx.rooms`, and `ctx.connections` are on mutation + action only, NOT query** (reactive purity). `action` has no direct `ctx.db`; use `ctx.runQuery` / `ctx.runMutation`.
-- **`ctx.llm.stream(request, onEvent)` streams tokens as they generate** and still resolves with the full response, so `stop_reason === "tool_use"` drives an agent tool loop. Events are `text_delta` / `tool_use_start` / `tool_input_delta` / `done`. Same auth + model-allowlist gating as `ctx.llm.complete`. Streaming does NOT extend the call deadline (`PYLON_FN_CALL_TIMEOUT`, 30s default) — set `timeout: <secs>` on the def for a long run.
+- **`ctx.llm.stream(request, onEvent)` streams tokens as they generate** and still resolves with the full response, so `stop_reason === "tool_use"` drives an agent tool loop. Events are `text_delta` / `tool_use_start` / `tool_input_delta` / `done`. Same auth + model-allowlist gating as `ctx.llm.complete`. The call timeout is an idle timeout (`PYLON_FN_CALL_TIMEOUT`, 30s default; Stack0 Cloud 300s): each stream event resets it, and the total run is capped at 10× the timeout. Set `timeout: <secs>` on the def when a step (a slow tool call) can be silent longer than that.
 - **`ctx.stream.write(text)` streams to the caller — and every fn stream is RESUMABLE**: the server buffers frames under a stream id (`streamFn`'s `onStreamId`), so a dropped connection or closed tab catches up via `resumeStream(id)`, including the final result after the handler finished. `ctx.rooms.broadcast(room, topic, data)` fans out to every CURRENTLY-CONNECTED subscriber (second device, second tab) but does not replay missed messages — use the stream id for anything that must survive a gap. Broadcast resolves `{ delivered: false }` when the room has no members — a no-op, not an error. Clients receive with `useRoomMessages(room, cb)` from `@pylonsync/react`; `useRoom` is the send side.
 - **It's `db.useQueryOne`, not `useOne`.** Validators and field types have aliases: `v.bool`/`v.boolean`, `v.float`/`v.number`.
 - **Use the supported file and scheduling APIs.** Files go through `<FileUpload>` and `/api/files/*`; an upload is readable by its uploader only, so pass `visibility: "public"` to `uploadFile` or `<FileUpload>` for files every visitor sees; there is no `ctx.files`. One-shot work uses `ctx.scheduler.runAfter`, `runAt`, or `cancel`; there is no `defineWorkflow` or `defineJob`. Recurring work uses `cron("0 * * * *", "fnName")` in `buildManifest({ crons: [...] })`, imported from `@pylonsync/sdk`. Make the target function `internal: true`. It runs with anonymous auth, but its own `ctx.db.*` calls are server-side and bypass policies. Use `ctx.auth.elevate({ admin: true, reason: "..." })`, with a mandatory reason, only when chaining another internal function through `ctx.scheduler`.

package/templates/chat/AGENTS.md

@@ -62,7 +62,7 @@ this pass before the user has to ask.
 - **`serverData` (SSR) is READ-ONLY.** No write methods; the runtime rejects write frames (`SSR_WRITE_FORBIDDEN`). Mutations belong in actions/functions, never in a page render.
 - **`response.*` / `response.redirect()` / `response.notFound()` must fire in the synchronous shell render**, before any `await` / `<Suspense>`. The HTTP head commits when the shell is ready; status/headers/cookies set from a suspended subtree are lost, and `redirect`/`notFound` thrown below a Suspense boundary are swallowed.
 - **`ctx.llm`, `ctx.rooms`, and `ctx.connections` are on mutation + action only, NOT query** (reactive purity). `action` has no direct `ctx.db`; use `ctx.runQuery` / `ctx.runMutation`.
-- **`ctx.llm.stream(request, onEvent)` streams tokens as they generate** and still resolves with the full response, so `stop_reason === "tool_use"` drives an agent tool loop. Events are `text_delta` / `tool_use_start` / `tool_input_delta` / `done`. Same auth + model-allowlist gating as `ctx.llm.complete`. Streaming does NOT extend the call deadline (`PYLON_FN_CALL_TIMEOUT`, 30s default) — set `timeout: <secs>` on the def for a long run.
+- **`ctx.llm.stream(request, onEvent)` streams tokens as they generate** and still resolves with the full response, so `stop_reason === "tool_use"` drives an agent tool loop. Events are `text_delta` / `tool_use_start` / `tool_input_delta` / `done`. Same auth + model-allowlist gating as `ctx.llm.complete`. The call timeout is an idle timeout (`PYLON_FN_CALL_TIMEOUT`, 30s default; Stack0 Cloud 300s): each stream event resets it, and the total run is capped at 10× the timeout. Set `timeout: <secs>` on the def when a step (a slow tool call) can be silent longer than that.
 - **`ctx.stream.write(text)` streams to the caller — and every fn stream is RESUMABLE**: the server buffers frames under a stream id (`streamFn`'s `onStreamId`), so a dropped connection or closed tab catches up via `resumeStream(id)`, including the final result after the handler finished. `ctx.rooms.broadcast(room, topic, data)` fans out to every CURRENTLY-CONNECTED subscriber (second device, second tab) but does not replay missed messages — use the stream id for anything that must survive a gap. Broadcast resolves `{ delivered: false }` when the room has no members — a no-op, not an error. Clients receive with `useRoomMessages(room, cb)` from `@pylonsync/react`; `useRoom` is the send side.
 
 Streaming agent turn — tokens to the caller, and to every device watching:

package/templates/chat/app/chat-client.tsx

@@ -254,7 +254,7 @@ function Chat({ selfId, initialChannel }: { selfId: string; initialChannel?: str
 
   function remove(id: string) {
     if (window.confirm("Delete this message? Everyone in the channel will stop seeing it.")) {
-      void db.delete("Message", id);
+      db.delete("Message", id).catch(console.warn);
     }
   }
 

package/templates/consumer/AGENTS.md

@@ -62,7 +62,7 @@ this pass before the user has to ask.
 - **`serverData` (SSR) is READ-ONLY.** No write methods; the runtime rejects write frames (`SSR_WRITE_FORBIDDEN`). Mutations belong in actions/functions, never in a page render.
 - **`response.*` / `response.redirect()` / `response.notFound()` must fire in the synchronous shell render**, before any `await` / `<Suspense>`. The HTTP head commits when the shell is ready; status/headers/cookies set from a suspended subtree are lost, and `redirect`/`notFound` thrown below a Suspense boundary are swallowed.
 - **`ctx.llm`, `ctx.rooms`, and `ctx.connections` are on mutation + action only, NOT query** (reactive purity). `action` has no direct `ctx.db`; use `ctx.runQuery` / `ctx.runMutation`.
-- **`ctx.llm.stream(request, onEvent)` streams tokens as they generate** and still resolves with the full response, so `stop_reason === "tool_use"` drives an agent tool loop. Events are `text_delta` / `tool_use_start` / `tool_input_delta` / `done`. Same auth + model-allowlist gating as `ctx.llm.complete`. Streaming does NOT extend the call deadline (`PYLON_FN_CALL_TIMEOUT`, 30s default) — set `timeout: <secs>` on the def for a long run.
+- **`ctx.llm.stream(request, onEvent)` streams tokens as they generate** and still resolves with the full response, so `stop_reason === "tool_use"` drives an agent tool loop. Events are `text_delta` / `tool_use_start` / `tool_input_delta` / `done`. Same auth + model-allowlist gating as `ctx.llm.complete`. The call timeout is an idle timeout (`PYLON_FN_CALL_TIMEOUT`, 30s default; Stack0 Cloud 300s): each stream event resets it, and the total run is capped at 10× the timeout. Set `timeout: <secs>` on the def when a step (a slow tool call) can be silent longer than that.
 - **`ctx.stream.write(text)` streams to the caller — and every fn stream is RESUMABLE**: the server buffers frames under a stream id (`streamFn`'s `onStreamId`), so a dropped connection or closed tab catches up via `resumeStream(id)`, including the final result after the handler finished. `ctx.rooms.broadcast(room, topic, data)` fans out to every CURRENTLY-CONNECTED subscriber (second device, second tab) but does not replay missed messages — use the stream id for anything that must survive a gap. Broadcast resolves `{ delivered: false }` when the room has no members — a no-op, not an error. Clients receive with `useRoomMessages(room, cb)` from `@pylonsync/react`; `useRoom` is the send side.
 - **It's `db.useQueryOne`, not `useOne`.** Validators and field types have aliases: `v.bool`/`v.boolean`, `v.float`/`v.number`.
 - **Use the supported file and scheduling APIs.** Files go through `<FileUpload>` and `/api/files/*`; an upload is readable by its uploader only, so pass `visibility: "public"` to `uploadFile` or `<FileUpload>` for files every visitor sees; there is no `ctx.files`. One-shot work uses `ctx.scheduler.runAfter`, `runAt`, or `cancel`; there is no `defineWorkflow` or `defineJob`. Recurring work uses `cron("0 * * * *", "fnName")` in `buildManifest({ crons: [...] })`, imported from `@pylonsync/sdk`. Make the target function `internal: true`. It runs with anonymous auth, but its own `ctx.db.*` calls are server-side and bypass policies. Use `ctx.auth.elevate({ admin: true, reason: "..." })`, with a mandatory reason, only when chaining another internal function through `ctx.scheduler`.

package/templates/consumer/components/social/post-parts.tsx

@@ -86,7 +86,7 @@ export function PostMenu({ social, post }: { social: Social; post: Post }) {
               className={cn(row, "font-semibold text-red-600")}
               onClick={() => {
                 setOpen(false);
-                void db.delete("Post", post.id);
+                db.delete("Post", post.id).catch(console.warn);
                 if (window.location.pathname.startsWith("/p/")) router.push("/");
               }}
             >

package/templates/consumer/components/social/post-screen.tsx

@@ -158,7 +158,7 @@ function CommentRow({
           {mine ? (
             <button
               type="button"
-              onClick={() => void db.delete("Comment", comment.id)}
+              onClick={() => db.delete("Comment", comment.id).catch(console.warn)}
               className="hidden items-center gap-1 hover:text-zinc-900 group-hover:inline-flex"
               aria-label="Delete comment"
             >

package/templates/consumer/components/social/use-social.ts

@@ -66,21 +66,21 @@ export type Social = ReturnType<typeof useSocial>;
 export const actions = {
   toggleLike(social: Social, postId: string) {
     const mine = social.myLikes.get(postId);
-    if (mine) void db.delete("Like", mine.id);
-    else if (social.me) void db.insert("Like", { postId, userId: social.me });
+    if (mine) db.delete("Like", mine.id).catch(console.warn);
+    else if (social.me) db.insert("Like", { postId, userId: social.me }).catch(console.warn);
   },
   like(social: Social, postId: string) {
-    if (social.me && !social.myLikes.has(postId)) void db.insert("Like", { postId, userId: social.me });
+    if (social.me && !social.myLikes.has(postId)) db.insert("Like", { postId, userId: social.me }).catch(console.warn);
   },
   toggleSave(social: Social, postId: string) {
     const mine = social.mySaves.get(postId);
-    if (mine) void db.delete("Save", mine.id);
-    else if (social.me) void db.insert("Save", { postId, userId: social.me });
+    if (mine) db.delete("Save", mine.id).catch(console.warn);
+    else if (social.me) db.insert("Save", { postId, userId: social.me }).catch(console.warn);
   },
   toggleFollow(social: Social, userId: string) {
     if (!social.me || userId === social.me) return;
     const mine = social.myFollows.get(userId);
-    if (mine) void db.delete("Follow", mine.id);
-    else void db.insert("Follow", { followingId: userId, followerId: social.me });
+    if (mine) db.delete("Follow", mine.id).catch(console.warn);
+    else db.insert("Follow", { followingId: userId, followerId: social.me }).catch(console.warn);
   },
 };

package/templates/creator/AGENTS.md

@@ -62,7 +62,7 @@ this pass before the user has to ask.
 - **`serverData` (SSR) is READ-ONLY.** No write methods; the runtime rejects write frames (`SSR_WRITE_FORBIDDEN`). Mutations belong in actions/functions, never in a page render.
 - **`response.*` / `response.redirect()` / `response.notFound()` must fire in the synchronous shell render**, before any `await` / `<Suspense>`. The HTTP head commits when the shell is ready; status/headers/cookies set from a suspended subtree are lost, and `redirect`/`notFound` thrown below a Suspense boundary are swallowed.
 - **`ctx.llm`, `ctx.rooms`, and `ctx.connections` are on mutation + action only, NOT query** (reactive purity). `action` has no direct `ctx.db`; use `ctx.runQuery` / `ctx.runMutation`.
-- **`ctx.llm.stream(request, onEvent)` streams tokens as they generate** and still resolves with the full response, so `stop_reason === "tool_use"` drives an agent tool loop. Events are `text_delta` / `tool_use_start` / `tool_input_delta` / `done`. Same auth + model-allowlist gating as `ctx.llm.complete`. Streaming does NOT extend the call deadline (`PYLON_FN_CALL_TIMEOUT`, 30s default) — set `timeout: <secs>` on the def for a long run.
+- **`ctx.llm.stream(request, onEvent)` streams tokens as they generate** and still resolves with the full response, so `stop_reason === "tool_use"` drives an agent tool loop. Events are `text_delta` / `tool_use_start` / `tool_input_delta` / `done`. Same auth + model-allowlist gating as `ctx.llm.complete`. The call timeout is an idle timeout (`PYLON_FN_CALL_TIMEOUT`, 30s default; Stack0 Cloud 300s): each stream event resets it, and the total run is capped at 10× the timeout. Set `timeout: <secs>` on the def when a step (a slow tool call) can be silent longer than that.
 - **`ctx.stream.write(text)` streams to the caller — and every fn stream is RESUMABLE**: the server buffers frames under a stream id (`streamFn`'s `onStreamId`), so a dropped connection or closed tab catches up via `resumeStream(id)`, including the final result after the handler finished. `ctx.rooms.broadcast(room, topic, data)` fans out to every CURRENTLY-CONNECTED subscriber (second device, second tab) but does not replay missed messages — use the stream id for anything that must survive a gap. Broadcast resolves `{ delivered: false }` when the room has no members — a no-op, not an error. Clients receive with `useRoomMessages(room, cb)` from `@pylonsync/react`; `useRoom` is the send side.
 - **It's `db.useQueryOne`, not `useOne`.** Validators and field types have aliases: `v.bool`/`v.boolean`, `v.float`/`v.number`.
 - **Use the supported file and scheduling APIs.** Files go through `<FileUpload>` and `/api/files/*`; an upload is readable by its uploader only, so pass `visibility: "public"` to `uploadFile` or `<FileUpload>` for files every visitor sees; there is no `ctx.files`. One-shot work uses `ctx.scheduler.runAfter`, `runAt`, or `cancel`; there is no `defineWorkflow` or `defineJob`. Recurring work uses `cron("0 * * * *", "fnName")` in `buildManifest({ crons: [...] })`, imported from `@pylonsync/sdk`. Make the target function `internal: true`. It runs with anonymous auth, but its own `ctx.db.*` calls are server-side and bypass policies. Use `ctx.auth.elevate({ admin: true, reason: "..." })`, with a mandatory reason, only when chaining another internal function through `ctx.scheduler`.

package/templates/crm/AGENTS.md

@@ -62,7 +62,7 @@ this pass before the user has to ask.
 - **`serverData` (SSR) is READ-ONLY.** No write methods; the runtime rejects write frames (`SSR_WRITE_FORBIDDEN`). Mutations belong in actions/functions, never in a page render.
 - **`response.*` / `response.redirect()` / `response.notFound()` must fire in the synchronous shell render**, before any `await` / `<Suspense>`. The HTTP head commits when the shell is ready; status/headers/cookies set from a suspended subtree are lost, and `redirect`/`notFound` thrown below a Suspense boundary are swallowed.
 - **`ctx.llm`, `ctx.rooms`, and `ctx.connections` are on mutation + action only, NOT query** (reactive purity). `action` has no direct `ctx.db`; use `ctx.runQuery` / `ctx.runMutation`.
-- **`ctx.llm.stream(request, onEvent)` streams tokens as they generate** and still resolves with the full response, so `stop_reason === "tool_use"` drives an agent tool loop. Events are `text_delta` / `tool_use_start` / `tool_input_delta` / `done`. Same auth + model-allowlist gating as `ctx.llm.complete`. Streaming does NOT extend the call deadline (`PYLON_FN_CALL_TIMEOUT`, 30s default) — set `timeout: <secs>` on the def for a long run.
+- **`ctx.llm.stream(request, onEvent)` streams tokens as they generate** and still resolves with the full response, so `stop_reason === "tool_use"` drives an agent tool loop. Events are `text_delta` / `tool_use_start` / `tool_input_delta` / `done`. Same auth + model-allowlist gating as `ctx.llm.complete`. The call timeout is an idle timeout (`PYLON_FN_CALL_TIMEOUT`, 30s default; Stack0 Cloud 300s): each stream event resets it, and the total run is capped at 10× the timeout. Set `timeout: <secs>` on the def when a step (a slow tool call) can be silent longer than that.
 - **`ctx.stream.write(text)` streams to the caller — and every fn stream is RESUMABLE**: the server buffers frames under a stream id (`streamFn`'s `onStreamId`), so a dropped connection or closed tab catches up via `resumeStream(id)`, including the final result after the handler finished. `ctx.rooms.broadcast(room, topic, data)` fans out to every CURRENTLY-CONNECTED subscriber (second device, second tab) but does not replay missed messages — use the stream id for anything that must survive a gap. Broadcast resolves `{ delivered: false }` when the room has no members — a no-op, not an error. Clients receive with `useRoomMessages(room, cb)` from `@pylonsync/react`; `useRoom` is the send side.
 - **It's `db.useQueryOne`, not `useOne`.** Validators and field types have aliases: `v.bool`/`v.boolean`, `v.float`/`v.number`.
 - **Use the supported file and scheduling APIs.** Files go through `<FileUpload>` and `/api/files/*`; an upload is readable by its uploader only, so pass `visibility: "public"` to `uploadFile` or `<FileUpload>` for files every visitor sees; there is no `ctx.files`. One-shot work uses `ctx.scheduler.runAfter`, `runAt`, or `cancel`; there is no `defineWorkflow` or `defineJob`. Recurring work uses `cron("0 * * * *", "fnName")` in `buildManifest({ crons: [...] })`, imported from `@pylonsync/sdk`. Make the target function `internal: true`. It runs with anonymous auth, but its own `ctx.db.*` calls are server-side and bypass policies. Use `ctx.auth.elevate({ admin: true, reason: "..." })`, with a mandatory reason, only when chaining another internal function through `ctx.scheduler`.

package/templates/directory/AGENTS.md

@@ -62,7 +62,7 @@ this pass before the user has to ask.
 - **`serverData` (SSR) is READ-ONLY.** No write methods; the runtime rejects write frames (`SSR_WRITE_FORBIDDEN`). Mutations belong in actions/functions, never in a page render.
 - **`response.*` / `response.redirect()` / `response.notFound()` must fire in the synchronous shell render**, before any `await` / `<Suspense>`. The HTTP head commits when the shell is ready; status/headers/cookies set from a suspended subtree are lost, and `redirect`/`notFound` thrown below a Suspense boundary are swallowed.
 - **`ctx.llm`, `ctx.rooms`, and `ctx.connections` are on mutation + action only, NOT query** (reactive purity). `action` has no direct `ctx.db`; use `ctx.runQuery` / `ctx.runMutation`.
-- **`ctx.llm.stream(request, onEvent)` streams tokens as they generate** and still resolves with the full response, so `stop_reason === "tool_use"` drives an agent tool loop. Events are `text_delta` / `tool_use_start` / `tool_input_delta` / `done`. Same auth + model-allowlist gating as `ctx.llm.complete`. Streaming does NOT extend the call deadline (`PYLON_FN_CALL_TIMEOUT`, 30s default) — set `timeout: <secs>` on the def for a long run.
+- **`ctx.llm.stream(request, onEvent)` streams tokens as they generate** and still resolves with the full response, so `stop_reason === "tool_use"` drives an agent tool loop. Events are `text_delta` / `tool_use_start` / `tool_input_delta` / `done`. Same auth + model-allowlist gating as `ctx.llm.complete`. The call timeout is an idle timeout (`PYLON_FN_CALL_TIMEOUT`, 30s default; Stack0 Cloud 300s): each stream event resets it, and the total run is capped at 10× the timeout. Set `timeout: <secs>` on the def when a step (a slow tool call) can be silent longer than that.
 - **`ctx.stream.write(text)` streams to the caller — and every fn stream is RESUMABLE**: the server buffers frames under a stream id (`streamFn`'s `onStreamId`), so a dropped connection or closed tab catches up via `resumeStream(id)`, including the final result after the handler finished. `ctx.rooms.broadcast(room, topic, data)` fans out to every CURRENTLY-CONNECTED subscriber (second device, second tab) but does not replay missed messages — use the stream id for anything that must survive a gap. Broadcast resolves `{ delivered: false }` when the room has no members — a no-op, not an error. Clients receive with `useRoomMessages(room, cb)` from `@pylonsync/react`; `useRoom` is the send side.
 - **It's `db.useQueryOne`, not `useOne`.** Validators and field types have aliases: `v.bool`/`v.boolean`, `v.float`/`v.number`.
 - **Use the supported file and scheduling APIs.** Files go through `<FileUpload>` and `/api/files/*`; an upload is readable by its uploader only, so pass `visibility: "public"` to `uploadFile` or `<FileUpload>` for files every visitor sees; there is no `ctx.files`. One-shot work uses `ctx.scheduler.runAfter`, `runAt`, or `cancel`; there is no `defineWorkflow` or `defineJob`. Recurring work uses `cron("0 * * * *", "fnName")` in `buildManifest({ crons: [...] })`, imported from `@pylonsync/sdk`. Make the target function `internal: true`. It runs with anonymous auth, but its own `ctx.db.*` calls are server-side and bypass policies. Use `ctx.auth.elevate({ admin: true, reason: "..." })`, with a mandatory reason, only when chaining another internal function through `ctx.scheduler`.

package/templates/helpdesk/AGENTS.md

@@ -62,7 +62,7 @@ this pass before the user has to ask.
 - **`serverData` (SSR) is READ-ONLY.** No write methods; the runtime rejects write frames (`SSR_WRITE_FORBIDDEN`). Mutations belong in actions/functions, never in a page render.
 - **`response.*` / `response.redirect()` / `response.notFound()` must fire in the synchronous shell render**, before any `await` / `<Suspense>`. The HTTP head commits when the shell is ready; status/headers/cookies set from a suspended subtree are lost, and `redirect`/`notFound` thrown below a Suspense boundary are swallowed.
 - **`ctx.llm`, `ctx.rooms`, and `ctx.connections` are on mutation + action only, NOT query** (reactive purity). `action` has no direct `ctx.db`; use `ctx.runQuery` / `ctx.runMutation`.
-- **`ctx.llm.stream(request, onEvent)` streams tokens as they generate** and still resolves with the full response, so `stop_reason === "tool_use"` drives an agent tool loop. Events are `text_delta` / `tool_use_start` / `tool_input_delta` / `done`. Same auth + model-allowlist gating as `ctx.llm.complete`. Streaming does NOT extend the call deadline (`PYLON_FN_CALL_TIMEOUT`, 30s default) — set `timeout: <secs>` on the def for a long run.
+- **`ctx.llm.stream(request, onEvent)` streams tokens as they generate** and still resolves with the full response, so `stop_reason === "tool_use"` drives an agent tool loop. Events are `text_delta` / `tool_use_start` / `tool_input_delta` / `done`. Same auth + model-allowlist gating as `ctx.llm.complete`. The call timeout is an idle timeout (`PYLON_FN_CALL_TIMEOUT`, 30s default; Stack0 Cloud 300s): each stream event resets it, and the total run is capped at 10× the timeout. Set `timeout: <secs>` on the def when a step (a slow tool call) can be silent longer than that.
 - **`ctx.stream.write(text)` streams to the caller — and every fn stream is RESUMABLE**: the server buffers frames under a stream id (`streamFn`'s `onStreamId`), so a dropped connection or closed tab catches up via `resumeStream(id)`, including the final result after the handler finished. `ctx.rooms.broadcast(room, topic, data)` fans out to every CURRENTLY-CONNECTED subscriber (second device, second tab) but does not replay missed messages — use the stream id for anything that must survive a gap. Broadcast resolves `{ delivered: false }` when the room has no members — a no-op, not an error. Clients receive with `useRoomMessages(room, cb)` from `@pylonsync/react`; `useRoom` is the send side.
 - **It's `db.useQueryOne`, not `useOne`.** Validators and field types have aliases: `v.bool`/`v.boolean`, `v.float`/`v.number`.
 - **Use the supported file and scheduling APIs.** Files go through `<FileUpload>` and `/api/files/*`; an upload is readable by its uploader only, so pass `visibility: "public"` to `uploadFile` or `<FileUpload>` for files every visitor sees; there is no `ctx.files`. One-shot work uses `ctx.scheduler.runAfter`, `runAt`, or `cancel`; there is no `defineWorkflow` or `defineJob`. Recurring work uses `cron("0 * * * *", "fnName")` in `buildManifest({ crons: [...] })`, imported from `@pylonsync/sdk`. Make the target function `internal: true`. It runs with anonymous auth, but its own `ctx.db.*` calls are server-side and bypass policies. Use `ctx.auth.elevate({ admin: true, reason: "..." })`, with a mandatory reason, only when chaining another internal function through `ctx.scheduler`.

package/templates/imessage/.env.example

@@ -42,8 +42,6 @@ IMESSAGE_TRANSPORT=sendblue
 # IMESSAGE_ALLOW_DEV_SENDS=1
 
 # ── Production only ──────────────────────────────────────────────────────────
-# The server runs the agent as the owner by calling its own API. It needs its
-# public origin and the admin token to open that session. `pylon dev` needs
-# neither (it falls back to http://127.0.0.1:$PYLON_PORT).
+# The public origin the Setup page uses for the webhook and relay URLs.
+# `pylon dev` falls back to http://127.0.0.1:$PYLON_PORT.
 # APP_URL=https://assistant.example.com
-# PYLON_ADMIN_TOKEN=

package/templates/imessage/AGENTS.md

@@ -14,9 +14,10 @@ transports, the owner model, and production setup.
   on the transport's message id, allowlist and rate limit (`lib/gate.ts`), then
   schedule `processTurn`. Do not add a second path that skips it.
 - **The agent is `functions/assistant.ts` (`agent()`, `auth: "admin"`).**
-  `processTurn` runs it as the owner through `lib/agent-call.ts`. Tools must
-  resolve their contact with `currentTurn(ctx)` and never accept a contact,
-  handle, or id from the model.
+  `processTurn` runs it as the owner with `ctx.agents.run`, passing the
+  conversation and turn as the run's `context`. Tools must resolve their
+  contact with `currentTurn(ctx, run)` and never accept a contact, handle, or
+  id from the model.
 - **The dashboard is owner-only.** Every entity policy is `auth.isAdmin`; the
   owner is the verified email in `PYLON_ADMIN_EMAILS`.
 - **AppleScript:** `relay/applescript.ts` passes text and handle as argv to a
@@ -68,7 +69,7 @@ transports, the owner model, and production setup.
 - **`serverData` (SSR) is READ-ONLY.** No write methods; the runtime rejects write frames (`SSR_WRITE_FORBIDDEN`). Mutations belong in actions/functions, never in a page render.
 - **`response.*` / `response.redirect()` / `response.notFound()` must fire in the synchronous shell render**, before any `await` / `<Suspense>`. The HTTP head commits when the shell is ready; status/headers/cookies set from a suspended subtree are lost, and `redirect`/`notFound` thrown below a Suspense boundary are swallowed.
 - **`ctx.llm`, `ctx.rooms`, and `ctx.connections` are on mutation + action only, NOT query** (reactive purity). `action` has no direct `ctx.db`; use `ctx.runQuery` / `ctx.runMutation`.
-- **`ctx.llm.stream(request, onEvent)` streams tokens as they generate** and still resolves with the full response, so `stop_reason === "tool_use"` drives an agent tool loop. Events are `text_delta` / `tool_use_start` / `tool_input_delta` / `done`. Same auth + model-allowlist gating as `ctx.llm.complete`. Streaming does NOT extend the call deadline (`PYLON_FN_CALL_TIMEOUT`, 30s default) — set `timeout: <secs>` on the def for a long run.
+- **`ctx.llm.stream(request, onEvent)` streams tokens as they generate** and still resolves with the full response, so `stop_reason === "tool_use"` drives an agent tool loop. Events are `text_delta` / `tool_use_start` / `tool_input_delta` / `done`. Same auth + model-allowlist gating as `ctx.llm.complete`. The call timeout is an idle timeout (`PYLON_FN_CALL_TIMEOUT`, 30s default; Stack0 Cloud 300s): each stream event resets it, and the total run is capped at 10× the timeout. Set `timeout: <secs>` on the def when a step (a slow tool call) can be silent longer than that.
 - **`ctx.stream.write(text)` streams to the caller — and every fn stream is RESUMABLE**: the server buffers frames under a stream id (`streamFn`'s `onStreamId`), so a dropped connection or closed tab catches up via `resumeStream(id)`, including the final result after the handler finished. `ctx.rooms.broadcast(room, topic, data)` fans out to every CURRENTLY-CONNECTED subscriber (second device, second tab) but does not replay missed messages — use the stream id for anything that must survive a gap. Broadcast resolves `{ delivered: false }` when the room has no members — a no-op, not an error. Clients receive with `useRoomMessages(room, cb)` from `@pylonsync/react`; `useRoom` is the send side.
 - **It's `db.useQueryOne`, not `useOne`.** Validators and field types have aliases: `v.bool`/`v.boolean`, `v.float`/`v.number`.
 - **Use the supported file and scheduling APIs.** Files go through `<FileUpload>` and `/api/files/*`; an upload is readable by its uploader only, so pass `visibility: "public"` to `uploadFile` or `<FileUpload>` for files every visitor sees; there is no `ctx.files`. One-shot work uses `ctx.scheduler.runAfter`, `runAt`, or `cancel`; there is no `defineWorkflow` or `defineJob`. Recurring work uses `cron("0 * * * *", "fnName")` in `buildManifest({ crons: [...] })`, imported from `@pylonsync/sdk`. Make the target function `internal: true`. It runs with anonymous auth, but its own `ctx.db.*` calls are server-side and bypass policies. Use `ctx.auth.elevate({ admin: true, reason: "..." })`, with a mandatory reason, only when chaining another internal function through `ctx.scheduler`.

package/templates/imessage/README.md

@@ -55,8 +55,8 @@ real texts arrive.
   history; after 80 turns a new run starts with the last few texts as context.
 - **Tools.** `remember_note`, `recall_notes`, `forget_note`, `set_reminder`,
   `list_reminders`, `cancel_reminder`. They act only on the person being
-  answered: the contact comes from the server (`functions/resolveTurn.ts`),
-  never from the model. Reminders run on Pylon's job scheduler
+  answered: the contact comes from the server (the run's context and
+  `functions/resolveTurn.ts`), never from the model. Reminders run on Pylon's job scheduler
   (`ctx.scheduler.runAt` → `functions/fireReminder.ts`).
 - **Replies** are converted from Markdown to plain text and split into up to
   four bubbles along paragraph breaks (`lib/chunk.ts`).
@@ -64,15 +64,15 @@ real texts arrive.
   owner is the account whose verified email is in `PYLON_ADMIN_EMAILS`.
   Anonymous visitors and other accounts read nothing.
 
-### Why the server calls itself
+### How a turn runs the agent
 
-`agent()` stores each run under the signed-in user who called it. A webhook
-has no user, so `processTurn` opens a session for the owner
-(`POST /api/auth/session`) and calls `/api/fn/assistant` over HTTP
-(`lib/agent-call.ts`). The session token stays in server memory. In
-`pylon dev` this needs nothing. In production set `PYLON_ADMIN_TOKEN` (only the
-server uses it, to open that session). The call goes to `127.0.0.1:$PYLON_PORT`
-when the port is known, otherwise to `APP_URL`, which must be https.
+`agent()` stores each run under a user. A webhook has no user, so
+`processTurn` (an internal action) calls `ctx.agents.run("assistant", ...)` with
+`as: { userId: <owner>, admin: true }`. The run belongs to the owner and shows
+up live in the dashboard. The call also passes `context: { conversationId,
+turnId }`; the tools read it from their `run` argument, and `resolveTurn`
+maps it to the contact only while that turn is running. Only server code can
+set a run's context.
 
 ## Transport 1: Sendblue
 
@@ -155,7 +155,7 @@ How the relay works (`relay/main.ts`):
 | `SENDBLUE_*` | The Sendblue transport. |
 | `RELAY_TOKEN` | The relay transport. At least 24 characters. |
 | `IMESSAGE_DRY_RUN=1` | Store replies without sending them (both transports). Always on in `pylon dev` unless `IMESSAGE_ALLOW_DEV_SENDS=1`. |
-| `PYLON_ADMIN_TOKEN`, `APP_URL` | Production: how the server reaches its own API to run the agent. `APP_URL` must be https and is used only when `PYLON_PORT` is not set. |
+| `APP_URL` | Production: the public origin the Setup page uses for the webhook and relay URLs. |
 
 The Setup page shows which of these are set (never their values), when the
 last text came in, and when the relay last checked in.
@@ -170,8 +170,8 @@ Covers webhook verification (valid, wrong, missing, unconfigured secret),
 idempotency, the allowlist and rate limit, STOP/START, relay token auth,
 AppleScript argument passing (including a real `osascript` echo run on macOS
 with quotes, backslashes, newlines, and unicode), the chat.db reader against a
-fixture database built in a temp directory, the agent call over SSE, and
-reply chunking. Nothing in the suite sends a message or calls Sendblue.
+fixture database built in a temp directory, the agent turn and its tool
+fence, and reply chunking. Nothing in the suite sends a message or calls Sendblue.
 
 ## Deploy
 
@@ -180,7 +180,7 @@ pylon deploy
 pylon secrets set PYLON_ADMIN_EMAILS=you@example.com ANTHROPIC_API_KEY=... \
   IMESSAGE_TRANSPORT=sendblue SENDBLUE_API_KEY=... SENDBLUE_API_SECRET=... \
   SENDBLUE_FROM_NUMBER=+1... SENDBLUE_WEBHOOK_SECRET=... \
-  APP_URL=https://<your app> PYLON_ADMIN_TOKEN=<openssl rand -hex 32>
+  APP_URL=https://<your app>
 ```
 
 Sign-in codes in production need an email provider (`PYLON_EMAIL_PROVIDER`);

package/templates/imessage/app/console.tsx

@@ -55,7 +55,7 @@ interface AgentRunRow {
   steps?: number | null;
   error?: string | null;
   updatedAt: string;
-  title?: string | null;
+  context?: { conversationId?: string } | null;
 }
 interface AgentMessageRow {
   id: string;
@@ -242,10 +242,10 @@ export function Console({ view, initialConversationId }: { view: View; initialCo
     const contact = conversation ? contactById.get(conversation.contactId) : undefined;
     const threadMessages = conversation ? (messages ?? []).filter((m) => m.conversationId === conversation.id) : [];
     const unanswered = threadMessages.filter((m) => m.direction === "in" && UNANSWERED.has(m.status)).length;
-    const runRow = conversation ? (runs ?? []).find((r) => r.id === conversation.agentRunId || r.title === conversation.id) : undefined;
+    const runRow = conversation ? (runs ?? []).find((r) => r.id === conversation.agentRunId || r.context?.conversationId === conversation.id) : undefined;
     const activity: PanelActivity[] = [];
     if (conversation) {
-      const runIds = new Set((runs ?? []).filter((r) => r.title === conversation.id).map((r) => r.id));
+      const runIds = new Set((runs ?? []).filter((r) => r.id === conversation.agentRunId || r.context?.conversationId === conversation.id).map((r) => r.id));
       const refusals = new Map<string, string | null>();
       for (const m of agentMessages ?? []) {
         if (!runIds.has(m.runId) || m.role !== "user" || !Array.isArray(m.content)) continue;

package/templates/imessage/components/setup-view.tsx

@@ -9,7 +9,6 @@ export interface SetupStatus {
   checklist: { key: string; label: string; ok: boolean; hint: string }[];
   provider: { configured: boolean; provider: string | null };
   ownerConfigured: boolean;
-  adminTokenSet: boolean;
   appUrlSet: boolean;
   devMode: boolean;
   baseUrl: string;
@@ -139,7 +138,7 @@ export function SetupView({
 function StatusGrid({ status, transport }: { status: SetupStatus; transport: TransportStateView | null }) {
   const online = relayOnline(transport?.relayLastSeenAt ?? null);
   const transportOk = status.transport !== null && status.checklist.every((c) => c.ok);
-  const needsProdConfig = !status.devMode && (!status.appUrlSet || !status.adminTokenSet);
+  const needsProdConfig = !status.devMode && !status.appUrlSet;
   return (
     <div className="mt-8 grid gap-3 sm:grid-cols-2">
       <StatusCard
@@ -200,13 +199,10 @@ function StatusGrid({ status, transport }: { status: SetupStatus; transport: Tra
         ok={!needsProdConfig}
         title="Server"
         lines={[
-          `Calls itself at ${status.baseUrl}`,
-          status.devMode
-            ? "Development mode: no admin token needed."
-            : status.adminTokenSet
-              ? "PYLON_ADMIN_TOKEN set."
-              : "Set PYLON_ADMIN_TOKEN so the server can open the owner's session for replies.",
-          ...(!status.devMode && !status.appUrlSet ? ["Set APP_URL to this app's public https origin."] : []),
+          `Public URL ${status.baseUrl}`,
+          ...(!status.devMode && !status.appUrlSet
+            ? ["Set APP_URL to this app's public https origin so the webhook and relay URLs are right."]
+            : []),
         ]}
       />
     </div>

package/templates/imessage/functions/assistant.ts

@@ -1,30 +1,13 @@
-import { agent, v, type ActionCtx } from "@pylonsync/functions";
+import { agent, v } from "@pylonsync/functions";
 import { ASSISTANT_MODEL, SYSTEM_PROMPT } from "../lib/assistant";
-
-interface Turn {
-  conversationId: string;
-  contactId: string;
-}
-
-// Which contact is this generation about? Every tool starts here. The agent
-// loop records its stream id on the AgentRun row it is working on, and
-// processTurn created that run with the conversation id as its title, so
-// resolveTurn can map this call back to exactly one contact. Nothing the
-// model or the texter writes can change that mapping.
-async function currentTurn(ctx: ActionCtx): Promise<Turn> {
-  const streamId = ctx.stream?.id;
-  if (!streamId) throw new Error("This tool is only available while answering a text.");
-  const turn = await ctx.runQuery<Turn | null>("resolveTurn", { streamId });
-  if (!turn) throw new Error("This tool is only available while answering a text.");
-  return turn;
-}
+import { currentTurn } from "../lib/turn";
 
 // The assistant. Pylon's agent() runs the tool loop, persists every turn into
 // AgentRun/AgentMessage (live in the dashboard), and streams tokens.
 //
-// auth "admin": only the owner's session may run it. processTurn calls it as
-// the owner for each inbound text (lib/agent-call.ts); any other account gets
-// FORBIDDEN before the model is called.
+// auth "admin": only the owner may run it. processTurn runs it as the owner
+// for each inbound text (ctx.agents.run); any other account gets FORBIDDEN
+// before the model is called.
 //
 // The tools act only on the contact of the current turn and never take a
 // contact, phone number, or id from the model.
@@ -40,23 +23,23 @@ export default agent({
       description:
         "Save a short fact about the person you are texting (a preference, a name, a date). One fact per call.",
       args: { text: v.string() },
-      handler: async (ctx, input) => {
-        const turn = await currentTurn(ctx);
+      handler: async (ctx, input, run) => {
+        const turn = await currentTurn(ctx, run);
         return ctx.runMutation("toolSaveNote", { contactId: turn.contactId, text: String(input.text) });
       },
     },
     recall_notes: {
       description: "List the facts saved about the person you are texting, newest first.",
-      handler: async (ctx) => {
-        const turn = await currentTurn(ctx);
+      handler: async (ctx, _input, run) => {
+        const turn = await currentTurn(ctx, run);
         return ctx.runQuery("toolListNotes", { contactId: turn.contactId });
       },
     },
     forget_note: {
       description: "Delete one saved fact about the person you are texting, by the id recall_notes returned.",
       args: { noteId: v.string() },
-      handler: async (ctx, input) => {
-        const turn = await currentTurn(ctx);
+      handler: async (ctx, input, run) => {
+        const turn = await currentTurn(ctx, run);
         return ctx.runMutation("toolForgetNote", { contactId: turn.contactId, noteId: String(input.noteId) });
       },
     },
@@ -64,8 +47,8 @@ export default agent({
       description:
         "Schedule a text to the person you are texting at a specific time. `when` is ISO 8601 with a UTC offset, e.g. 2026-10-03T09:00:00-05:00. `text` is the exact message they will receive.",
       args: { when: v.string(), text: v.string() },
-      handler: async (ctx, input) => {
-        const turn = await currentTurn(ctx);
+      handler: async (ctx, input, run) => {
+        const turn = await currentTurn(ctx, run);
         return ctx.runMutation("toolSetReminder", {
           contactId: turn.contactId,
           conversationId: turn.conversationId,
@@ -76,16 +59,16 @@ export default agent({
     },
     list_reminders: {
       description: "List the upcoming reminders for the person you are texting.",
-      handler: async (ctx) => {
-        const turn = await currentTurn(ctx);
+      handler: async (ctx, _input, run) => {
+        const turn = await currentTurn(ctx, run);
         return ctx.runQuery("toolListReminders", { contactId: turn.contactId });
       },
     },
     cancel_reminder: {
       description: "Cancel one upcoming reminder for the person you are texting, by the id list_reminders returned.",
       args: { reminderId: v.string() },
-      handler: async (ctx, input) => {
-        const turn = await currentTurn(ctx);
+      handler: async (ctx, input, run) => {
+        const turn = await currentTurn(ctx, run);
         return ctx.runMutation("toolCancelReminder", {
           contactId: turn.contactId,
           reminderId: String(input.reminderId),

package/templates/imessage/functions/processTurn.ts

@@ -1,5 +1,5 @@
 import { action, v } from "@pylonsync/functions";
-import { runAgentAsOwner } from "../lib/agent-call";
+import { AGENT_NAME } from "../lib/assistant";
 import { chunkReply } from "../lib/chunk";
 import { providerStatus } from "../lib/provider";
 
@@ -47,27 +47,28 @@ export default action({
         return { state: "awaiting_setup" };
       }
 
-      const outcome = await runAgentAsOwner(ctx.env, owner.userId, {
+      // The run belongs to the owner, so it shows up live in the dashboard.
+      // `admin: true` because the assistant is declared auth: "admin".
+      // The context tells the tools which conversation and turn they act on
+      // (functions/assistant.ts); only server code can set it.
+      const result = await ctx.agents.run(AGENT_NAME, {
         input: begin.input,
         ...(begin.runId ? { runId: begin.runId } : {}),
-        // The run's title carries the conversation id. The agent's tools read
-        // it back (functions/resolveTurn.ts) to know which contact they act on.
-        title: begin.conversationId,
+        as: { userId: owner.userId, admin: true },
+        context: { conversationId: begin.conversationId, turnId: begin.turnId },
       });
-      if (!outcome.ok) {
-        await finish({ outcome: "failed", detail: `${outcome.code}: ${outcome.message}`.slice(0, 500) });
-        return { state: "failed" };
-      }
-      const chunks = chunkReply(outcome.result.text);
+      const chunks = chunkReply(result.text);
       if (chunks.length === 0) {
-        await finish({ outcome: "failed", detail: "The model returned an empty reply", runId: outcome.result.runId });
+        await finish({ outcome: "failed", detail: "The model returned an empty reply", runId: result.runId });
         return { state: "failed" };
       }
-      await finish({ outcome: "answered", runId: outcome.result.runId, chunks });
+      await finish({ outcome: "answered", runId: result.runId, chunks });
       return { state: "answered", bubbles: chunks.length };
     } catch (err) {
+      const code = (err as { code?: unknown })?.code;
       const message = err instanceof Error ? err.message : String(err);
-      await finish({ outcome: "failed", detail: message.slice(0, 500) });
+      const detail = typeof code === "string" ? `${code}: ${message}` : message;
+      await finish({ outcome: "failed", detail: detail.slice(0, 500) });
       return { state: "failed" };
     }
   },

package/templates/imessage/functions/resolveTurn.ts

@@ -1,25 +1,20 @@
 import { query, v } from "@pylonsync/functions";
-import { AGENT_NAME } from "../lib/assistant";
 
-// Map the agent's current stream id to the conversation it is answering.
-// Internal: called by the assistant's tools only (functions/assistant.ts).
+// The contact a tool call acts on. Internal: called by the assistant's tools
+// only (functions/assistant.ts), with the conversation and turn that
+// processTurn put in the agent run's context.
 //
-// Returns null unless all of these hold:
-//   - an AgentRun of the assistant carries this stream id and belongs to the caller
-//   - its title is a conversation id (processTurn sets it)
-//   - that conversation has a turn running right now
+// Returns null unless that conversation exists and that exact turn is still
+// running, so a tool cannot act for a finished turn (for example when the
+// owner continues the run from the dashboard later).
 export default query({
   internal: true,
   auth: "admin",
-  args: { streamId: v.string() },
+  args: { conversationId: v.string(), turnId: v.string() },
   async handler(ctx, args) {
-    if (args.streamId === "") return null;
-    const runs = await ctx.db.query("AgentRun", { streamId: args.streamId, $limit: 2 });
-    if (runs.length !== 1) return null;
-    const run = runs[0];
-    if (run.agent !== AGENT_NAME || run.userId !== ctx.auth.userId || run.status !== "running") return null;
-    const conversation = await ctx.db.get("Conversation", String(run.title ?? ""));
-    if (!conversation || conversation.turnState !== "running") return null;
+    if (args.conversationId === "" || args.turnId === "") return null;
+    const conversation = await ctx.db.get("Conversation", args.conversationId);
+    if (!conversation || conversation.turnState !== "running" || conversation.turnId !== args.turnId) return null;
     return { conversationId: String(conversation.id), contactId: String(conversation.contactId) };
   },
 });