experimental-ash 0.2.0-alpha.2 → 0.2.0-alpha.21

package/docs/public/session-context.md

@@ -1,8 +1,11 @@
 # Session Context
 
-Ash exposes three runtime helpers for authored code:
+Ash exposes six runtime helpers for authored code:
 
 - `getSession()`
+- `getContext(key)`
+- `setContext(key, value)`
+- `ensureContext(key, valueOrFactory)`
 - `getSandbox(name)`
 - `getSkill(identifier)`
 
@@ -26,13 +29,12 @@ export default defineTool({
     const session = getSession();
 
     return {
-      runId: session.runId,
       sessionId: session.sessionId,
       turnId: session.turn.id,
       turnSequence: session.turn.sequence,
       currentCaller: session.auth.current?.principalId,
       initiator: session.auth.initiator?.principalId,
-      parentRunId: session.parent?.runId,
+      parentSessionId: session.parent?.sessionId,
     };
   },
 });
@@ -43,7 +45,6 @@ Public session fields:
 - `auth.current`
 - `auth.initiator`
 - `sessionId`
-- `runId`
 - `turn.id`
 - `turn.sequence`
 - optional `parent`
@@ -53,8 +54,8 @@ Important behavior:
 - `auth.current` is the caller for the active inbound turn
 - `auth.initiator` is the caller that started the durable session
 - unprotected agents expose both as `null`
-- top-level schedule runs expose a framework-owned `schedule` principal
-- `parent` is present for child subagent runs
+- top-level schedule sessions expose a framework-owned `schedule` principal
+- `parent` is present for child subagent sessions
 
 ## `getSandbox(name)`
 
@@ -95,6 +96,120 @@ Important behavior:
 
 See [`skills.md`](./skills.md) for the full authoring model.
 
+## Durable Authored Context
+
+`ContextKey` values are session-durable by default. Once authored code sets a key, Ash hydrates it
+from `session.context` before later steps and commits it back after each step.
+
+```ts
+import { ContextKey, ensureContext, getContext, setContext } from "experimental-ash";
+
+const TenantKey = new ContextKey<string>("myapp.tenant");
+const NotesKey = new ContextKey<{ readonly notes: readonly string[] }>("myapp.notes");
+
+const tenant = getContext(TenantKey);
+const notes = ensureContext(NotesKey, () => ({ notes: [] }));
+
+setContext(NotesKey, {
+  notes: [...notes.notes, `Handled tenant ${tenant}`],
+});
+```
+
+Use `ensureContext` when a key needs a default value. `ContextKey({ initial })` no longer exists.
+
+## Passing Custom Context From a Channel
+
+Channels can inject custom typed context into the agent inside `onDeliver`. This is useful when a
+channel needs to pass platform-specific metadata (tenant ID, feature flags, etc.) that authored
+tools can read.
+
+### Defining a key
+
+Declare a `ContextKey` at module scope. The key is shared between the channel and the tools that
+read it.
+
+`agent/channels/keys.ts`
+
+```ts
+import { ContextKey } from "experimental-ash";
+
+export const TenantKey = new ContextKey<string>("myapp.tenant");
+```
+
+### Setting context from a channel
+
+Wrap an existing channel with `onDeliver` to set custom context keys. The hook receives a narrow
+`ContextAccessor` (`get`, `tryGet`, `has`, `set`, `ensure`) as its first argument and a
+`DeliverPayload` as the second. It runs on both `run()` and `deliver()`, after Ash has hydrated the
+durable context bag for that turn.
+
+`agent/channels/slack.ts`
+
+```ts
+import {
+  slackRoute,
+  SlackChannel,
+  type SlackChannelState,
+} from "experimental-ash/channels/slack";
+import { TenantKey } from "./keys.js";
+
+interface TenantSlackState extends SlackChannelState {
+  readonly tenantId: string;
+}
+
+class TenantSlackChannel extends SlackChannel<TenantSlackState> {
+  static override readonly kind = "tenant-slack";
+
+  constructor(state: SlackChannelState) {
+    super({
+      ...state,
+      tenantId: lookupTenant(state),
+    });
+  }
+
+  async onDeliver(ctx, payload) {
+    ctx.set(TenantKey, this.state().tenantId);
+    return await super.onDeliver(ctx, payload);
+  }
+}
+
+export default slackRoute({
+  channel: TenantSlackChannel,
+});
+```
+
+Auth lives on `RunInput.auth` and `DeliverInput.auth`, not on the channel object. There is no
+`withAuth` or `withContext` wrapper.
+
+Keep channel constructor state immutable after the run starts. Stable transport identity belongs in
+serialized channel state; mutable per-session data belongs in durable context or `session.internal`.
+
+### Reading context from a tool
+
+```ts
+import { getContext } from "experimental-ash";
+import { defineTool } from "experimental-ash/tools";
+import { TenantKey } from "../channels/keys.js";
+
+export default defineTool({
+  description: "Return the active tenant.",
+  async execute() {
+    const tenant = getContext(TenantKey);
+    return { tenant };
+  },
+});
+```
+
+### Context on deliver
+
+`onDeliver` runs on every turn, including `deliver()` follow-ups. The channel is deserialized from
+the session, so its stable serialized state (including custom fields like `tenantId`) is available
+on follow-up turns.
+
+Auth on `deliver()` is also honored — `session.auth.current` reflects the caller of each follow-up
+message, not just the session initiator. Deliver-time auth is passed via `DeliverInput.auth` and the
+runtime applies it directly.
+
 ## Where These APIs Work
 
 Safe places:
@@ -114,17 +229,18 @@ explaining the required scope.
 
 ## How It Works
 
-All three accessors read from the same `AshContext` container bound by a single `AsyncLocalStorage`.
-The framework sets up this context before invoking authored code:
+All runtime helpers read from the same `AshContext` container bound by a single
+`AsyncLocalStorage`. The framework sets up this context before invoking authored code:
 
-1. The runtime entry point creates an `AshContext` and populates seed keys (auth, session ID,
-   run ID, channel emitter, compiled bundle).
-2. Before each step, providers create derived values (session metadata, sandbox access, skill
-   access) from the seed keys and the harness session.
-3. The step callback runs inside the `AsyncLocalStorage` scope, making the context available to
+1. The runtime entry point creates an `AshContext` and serializes only runtime seed keys such as
+   auth, session id, channel, and compiled bundle.
+2. Before each step, Ash rebuilds a fresh context, hydrates durable authored context from
+   `session.context`, seeds runtime-only bookkeeping, and runs `channel.onDeliver(...)`.
+3. Providers create derived values such as session metadata, sandbox access, and skill access.
+4. The step callback runs inside the `AsyncLocalStorage` scope, making the context available to
    all authored code in the call chain.
-4. After the step, providers with mutable state (sandboxes, skills) commit their changes back onto
-   the session for persistence.
+5. After the step, Ash commits the full durable context bag back to `session.context` and lets
+   mutable providers persist any provider-owned state.
 
 This lifecycle is fully managed by the framework. Authored code only needs to call the public
 accessors.

package/docs/public/skills.md

@@ -16,17 +16,23 @@ single turn.
 ## How Skill Loading Works
 
 Ash discovers the files under `skills/`, advertises them to the model, and adds a framework-owned
-`activate_skill` tool.
+`load_skill` tool.
 
-When the model decides a skill is relevant, it calls `activate_skill`. Ash then adds that skill's
+When the model decides a skill is relevant, it calls `load_skill`. Ash then adds that skill's
 instructions to the active turn context.
 
+In practice, the model should activate a skill when the user names it directly or when the request
+clearly matches the skill's description. That makes the description a routing hint, not just a
+label.
+
 Important behavior:
 
 - skills are not pasted into the base prompt by default
 - tools remain visible whether or not a skill is activated
 - skills are for instructions and procedures, not for executing code
 - if you need typed runtime behavior, use a tool
+- packaged skill paths are visible in the runtime workspace, so the model can inspect sibling files
+  with normal file or shell tools when needed
 
 ## Flat Markdown Skills
 
@@ -92,6 +98,25 @@ export default defineTool({
 - flat skills may omit frontmatter
 - the legacy `allowed-tools` frontmatter field is not supported
 
+## Write Good Descriptions
+
+Skill descriptions should describe the task that should trigger activation.
+
+Prefer descriptions like:
+
+- `Use when the user needs a release checklist or changelog workflow.`
+- `Research unfamiliar topics before answering with confidence.`
+- `Use the weather tool before answering forecast or temperature questions.`
+
+Avoid vague descriptions like:
+
+- `Helpful workflow`
+- `General assistant support`
+- `Misc utilities`
+
+Better descriptions improve automatic routing quality because Ash exposes them to the model as the
+main signal for when a skill should be activated.
+
 ## When To Use A Skill
 
 Use a skill for:
@@ -163,4 +188,3 @@ For most apps:
 - [`context-control.md`](./context-control.md)
 - [`tools.md`](./tools.md)
 - [`subagents.md`](./subagents.md)
-

package/docs/public/subagents.md

@@ -58,13 +58,13 @@ Subagent execution gets:
 
 ## Stream Behavior
 
-Subagent activity is emitted inline on the parent run stream:
+Subagent activity is emitted inline on the parent session stream:
 
 - `subagent.started`
 - `subagent.event`
 - `subagent.completed`
 
-There is no separate public child-run stream to attach to.
+There is no separate public child-session stream to attach to.
 
 ## What Subagents Can Declare
 

package/docs/public/tools.md

@@ -24,7 +24,6 @@ export default defineTool({
 
     return {
       city: input.city,
-      runId: session.runId,
       sessionId: session.sessionId,
       temperatureF: 72,
     };
@@ -37,8 +36,8 @@ exposed to the model as `get_weather`; a file at `agent/tools/get-weather.ts` is
 `get-weather`. You can override that by setting `name` in the tool definition.
 
 `defineTool`, `disableTool`, `defineBashTool`, `defineReadFileTool`, and `defineWriteFileTool` live on the `experimental-ash/tools` subpath.
-Runtime helpers like `getSession`, `getSandbox`, `getSkill`, `getState`, and `setState` stay on the
-main `experimental-ash` barrel.
+Runtime helpers like `getSession`, `getContext`, `setContext`, `ensureContext`, `getSandbox`, and
+`getSkill` stay on the main `experimental-ash` barrel.
 
 ## What A Tool Definition Needs
 
@@ -75,7 +74,7 @@ export default defineTool({
 
 Tools are the most common place to use Ash's runtime helpers:
 
-- `getSession()` for run, turn, auth, and parent lineage data
+- `getSession()` for session, turn, auth, and parent lineage data
 - `getSandbox(name)` for live isolated shell environments
 - `getSkill(identifier)` for reading skill metadata and packaged skill files
 
@@ -100,12 +99,15 @@ That means tools are:
 
 Every Ash agent gets a small set of framework-provided tools by default:
 `bash`, `read_file`, `write_file`, `todo`, `web_fetch`, `web_search`, and, when the agent has skills,
-`activate_skill`.
+`load_skill`.
+
+`load_skill` loads on-demand skill instructions into the current turn. It does not add a new
+execution surface by itself; executable behavior still comes from the tools the agent already has.
 
 `read_file` reads a text file from the sandbox filesystem with line-numbered output. `write_file`
 writes a complete file, enforcing read-before-write for existing files and detecting stale reads.
-Both target the framework default sandbox. Compaction clears the durable read-file state so the model
-must re-read files before overwriting after compaction.
+Both target the framework default sandbox. Compaction clears the durable read-file context so the
+model must re-read files before overwriting after compaction.
 
 Authors can wrap, replace, or disable these defaults from `agent/tools/`.
 
@@ -223,32 +225,23 @@ export default defineWriteFileTool({
 ```
 
 When replacing the framework `read_file`, the authored version inherits the same compaction
-state-reset behavior by default. Provide an explicit `onCompact` to override that.
+context-reset behavior by default. Provide an explicit `onCompact` to override that.
 
-### Replace A Default With Custom State
+### Replace A Default With Custom Context
 
-`agent/tools/todo.ts` - replace the framework `todo` tool with a custom stateful version. State is
-the replacement's responsibility. Declare your own `ContextKey` and use `getState` / `setState` to
-read and write it:
+`agent/tools/todo.ts` - replace the framework `todo` tool with a custom durable-context version.
+Declare your own `ContextKey` and use `ensureContext` / `setContext` to read and write it:
 
 ```ts
-import { ContextKey, getState, setState } from "experimental-ash";
+import { ContextKey, ensureContext, setContext } from "experimental-ash";
 import { defineTool } from "experimental-ash/tools";
 import { z } from "zod";
 
-interface NoteListState {
+interface NoteListContext {
   readonly notes: readonly string[];
 }
 
-const NoteListStateKey = new ContextKey<NoteListState>("myapp.notes", {
-  initial: () => ({ notes: [] }),
-  compact: (state) => ({
-    summary:
-      state.notes.length === 0
-        ? undefined
-        : `Notes (${state.notes.length}): ${state.notes.join("; ")}`,
-  }),
-});
+const NoteListContextKey = new ContextKey<NoteListContext>("myapp.notes");
 
 export default defineTool({
   description: "Append a note or read the running list of notes.",
@@ -257,12 +250,12 @@ export default defineTool({
   }),
   async execute(input) {
     if (typeof input.note === "string" && input.note.length > 0) {
-      const next = input.note;
-      setState(NoteListStateKey, (current) => ({
-        notes: [...current.notes, next],
-      }));
+      const current = ensureContext(NoteListContextKey, () => ({ notes: [] }));
+      setContext(NoteListContextKey, {
+        notes: [...current.notes, input.note],
+      });
     }
-    return getState(NoteListStateKey);
+    return ensureContext(NoteListContextKey, () => ({ notes: [] }));
   },
 });
 ```
@@ -270,8 +263,8 @@ export default defineTool({
 ### Subtleties Worth Knowing
 
 - The filename is the default name. There is also an explicit `name` property when you need it.
-- State is owned by the replacement. Replacing `todo` with a fresh `defineTool` does not inherit the
-  framework's state key.
+- Durable context is owned by the replacement. Replacing `todo` with a fresh `defineTool` does not
+  inherit the framework's context key.
 - Authored-vs-authored collisions are impossible by construction. Two files cannot share a slug under
   the same `agent/tools/` directory.
 

package/docs/public/typescript-api.md

@@ -17,7 +17,7 @@ Use these to author the filesystem-backed surface. Tool authoring helpers live o
 on the main `experimental-ash` barrel.
 
 - `defineAgent(...)` - additive runtime config for `agent.ts`
-- `defineChannel(...)` - messaging-platform or HTTP channel entrypoints in `channels/`
+- `defineRoute(...)` - messaging-platform or HTTP route entrypoints in `channels/`
 - `defineSandbox(...)` - isolated bash-style environments in `sandboxes/`
 - `defineSchedule(...)` - recurring jobs in `schedules/`
 - `defineSkill(...)` - module-authored skills
@@ -28,22 +28,24 @@ on the main `experimental-ash` barrel.
 - `defineReadFileTool(...)` - model-visible file reader targeting a named sandbox
 - `defineWriteFileTool(...)` - model-visible file writer targeting a named sandbox
 - `disableTool()` - disable the framework default whose name matches `tools/<name>.ts`
-- `disableChannel()` - disable a framework-owned channel that matches the file path
+- `disableRoute()` - disable a framework-owned route that matches the file path
 - `defineEvalSuite(...)` - repeatable eval suite under `evals/*.eval.ts`
 
 Framework defaults reachable for spread/wrap composition:
 
-- `bash`, `readFile`, `writeFile`, `webFetch`, `todo`, `activateSkill` (`experimental-ash/tools/defaults`)
+- `bash`, `readFile`, `writeFile`, `webFetch`, `todo`, `loadSkill` (`experimental-ash/tools/defaults`)
 - `defaultSandbox` (`experimental-ash/sandboxes/defaults`)
 
 Most apps use `defineAgent`, `defineTool`, and `defineSandbox` the most.
 
 ## Runtime Helpers
 
-- `getSession()` - current run, turn, auth, and optional parent lineage
+- `getSession()` - current session, turn, auth, and optional parent lineage
+- `getContext(key)` - read one durable authored context value
+- `setContext(key, value)` - write one durable authored context value
+- `ensureContext(key, valueOrFactory)` - read-or-create one durable context value
 - `getSandbox(name)` - live named sandbox session
 - `getSkill(identifier)` - handle for a named skill visible to the current agent
-- `getState(key)` / `setState(key)` - context-backed runtime state helpers
 
 Related exported types:
 
@@ -56,11 +58,13 @@ Related exported types:
 Ash also exports lower-level runtime primitives such as `createToolLoopHarness(...)`,
 `createContinuousLoopRuntime(...)`, and `createWorkflowRuntime(...)`.
 
-`RunMode` is explicit: `"conversation"` runs may wait for follow-up input, while `"task"` runs must
-finish inside the current invocation.
+`RunMode` is explicit: `"conversation"` sessions may wait for follow-up input, while `"task"`
+sessions must finish inside the current invocation.
 
 These helpers only work inside active authored runtime execution.
 
+Breaking change details and before/after examples live in [`migration-guide.md`](./migration-guide.md).
+
 ## Markdown Helpers
 
 Ash also exports helpers for turning markdown into the same shapes as module-authored definitions:
@@ -81,11 +85,11 @@ shapes.
 import { defineAgent } from "experimental-ash";
 ```
 
-### Channel Definition
+### Route Definition
 
 ```ts
-import { defineChannel } from "experimental-ash";
-import { httpMessageChannel } from "experimental-ash/channels/http";
+import { defineRoute } from "experimental-ash";
+import { httpRoute } from "experimental-ash/channels/http";
 import { vercelOidc } from "experimental-ash/channels/auth";
 ```
 
@@ -108,7 +112,7 @@ import { defineBashTool } from "experimental-ash/tools";
 
 ```ts
 import { defineTool, disableTool } from "experimental-ash/tools";
-import { bash, readFile, writeFile, webFetch, todo, activateSkill } from "experimental-ash/tools/defaults";
+import { bash, readFile, writeFile, webFetch, todo, loadSkill } from "experimental-ash/tools/defaults";
 ```
 
 See [`tools.md`](./tools.md) for the full override patterns.
@@ -131,7 +135,7 @@ import { Braintrust } from "experimental-ash/evals/reporters";
 ## Where To Learn Each Surface
 
 - `defineAgent` -> [`agent-ts.md`](./agent-ts.md)
-- `defineChannel` and channel factories -> [`channels/README.md`](./channels/README.md)
+- `defineRoute` and route/channel factories -> [`channels/README.md`](./channels/README.md)
 - `defineTool`, `disableTool`, `defineBashTool`, `defineReadFileTool`, `defineWriteFileTool`, and `experimental-ash/tools/defaults` -> [`tools.md`](./tools.md)
 - `defineSandbox` and `getSandbox` -> [`sandboxes.md`](./sandboxes.md)
 - `getSession` -> [`session-context.md`](./session-context.md)

package/docs/public/vercel-deployment.md

@@ -9,7 +9,7 @@ This page covers the practical expectations for shipping an Ash app on Vercel.
 - use `ash build` for production builds
 - keep provider keys and auth secrets in Vercel environment variables
 - use the `vercel` workspace or sandbox backend when the app needs hosted command environments
-- expect Ash to expose the same stable health, message, and run-stream routes after deployment
+- expect Ash to expose the same stable health, message, and session-stream routes after deployment
 
 ## Build Output
 
@@ -76,7 +76,7 @@ curl -X POST https://<your-app>/.well-known/ash/v1/message \
 Then attach to the returned stream URL pattern:
 
 ```bash
-curl https://<your-app>/.well-known/ash/v1/runs/<runId>/stream
+curl https://<your-app>/.well-known/ash/v1/sessions/<sessionId>/stream
 ```
 
 ## Remote REPL
@@ -95,11 +95,10 @@ This is useful for smoke tests against preview or production environments.
 - route-auth secrets are set on the relevant channel
 - the default sandbox `adapter` matches the deployment environment
 - the health route responds
-- a test message run streams successfully
+- a test message session streams successfully
 
 ## What To Read Next
 
 - [`workspace.md`](./workspace.md)
 - [`sandboxes.md`](./sandboxes.md)
 - [`auth-and-route-protection.md`](./auth-and-route-protection.md)
-

package/docs/public/workspace.md

@@ -1,17 +1,17 @@
 # Workspace
 
-Every Ash run gets a shared runtime workspace exposed to the model as the `bash` tool.
+Every Ash session gets a shared runtime workspace exposed to the model as the `bash` tool.
 
 This workspace is for command-and-file work that should be shared across turns in the same durable
-run.
+session.
 
 ## What The Workspace Is
 
 Use the shared workspace when you want:
 
 - one place for the model to inspect files
-- one mutable command environment for the current run
-- command/file continuity across follow-up turns in the same run
+- one mutable command environment for the current session
+- command/file continuity across follow-up turns in the same session
 
 The workspace is not:
 
@@ -44,13 +44,13 @@ inspection to happen through runtime tools such as `bash`.
 
 ## Workspace Vs Sandboxes
 
-Use the workspace when you want one shared per-run shell.
+Use the workspace when you want one shared per-session shell.
 
 Use a sandbox when you want a separate named environment with its own lifecycle hooks.
 
 Quick comparison:
 
-- workspace -> one shared `bash` tool for the run
+- workspace -> one shared `bash` tool for the session
 - sandbox -> additional isolated bash-style tool surfaces
 
 See [`sandboxes.md`](./sandboxes.md) for the isolated case.
@@ -85,28 +85,28 @@ The live root that the `bash` tool sees depends on the active workspace adapter:
 - `local` -> `/workspace`
 - `vercel` -> `/vercel/sandbox/workspace`
 
-Ash includes the active live root in the runtime prompt for each run, so the model can inspect the
+Ash includes the active live root in the runtime prompt for each session, so the model can inspect the
 right location with `pwd`, `ls`, `find`, or `rg` instead of guessing.
 
 ## What Persists Across Turns
 
-The shared workspace can persist across turns for the same durable run.
+The shared workspace can persist across turns for the same durable session.
 
 That lets the model do workflows like:
 
 1. inspect files
 2. write or modify files
 3. wait for a follow-up message
-4. continue working in the same run
+4. continue working in the same session
 
-This persistence is run-scoped, not app-global.
+This persistence is session-scoped, not app-global.
 
 ## Good Uses
 
 Use the workspace for:
 
 - browsing skill files
-- temporary working files for a run
+- temporary working files for a session
 - simple command-driven workflows
 - shared scratch state across turns
 

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "experimental-ash",
-  "version": "0.2.0-alpha.2",
+  "version": "0.2.0-alpha.21",
   "type": "module",
   "main": "./dist/src/index.js",
   "types": "./dist/src/index.d.ts",
@@ -47,6 +47,11 @@
       "import": "./dist/src/public/tools/defaults.js",
       "default": "./dist/src/public/tools/defaults.js"
     },
+    "./connections": {
+      "types": "./dist/src/public/connections/index.d.ts",
+      "import": "./dist/src/public/connections/index.js",
+      "default": "./dist/src/public/connections/index.js"
+    },
     "./sandboxes": {
       "types": "./dist/src/public/sandboxes/index.d.ts",
       "import": "./dist/src/public/sandboxes/index.js",
@@ -100,31 +105,32 @@
     "./package.json": "./package.json"
   },
   "dependencies": {
-    "@ai-sdk/anthropic": "^3.0.68",
+    "@ai-sdk/anthropic": "^3.0.69",
     "@ai-sdk/google": "^3.0.61",
+    "@ai-sdk/mcp": "^1.0.36",
     "@ai-sdk/openai": "^3.0.52",
-    "@chat-adapter/slack": "^4.24.0",
-    "@chat-adapter/state-memory": "^4.24.0",
+    "@chat-adapter/slack": "^4.25.0",
+    "@chat-adapter/state-memory": "^4.25.0",
     "@standard-schema/spec": "^1.1.0",
     "@vercel/oidc": "^3.2.0",
     "@vercel/sandbox": "2.0.0-beta.12",
-    "@workflow/ai": "^4.1.0",
-    "@workflow/builders": "^4.0.1",
-    "ai": "^6.0.154",
+    "@workflow/ai": "^4.1.1",
+    "@workflow/builders": "^4.0.2",
+    "ai": "^6.0.158",
     "bash-tool": "^1.3.16",
-    "chat": "^4.24.0",
+    "chat": "^4.25.0",
     "chokidar": "^5.0.0",
     "commander": "^14.0.3",
     "esbuild": "^0.28.0",
     "gray-matter": "^4.0.3",
     "jose": "^6.2.2",
     "jsonc-parser": "^3.3.1",
-    "just-bash": "^2.14.0",
+    "just-bash": "^2.14.1",
     "nitro": "3.0.260311-beta",
     "picocolors": "^1.1.1",
     "std-env": "^4.0.0",
     "turndown": "^7.2.4",
-    "workflow": "^4.2.0",
+    "workflow": "^4.2.1",
     "zod": "^4.3.6",
     "zod-validation-error": "^5.0.0"
   },
@@ -138,11 +144,12 @@
   },
   "devDependencies": {
     "@types/turndown": "^5.0.6",
-    "@workflow/vitest": "^4.0.1"
+    "@workflow/vitest": "^4.0.2"
   },
   "scripts": {
     "clean": "rm -rf dist",
     "build": "pnpm run clean && tsc -p tsconfig.build.json && node ./scripts/copy-static-assets.mjs",
+    "dev": "tsc -p tsconfig.build.json --watch --preserveWatchOutput",
     "lint": "biome lint .",
     "test": "pnpm run test:unit && pnpm run test:integration",
     "test:integration": "vitest run --config vitest.integration.config.ts",