diff --git a/.github/workflows/git-sync-test.yml b/.github/workflows/git-sync-test.yml
index 09f69bb701..12b75932ce 100644
--- a/.github/workflows/git-sync-test.yml
+++ b/.github/workflows/git-sync-test.yml
@@ -8,6 +8,7 @@ on:
       - "backend/windmill-git-sync/**"
       - "backend/windmill-api-integration-tests/tests/git_sync*"
       - "backend/ee-repo-ref.txt"
+      - "backend/windmill-common/src/workspaces.rs"
       - "integration_tests/test/git_sync_test.py"
       - ".github/workflows/git-sync-test.yml"
   pull_request:
@@ -16,6 +17,7 @@ on:
       - "backend/windmill-git-sync/**"
       - "backend/windmill-api-integration-tests/tests/git_sync*"
       - "backend/ee-repo-ref.txt"
+      - "backend/windmill-common/src/workspaces.rs"
       - "integration_tests/test/git_sync_test.py"
       - ".github/workflows/git-sync-test.yml"
 
@@ -49,7 +51,7 @@ jobs:
           echo "$CHANGED_FILES"
 
           # Direct git sync file changes — always relevant
-          if echo "$CHANGED_FILES" | grep -qE '^(backend/windmill-git-sync/|backend/windmill-api-integration-tests/tests/git_sync|integration_tests/test/git_sync|\.github/workflows/git-sync-test\.yml)'; then
+          if echo "$CHANGED_FILES" | grep -qE '^(backend/windmill-git-sync/|backend/windmill-api-integration-tests/tests/git_sync|backend/windmill-common/src/workspaces\.rs|integration_tests/test/git_sync|\.github/workflows/git-sync-test\.yml)'; then
             echo "should_run=true" >> "$GITHUB_OUTPUT"
             echo "Relevant: direct git sync file changes"
             exit 0
diff --git a/CHANGELOG.md b/CHANGELOG.md
index ebbf6cb922..193472c590 100644
--- a/CHANGELOG.md
+++ b/CHANGELOG.md
@@ -1,5 +1,81 @@
 # Changelog
 
+## [1.714.0](https://github.com/windmill-labs/windmill/compare/v1.713.1...v1.714.0) (2026-06-02)
+
+
+### Features
+
+* add global ai chat test tools ([#9391](https://github.com/windmill-labs/windmill/issues/9391)) ([5c20d6b](https://github.com/windmill-labs/windmill/commit/5c20d6b4f79f2ccc1987ce7fdaf74e6b8f697846))
+* add workspace datatable tools to global AI chat mode ([#9395](https://github.com/windmill-labs/windmill/issues/9395)) ([943ef6e](https://github.com/windmill-labs/windmill/commit/943ef6eb2089f4b744cfa7945ce47f7f3b361ec7))
+* **flow-ai:** constrain flow-group colors to the NoteColor palette ([#9343](https://github.com/windmill-labs/windmill/issues/9343)) ([e4213c1](https://github.com/windmill-labs/windmill/commit/e4213c1ab8c448f492f372580f5c9df37e33fffc))
+* **frontend:** surface local drafts in drawer editors with an unsaved-changes banner ([#9335](https://github.com/windmill-labs/windmill/issues/9335)) ([075faab](https://github.com/windmill-labs/windmill/commit/075faabf3bba16a10a02ae3973008e5a13473085))
+* handle CTRL_BREAK_EVENT for graceful shutdown on Windows ([#9400](https://github.com/windmill-labs/windmill/issues/9400)) ([2e14456](https://github.com/windmill-labs/windmill/commit/2e1445616a412c5112ad2247b4087c7ddc218845))
+* refine ask-user-question chat display and keyboard nav ([#9392](https://github.com/windmill-labs/windmill/issues/9392)) ([1275487](https://github.com/windmill-labs/windmill/commit/1275487f028d4c74a9eeb18981ed05c225505be0))
+* sessions page with isolated AI chat + flow editor ([#9034](https://github.com/windmill-labs/windmill/issues/9034)) ([eadeac2](https://github.com/windmill-labs/windmill/commit/eadeac248bd022c2796cfe638eb617c6143b8fc4))
+
+
+### Bug Fixes
+
+* **cli:** make encryption key push non-interactive-safe + add --skip-reencrypt-on-key-change ([#9402](https://github.com/windmill-labs/windmill/issues/9402)) ([e356bb1](https://github.com/windmill-labs/windmill/commit/e356bb1f5df92eca3fbb0ca2114b9f4c32d4c496))
+* **cli:** stop git-sync promotion deploys from dropping triggers/schedules ([#9403](https://github.com/windmill-labs/windmill/issues/9403)) ([24e3ef2](https://github.com/windmill-labs/windmill/commit/24e3ef27be8498fb820c228a52febf6a0a91b487))
+* **frontend:** align Monaco editor font size with text-xs ([#9161](https://github.com/windmill-labs/windmill/issues/9161)) ([de76668](https://github.com/windmill-labs/windmill/commit/de76668c10c04abe8771a8ca7bba7b2259819a1c))
+* resolve username rename failing on apps with runnable deps ([#9401](https://github.com/windmill-labs/windmill/issues/9401)) ([e8ad53d](https://github.com/windmill-labs/windmill/commit/e8ad53dae92597f5a1a8b76f38a7d8c24f578a47))
+
+
+### Performance Improvements
+
+* **python:** add --compile-bytecode to uv pip install ([#9393](https://github.com/windmill-labs/windmill/issues/9393)) ([c19441b](https://github.com/windmill-labs/windmill/commit/c19441bc8cb2da064e4ad44d77dc04ab8bbb22ec))
+
+## [1.713.1](https://github.com/windmill-labs/windmill/compare/v1.713.0...v1.713.1) (2026-06-01)
+
+
+### Bug Fixes
+
+* **api:** handle multi-version scripts when removing granular ACL ([#9388](https://github.com/windmill-labs/windmill/issues/9388)) ([9d9c503](https://github.com/windmill-labs/windmill/commit/9d9c5038ce8b0016320a670c434ef9063cb40441))
+
+## [1.713.0](https://github.com/windmill-labs/windmill/compare/v1.712.0...v1.713.0) (2026-05-31)
+
+
+### Features
+
+* **flows:** preserve step/subflow worker tags under a custom-tagged flow ([#9375](https://github.com/windmill-labs/windmill/issues/9375)) ([f0301b1](https://github.com/windmill-labs/windmill/commit/f0301b1605cee5fba4024803555333e6fa5c40ee))
+* **oauth:** support per-provider sandbox URLs ([#9358](https://github.com/windmill-labs/windmill/issues/9358)) ([2bf11dc](https://github.com/windmill-labs/windmill/commit/2bf11dcb15540c538ea2ac3cf70dcbe589060b4e))
+
+
+### Bug Fixes
+
+* **ai:** validate token_url for SSRF in OAuth credentials flow ([#9385](https://github.com/windmill-labs/windmill/issues/9385)) ([4b06881](https://github.com/windmill-labs/windmill/commit/4b06881918b76c5a411cc70b318e46efcc1393a7))
+* **api:** authorize and harden log-file reading endpoints ([#9368](https://github.com/windmill-labs/windmill/issues/9368)) ([bb90f4c](https://github.com/windmill-labs/windmill/commit/bb90f4ce83a0e60af219b11c12ab4fe1d13f47a4))
+* **apps:** make public apps opt into cross-origin isolation via wm_coep (GIT-884) ([#9374](https://github.com/windmill-labs/windmill/issues/9374)) ([2c0c2c4](https://github.com/windmill-labs/windmill/commit/2c0c2c467f163cd24c14c7be2db07af9cf2ce020))
+* **auth:** enforce monotonic privilege on user token lifecycle endpoints ([#9371](https://github.com/windmill-labs/windmill/issues/9371)) ([2ddf93d](https://github.com/windmill-labs/windmill/commit/2ddf93de96622b2a1b2b6f59398a7a1f59360efd))
+* batch encryption-key rotation into one git-sync job ([#9355](https://github.com/windmill-labs/windmill/issues/9355)) ([04a0897](https://github.com/windmill-labs/windmill/commit/04a08976aec4ba9b0516350316df303e9f96bfd3))
+* **cli:** preserve user drafts on sync push and permissioned-as ([#9381](https://github.com/windmill-labs/windmill/issues/9381)) ([b0c3b01](https://github.com/windmill-labs/windmill/commit/b0c3b01d31b0ab3a6566e1f5fec60e3e230cfadb))
+* **frontend:** sanitize user markdown to prevent stored XSS ([#9386](https://github.com/windmill-labs/windmill/issues/9386)) ([def01b8](https://github.com/windmill-labs/windmill/commit/def01b8ff6f331cc36ce02b947adc31c766042c4))
+* **security:** re-pin cached hub scripts to CVE-patched versions (+ HUB_BASE_URL override for cache mode) ([#9387](https://github.com/windmill-labs/windmill/issues/9387)) ([edf340c](https://github.com/windmill-labs/windmill/commit/edf340c4d4f18b16b142cb7deb67afa586f10946))
+
+## [1.712.0](https://github.com/windmill-labs/windmill/compare/v1.711.0...v1.712.0) (2026-05-28)
+
+
+### Features
+
+* add deepseek fim support ([#9365](https://github.com/windmill-labs/windmill/issues/9365)) ([2553fbf](https://github.com/windmill-labs/windmill/commit/2553fbfe31417bd985e7994eac695bf918f97ce2))
+* deploy raw apps from global chat ([#9349](https://github.com/windmill-labs/windmill/issues/9349)) ([dec58e6](https://github.com/windmill-labs/windmill/commit/dec58e6c4f55062b42a752c43c89ef05903e713a))
+* inject active editor into global chat ([#9361](https://github.com/windmill-labs/windmill/issues/9361)) ([9e7eaf3](https://github.com/windmill-labs/windmill/commit/9e7eaf36847ad3a004ec84e8b7d4784771b7b451))
+* **queue:** duration-weighted fairness admission ([#9334](https://github.com/windmill-labs/windmill/issues/9334)) ([045d120](https://github.com/windmill-labs/windmill/commit/045d12043e7c99830ef90bc0da798c94e2094711))
+* warn when custom instance db is shared across workspaces ([#9359](https://github.com/windmill-labs/windmill/issues/9359)) ([a9e5140](https://github.com/windmill-labs/windmill/commit/a9e514099585e5ee72df21bd551a223cceb20fb0))
+
+
+### Bug Fixes
+
+* **cli:** redact encryption_key diff in stdout by default ([#9347](https://github.com/windmill-labs/windmill/issues/9347)) ([88056f8](https://github.com/windmill-labs/windmill/commit/88056f8d4c91c1d14d85a08851ecf0bd97e2260d))
+* **cli:** stop re-prompting on wmill refresh prompts ([#9357](https://github.com/windmill-labs/windmill/issues/9357)) ([c2b5ba8](https://github.com/windmill-labs/windmill/commit/c2b5ba8871abbbcff6de69c90e2f09fee70586c1))
+* **frontend:** close other sidebar menus when hovering Help ([#9354](https://github.com/windmill-labs/windmill/issues/9354)) ([da882c5](https://github.com/windmill-labs/windmill/commit/da882c54b21e3eaf2c1d1abccd0996b243d96dce))
+* **frontend:** prevent duplicate asset node ids crashing flow graph ([#9367](https://github.com/windmill-labs/windmill/issues/9367)) ([9a659b6](https://github.com/windmill-labs/windmill/commit/9a659b636d713ee8fdfbdad41c58bb3d7c79e0d9))
+* **frontend:** prevent MultiSelect crash on undefined value ([#9364](https://github.com/windmill-labs/windmill/issues/9364)) ([aea0061](https://github.com/windmill-labs/windmill/commit/aea00611c41379be2afdad0eedd608c9537d03f7))
+* **git-sync:** publish fork branch on only_create_branch from the CLI ([#9366](https://github.com/windmill-labs/windmill/issues/9366)) ([2fdc51e](https://github.com/windmill-labs/windmill/commit/2fdc51e62985fc755884436130bdd58e294247c8))
+* infer script arg schema when deploying via AI chat ([#9356](https://github.com/windmill-labs/windmill/issues/9356)) ([4efc372](https://github.com/windmill-labs/windmill/commit/4efc37212a98571214aba135b0fbb10dc263fd4f))
+* **monitor:** cleanup stale server_heartbeat background_task_state rows ([#9338](https://github.com/windmill-labs/windmill/issues/9338)) ([59ab038](https://github.com/windmill-labs/windmill/commit/59ab038d7718d8a4c25efa5928f42e1393ebbf40))
+
 ## [1.711.0](https://github.com/windmill-labs/windmill/compare/v1.710.1...v1.711.0) (2026-05-26)
 
 
diff --git a/Dockerfile b/Dockerfile
index e11cf9cecd..9062a4d9d8 100644
--- a/Dockerfile
+++ b/Dockerfile
@@ -66,6 +66,7 @@ RUN npm ci
 COPY frontend .
 RUN mkdir /backend
 COPY /backend/windmill-api/openapi.yaml /backend/windmill-api/openapi.yaml
+COPY /backend/oauth_connect.json /backend/oauth_connect.json
 COPY /openflow.openapi.yaml /openflow.openapi.yaml
 COPY /backend/windmill-api/build_openapi.sh /backend/windmill-api/build_openapi.sh
 COPY /system_prompts/auto-generated /system_prompts/auto-generated
diff --git a/ai_evals/README.md b/ai_evals/README.md
index 6982d70da9..d5fe1661a2 100644
--- a/ai_evals/README.md
+++ b/ai_evals/README.md
@@ -56,7 +56,7 @@ bun run cli -- run flow flow-test4-order-processing-loop --model opus
 bun run cli -- run flow flow-test0-sum-two-numbers --models haiku,opus,4o
 bun run cli -- run flow flow-test0-sum-two-numbers --runs 3 --verbose
 bun run cli -- run flow --record
-GEMINI_API_KEY=... bun run cli -- run app app-test1-counter-create --model gemini-pro
+GEMINI_API_KEY=... bun run cli -- run app app-test1-counter-create --model gemini-3-flash-preview
 WMILL_AI_EVAL_BACKEND_URL=http://127.0.0.1:8000 bun run cli -- run flow --backend-validation preview
 bun run cli -- run global global-test1-script-create
 bun run cli -- run cli bun-hello-script
@@ -88,15 +88,16 @@ Today:
 - `sonnet`
 - `opus`
 - `4o`
-- `gemini-flash`
-- `gemini-pro`
+- `gpt-5.5`
 - `gemini-3-flash-preview`
 - `gemini-3.1-pro-preview`
+- `deepseek-v4-flash`
+- `deepseek-v4-pro`
 
 Notes:
 
-- the command also prints accepted alias spellings such as `gpt-4o`, `claude-opus-4.6`, and `claude-haiku-4.5`
-- frontend modes (`flow`, `script`, `app`, `global`) can use Anthropic, OpenAI, and Gemini-backed aliases
+- the command also prints accepted alias spellings such as `gpt-4o`, `gpt-55`, `claude-opus-4.6`, and `claude-haiku-4.5`
+- frontend modes (`flow`, `script`, `app`, `global`) can use Anthropic, OpenAI, Gemini, and DeepSeek-backed aliases
 - `cli` mode always uses the Anthropic agent SDK, so only Anthropic aliases are valid there
 - the judge model is separate and currently defaults to `claude-sonnet-4-6`
 
@@ -142,6 +143,15 @@ For `global` mode, `validate` can express draft-level requirements such as:
 - required or forbidden draft counts
 - forbidden draft paths
 
+Global initial fixtures can also seed `liveEditorDrafts` with `type`,
+`storagePath`, `effectivePath`, and `value` fields. These drafts emulate the
+currently open script, flow, or raw app editor so cases can test prompts that
+refer to "this" or the "current" item.
+
+Set `WMILL_AI_EVAL_DISABLE_ACTIVE_EDITOR_CONTEXT=1` to run those cases with
+the old behavior where the live editor is only discoverable through
+`list_workspace_items`.
+
 App fixtures can also include an optional `datatables.json` file at the fixture root.
 
 For `flow` mode, an `initial` fixture can also include a benchmark workspace catalog of
@@ -189,11 +199,15 @@ If `--record` is used, the CLI also appends one compact JSON line to:
 Each recorded line contains:
 
 - run metadata (`createdAt`, `gitSha`, `mode`, `runModel`, `judgeModel`)
-- suite totals (`caseCount`, `attemptCount`, `passedAttempts`, `passRate`, `averageDurationMs`, `averageJudgeScore`)
-- average token usage (`averageTokenUsagePerAttempt`)
-- per-case metrics under `cases[]` (`averageDurationMs`, `averageJudgeScore`, `averageTokenUsagePerAttempt`, pass rate)
+- suite totals (`caseCount`, `attemptCount`, `passedAttempts`, `passRate`, `averageDurationMs`, `averagePassedDurationMs`, `averageJudgeScore`)
+- average token usage (`averageTokenUsagePerAttempt`, `averageTokenUsagePerPassedAttempt`)
+- per-case metrics under `cases[]` (`averageDurationMs`, `averagePassedDurationMs`, `averageJudgeScore`, `averageTokenUsagePerAttempt`, `averageTokenUsagePerPassedAttempt`, pass rate)
 - `failedCaseIds`
 
+The CLI headline duration and token averages use passed attempts only.
+All-attempt averages are still recorded to make failures auditable without
+letting failed attempts skew success cost comparisons.
+
 Example:
 
 - summary: `ai_evals/results/2026-04-09T09-40-33.051Z__flow.json`
diff --git a/ai_evals/adapters/frontend/core/global/globalEvalRunner.ts b/ai_evals/adapters/frontend/core/global/globalEvalRunner.ts
index 5e00dd6f34..058adc3644 100644
--- a/ai_evals/adapters/frontend/core/global/globalEvalRunner.ts
+++ b/ai_evals/adapters/frontend/core/global/globalEvalRunner.ts
@@ -7,8 +7,12 @@ import {
   prepareGlobalSystemMessage,
   prepareGlobalUserMessage,
 } from "../../../../../frontend/src/lib/components/copilot/chat/global/core";
-import { globalDraftStore } from "../../../../../frontend/src/lib/components/copilot/chat/global/draftStore.svelte";
+import {
+  clearGlobalDrafts,
+  listGlobalDrafts,
+} from "../../../../../frontend/src/lib/components/copilot/chat/global/userDraftAdapter";
 import type { Tool as ProductionTool } from "../../../../../frontend/src/lib/components/copilot/chat/shared";
+import { UserDraft } from "../../../../../frontend/src/lib/userDraft.svelte";
 import type { ModeRunContext } from "../../../../core/types";
 import type { GlobalDraftState } from "../../../../core/validators";
 import type { WindmillBackendSettings } from "../../../../core/windmillBackendSettings";
@@ -24,6 +28,21 @@ const MUTATING_GLOBAL_TOOLS = new Set([
   "deploy_workspace_item",
   "delete_workspace_item",
 ]);
+const DISABLE_ACTIVE_EDITOR_CONTEXT_ENV =
+  "WMILL_AI_EVAL_DISABLE_ACTIVE_EDITOR_CONTEXT";
+
+const LIVE_EDITOR_ITEM_KINDS = {
+  script: "script",
+  flow: "flow",
+  app: "raw_app",
+} as const;
+
+export interface GlobalLiveEditorDraftFixture {
+  type: keyof typeof LIVE_EDITOR_ITEM_KINDS;
+  storagePath?: string;
+  effectivePath?: string;
+  value?: unknown;
+}
 
 export interface GlobalEvalResult {
   success: boolean;
@@ -38,6 +57,7 @@ export interface GlobalEvalResult {
 
 export interface GlobalEvalOptions {
   workspaceFixtures?: BenchmarkWorkspaceRunnables;
+  liveEditorDrafts?: GlobalLiveEditorDraftFixture[];
   model?: string;
   maxIterations?: number;
   provider?: AIProvider;
@@ -55,19 +75,26 @@ export async function runGlobalEval(
     options.workspaceRoot ??
     (await mkdtemp(join(tmpdir(), "wmill-frontend-global-benchmark-")));
 
-  globalDraftStore.clearDrafts(workspaceRoot);
+  clearGlobalDrafts(workspaceRoot);
   registerBenchmarkWorkspaceRunnables(workspaceRoot, options.workspaceFixtures ?? {});
+  seedLiveEditorDrafts(workspaceRoot, options.liveEditorDrafts ?? []);
 
   try {
     const model = options.model ?? "claude-haiku-4-5-20251001";
+    const injectActiveEditorContext =
+      process.env[DISABLE_ACTIVE_EDITOR_CONTEXT_ENV] !== "1";
     const rawResult = await runEval({
       userPrompt,
       systemMessage: prepareGlobalSystemMessage(),
-      userMessage: prepareGlobalUserMessage(userPrompt),
+      userMessage: prepareGlobalUserMessage(
+        userPrompt,
+        [],
+        injectActiveEditorContext ? { workspace: workspaceRoot } : {},
+      ),
       tools: getGlobalEvalTools(),
       helpers: {},
       apiKey,
-      getOutput: () => ({ drafts: globalDraftStore.listDrafts(workspaceRoot) }),
+      getOutput: () => ({ drafts: listGlobalDrafts(workspaceRoot) }),
       onAssistantMessageStart: options.runContext?.onAssistantMessageStart,
       onAssistantToken: options.runContext?.onAssistantChunk,
       onAssistantMessageEnd: options.runContext?.onAssistantMessageEnd,
@@ -94,7 +121,8 @@ export async function runGlobalEval(
       tokenUsage: rawResult.tokenUsage,
     };
   } finally {
-    globalDraftStore.clearDrafts(workspaceRoot);
+    clearGlobalDrafts(workspaceRoot);
+    clearLiveEditorDrafts(workspaceRoot, options.liveEditorDrafts ?? []);
     unregisterBenchmarkWorkspaceRunnables(workspaceRoot);
     if (!options.workspaceRoot) {
       await rm(workspaceRoot, { recursive: true, force: true });
@@ -102,6 +130,36 @@ export async function runGlobalEval(
   }
 }
 
+function seedLiveEditorDrafts(
+  workspace: string,
+  fixtures: GlobalLiveEditorDraftFixture[],
+): void {
+  for (const fixture of fixtures) {
+    const itemKind = LIVE_EDITOR_ITEM_KINDS[fixture.type];
+    const storagePath = fixture.storagePath ?? fixture.effectivePath ?? "";
+    if (fixture.value !== undefined) {
+      UserDraft.save(itemKind, storagePath, fixture.value, { workspace });
+    }
+    UserDraft.setLiveEditorDraft({
+      workspace,
+      itemKind,
+      storagePath,
+      effectivePath: fixture.effectivePath ?? fixture.storagePath,
+    });
+  }
+}
+
+function clearLiveEditorDrafts(
+  workspace: string,
+  fixtures: GlobalLiveEditorDraftFixture[],
+): void {
+  for (const fixture of fixtures) {
+    const itemKind = LIVE_EDITOR_ITEM_KINDS[fixture.type];
+    const storagePath = fixture.storagePath ?? fixture.effectivePath ?? "";
+    UserDraft.clearLiveEditorDraft(itemKind, { workspace, storagePath });
+  }
+}
+
 function getGlobalEvalTools(): ProductionTool<{}>[] {
   return (globalTools as ProductionTool<{}>[]).map((tool) => {
     if (!MUTATING_GLOBAL_TOOLS.has(tool.def.function.name)) {
diff --git a/ai_evals/adapters/frontend/core/shared/providerConfig.test.ts b/ai_evals/adapters/frontend/core/shared/providerConfig.test.ts
index 819300bd62..01a55e048e 100644
--- a/ai_evals/adapters/frontend/core/shared/providerConfig.test.ts
+++ b/ai_evals/adapters/frontend/core/shared/providerConfig.test.ts
@@ -21,9 +21,9 @@ describe("proxy helpers", () => {
 
 describe("resolveEvalModelProvider", () => {
   it("infers googleai from Gemini model ids", () => {
-    expect(resolveEvalModelProvider("gemini-2.5-flash")).toEqual({
+    expect(resolveEvalModelProvider("gemini-3-flash-preview")).toEqual({
       provider: "googleai",
-      model: "gemini-2.5-flash",
+      model: "gemini-3-flash-preview",
     });
   });
 
@@ -35,9 +35,11 @@ describe("resolveEvalModelProvider", () => {
   });
 
   it("preserves an explicit provider", () => {
-    expect(resolveEvalModelProvider("gemini-2.5-pro", "googleai")).toEqual({
+    expect(
+      resolveEvalModelProvider("gemini-3.1-pro-preview", "googleai"),
+    ).toEqual({
       provider: "googleai",
-      model: "gemini-2.5-pro",
+      model: "gemini-3.1-pro-preview",
     });
   });
 });
diff --git a/ai_evals/adapters/frontend/vitestAdapter.test.ts b/ai_evals/adapters/frontend/vitestAdapter.test.ts
index 1275acf0b4..92c43aab06 100644
--- a/ai_evals/adapters/frontend/vitestAdapter.test.ts
+++ b/ai_evals/adapters/frontend/vitestAdapter.test.ts
@@ -79,6 +79,16 @@ vi.mock('$lib/gen', async () => {
 				}
 				return actual.ScriptService.getScriptByPath(data)
 			},
+			getScriptByPathWithDraft: async (data: { workspace: string; path: string }) => {
+				if (hasBenchmarkWorkspace(data.workspace)) {
+					const script = getBenchmarkScriptByPath(data.workspace, data.path)
+					if (!script) {
+						throw new Error(`Script "${data.path}" not found in benchmark workspace`)
+					}
+					return script
+				}
+				return actual.ScriptService.getScriptByPathWithDraft(data)
+			},
 			getScriptByHash: async (data: { workspace: string; hash: string }) => {
 				if (hasBenchmarkWorkspace(data.workspace)) {
 					const script = getBenchmarkScriptByHash(data.workspace, data.hash)
@@ -108,6 +118,26 @@ vi.mock('$lib/gen', async () => {
 					return flow
 				}
 				return actual.FlowService.getFlowByPath(data)
+			},
+			getFlowByPathWithDraft: async (data: { workspace: string; path: string }) => {
+				if (hasBenchmarkWorkspace(data.workspace)) {
+					const flow = getBenchmarkFlowByPath(data.workspace, data.path)
+					if (!flow) {
+						throw new Error(`Flow "${data.path}" not found in benchmark workspace`)
+					}
+					return flow
+				}
+				return actual.FlowService.getFlowByPathWithDraft(data)
+			},
+			getFlowLatestVersion: async (data: { workspace: string; path: string }) => {
+				if (hasBenchmarkWorkspace(data.workspace)) {
+					const flow = getBenchmarkFlowByPath(data.workspace, data.path)
+					if (!flow) {
+						throw new Error(`Flow "${data.path}" not found in benchmark workspace`)
+					}
+					return { id: 1 }
+				}
+				return actual.FlowService.getFlowLatestVersion(data)
 			}
 		}),
 		JobService: wrapService(actual.JobService, {
diff --git a/ai_evals/cases/flow.yaml b/ai_evals/cases/flow.yaml
index af7added38..5f4abafc48 100644
--- a/ai_evals/cases/flow.yaml
+++ b/ai_evals/cases/flow.yaml
@@ -8,6 +8,9 @@
       args:
         a: 4
         b: 5
+  toolExpect:
+    requiredToolsUsed:
+      - test_run_flow
   judgeChecklist:
     - "the flow takes `a` and `b` as inputs"
     - "the main step is named `sum_numbers`"
@@ -25,6 +28,9 @@
       args:
         a: 2
         b: 3
+  toolExpect:
+    requiredToolsUsed:
+      - test_run_flow
   judgeChecklist:
     - "the flow takes `a` and `b` as inputs"
     - "the main step is named `sum_numbers`"
@@ -42,6 +48,9 @@
       args:
         a: 7
         b: 8
+  toolExpect:
+    requiredToolsUsed:
+      - test_run_flow
   judgeChecklist:
     - "the parent flow takes `a` and `b` as inputs"
     - "the main step is named `call_add_numbers`"
@@ -426,6 +435,7 @@
       - return_schedule_status
   toolExpect:
     requiredToolsUsed:
+      - test_run_flow
       - create_schedule
     toolCallArgs:
       - tool: create_schedule
@@ -453,6 +463,7 @@
       - webhook_response
   toolExpect:
     requiredToolsUsed:
+      - test_run_flow
       - create_trigger
     toolCallArgs:
       - tool: create_trigger
diff --git a/ai_evals/cases/global.yaml b/ai_evals/cases/global.yaml
index b4526f8a85..732ca7f2e9 100644
--- a/ai_evals/cases/global.yaml
+++ b/ai_evals/cases/global.yaml
@@ -87,3 +87,534 @@
     - the flow accepts numeric inputs a and b
     - the flow returns the sum of a and b
     - the result stays as an AI draft and is not deployed or saved to the workspace
+
+- id: global-test4-multi-artifact-notification-job
+  prompt: |-
+    Set up a draft stale-trial notification job.
+    Create a Bun script at `f/evals/global/check_stale_trials` that accepts `max_age_days`, uses mocked inline trial account data, and returns the stale trial account IDs.
+    Also create a weekday 09:00 UTC schedule at `f/evals/global/check_stale_trials_weekday` for that script with `max_age_days` set to 14.
+    Add an HTTP POST trigger at `f/evals/global/check_stale_trials_manual` with route path `evals/check-stale-trials` that runs the same script manually.
+    Leave everything as AI drafts only; do not deploy or save anything to the workspace.
+  runtime:
+    maxTurns: 12
+  validate:
+    draftCountExactly: 3
+    requiredDrafts:
+      - type: script
+        path: f/evals/global/check_stale_trials
+        language: bun
+        valueIncludes:
+          - max_age_days
+          - trial
+      - type: schedule
+        path: f/evals/global/check_stale_trials_weekday
+        valueIncludes:
+          - f/evals/global/check_stale_trials
+          - UTC
+          - "14"
+      - type: trigger
+        triggerKind: http
+        path: f/evals/global/check_stale_trials_manual
+        valueIncludes:
+          - evals/check-stale-trials
+          - f/evals/global/check_stale_trials
+  toolExpect:
+    requiredToolsUsed:
+      - write_script
+      - write_schedule
+      - write_trigger
+    forbiddenToolsUsed:
+      - deploy_workspace_item
+      - delete_workspace_item
+  judgeChecklist:
+    - creates a Bun script draft for stale trial accounts
+    - creates a weekday 09:00 UTC schedule draft for the script with max_age_days set to 14
+    - creates an HTTP POST trigger draft with route path evals/check-stale-trials for the same script
+    - leaves all artifacts as drafts only and does not deploy
+
+- id: global-test5-existing-flow-inline-code-edit
+  prompt: |-
+    Update the existing flow at `f/evals/global/process_invoice`.
+    Only change the `calculate_total` inline code so it applies 8% tax and returns an object containing `subtotal`, `tax`, and `total`.
+    Leave the updated flow as an AI draft only; do not deploy or save it.
+  initial: ai_evals/fixtures/frontend/global/initial/process_invoice_flow.json
+  runtime:
+    maxTurns: 10
+  validate:
+    draftCountExactly: 1
+    requiredDrafts:
+      - type: flow
+        path: f/evals/global/process_invoice
+        valueIncludes:
+          - calculate_total
+          - tax
+          - total
+  toolExpect:
+    requiredToolsUsed:
+      - read_workspace_item
+    forbiddenToolsUsed:
+      - deploy_workspace_item
+      - delete_workspace_item
+  judgeChecklist:
+    - reads the existing process_invoice flow before editing it
+    - updates the calculate_total inline code to apply 8% tax
+    - returns subtotal, tax, and total from the updated flow logic
+    - leaves the result as an AI draft only
+
+- id: global-test6-secret-variable-draft
+  prompt: |-
+    Create a secret variable draft at `f/evals/global/slack_bot_token`.
+    Use the placeholder value `xoxb-redacted-test-token` and description `Slack bot token for eval notifications`.
+    Do not create any resource or deploy anything.
+  runtime:
+    maxTurns: 6
+  validate:
+    draftCountExactly: 1
+    requiredDrafts:
+      - type: variable
+        path: f/evals/global/slack_bot_token
+        valueIncludes:
+          - Slack bot token
+          - "true"
+    forbiddenDrafts:
+      - type: resource
+        path: f/evals/global/slack_bot_token
+  toolExpect:
+    requiredToolsUsed:
+      - write_variable
+    forbiddenToolsUsed:
+      - write_resource
+      - deploy_workspace_item
+      - delete_workspace_item
+    toolCallArgs:
+      - tool: write_variable
+        field: value
+        stringStartsWithAnyOf:
+          - xoxb-redacted-test-token
+  skipJudge: true
+  judgeChecklist:
+    - creates exactly one secret variable draft at f/evals/global/slack_bot_token
+    - uses the requested placeholder value and description
+    - does not create a resource or deploy anything
+
+- id: global-test7-ambiguous-app-asks-question
+  prompt: |-
+    Create a new raw app for triaging support tickets.
+  runtime:
+    maxTurns: 4
+  validate:
+    draftCountExactly: 0
+  toolExpect:
+    requiredToolsUsed:
+      - askUserQuestion
+    forbiddenToolsUsed:
+      - init_app
+      - write_app_file
+      - write_app_runnable
+      - deploy_workspace_item
+      - delete_workspace_item
+  skipJudge: true
+
+- id: global-test8-human-script-infer-path-language
+  prompt: |-
+    I need a small helper that formats a customer-facing welcome line.
+    It should take a person's name and return "Welcome aboard, <name>!".
+    Please just stage it as a draft for now.
+  runtime:
+    maxTurns: 8
+  validate:
+    draftCountExactly: 1
+    requiredDrafts:
+      - type: script
+        valueIncludes:
+          - Welcome aboard
+          - name
+  toolExpect:
+    requiredToolsUsed:
+      - write_script
+    forbiddenToolsUsed:
+      - deploy_workspace_item
+      - delete_workspace_item
+  judgeChecklist:
+    - creates a single script draft for a welcome-line helper
+    - accepts a person's name as input
+    - returns a message containing Welcome aboard, the provided name, and an exclamation mark
+    - chooses a reasonable workspace path and script language without needing the user to specify them
+    - leaves the result as an AI draft only
+
+- id: global-test9-human-weekday-trial-job
+  prompt: |-
+    Can you set up a draft daily job that checks a few hard-coded trial accounts and returns the ones whose trial has ended?
+    It should run every weekday morning around 9 in UTC with a 30 day cutoff.
+    Keep it as draft work only.
+  runtime:
+    maxTurns: 10
+  validate:
+    draftCountExactly: 2
+    requiredDrafts:
+      - type: script
+        pathIncludes:
+          - trial
+        valueIncludes:
+          - trial
+          - "30"
+      - type: schedule
+        pathIncludes:
+          - trial
+        valueIncludes:
+          - UTC
+  toolExpect:
+    requiredToolsUsed:
+      - write_script
+      - write_schedule
+    forbiddenToolsUsed:
+      - deploy_workspace_item
+      - delete_workspace_item
+  judgeChecklist:
+    - creates a script draft that checks hard-coded trial accounts
+    - returns the accounts whose trial has ended based on a 30 day cutoff
+    - creates a schedule draft for weekday mornings around 09:00 UTC
+    - links the schedule to the generated script
+    - leaves both artifacts as drafts only
+
+- id: global-test10-human-secret-variable
+  prompt: |-
+    I need a placeholder Slack bot token stored securely for future notification work.
+    Use xoxb-redacted-test-token and note that it is for eval notifications.
+    Only prepare a draft.
+  runtime:
+    maxTurns: 6
+  validate:
+    draftCountExactly: 1
+    requiredDrafts:
+      - type: variable
+        pathIncludes:
+          - slack
+        valueIncludes:
+          - eval notifications
+          - "true"
+  toolExpect:
+    requiredToolsUsed:
+      - write_variable
+    forbiddenToolsUsed:
+      - write_resource
+      - deploy_workspace_item
+      - delete_workspace_item
+    toolCallArgs:
+      - tool: write_variable
+        field: value
+        stringStartsWithAnyOf:
+          - xoxb-redacted-test-token
+  skipJudge: true
+  judgeChecklist:
+    - creates a single secret variable draft for the Slack bot token placeholder
+    - uses the requested placeholder value
+    - includes a note or description that it is for eval notifications
+    - does not create a resource or deploy anything
+
+- id: global-test11-human-existing-flow-informal-edit
+  prompt: |-
+    There is an invoice processing flow in this workspace.
+    Can you adjust its total calculation so it adds 8% tax and returns subtotal, tax, and total?
+    Keep the change as a draft.
+  initial: ai_evals/fixtures/frontend/global/initial/process_invoice_flow.json
+  runtime:
+    maxTurns: 10
+  validate:
+    draftCountExactly: 1
+    requiredDrafts:
+      - type: flow
+        pathIncludes:
+          - invoice
+        valueIncludes:
+          - calculate_total
+          - tax
+          - total
+  toolExpect:
+    requiredToolsUsed:
+      - read_workspace_item
+    forbiddenToolsUsed:
+      - deploy_workspace_item
+      - delete_workspace_item
+  judgeChecklist:
+    - finds and edits the existing invoice processing flow without the user providing its exact path
+    - updates the total calculation to apply 8% tax
+    - returns subtotal, tax, and total from the updated flow logic
+    - leaves the result as an AI draft only
+
+- id: global-test12-current-live-script-edit
+  prompt: |-
+    The script I have open formats greetings.
+    Can you update this script so it uppercases the name before greeting them and ends with an exclamation mark?
+    Keep it as draft work.
+  initial: ai_evals/fixtures/frontend/global/initial/current_greeting_live_script.json
+  runtime:
+    maxTurns: 8
+  validate:
+    draftCountExactly: 1
+    requiredDrafts:
+      - type: script
+        path: f/evals/global/current_greeting
+        language: bun
+        valueIncludes:
+          - toUpperCase
+          - "!"
+    forbiddenDrafts:
+      - type: script
+        path: f/evals/global/format_greeting
+      - type: script
+        path: f/evals/global/format_greeting_archive
+  toolExpect:
+    requiredToolsUsed:
+      - read_workspace_item
+    forbiddenToolsUsed:
+      - deploy_workspace_item
+      - delete_workspace_item
+  judgeChecklist:
+    - resolves "this script" to the active live editor script instead of another similarly named workspace script
+    - updates the greeting logic to uppercase the provided name
+    - returns a greeting ending with an exclamation mark
+    - leaves the result as a draft only
+
+- id: global-test13-current-live-flow-edit
+  prompt: |-
+    I have the invoice flow open.
+    In the current flow, update the total calculation to add 8% tax and return subtotal, tax, and total.
+    Keep the change as a draft.
+  initial: ai_evals/fixtures/frontend/global/initial/current_invoice_live_flow.json
+  runtime:
+    maxTurns: 10
+  validate:
+    draftCountExactly: 1
+    requiredDrafts:
+      - type: flow
+        path: f/evals/global/current_invoice_flow
+        valueIncludes:
+          - calculate_total
+          - tax
+          - total
+    forbiddenDrafts:
+      - type: flow
+        path: f/evals/global/process_invoice
+      - type: flow
+        path: f/evals/global/process_refund
+  toolExpect:
+    requiredToolsUsed:
+      - read_workspace_item
+    forbiddenToolsUsed:
+      - deploy_workspace_item
+      - delete_workspace_item
+  judgeChecklist:
+    - resolves "current flow" to the active live editor flow
+    - does not edit the similarly named deployed invoice or refund flows
+    - updates the calculate_total logic to apply 8% tax
+    - returns subtotal, tax, and total from the updated flow logic
+    - leaves the result as a draft only
+
+- id: global-test14-current-without-live-editor-asks-question
+  prompt: |-
+    Please update this script so it returns `ok`.
+    Keep it as a draft.
+  runtime:
+    maxTurns: 4
+  validate:
+    draftCountExactly: 0
+  toolExpect:
+    forbiddenToolsUsed:
+      - write_script
+      - edit_script
+      - write_flow
+      - deploy_workspace_item
+      - delete_workspace_item
+  skipJudge: true
+  judgeChecklist:
+    - asks which script to update when the user refers to "this script" without selected or active editor context
+    - does not guess a path or create a new script draft
+
+- id: global-test15-human-postgres-resource
+  prompt: |-
+    I'm wiring the eval reporting database into this workspace.
+    Can you stage a Postgres connection for it in the shared evals/global folder?
+    Use host `reports-db.internal`, port 5432, database `evals_reporting`, user `report_reader`, and password `pg-redacted-reporting-password`.
+    Keep the credentials safe.
+    This is just draft work for now.
+  runtime:
+    maxTurns: 10
+  validate:
+    draftCountExactly: 2
+    requiredDrafts:
+      - type: variable
+        pathStartsWith: f/evals/global/
+        pathIncludes:
+          - evals
+          - global
+          - report
+          - password
+        valueIncludes:
+          - "true"
+          - report
+      - type: resource
+        pathStartsWith: f/evals/global/
+        pathIncludes:
+          - evals
+          - global
+          - report
+        valueIncludes:
+          - postgres
+          - reports-db.internal
+          - "5432"
+          - evals_reporting
+          - report_reader
+          - "$var:"
+        valueExcludes:
+          - pg-redacted-reporting-password
+  toolExpect:
+    requiredToolsUsed:
+      - write_variable
+      - search_resource_types
+      - write_resource
+    forbiddenToolsUsed:
+      - write_schedule
+      - write_trigger
+      - deploy_workspace_item
+      - delete_workspace_item
+    toolCallArgs:
+      - tool: write_variable
+        field: value
+        stringStartsWithAnyOf:
+          - pg-redacted-reporting-password
+  skipJudge: true
+  judgeChecklist:
+    - creates a Postgres resource draft for the eval reporting database
+    - creates a secret variable draft for the database password
+    - puts the drafts in sensible eval/global reporting-related paths
+    - uses the requested host, port, database, and user
+    - references the secret variable from the resource instead of embedding the password
+    - leaves the work as a draft only
+
+- id: global-test16-human-visible-variable
+  prompt: |-
+    We keep reusing a 30 day trial cutoff in eval notification jobs.
+    Can you stage that as a normal workspace variable in the shared evals/global folder, with a short description so people know what it controls?
+    It is not a secret.
+  runtime:
+    maxTurns: 6
+  validate:
+    draftCountExactly: 1
+    requiredDrafts:
+      - type: variable
+        pathStartsWith: f/evals/global/
+        pathIncludes:
+          - evals
+          - global
+          - trial
+        valueIncludes:
+          - "30"
+          - "false"
+          - trial
+  toolExpect:
+    requiredToolsUsed:
+      - write_variable
+    forbiddenToolsUsed:
+      - write_resource
+      - write_schedule
+      - write_trigger
+      - deploy_workspace_item
+      - delete_workspace_item
+  judgeChecklist:
+    - creates exactly one non-secret variable draft for the trial cutoff
+    - stores the value 30
+    - chooses a sensible eval/global path related to trials or notifications
+    - includes a useful description of what the value controls
+    - does not create resources, schedules, triggers, or deployed workspace changes
+
+- id: global-test17-human-schedule-existing-helper
+  prompt: |-
+    The workspace already has a report digest helper.
+    Can you stage a weekday 8:30 AM UTC run for it with `dry_run` turned on?
+    I only want the schedule draft for review.
+  initial: ai_evals/fixtures/frontend/global/initial/report_digest_script.json
+  runtime:
+    maxTurns: 8
+  validate:
+    draftCountExactly: 1
+    requiredDrafts:
+      - type: schedule
+        pathIncludes:
+          - digest
+        valueIncludes:
+          - f/evals/global/send_report_digest
+          - UTC
+          - dry_run
+          - "true"
+  toolExpect:
+    requiredToolsUsed:
+      - list_workspace_items
+      - write_schedule
+    forbiddenToolsUsed:
+      - write_script
+      - write_flow
+      - write_resource
+      - write_variable
+      - write_trigger
+      - deploy_workspace_item
+      - delete_workspace_item
+  judgeChecklist:
+    - finds the existing report digest helper rather than creating a new script or flow
+    - creates one schedule draft for that helper
+    - schedules it for weekdays around 08:30 UTC
+    - passes dry_run as true
+    - leaves only the schedule draft for review
+
+- id: global-test18-human-slack-resource-with-secret
+  prompt: |-
+    I'm preparing Slack notifications for eval failures.
+    Can you stage a Slack connection in the shared evals/global folder?
+    The bot token is `xoxb-redacted-test-token`; keep it safe.
+    Don't deploy anything yet.
+  runtime:
+    maxTurns: 8
+  validate:
+    draftCountExactly: 2
+    requiredDrafts:
+      - type: variable
+        pathStartsWith: f/evals/global/
+        pathIncludes:
+          - evals
+          - global
+          - slack
+          - token
+        valueIncludes:
+          - "true"
+      - type: resource
+        pathStartsWith: f/evals/global/
+        pathIncludes:
+          - evals
+          - global
+          - slack
+        valueIncludes:
+          - slack
+          - "$var:"
+        valueExcludes:
+          - xoxb-redacted-test-token
+  toolExpect:
+    requiredToolsUsed:
+      - write_variable
+      - search_resource_types
+      - write_resource
+    forbiddenToolsUsed:
+      - write_schedule
+      - write_trigger
+      - deploy_workspace_item
+      - delete_workspace_item
+    toolCallArgs:
+      - tool: write_variable
+        field: value
+        stringStartsWithAnyOf:
+          - xoxb-redacted-test-token
+  skipJudge: true
+  judgeChecklist:
+    - creates a secret variable draft for the Slack bot token placeholder
+    - creates a Slack resource draft that references the secret variable instead of embedding the token
+    - keeps both drafts under a sensible eval/global Slack-related path
+    - does not create schedules, triggers, or deployed workspace changes
diff --git a/ai_evals/cases/script.yaml b/ai_evals/cases/script.yaml
index feae74dcda..f0910e939a 100644
--- a/ai_evals/cases/script.yaml
+++ b/ai_evals/cases/script.yaml
@@ -5,6 +5,9 @@
     Keep it simple and do not add external dependencies.
   initial: ai_evals/fixtures/frontend/script/initial/test1_empty_bun.json
   expected: ai_evals/fixtures/frontend/script/expected/test1_greet_user.json
+  toolExpect:
+    requiredToolsUsed:
+      - test_run_script
   judgeChecklist:
     - uses the existing `name` input
     - returns a plain greeting string
@@ -20,6 +23,7 @@
   expected: ai_evals/fixtures/frontend/script/expected/test1_greet_user.json
   toolExpect:
     requiredToolsUsed:
+      - test_run_script
       - create_schedule
     toolCallArgs:
       - tool: create_schedule
@@ -44,6 +48,7 @@
   expected: ai_evals/fixtures/frontend/script/expected/test1_greet_user.json
   toolExpect:
     requiredToolsUsed:
+      - test_run_script
       - create_trigger
     toolCallArgs:
       - tool: create_trigger
diff --git a/ai_evals/cli/index.ts b/ai_evals/cli/index.ts
index 8ed61740c8..f92d6d7027 100644
--- a/ai_evals/cli/index.ts
+++ b/ai_evals/cli/index.ts
@@ -211,7 +211,7 @@ async function handleRun(input: {
   const summaries: Array<{
     label: string;
     passRate: number;
-    averageDurationMs: number;
+    averagePassedDurationMs: number | null;
   }> = [];
 
   for (const [index, model] of models.entries()) {
@@ -259,7 +259,7 @@ async function handleRun(input: {
     summaries.push({
       label: `${model.id} (${runModel})`,
       passRate: result.passRate,
-      averageDurationMs: result.averageDurationMs,
+      averagePassedDurationMs: result.averagePassedDurationMs ?? null,
     });
   }
 
@@ -267,7 +267,7 @@ async function handleRun(input: {
     process.stdout.write("\nModel summary\n");
     for (const summary of summaries) {
       process.stdout.write(
-        `- ${summary.label}: ${formatPercent(summary.passRate)} | ${Math.round(summary.averageDurationMs)}ms\n`,
+        `- ${summary.label}: ${formatPercent(summary.passRate)} | passed avg ${formatNullableDuration(summary.averagePassedDurationMs)}\n`,
       );
     }
   }
@@ -351,6 +351,10 @@ function formatPercent(value: number): string {
   return `${(value * 100).toFixed(1)}%`;
 }
 
+function formatNullableDuration(value: number | null): string {
+  return value === null ? "n/a" : `${Math.round(value)}ms`;
+}
+
 void main().catch((error) => {
   const message = error instanceof Error ? error.message : String(error);
   process.stderr.write(`${message}\n`);
diff --git a/ai_evals/core/cases.test.ts b/ai_evals/core/cases.test.ts
index 733d34ddd2..05e2f1527b 100644
--- a/ai_evals/core/cases.test.ts
+++ b/ai_evals/core/cases.test.ts
@@ -14,6 +14,21 @@ describe("loadCases", () => {
         },
       },
     });
+    expect(caseEntry?.toolExpect).toEqual({
+      requiredToolsUsed: ["test_run_flow"],
+    });
+  });
+
+  it("loads script and flow test tool expectations", async () => {
+    const scriptCases = await loadCases("script");
+    const flowCases = await loadCases("flow");
+
+    expect(scriptCases.find((entry) => entry.id === "script-test1-greet-user")?.toolExpect).toEqual({
+      requiredToolsUsed: ["test_run_script"],
+    });
+    expect(flowCases.find((entry) => entry.id === "flow-test0-sum-two-numbers")?.toolExpect).toEqual({
+      requiredToolsUsed: ["test_run_flow"],
+    });
   });
 
   it("loads the workspace-flow preference benchmark case", async () => {
@@ -203,6 +218,34 @@ describe("loadCases", () => {
     });
   });
 
+  it("loads global active-editor eval cases", async () => {
+    const globalCases = await loadCases("global");
+    const scriptCase = globalCases.find(
+      (entry) => entry.id === "global-test12-current-live-script-edit"
+    );
+    const flowCase = globalCases.find(
+      (entry) => entry.id === "global-test13-current-live-flow-edit"
+    );
+
+    expect(scriptCase?.initialPath).toContain(
+      "ai_evals/fixtures/frontend/global/initial/current_greeting_live_script.json"
+    );
+    expect(scriptCase?.toolExpect).toMatchObject({
+      requiredToolsUsed: ["read_workspace_item"],
+    });
+    expect(flowCase?.initialPath).toContain(
+      "ai_evals/fixtures/frontend/global/initial/current_invoice_live_flow.json"
+    );
+    expect(flowCase?.validate).toMatchObject({
+      requiredDrafts: [
+        {
+          type: "flow",
+          path: "f/evals/global/current_invoice_flow",
+        },
+      ],
+    });
+  });
+
   it("loads tool expectations for workspace mutation cases", async () => {
     const scriptCases = await loadCases("script");
     const caseEntry = scriptCases.find(
@@ -210,7 +253,7 @@ describe("loadCases", () => {
     );
 
     expect(caseEntry?.toolExpect).toEqual({
-      requiredToolsUsed: ["create_schedule"],
+      requiredToolsUsed: ["test_run_script", "create_schedule"],
       toolCallArgs: [
         {
           tool: "create_schedule",
diff --git a/ai_evals/core/models.test.ts b/ai_evals/core/models.test.ts
index a11fe40530..ba53c24592 100644
--- a/ai_evals/core/models.test.ts
+++ b/ai_evals/core/models.test.ts
@@ -2,15 +2,22 @@ import { describe, expect, it } from "bun:test";
 import { resolveEvalModel } from "./models";
 
 describe("resolveEvalModel", () => {
+  it("supports GPT-5.5 aliases for frontend evals", () => {
+    expect(resolveEvalModel("flow", "gpt-5.5").frontend).toEqual({
+      provider: "openai",
+      model: "gpt-5.5",
+    });
+    expect(resolveEvalModel("app", "gpt-55").frontend).toEqual({
+      provider: "openai",
+      model: "gpt-5.5",
+    });
+    expect(resolveEvalModel("script", "5.5").frontend).toEqual({
+      provider: "openai",
+      model: "gpt-5.5",
+    });
+  });
+
   it("supports Gemini aliases for frontend evals", () => {
-    expect(resolveEvalModel("flow", "gemini").frontend).toEqual({
-      provider: "googleai",
-      model: "gemini-2.5-flash",
-    });
-    expect(resolveEvalModel("app", "gemini-pro").frontend).toEqual({
-      provider: "googleai",
-      model: "gemini-2.5-pro",
-    });
     expect(
       resolveEvalModel("script", "gemini-3-flash-preview").frontend,
     ).toEqual({
@@ -37,8 +44,8 @@ describe("resolveEvalModel", () => {
   });
 
   it("rejects Gemini aliases for cli evals", () => {
-    expect(() => resolveEvalModel("cli", "gemini")).toThrow(
-      "Model gemini-flash is not supported for cli mode",
+    expect(() => resolveEvalModel("cli", "gemini-3-flash-preview")).toThrow(
+      "Model gemini-3-flash-preview is not supported for cli mode",
     );
   });
 });
diff --git a/ai_evals/core/models.ts b/ai_evals/core/models.ts
index 054a27bc1c..295cd36135 100644
--- a/ai_evals/core/models.ts
+++ b/ai_evals/core/models.ts
@@ -88,21 +88,12 @@ export const EVAL_MODELS: EvalModelSpec[] = [
     },
   },
   {
-    id: "gemini-flash",
-    label: "Gemini 2.5 Flash",
-    aliases: ["gemini", "gemini-flash", "gemini-2.5-flash"],
+    id: "gpt-5.5",
+    label: "GPT-5.5",
+    aliases: ["gpt-5.5", "gpt-55", "5.5"],
     frontend: {
-      provider: "googleai",
-      model: "gemini-2.5-flash",
-    },
-  },
-  {
-    id: "gemini-pro",
-    label: "Gemini 2.5 Pro",
-    aliases: ["gemini-pro", "gemini-2.5-pro"],
-    frontend: {
-      provider: "googleai",
-      model: "gemini-2.5-pro",
+      provider: "openai",
+      model: "gpt-5.5",
     },
   },
   {
diff --git a/ai_evals/core/results.test.ts b/ai_evals/core/results.test.ts
new file mode 100644
index 0000000000..2d6077c5bd
--- /dev/null
+++ b/ai_evals/core/results.test.ts
@@ -0,0 +1,242 @@
+import { mkdtemp, readFile, rm } from "node:fs/promises";
+import { join } from "node:path";
+import { tmpdir } from "node:os";
+import { describe, expect, it } from "bun:test";
+import {
+  appendHistoryRecord,
+  buildRunResult,
+  formatRunSummary,
+} from "./results";
+import type { BenchmarkCaseResult } from "./types";
+
+function caseResult(
+  attempts: BenchmarkCaseResult["attempts"],
+): BenchmarkCaseResult {
+  return {
+    id: "case-1",
+    prompt: "Do the thing",
+    attempts,
+  };
+}
+
+describe("benchmark results", () => {
+  it("keeps success cost metrics separate from failed attempts", () => {
+    const result = buildRunResult({
+      mode: "global",
+      runs: 1,
+      runModel: "model-under-test",
+      judgeModel: "judge-model",
+      caseResults: [
+        caseResult([
+          {
+            attempt: 1,
+            passed: true,
+            durationMs: 1000,
+            assistantMessageCount: 1,
+            toolCallCount: 1,
+            toolsUsed: ["edit_script"],
+            skillsInvoked: [],
+            checks: [{ name: "edited", passed: true }],
+            judgeScore: 100,
+            judgeSummary: "ok",
+            error: null,
+            tokenUsage: { prompt: 100, completion: 20, total: 120 },
+          },
+          {
+            attempt: 2,
+            passed: false,
+            durationMs: 100,
+            assistantMessageCount: 1,
+            toolCallCount: 0,
+            toolsUsed: [],
+            skillsInvoked: [],
+            checks: [{ name: "edited", passed: false }],
+            judgeScore: 10,
+            judgeSummary: "missed",
+            error: "failed",
+            tokenUsage: { prompt: 10, completion: 5, total: 15 },
+          },
+        ]),
+      ],
+    });
+
+    expect(result.attemptCount).toBe(2);
+    expect(result.passedAttempts).toBe(1);
+    expect(result.passRate).toBe(0.5);
+    expect(result.averageDurationMs).toBe(550);
+    expect(result.averagePassedDurationMs).toBe(1000);
+    expect(result.totalTokenUsage).toEqual({
+      prompt: 110,
+      completion: 25,
+      total: 135,
+    });
+    expect(result.totalPassedTokenUsage).toEqual({
+      prompt: 100,
+      completion: 20,
+      total: 120,
+    });
+    expect(result.averageTokenUsagePerAttempt).toEqual({
+      prompt: 55,
+      completion: 12.5,
+      total: 67.5,
+    });
+    expect(result.averageTokenUsagePerPassedAttempt).toEqual({
+      prompt: 100,
+      completion: 20,
+      total: 120,
+    });
+
+    const summary = formatRunSummary(result);
+    expect(summary).toContain("Average duration (passed): 1000ms");
+    expect(summary).toContain("Average tokens (passed): 120 total");
+    expect(summary).toContain("Average duration (all attempts): 550ms");
+  });
+
+  it("reports passed averages as unavailable when no attempt passes", () => {
+    const result = buildRunResult({
+      mode: "global",
+      runs: 1,
+      runModel: "model-under-test",
+      judgeModel: "judge-model",
+      caseResults: [
+        caseResult([
+          {
+            attempt: 1,
+            passed: false,
+            durationMs: 100,
+            assistantMessageCount: 1,
+            toolCallCount: 0,
+            toolsUsed: [],
+            skillsInvoked: [],
+            checks: [{ name: "edited", passed: false }],
+            judgeScore: 10,
+            judgeSummary: "missed",
+            error: "failed",
+            tokenUsage: { prompt: 10, completion: 5, total: 15 },
+          },
+        ]),
+      ],
+    });
+
+    expect(result.averagePassedDurationMs).toBeNull();
+    expect(result.totalPassedTokenUsage).toBeNull();
+    expect(result.averageTokenUsagePerPassedAttempt).toBeNull();
+    expect(formatRunSummary(result)).toContain(
+      "Average duration (passed): n/a",
+    );
+  });
+
+  it("normalizes passed token averages by passed attempts", () => {
+    const result = buildRunResult({
+      mode: "global",
+      runs: 1,
+      runModel: "model-under-test",
+      judgeModel: "judge-model",
+      caseResults: [
+        caseResult([
+          {
+            attempt: 1,
+            passed: true,
+            durationMs: 1000,
+            assistantMessageCount: 1,
+            toolCallCount: 1,
+            toolsUsed: ["edit_script"],
+            skillsInvoked: [],
+            checks: [{ name: "edited", passed: true }],
+            judgeScore: 100,
+            judgeSummary: "ok",
+            error: null,
+            tokenUsage: { prompt: 100, completion: 20, total: 120 },
+          },
+          {
+            attempt: 2,
+            passed: true,
+            durationMs: 1200,
+            assistantMessageCount: 1,
+            toolCallCount: 1,
+            toolsUsed: ["edit_script"],
+            skillsInvoked: [],
+            checks: [{ name: "edited", passed: true }],
+            judgeScore: 100,
+            judgeSummary: "ok",
+            error: null,
+            tokenUsage: null,
+          },
+        ]),
+      ],
+    });
+
+    expect(result.passedAttempts).toBe(2);
+    expect(result.totalPassedTokenUsage).toEqual({
+      prompt: 100,
+      completion: 20,
+      total: 120,
+    });
+    expect(result.averageTokenUsagePerPassedAttempt).toEqual({
+      prompt: 50,
+      completion: 10,
+      total: 60,
+    });
+  });
+
+  it("records passed-attempt metrics in history", async () => {
+    const tempDir = await mkdtemp(join(tmpdir(), "windmill-ai-evals-"));
+    try {
+      const historyPath = join(tempDir, "history.jsonl");
+      const result = buildRunResult({
+        mode: "global",
+        runs: 1,
+        runModel: "model-under-test",
+        judgeModel: "judge-model",
+        caseResults: [
+          caseResult([
+            {
+              attempt: 1,
+              passed: true,
+              durationMs: 1000,
+              assistantMessageCount: 1,
+              toolCallCount: 1,
+              toolsUsed: ["edit_script"],
+              skillsInvoked: [],
+              checks: [{ name: "edited", passed: true }],
+              judgeScore: 100,
+              judgeSummary: "ok",
+              error: null,
+              tokenUsage: { prompt: 100, completion: 20, total: 120 },
+            },
+            {
+              attempt: 2,
+              passed: false,
+              durationMs: 100,
+              assistantMessageCount: 1,
+              toolCallCount: 0,
+              toolsUsed: [],
+              skillsInvoked: [],
+              checks: [{ name: "edited", passed: false }],
+              judgeScore: 10,
+              judgeSummary: "missed",
+              error: "failed",
+              tokenUsage: { prompt: 10, completion: 5, total: 15 },
+            },
+          ]),
+        ],
+      });
+
+      await appendHistoryRecord(result, historyPath);
+      const record = JSON.parse(await readFile(historyPath, "utf8"));
+
+      expect(record.averageDurationMs).toBe(550);
+      expect(record.averagePassedDurationMs).toBe(1000);
+      expect(record.averageTokenUsagePerAttempt.total).toBe(67.5);
+      expect(record.averageTokenUsagePerPassedAttempt.total).toBe(120);
+      expect(record.cases[0].averageDurationMs).toBe(550);
+      expect(record.cases[0].averagePassedDurationMs).toBe(1000);
+      expect(record.cases[0].averageTokenUsagePerAttempt.total).toBe(67.5);
+      expect(record.cases[0].averageTokenUsagePerPassedAttempt.total).toBe(
+        120,
+      );
+    } finally {
+      await rm(tempDir, { recursive: true, force: true });
+    }
+  });
+});
diff --git a/ai_evals/core/results.ts b/ai_evals/core/results.ts
index e58840f911..0b84497165 100644
--- a/ai_evals/core/results.ts
+++ b/ai_evals/core/results.ts
@@ -4,12 +4,20 @@ import { execFileSync } from "node:child_process";
 import { getAiEvalsRoot, getRepoRoot } from "./cases";
 import type {
   BenchmarkArtifactFile,
+  BenchmarkAttemptResult,
   BenchmarkCaseResult,
   BenchmarkRunResult,
   BenchmarkTokenUsage,
   EvalMode,
 } from "./types";
 
+type AttemptAggregate = {
+  attemptCount: number;
+  durationTotal: number;
+  tokenUsageAttemptCount: number;
+  tokenUsageTotal: BenchmarkTokenUsage | null;
+};
+
 export async function writeRunResult(
   result: BenchmarkRunResult,
   outputPath?: string,
@@ -77,36 +85,12 @@ export function buildRunResult(input: {
   judgeModel: string | null;
   caseResults: BenchmarkCaseResult[];
 }): BenchmarkRunResult {
-  const attemptCount = input.caseResults.reduce(
-    (sum, entry) => sum + entry.attempts.length,
-    0,
-  );
-  const passedAttempts = input.caseResults.reduce(
-    (sum, entry) =>
-      sum + entry.attempts.filter((attempt) => attempt.passed).length,
-    0,
-  );
-  const durationTotal = input.caseResults.reduce(
-    (sum, entry) =>
-      sum +
-      entry.attempts.reduce((inner, attempt) => inner + attempt.durationMs, 0),
-    0,
-  );
-  const tokenUsageTotal = input.caseResults.reduce<BenchmarkTokenUsage | null>(
-    (sum, entry) => {
-      for (const attempt of entry.attempts) {
-        if (!attempt.tokenUsage) {
-          continue;
-        }
-        sum ??= { prompt: 0, completion: 0, total: 0 };
-        sum.prompt += attempt.tokenUsage.prompt;
-        sum.completion += attempt.tokenUsage.completion;
-        sum.total += attempt.tokenUsage.total;
-      }
-      return sum;
-    },
-    null,
-  );
+  const attempts = input.caseResults.flatMap((entry) => entry.attempts);
+  const passedAttemptResults = attempts.filter((attempt) => attempt.passed);
+  const attemptAggregate = aggregateAttempts(attempts);
+  const passedAttemptAggregate = aggregateAttempts(passedAttemptResults);
+  const attemptCount = attemptAggregate.attemptCount;
+  const passedAttempts = passedAttemptAggregate.attemptCount;
 
   return {
     version: 1,
@@ -120,16 +104,19 @@ export function buildRunResult(input: {
     attemptCount,
     passedAttempts,
     passRate: attemptCount === 0 ? 0 : passedAttempts / attemptCount,
-    averageDurationMs: attemptCount === 0 ? 0 : durationTotal / attemptCount,
-    totalTokenUsage: tokenUsageTotal,
+    averageDurationMs:
+      attemptCount === 0 ? 0 : attemptAggregate.durationTotal / attemptCount,
+    averagePassedDurationMs: averageDuration(passedAttemptAggregate),
+    totalTokenUsage: attemptAggregate.tokenUsageTotal,
+    totalPassedTokenUsage: passedAttemptAggregate.tokenUsageTotal,
     averageTokenUsagePerAttempt:
-      attemptCount === 0 || !tokenUsageTotal
+      attemptCount === 0
         ? null
-        : {
-            prompt: tokenUsageTotal.prompt / attemptCount,
-            completion: tokenUsageTotal.completion / attemptCount,
-            total: tokenUsageTotal.total / attemptCount,
-          },
+        : averageTokenUsage(attemptAggregate, attemptCount),
+    averageTokenUsagePerPassedAttempt: averageTokenUsage(
+      passedAttemptAggregate,
+      passedAttempts,
+    ),
     cases: input.caseResults,
   };
 }
@@ -138,9 +125,25 @@ export function formatRunSummary(result: BenchmarkRunResult): string {
   const lines = [
     `${result.mode} benchmark complete`,
     `Pass rate: ${formatPercent(result.passRate)} (${result.passedAttempts}/${result.attemptCount})`,
-    `Average duration: ${Math.round(result.averageDurationMs)}ms`,
+    `Average duration (passed): ${formatNullableDuration(result.averagePassedDurationMs ?? null)}`,
   ];
 
+  if (result.averageTokenUsagePerPassedAttempt) {
+    lines.push(
+      `Average tokens (passed): ${formatTokenUsage(result.averageTokenUsagePerPassedAttempt)}`,
+    );
+  }
+  if (result.passedAttempts < result.attemptCount) {
+    lines.push(
+      `Average duration (all attempts): ${Math.round(result.averageDurationMs)}ms`,
+    );
+    if (result.averageTokenUsagePerAttempt) {
+      lines.push(
+        `Average tokens (all attempts): ${formatTokenUsage(result.averageTokenUsagePerAttempt)}`,
+      );
+    }
+  }
+
   const failures = collectFailures(result);
   if (failures.length > 0) {
     lines.push("Failures:");
@@ -172,6 +175,60 @@ function collectFailures(result: BenchmarkRunResult): string[] {
   return failures;
 }
 
+function aggregateAttempts(attempts: BenchmarkAttemptResult[]): AttemptAggregate {
+  const aggregate: AttemptAggregate = {
+    attemptCount: attempts.length,
+    durationTotal: 0,
+    tokenUsageAttemptCount: 0,
+    tokenUsageTotal: null,
+  };
+
+  for (const attempt of attempts) {
+    aggregate.durationTotal += attempt.durationMs;
+    if (!attempt.tokenUsage) {
+      continue;
+    }
+    aggregate.tokenUsageAttemptCount += 1;
+    aggregate.tokenUsageTotal ??= { prompt: 0, completion: 0, total: 0 };
+    aggregate.tokenUsageTotal.prompt += attempt.tokenUsage.prompt;
+    aggregate.tokenUsageTotal.completion += attempt.tokenUsage.completion;
+    aggregate.tokenUsageTotal.total += attempt.tokenUsage.total;
+  }
+
+  return aggregate;
+}
+
+function averageDuration(aggregate: AttemptAggregate): number | null {
+  return aggregate.attemptCount === 0
+    ? null
+    : aggregate.durationTotal / aggregate.attemptCount;
+}
+
+function averageTokenUsage(
+  aggregate: AttemptAggregate,
+  denominator: number,
+): BenchmarkTokenUsage | null {
+  if (denominator === 0 || !aggregate.tokenUsageTotal) {
+    return null;
+  }
+  return {
+    prompt: aggregate.tokenUsageTotal.prompt / denominator,
+    completion: aggregate.tokenUsageTotal.completion / denominator,
+    total: aggregate.tokenUsageTotal.total / denominator,
+  };
+}
+
+function formatNullableDuration(value: number | null): string {
+  return value === null ? "n/a" : `${Math.round(value)}ms`;
+}
+
+function formatTokenUsage(value: BenchmarkTokenUsage): string {
+  const total = Math.round(value.total);
+  const prompt = Math.round(value.prompt);
+  const completion = Math.round(value.completion);
+  return `${total} total (${prompt} prompt, ${completion} completion)`;
+}
+
 function defaultFileName(mode: EvalMode): string {
   return `${new Date().toISOString().replaceAll(":", "-")}__${mode}.json`;
 }
@@ -252,12 +309,15 @@ function toHistoryRecord(result: BenchmarkRunResult) {
     passedAttempts: result.passedAttempts,
     passRate: result.passRate,
     averageDurationMs: result.averageDurationMs,
+    averagePassedDurationMs: result.averagePassedDurationMs ?? null,
     averageJudgeScore:
       judgeScores.length === 0
         ? null
         : judgeScores.reduce((sum, score) => sum + score, 0) /
           judgeScores.length,
     averageTokenUsagePerAttempt: result.averageTokenUsagePerAttempt ?? null,
+    averageTokenUsagePerPassedAttempt:
+      result.averageTokenUsagePerPassedAttempt ?? null,
     failedCaseIds: Array.from(
       new Set(
         result.cases
@@ -268,31 +328,15 @@ function toHistoryRecord(result: BenchmarkRunResult) {
       ),
     ),
     cases: result.cases.map((caseResult) => {
-      const attemptCount = caseResult.attempts.length;
-      const passedAttempts = caseResult.attempts.filter(
-        (attempt) => attempt.passed,
-      ).length;
-      const totalDurationMs = caseResult.attempts.reduce(
-        (sum, attempt) => sum + attempt.durationMs,
-        0,
+      const attemptAggregate = aggregateAttempts(caseResult.attempts);
+      const passedAttemptAggregate = aggregateAttempts(
+        caseResult.attempts.filter((attempt) => attempt.passed),
       );
+      const attemptCount = attemptAggregate.attemptCount;
+      const passedAttempts = passedAttemptAggregate.attemptCount;
       const judgeScores = caseResult.attempts.flatMap((attempt) =>
         typeof attempt.judgeScore === "number" ? [attempt.judgeScore] : [],
       );
-      const totalTokenUsage =
-        caseResult.attempts.reduce<BenchmarkTokenUsage | null>(
-          (sum, attempt) => {
-            if (!attempt.tokenUsage) {
-              return sum;
-            }
-            sum ??= { prompt: 0, completion: 0, total: 0 };
-            sum.prompt += attempt.tokenUsage.prompt;
-            sum.completion += attempt.tokenUsage.completion;
-            sum.total += attempt.tokenUsage.total;
-            return sum;
-          },
-          null,
-        );
 
       return {
         id: caseResult.id,
@@ -300,20 +344,23 @@ function toHistoryRecord(result: BenchmarkRunResult) {
         passedAttempts,
         passRate: attemptCount === 0 ? 0 : passedAttempts / attemptCount,
         averageDurationMs:
-          attemptCount === 0 ? 0 : totalDurationMs / attemptCount,
+          attemptCount === 0
+            ? 0
+            : attemptAggregate.durationTotal / attemptCount,
+        averagePassedDurationMs: averageDuration(passedAttemptAggregate),
         averageJudgeScore:
           judgeScores.length === 0
             ? null
             : judgeScores.reduce((sum, score) => sum + score, 0) /
               judgeScores.length,
         averageTokenUsagePerAttempt:
-          attemptCount === 0 || !totalTokenUsage
+          attemptCount === 0
             ? null
-            : {
-                prompt: totalTokenUsage.prompt / attemptCount,
-                completion: totalTokenUsage.completion / attemptCount,
-                total: totalTokenUsage.total / attemptCount,
-              },
+            : averageTokenUsage(attemptAggregate, attemptCount),
+        averageTokenUsagePerPassedAttempt: averageTokenUsage(
+          passedAttemptAggregate,
+          passedAttempts,
+        ),
       };
     }),
   };
diff --git a/ai_evals/core/types.ts b/ai_evals/core/types.ts
index 2b42a0dfc5..ecc46591fc 100644
--- a/ai_evals/core/types.ts
+++ b/ai_evals/core/types.ts
@@ -110,7 +110,9 @@ export interface AppValidationSpec {
 
 export interface GlobalDraftRequirement {
   type: string;
-  path: string;
+  path?: string;
+  pathIncludes?: string[];
+  pathStartsWith?: string;
   triggerKind?: string;
   language?: string;
   summaryIncludes?: string[];
@@ -324,8 +326,11 @@ export interface BenchmarkRunResult {
   passedAttempts: number;
   passRate: number;
   averageDurationMs: number;
+  averagePassedDurationMs?: number | null;
   totalTokenUsage?: BenchmarkTokenUsage | null;
+  totalPassedTokenUsage?: BenchmarkTokenUsage | null;
   averageTokenUsagePerAttempt?: BenchmarkTokenUsage | null;
+  averageTokenUsagePerPassedAttempt?: BenchmarkTokenUsage | null;
   artifactsPath?: string | null;
   cases: BenchmarkCaseResult[];
 }
diff --git a/ai_evals/core/validators.test.ts b/ai_evals/core/validators.test.ts
index d2a6e954bb..6010f6351a 100644
--- a/ai_evals/core/validators.test.ts
+++ b/ai_evals/core/validators.test.ts
@@ -195,6 +195,69 @@ describe("validateGlobalState", () => {
     });
   });
 
+  it("accepts a required script draft without an exact path", () => {
+    const checks = validateGlobalState({
+      actual: {
+        drafts: [
+          {
+            type: "script",
+            path: "f/team_tools/friendly_greeting",
+            language: "bun",
+            summary: "Friendly greeting helper",
+            value:
+              "export async function main(name: string) {\n  return `Hello, ${name}!`\n}\n",
+            isDraft: true,
+          },
+        ],
+      },
+      validate: {
+        draftCountExactly: 1,
+        requiredDrafts: [
+          {
+            type: "script",
+            pathIncludes: ["greeting"],
+            language: "bun",
+            summaryIncludes: ["Friendly"],
+            valueIncludes: ["Hello"],
+          },
+        ],
+      },
+    });
+
+    expect(checks.every((check) => check.passed)).toBe(true);
+  });
+
+  it("reports flexible global draft path filters when no draft matches", () => {
+    const checks = validateGlobalState({
+      actual: {
+        drafts: [
+          {
+            type: "script",
+            path: "f/team_tools/friendly_greeting",
+            language: "bun",
+            value:
+              "export async function main(name: string) {\n  return `Hello, ${name}!`\n}\n",
+            isDraft: true,
+          },
+        ],
+      },
+      validate: {
+        requiredDrafts: [
+          {
+            type: "script",
+            pathIncludes: ["invoice"],
+          },
+        ],
+      },
+    });
+
+    expect(checks).toContainEqual({
+      name: "global includes script draft (path includes invoice)",
+      passed: false,
+      details: "drafts: script:f/team_tools/friendly_greeting",
+    });
+  });
+
   it("does not require a TypeScript entrypoint for non-TypeScript script drafts", () => {
     const checks = validateGlobalState({
       actual: {
diff --git a/ai_evals/core/validators.ts b/ai_evals/core/validators.ts
index 4f59368113..693d34a013 100644
--- a/ai_evals/core/validators.ts
+++ b/ai_evals/core/validators.ts
@@ -315,10 +315,11 @@ export function validateGlobalState(input: {
   }
 
   for (const required of validate.requiredDrafts ?? []) {
-    const draft = findGlobalDraft(drafts, required.type, required.path, required.triggerKind);
+    const requirementLabel = formatGlobalDraftRequirement(required);
+    const draft = findGlobalDraft(drafts, required);
     checks.push(
       check(
-        `global includes ${required.type} draft ${required.path}`,
+        `global includes ${requirementLabel}`,
         Boolean(draft),
         summarizeGlobalDrafts(drafts)
       )
@@ -330,7 +331,7 @@ export function validateGlobalState(input: {
     if (required.language !== undefined) {
       checks.push(
         check(
-          `${required.type} draft ${required.path} uses ${required.language}`,
+          `${requirementLabel} uses ${required.language}`,
           draft.language === required.language,
           `language=${draft.language ?? "(none)"}`
         )
@@ -340,7 +341,7 @@ export function validateGlobalState(input: {
     for (const snippet of required.summaryIncludes ?? []) {
       checks.push(
         check(
-          `${required.type} draft ${required.path} summary includes '${snippet}'`,
+          `${requirementLabel} summary includes '${snippet}'`,
           normalizeText(draft.summary ?? "").includes(normalizeText(snippet)),
           `summary=${draft.summary ?? ""}`
         )
@@ -351,7 +352,7 @@ export function validateGlobalState(input: {
     for (const snippet of required.valueIncludes ?? []) {
       checks.push(
         check(
-          `${required.type} draft ${required.path} value includes '${snippet}'`,
+          `${requirementLabel} value includes '${snippet}'`,
           normalizeText(valueText).includes(normalizeText(snippet)),
           truncateForDetails(valueText)
         )
@@ -361,7 +362,7 @@ export function validateGlobalState(input: {
     for (const snippet of required.valueExcludes ?? []) {
       checks.push(
         check(
-          `${required.type} draft ${required.path} value excludes '${snippet}'`,
+          `${requirementLabel} value excludes '${snippet}'`,
           !normalizeText(valueText).includes(normalizeText(snippet)),
           truncateForDetails(valueText)
         )
@@ -373,7 +374,7 @@ export function validateGlobalState(input: {
     checks.push(
       check(
         `global does not include ${forbidden.type} draft ${forbidden.path}`,
-        !findGlobalDraft(drafts, forbidden.type, forbidden.path, forbidden.triggerKind),
+        !findGlobalDraft(drafts, forbidden),
         summarizeGlobalDrafts(drafts)
       )
     );
@@ -615,16 +616,100 @@ function summarizeProblems(problems: string[], limit = 5): string | undefined {
 
 function findGlobalDraft(
   drafts: GlobalDraft[],
-  type: string,
-  path: string,
-  triggerKind?: string
+  requirement: {
+    type: string;
+    path?: string;
+    pathIncludes?: string[];
+    pathStartsWith?: string;
+    triggerKind?: string;
+    summaryIncludes?: string[];
+    valueIncludes?: string[];
+    valueExcludes?: string[];
+  }
 ): GlobalDraft | undefined {
-  return drafts.find(
-    (draft) =>
-      draft.type === type &&
-      draft.path === path &&
-      (triggerKind === undefined || draft.triggerKind === triggerKind)
+  const candidates = drafts.filter((draft) =>
+    globalDraftMatchesLocator(draft, requirement)
   );
+  return (
+    candidates.find((draft) => globalDraftMatchesContent(draft, requirement)) ??
+    candidates[0]
+  );
+}
+
+function globalDraftMatchesLocator(
+  draft: GlobalDraft,
+  requirement: {
+    type: string;
+    path?: string;
+    pathIncludes?: string[];
+    pathStartsWith?: string;
+    triggerKind?: string;
+  }
+): boolean {
+  return (
+    draft.type === requirement.type &&
+    (requirement.path === undefined || draft.path === requirement.path) &&
+    (requirement.pathStartsWith === undefined ||
+      draft.path.startsWith(requirement.pathStartsWith)) &&
+    (requirement.pathIncludes ?? []).every((snippet) =>
+      normalizeText(draft.path).includes(normalizeText(snippet))
+    ) &&
+    (requirement.triggerKind === undefined ||
+      draft.triggerKind === requirement.triggerKind)
+  );
+}
+
+function globalDraftMatchesContent(
+  draft: GlobalDraft,
+  requirement: {
+    summaryIncludes?: string[];
+    valueIncludes?: string[];
+    valueExcludes?: string[];
+  }
+): boolean {
+  const summary = normalizeText(draft.summary ?? "");
+  const value = normalizeText(stringifyGlobalDraftValue(draft.value));
+  return (
+    (requirement.summaryIncludes ?? []).every((snippet) =>
+      summary.includes(normalizeText(snippet))
+    ) &&
+    (requirement.valueIncludes ?? []).every((snippet) =>
+      value.includes(normalizeText(snippet))
+    ) &&
+    (requirement.valueExcludes ?? []).every(
+      (snippet) => !value.includes(normalizeText(snippet))
+    )
+  );
+}
+
+function formatGlobalDraftRequirement(
+  requirement: {
+    type: string;
+    path?: string;
+    pathIncludes?: string[];
+    pathStartsWith?: string;
+    triggerKind?: string;
+  }
+): string {
+  const typeLabel =
+    requirement.triggerKind === undefined
+      ? requirement.type
+      : `${requirement.triggerKind} ${requirement.type}`;
+  if (requirement.path !== undefined) {
+    return `${typeLabel} draft ${requirement.path}`;
+  }
+
+  const filters = [
+    ...(requirement.pathStartsWith === undefined
+      ? []
+      : [`path starts with ${requirement.pathStartsWith}`]),
+    ...(requirement.pathIncludes ?? []).map(
+      (snippet) => `path includes ${snippet}`
+    ),
+  ];
+  return filters.length === 0
+    ? `${typeLabel} draft`
+    : `${typeLabel} draft (${filters.join(", ")})`;
 }
 
 function summarizeGlobalDrafts(drafts: GlobalDraft[]): string {
diff --git a/ai_evals/fixtures/frontend/global/initial/current_greeting_live_script.json b/ai_evals/fixtures/frontend/global/initial/current_greeting_live_script.json
new file mode 100644
index 0000000000..98538a1ccb
--- /dev/null
+++ b/ai_evals/fixtures/frontend/global/initial/current_greeting_live_script.json
@@ -0,0 +1,66 @@
+{
+  "workspace": {
+    "scripts": [
+      {
+        "path": "f/evals/global/format_greeting",
+        "summary": "Format a deployed greeting",
+        "description": "Returns a plain greeting for a provided name.",
+        "language": "bun",
+        "schema": {
+          "$schema": "https://json-schema.org/draft/2020-12/schema",
+          "type": "object",
+          "properties": {
+            "name": {
+              "type": "string"
+            }
+          },
+          "required": ["name"]
+        },
+        "content": "export async function main(name: string) {\n  return `Hello, ${name}`\n}\n"
+      },
+      {
+        "path": "f/evals/global/format_greeting_archive",
+        "summary": "Archived greeting formatter",
+        "description": "Older greeting formatter kept for reference.",
+        "language": "bun",
+        "schema": {
+          "$schema": "https://json-schema.org/draft/2020-12/schema",
+          "type": "object",
+          "properties": {
+            "name": {
+              "type": "string"
+            }
+          },
+          "required": ["name"]
+        },
+        "content": "export async function main(name: string) {\n  return `Hi, ${name}`\n}\n"
+      }
+    ]
+  },
+  "liveEditorDrafts": [
+    {
+      "type": "script",
+      "storagePath": "f/evals/global/current_greeting",
+      "effectivePath": "f/evals/global/current_greeting",
+      "value": {
+        "path": "f/evals/global/current_greeting",
+        "summary": "Open greeting formatter",
+        "description": "Formats a greeting in the live editor.",
+        "language": "bun",
+        "schema": {
+          "$schema": "https://json-schema.org/draft/2020-12/schema",
+          "type": "object",
+          "properties": {
+            "name": {
+              "type": "string"
+            }
+          },
+          "required": ["name"]
+        },
+        "content": "export async function main(name: string) {\n  return `Hello, ${name}`\n}\n",
+        "is_template": false,
+        "kind": "script"
+      }
+    }
+  ]
+}
diff --git a/ai_evals/fixtures/frontend/global/initial/current_invoice_live_flow.json b/ai_evals/fixtures/frontend/global/initial/current_invoice_live_flow.json
new file mode 100644
index 0000000000..5c2ffcb0f0
--- /dev/null
+++ b/ai_evals/fixtures/frontend/global/initial/current_invoice_live_flow.json
@@ -0,0 +1,118 @@
+{
+  "workspace": {
+    "flows": [
+      {
+        "path": "f/evals/global/process_invoice",
+        "summary": "Deployed invoice processor",
+        "description": "Calculates invoice totals from a subtotal.",
+        "schema": {
+          "$schema": "https://json-schema.org/draft/2020-12/schema",
+          "type": "object",
+          "properties": {
+            "subtotal": {
+              "type": "number"
+            }
+          },
+          "required": ["subtotal"]
+        },
+        "value": {
+          "modules": [
+            {
+              "id": "calculate_total",
+              "summary": "Calculate total from subtotal",
+              "value": {
+                "type": "rawscript",
+                "language": "bun",
+                "content": "export async function main(subtotal: number) {\n  return { subtotal, total: subtotal }\n}\n",
+                "input_transforms": {
+                  "subtotal": {
+                    "type": "javascript",
+                    "expr": "flow_input.subtotal"
+                  }
+                }
+              }
+            }
+          ]
+        }
+      },
+      {
+        "path": "f/evals/global/process_refund",
+        "summary": "Refund processor",
+        "description": "Calculates refund totals.",
+        "schema": {
+          "$schema": "https://json-schema.org/draft/2020-12/schema",
+          "type": "object",
+          "properties": {
+            "subtotal": {
+              "type": "number"
+            }
+          },
+          "required": ["subtotal"]
+        },
+        "value": {
+          "modules": [
+            {
+              "id": "calculate_total",
+              "summary": "Calculate refund total",
+              "value": {
+                "type": "rawscript",
+                "language": "bun",
+                "content": "export async function main(subtotal: number) {\n  return { subtotal, total: subtotal }\n}\n",
+                "input_transforms": {
+                  "subtotal": {
+                    "type": "javascript",
+                    "expr": "flow_input.subtotal"
+                  }
+                }
+              }
+            }
+          ]
+        }
+      }
+    ]
+  },
+  "liveEditorDrafts": [
+    {
+      "type": "flow",
+      "storagePath": "f/evals/global/current_invoice_flow",
+      "effectivePath": "f/evals/global/current_invoice_flow",
+      "value": {
+        "path": "f/evals/global/current_invoice_flow",
+        "summary": "Open invoice processor",
+        "schema": {
+          "$schema": "https://json-schema.org/draft/2020-12/schema",
+          "type": "object",
+          "properties": {
+            "subtotal": {
+              "type": "number"
+            }
+          },
+          "required": ["subtotal"]
+        },
+        "value": {
+          "modules": [
+            {
+              "id": "calculate_total",
+              "summary": "Calculate total from subtotal",
+              "value": {
+                "type": "rawscript",
+                "language": "bun",
+                "content": "export async function main(subtotal: number) {\n  return { subtotal, total: subtotal }\n}\n",
+                "input_transforms": {
+                  "subtotal": {
+                    "type": "javascript",
+                    "expr": "flow_input.subtotal"
+                  }
+                }
+              }
+            }
+          ]
+        },
+        "edited_by": "",
+        "edited_at": "",
+        "archived": false,
+        "extra_perms": {}
+      }
+    }
+  ]
+}
diff --git a/ai_evals/fixtures/frontend/global/initial/process_invoice_flow.json b/ai_evals/fixtures/frontend/global/initial/process_invoice_flow.json
new file mode 100644
index 0000000000..b9b4c675c5
--- /dev/null
+++ b/ai_evals/fixtures/frontend/global/initial/process_invoice_flow.json
@@ -0,0 +1,40 @@
+{
+  "workspace": {
+    "flows": [
+      {
+        "path": "f/evals/global/process_invoice",
+        "summary": "Process an invoice subtotal",
+        "description": "Calculates invoice totals from a subtotal.",
+        "schema": {
+          "$schema": "https://json-schema.org/draft/2020-12/schema",
+          "type": "object",
+          "properties": {
+            "subtotal": {
+              "type": "number"
+            }
+          },
+          "required": ["subtotal"]
+        },
+        "value": {
+          "modules": [
+            {
+              "id": "calculate_total",
+              "summary": "Calculate total from subtotal",
+              "value": {
+                "type": "rawscript",
+                "language": "bun",
+                "content": "export async function main(subtotal: number) {\n  return { subtotal, total: subtotal }\n}\n",
+                "input_transforms": {
+                  "subtotal": {
+                    "type": "javascript",
+                    "expr": "flow_input.subtotal"
+                  }
+                }
+              }
+            }
+          ]
+        }
+      }
+    ]
+  }
+}
diff --git a/ai_evals/fixtures/frontend/global/initial/report_digest_script.json b/ai_evals/fixtures/frontend/global/initial/report_digest_script.json
new file mode 100644
index 0000000000..832b06712f
--- /dev/null
+++ b/ai_evals/fixtures/frontend/global/initial/report_digest_script.json
@@ -0,0 +1,23 @@
+{
+  "workspace": {
+    "scripts": [
+      {
+        "path": "f/evals/global/send_report_digest",
+        "summary": "Build and send the eval report digest",
+        "description": "Returns a dry-run summary for eval report digest notifications.",
+        "language": "bun",
+        "schema": {
+          "$schema": "https://json-schema.org/draft/2020-12/schema",
+          "type": "object",
+          "properties": {
+            "dry_run": {
+              "type": "boolean"
+            }
+          },
+          "required": ["dry_run"]
+        },
+        "content": "export async function main(dry_run: boolean) {\n  return { dry_run, sent: !dry_run, message: dry_run ? 'Preview digest' : 'Digest sent' }\n}\n"
+      }
+    ]
+  }
+}
diff --git a/ai_evals/modes/global.ts b/ai_evals/modes/global.ts
index d68df9f5f8..f3cbf6fd86 100644
--- a/ai_evals/modes/global.ts
+++ b/ai_evals/modes/global.ts
@@ -1,5 +1,8 @@
 import { readFile } from "node:fs/promises";
-import { runGlobalEval } from "../adapters/frontend/core/global/globalEvalRunner";
+import {
+  runGlobalEval,
+  type GlobalLiveEditorDraftFixture,
+} from "../adapters/frontend/core/global/globalEvalRunner";
 import type { BenchmarkWorkspaceRunnables } from "../adapters/frontend/mockBackend";
 import type { FrontendEvalModelConfig } from "../core/models";
 import type { BenchmarkArtifactFile, GlobalValidationSpec, ModeRunner } from "../core/types";
@@ -9,6 +12,7 @@ import { getFrontendApiKey } from "./frontendCommon";
 
 export interface GlobalInitialFixture {
   workspace?: BenchmarkWorkspaceRunnables;
+  liveEditorDrafts?: GlobalLiveEditorDraftFixture[];
 }
 
 export function createGlobalModeRunner(
@@ -31,6 +35,7 @@ export function createGlobalModeRunner(
         getFrontendApiKey(modelConfig.provider),
         {
           workspaceFixtures: initial?.workspace,
+          liveEditorDrafts: initial?.liveEditorDrafts,
           maxIterations: context.evalCase?.runtime?.maxTurns,
           provider: modelConfig.provider,
           model: modelConfig.model,
@@ -73,6 +78,7 @@ async function loadGlobalInitialFixture(path: string): Promise<GlobalInitialFixt
   const parsed = JSON.parse(await readFile(path, "utf8")) as GlobalInitialFixture;
   return {
     workspace: parsed.workspace ?? {},
+    liveEditorDrafts: parsed.liveEditorDrafts ?? [],
   };
 }
 
diff --git a/backend/.sqlx/query-07168aaf14cb6beff0ad4274b441f7f387f5055c47f493271d26731336257384.json b/backend/.sqlx/query-07168aaf14cb6beff0ad4274b441f7f387f5055c47f493271d26731336257384.json
index d29a18c691..e7ed0aee65 100644
--- a/backend/.sqlx/query-07168aaf14cb6beff0ad4274b441f7f387f5055c47f493271d26731336257384.json
+++ b/backend/.sqlx/query-07168aaf14cb6beff0ad4274b441f7f387f5055c47f493271d26731336257384.json
@@ -46,11 +46,11 @@
       ]
     },
     "nullable": [
-      true,
-      true,
-      true,
-      true,
-      true,
+      false,
+      false,
+      false,
+      false,
+      false,
       true,
       true
     ]
diff --git a/backend/.sqlx/query-7f832370916794ab0e5645053688c24678f1519d49ee7263a86dba71d45b8e8c.json b/backend/.sqlx/query-7f832370916794ab0e5645053688c24678f1519d49ee7263a86dba71d45b8e8c.json
new file mode 100644
index 0000000000..173d8f2281
--- /dev/null
+++ b/backend/.sqlx/query-7f832370916794ab0e5645053688c24678f1519d49ee7263a86dba71d45b8e8c.json
@@ -0,0 +1,22 @@
+{
+  "db_name": "PostgreSQL",
+  "query": "INSERT INTO token\n            (token_hash, token_prefix, token, email, label, expiration, super_admin, scopes, read_only)\n            VALUES ($1, $2, $3, $4, $5, now() + ($6 || ' seconds')::interval, $7, $8, $9)",
+  "describe": {
+    "columns": [],
+    "parameters": {
+      "Left": [
+        "Varchar",
+        "Varchar",
+        "Varchar",
+        "Varchar",
+        "Varchar",
+        "Text",
+        "Bool",
+        "TextArray",
+        "Bool"
+      ]
+    },
+    "nullable": []
+  },
+  "hash": "7f832370916794ab0e5645053688c24678f1519d49ee7263a86dba71d45b8e8c"
+}
diff --git a/backend/.sqlx/query-815d96aea4681490582b08630a30a168cc1191acaab96bed6a016c437059c2cd.json b/backend/.sqlx/query-815d96aea4681490582b08630a30a168cc1191acaab96bed6a016c437059c2cd.json
new file mode 100644
index 0000000000..28a725277d
--- /dev/null
+++ b/backend/.sqlx/query-815d96aea4681490582b08630a30a168cc1191acaab96bed6a016c437059c2cd.json
@@ -0,0 +1,26 @@
+{
+  "db_name": "PostgreSQL",
+  "query": "\n            SELECT ws.workspace_id AS \"workspace_id!\", entry->'catalog'->>'resource_path' AS dbname\n            FROM workspace_settings ws\n            CROSS JOIN LATERAL jsonb_each(\n                CASE WHEN jsonb_typeof(ws.ducklake->'ducklakes') = 'object'\n                    THEN ws.ducklake->'ducklakes'\n                    ELSE '{}'::jsonb END\n            ) AS dl(k, entry)\n            WHERE entry->'catalog'->>'resource_type' = 'instance'\n            AND entry->'catalog'->>'resource_path' IS NOT NULL\n            UNION ALL\n            SELECT ws.workspace_id AS \"workspace_id!\", entry->'database'->>'resource_path' AS dbname\n            FROM workspace_settings ws\n            CROSS JOIN LATERAL jsonb_each(\n                CASE WHEN jsonb_typeof(ws.datatable->'datatables') = 'object'\n                    THEN ws.datatable->'datatables'\n                    ELSE '{}'::jsonb END\n            ) AS dt(k, entry)\n            WHERE entry->'database'->>'resource_type' = 'instance'\n            AND entry->'database'->>'resource_path' IS NOT NULL\n            ",
+  "describe": {
+    "columns": [
+      {
+        "ordinal": 0,
+        "name": "workspace_id!",
+        "type_info": "Varchar"
+      },
+      {
+        "ordinal": 1,
+        "name": "dbname",
+        "type_info": "Text"
+      }
+    ],
+    "parameters": {
+      "Left": []
+    },
+    "nullable": [
+      null,
+      null
+    ]
+  },
+  "hash": "815d96aea4681490582b08630a30a168cc1191acaab96bed6a016c437059c2cd"
+}
diff --git a/backend/.sqlx/query-b876f26ce90e30c3510eacddb03d9dd26fac05d18183f2d623ac91ea3876dd5c.json b/backend/.sqlx/query-b876f26ce90e30c3510eacddb03d9dd26fac05d18183f2d623ac91ea3876dd5c.json
new file mode 100644
index 0000000000..e1a3640463
--- /dev/null
+++ b/backend/.sqlx/query-b876f26ce90e30c3510eacddb03d9dd26fac05d18183f2d623ac91ea3876dd5c.json
@@ -0,0 +1,16 @@
+{
+  "db_name": "PostgreSQL",
+  "query": "\n            INSERT INTO variable (workspace_id, path, value, is_secret, description, extra_perms, account)\n            VALUES ($1, $2, $3, true, '', '{}'::jsonb, NULL)\n            ON CONFLICT (workspace_id, path) DO UPDATE SET value = EXCLUDED.value\n            ",
+  "describe": {
+    "columns": [],
+    "parameters": {
+      "Left": [
+        "Varchar",
+        "Varchar",
+        "Varchar"
+      ]
+    },
+    "nullable": []
+  },
+  "hash": "b876f26ce90e30c3510eacddb03d9dd26fac05d18183f2d623ac91ea3876dd5c"
+}
diff --git a/backend/.sqlx/query-bf601a919de299e44e6e418b2e711e24909fc206b7fd48541483e6316fe002d5.json b/backend/.sqlx/query-bf601a919de299e44e6e418b2e711e24909fc206b7fd48541483e6316fe002d5.json
new file mode 100644
index 0000000000..6ca4cbb60f
--- /dev/null
+++ b/backend/.sqlx/query-bf601a919de299e44e6e418b2e711e24909fc206b7fd48541483e6316fe002d5.json
@@ -0,0 +1,28 @@
+{
+  "db_name": "PostgreSQL",
+  "query": "\n            SELECT j.id, j.args\n            FROM v2_job j\n            JOIN v2_job_queue q ON j.id = q.id\n            WHERE j.runnable_path = $1\n              AND j.kind = 'deploymentcallback'\n              AND j.workspace_id = 'test-workspace'\n            ORDER BY j.created_at DESC\n            ",
+  "describe": {
+    "columns": [
+      {
+        "ordinal": 0,
+        "name": "id",
+        "type_info": "Uuid"
+      },
+      {
+        "ordinal": 1,
+        "name": "args",
+        "type_info": "Jsonb"
+      }
+    ],
+    "parameters": {
+      "Left": [
+        "Text"
+      ]
+    },
+    "nullable": [
+      false,
+      true
+    ]
+  },
+  "hash": "bf601a919de299e44e6e418b2e711e24909fc206b7fd48541483e6316fe002d5"
+}
diff --git a/backend/.sqlx/query-f699cc3644aeb35a0588bbb3a6bf2dc0746d9f3a1bea104123188fe2921bc886.json b/backend/.sqlx/query-f699cc3644aeb35a0588bbb3a6bf2dc0746d9f3a1bea104123188fe2921bc886.json
deleted file mode 100644
index d352d3d69d..0000000000
--- a/backend/.sqlx/query-f699cc3644aeb35a0588bbb3a6bf2dc0746d9f3a1bea104123188fe2921bc886.json
+++ /dev/null
@@ -1,16 +0,0 @@
-{
-  "db_name": "PostgreSQL",
-  "query": "UPDATE workspace_runnable_dependencies SET app_path = REGEXP_REPLACE(app_path,'u/' || $2 || '/(.*)','u/' || $1 || '/\\1') WHERE app_path LIKE ('u/' || $2 || '/%') AND workspace_id = $3",
-  "describe": {
-    "columns": [],
-    "parameters": {
-      "Left": [
-        "Text",
-        "Text",
-        "Text"
-      ]
-    },
-    "nullable": []
-  },
-  "hash": "f699cc3644aeb35a0588bbb3a6bf2dc0746d9f3a1bea104123188fe2921bc886"
-}
diff --git a/backend/Cargo.lock b/backend/Cargo.lock
index c32e1d9c67..e39f97cd1f 100644
--- a/backend/Cargo.lock
+++ b/backend/Cargo.lock
@@ -1141,14 +1141,14 @@ dependencies = [
  "http 1.4.1",
  "http-body 0.4.6",
  "hyper 0.14.32",
- "hyper 1.9.0",
+ "hyper 1.10.1",
  "hyper-rustls 0.24.2",
  "hyper-rustls 0.27.9",
  "hyper-util",
  "pin-project-lite",
  "rustls 0.21.12",
  "rustls 0.23.35",
- "rustls-native-certs 0.8.3",
+ "rustls-native-certs 0.8.4",
  "rustls-pki-types",
  "tokio",
  "tokio-rustls 0.26.4",
@@ -1335,7 +1335,7 @@ dependencies = [
  "http 1.4.1",
  "http-body 1.0.1",
  "http-body-util",
- "hyper 1.9.0",
+ "hyper 1.10.1",
  "hyper-util",
  "itoa",
  "matchit 0.8.4",
@@ -1531,7 +1531,7 @@ dependencies = [
  "quote",
  "regex",
  "rustc-hash 2.1.2",
- "shlex",
+ "shlex 1.3.0",
  "syn 2.0.117",
 ]
 
@@ -1551,7 +1551,7 @@ dependencies = [
  "quote",
  "regex",
  "rustc-hash 2.1.2",
- "shlex",
+ "shlex 1.3.0",
  "syn 2.0.117",
 ]
 
@@ -1684,7 +1684,7 @@ dependencies = [
  "hex",
  "http 1.4.1",
  "http-body-util",
- "hyper 1.9.0",
+ "hyper 1.10.1",
  "hyper-named-pipe",
  "hyper-util",
  "hyperlocal",
@@ -1786,13 +1786,13 @@ dependencies = [
 
 [[package]]
 name = "brotli"
-version = "8.0.2"
+version = "8.0.3"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "4bd8b9603c7aa97359dbd97ecf258968c95f3adddd6db2f7e7a5bef101c84560"
+checksum = "8119e4516436f5708bbc474a9d395bf12f1b5395e93a92a56e647ac3388c8610"
 dependencies = [
  "alloc-no-stdlib",
  "alloc-stdlib",
- "brotli-decompressor 5.0.0",
+ "brotli-decompressor 5.0.1",
 ]
 
 [[package]]
@@ -1807,9 +1807,9 @@ dependencies = [
 
 [[package]]
 name = "brotli-decompressor"
-version = "5.0.0"
+version = "5.0.1"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "874bb8112abecc98cbd6d81ea4fa7e94fb9449648c93cc89aa40c81c24d7de03"
+checksum = "5962523e1b92ce1b5e793d9169b9943eece10d39f62550bc04bb605d75b94924"
 dependencies = [
  "alloc-no-stdlib",
  "alloc-stdlib",
@@ -2056,14 +2056,14 @@ dependencies = [
 
 [[package]]
 name = "cc"
-version = "1.2.62"
+version = "1.2.63"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "a1dce859f0832a7d088c4f1119888ab94ef4b5d6795d1ce05afb7fe159d79f98"
+checksum = "556e016178bb5662a08681bbe0f00f8e17631781a4dfc8c45e466e4b185ec27f"
 dependencies = [
  "find-msvc-tools",
  "jobserver",
  "libc",
- "shlex",
+ "shlex 2.0.1",
 ]
 
 [[package]]
@@ -2202,7 +2202,7 @@ version = "4.6.1"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "f2ce8604710f6733aa641a2b3731eaa1e8b3d9973d5e3565da11800813f997a9"
 dependencies = [
- "heck 0.5.0",
+ "heck",
  "proc-macro2",
  "quote",
  "syn 2.0.117",
@@ -3599,7 +3599,7 @@ dependencies = [
  "hickory-resolver",
  "http 1.4.1",
  "http-body-util",
- "hyper 1.9.0",
+ "hyper 1.10.1",
  "hyper-rustls 0.27.9",
  "hyper-util",
  "ipnet",
@@ -3731,8 +3731,8 @@ dependencies = [
  "proc-macro2",
  "quote",
  "stringcase",
- "strum 0.27.2",
- "strum_macros 0.27.2",
+ "strum",
+ "strum_macros",
  "syn 2.0.117",
  "thiserror 2.0.18",
 ]
@@ -3802,7 +3802,7 @@ dependencies = [
  "deno_error 0.6.1",
  "deno_tls",
  "http-body-util",
- "hyper 1.9.0",
+ "hyper 1.10.1",
  "hyper-rustls 0.27.9",
  "hyper-util",
  "log",
@@ -4155,9 +4155,9 @@ dependencies = [
 
 [[package]]
 name = "displaydoc"
-version = "0.2.5"
+version = "0.2.6"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "97369cbbc041bc366949bc74d34658d6cda5621039731c6310521892a3a20ae0"
+checksum = "1ac70aa55017e108007fbaf5aa0f54b021c98f92ff8af59d42eda9da96e3dd4f"
 dependencies = [
  "proc-macro2",
  "quote",
@@ -4364,7 +4364,7 @@ version = "0.6.1"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "a1e6a265c649f3f5979b601d26f1d05ada116434c87741c9493cb56218f76cbc"
 dependencies = [
- "heck 0.5.0",
+ "heck",
  "proc-macro2",
  "quote",
  "syn 2.0.117",
@@ -4984,9 +4984,9 @@ dependencies = [
 
 [[package]]
 name = "generator"
-version = "0.8.8"
+version = "0.8.9"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "52f04ae4152da20c76fe800fa48659201d5cf627c5149ca0b707b69d7eef6cf9"
+checksum = "b3b854b0e584ead1a33f18b2fcad7cf7be18b3875c78816b753639aa501513ae"
 dependencies = [
  "cc",
  "cfg-if",
@@ -5236,13 +5236,13 @@ dependencies = [
 
 [[package]]
 name = "gosyn"
-version = "0.2.9"
+version = "0.2.10"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "5eb37859fda6792e95231aef1c5838f4043ec0ee352d8313421e311c606df612"
+checksum = "c99c1502d84229dc7ddb6af755f40ebe80e7e932fa78ecef979cedcf9999ba93"
 dependencies = [
  "anyhow",
- "strum 0.25.0",
- "thiserror 1.0.69",
+ "strum",
+ "thiserror 2.0.18",
  "unic-ucd-category",
 ]
 
@@ -5418,12 +5418,6 @@ dependencies = [
  "http 1.4.1",
 ]
 
-[[package]]
-name = "heck"
-version = "0.4.1"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "95505c38b4572b2d910cecb0281560f54b440a19336cbbcb27bf6ce6adc6f5a8"
-
 [[package]]
 name = "heck"
 version = "0.5.0"
@@ -5649,7 +5643,7 @@ dependencies = [
  "futures",
  "http 1.4.1",
  "http-body-util",
- "hyper 1.9.0",
+ "hyper 1.10.1",
  "hyper-rustls 0.26.0",
  "hyper-tls",
  "hyper-tungstenite",
@@ -5699,9 +5693,9 @@ dependencies = [
 
 [[package]]
 name = "hyper"
-version = "1.9.0"
+version = "1.10.1"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "6299f016b246a94207e63da54dbe807655bf9e00044f73ded42c3ac5305fbcca"
+checksum = "55281c53a1894c864990125767da440a4e630446785086f52523b20033b74498"
 dependencies = [
  "atomic-waker",
  "bytes",
@@ -5729,7 +5723,7 @@ dependencies = [
  "futures-util",
  "headers",
  "http 1.4.1",
- "hyper 1.9.0",
+ "hyper 1.10.1",
  "hyper-rustls 0.27.9",
  "hyper-tls",
  "hyper-util",
@@ -5749,7 +5743,7 @@ source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "73b7d8abf35697b81a825e386fc151e0d503e8cb5fcb93cc8669c376dfd6f278"
 dependencies = [
  "hex",
- "hyper 1.9.0",
+ "hyper 1.10.1",
  "hyper-util",
  "pin-project-lite",
  "tokio",
@@ -5781,7 +5775,7 @@ checksum = "a0bea761b46ae2b24eb4aef630d8d1c398157b6fc29e6350ecf090a0b70c952c"
 dependencies = [
  "futures-util",
  "http 1.4.1",
- "hyper 1.9.0",
+ "hyper 1.10.1",
  "hyper-util",
  "log",
  "rustls 0.22.4",
@@ -5799,11 +5793,11 @@ source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "33ca68d021ef39cf6463ab54c1d0f5daf03377b70561305bb89a8f83aab66e0f"
 dependencies = [
  "http 1.4.1",
- "hyper 1.9.0",
+ "hyper 1.10.1",
  "hyper-util",
  "log",
  "rustls 0.23.35",
- "rustls-native-certs 0.8.3",
+ "rustls-native-certs 0.8.4",
  "tokio",
  "tokio-rustls 0.26.4",
  "tower-service",
@@ -5816,7 +5810,7 @@ version = "0.5.2"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "2b90d566bffbce6a75bd8b09a05aa8c2cb1fabb6cb348f8840c9e4c90a0d83b0"
 dependencies = [
- "hyper 1.9.0",
+ "hyper 1.10.1",
  "hyper-util",
  "pin-project-lite",
  "tokio",
@@ -5831,7 +5825,7 @@ checksum = "70206fc6890eaca9fde8a0bf71caa2ddfc9fe045ac9e5c70df101a7dbde866e0"
 dependencies = [
  "bytes",
  "http-body-util",
- "hyper 1.9.0",
+ "hyper 1.10.1",
  "hyper-util",
  "native-tls",
  "tokio",
@@ -5846,7 +5840,7 @@ source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "7a343d17fe7885302ed7252767dc7bb83609a874b6ff581142241ec4b73957ad"
 dependencies = [
  "http-body-util",
- "hyper 1.9.0",
+ "hyper 1.10.1",
  "hyper-util",
  "pin-project-lite",
  "tokio",
@@ -5866,12 +5860,12 @@ dependencies = [
  "futures-util",
  "http 1.4.1",
  "http-body 1.0.1",
- "hyper 1.9.0",
+ "hyper 1.10.1",
  "ipnet",
  "libc",
  "percent-encoding",
  "pin-project-lite",
- "socket2 0.6.3",
+ "socket2 0.6.4",
  "system-configuration",
  "tokio",
  "tower-service",
@@ -5887,7 +5881,7 @@ checksum = "986c5ce3b994526b3cd75578e62554abd09f0899d6206de48b3e96ab34ccc8c7"
 dependencies = [
  "hex",
  "http-body-util",
- "hyper 1.9.0",
+ "hyper 1.10.1",
  "hyper-util",
  "pin-project-lite",
  "tokio",
@@ -6116,7 +6110,7 @@ version = "0.3.4"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "4d40460c0ce33d6ce4b0630ad68ff63d6661961c48b6dba35e5a4d81cfb48222"
 dependencies = [
- "socket2 0.6.3",
+ "socket2 0.6.4",
  "widestring",
  "windows-registry",
  "windows-result 0.4.1",
@@ -6144,7 +6138,7 @@ version = "0.3.7"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "1d57a3e447e24c22647738e4607f1df1e0ec6f72e16182c4cd199f647cdfb0e4"
 dependencies = [
- "heck 0.5.0",
+ "heck",
  "proc-macro2",
  "quote",
  "syn 2.0.117",
@@ -6406,7 +6400,7 @@ dependencies = [
  "http 1.4.1",
  "http-body 1.0.1",
  "http-body-util",
- "hyper 1.9.0",
+ "hyper 1.10.1",
  "hyper-http-proxy",
  "hyper-rustls 0.27.9",
  "hyper-timeout",
@@ -6601,9 +6595,9 @@ dependencies = [
 
 [[package]]
 name = "libgssapi-sys"
-version = "0.3.3"
+version = "0.3.4"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "7518e6902e94f92e7c7271232684b60988b4bd813529b4ef9d97aead96956ae8"
+checksum = "5103ac4557eacd36ff678b654b943f8966d3db9688fbd180a0b4c5464759ce17"
 dependencies = [
  "bindgen 0.71.1",
  "pkg-config",
@@ -6638,14 +6632,14 @@ dependencies = [
 
 [[package]]
 name = "libredox"
-version = "0.1.16"
+version = "0.1.17"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "e02f3bb43d335493c96bf3fd3a321600bf6bd07ed34bc64118e9293bdffea46c"
+checksum = "f02ab6bace2054fb888a3c16f990117b579d14a3088e472d63c6011fa185c9d3"
 dependencies = [
  "bitflags 2.11.1",
  "libc",
  "plain",
- "redox_syscall 0.7.5",
+ "redox_syscall 0.8.1",
 ]
 
 [[package]]
@@ -6681,9 +6675,9 @@ dependencies = [
 
 [[package]]
 name = "libz-sys"
-version = "1.1.28"
+version = "1.1.29"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "fc3a226e576f50782b3305c5ccf458698f92798987f551c6a02efe8276721e22"
+checksum = "85bc9657773828b90eeb625adff10eeac83cc21bbfd8e23a03eaa8a33c9e28d9"
 dependencies = [
  "cc",
  "libc",
@@ -7022,9 +7016,9 @@ dependencies = [
 
 [[package]]
 name = "memchr"
-version = "2.8.0"
+version = "2.8.1"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "f8ca58f447f06ed17d5fc4043ce1b10dd205e060fb3ce5b979b8ed8e59ff3f79"
+checksum = "6b947ae49db0d222b1dbc6b113ce7248a3fc3a6ca21b696717bfc000ba4484d8"
 
 [[package]]
 name = "memmap2"
@@ -7117,9 +7111,9 @@ dependencies = [
 
 [[package]]
 name = "mio"
-version = "1.2.0"
+version = "1.2.1"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "50b7e5b27aa02a74bac8c3f23f448f8d87ff11f92d3aac1a6ed369ee08cc56c1"
+checksum = "02bd0af71c67b473010cbbc60715ee815645a4dc942899111f494b4b737d6fda"
 dependencies = [
  "libc",
  "wasi 0.11.1+wasi-snapshot-preview1",
@@ -7198,7 +7192,7 @@ source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "66f62cad7623a9cb6f8f64037f0c4f69c8db8e82914334a83c9788201c2c1bfa"
 dependencies = [
  "darling 0.20.11",
- "heck 0.5.0",
+ "heck",
  "num-bigint",
  "proc-macro-crate",
  "proc-macro-error2",
@@ -7230,7 +7224,7 @@ dependencies = [
  "percent-encoding",
  "rand 0.10.1",
  "serde",
- "socket2 0.6.3",
+ "socket2 0.6.4",
  "thiserror 2.0.18",
  "tokio",
  "tokio-native-tls",
@@ -7396,7 +7390,7 @@ version = "0.101.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "71f7c8ed6ba88a567ec6f7c4cad4a7a8465ab93b8cdaf89d3dc72347a83c2d1f"
 dependencies = [
- "heck 0.5.0",
+ "heck",
  "proc-macro-error",
  "proc-macro2",
  "quote",
@@ -7464,7 +7458,7 @@ dependencies = [
  "dirs 5.0.1",
  "dirs-sys 0.4.1",
  "fancy-regex 0.14.0",
- "heck 0.5.0",
+ "heck",
  "indexmap 2.14.0",
  "log",
  "lru 0.12.5",
@@ -7720,7 +7714,7 @@ dependencies = [
  "http-body-util",
  "httparse",
  "humantime",
- "hyper 1.9.0",
+ "hyper 1.10.1",
  "itertools 0.14.0",
  "md-5 0.10.6",
  "parking_lot",
@@ -8245,7 +8239,7 @@ dependencies = [
  "arrow-schema",
  "arrow-select",
  "base64 0.22.1",
- "brotli 8.0.2",
+ "brotli 8.0.3",
  "bytes",
  "chrono",
  "flate2",
@@ -8698,7 +8692,7 @@ version = "3.5.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "e67ba7e9b2b56446f1d419b1d807906278ffa1a658a8a5d8a39dcb1f5a78614f"
 dependencies = [
- "toml_edit 0.25.11+spec-1.1.0",
+ "toml_edit 0.25.12+spec-1.1.0",
 ]
 
 [[package]]
@@ -8979,7 +8973,7 @@ dependencies = [
  "quinn-udp",
  "rustc-hash 2.1.2",
  "rustls 0.23.35",
- "socket2 0.6.3",
+ "socket2 0.6.4",
  "thiserror 2.0.18",
  "tokio",
  "tracing",
@@ -9017,7 +9011,7 @@ dependencies = [
  "cfg_aliases",
  "libc",
  "once_cell",
- "socket2 0.6.3",
+ "socket2 0.6.4",
  "tracing",
  "windows-sys 0.60.2",
 ]
@@ -9302,9 +9296,9 @@ dependencies = [
 
 [[package]]
 name = "redox_syscall"
-version = "0.7.5"
+version = "0.8.1"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "4666a1a60d8412eab19d94f6d13dcc9cea0a5ef4fdf6a5db306537413c661b1b"
+checksum = "5b44b894f2a6e36457d665d1e08c3866add6ed5e70050c1b4ba8a8ddedb02ce7"
 dependencies = [
  "bitflags 2.11.1",
 ]
@@ -9426,7 +9420,7 @@ dependencies = [
  "http 1.4.1",
  "http-body 1.0.1",
  "http-body-util",
- "hyper 1.9.0",
+ "hyper 1.10.1",
  "hyper-rustls 0.27.9",
  "hyper-tls",
  "hyper-util",
@@ -9438,7 +9432,7 @@ dependencies = [
  "pin-project-lite",
  "quinn",
  "rustls 0.23.35",
- "rustls-native-certs 0.8.3",
+ "rustls-native-certs 0.8.4",
  "rustls-pki-types",
  "serde",
  "serde_json",
@@ -9474,7 +9468,7 @@ dependencies = [
  "http 1.4.1",
  "http-body 1.0.1",
  "http-body-util",
- "hyper 1.9.0",
+ "hyper 1.10.1",
  "hyper-rustls 0.27.9",
  "hyper-util",
  "js-sys",
@@ -9530,7 +9524,7 @@ dependencies = [
  "futures",
  "getrandom 0.2.17",
  "http 1.4.1",
- "hyper 1.9.0",
+ "hyper 1.10.1",
  "reqwest 0.13.1",
  "reqwest-middleware",
  "retry-policies",
@@ -9962,9 +9956,9 @@ dependencies = [
 
 [[package]]
 name = "rustls-native-certs"
-version = "0.8.3"
+version = "0.8.4"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "612460d5f7bea540c490b2b6395d8e34a953e52b491accd6c86c8164c5932a63"
+checksum = "dab5152771c58876a2146916e53e35057e1a4dfa2b9df0f0305b07f611fdea4d"
 dependencies = [
  "openssl-probe 0.2.1",
  "rustls-pki-types",
@@ -10012,7 +10006,7 @@ dependencies = [
  "log",
  "once_cell",
  "rustls 0.23.35",
- "rustls-native-certs 0.8.3",
+ "rustls-native-certs 0.8.4",
  "rustls-platform-verifier-android",
  "rustls-webpki 0.103.13",
  "security-framework 3.7.0",
@@ -10211,15 +10205,6 @@ version = "0.1.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "ece8e78b2f38ec51c51f5d475df0a7187ba5111b2a28bdc761ee05b075d40a71"
 
-[[package]]
-name = "scc"
-version = "2.4.0"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "46e6f046b7fef48e2660c57ed794263155d713de679057f2d0c169bfc6e756cc"
-dependencies = [
- "sdd",
-]
-
 [[package]]
 name = "schannel"
 version = "0.1.29"
@@ -10313,12 +10298,6 @@ dependencies = [
  "untrusted 0.9.0",
 ]
 
-[[package]]
-name = "sdd"
-version = "3.0.10"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "490dcfcbfef26be6800d11870ff2df8774fa6e86d047e3e8c8a76b25655e41ca"
-
 [[package]]
 name = "seahash"
 version = "4.1.0"
@@ -10636,24 +10615,23 @@ dependencies = [
 
 [[package]]
 name = "serial_test"
-version = "3.4.0"
+version = "3.5.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "911bd979bf1070a3f3aa7b691a3b3e9968f339ceeec89e08c280a8a22207a32f"
+checksum = "699f4197115b8a7e7ff19c9a315a4bd6fffec26cc4626ef45ecaea389e081c6d"
 dependencies = [
  "futures-executor",
  "futures-util",
  "log",
  "once_cell",
  "parking_lot",
- "scc",
  "serial_test_derive",
 ]
 
 [[package]]
 name = "serial_test_derive"
-version = "3.4.0"
+version = "3.5.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "0a7d91949b85b0d2fb687445e448b40d322b6b3e4af6b44a29b21d9a5f33e6d9"
+checksum = "94e153fc76e1c6a068703d6d29c508a0b15c061c4b7e43da59cc097bc342673c"
 dependencies = [
  "proc-macro2",
  "quote",
@@ -10729,6 +10707,12 @@ version = "1.3.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "0fda2ff0d084019ba4d7c6f371c95d8fd75ce3524c3cb8fb653a3023f6323e64"
 
+[[package]]
+name = "shlex"
+version = "2.0.1"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "f8fadd59c855ef2080decdef8ff161eb6661b86933c9d82e5ba29dc602a55aba"
+
 [[package]]
 name = "signal-hook-registry"
 version = "1.4.8"
@@ -10862,9 +10846,9 @@ dependencies = [
 
 [[package]]
 name = "socket2"
-version = "0.6.3"
+version = "0.6.4"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "3a766e1110788c36f4fa1c2b71b387a7815aa65f88ce0229841826633d93723e"
+checksum = "52d1cfed4120b4d927bf7c0f86d2087a4a7d6027c906d9f9d525a80573b9be51"
 dependencies = [
  "libc",
  "windows-sys 0.61.2",
@@ -11052,7 +11036,7 @@ checksum = "19a9c1841124ac5a61741f96e1d9e2ec77424bf323962dd894bdb93f37d5219b"
 dependencies = [
  "dotenvy",
  "either",
- "heck 0.5.0",
+ "heck",
  "hex",
  "once_cell",
  "proc-macro2",
@@ -11268,35 +11252,13 @@ version = "0.11.1"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "7da8b5736845d9f2fcb837ea5d9e2628564b3b043a70948a3f0b778838c5fb4f"
 
-[[package]]
-name = "strum"
-version = "0.25.0"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "290d54ea6f91c969195bdbcd7442c8c2a2ba87da8bf60a7ee86a235d4bc1e125"
-dependencies = [
- "strum_macros 0.25.3",
-]
-
 [[package]]
 name = "strum"
 version = "0.27.2"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "af23d6f6c1a224baef9d3f61e287d2761385a5b88fdab4eb4c6f11aeb54c4bcf"
 dependencies = [
- "strum_macros 0.27.2",
-]
-
-[[package]]
-name = "strum_macros"
-version = "0.25.3"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "23dc1fa9ac9c169a78ba62f0b841814b7abae11bdd047b9c58f893439e309ea0"
-dependencies = [
- "heck 0.4.1",
- "proc-macro2",
- "quote",
- "rustversion",
- "syn 2.0.117",
+ "strum_macros",
 ]
 
 [[package]]
@@ -11305,7 +11267,7 @@ version = "0.27.2"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "7695ce3845ea4b33927c055a39dc438a45b059f7c1b3d91d38d10355fb8cbca7"
 dependencies = [
- "heck 0.5.0",
+ "heck",
  "proc-macro2",
  "quote",
  "syn 2.0.117",
@@ -12397,7 +12359,7 @@ dependencies = [
  "postgres-protocol",
  "postgres-types",
  "rand 0.9.0",
- "socket2 0.6.3",
+ "socket2 0.6.4",
  "tokio",
  "tokio-util",
  "whoami",
@@ -12446,9 +12408,9 @@ dependencies = [
 
 [[package]]
 name = "tokio-socks"
-version = "0.5.2"
+version = "0.5.3"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "0d4770b8024672c1101b3f6733eab95b18007dbe0847a8afe341fcf79e06043f"
+checksum = "a7e2948f60dbe26b35f2c7fb74ac2854c1fddded0fe9d7548fcc674a246f7615"
 dependencies = [
  "either",
  "futures-util",
@@ -12542,7 +12504,7 @@ dependencies = [
  "httparse",
  "rand 0.8.5",
  "ring 0.17.14",
- "rustls-native-certs 0.8.3",
+ "rustls-native-certs 0.8.4",
  "rustls-pki-types",
  "tokio",
  "tokio-rustls 0.26.4",
@@ -12594,9 +12556,9 @@ dependencies = [
 
 [[package]]
 name = "toml_edit"
-version = "0.25.11+spec-1.1.0"
+version = "0.25.12+spec-1.1.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "0b59c4d22ed448339746c59b905d24568fcbb3ab65a500494f7b8c3e97739f2b"
+checksum = "d2153edc6955a6c354fad8f5efd38b6a8769bdccf9fe50f8e1329f81b0baa5d7"
 dependencies = [
  "indexmap 2.14.0",
  "toml_datetime 1.1.1+spec-1.1.0",
@@ -12629,7 +12591,7 @@ dependencies = [
  "http 1.4.1",
  "http-body 1.0.1",
  "http-body-util",
- "hyper 1.9.0",
+ "hyper 1.10.1",
  "hyper-timeout",
  "hyper-util",
  "percent-encoding",
@@ -12661,13 +12623,13 @@ dependencies = [
  "http 1.4.1",
  "http-body 1.0.1",
  "http-body-util",
- "hyper 1.9.0",
+ "hyper 1.10.1",
  "hyper-timeout",
  "hyper-util",
  "percent-encoding",
  "pin-project",
  "prost",
- "rustls-native-certs 0.8.3",
+ "rustls-native-certs 0.8.4",
  "socket2 0.5.10",
  "tokio",
  "tokio-rustls 0.26.4",
@@ -13032,9 +12994,9 @@ checksum = "bc7d623258602320d5c55d1bc22793b57daff0ec7efc270ea7d55ce1d5f5471c"
 
 [[package]]
 name = "typenum"
-version = "1.20.0"
+version = "1.20.1"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "40ce102ab67701b8526c123c1bab5cbe42d7040ccfd0f64af1a385808d2f43de"
+checksum = "b6f5e870be6c3b371b77fe0ee0bafb859fa4964b4404c27de1d380043c4dda20"
 
 [[package]]
 name = "typetag"
@@ -13197,9 +13159,9 @@ checksum = "7df058c713841ad818f1dc5d3fd88063241cc61f49f5fbea4b951e8cf5a8d71d"
 
 [[package]]
 name = "unicode-segmentation"
-version = "1.13.2"
+version = "1.13.3"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "9629274872b2bfaf8d66f5f15725007f635594914870f65218920345aa11aa8c"
+checksum = "c6f5d3c3b1bf09027a88a6bc961fc00497d651009560b5463668dc81b0fa87a8"
 
 [[package]]
 name = "unicode-width"
@@ -13364,9 +13326,9 @@ checksum = "06abde3611657adf66d383f00b093d7faecc7fa57071cce2578660c9f1010821"
 
 [[package]]
 name = "uuid"
-version = "1.23.1"
+version = "1.23.2"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "ddd74a9687298c6858e9b88ec8935ec45d22e8fd5e6394fa1bd4e99a87789c76"
+checksum = "d258b83ceec21034727ecee8c382cfa6c3e133699b0742c64571814fb420c9f7"
 dependencies = [
  "getrandom 0.4.2",
  "js-sys",
@@ -13802,7 +13764,7 @@ dependencies = [
 
 [[package]]
 name = "windmill"
-version = "1.711.0"
+version = "1.714.0"
 dependencies = [
  "anyhow",
  "async-nats",
@@ -13836,7 +13798,7 @@ dependencies = [
  "sha2 0.10.9",
  "sql-builder",
  "sqlx",
- "strum 0.27.2",
+ "strum",
  "tar",
  "tempfile",
  "tikv-jemalloc-ctl",
@@ -13883,7 +13845,7 @@ dependencies = [
 
 [[package]]
 name = "windmill-ai"
-version = "1.711.0"
+version = "1.714.0"
 dependencies = [
  "async-stream",
  "async-trait",
@@ -13916,7 +13878,7 @@ dependencies = [
 
 [[package]]
 name = "windmill-alerting"
-version = "1.711.0"
+version = "1.714.0"
 dependencies = [
  "axum 0.8.9",
  "chrono",
@@ -13929,7 +13891,7 @@ dependencies = [
 
 [[package]]
 name = "windmill-api"
-version = "1.711.0"
+version = "1.714.0"
 dependencies = [
  "anyhow",
  "argon2",
@@ -13959,7 +13921,7 @@ dependencies = [
  "hex",
  "hmac",
  "http 1.4.1",
- "hyper 1.9.0",
+ "hyper 1.10.1",
  "indexmap 2.14.0",
  "itertools 0.14.0",
  "jsonwebtoken 8.3.0",
@@ -13990,7 +13952,7 @@ dependencies = [
  "sha2 0.10.9",
  "sql-builder",
  "sqlx",
- "strum 0.27.2",
+ "strum",
  "tar",
  "tempfile",
  "time",
@@ -14067,12 +14029,12 @@ dependencies = [
 
 [[package]]
 name = "windmill-api-agent-workers"
-version = "1.711.0"
+version = "1.714.0"
 dependencies = [
  "axum 0.8.9",
  "chrono",
  "http 1.4.1",
- "hyper 1.9.0",
+ "hyper 1.10.1",
  "lazy_static",
  "quick_cache",
  "serde",
@@ -14090,7 +14052,7 @@ dependencies = [
 
 [[package]]
 name = "windmill-api-assets"
-version = "1.711.0"
+version = "1.714.0"
 dependencies = [
  "axum 0.8.9",
  "chrono",
@@ -14103,7 +14065,7 @@ dependencies = [
 
 [[package]]
 name = "windmill-api-auth"
-version = "1.711.0"
+version = "1.714.0"
 dependencies = [
  "anyhow",
  "axum 0.8.9",
@@ -14129,7 +14091,7 @@ dependencies = [
 
 [[package]]
 name = "windmill-api-client"
-version = "1.711.0"
+version = "1.714.0"
 dependencies = [
  "reqwest 0.12.28",
  "serde",
@@ -14139,7 +14101,7 @@ dependencies = [
 
 [[package]]
 name = "windmill-api-configs"
-version = "1.711.0"
+version = "1.714.0"
 dependencies = [
  "axum 0.8.9",
  "chrono",
@@ -14156,7 +14118,7 @@ dependencies = [
 
 [[package]]
 name = "windmill-api-debug"
-version = "1.711.0"
+version = "1.714.0"
 dependencies = [
  "axum 0.8.9",
  "base64 0.22.1",
@@ -14178,7 +14140,7 @@ dependencies = [
 
 [[package]]
 name = "windmill-api-embeddings"
-version = "1.711.0"
+version = "1.714.0"
 dependencies = [
  "anyhow",
  "axum 0.8.9",
@@ -14201,7 +14163,7 @@ dependencies = [
 
 [[package]]
 name = "windmill-api-flow-conversations"
-version = "1.711.0"
+version = "1.714.0"
 dependencies = [
  "axum 0.8.9",
  "chrono",
@@ -14217,11 +14179,11 @@ dependencies = [
 
 [[package]]
 name = "windmill-api-flows"
-version = "1.711.0"
+version = "1.714.0"
 dependencies = [
  "axum 0.8.9",
  "chrono",
- "hyper 1.9.0",
+ "hyper 1.10.1",
  "serde",
  "serde_json",
  "sql-builder",
@@ -14238,7 +14200,7 @@ dependencies = [
 
 [[package]]
 name = "windmill-api-groups"
-version = "1.711.0"
+version = "1.714.0"
 dependencies = [
  "axum 0.8.9",
  "chrono",
@@ -14259,7 +14221,7 @@ dependencies = [
 
 [[package]]
 name = "windmill-api-inputs"
-version = "1.711.0"
+version = "1.714.0"
 dependencies = [
  "axum 0.8.9",
  "chrono",
@@ -14273,7 +14235,7 @@ dependencies = [
 
 [[package]]
 name = "windmill-api-integration-tests"
-version = "1.711.0"
+version = "1.714.0"
 dependencies = [
  "anyhow",
  "async-nats",
@@ -14305,14 +14267,14 @@ dependencies = [
 
 [[package]]
 name = "windmill-api-jobs"
-version = "1.711.0"
+version = "1.714.0"
 dependencies = [
  "anyhow",
  "axum 0.8.9",
  "base64 0.22.1",
  "chrono",
  "http 1.4.1",
- "hyper 1.9.0",
+ "hyper 1.10.1",
  "lazy_static",
  "serde",
  "serde_json",
@@ -14330,7 +14292,7 @@ dependencies = [
 
 [[package]]
 name = "windmill-api-npm-proxy"
-version = "1.711.0"
+version = "1.714.0"
 dependencies = [
  "axum 0.8.9",
  "flate2",
@@ -14348,7 +14310,7 @@ dependencies = [
 
 [[package]]
 name = "windmill-api-openapi"
-version = "1.711.0"
+version = "1.714.0"
 dependencies = [
  "anyhow",
  "axum 0.8.9",
@@ -14370,7 +14332,7 @@ dependencies = [
 
 [[package]]
 name = "windmill-api-schedule"
-version = "1.711.0"
+version = "1.714.0"
 dependencies = [
  "axum 0.8.9",
  "chrono",
@@ -14390,13 +14352,13 @@ dependencies = [
 
 [[package]]
 name = "windmill-api-scripts"
-version = "1.711.0"
+version = "1.714.0"
 dependencies = [
  "axum 0.8.9",
  "chrono",
  "futures",
  "http 1.4.1",
- "hyper 1.9.0",
+ "hyper 1.10.1",
  "itertools 0.14.0",
  "lazy_static",
  "quick_cache",
@@ -14420,7 +14382,7 @@ dependencies = [
 
 [[package]]
 name = "windmill-api-settings"
-version = "1.711.0"
+version = "1.714.0"
 dependencies = [
  "anyhow",
  "axum 0.8.9",
@@ -14448,7 +14410,7 @@ dependencies = [
 
 [[package]]
 name = "windmill-api-sse"
-version = "1.711.0"
+version = "1.714.0"
 dependencies = [
  "lazy_static",
  "serde",
@@ -14460,14 +14422,14 @@ dependencies = [
 
 [[package]]
 name = "windmill-api-users"
-version = "1.711.0"
+version = "1.714.0"
 dependencies = [
  "argon2",
  "axum 0.8.9",
  "chrono",
  "dashmap",
  "http 1.4.1",
- "hyper 1.9.0",
+ "hyper 1.10.1",
  "lazy_static",
  "serde",
  "serde_json",
@@ -14485,7 +14447,7 @@ dependencies = [
 
 [[package]]
 name = "windmill-api-workers"
-version = "1.711.0"
+version = "1.714.0"
 dependencies = [
  "axum 0.8.9",
  "chrono",
@@ -14499,13 +14461,13 @@ dependencies = [
 
 [[package]]
 name = "windmill-api-workspaces"
-version = "1.711.0"
+version = "1.714.0"
 dependencies = [
  "axum 0.8.9",
  "chrono",
  "hex",
  "http 1.4.1",
- "hyper 1.9.0",
+ "hyper 1.10.1",
  "lazy_static",
  "magic-crypt",
  "regex",
@@ -14513,7 +14475,7 @@ dependencies = [
  "serde_json",
  "sha2 0.10.9",
  "sqlx",
- "strum 0.27.2",
+ "strum",
  "tokio",
  "tracing",
  "uuid",
@@ -14532,7 +14494,7 @@ dependencies = [
 
 [[package]]
 name = "windmill-audit"
-version = "1.711.0"
+version = "1.714.0"
 dependencies = [
  "chrono",
  "lazy_static",
@@ -14546,7 +14508,7 @@ dependencies = [
 
 [[package]]
 name = "windmill-autoscaling"
-version = "1.711.0"
+version = "1.714.0"
 dependencies = [
  "anyhow",
  "axum 0.8.9",
@@ -14565,7 +14527,7 @@ dependencies = [
 
 [[package]]
 name = "windmill-common"
-version = "1.711.0"
+version = "1.714.0"
 dependencies = [
  "aes-gcm",
  "aho-corasick",
@@ -14601,7 +14563,7 @@ dependencies = [
  "globset",
  "hex",
  "hmac",
- "hyper 1.9.0",
+ "hyper 1.10.1",
  "indexmap 2.14.0",
  "itertools 0.14.0",
  "jsonwebtoken 8.3.0",
@@ -14636,8 +14598,8 @@ dependencies = [
  "sha2 0.10.9",
  "size",
  "sqlx",
- "strum 0.27.2",
- "strum_macros 0.27.2",
+ "strum",
+ "strum_macros",
  "sysinfo",
  "systemstat",
  "tar",
@@ -14666,7 +14628,7 @@ dependencies = [
 
 [[package]]
 name = "windmill-dep-map"
-version = "1.711.0"
+version = "1.714.0"
 dependencies = [
  "chrono",
  "itertools 0.14.0",
@@ -14685,7 +14647,7 @@ dependencies = [
 
 [[package]]
 name = "windmill-git-sync"
-version = "1.711.0"
+version = "1.714.0"
 dependencies = [
  "regex",
  "serde",
@@ -14700,7 +14662,7 @@ dependencies = [
 
 [[package]]
 name = "windmill-indexer"
-version = "1.711.0"
+version = "1.714.0"
 dependencies = [
  "anyhow",
  "astral-tokio-tar",
@@ -14724,7 +14686,7 @@ dependencies = [
 
 [[package]]
 name = "windmill-jseval"
-version = "1.711.0"
+version = "1.714.0"
 dependencies = [
  "anyhow",
  "futures",
@@ -14741,7 +14703,7 @@ dependencies = [
 
 [[package]]
 name = "windmill-macros"
-version = "1.711.0"
+version = "1.714.0"
 dependencies = [
  "itertools 0.14.0",
  "lazy_static",
@@ -14757,7 +14719,7 @@ dependencies = [
 
 [[package]]
 name = "windmill-mcp"
-version = "1.711.0"
+version = "1.714.0"
 dependencies = [
  "anyhow",
  "async-trait",
@@ -14778,7 +14740,7 @@ dependencies = [
 
 [[package]]
 name = "windmill-native-triggers"
-version = "1.711.0"
+version = "1.714.0"
 dependencies = [
  "anyhow",
  "async-trait",
@@ -14795,7 +14757,7 @@ dependencies = [
  "serde_json",
  "sha2 0.10.9",
  "sqlx",
- "strum 0.27.2",
+ "strum",
  "tokio",
  "tracing",
  "urlencoding",
@@ -14809,7 +14771,7 @@ dependencies = [
 
 [[package]]
 name = "windmill-oauth"
-version = "1.711.0"
+version = "1.714.0"
 dependencies = [
  "anyhow",
  "arc-swap",
@@ -14834,7 +14796,7 @@ dependencies = [
 
 [[package]]
 name = "windmill-object-store"
-version = "1.711.0"
+version = "1.714.0"
 dependencies = [
  "anyhow",
  "async-stream",
@@ -14868,7 +14830,7 @@ dependencies = [
 
 [[package]]
 name = "windmill-operator"
-version = "1.711.0"
+version = "1.714.0"
 dependencies = [
  "anyhow",
  "futures",
@@ -14886,7 +14848,7 @@ dependencies = [
 
 [[package]]
 name = "windmill-parser"
-version = "1.711.0"
+version = "1.714.0"
 dependencies = [
  "convert_case 0.6.0",
  "serde",
@@ -14895,7 +14857,7 @@ dependencies = [
 
 [[package]]
 name = "windmill-parser-bash"
-version = "1.711.0"
+version = "1.714.0"
 dependencies = [
  "anyhow",
  "lazy_static",
@@ -14907,7 +14869,7 @@ dependencies = [
 
 [[package]]
 name = "windmill-parser-csharp"
-version = "1.711.0"
+version = "1.714.0"
 dependencies = [
  "anyhow",
  "serde_json",
@@ -14919,7 +14881,7 @@ dependencies = [
 
 [[package]]
 name = "windmill-parser-go"
-version = "1.711.0"
+version = "1.714.0"
 dependencies = [
  "anyhow",
  "gosyn",
@@ -14931,7 +14893,7 @@ dependencies = [
 
 [[package]]
 name = "windmill-parser-graphql"
-version = "1.711.0"
+version = "1.714.0"
 dependencies = [
  "anyhow",
  "lazy_static",
@@ -14943,7 +14905,7 @@ dependencies = [
 
 [[package]]
 name = "windmill-parser-java"
-version = "1.711.0"
+version = "1.714.0"
 dependencies = [
  "anyhow",
  "serde_json",
@@ -14955,7 +14917,7 @@ dependencies = [
 
 [[package]]
 name = "windmill-parser-nu"
-version = "1.711.0"
+version = "1.714.0"
 dependencies = [
  "anyhow",
  "nu-parser",
@@ -14966,7 +14928,7 @@ dependencies = [
 
 [[package]]
 name = "windmill-parser-php"
-version = "1.711.0"
+version = "1.714.0"
 dependencies = [
  "anyhow",
  "itertools 0.14.0",
@@ -14977,7 +14939,7 @@ dependencies = [
 
 [[package]]
 name = "windmill-parser-py"
-version = "1.711.0"
+version = "1.714.0"
 dependencies = [
  "anyhow",
  "itertools 0.14.0",
@@ -14989,7 +14951,7 @@ dependencies = [
 
 [[package]]
 name = "windmill-parser-py-asset"
-version = "1.711.0"
+version = "1.714.0"
 dependencies = [
  "anyhow",
  "rustpython-ast",
@@ -15000,7 +14962,7 @@ dependencies = [
 
 [[package]]
 name = "windmill-parser-py-imports"
-version = "1.711.0"
+version = "1.714.0"
 dependencies = [
  "anyhow",
  "async-recursion",
@@ -15022,7 +14984,7 @@ dependencies = [
 
 [[package]]
 name = "windmill-parser-r"
-version = "1.711.0"
+version = "1.714.0"
 dependencies = [
  "anyhow",
  "serde_json",
@@ -15034,7 +14996,7 @@ dependencies = [
 
 [[package]]
 name = "windmill-parser-ruby"
-version = "1.711.0"
+version = "1.714.0"
 dependencies = [
  "anyhow",
  "lazy_static",
@@ -15048,7 +15010,7 @@ dependencies = [
 
 [[package]]
 name = "windmill-parser-rust"
-version = "1.711.0"
+version = "1.714.0"
 dependencies = [
  "anyhow",
  "convert_case 0.6.0",
@@ -15065,7 +15027,7 @@ dependencies = [
 
 [[package]]
 name = "windmill-parser-sql"
-version = "1.711.0"
+version = "1.714.0"
 dependencies = [
  "anyhow",
  "lazy_static",
@@ -15078,7 +15040,7 @@ dependencies = [
 
 [[package]]
 name = "windmill-parser-sql-asset"
-version = "1.711.0"
+version = "1.714.0"
 dependencies = [
  "anyhow",
  "serde",
@@ -15090,7 +15052,7 @@ dependencies = [
 
 [[package]]
 name = "windmill-parser-ts"
-version = "1.711.0"
+version = "1.714.0"
 dependencies = [
  "anyhow",
  "lazy_static",
@@ -15108,7 +15070,7 @@ dependencies = [
 
 [[package]]
 name = "windmill-parser-ts-asset"
-version = "1.711.0"
+version = "1.714.0"
 dependencies = [
  "anyhow",
  "serde-wasm-bindgen",
@@ -15124,7 +15086,7 @@ dependencies = [
 
 [[package]]
 name = "windmill-parser-wac"
-version = "1.711.0"
+version = "1.714.0"
 dependencies = [
  "anyhow",
  "rustpython-ast",
@@ -15140,7 +15102,7 @@ dependencies = [
 
 [[package]]
 name = "windmill-parser-yaml"
-version = "1.711.0"
+version = "1.714.0"
 dependencies = [
  "anyhow",
  "serde",
@@ -15151,7 +15113,7 @@ dependencies = [
 
 [[package]]
 name = "windmill-queue"
-version = "1.711.0"
+version = "1.714.0"
 dependencies = [
  "anyhow",
  "async-recursion",
@@ -15189,7 +15151,7 @@ dependencies = [
 
 [[package]]
 name = "windmill-runtime-nativets"
-version = "1.711.0"
+version = "1.714.0"
 dependencies = [
  "anyhow",
  "const_format",
@@ -15227,7 +15189,7 @@ dependencies = [
 
 [[package]]
 name = "windmill-sql-datatype-parser-wasm"
-version = "1.711.0"
+version = "1.714.0"
 dependencies = [
  "getrandom 0.3.4",
  "wasm-bindgen",
@@ -15238,7 +15200,7 @@ dependencies = [
 
 [[package]]
 name = "windmill-store"
-version = "1.711.0"
+version = "1.714.0"
 dependencies = [
  "anyhow",
  "async-recursion",
@@ -15246,7 +15208,7 @@ dependencies = [
  "chrono",
  "futures",
  "http 1.4.1",
- "hyper 1.9.0",
+ "hyper 1.10.1",
  "lazy_static",
  "quick_cache",
  "reqwest 0.13.1",
@@ -15268,7 +15230,7 @@ dependencies = [
 
 [[package]]
 name = "windmill-test-utils"
-version = "1.711.0"
+version = "1.714.0"
 dependencies = [
  "anyhow",
  "async-trait",
@@ -15292,14 +15254,14 @@ dependencies = [
 
 [[package]]
 name = "windmill-trigger"
-version = "1.711.0"
+version = "1.714.0"
 dependencies = [
  "anyhow",
  "async-trait",
  "axum 0.8.9",
  "chrono",
  "http 1.4.1",
- "hyper 1.9.0",
+ "hyper 1.10.1",
  "itertools 0.14.0",
  "lazy_static",
  "rand 0.9.0",
@@ -15325,7 +15287,7 @@ dependencies = [
 
 [[package]]
 name = "windmill-trigger-azure"
-version = "1.711.0"
+version = "1.714.0"
 dependencies = [
  "anyhow",
  "async-trait",
@@ -15358,7 +15320,7 @@ dependencies = [
 
 [[package]]
 name = "windmill-trigger-email"
-version = "1.711.0"
+version = "1.714.0"
 dependencies = [
  "anyhow",
  "async-trait",
@@ -15378,7 +15340,7 @@ dependencies = [
 
 [[package]]
 name = "windmill-trigger-gcp"
-version = "1.711.0"
+version = "1.714.0"
 dependencies = [
  "anyhow",
  "async-trait",
@@ -15412,7 +15374,7 @@ dependencies = [
 
 [[package]]
 name = "windmill-trigger-http"
-version = "1.711.0"
+version = "1.714.0"
 dependencies = [
  "anyhow",
  "async-trait",
@@ -15424,7 +15386,7 @@ dependencies = [
  "hex",
  "hmac",
  "http 1.4.1",
- "hyper 1.9.0",
+ "hyper 1.10.1",
  "itertools 0.14.0",
  "lazy_static",
  "matchit 0.7.3",
@@ -15448,7 +15410,7 @@ dependencies = [
 
 [[package]]
 name = "windmill-trigger-kafka"
-version = "1.711.0"
+version = "1.714.0"
 dependencies = [
  "anyhow",
  "async-trait",
@@ -15471,7 +15433,7 @@ dependencies = [
 
 [[package]]
 name = "windmill-trigger-mqtt"
-version = "1.711.0"
+version = "1.714.0"
 dependencies = [
  "anyhow",
  "async-trait",
@@ -15495,7 +15457,7 @@ dependencies = [
 
 [[package]]
 name = "windmill-trigger-nats"
-version = "1.711.0"
+version = "1.714.0"
 dependencies = [
  "anyhow",
  "async-nats",
@@ -15519,7 +15481,7 @@ dependencies = [
 
 [[package]]
 name = "windmill-trigger-postgres"
-version = "1.711.0"
+version = "1.714.0"
 dependencies = [
  "anyhow",
  "async-trait",
@@ -15554,7 +15516,7 @@ dependencies = [
 
 [[package]]
 name = "windmill-trigger-sqs"
-version = "1.711.0"
+version = "1.714.0"
 dependencies = [
  "anyhow",
  "async-trait",
@@ -15582,7 +15544,7 @@ dependencies = [
 
 [[package]]
 name = "windmill-trigger-websocket"
-version = "1.711.0"
+version = "1.714.0"
 dependencies = [
  "anyhow",
  "async-trait",
@@ -15607,7 +15569,7 @@ dependencies = [
 
 [[package]]
 name = "windmill-types"
-version = "1.711.0"
+version = "1.714.0"
 dependencies = [
  "anyhow",
  "bitflags 2.11.1",
@@ -15618,7 +15580,7 @@ dependencies = [
  "serde",
  "serde_json",
  "sqlx",
- "strum 0.27.2",
+ "strum",
  "tracing",
  "uuid",
  "windmill-parser",
@@ -15626,7 +15588,7 @@ dependencies = [
 
 [[package]]
 name = "windmill-worker"
-version = "1.711.0"
+version = "1.714.0"
 dependencies = [
  "anyhow",
  "async-once-cell",
@@ -15736,7 +15698,7 @@ dependencies = [
 
 [[package]]
 name = "windmill-worker-volumes"
-version = "1.711.0"
+version = "1.714.0"
 dependencies = [
  "bytes",
  "futures",
@@ -16371,7 +16333,7 @@ source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "ea61de684c3ea68cb082b7a88508a8b27fcc8b797d738bfc99a82facf1d752dc"
 dependencies = [
  "anyhow",
- "heck 0.5.0",
+ "heck",
  "wit-parser",
 ]
 
@@ -16382,7 +16344,7 @@ source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "b7c566e0f4b284dd6561c786d9cb0142da491f46a9fbed79ea69cdad5db17f21"
 dependencies = [
  "anyhow",
- "heck 0.5.0",
+ "heck",
  "indexmap 2.14.0",
  "prettyplease",
  "syn 2.0.117",
@@ -16550,18 +16512,18 @@ dependencies = [
 
 [[package]]
 name = "zerocopy"
-version = "0.8.48"
+version = "0.8.50"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "eed437bf9d6692032087e337407a86f04cd8d6a16a37199ed57949d415bd68e9"
+checksum = "3b065d4f0e55f82fae73202e189638116a87c55ab6b8e6c2721e13dd9d854ad1"
 dependencies = [
  "zerocopy-derive",
 ]
 
 [[package]]
 name = "zerocopy-derive"
-version = "0.8.48"
+version = "0.8.50"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "70e3cd084b1788766f53af483dd21f93881ff30d7320490ec3ef7526d203bad4"
+checksum = "0b631b19d36a892ab55420c92dbc83ccd79274f25be714855d3074aa71cab639"
 dependencies = [
  "proc-macro2",
  "quote",
diff --git a/backend/Cargo.toml b/backend/Cargo.toml
index e296f9fb6a..32ae3ce1fc 100644
--- a/backend/Cargo.toml
+++ b/backend/Cargo.toml
@@ -1,6 +1,6 @@
 [package]
 name = "windmill"
-version = "1.711.0"
+version = "1.714.0"
 authors.workspace = true
 edition.workspace = true
 
@@ -87,7 +87,7 @@ members = [
 exclude = ["./windmill-duckdb-ffi-internal", "./parsers/windmill-parser-wasm"]
 
 [workspace.package]
-version = "1.711.0"
+version = "1.714.0"
 authors = ["Ruben Fiszel <ruben@windmill.dev>"]
 edition = "2021"
 
diff --git a/backend/ee-repo-ref.txt b/backend/ee-repo-ref.txt
index 3c4cbb02ae..4e1f516570 100644
--- a/backend/ee-repo-ref.txt
+++ b/backend/ee-repo-ref.txt
@@ -1 +1 @@
-327d23f7438968a21bac9fd42e7f6f027c61477c
+3742e0659c5e97aab03b9efeea14cd94a3ac658a
diff --git a/backend/oauth_connect.json b/backend/oauth_connect.json
index c9693b2311..36f565fc2b 100644
--- a/backend/oauth_connect.json
+++ b/backend/oauth_connect.json
@@ -176,6 +176,23 @@
     "token_url": "https://account.docusign.com/oauth/token",
     "scopes": [
       "signature"
-    ]
+    ],
+    "sandbox": {
+      "auth_url": "https://account-d.docusign.com/oauth/auth",
+      "token_url": "https://account-d.docusign.com/oauth/token"
+    }
+  },
+  "salesforce": {
+    "auth_url": "https://login.salesforce.com/services/oauth2/authorize",
+    "token_url": "https://login.salesforce.com/services/oauth2/token",
+    "scopes": [
+      "api",
+      "refresh_token",
+      "offline_access"
+    ],
+    "sandbox": {
+      "auth_url": "https://test.salesforce.com/services/oauth2/authorize",
+      "token_url": "https://test.salesforce.com/services/oauth2/token"
+    }
   }
 }
diff --git a/backend/parsers/windmill-parser-wasm/Cargo.lock b/backend/parsers/windmill-parser-wasm/Cargo.lock
index f06ab454a3..aa0b618798 100644
--- a/backend/parsers/windmill-parser-wasm/Cargo.lock
+++ b/backend/parsers/windmill-parser-wasm/Cargo.lock
@@ -6183,7 +6183,7 @@ checksum = "712e227841d057c1ee1cd2fb22fa7e5a5461ae8e48fa2ca79ec42cfc1931183f"
 
 [[package]]
 name = "windmill-common"
-version = "1.711.0"
+version = "1.714.0"
 dependencies = [
  "aho-corasick",
  "anyhow",
@@ -6263,7 +6263,7 @@ dependencies = [
 
 [[package]]
 name = "windmill-macros"
-version = "1.711.0"
+version = "1.714.0"
 dependencies = [
  "proc-macro2",
  "quote",
@@ -6275,7 +6275,7 @@ dependencies = [
 
 [[package]]
 name = "windmill-parser"
-version = "1.711.0"
+version = "1.714.0"
 dependencies = [
  "convert_case",
  "serde",
@@ -6284,7 +6284,7 @@ dependencies = [
 
 [[package]]
 name = "windmill-parser-bash"
-version = "1.711.0"
+version = "1.714.0"
 dependencies = [
  "anyhow",
  "lazy_static",
@@ -6296,7 +6296,7 @@ dependencies = [
 
 [[package]]
 name = "windmill-parser-csharp"
-version = "1.711.0"
+version = "1.714.0"
 dependencies = [
  "anyhow",
  "serde_json",
@@ -6308,7 +6308,7 @@ dependencies = [
 
 [[package]]
 name = "windmill-parser-go"
-version = "1.711.0"
+version = "1.714.0"
 dependencies = [
  "anyhow",
  "gosyn",
@@ -6320,7 +6320,7 @@ dependencies = [
 
 [[package]]
 name = "windmill-parser-graphql"
-version = "1.711.0"
+version = "1.714.0"
 dependencies = [
  "anyhow",
  "lazy_static",
@@ -6332,7 +6332,7 @@ dependencies = [
 
 [[package]]
 name = "windmill-parser-java"
-version = "1.711.0"
+version = "1.714.0"
 dependencies = [
  "anyhow",
  "serde_json",
@@ -6344,7 +6344,7 @@ dependencies = [
 
 [[package]]
 name = "windmill-parser-nu"
-version = "1.711.0"
+version = "1.714.0"
 dependencies = [
  "anyhow",
  "nu-parser",
@@ -6355,7 +6355,7 @@ dependencies = [
 
 [[package]]
 name = "windmill-parser-php"
-version = "1.711.0"
+version = "1.714.0"
 dependencies = [
  "anyhow",
  "itertools 0.14.0",
@@ -6366,7 +6366,7 @@ dependencies = [
 
 [[package]]
 name = "windmill-parser-py"
-version = "1.711.0"
+version = "1.714.0"
 dependencies = [
  "anyhow",
  "itertools 0.14.0",
@@ -6378,7 +6378,7 @@ dependencies = [
 
 [[package]]
 name = "windmill-parser-py-asset"
-version = "1.711.0"
+version = "1.714.0"
 dependencies = [
  "anyhow",
  "rustpython-ast",
@@ -6389,7 +6389,7 @@ dependencies = [
 
 [[package]]
 name = "windmill-parser-py-imports"
-version = "1.711.0"
+version = "1.714.0"
 dependencies = [
  "anyhow",
  "async-recursion",
@@ -6411,7 +6411,7 @@ dependencies = [
 
 [[package]]
 name = "windmill-parser-r"
-version = "1.711.0"
+version = "1.714.0"
 dependencies = [
  "anyhow",
  "serde_json",
@@ -6423,7 +6423,7 @@ dependencies = [
 
 [[package]]
 name = "windmill-parser-ruby"
-version = "1.711.0"
+version = "1.714.0"
 dependencies = [
  "anyhow",
  "lazy_static",
@@ -6437,7 +6437,7 @@ dependencies = [
 
 [[package]]
 name = "windmill-parser-rust"
-version = "1.711.0"
+version = "1.714.0"
 dependencies = [
  "anyhow",
  "convert_case",
@@ -6454,7 +6454,7 @@ dependencies = [
 
 [[package]]
 name = "windmill-parser-sql"
-version = "1.711.0"
+version = "1.714.0"
 dependencies = [
  "anyhow",
  "lazy_static",
@@ -6467,7 +6467,7 @@ dependencies = [
 
 [[package]]
 name = "windmill-parser-sql-asset"
-version = "1.711.0"
+version = "1.714.0"
 dependencies = [
  "anyhow",
  "serde",
@@ -6479,7 +6479,7 @@ dependencies = [
 
 [[package]]
 name = "windmill-parser-ts"
-version = "1.711.0"
+version = "1.714.0"
 dependencies = [
  "anyhow",
  "lazy_static",
@@ -6497,7 +6497,7 @@ dependencies = [
 
 [[package]]
 name = "windmill-parser-ts-asset"
-version = "1.711.0"
+version = "1.714.0"
 dependencies = [
  "anyhow",
  "serde-wasm-bindgen",
@@ -6513,7 +6513,7 @@ dependencies = [
 
 [[package]]
 name = "windmill-parser-wac"
-version = "1.711.0"
+version = "1.714.0"
 dependencies = [
  "anyhow",
  "rustpython-ast",
@@ -6529,7 +6529,7 @@ dependencies = [
 
 [[package]]
 name = "windmill-parser-wasm"
-version = "1.711.0"
+version = "1.714.0"
 dependencies = [
  "anyhow",
  "getrandom 0.2.17",
@@ -6561,7 +6561,7 @@ dependencies = [
 
 [[package]]
 name = "windmill-parser-yaml"
-version = "1.711.0"
+version = "1.714.0"
 dependencies = [
  "anyhow",
  "serde",
@@ -6572,7 +6572,7 @@ dependencies = [
 
 [[package]]
 name = "windmill-types"
-version = "1.711.0"
+version = "1.714.0"
 dependencies = [
  "anyhow",
  "bitflags",
diff --git a/backend/parsers/windmill-parser-wasm/Cargo.toml b/backend/parsers/windmill-parser-wasm/Cargo.toml
index f49ea30ecd..ec9a764a03 100644
--- a/backend/parsers/windmill-parser-wasm/Cargo.toml
+++ b/backend/parsers/windmill-parser-wasm/Cargo.toml
@@ -12,7 +12,7 @@ resolver = "2"
 members = ["."]
 
 [workspace.package]
-version = "1.711.0"
+version = "1.714.0"
 edition = "2021"
 authors = ["Ruben Fiszel <ruben@windmill.dev>"]
 
diff --git a/backend/src/main.rs b/backend/src/main.rs
index 87285e2ae1..29bea050ed 100644
--- a/backend/src/main.rs
+++ b/backend/src/main.rs
@@ -258,6 +258,15 @@ pub fn main() -> anyhow::Result<()> {
 }
 
 async fn cache_hub_scripts(file_path: Option<String>) -> anyhow::Result<()> {
+    // The `cache` CLI mode never connects to the DB, so HUB_BASE_URL keeps its
+    // compiled default. Allow overriding it via env so the prebuild cache step can
+    // be pointed at a private/staging hub (e.g. a local proxy for testing).
+    if let Ok(hub_base_url) = std::env::var("HUB_BASE_URL") {
+        if !hub_base_url.is_empty() {
+            tracing::info!("Overriding hub base url from env: {hub_base_url}");
+            windmill_common::HUB_BASE_URL.store(std::sync::Arc::new(hub_base_url));
+        }
+    }
     let file_path = file_path.unwrap_or("./hubPaths.json".to_string());
     let mut file = File::open(&file_path)
         .await
@@ -567,6 +576,7 @@ fn print_help() {
     println!("  RUN_UPDATE_CA_CERTIFICATE_AT_START = false  Run system CA update at startup");
     println!("  RUN_UPDATE_CA_CERTIFICATE_PATH = /usr/sbin/update-ca-certificates  Path to CA update tool");
     println!("  SYNC_CACHED_RT = false                 Sync cached resource types to admins workspace on server start");
+    println!("  HUB_BASE_URL = https://hub.windmill.dev  Hub to fetch scripts from in `cache` mode (server/worker use the DB setting instead)");
     println!();
     println!("Notes:");
     println!("- Advanced and less commonly used settings are managed via the database and are omitted here.");
diff --git a/backend/tests/dependency_map.rs b/backend/tests/dependency_map.rs
index d6d49c8d85..48a50ef9b9 100644
--- a/backend/tests/dependency_map.rs
+++ b/backend/tests/dependency_map.rs
@@ -451,6 +451,7 @@ def main():
                 preserve_on_behalf_of: None,
                 ws_error_handler_muted: None,
                 labels: None,
+                skip_draft_deletion: None,
             })
             .send()
             .await
@@ -513,6 +514,7 @@ def main():
                 custom_path: None,
                 preserve_on_behalf_of: None,
                 labels: None,
+                skip_draft_deletion: None,
             })
             .send()
             .await
diff --git a/backend/windmill-ai/src/ai_bedrock.rs b/backend/windmill-ai/src/ai_bedrock.rs
index c05094b8f4..e549e63041 100644
--- a/backend/windmill-ai/src/ai_bedrock.rs
+++ b/backend/windmill-ai/src/ai_bedrock.rs
@@ -754,6 +754,26 @@ pub fn bedrock_stream_event_to_tool_start(
     }
 }
 
+pub fn bedrock_stream_event_to_tool_start_with_block_index(
+    event: &ConverseStreamOutput,
+) -> Option<(usize, StreamingToolCall)> {
+    match event {
+        ConverseStreamOutput::ContentBlockStart(start) => {
+            let block_index = usize::try_from(start.content_block_index()).ok()?;
+            let tool_use = start.start().and_then(|s| s.as_tool_use().ok())?;
+            Some((
+                block_index,
+                StreamingToolCall {
+                    id: tool_use.tool_use_id().to_string(),
+                    name: tool_use.name().to_string(),
+                    arguments: String::new(),
+                },
+            ))
+        }
+        _ => None,
+    }
+}
+
 /// Extract tool use input delta from stream
 pub fn bedrock_stream_event_to_tool_delta(event: &ConverseStreamOutput) -> Option<String> {
     match event {
@@ -765,6 +785,22 @@ pub fn bedrock_stream_event_to_tool_delta(event: &ConverseStreamOutput) -> Optio
     }
 }
 
+pub fn bedrock_stream_event_to_tool_delta_with_block_index(
+    event: &ConverseStreamOutput,
+) -> Option<(usize, String)> {
+    match event {
+        ConverseStreamOutput::ContentBlockDelta(delta) => {
+            let block_index = usize::try_from(delta.content_block_index()).ok()?;
+            let input = delta
+                .delta()
+                .and_then(|d| d.as_tool_use().ok())
+                .map(|tool_use| tool_use.input().to_string())?;
+            Some((block_index, input))
+        }
+        _ => None,
+    }
+}
+
 /// Check if stream event indicates content block stop
 pub fn bedrock_stream_event_is_block_stop(event: &ConverseStreamOutput) -> bool {
     matches!(event, ConverseStreamOutput::ContentBlockStop(_))
diff --git a/backend/windmill-ai/src/ai_providers.rs b/backend/windmill-ai/src/ai_providers.rs
index b568c0accb..52d04910de 100644
--- a/backend/windmill-ai/src/ai_providers.rs
+++ b/backend/windmill-ai/src/ai_providers.rs
@@ -20,13 +20,14 @@ where
 
 lazy_static::lazy_static! {
     static ref OPENAI_AZURE_BASE_PATH: Option<String> = std::env::var("OPENAI_AZURE_BASE_PATH").ok();
-    static ref ALLOW_PRIVATE_AI_BASE_URLS: bool = std::env::var("ALLOW_PRIVATE_AI_BASE_URLS")
+    pub static ref ALLOW_PRIVATE_AI_BASE_URLS: bool = std::env::var("ALLOW_PRIVATE_AI_BASE_URLS")
         .ok()
         .map(|v| v == "true" || v == "1")
         .unwrap_or(false);
 }
 
 pub const OPENAI_BASE_URL: &str = "https://api.openai.com/v1";
+pub const DEEPSEEK_BASE_URL: &str = "https://api.deepseek.com/v1";
 pub const GOOGLE_AI_BASE_URL: &str = "https://generativelanguage.googleapis.com/v1beta";
 
 /// Empty string signals BedrockClient::from_env() to use the region from AWS environment/config
@@ -106,7 +107,7 @@ impl AIProvider {
 
                 Ok(azure_base_path.unwrap_or("https://api.openai.com/v1".to_string()))
             }
-            AIProvider::DeepSeek => Ok("https://api.deepseek.com/v1".to_string()),
+            AIProvider::DeepSeek => Ok(DEEPSEEK_BASE_URL.to_string()),
             AIProvider::GoogleAI => Ok(GOOGLE_AI_BASE_URL.to_string()),
             AIProvider::Groq => Ok("https://api.groq.com/openai/v1".to_string()),
             AIProvider::OpenRouter => Ok("https://openrouter.ai/api/v1".to_string()),
diff --git a/backend/windmill-ai/src/credentials.rs b/backend/windmill-ai/src/credentials.rs
new file mode 100644
index 0000000000..75d523cf25
--- /dev/null
+++ b/backend/windmill-ai/src/credentials.rs
@@ -0,0 +1,25 @@
+use std::collections::HashMap;
+
+use crate::ai_providers::{AIPlatform, AIProvider};
+
+/// Resolved provider credentials shared by API proxy and worker execution.
+///
+/// Raw API resources and worker agent payloads convert into this shape at their
+/// execution boundaries. Request-specific state such as the selected model stays
+/// outside this type.
+#[derive(Clone, Debug)]
+pub struct ProviderCredentials {
+    pub provider: AIProvider,
+    pub base_url: String,
+    pub api_key: Option<String>,
+    pub access_token: Option<String>,
+    pub organization_id: Option<String>,
+    pub user: Option<String>,
+    pub region: Option<String>,
+    pub aws_access_key_id: Option<String>,
+    pub aws_secret_access_key: Option<String>,
+    pub aws_session_token: Option<String>,
+    pub platform: AIPlatform,
+    pub enable_1m_context: bool,
+    pub custom_headers: HashMap<String, String>,
+}
diff --git a/backend/windmill-ai/src/lib.rs b/backend/windmill-ai/src/lib.rs
index a138d72f3c..b6487c0ac5 100644
--- a/backend/windmill-ai/src/lib.rs
+++ b/backend/windmill-ai/src/lib.rs
@@ -4,6 +4,7 @@ pub mod ai_cache;
 pub mod ai_google;
 pub mod ai_providers;
 pub mod ai_types;
+pub mod credentials;
 pub mod image_handler;
 pub mod providers;
 pub mod proxy;
diff --git a/backend/windmill-ai/src/providers/anthropic.rs b/backend/windmill-ai/src/providers/anthropic.rs
index 8a8a2b846d..17a27e370f 100644
--- a/backend/windmill-ai/src/providers/anthropic.rs
+++ b/backend/windmill-ai/src/providers/anthropic.rs
@@ -729,8 +729,7 @@ impl QueryBuilder for AnthropicQueryBuilder {
 mod tests {
     use super::*;
     use crate::{
-        proxy::{ProviderCredentials, ProxyBuildArgs},
-        query_builder::QueryBuilder,
+        credentials::ProviderCredentials, proxy::ProxyBuildArgs, query_builder::QueryBuilder,
     };
     use http::{HeaderMap, HeaderValue, Method};
     use std::collections::HashMap;
diff --git a/backend/windmill-ai/src/providers/bedrock.rs b/backend/windmill-ai/src/providers/bedrock.rs
index ec6f4fbcd3..0eef359c36 100644
--- a/backend/windmill-ai/src/providers/bedrock.rs
+++ b/backend/windmill-ai/src/providers/bedrock.rs
@@ -10,9 +10,10 @@ use crate::{
     ai_bedrock::{
         bedrock_model_supports_prompt_caching, bedrock_stream_event_is_block_stop,
         bedrock_stream_event_to_text, bedrock_stream_event_to_tool_delta,
-        bedrock_stream_event_to_tool_start, build_tool_config, create_inference_config,
-        format_bedrock_error, openai_messages_to_bedrock, streaming_tool_calls_to_openai,
-        BearerTokenProvider, BedrockClient, StreamingToolCall,
+        bedrock_stream_event_to_tool_delta_with_block_index, bedrock_stream_event_to_tool_start,
+        bedrock_stream_event_to_tool_start_with_block_index, build_tool_config,
+        create_inference_config, format_bedrock_error, openai_messages_to_bedrock,
+        streaming_tool_calls_to_openai, BearerTokenProvider, BedrockClient, StreamingToolCall,
     },
     ai_providers::USE_ENV_REGION,
     ai_types::{OpenAIFunction, OpenAIToolCall, ToolDefFunction},
@@ -403,137 +404,15 @@ pub fn sdk_stream_to_sse(
         .unwrap()
         .as_secs();
 
-    struct StreamState {
-        id: String,
-        model: String,
-        created: u64,
-        tool_calls: HashMap<usize, (String, String, String)>,
-        current_tool_index: usize,
-    }
-
-    let state = std::sync::Arc::new(tokio::sync::Mutex::new(StreamState {
-        id,
-        model,
-        created,
-        tool_calls: HashMap::new(),
-        current_tool_index: 0,
-    }));
-
     async_stream::stream! {
         let mut stream = stream;
-        let state = state.clone();
+        let mut state = BedrockSseStreamState::new(id, model, created);
 
         loop {
             match stream.recv().await {
                 Ok(Some(event)) => {
-                    let mut state = state.lock().await;
-
-                    if let Some(tool_call) = bedrock_stream_event_to_tool_start(&event) {
-                        let index = state.current_tool_index;
-                        state.tool_calls.insert(
-                            index,
-                            (tool_call.id.clone(), tool_call.name.clone(), String::new()),
-                        );
-
-                        let chunk = serde_json::json!({
-                            "id": state.id,
-                            "object": "chat.completion.chunk",
-                            "created": state.created,
-                            "model": state.model,
-                            "choices": [{
-                                "index": 0,
-                                "delta": {
-                                    "tool_calls": [{
-                                        "index": index,
-                                        "id": tool_call.id,
-                                        "type": "function",
-                                        "function": {
-                                            "name": tool_call.name,
-                                            "arguments": ""
-                                        }
-                                    }]
-                                },
-                                "finish_reason": serde_json::Value::Null
-                            }]
-                        });
-
-                        yield Ok(Bytes::from(format!("data: {}\n\n", chunk)));
-                    }
-
-                    if let Some(text) = bedrock_stream_event_to_text(&event) {
-                        let chunk = serde_json::json!({
-                            "id": state.id,
-                            "object": "chat.completion.chunk",
-                            "created": state.created,
-                            "model": state.model,
-                            "choices": [{
-                                "index": 0,
-                                "delta": {
-                                    "content": text
-                                },
-                                "finish_reason": serde_json::Value::Null
-                            }]
-                        });
-
-                        yield Ok(Bytes::from(format!("data: {}\n\n", chunk)));
-                    }
-
-                    if let Some(input_delta) = bedrock_stream_event_to_tool_delta(&event) {
-                        let index = state.current_tool_index;
-                        if let Some((_id, _name, ref mut args)) = state.tool_calls.get_mut(&index) {
-                            args.push_str(&input_delta);
-
-                            let chunk = serde_json::json!({
-                                "id": state.id,
-                                "object": "chat.completion.chunk",
-                                "created": state.created,
-                                "model": state.model,
-                                "choices": [{
-                                    "index": 0,
-                                    "delta": {
-                                        "tool_calls": [{
-                                            "index": index,
-                                            "function": {
-                                                "arguments": input_delta
-                                            }
-                                        }]
-                                    },
-                                    "finish_reason": serde_json::Value::Null
-                                }]
-                            });
-
-                            yield Ok(Bytes::from(format!("data: {}\n\n", chunk)));
-                        }
-                    }
-
-                    if bedrock_stream_event_is_block_stop(&event) {
-                        state.current_tool_index += 1;
-                    }
-
-                    if let aws_sdk_bedrockruntime::types::ConverseStreamOutput::MessageStop(stop) = &event {
-                        let stop_reason = stop.stop_reason().as_str();
-                        let finish_reason = match stop_reason {
-                            "end_turn" => "stop",
-                            "max_tokens" => "length",
-                            "tool_use" => "tool_calls",
-                            "stop_sequence" => "stop",
-                            "guardrail_intervened" | "content_filtered" => "content_filter",
-                            _ => "stop",
-                        };
-
-                        let chunk = serde_json::json!({
-                            "id": state.id,
-                            "object": "chat.completion.chunk",
-                            "created": state.created,
-                            "model": state.model,
-                            "choices": [{
-                                "index": 0,
-                                "delta": {},
-                                "finish_reason": finish_reason
-                            }]
-                        });
-
-                        yield Ok(Bytes::from(format!("data: {}\n\n", chunk)));
+                    for chunk in bedrock_sse_chunks_for_event(&event, &mut state) {
+                        yield Ok(chunk);
                     }
                 }
                 Ok(None) => break,
@@ -551,6 +430,149 @@ pub fn sdk_stream_to_sse(
     }
 }
 
+#[derive(Debug)]
+struct BedrockSseStreamState {
+    id: String,
+    model: String,
+    created: u64,
+    tool_calls: HashMap<usize, (String, String, String)>,
+    tool_block_indexes: HashMap<usize, usize>,
+    next_tool_index: usize,
+}
+
+impl BedrockSseStreamState {
+    fn new(id: String, model: String, created: u64) -> Self {
+        Self {
+            id,
+            model,
+            created,
+            tool_calls: HashMap::new(),
+            tool_block_indexes: HashMap::new(),
+            next_tool_index: 0,
+        }
+    }
+}
+
+fn bedrock_sse_chunks_for_event(
+    event: &aws_sdk_bedrockruntime::types::ConverseStreamOutput,
+    state: &mut BedrockSseStreamState,
+) -> Vec<Bytes> {
+    let mut chunks = Vec::new();
+
+    if let Some((block_index, tool_call)) =
+        bedrock_stream_event_to_tool_start_with_block_index(event)
+    {
+        let index = state.next_tool_index;
+        state.next_tool_index += 1;
+        state.tool_block_indexes.insert(block_index, index);
+        state.tool_calls.insert(
+            index,
+            (tool_call.id.clone(), tool_call.name.clone(), String::new()),
+        );
+
+        let chunk = serde_json::json!({
+            "id": state.id,
+            "object": "chat.completion.chunk",
+            "created": state.created,
+            "model": state.model,
+            "choices": [{
+                "index": 0,
+                "delta": {
+                    "tool_calls": [{
+                        "index": index,
+                        "id": tool_call.id,
+                        "type": "function",
+                        "function": {
+                            "name": tool_call.name,
+                            "arguments": ""
+                        }
+                    }]
+                },
+                "finish_reason": serde_json::Value::Null
+            }]
+        });
+
+        chunks.push(Bytes::from(format!("data: {}\n\n", chunk)));
+    }
+
+    if let Some(text) = bedrock_stream_event_to_text(event) {
+        let chunk = serde_json::json!({
+            "id": state.id,
+            "object": "chat.completion.chunk",
+            "created": state.created,
+            "model": state.model,
+            "choices": [{
+                "index": 0,
+                "delta": {
+                    "content": text
+                },
+                "finish_reason": serde_json::Value::Null
+            }]
+        });
+
+        chunks.push(Bytes::from(format!("data: {}\n\n", chunk)));
+    }
+
+    if let Some((block_index, input_delta)) =
+        bedrock_stream_event_to_tool_delta_with_block_index(event)
+    {
+        if let Some(index) = state.tool_block_indexes.get(&block_index).copied() {
+            if let Some((_id, _name, ref mut args)) = state.tool_calls.get_mut(&index) {
+                args.push_str(&input_delta);
+
+                let chunk = serde_json::json!({
+                    "id": state.id,
+                    "object": "chat.completion.chunk",
+                    "created": state.created,
+                    "model": state.model,
+                    "choices": [{
+                        "index": 0,
+                        "delta": {
+                            "tool_calls": [{
+                                "index": index,
+                                "function": {
+                                    "arguments": input_delta
+                                }
+                            }]
+                        },
+                        "finish_reason": serde_json::Value::Null
+                    }]
+                });
+
+                chunks.push(Bytes::from(format!("data: {}\n\n", chunk)));
+            }
+        }
+    }
+
+    if let aws_sdk_bedrockruntime::types::ConverseStreamOutput::MessageStop(stop) = event {
+        let stop_reason = stop.stop_reason().as_str();
+        let finish_reason = match stop_reason {
+            "end_turn" => "stop",
+            "max_tokens" => "length",
+            "tool_use" => "tool_calls",
+            "stop_sequence" => "stop",
+            "guardrail_intervened" | "content_filtered" => "content_filter",
+            _ => "stop",
+        };
+
+        let chunk = serde_json::json!({
+            "id": state.id,
+            "object": "chat.completion.chunk",
+            "created": state.created,
+            "model": state.model,
+            "choices": [{
+                "index": 0,
+                "delta": {},
+                "finish_reason": finish_reason
+            }]
+        });
+
+        chunks.push(Bytes::from(format!("data: {}\n\n", chunk)));
+    }
+
+    chunks
+}
+
 async fn handle_bedrock_sdk_non_streaming(
     model: &str,
     body: &[u8],
@@ -970,6 +992,19 @@ impl BedrockQueryBuilder {
 #[cfg(test)]
 mod tests {
     use super::*;
+    use aws_sdk_bedrockruntime::types::{
+        ContentBlockDelta, ContentBlockDeltaEvent, ContentBlockStart, ContentBlockStartEvent,
+        ContentBlockStopEvent, ConverseStreamOutput, ToolUseBlockDelta, ToolUseBlockStart,
+    };
+
+    fn sse_json(chunk: &Bytes) -> serde_json::Value {
+        let chunk = std::str::from_utf8(chunk).expect("SSE chunk should be UTF-8");
+        let payload = chunk
+            .strip_prefix("data: ")
+            .and_then(|chunk| chunk.strip_suffix("\n\n"))
+            .expect("chunk should be SSE data");
+        serde_json::from_str(payload).expect("chunk should contain JSON")
+    }
 
     #[test]
     fn determine_auth_config_prioritizes_bearer_token() {
@@ -1022,4 +1057,69 @@ mod tests {
         let config = determine_auth_config(None, Some("AKIA123"), None, Some("session-token"));
         assert!(matches!(config, BedrockAuthConfig::Environment));
     }
+
+    #[test]
+    fn bedrock_sse_tool_indexes_ignore_text_block_stops() {
+        let mut state =
+            BedrockSseStreamState::new("chatcmpl-test".to_string(), "model".to_string(), 1);
+
+        let text_delta = ConverseStreamOutput::ContentBlockDelta(
+            ContentBlockDeltaEvent::builder()
+                .content_block_index(0)
+                .delta(ContentBlockDelta::Text("hello".to_string()))
+                .build()
+                .unwrap(),
+        );
+        assert_eq!(
+            bedrock_sse_chunks_for_event(&text_delta, &mut state).len(),
+            1
+        );
+
+        let text_stop = ConverseStreamOutput::ContentBlockStop(
+            ContentBlockStopEvent::builder()
+                .content_block_index(0)
+                .build()
+                .unwrap(),
+        );
+        assert!(bedrock_sse_chunks_for_event(&text_stop, &mut state).is_empty());
+
+        let tool_start = ConverseStreamOutput::ContentBlockStart(
+            ContentBlockStartEvent::builder()
+                .content_block_index(1)
+                .start(ContentBlockStart::ToolUse(
+                    ToolUseBlockStart::builder()
+                        .tool_use_id("call_1")
+                        .name("lookup")
+                        .build()
+                        .unwrap(),
+                ))
+                .build()
+                .unwrap(),
+        );
+        let start_chunks = bedrock_sse_chunks_for_event(&tool_start, &mut state);
+        let start_json = sse_json(&start_chunks[0]);
+        assert_eq!(
+            start_json["choices"][0]["delta"]["tool_calls"][0]["index"],
+            0
+        );
+
+        let tool_delta = ConverseStreamOutput::ContentBlockDelta(
+            ContentBlockDeltaEvent::builder()
+                .content_block_index(1)
+                .delta(ContentBlockDelta::ToolUse(
+                    ToolUseBlockDelta::builder()
+                        .input("{\"city\":\"Paris\"}")
+                        .build()
+                        .unwrap(),
+                ))
+                .build()
+                .unwrap(),
+        );
+        let delta_chunks = bedrock_sse_chunks_for_event(&tool_delta, &mut state);
+        let delta_json = sse_json(&delta_chunks[0]);
+        assert_eq!(
+            delta_json["choices"][0]["delta"]["tool_calls"][0]["index"],
+            0
+        );
+    }
 }
diff --git a/backend/windmill-ai/src/providers/google_ai.rs b/backend/windmill-ai/src/providers/google_ai.rs
index 57abae5182..cf00ddc142 100644
--- a/backend/windmill-ai/src/providers/google_ai.rs
+++ b/backend/windmill-ai/src/providers/google_ai.rs
@@ -691,7 +691,7 @@ impl QueryBuilder for GoogleAIQueryBuilder {
 #[cfg(test)]
 mod tests {
     use super::*;
-    use crate::{ai_providers::AIProvider, proxy::ProviderCredentials};
+    use crate::{ai_providers::AIProvider, credentials::ProviderCredentials};
     use std::collections::HashMap;
 
     fn credentials(base_url: &str, platform: AIPlatform) -> ProviderCredentials {
diff --git a/backend/windmill-ai/src/providers/mod.rs b/backend/windmill-ai/src/providers/mod.rs
index f3f4a37478..fb50707221 100644
--- a/backend/windmill-ai/src/providers/mod.rs
+++ b/backend/windmill-ai/src/providers/mod.rs
@@ -6,7 +6,9 @@ pub mod openai;
 pub mod openrouter;
 pub mod other;
 
-use crate::{ai_providers::AIProvider, proxy::ProviderCredentials, query_builder::QueryBuilder};
+use crate::{
+    ai_providers::AIProvider, credentials::ProviderCredentials, query_builder::QueryBuilder,
+};
 
 use self::{
     anthropic::AnthropicQueryBuilder, google_ai::GoogleAIQueryBuilder, openai::OpenAIQueryBuilder,
diff --git a/backend/windmill-ai/src/proxy.rs b/backend/windmill-ai/src/proxy.rs
index 2600999e1c..32ba35cd6d 100644
--- a/backend/windmill-ai/src/proxy.rs
+++ b/backend/windmill-ai/src/proxy.rs
@@ -4,30 +4,11 @@ use http::{HeaderMap, Method};
 use serde_json::value::RawValue;
 use windmill_common::error::{Error, Result};
 
-use crate::ai_providers::{AIPlatform, AIProvider};
+use crate::ai_providers::AIProvider;
+use crate::credentials::ProviderCredentials;
 use crate::utils::AI_HTTP_HEADERS;
 
-/// Resolved provider credentials shared by API proxy and worker execution.
-///
-/// Raw API resources and worker agent payloads convert into this shape at their
-/// execution boundaries. Request-specific state such as the selected model stays
-/// outside this type.
-#[derive(Clone, Debug)]
-pub struct ProviderCredentials {
-    pub provider: AIProvider,
-    pub base_url: String,
-    pub api_key: Option<String>,
-    pub access_token: Option<String>,
-    pub organization_id: Option<String>,
-    pub user: Option<String>,
-    pub region: Option<String>,
-    pub aws_access_key_id: Option<String>,
-    pub aws_secret_access_key: Option<String>,
-    pub aws_session_token: Option<String>,
-    pub platform: AIPlatform,
-    pub enable_1m_context: bool,
-    pub custom_headers: HashMap<String, String>,
-}
+pub mod fim;
 
 /// Inputs needed to transform an OpenAI-compatible proxy request for a provider.
 pub struct ProxyBuildArgs<'a> {
@@ -167,6 +148,9 @@ pub(crate) fn add_user_to_body(body: &[u8], user: &str) -> Result<Vec<u8>> {
 #[cfg(test)]
 mod tests {
     use super::*;
+    use std::collections::HashMap;
+
+    use crate::ai_providers::AIPlatform;
 
     fn credentials(provider: AIProvider, base_url: &str) -> ProviderCredentials {
         ProviderCredentials {
diff --git a/backend/windmill-ai/src/proxy/fim.rs b/backend/windmill-ai/src/proxy/fim.rs
new file mode 100644
index 0000000000..3645476441
--- /dev/null
+++ b/backend/windmill-ai/src/proxy/fim.rs
@@ -0,0 +1,212 @@
+use bytes::Bytes;
+use serde::Deserialize;
+use serde_json::json;
+use windmill_common::error::{Error, Result};
+
+use crate::ai_providers::{AIProvider, DEEPSEEK_BASE_URL};
+
+#[derive(Debug, Eq, PartialEq)]
+pub struct FimProxyTransform {
+    pub body: Bytes,
+    pub path: String,
+    pub base_url: Option<String>,
+}
+
+#[derive(Deserialize)]
+struct FimRequest {
+    model: String,
+    prompt: String,
+    suffix: Option<String>,
+    temperature: Option<f32>,
+    max_tokens: Option<u32>,
+    stop: Option<Vec<String>>,
+}
+
+pub fn supports_native_fim(provider: &AIProvider) -> bool {
+    matches!(provider, AIProvider::Mistral | AIProvider::DeepSeek)
+}
+
+fn deepseek_fim_base_url(base_url: &str) -> String {
+    let trimmed = base_url.trim_end_matches('/');
+    let deepseek_root_base_url = DEEPSEEK_BASE_URL
+        .strip_suffix("/v1")
+        .unwrap_or(DEEPSEEK_BASE_URL);
+
+    if trimmed == DEEPSEEK_BASE_URL || trimmed == deepseek_root_base_url {
+        return format!("{deepseek_root_base_url}/beta");
+    }
+
+    if let Some(prefix) = trimmed.strip_suffix("/v1") {
+        return format!("{prefix}/beta");
+    }
+
+    trimmed.to_string()
+}
+
+pub fn maybe_transform_fim_request(
+    provider: &AIProvider,
+    path: &str,
+    base_url: &str,
+    body: &[u8],
+) -> Result<Option<FimProxyTransform>> {
+    if !path.contains("fim/completions") {
+        return Ok(None);
+    }
+
+    if matches!(provider, AIProvider::DeepSeek) {
+        return Ok(Some(FimProxyTransform {
+            body: Bytes::copy_from_slice(body),
+            path: "completions".to_string(),
+            base_url: Some(deepseek_fim_base_url(base_url)),
+        }));
+    }
+
+    if !supports_native_fim(provider) {
+        return transform_fim_to_chat_completions(body).map(Some);
+    }
+
+    Ok(None)
+}
+
+fn transform_fim_to_chat_completions(body: &[u8]) -> Result<FimProxyTransform> {
+    let fim_req: FimRequest = serde_json::from_slice(body)
+        .map_err(|e| Error::BadRequest(format!("Failed to parse FIM request: {}", e)))?;
+
+    let suffix = fim_req.suffix.unwrap_or_default();
+
+    let system_prompt = "You are a code completion assistant. Complete the code at the <CURSOR/> position between the given prefix and suffix. Output ONLY the code that goes at the cursor - no explanations, no markdown, no repeating the prefix or suffix.";
+
+    let user_content = format!(
+        "<PREFIX>\n{}\n<CURSOR/>\n<SUFFIX>\n{}",
+        fim_req.prompt, suffix
+    );
+
+    let chat_req = json!({
+        "model": fim_req.model,
+        "messages": [
+            {"role": "system", "content": system_prompt},
+            {"role": "user", "content": user_content}
+        ],
+        "temperature": fim_req.temperature.unwrap_or(0.0),
+        "max_tokens": fim_req.max_tokens.unwrap_or(256),
+        "stop": fim_req.stop
+    });
+
+    let body = serde_json::to_vec(&chat_req)
+        .map_err(|e| Error::internal_err(format!("Failed to serialize chat request: {}", e)))?;
+
+    Ok(FimProxyTransform {
+        body: Bytes::from(body),
+        path: "chat/completions".to_string(),
+        base_url: None,
+    })
+}
+
+#[cfg(test)]
+mod tests {
+    use super::*;
+
+    #[test]
+    fn mistral_keeps_native_fim_request() {
+        let transformed = maybe_transform_fim_request(
+            &AIProvider::Mistral,
+            "fim/completions",
+            "https://api.mistral.ai/v1",
+            br#"{}"#,
+        )
+        .unwrap();
+
+        assert!(transformed.is_none());
+        assert!(supports_native_fim(&AIProvider::Mistral));
+        assert!(supports_native_fim(&AIProvider::DeepSeek));
+        assert!(!supports_native_fim(&AIProvider::OpenAI));
+    }
+
+    #[test]
+    fn deepseek_fim_base_url_uses_beta_endpoint() {
+        assert_eq!(
+            deepseek_fim_base_url("https://api.deepseek.com/v1"),
+            "https://api.deepseek.com/beta"
+        );
+        assert_eq!(
+            deepseek_fim_base_url("https://api.deepseek.com/v1/"),
+            "https://api.deepseek.com/beta"
+        );
+        assert_eq!(
+            deepseek_fim_base_url("https://api.deepseek.com"),
+            "https://api.deepseek.com/beta"
+        );
+        assert_eq!(
+            deepseek_fim_base_url("https://proxy.example/deepseek/v1"),
+            "https://proxy.example/deepseek/beta"
+        );
+        assert_eq!(
+            deepseek_fim_base_url("https://proxy.example/deepseek/beta"),
+            "https://proxy.example/deepseek/beta"
+        );
+    }
+
+    #[test]
+    fn deepseek_fim_request_uses_beta_completions_endpoint() {
+        let body = br#"{"model":"deepseek-v4-pro","prompt":"return ","suffix":";"}"#;
+        let transformed = maybe_transform_fim_request(
+            &AIProvider::DeepSeek,
+            "fim/completions",
+            DEEPSEEK_BASE_URL,
+            body,
+        )
+        .unwrap()
+        .expect("DeepSeek FIM should be routed to the beta completions endpoint");
+
+        assert_eq!(transformed.path, "completions");
+        assert_eq!(
+            transformed.base_url.as_deref(),
+            Some("https://api.deepseek.com/beta")
+        );
+        assert_eq!(transformed.body, Bytes::copy_from_slice(body));
+    }
+
+    #[test]
+    fn openai_fim_request_is_transformed_to_chat_completion() {
+        let transformed = maybe_transform_fim_request(
+            &AIProvider::OpenAI,
+            "fim/completions",
+            "https://api.openai.com/v1",
+            br#"{
+                "model": "gpt-4.1",
+                "prompt": "fn main() {",
+                "suffix": "}",
+                "stop": ["\n\n"]
+            }"#,
+        )
+        .unwrap()
+        .expect("OpenAI FIM should be transformed");
+
+        assert_eq!(transformed.path, "chat/completions");
+        assert_eq!(transformed.base_url, None);
+
+        let body: serde_json::Value = serde_json::from_slice(&transformed.body).unwrap();
+        assert_eq!(body["model"], "gpt-4.1");
+        assert_eq!(body["temperature"], 0.0);
+        assert_eq!(body["max_tokens"], 256);
+        assert_eq!(body["stop"], serde_json::json!(["\n\n"]));
+        assert_eq!(body["messages"][1]["role"], "user");
+        assert_eq!(
+            body["messages"][1]["content"],
+            "<PREFIX>\nfn main() {\n<CURSOR/>\n<SUFFIX>\n}"
+        );
+    }
+
+    #[test]
+    fn invalid_fim_body_is_bad_request() {
+        let err = maybe_transform_fim_request(
+            &AIProvider::OpenAI,
+            "fim/completions",
+            "https://api.openai.com/v1",
+            br#"{"model": 1}"#,
+        )
+        .unwrap_err();
+
+        assert!(matches!(err, Error::BadRequest(_)));
+    }
+}
diff --git a/backend/windmill-ai/src/types.rs b/backend/windmill-ai/src/types.rs
index 1d18e2411c..56a796e41d 100644
--- a/backend/windmill-ai/src/types.rs
+++ b/backend/windmill-ai/src/types.rs
@@ -18,7 +18,7 @@ pub struct McpToolSource {
 use crate::{
     ai_google::sanitize_schema_for_google,
     ai_providers::{empty_string_as_none, AIProvider},
-    proxy::ProviderCredentials,
+    credentials::ProviderCredentials,
 };
 use windmill_common::{db::DB, error::Error, flow_status::AgentAction, flows::FlowModule};
 use windmill_parser::Typ;
diff --git a/backend/windmill-api-auth/src/lib.rs b/backend/windmill-api-auth/src/lib.rs
index 99fa677cee..734753a0e0 100644
--- a/backend/windmill-api-auth/src/lib.rs
+++ b/backend/windmill-api-auth/src/lib.rs
@@ -235,6 +235,202 @@ where
     Ok(())
 }
 
+/// Returns the caller's "real" scope restrictions: every scope other than
+/// `if_jobs:filter_tags:` tag filters. `None` means the token is unscoped and
+/// has the full privileges of its user; `Some` means it is restricted to the
+/// returned scopes. An empty or filter-tags-only scope list is treated as
+/// unscoped, mirroring `check_scopes`/`check_route_access`.
+fn scope_restrictions(scopes: Option<&[String]>) -> Option<Vec<&String>> {
+    let restrictions: Vec<&String> = scopes?
+        .iter()
+        .filter(|s| !s.starts_with("if_jobs:filter_tags:"))
+        .collect();
+    (!restrictions.is_empty()).then_some(restrictions)
+}
+
+/// Enforce monotonic privilege when a token lifecycle endpoint mints or rescopes
+/// a credential on behalf of `authed`: the resulting credential must never be
+/// more privileged than the caller's own token.
+///
+/// - An unscoped caller may grant any scopes (this is the existing UI/CLI flow).
+/// - A scope-restricted caller may only grant scopes that are a subset of its
+///   own, and may never produce an unscoped credential.
+///
+/// Without this, a `users:write` token could create or rescope a token to be
+/// unscoped, and a `users:read` token could refresh into an unscoped session —
+/// escaping its own restrictions.
+pub fn ensure_scopes_within_caller(
+    authed: &ApiAuthed,
+    requested_scopes: Option<&[String]>,
+) -> error::Result<()> {
+    if let Some(caller_restrictions) = scope_restrictions(authed.scopes.as_deref()) {
+        let Some(requested_restrictions) = scope_restrictions(requested_scopes) else {
+            return Err(Error::PermissionDenied(
+                "A scope-restricted token cannot create or update a token with broader (unscoped) \
+                 privileges"
+                    .to_string(),
+            ));
+        };
+
+        // MCP scopes (`mcp:all`, `mcp:favorites`, `mcp:scripts:*`, etc.) use a
+        // custom format that ScopeDefinition::from_scope_string parses
+        // permissively but the MCP runtime interprets via its own parser
+        // (parse_mcp_scopes). The two views disagree — e.g. the generic parser
+        // accepts `mcp:scripts` as an unrestricted-resource scope, while the
+        // MCP runtime ignores it as unrecognized but interprets `mcp:scripts:*`
+        // as granting all scripts. So generic containment would silently allow
+        // `mcp:scripts` → `mcp:scripts:*` (a widening). Legitimate MCP token
+        // issuance goes through the OAuth gateway (mcp/oauth_server.rs), not
+        // these user-token endpoints, so require byte-identical match for MCP
+        // scopes here rather than trying to mirror MCP semantics in two places.
+        // Unparseable non-MCP caller scopes are intentionally dropped
+        // (fail-closed): a caller scope that fails to parse can only narrow
+        // the set of requested scopes that get covered, never widen it.
+        // Unparseable requested scopes surface as `BadRequest`, which is what
+        // we want — the client is sending garbage.
+        let parsed_caller: Vec<ScopeDefinition> = caller_restrictions
+            .iter()
+            .filter(|s| !s.starts_with("mcp:"))
+            .filter_map(|s| ScopeDefinition::from_scope_string(s).ok())
+            .collect();
+        let caller_mcp: std::collections::HashSet<&str> = caller_restrictions
+            .iter()
+            .filter(|s| s.starts_with("mcp:"))
+            .map(|s| s.as_str())
+            .collect();
+
+        for requested in requested_restrictions {
+            if requested.starts_with("mcp:") {
+                if !caller_mcp.contains(requested.as_str()) {
+                    return Err(Error::PermissionDenied(format!(
+                        "A scope-restricted token cannot grant MCP scope '{requested}' unless the \
+                         caller holds the same scope verbatim"
+                    )));
+                }
+                continue;
+            }
+            let requested_scope = ScopeDefinition::from_scope_string(requested)?;
+            let covered = parsed_caller
+                .iter()
+                .any(|caller_scope| scope_contains(caller_scope, &requested_scope));
+            if !covered {
+                return Err(Error::PermissionDenied(format!(
+                    "A scope-restricted token cannot grant scope '{requested}' which exceeds its \
+                     own scopes"
+                )));
+            }
+        }
+    }
+
+    // `if_jobs:filter_tags:` fences which job tags a token can run on (enforced
+    // at job operations as `v2_job.tag = ANY(...)`), and is checked independently
+    // of domain/action/resource subset. A caller restricted by filter_tags must
+    // not be able to mint or rescope a credential that drops or widens the fence
+    // — even if the caller has no other scope restrictions (filter_tags-only
+    // tokens otherwise look "unscoped" to `scope_restrictions`).
+    if let Some(caller_tags) = first_filter_tags(authed.scopes.as_deref()) {
+        let Some(requested_tags) = first_filter_tags(requested_scopes) else {
+            return Err(Error::PermissionDenied(
+                "A token restricted by if_jobs:filter_tags cannot mint or rescope a token that \
+                 drops the tag restriction"
+                    .to_string(),
+            ));
+        };
+        let caller_set: std::collections::HashSet<&str> = caller_tags.iter().copied().collect();
+        for tag in &requested_tags {
+            if !caller_set.contains(tag) {
+                return Err(Error::PermissionDenied(format!(
+                    "A token restricted by if_jobs:filter_tags cannot grant tag '{tag}' which is \
+                     not within its own filter_tags"
+                )));
+            }
+        }
+    }
+
+    Ok(())
+}
+
+/// Tags from the first `if_jobs:filter_tags:<a,b,...>` scope, matching the
+/// semantics of [`get_scope_tags`] (which is what the job runtime consults).
+/// Returns `None` if no such scope is present.
+fn first_filter_tags(scopes: Option<&[String]>) -> Option<Vec<&str>> {
+    scopes?.iter().find_map(|s| {
+        s.strip_prefix("if_jobs:filter_tags:")
+            .map(|tags| tags.split(',').collect())
+    })
+}
+
+/// Whether `caller` grants at least everything `requested` grants (directional
+/// containment).
+///
+/// This is intentionally NOT `ScopeDefinition::includes`: that method answers
+/// "does this scope grant access to a required action" using OR semantics over
+/// resources (any overlap counts, and a `*` on either side matches), which is
+/// correct for access checks but unsafe for subset checks — it would let a
+/// token scoped to `scripts:read:f/team/a` mint `scripts:read:*` or
+/// `scripts:read:f/team/a,f/other/b`. Subset containment instead requires that
+/// EVERY requested resource is covered by SOME caller resource.
+fn scope_contains(caller: &ScopeDefinition, requested: &ScopeDefinition) -> bool {
+    if caller.domain != requested.domain {
+        return false;
+    }
+
+    // write subsumes read; otherwise the action must match exactly.
+    match (caller.action.as_str(), requested.action.as_str()) {
+        (c, r) if c == r || (c == "write" && r == "read") => {}
+        _ => return false,
+    }
+
+    if caller.domain == "jobs" && caller.action == "run" {
+        match (&caller.kind, &requested.kind) {
+            (Some(caller_kind), Some(requested_kind)) if caller_kind != requested_kind => {
+                return false
+            }
+            // Caller pinned to a kind, but the request covers any kind.
+            (Some(_), None) => return false,
+            _ => {}
+        }
+    }
+
+    match (&caller.resource, &requested.resource) {
+        // Caller is unrestricted on resources: covers everything.
+        (None, _) => true,
+        // Caller is resource-restricted but the request is not: broader.
+        (Some(_), None) => false,
+        (Some(caller_resources), Some(requested_resources)) => {
+            resource_set_contains(caller_resources, requested_resources)
+        }
+    }
+}
+
+/// Every resource in `requested` must be covered by some resource in `caller`.
+fn resource_set_contains(caller: &[String], requested: &[String]) -> bool {
+    if caller.iter().any(|r| r == "*") {
+        return true;
+    }
+    requested
+        .iter()
+        .all(|req| req != "*" && caller.iter().any(|c| resource_covers(c, req)))
+}
+
+/// Directional: does the single caller resource pattern cover `requested`?
+/// `caller` may be an exact path or a `<prefix>/*` subtree wildcard; `requested`
+/// may itself be a subtree wildcard, in which case the whole requested subtree
+/// must fall within the caller's subtree.
+fn resource_covers(caller: &str, requested: &str) -> bool {
+    if caller == requested {
+        return true;
+    }
+    let Some(prefix) = caller.strip_suffix("/*") else {
+        // An exact caller resource only covers itself (handled above).
+        return false;
+    };
+    let requested_base = requested.strip_suffix("/*").unwrap_or(requested);
+    requested_base == prefix
+        || (requested_base.starts_with(prefix)
+            && requested_base.as_bytes().get(prefix.len()) == Some(&b'/'))
+}
+
 /// Returns a predicate that checks whether `path` is within the token's
 /// scope for `{domain}:{action}:{path}`. For tokens without scope
 /// restrictions (no scopes at all, or only `if_jobs:filter_tags:*` scopes),
@@ -574,6 +770,13 @@ impl NewToken {
     }
 }
 
+/// Low-level token mint shared by trusted callers (the user-facing
+/// `tokens/create` handler and internal mints such as native-trigger webhook
+/// tokens). It does NOT enforce that `token_config.scopes` is within the
+/// caller's own scopes — callers exposed to untrusted input must call
+/// [`ensure_scopes_within_caller`] first (internal narrowing mints intentionally
+/// skip it, since their scopes derive from the action being authorized, not the
+/// caller's token).
 pub async fn create_token_internal(
     tx: &mut sqlx::PgConnection,
     db: &DB,
@@ -908,4 +1111,278 @@ mod tests {
         assert!(allowed("u/alice/foo"));
         assert!(!allowed("u/alice/bar"));
     }
+
+    fn opt_scopes(scopes: Option<Vec<&str>>) -> Option<Vec<String>> {
+        scopes.map(|v| v.into_iter().map(String::from).collect())
+    }
+
+    // Regression tests for WIN-1999: scoped user tokens must not be able to
+    // mint or rescope credentials with broader privileges than themselves.
+
+    #[test]
+    fn unscoped_caller_can_grant_anything() {
+        let authed = authed_with_scopes(None);
+        assert!(ensure_scopes_within_caller(&authed, None).is_ok());
+        assert!(ensure_scopes_within_caller(
+            &authed,
+            opt_scopes(Some(vec!["jobs:run:scripts"])).as_deref()
+        )
+        .is_ok());
+    }
+
+    #[test]
+    fn filter_tags_only_caller_is_unrestricted_on_domain_action_dimension() {
+        // The domain/action/resource subset check treats filter-tags-only as
+        // unrestricted, mirroring check_scopes/check_route_access. The tag
+        // dimension is checked separately (see filter_tags_dimension_is_monotonic).
+        let authed = authed_with_scopes(Some(vec!["if_jobs:filter_tags:default"]));
+        assert!(ensure_scopes_within_caller(
+            &authed,
+            opt_scopes(Some(vec!["users:write", "if_jobs:filter_tags:default"])).as_deref()
+        )
+        .is_ok());
+    }
+
+    #[test]
+    fn filter_tags_dimension_is_monotonic() {
+        // Caller restricted to tag fence "a" cannot drop the fence …
+        let single = authed_with_scopes(Some(vec!["if_jobs:filter_tags:a"]));
+        assert!(ensure_scopes_within_caller(&single, None).is_err());
+        assert!(
+            ensure_scopes_within_caller(&single, opt_scopes(Some(vec!["users:read"])).as_deref())
+                .is_err(),
+            "minting a token without filter_tags must be rejected"
+        );
+        // … cannot widen to a tag it lacks …
+        assert!(ensure_scopes_within_caller(
+            &single,
+            opt_scopes(Some(vec!["if_jobs:filter_tags:a,b"])).as_deref()
+        )
+        .is_err());
+        // … and cannot mint a token fenced on a disjoint tag.
+        assert!(ensure_scopes_within_caller(
+            &single,
+            opt_scopes(Some(vec!["if_jobs:filter_tags:b"])).as_deref()
+        )
+        .is_err());
+        // Narrowing or matching the tag fence is allowed.
+        let multi = authed_with_scopes(Some(vec!["if_jobs:filter_tags:a,b"]));
+        assert!(ensure_scopes_within_caller(
+            &multi,
+            opt_scopes(Some(vec!["if_jobs:filter_tags:a"])).as_deref()
+        )
+        .is_ok());
+        assert!(ensure_scopes_within_caller(
+            &multi,
+            opt_scopes(Some(vec!["if_jobs:filter_tags:a,b"])).as_deref()
+        )
+        .is_ok());
+        // A caller with a real scope plus a tag fence cannot drop just the fence.
+        let mixed = authed_with_scopes(Some(vec!["jobs:run:scripts", "if_jobs:filter_tags:a"]));
+        assert!(ensure_scopes_within_caller(
+            &mixed,
+            opt_scopes(Some(vec!["jobs:run:scripts"])).as_deref()
+        )
+        .is_err());
+        assert!(ensure_scopes_within_caller(
+            &mixed,
+            opt_scopes(Some(vec!["jobs:run:scripts", "if_jobs:filter_tags:a"])).as_deref()
+        )
+        .is_ok());
+        // An unrestricted caller may grant filter_tags freely.
+        let unscoped = authed_with_scopes(None);
+        assert!(ensure_scopes_within_caller(
+            &unscoped,
+            opt_scopes(Some(vec!["if_jobs:filter_tags:x"])).as_deref()
+        )
+        .is_ok());
+    }
+
+    #[test]
+    fn scoped_caller_cannot_mint_unscoped_token() {
+        // Primitive 2 in the report: a users:write token minting an unscoped token.
+        let authed = authed_with_scopes(Some(vec!["users:write"]));
+        assert!(ensure_scopes_within_caller(&authed, None).is_err());
+        // Empty scope list is effectively unscoped and must also be rejected.
+        assert!(ensure_scopes_within_caller(&authed, Some(&[])).is_err());
+        // A scope list of only tag filters is effectively unscoped too.
+        assert!(ensure_scopes_within_caller(
+            &authed,
+            opt_scopes(Some(vec!["if_jobs:filter_tags:default"])).as_deref()
+        )
+        .is_err());
+    }
+
+    #[test]
+    fn scoped_caller_cannot_remove_its_own_scopes() {
+        // Primitive 3 in the report: a users:write token setting its scopes to null.
+        let authed = authed_with_scopes(Some(vec!["users:write"]));
+        assert!(ensure_scopes_within_caller(&authed, None).is_err());
+    }
+
+    #[test]
+    fn scoped_caller_cannot_grant_scope_it_lacks() {
+        let authed = authed_with_scopes(Some(vec!["users:write"]));
+        assert!(ensure_scopes_within_caller(
+            &authed,
+            opt_scopes(Some(vec!["jobs:run:scripts"])).as_deref()
+        )
+        .is_err());
+    }
+
+    #[test]
+    fn scoped_caller_can_grant_subset_of_own_scopes() {
+        let authed = authed_with_scopes(Some(vec!["users:write", "jobs:run:scripts"]));
+        // Equal scope is allowed.
+        assert!(ensure_scopes_within_caller(
+            &authed,
+            opt_scopes(Some(vec!["jobs:run:scripts"])).as_deref()
+        )
+        .is_ok());
+        // write implies read, so a narrower read scope is allowed.
+        assert!(ensure_scopes_within_caller(
+            &authed,
+            opt_scopes(Some(vec!["users:read"])).as_deref()
+        )
+        .is_ok());
+        // Tag filters narrow further and are always permitted.
+        assert!(ensure_scopes_within_caller(
+            &authed,
+            opt_scopes(Some(vec!["users:read", "if_jobs:filter_tags:default"])).as_deref()
+        )
+        .is_ok());
+    }
+
+    #[test]
+    fn scoped_caller_cannot_broaden_resource_scope() {
+        let authed = authed_with_scopes(Some(vec!["scripts:read:f/team/*"]));
+        // Narrower resource within the subtree is allowed.
+        assert!(ensure_scopes_within_caller(
+            &authed,
+            opt_scopes(Some(vec!["scripts:read:f/team/sub"])).as_deref()
+        )
+        .is_ok());
+        // A nested subtree within the caller's subtree is allowed.
+        assert!(ensure_scopes_within_caller(
+            &authed,
+            opt_scopes(Some(vec!["scripts:read:f/team/sub/*"])).as_deref()
+        )
+        .is_ok());
+        // The subtree root itself is allowed.
+        assert!(ensure_scopes_within_caller(
+            &authed,
+            opt_scopes(Some(vec!["scripts:read:f/team"])).as_deref()
+        )
+        .is_ok());
+        // A path outside the subtree is rejected.
+        assert!(ensure_scopes_within_caller(
+            &authed,
+            opt_scopes(Some(vec!["scripts:read:f/other/x"])).as_deref()
+        )
+        .is_err());
+        // read caller cannot grant write.
+        assert!(ensure_scopes_within_caller(
+            &authed,
+            opt_scopes(Some(vec!["scripts:write:f/team/db"])).as_deref()
+        )
+        .is_err());
+    }
+
+    #[test]
+    fn mcp_scopes_require_byte_identical_match() {
+        // Regression for the access-grant-OR vs runtime-MCP-parser confusion:
+        // ScopeDefinition treats `mcp:scripts` as an unrestricted-resource scope
+        // and `mcp:scripts:*` as a strictly narrower one, so generic containment
+        // would silently allow widening. The MCP runtime however ignores
+        // `mcp:scripts` (unrecognized) while `mcp:scripts:*` grants all scripts.
+        // Legitimate MCP token issuance is the OAuth gateway, not these
+        // user-token endpoints, so MCP scopes must match the caller verbatim.
+
+        // The bypass the reviewer flagged: malformed `mcp:scripts` would widen
+        // into the real `mcp:scripts:*` under generic containment.
+        let bypass = authed_with_scopes(Some(vec!["users:write", "mcp:scripts"]));
+        assert!(ensure_scopes_within_caller(
+            &bypass,
+            opt_scopes(Some(vec!["users:write", "mcp:scripts:*"])).as_deref()
+        )
+        .is_err());
+
+        // A caller without any MCP scope cannot grant one (widening on the MCP
+        // dimension), even if the rest of the requested scopes are within reach.
+        let no_mcp = authed_with_scopes(Some(vec!["users:write"]));
+        assert!(ensure_scopes_within_caller(
+            &no_mcp,
+            opt_scopes(Some(vec!["users:write", "mcp:scripts:*"])).as_deref()
+        )
+        .is_err());
+
+        // Byte-identical MCP scope passes; an additional non-matching MCP scope
+        // alongside it does not.
+        let mcp_caller = authed_with_scopes(Some(vec!["mcp:scripts:*"]));
+        assert!(ensure_scopes_within_caller(
+            &mcp_caller,
+            opt_scopes(Some(vec!["mcp:scripts:*"])).as_deref()
+        )
+        .is_ok());
+        assert!(ensure_scopes_within_caller(
+            &mcp_caller,
+            opt_scopes(Some(vec!["mcp:scripts:*", "mcp:flows:*"])).as_deref()
+        )
+        .is_err());
+
+        // Even a narrowing within MCP semantics (`mcp:all` → `mcp:scripts:*`)
+        // is rejected by the byte-identical rule. This is intentional — these
+        // endpoints are not the legitimate path for narrowing MCP tokens.
+        let mcp_all = authed_with_scopes(Some(vec!["mcp:all"]));
+        assert!(ensure_scopes_within_caller(
+            &mcp_all,
+            opt_scopes(Some(vec!["mcp:scripts:*"])).as_deref()
+        )
+        .is_err());
+    }
+
+    #[test]
+    fn scoped_caller_cannot_escalate_to_wildcard_or_superset() {
+        // Regression for the access-grant-OR vs subset-containment confusion:
+        // ScopeDefinition::includes would (incorrectly) allow all of these.
+        let star = authed_with_scopes(Some(vec!["scripts:read:f/team/a"]));
+        // Minting `*` from a single-path scope must be rejected.
+        assert!(ensure_scopes_within_caller(
+            &star,
+            opt_scopes(Some(vec!["scripts:read:*"])).as_deref()
+        )
+        .is_err());
+        // Minting a broader subtree must be rejected.
+        assert!(ensure_scopes_within_caller(
+            &star,
+            opt_scopes(Some(vec!["scripts:read:f/team/*"])).as_deref()
+        )
+        .is_err());
+
+        // A comma-separated list that adds an uncovered resource must be rejected,
+        // even though one element overlaps the caller's scope.
+        let list = authed_with_scopes(Some(vec!["scripts:read:f/team/a"]));
+        assert!(ensure_scopes_within_caller(
+            &list,
+            opt_scopes(Some(vec!["scripts:read:f/team/a,f/other/b"])).as_deref()
+        )
+        .is_err());
+
+        // A subset of a multi-resource caller scope is allowed.
+        let multi = authed_with_scopes(Some(vec!["scripts:read:f/team/a,f/team/b"]));
+        assert!(ensure_scopes_within_caller(
+            &multi,
+            opt_scopes(Some(vec!["scripts:read:f/team/a"])).as_deref()
+        )
+        .is_ok());
+
+        // A wildcard caller covers any subset, but not `*`-less escalation rules apply
+        // only when the caller itself lacks `*`.
+        let wildcard = authed_with_scopes(Some(vec!["scripts:read:*"]));
+        assert!(ensure_scopes_within_caller(
+            &wildcard,
+            opt_scopes(Some(vec!["scripts:read:f/team/a"])).as_deref()
+        )
+        .is_ok());
+    }
 }
diff --git a/backend/windmill-api-flows/src/flows.rs b/backend/windmill-api-flows/src/flows.rs
index 8a42bce88e..546bda32f0 100644
--- a/backend/windmill-api-flows/src/flows.rs
+++ b/backend/windmill-api-flows/src/flows.rs
@@ -558,13 +558,17 @@ async fn create_flow(
         w_id
     ).execute(&mut *tx).await?;
 
-    sqlx::query!(
-        "DELETE FROM draft WHERE path = $1 AND workspace_id = $2 AND typ = 'flow'",
-        nf.path,
-        &w_id
-    )
-    .execute(&mut *tx)
-    .await?;
+    // CLI / git-sync deploys ask us to preserve any existing user draft at this
+    // path instead of wiping it as part of the deploy.
+    if !nf.skip_draft_deletion.unwrap_or(false) {
+        sqlx::query!(
+            "DELETE FROM draft WHERE path = $1 AND workspace_id = $2 AND typ = 'flow'",
+            nf.path,
+            &w_id
+        )
+        .execute(&mut *tx)
+        .await?;
+    }
 
     audit_log(
         &mut *tx,
@@ -1157,13 +1161,17 @@ async fn update_flow(
         })?;
     }
 
-    sqlx::query!(
-        "DELETE FROM draft WHERE path = $1 AND workspace_id = $2 AND typ = 'flow'",
-        flow_path,
-        &w_id
-    )
-    .execute(&mut *tx)
-    .await?;
+    // CLI / git-sync deploys ask us to preserve any existing user draft at this
+    // path instead of wiping it as part of the deploy.
+    if !nf.skip_draft_deletion.unwrap_or(false) {
+        sqlx::query!(
+            "DELETE FROM draft WHERE path = $1 AND workspace_id = $2 AND typ = 'flow'",
+            flow_path,
+            &w_id
+        )
+        .execute(&mut *tx)
+        .await?;
+    }
 
     audit_log(
         &mut *tx,
@@ -2031,6 +2039,7 @@ mod tests {
             })),
             preprocessor_module: None,
             same_worker: false,
+            preserve_step_tags: false,
             skip_expr: None,
             cache_ttl: None,
             cache_ignore_s3_path: None,
diff --git a/backend/windmill-api-groups/src/granular_acls.rs b/backend/windmill-api-groups/src/granular_acls.rs
index 3f0549f4e8..1f88c33e9f 100644
--- a/backend/windmill-api-groups/src/granular_acls.rs
+++ b/backend/windmill-api-groups/src/granular_acls.rs
@@ -383,6 +383,8 @@ async fn remove_granular_acl(
     // workspace export.
     let table = if kind == "raw_app" { "app" } else { kind };
     // SAFETY: `kind` has been validated against the `KINDS` allowlist before reaching this function.
+    // LIMIT 1: `script` shares (workspace_id, path) across versions, so `old` can
+    // return >1 row, which would break the scalar subquery in RETURNING.
     let obj_o = sqlx::query_scalar::<_, bool>(&format!(
         "WITH old AS (
             SELECT extra_perms->$1 as old_write FROM {table}
@@ -390,7 +392,7 @@ async fn remove_granular_acl(
         )
         UPDATE {table} SET extra_perms = extra_perms - $1
         WHERE {identifier} = $2 AND workspace_id = $3 AND extra_perms ? $1
-        RETURNING (SELECT old_write FROM old)::bool"
+        RETURNING (SELECT old_write FROM old LIMIT 1)::bool"
     ))
     .bind(&owner)
     .bind(path)
diff --git a/backend/windmill-api-integration-tests/tests/workspace_encryption_key_git_sync.rs b/backend/windmill-api-integration-tests/tests/workspace_encryption_key_git_sync.rs
new file mode 100644
index 0000000000..8edfd39d61
--- /dev/null
+++ b/backend/windmill-api-integration-tests/tests/workspace_encryption_key_git_sync.rs
@@ -0,0 +1,358 @@
+/*!
+ * Integration test for workspace encryption key rotation triggering git sync.
+ *
+ * Regression test for windmill-labs/windmill#9344 — re-encrypting all secret
+ * variables on workspace key change must dispatch a git-sync job that carries
+ * every re-encrypted variable plus the encryption_key entry, so repos with
+ * Secrets sync enabled receive the new ciphertexts in one commit.
+ *
+ * Run with enterprise features:
+ * ```bash
+ * cargo test --test workspace_encryption_key_git_sync --features enterprise,private
+ * ```
+ */
+
+use serde_json::json;
+use sqlx::{Pool, Postgres};
+use std::time::Duration;
+
+#[allow(unused_imports)]
+use windmill_test_utils::*;
+
+fn client() -> reqwest::Client {
+    reqwest::Client::new()
+}
+
+fn authed(builder: reqwest::RequestBuilder) -> reqwest::RequestBuilder {
+    builder.header("Authorization", "Bearer SECRET_TOKEN")
+}
+
+#[allow(dead_code)]
+async fn create_git_repo_resource(db: &Pool<Postgres>) -> anyhow::Result<()> {
+    sqlx::query(
+        r#"
+        INSERT INTO resource (workspace_id, path, value, resource_type, extra_perms, created_by)
+        VALUES ('test-workspace', 'u/test-user/test_git_repo', $1::jsonb, 'git_repository', '{}'::jsonb, 'test-user')
+        ON CONFLICT (workspace_id, path) DO NOTHING
+        "#,
+    )
+    .bind(json!({
+        "url": "https://github.com/test/test.git",
+        "branch": "main",
+        "token": "test-token"
+    }))
+    .execute(db)
+    .await?;
+    Ok(())
+}
+
+#[allow(dead_code)]
+async fn create_folder(db: &Pool<Postgres>, name: &str) -> anyhow::Result<()> {
+    sqlx::query(
+        r#"
+        INSERT INTO folder (workspace_id, name, display_name, owners, extra_perms, created_by)
+        VALUES ('test-workspace', $1, $1, ARRAY['u/test-user'], '{}'::jsonb, 'test-user')
+        ON CONFLICT (workspace_id, name) DO NOTHING
+        "#,
+    )
+    .bind(name)
+    .execute(db)
+    .await?;
+    Ok(())
+}
+
+#[allow(dead_code)]
+async fn create_sync_script(db: &Pool<Postgres>, path: &str) -> anyhow::Result<i64> {
+    let hash: i64 = rand::random::<i64>().unsigned_abs() as i64;
+    sqlx::query(
+        r#"
+        INSERT INTO script (workspace_id, hash, path, summary, description, content,
+                  created_by, language, kind, lock)
+        VALUES ('test-workspace', $1, $2, 'sync script', '',
+                'export function main(items: any[]) { return { synced: items.length }; }',
+                'test-user', 'bun', 'script', '')
+        "#,
+    )
+    .bind(hash)
+    .bind(path)
+    .execute(db)
+    .await?;
+    Ok(hash)
+}
+
+#[allow(dead_code)]
+async fn setup_git_sync_config(db: &Pool<Postgres>, sync_script_path: &str) -> anyhow::Result<()> {
+    // Include Variable + Secret + Key so the encryption rotation has a reason
+    // to push every re-encrypted variable. Anchor include_path to root so all
+    // u/... and f/... paths pass the regex filter.
+    let git_sync_config = json!({
+        "include_type": ["variable", "secret", "key"],
+        "include_path": ["**"],
+        "repositories": [{
+            "script_path": sync_script_path,
+            "git_repo_resource_path": "$res:u/test-user/test_git_repo",
+            "use_individual_branch": false,
+            "group_by_folder": false
+        }]
+    });
+    sqlx::query!(
+        "UPDATE workspace_settings SET git_sync = $1 WHERE workspace_id = $2",
+        git_sync_config,
+        "test-workspace"
+    )
+    .execute(db)
+    .await?;
+    Ok(())
+}
+
+/// Insert N secret variables, encrypting their values with the workspace's
+/// current key so the re-encryption path can decrypt them.
+#[allow(dead_code)]
+async fn insert_secret_variables(db: &Pool<Postgres>, paths: &[&str]) -> anyhow::Result<()> {
+    use windmill_common::variables::{build_crypt, encrypt};
+    let mc = build_crypt(db, "test-workspace").await?;
+    for path in paths {
+        let plaintext = format!("secret-value-for-{path}");
+        let encrypted = encrypt(&mc, &plaintext);
+        sqlx::query!(
+            r#"
+            INSERT INTO variable (workspace_id, path, value, is_secret, description, extra_perms, account)
+            VALUES ($1, $2, $3, true, '', '{}'::jsonb, NULL)
+            ON CONFLICT (workspace_id, path) DO UPDATE SET value = EXCLUDED.value
+            "#,
+            "test-workspace",
+            path,
+            encrypted,
+        )
+        .execute(db)
+        .await?;
+    }
+    Ok(())
+}
+
+#[derive(Debug)]
+#[allow(dead_code)]
+struct DeploymentCallbackJob {
+    id: uuid::Uuid,
+    args: Option<serde_json::Value>,
+}
+
+/// Poll until at least `min_count` deployment-callback jobs exist for the
+/// script path, or the timeout elapses. Returns whatever was found.
+#[allow(dead_code)]
+async fn wait_for_deployment_callbacks(
+    db: &Pool<Postgres>,
+    script_path: &str,
+    min_count: usize,
+    timeout: Duration,
+) -> anyhow::Result<Vec<DeploymentCallbackJob>> {
+    let deadline = tokio::time::Instant::now() + timeout;
+    loop {
+        let rows = sqlx::query_as!(
+            DeploymentCallbackJob,
+            r#"
+            SELECT j.id, j.args
+            FROM v2_job j
+            JOIN v2_job_queue q ON j.id = q.id
+            WHERE j.runnable_path = $1
+              AND j.kind = 'deploymentcallback'
+              AND j.workspace_id = 'test-workspace'
+            ORDER BY j.created_at DESC
+            "#,
+            script_path,
+        )
+        .fetch_all(db)
+        .await?;
+        if rows.len() >= min_count || tokio::time::Instant::now() >= deadline {
+            return Ok(rows);
+        }
+        tokio::time::sleep(Duration::from_millis(100)).await;
+    }
+}
+
+#[cfg(all(feature = "enterprise", feature = "private"))]
+#[sqlx::test(migrations = "../migrations", fixtures("base"))]
+async fn test_encryption_key_rotation_dispatches_batched_git_sync(
+    db: Pool<Postgres>,
+) -> anyhow::Result<()> {
+    initialize_tracing().await;
+
+    // Setup git sync repo + sync script (folder/path encodes the hub min-version)
+    create_folder(&db, "28103").await?;
+    create_git_repo_resource(&db).await?;
+    let sync_script_path = "f/28103/test_sync_script_encryption";
+    create_sync_script(&db, sync_script_path).await?;
+    setup_git_sync_config(&db, sync_script_path).await?;
+
+    let secret_paths = [
+        "u/test-user/secret_a",
+        "u/test-user/secret_b",
+        "u/test-user/secret_c",
+    ];
+    insert_secret_variables(&db, &secret_paths).await?;
+
+    let server = ApiServer::start(db.clone()).await?;
+    let port = server.addr.port();
+    let base = format!("http://localhost:{port}/api/w/test-workspace/workspaces");
+
+    // 64-char alphanumeric per the route's WORKSPACE_KEY_REGEXP
+    let new_key = "a".repeat(64);
+    let resp = authed(client().post(format!("{base}/encryption_key")))
+        .json(&json!({"new_key": new_key, "skip_reencrypt": false}))
+        .send()
+        .await?;
+    assert_eq!(
+        resp.status(),
+        200,
+        "set_encryption_key failed: {}",
+        resp.text().await?
+    );
+
+    // The git-sync dispatch runs in a tokio::spawn'd task. Poll up to a few
+    // seconds for the deployment callback to land in the queue.
+    let jobs =
+        wait_for_deployment_callbacks(&db, sync_script_path, 1, Duration::from_secs(5)).await?;
+    assert_eq!(
+        jobs.len(),
+        1,
+        "expected exactly one batched deployment callback job, got {}",
+        jobs.len()
+    );
+    let job = &jobs[0];
+
+    let args = job.args.as_ref().expect("job should have args");
+    let items = args
+        .get("items")
+        .and_then(|v| v.as_array())
+        .expect("args.items should be a JSON array");
+
+    // Expect exactly one job carrying the Key entry + every re-encrypted variable
+    assert_eq!(
+        items.len(),
+        secret_paths.len() + 1,
+        "expected {} items (key + {} variables) in a single sync job, got {} — items: {:#?}",
+        secret_paths.len() + 1,
+        secret_paths.len(),
+        items.len(),
+        items
+    );
+
+    let mut variable_paths: Vec<String> = Vec::new();
+    let mut saw_key = false;
+    for item in items {
+        let path_type = item.get("path_type").and_then(|v| v.as_str()).unwrap_or("");
+        let path = item.get("path").and_then(|v| v.as_str()).unwrap_or("");
+        match path_type {
+            "variable" => variable_paths.push(path.to_string()),
+            "key" => saw_key = true,
+            other => panic!("unexpected path_type in batch: {other}"),
+        }
+    }
+    assert!(
+        saw_key,
+        "expected a path_type=key entry in items: {:#?}",
+        items
+    );
+    variable_paths.sort();
+    let mut expected: Vec<String> = secret_paths.iter().map(|s| s.to_string()).collect();
+    expected.sort();
+    assert_eq!(
+        variable_paths, expected,
+        "items array should contain every re-encrypted secret variable"
+    );
+
+    // Secrets sync is enabled (ObjectType::Secret in include_type), so the sync
+    // script should be invoked with skip_secret=false.
+    let skip_secret = args
+        .get("skip_secret")
+        .and_then(|v| v.as_bool())
+        .expect("args.skip_secret should be set when batch carries variables");
+    assert!(
+        !skip_secret,
+        "skip_secret should be false when Secret is included in the repo's types"
+    );
+
+    Ok(())
+}
+
+/// Regression test for the non-debouncing fallback: a workspace whose sync
+/// script predates hub version 28103 must still receive git-sync jobs for the
+/// encryption_key entry and every re-encrypted secret. Before the fallback was
+/// added, the batch path `continue`d past such repos and queued nothing,
+/// silently leaving the repo stale after a key rotation.
+#[cfg(all(feature = "enterprise", feature = "private"))]
+#[sqlx::test(migrations = "../migrations", fixtures("base"))]
+async fn test_encryption_key_rotation_falls_back_without_debouncing(
+    db: Pool<Postgres>,
+) -> anyhow::Result<()> {
+    initialize_tracing().await;
+
+    // Folder/path encodes a hub version BELOW 28103, so
+    // is_script_meets_min_version(28103) is false → debouncing unsupported.
+    create_folder(&db, "28000").await?;
+    create_git_repo_resource(&db).await?;
+    let sync_script_path = "f/28000/test_sync_script_legacy";
+    create_sync_script(&db, sync_script_path).await?;
+    setup_git_sync_config(&db, sync_script_path).await?;
+
+    let secret_paths = ["u/test-user/secret_a", "u/test-user/secret_b"];
+    insert_secret_variables(&db, &secret_paths).await?;
+
+    let server = ApiServer::start(db.clone()).await?;
+    let port = server.addr.port();
+    let base = format!("http://localhost:{port}/api/w/test-workspace/workspaces");
+
+    let new_key = "b".repeat(64);
+    let resp = authed(client().post(format!("{base}/encryption_key")))
+        .json(&json!({"new_key": new_key, "skip_reencrypt": false}))
+        .send()
+        .await?;
+    assert_eq!(
+        resp.status(),
+        200,
+        "set_encryption_key failed: {}",
+        resp.text().await?
+    );
+
+    // Legacy fallback pushes one job per item (flat args, no `items` array):
+    // the Key entry + one per re-encrypted variable.
+    let expected = secret_paths.len() + 1;
+    let jobs =
+        wait_for_deployment_callbacks(&db, sync_script_path, expected, Duration::from_secs(5))
+            .await?;
+    assert_eq!(
+        jobs.len(),
+        expected,
+        "expected {expected} legacy deployment-callback jobs (key + {} variables), got {} — a repo on an old sync script must not be silently skipped",
+        secret_paths.len(),
+        jobs.len()
+    );
+
+    let mut variable_paths: Vec<String> = Vec::new();
+    let mut saw_key = false;
+    for job in &jobs {
+        let args = job.args.as_ref().expect("job should have args");
+        // Legacy format: flat fields, never an `items` array.
+        assert!(
+            args.get("items").is_none(),
+            "fallback jobs must use the flat legacy format, not an items array: {args:#?}"
+        );
+        let path_type = args.get("path_type").and_then(|v| v.as_str()).unwrap_or("");
+        let path = args.get("path").and_then(|v| v.as_str()).unwrap_or("");
+        match path_type {
+            "variable" => variable_paths.push(path.to_string()),
+            "key" => saw_key = true,
+            other => panic!("unexpected path_type in fallback job: {other}"),
+        }
+    }
+    assert!(saw_key, "expected a path_type=key fallback job");
+    variable_paths.sort();
+    let mut expected_paths: Vec<String> = secret_paths.iter().map(|s| s.to_string()).collect();
+    expected_paths.sort();
+    assert_eq!(
+        variable_paths, expected_paths,
+        "fallback must queue a job for every re-encrypted secret variable"
+    );
+
+    Ok(())
+}
diff --git a/backend/windmill-api-scripts/src/scripts.rs b/backend/windmill-api-scripts/src/scripts.rs
index faf8592d24..b2ed92ad8f 100644
--- a/backend/windmill-api-scripts/src/scripts.rs
+++ b/backend/windmill-api-scripts/src/scripts.rs
@@ -739,6 +739,9 @@ async fn is_noop_deploy_against_parent(
         // caller-intent flag (auto-resolve parent), not script state
         auto_parent: _,
         labels,
+        // caller-intent flag (preserve user drafts on CLI/git-sync deploys);
+        // transient, never persisted, does not change what the script *is*
+        skip_draft_deletion: _,
     } = ns;
 
     if path != &parent.path {
@@ -927,6 +930,9 @@ async fn create_script_internal<'c>(
         }
     }
     let script_path = ns.path.clone();
+    // Caller-intent: CLI / git-sync deploys ask us to preserve any existing
+    // user draft at this path instead of wiping it as part of the deploy.
+    let skip_draft_deletion = ns.skip_draft_deletion.unwrap_or(false);
     let hash = ScriptHash(hash_script(&ns));
     let authed = maybe_refresh_folders(&ns.path, &w_id, authed, &db).await;
 
@@ -1395,13 +1401,15 @@ async fn create_script_internal<'c>(
 
     let p_path_opt = parent_hashes_and_perms.as_ref().map(|x| x.p_path.clone());
     if let Some(ref p_path) = p_path_opt {
-        sqlx::query!(
-            "DELETE FROM draft WHERE path = $1 AND workspace_id = $2 AND typ = 'script'",
-            p_path,
-            &w_id
-        )
-        .execute(&mut *tx)
-        .await?;
+        if !skip_draft_deletion {
+            sqlx::query!(
+                "DELETE FROM draft WHERE path = $1 AND workspace_id = $2 AND typ = 'script'",
+                p_path,
+                &w_id
+            )
+            .execute(&mut *tx)
+            .await?;
+        }
 
         sqlx::query!(
             "UPDATE capture_config SET path = $1 WHERE path = $2 AND workspace_id = $3 AND is_flow IS FALSE",
@@ -1480,7 +1488,7 @@ async fn create_script_internal<'c>(
                 tx = push_scheduled_job(&db, tx, &schedule, None, None).await?;
             }
         }
-    } else {
+    } else if !skip_draft_deletion {
         sqlx::query!(
             "DELETE FROM draft WHERE path = $1 AND workspace_id = $2 AND typ = 'script'",
             ns.path,
diff --git a/backend/windmill-api-settings/src/lib.rs b/backend/windmill-api-settings/src/lib.rs
index af7c42ee4b..9fd1091d66 100644
--- a/backend/windmill-api-settings/src/lib.rs
+++ b/backend/windmill-api-settings/src/lib.rs
@@ -6,7 +6,10 @@
  * LICENSE-AGPL for a copy of the license.
  */
 
-use std::{collections::HashMap, time::Duration};
+use std::{
+    collections::{BTreeSet, HashMap},
+    time::Duration,
+};
 
 #[cfg(feature = "parquet")]
 mod audit_logs_s3;
@@ -47,6 +50,7 @@ use windmill_common::secret_backend::{
     AwsSecretsManagerSettings, AzureKeyVaultSettings, SecretMigrationReport, VaultSettings,
 };
 use windmill_common::{
+    auth::is_super_admin_email,
     ee_oss::{get_license_plan, LicensePlan},
     email_oss::send_email_plain_text,
     error::{self, JsonResult, Result},
@@ -1135,6 +1139,8 @@ struct CustomInstanceDb {
     success: bool,
     error: Option<String>,
     tag: Option<String>,
+    #[serde(default, skip_serializing_if = "Vec::is_empty")]
+    used_by_workspaces: Vec<String>,
 }
 
 #[derive(Deserialize, Debug, Serialize, Default)]
@@ -1154,7 +1160,7 @@ struct CustomInstanceDbLogs {
 }
 
 async fn list_custom_instance_pg_databases(
-    _authed: ApiAuthed,
+    authed: ApiAuthed,
     Extension(db): Extension<DB>,
 ) -> JsonResult<HashMap<String, CustomInstanceDb>> {
     let result = sqlx::query_scalar!(
@@ -1163,12 +1169,57 @@ async fn list_custom_instance_pg_databases(
     .fetch_one(&db)
     .await?
     .ok_or_else(|| error::Error::ExecutionErr("Couldn't find custom_instance_pg_databases".to_string()))?;
-    let result = serde_json::from_value(result).map_err(|e| {
-        error::Error::ExecutionErr(format!(
-            "couldn't parse custom_instance_pg_databases.databases : {}",
-            e.to_string()
-        ))
-    })?;
+    let mut result: HashMap<String, CustomInstanceDb> =
+        serde_json::from_value(result).map_err(|e| {
+            error::Error::ExecutionErr(format!(
+                "couldn't parse custom_instance_pg_databases.databases : {}",
+                e.to_string()
+            ))
+        })?;
+
+    if is_super_admin_email(&db, &authed.email).await? {
+        // Enrich each database with the list of workspaces referencing it through
+        // either a ducklake catalog or a datatable database whose resource_type is
+        // 'instance'. Not stored in DB to avoid drift.
+        let usages = sqlx::query!(
+            r#"
+            SELECT ws.workspace_id AS "workspace_id!", entry->'catalog'->>'resource_path' AS dbname
+            FROM workspace_settings ws
+            CROSS JOIN LATERAL jsonb_each(
+                CASE WHEN jsonb_typeof(ws.ducklake->'ducklakes') = 'object'
+                    THEN ws.ducklake->'ducklakes'
+                    ELSE '{}'::jsonb END
+            ) AS dl(k, entry)
+            WHERE entry->'catalog'->>'resource_type' = 'instance'
+            AND entry->'catalog'->>'resource_path' IS NOT NULL
+            UNION ALL
+            SELECT ws.workspace_id AS "workspace_id!", entry->'database'->>'resource_path' AS dbname
+            FROM workspace_settings ws
+            CROSS JOIN LATERAL jsonb_each(
+                CASE WHEN jsonb_typeof(ws.datatable->'datatables') = 'object'
+                    THEN ws.datatable->'datatables'
+                    ELSE '{}'::jsonb END
+            ) AS dt(k, entry)
+            WHERE entry->'database'->>'resource_type' = 'instance'
+            AND entry->'database'->>'resource_path' IS NOT NULL
+            "#,
+        )
+        .fetch_all(&db)
+        .await?;
+
+        let mut by_db: HashMap<String, BTreeSet<String>> = HashMap::new();
+        for row in usages {
+            if let Some(dbname) = row.dbname {
+                by_db.entry(dbname).or_default().insert(row.workspace_id);
+            }
+        }
+        for (dbname, entry) in result.iter_mut() {
+            if let Some(workspaces) = by_db.remove(dbname) {
+                entry.used_by_workspaces = workspaces.into_iter().collect();
+            }
+        }
+    }
+
     return Ok(Json(result));
 }
 
@@ -1196,7 +1247,8 @@ async fn setup_custom_instance_pg_database(
     let result = setup_custom_instance_pg_database_inner(authed, &db, &dbname, &mut logs).await;
     let success = result.is_ok();
     let error = result.err().map(|e| e.to_string());
-    let status = CustomInstanceDb { logs, success, error, tag: body.tag };
+    let status =
+        CustomInstanceDb { logs, success, error, tag: body.tag, used_by_workspaces: vec![] };
     let status_json = serde_json::to_value(&status).map_err(to_anyhow)?;
     // Save that the database was setup successfully
     sqlx::query!(
diff --git a/backend/windmill-api-users/src/users.rs b/backend/windmill-api-users/src/users.rs
index 405efba4e5..95b9527a8e 100644
--- a/backend/windmill-api-users/src/users.rs
+++ b/backend/windmill-api-users/src/users.rs
@@ -1964,7 +1964,8 @@ async fn login(
             windmill_common::login_rate_limit::record_login_failure(&email);
             Err(Error::BadRequest("Invalid login".to_string()))
         } else {
-            let token = create_session_token(&email, super_admin, &mut tx, cookies).await?;
+            let token =
+                create_session_token(&email, super_admin, None, false, &mut tx, cookies).await?;
 
             let audit_author = AuditAuthor {
                 email: email.clone(),
@@ -2036,7 +2037,15 @@ async fn refresh_token(
     .await?
     .unwrap_or(false);
 
-    let new_token = create_session_token(&authed.email, super_admin, &mut tx, cookies).await?;
+    let new_token = create_session_token(
+        &authed.email,
+        super_admin,
+        authed.scopes.as_deref(),
+        authed.read_only,
+        &mut tx,
+        cookies,
+    )
+    .await?;
 
     audit_log(
         &mut *tx,
@@ -2066,6 +2075,8 @@ lazy_static::lazy_static! {
 pub async fn create_session_token<'c>(
     email: &str,
     super_admin: bool,
+    scopes: Option<&[String]>,
+    read_only: bool,
     tx: &mut sqlx::Transaction<'c, sqlx::Postgres>,
     cookies: Cookies,
 ) -> Result<String> {
@@ -2108,15 +2119,17 @@ pub async fn create_session_token<'c>(
 
     sqlx::query!(
         "INSERT INTO token
-            (token_hash, token_prefix, token, email, label, expiration, super_admin)
-            VALUES ($1, $2, $3, $4, $5, now() + ($6 || ' seconds')::interval, $7)",
+            (token_hash, token_prefix, token, email, label, expiration, super_admin, scopes, read_only)
+            VALUES ($1, $2, $3, $4, $5, now() + ($6 || ' seconds')::interval, $7, $8, $9)",
         t_hash,
         t_prefix,
         plaintext as Option<&str>,
         email,
         "session",
         &MAX_SESSION_VALIDITY_SECONDS.to_string(),
-        super_admin
+        super_admin,
+        scopes,
+        read_only,
     )
     .execute(&mut **tx)
     .await?;
@@ -2146,6 +2159,8 @@ async fn create_token(
 ) -> Result<(StatusCode, String)> {
     check_token_create_rate_limit(&authed.username)?;
 
+    windmill_api_auth::ensure_scopes_within_caller(&authed, token_config.scopes.as_deref())?;
+
     let mut tx = db.begin().await?;
 
     let token = create_token_internal(&mut *tx, &db, &authed, token_config).await?;
@@ -2353,6 +2368,8 @@ async fn update_token_scopes(
     Path(token_prefix): Path<String>,
     Json(req): Json<UpdateTokenScopesRequest>,
 ) -> Result<String> {
+    windmill_api_auth::ensure_scopes_within_caller(&authed, req.scopes.as_deref())?;
+
     let mut tx = db.begin().await?;
 
     let updated: Option<String> = sqlx::query_scalar!(
diff --git a/backend/windmill-api-workspaces/src/workspaces.rs b/backend/windmill-api-workspaces/src/workspaces.rs
index 07ebcc7468..db60ae7fac 100644
--- a/backend/windmill-api-workspaces/src/workspaces.rs
+++ b/backend/windmill-api-workspaces/src/workspaces.rs
@@ -55,7 +55,10 @@ use windmill_common::{
 use windmill_dep_map::scoped_dependency_map::{
     DependencyDependent, DependencyMap, ScopedDependencyMap,
 };
-use windmill_git_sync::{handle_deployment_metadata, handle_fork_branch_creation, DeployedObject};
+use windmill_git_sync::{
+    handle_deployment_metadata, handle_deployment_metadata_batch, handle_fork_branch_creation,
+    DeployedObject,
+};
 use windmill_types::s3::LargeFileStorage;
 
 use hyper::StatusCode;
@@ -3403,6 +3406,7 @@ async fn set_encryption_key(
     .execute(&mut *tx)
     .await?;
 
+    let mut reencrypted_secret_paths: Vec<String> = Vec::new();
     if !request.skip_reencrypt.unwrap_or(false) {
         // Build the new cipher directly from the key string, since the transaction
         // hasn't committed yet and build_crypt() would read the old key from the pool.
@@ -3448,6 +3452,7 @@ async fn set_encryption_key(
             )
             .execute(&mut *tx)
             .await?;
+            reencrypted_secret_paths.push(variable.path);
         }
     }
 
@@ -3456,16 +3461,23 @@ async fn set_encryption_key(
     // Invalidate the cache only after the transaction has committed
     WORKSPACE_CRYPT_CACHE.remove(w_id.as_str());
 
-    // Trigger git sync for encryption key changes
-    handle_deployment_metadata(
+    // Build the batch: one event for the encryption key itself plus one per
+    // re-encrypted secret variable. The batch entrypoint dispatches a single
+    // git-sync job per repo carrying all items, so repos with Secrets sync
+    // enabled receive the new ciphertexts in one commit.
+    let mut batch: Vec<DeployedObject> = Vec::with_capacity(reencrypted_secret_paths.len() + 1);
+    batch.push(DeployedObject::Key { key_type: "encryption_key".to_string() });
+    for path in reencrypted_secret_paths {
+        batch.push(DeployedObject::Variable { path: path.clone(), parent_path: Some(path) });
+    }
+
+    handle_deployment_metadata_batch(
         &authed.email,
         &authed.username,
         &db,
         &w_id,
-        windmill_git_sync::DeployedObject::Key { key_type: "encryption_key".to_string() },
+        batch,
         Some("Encryption key updated".to_string()),
-        false,
-        None,
     )
     .await?;
 
diff --git a/backend/windmill-api/openapi.yaml b/backend/windmill-api/openapi.yaml
index fdec53098c..22014e1229 100644
--- a/backend/windmill-api/openapi.yaml
+++ b/backend/windmill-api/openapi.yaml
@@ -1,7 +1,7 @@
 openapi: "3.0.3"
 
 info:
-  version: 1.711.0
+  version: 1.714.0
   title: Windmill API
 
   contact:
@@ -9751,6 +9751,9 @@ paths:
                       type: boolean
                     deployment_message:
                       type: string
+                    skip_draft_deletion:
+                      type: boolean
+                      description: "When true (set by the CLI / git sync), deploying this flow does not delete an existing user draft at the same path."
       responses:
         "201":
           description: flow created
@@ -9792,6 +9795,9 @@ paths:
                   properties:
                     deployment_message:
                       type: string
+                    skip_draft_deletion:
+                      type: boolean
+                      description: "When true (set by the CLI / git sync), deploying this flow does not delete an existing user draft at the same path."
 
       responses:
         "200":
@@ -10290,6 +10296,9 @@ paths:
                   type: array
                   items:
                     type: string
+                skip_draft_deletion:
+                  type: boolean
+                  description: "When true (set by the CLI / git sync), deploying this app does not delete an existing user draft at the same path."
               required:
                 - path
                 - value
@@ -10342,6 +10351,9 @@ paths:
                       type: array
                       items:
                         type: string
+                    skip_draft_deletion:
+                      type: boolean
+                      description: "When true (set by the CLI / git sync), deploying this app does not delete an existing user draft at the same path."
                   required:
                     - path
                     - value
@@ -10660,6 +10672,9 @@ paths:
                   type: array
                   items:
                     type: string
+                skip_draft_deletion:
+                  type: boolean
+                  description: "When true (set by the CLI / git sync), deploying this app does not delete an existing user draft at the same path."
       responses:
         "200":
           description: app updated
@@ -10706,6 +10721,9 @@ paths:
                       type: array
                       items:
                         type: string
+                    skip_draft_deletion:
+                      type: boolean
+                      description: "When true (set by the CLI / git sync), deploying this app does not delete an existing user draft at the same path."
                 js:
                   type: string
                 css:
@@ -21952,6 +21970,9 @@ components:
           type: array
           items:
             type: string
+        skip_draft_deletion:
+          type: boolean
+          description: "When true (set by the CLI / git sync), deploying this script does not delete an existing user draft at the same path."
 
       required:
         - path
@@ -25475,6 +25496,11 @@ components:
           example: "Connection timeout"
         tag:
           $ref: "#/components/schemas/CustomInstanceDbTag"
+        used_by_workspaces:
+          type: array
+          items:
+            type: string
+          description: Workspaces that reference this database via a ducklake catalog or datatable database with resource_type 'instance'. Computed at request time, not persisted.
 
     NewSqsTrigger:
       type: object
diff --git a/backend/windmill-api/src/ai.rs b/backend/windmill-api/src/ai.rs
index 6956192f04..0e096eb798 100644
--- a/backend/windmill-api/src/ai.rs
+++ b/backend/windmill-api/src/ai.rs
@@ -11,13 +11,14 @@ use http::{HeaderMap, Method};
 use quick_cache::sync::Cache;
 use reqwest::{Client, RequestBuilder};
 use serde::{Deserialize, Serialize};
-use serde_json::{json, value::RawValue};
+use serde_json::value::RawValue;
 use std::collections::HashMap;
 use std::time::Duration;
 use windmill_ai::ai_cache::current_instance_ai_config_revision;
 use windmill_ai::ai_providers::{
     empty_string_as_none, AIPlatform, AIProvider, ProviderConfig, ProviderModel,
 };
+use windmill_ai::credentials::ProviderCredentials;
 #[cfg(feature = "bedrock")]
 use windmill_ai::providers::bedrock::{
     handle_bedrock_proxy, BedrockProxyResponse, BedrockProxyResponseBody,
@@ -30,10 +31,9 @@ use windmill_ai::providers::{
     },
 };
 use windmill_ai::proxy::{
-    proxy_execution_mode, supports_query_builder_proxy, ProviderCredentials, ProxyBuildArgs,
-    ProxyExecutionMode, ProxyRequest,
+    fim::maybe_transform_fim_request, proxy_execution_mode, ProxyBuildArgs, ProxyExecutionMode,
+    ProxyRequest,
 };
-use windmill_ai::utils::AI_HTTP_HEADERS;
 use windmill_audit::{audit_oss::audit_log, ActionKind};
 use windmill_common::db::UserDB;
 use windmill_common::error::{to_anyhow, Error, Result};
@@ -108,6 +108,13 @@ lazy_static::lazy_static! {
         .timeout(std::time::Duration::from_secs(*AI_TIMEOUT_SECS))
         .pool_max_idle_per_host(HTTP_POOL_MAX_IDLE_PER_HOST)
         .pool_idle_timeout(Some(std::time::Duration::from_secs(HTTP_POOL_IDLE_TIMEOUT_SECS)))
+        // The SSRF check in `get_base_url` only validates the configured `base_url`.
+        // reqwest follows up to 10 redirects by default and does not revalidate the
+        // hops, so a public base_url could 3xx the server into a private/internal
+        // address. Disable redirect following so the validated host is the only one
+        // we ever connect to. AI APIs respond directly and do not rely on redirects,
+        // so this holds even for ALLOW_PRIVATE_AI_BASE_URLS deployments.
+        .redirect(reqwest::redirect::Policy::none())
         .user_agent("windmill/beta"))
         .build()
         .expect("Failed to build AI HTTP client - check system TLS configuration");
@@ -298,6 +305,22 @@ async fn get_token_using_oauth(
     resource.client_id = resolve_var(resource.client_id, db, w_id, user_db, authed).await?;
     resource.client_secret = resolve_var(resource.client_secret, db, w_id, user_db, authed).await?;
     resource.token_url = resolve_var(resource.token_url, db, w_id, user_db, authed).await?;
+    // Validate the resolved token_url against SSRF rules before issuing the request,
+    // mirroring the protection applied to base_url in `get_base_url` (same
+    // ALLOW_PRIVATE_AI_BASE_URLS opt-in). Without this a workspace member could
+    // point token_url at an internal/metadata address.
+    if !*windmill_ai::ai_providers::ALLOW_PRIVATE_AI_BASE_URLS {
+        use windmill_common::ssrf::SsrfValidationError;
+        windmill_common::ssrf::validate_url_for_ssrf(&resource.token_url)
+            .await
+            .map_err(|e| match e {
+                e @ SsrfValidationError::Private { .. } => Error::BadRequest(format!(
+                    "{e}. If you need to use private/internal AI endpoints, \
+                     set the ALLOW_PRIVATE_AI_BASE_URLS=true environment variable"
+                )),
+                e => Error::from(e),
+            })?;
+    }
     let mut params = HashMap::new();
     params.insert("grant_type", "client_credentials");
     params.insert("scope", "https://cognitiveservices.azure.com/.default");
@@ -369,53 +392,6 @@ impl AIConfig {
     }
 }
 
-// FIM (Fill-in-the-Middle) simulation for providers that don't support native FIM
-#[derive(Deserialize, Debug)]
-struct FimRequest {
-    model: String,
-    prompt: String,         // code before cursor
-    suffix: Option<String>, // code after cursor
-    temperature: Option<f32>,
-    max_tokens: Option<u32>,
-    stop: Option<Vec<String>>,
-}
-
-/// Checks if the AI provider supports native FIM (Fill-in-the-Middle) endpoint
-fn supports_native_fim(provider: &AIProvider) -> bool {
-    matches!(provider, AIProvider::Mistral)
-}
-
-/// Transforms a FIM request to chat/completions format for providers that don't support native FIM.
-fn transform_fim_to_chat_completions(body: &Bytes) -> Result<(Bytes, String)> {
-    let fim_req: FimRequest = serde_json::from_slice(body)
-        .map_err(|e| Error::internal_err(format!("Failed to parse FIM request: {}", e)))?;
-
-    let suffix = fim_req.suffix.unwrap_or_default();
-
-    let system_prompt = "You are a code completion assistant. Complete the code at the <CURSOR/> position between the given prefix and suffix. Output ONLY the code that goes at the cursor - no explanations, no markdown, no repeating the prefix or suffix.";
-
-    let user_content = format!(
-        "<PREFIX>\n{}\n<CURSOR/>\n<SUFFIX>\n{}",
-        fim_req.prompt, suffix
-    );
-
-    let chat_req = json!({
-        "model": fim_req.model,
-        "messages": [
-            {"role": "system", "content": system_prompt},
-            {"role": "user", "content": user_content}
-        ],
-        "temperature": fim_req.temperature.unwrap_or(0.0),
-        "max_tokens": fim_req.max_tokens.unwrap_or(256),
-        "stop": fim_req.stop
-    });
-
-    let chat_body = serde_json::to_vec(&chat_req)
-        .map_err(|e| Error::internal_err(format!("Failed to serialize chat request: {}", e)))?;
-
-    Ok((Bytes::from(chat_body), "chat/completions".to_string()))
-}
-
 pub fn global_service() -> Router {
     Router::new().route("/proxy/{*ai}", post(global_proxy).get(global_proxy))
 }
@@ -455,6 +431,24 @@ fn proxy_request_to_request_builder(proxy_request: ProxyRequest) -> RequestBuild
     request.body(proxy_request.body)
 }
 
+async fn audit_global_ai_request(db: &DB, authed: &ApiAuthed) -> Result<()> {
+    let mut tx = db.begin().await?;
+
+    audit_log(
+        &mut *tx,
+        authed,
+        "ai.global_request",
+        ActionKind::Execute,
+        "global",
+        Some(&authed.email),
+        None,
+    )
+    .await?;
+    tx.commit().await?;
+
+    Ok(())
+}
+
 fn google_ai_proxy_response_to_body(
     response: GoogleAIProxyResponse,
 ) -> (http::StatusCode, HeaderMap, axum::body::Body) {
@@ -530,63 +524,78 @@ async fn global_proxy(
         return Err(Error::BadRequest("API key is required".to_string()));
     };
 
-    let base_url = provider.get_base_url(None, &db).await?;
+    let proxy_mode = proxy_execution_mode(&provider);
 
-    let request = if supports_query_builder_proxy(&provider) {
-        let credentials = ProviderCredentials {
-            provider: provider.clone(),
-            base_url,
-            api_key: Some(api_key.clone()),
-            access_token: None,
-            organization_id: None,
-            user: None,
-            region: None,
-            aws_access_key_id: None,
-            aws_secret_access_key: None,
-            aws_session_token: None,
-            platform: AIPlatform::Standard,
-            enable_1m_context: false,
-            custom_headers: HashMap::new(),
-        };
-        let query_builder = create_query_builder(&credentials);
-        let proxy_request = query_builder.build_proxy_request(&ProxyBuildArgs {
+    if matches!(proxy_mode, ProxyExecutionMode::NativeAwsBedrock) {
+        return Err(Error::BadRequest(
+            "AWS Bedrock global proxy is not supported; use a workspace AI resource with a region"
+                .to_string(),
+        ));
+    }
+
+    let base_url = provider.get_base_url(None, &db).await?;
+    let credentials = ProviderCredentials {
+        provider: provider.clone(),
+        base_url,
+        api_key: Some(api_key.clone()),
+        access_token: None,
+        organization_id: None,
+        user: None,
+        region: None,
+        aws_access_key_id: None,
+        aws_secret_access_key: None,
+        aws_session_token: None,
+        platform: AIPlatform::Standard,
+        enable_1m_context: false,
+        custom_headers: HashMap::new(),
+    };
+
+    if matches!(proxy_mode, ProxyExecutionMode::NativeGoogleAi) {
+        let proxy_args = ProxyBuildArgs {
             method: &method,
             path: &ai_path,
             headers: &headers,
             body: &body,
             credentials: &credentials,
-        })?;
-        proxy_request_to_request_builder(proxy_request)
-    } else {
-        let url = format!("{}/{}", base_url, ai_path);
-        let mut request = HTTP_CLIENT
-            .request(method, url)
-            .header("content-type", "application/json")
-            .header("Authorization", format!("Bearer {}", &api_key));
+        };
 
-        // Apply custom headers from AI_HTTP_HEADERS environment variable
-        for (header_name, header_value) in AI_HTTP_HEADERS.iter() {
-            request = request.header(header_name.as_str(), header_value.as_str());
+        audit_global_ai_request(&db, &authed).await?;
+
+        let response = match ai_path.as_str() {
+            "chat/completions" => handle_google_ai_chat_proxy(&HTTP_CLIENT, &proxy_args).await,
+            "models" => handle_google_ai_models_proxy(&HTTP_CLIENT, &proxy_args).await,
+            _ => Err(Error::BadRequest(format!(
+                "Unsupported Google AI path: {}",
+                ai_path
+            ))),
+        }?;
+
+        return Ok(google_ai_proxy_response_to_body(response));
+    }
+
+    let request = match proxy_mode {
+        ProxyExecutionMode::HttpForward => {
+            let query_builder = create_query_builder(&credentials);
+            let proxy_request = query_builder.build_proxy_request(&ProxyBuildArgs {
+                method: &method,
+                path: &ai_path,
+                headers: &headers,
+                body: &body,
+                credentials: &credentials,
+            })?;
+            proxy_request_to_request_builder(proxy_request)
+        }
+        ProxyExecutionMode::NativeGoogleAi | ProxyExecutionMode::NativeAwsBedrock => {
+            return Err(Error::BadRequest(format!(
+                "Unsupported global proxy mode for provider {:?}",
+                provider
+            )))
         }
-
-        request.body(body)
     };
 
     let response = request.send().await.map_err(to_anyhow)?;
 
-    let mut tx = db.begin().await?;
-
-    audit_log(
-        &mut *tx,
-        &authed,
-        "ai.global_request",
-        ActionKind::Execute,
-        "global",
-        Some(&authed.email),
-        None,
-    )
-    .await?;
-    tx.commit().await?;
+    audit_global_ai_request(&db, &authed).await?;
 
     if response.error_for_status_ref().is_err() {
         let err_msg = response.text().await.unwrap_or("".to_string());
@@ -641,7 +650,7 @@ async fn proxy(
         check_scopes(&authed, || format!("resources:read:{}", resource_path))?;
     }
 
-    let credentials = match workspace_cache {
+    let mut credentials = match workspace_cache {
         Some(request_cache) if !request_cache.is_expired() && forced_resource_path.is_none() => {
             request_cache.credentials
         }
@@ -772,17 +781,25 @@ async fn proxy(
         }
     };
 
-    // Check if this is a FIM request to a provider that doesn't support native FIM endpoint
-    // For such providers, transform to use FIM sentinel tokens with the chat/completions endpoint
-    let is_fim_request = ai_path.contains("fim/completions");
-    if is_fim_request && !supports_native_fim(&provider) {
-        tracing::debug!(
-            "Transforming FIM request to chat/completions with FIM tokens for provider {:?}",
-            provider
-        );
-        let (chat_body, chat_path) = transform_fim_to_chat_completions(&body)?;
-        body = chat_body;
-        ai_path = chat_path;
+    if let Some(fim_transform) =
+        maybe_transform_fim_request(&provider, &ai_path, &credentials.base_url, &body)?
+    {
+        if fim_transform.base_url.is_some() {
+            tracing::debug!(
+                "Routing native FIM request through provider-specific endpoint for {:?}",
+                provider
+            );
+        } else {
+            tracing::debug!(
+                "Transforming FIM request to chat/completions with FIM tokens for provider {:?}",
+                provider
+            );
+        }
+        if let Some(base_url) = fim_transform.base_url {
+            credentials.base_url = base_url;
+        }
+        body = fim_transform.body;
+        ai_path = fim_transform.path;
     }
 
     let proxy_mode = proxy_execution_mode(&provider);
diff --git a/backend/windmill-api/src/apps.rs b/backend/windmill-api/src/apps.rs
index c377203f38..de55cb87ff 100644
--- a/backend/windmill-api/src/apps.rs
+++ b/backend/windmill-api/src/apps.rs
@@ -306,6 +306,11 @@ pub struct CreateApp {
     pub preserve_on_behalf_of: Option<bool>,
     #[serde(default)]
     pub labels: Option<Vec<String>>,
+    /// Caller-intent flag (set by the CLI / git sync): when true, deploying
+    /// this app must NOT delete an existing user draft at the same path.
+    /// Transient — never persisted.
+    #[serde(default, skip_serializing_if = "Option::is_none")]
+    pub skip_draft_deletion: Option<bool>,
 }
 
 #[derive(Serialize, Deserialize)]
@@ -319,6 +324,11 @@ pub struct EditApp {
     pub preserve_on_behalf_of: Option<bool>,
     #[serde(default)]
     pub labels: Option<Vec<String>>,
+    /// Caller-intent flag (set by the CLI / git sync): when true, deploying
+    /// this app must NOT delete an existing user draft at the same path.
+    /// Transient — never persisted.
+    #[serde(default, skip_serializing_if = "Option::is_none")]
+    pub skip_draft_deletion: Option<bool>,
 }
 
 #[derive(Serialize, FromRow)]
@@ -1338,13 +1348,17 @@ async fn create_app_internal<'a>(
             ));
         }
     }
-    sqlx::query!(
-        "DELETE FROM draft WHERE path = $1 AND workspace_id = $2 AND typ = 'app'",
-        &app.path,
-        &w_id
-    )
-    .execute(&mut *tx)
-    .await?;
+    // CLI / git-sync deploys ask us to preserve any existing user draft at this
+    // path instead of wiping it as part of the deploy.
+    if !app.skip_draft_deletion.unwrap_or(false) {
+        sqlx::query!(
+            "DELETE FROM draft WHERE path = $1 AND workspace_id = $2 AND typ = 'app'",
+            &app.path,
+            &w_id
+        )
+        .execute(&mut *tx)
+        .await?;
+    }
     let id = sqlx::query_scalar!(
         "INSERT INTO app
             (workspace_id, path, summary, policy, versions, draft_only, custom_path, labels)
@@ -1943,13 +1957,17 @@ async fn update_app_internal<'a>(
             )));
         }
     };
-    sqlx::query!(
-        "DELETE FROM draft WHERE path = $1 AND workspace_id = $2 AND typ = 'app'",
-        path,
-        &w_id
-    )
-    .execute(&mut *tx)
-    .await?;
+    // CLI / git-sync deploys ask us to preserve any existing user draft at this
+    // path instead of wiping it as part of the deploy.
+    if !ns.skip_draft_deletion.unwrap_or(false) {
+        sqlx::query!(
+            "DELETE FROM draft WHERE path = $1 AND workspace_id = $2 AND typ = 'app'",
+            path,
+            &w_id
+        )
+        .execute(&mut *tx)
+        .await?;
+    }
     audit_log(
         &mut *tx,
         &authed,
diff --git a/backend/windmill-api/src/jobs.rs b/backend/windmill-api/src/jobs.rs
index 875a1e80d2..71f9645272 100644
--- a/backend/windmill-api/src/jobs.rs
+++ b/backend/windmill-api/src/jobs.rs
@@ -7107,7 +7107,11 @@ pub async fn run_job_by_hash_inner(
     Ok((uuid, delete_after_use, delete_after_secs))
 }
 
-async fn get_log_file(Path((_w_id, file_p)): Path<(String, String)>) -> error::Result<Response> {
+async fn get_log_file(
+    OptAuthed(opt_authed): OptAuthed,
+    Extension(db): Extension<DB>,
+    Path((w_id, file_p)): Path<(String, String)>,
+) -> error::Result<Response> {
     if file_p.contains("..") {
         return Err(error::Error::BadRequest("Invalid path".to_string()));
     }
@@ -7119,27 +7123,58 @@ async fn get_log_file(Path((_w_id, file_p)): Path<(String, String)>) -> error::R
             "Invalid path: must have exactly 2 components".to_string(),
         ));
     }
-    if Uuid::parse_str(parts[0]).is_err() {
-        return Err(error::Error::BadRequest(
-            "Invalid path: first component must be a valid UUID".to_string(),
-        ));
-    }
+    let job_id = Uuid::parse_str(parts[0]).map_err(|_| {
+        error::Error::BadRequest("Invalid path: first component must be a valid UUID".to_string())
+    })?;
     if !parts[1].ends_with(".txt") {
         return Err(error::Error::BadRequest(
             "Invalid path: file must end with .txt".to_string(),
         ));
     }
 
+    // Authorization: the log file directory is the job id, so gate access the same
+    // way as get_job_logs — the caller must be able to read the job. Non-logged-in
+    // callers may only read logs of jobs created by the anonymous user.
+    let tags = opt_authed
+        .as_ref()
+        .map(|authed| get_scope_tags(authed).map(|v| v.iter().map(|s| s.to_string()).collect_vec()))
+        .flatten();
+    let created_by = sqlx::query_scalar!(
+        "SELECT created_by FROM v2_job WHERE id = $1 AND workspace_id = $2 AND ($3::text[] IS NULL OR tag = ANY($3))",
+        job_id,
+        w_id,
+        tags.as_ref().map(|v| v.as_slice())
+    )
+    .fetch_optional(&db)
+    .await?
+    .ok_or_else(|| error::Error::NotFound(format!("Job {job_id} not found")))?;
+    if opt_authed.is_none() && created_by != "anonymous" {
+        return Err(error::Error::BadRequest(
+            "As a non logged in user, you can only see jobs ran by anonymous users".to_string(),
+        ));
+    }
+
     let local_file = format!("{}/logs/{file_p}", *WINDMILL_DIR);
-    if tokio::fs::metadata(&local_file).await.is_ok() {
-        let mut file = tokio::fs::File::open(local_file).await.map_err(to_anyhow)?;
-        let mut buffer = Vec::new();
-        file.read_to_end(&mut buffer).await.map_err(to_anyhow)?;
-        let res = Response::builder()
-            .header(http::header::CONTENT_TYPE, "text/plain")
-            .body(Body::from(bytes::Bytes::from(buffer)))
-            .unwrap();
-        return Ok(res);
+    // SECURITY (defense in depth): refuse to read through a symlink so a planted
+    // symlink in the logs directory cannot be used to exfiltrate arbitrary files.
+    // `symlink_metadata` returns the link's own metadata without following it.
+    match tokio::fs::symlink_metadata(&local_file).await {
+        Ok(meta) if meta.file_type().is_symlink() => {
+            return Err(error::Error::BadRequest("Invalid path".to_string()));
+        }
+        Ok(_) => {
+            let mut file = tokio::fs::File::open(&local_file)
+                .await
+                .map_err(to_anyhow)?;
+            let mut buffer = Vec::new();
+            file.read_to_end(&mut buffer).await.map_err(to_anyhow)?;
+            let res = Response::builder()
+                .header(http::header::CONTENT_TYPE, "text/plain")
+                .body(Body::from(bytes::Bytes::from(buffer)))
+                .unwrap();
+            return Ok(res);
+        }
+        Err(_) => {}
     }
 
     #[cfg(all(feature = "enterprise", feature = "parquet"))]
diff --git a/backend/windmill-api/src/service_logs.rs b/backend/windmill-api/src/service_logs.rs
index 57131d823e..b1902f7c1a 100644
--- a/backend/windmill-api/src/service_logs.rs
+++ b/backend/windmill-api/src/service_logs.rs
@@ -133,7 +133,18 @@ async fn get_log_file(
             }
         }
     }
-    let file = tokio::fs::read(format!("{}{}", *TMP_WINDMILL_LOGS_SERVICE, path)).await;
+    let full_path = format!("{}{}", *TMP_WINDMILL_LOGS_SERVICE, path);
+    // SECURITY (defense in depth): refuse to read through a symlink so a planted
+    // symlink in the logs directory cannot be used to exfiltrate arbitrary files.
+    // `symlink_metadata` returns the link's own metadata without following it.
+    match tokio::fs::symlink_metadata(&full_path).await {
+        Ok(meta) if meta.file_type().is_symlink() => {
+            return Err(Error::BadRequest("Invalid path".to_string()));
+        }
+        Ok(_) => {}
+        Err(_) => return Err(Error::NotFound(format!("File {path} not found"))),
+    }
+    let file = tokio::fs::read(&full_path).await;
     if let Ok(bytes) = file {
         Ok(content_plain(Body::from(bytes::Bytes::from(bytes))))
     } else {
diff --git a/backend/windmill-api/src/static_assets.rs b/backend/windmill-api/src/static_assets.rs
index 2b93d59bc0..35728bc693 100644
--- a/backend/windmill-api/src/static_assets.rs
+++ b/backend/windmill-api/src/static_assets.rs
@@ -39,23 +39,43 @@ pub struct StaticFile(Uri);
 impl IntoResponse for StaticFile {
     fn into_response(self) -> Response<Body> {
         let original_path = self.0.path();
+        let query = self.0.query();
         let path = original_path.trim_start_matches('/');
-        serve_path(path, original_path)
+        serve_path(path, original_path, query)
     }
 }
 
 #[cfg(feature = "static_frontend")]
 const TWO_HUNDRED: &str = "200.html";
 
-/// Check if the original path requires cross-origin isolation headers
+/// Check if the original path requires cross-origin isolation headers.
+///
 /// These headers are needed for SharedArrayBuffer and TypeScript workers
-/// Only enabled for /apps_raw paths (raw app editor)
+/// (raw app editor at `/apps_raw/`, in-browser bundler at `/ui_builder/`).
+///
+/// Public apps (`/public/` and custom paths `/a/`) opt in via the `wm_coep`
+/// query param: a public (raw) app must set COEP to be embeddable as an iframe
+/// inside a cross-origin-isolated page (which requires the embedded document to
+/// also set COEP). It is opt-in rather than always-on because cross-origin
+/// isolation also blocks subresources without CORP (e.g. external image URLs
+/// or embeds used by classic apps), so we only enable it when the embedder
+/// explicitly requests it.
 #[cfg(feature = "static_frontend")]
-fn needs_cross_origin_isolation(original_path: &str) -> bool {
-    original_path.starts_with("/apps_raw/") || original_path.starts_with("/ui_builder/")
+fn needs_cross_origin_isolation(original_path: &str, query: Option<&str>) -> bool {
+    original_path.starts_with("/apps_raw/")
+        || original_path.starts_with("/ui_builder/")
+        || ((original_path.starts_with("/public/") || original_path.starts_with("/a/"))
+            && query_has_flag(query, "wm_coep"))
 }
 
-fn serve_path(path: &str, original_path: &str) -> Response<Body> {
+/// Returns true if `query` contains the given flag key (with or without a
+/// value), e.g. `?wm_coep`, `?wm_coep=on`, `?foo=1&wm_coep=1`.
+#[cfg(feature = "static_frontend")]
+fn query_has_flag(query: Option<&str>, flag: &str) -> bool {
+    query.is_some_and(|q| q.split('&').any(|kv| kv.split('=').next() == Some(flag)))
+}
+
+fn serve_path(path: &str, original_path: &str, query: Option<&str>) -> Response<Body> {
     if path.starts_with("api/") {
         return Response::builder().status(404).body(Body::empty()).unwrap();
     }
@@ -71,7 +91,7 @@ fn serve_path(path: &str, original_path: &str) -> Response<Body> {
 
             // Add cross-origin isolation headers only for paths that need them
             // (apps_raw editor needs SharedArrayBuffer for TypeScript workers)
-            if needs_cross_origin_isolation(original_path) {
+            if needs_cross_origin_isolation(original_path, query) {
                 res = res
                     .header("Cross-Origin-Opener-Policy", "same-origin")
                     .header("Cross-Origin-Embedder-Policy", "require-corp")
@@ -102,12 +122,68 @@ fn serve_path(path: &str, original_path: &str) -> Response<Body> {
         None if path.starts_with("_app/") => {
             Response::builder().status(404).body(Body::empty()).unwrap()
         }
-        None => serve_path(TWO_HUNDRED, original_path),
+        None => serve_path(TWO_HUNDRED, original_path, query),
     }
 
     #[cfg(not(feature = "static_frontend"))]
     {
-        let _ = original_path; // suppress unused warning
+        let _ = (original_path, query); // suppress unused warning
         Response::builder().status(404).body(Body::empty()).unwrap()
     }
 }
+
+#[cfg(all(test, feature = "static_frontend"))]
+mod tests {
+    use super::*;
+
+    #[test]
+    fn test_query_has_flag() {
+        assert!(query_has_flag(Some("wm_coep"), "wm_coep"));
+        assert!(query_has_flag(Some("wm_coep=on"), "wm_coep"));
+        assert!(query_has_flag(Some("foo=1&wm_coep=1"), "wm_coep"));
+        assert!(query_has_flag(Some("wm_coep&foo=1"), "wm_coep"));
+        assert!(!query_has_flag(Some("wm_coepx=1"), "wm_coep"));
+        assert!(!query_has_flag(Some("foo=wm_coep"), "wm_coep"));
+        assert!(!query_has_flag(Some(""), "wm_coep"));
+        assert!(!query_has_flag(None, "wm_coep"));
+    }
+
+    #[test]
+    fn test_needs_cross_origin_isolation() {
+        // editor + bundler are always isolated, regardless of query
+        assert!(needs_cross_origin_isolation("/apps_raw/edit/foo", None));
+        assert!(needs_cross_origin_isolation("/ui_builder/index.html", None));
+
+        // public apps (and custom paths) are isolated only when they opt in via wm_coep
+        assert!(needs_cross_origin_isolation(
+            "/public/ws/secret",
+            Some("wm_coep")
+        ));
+        assert!(needs_cross_origin_isolation(
+            "/public/ws/secret",
+            Some("wm_coep=on")
+        ));
+        assert!(needs_cross_origin_isolation(
+            "/a/ws/my/path",
+            Some("wm_coep=on")
+        ));
+        assert!(!needs_cross_origin_isolation("/public/ws/secret", None));
+        assert!(!needs_cross_origin_isolation("/a/ws/my/path", None));
+        assert!(!needs_cross_origin_isolation(
+            "/public/ws/secret",
+            Some("foo=1")
+        ));
+
+        // unrelated paths never get the headers
+        assert!(!needs_cross_origin_isolation(
+            "/apps/get/foo",
+            Some("wm_coep")
+        ));
+        // `/api/` must not be caught by the `/a/` prefix
+        assert!(!needs_cross_origin_isolation(
+            "/api/version",
+            Some("wm_coep")
+        ));
+        assert!(!needs_cross_origin_isolation("/", None));
+    }
+}
diff --git a/backend/windmill-api/src/users.rs b/backend/windmill-api/src/users.rs
index 58871866b1..d53998355b 100644
--- a/backend/windmill-api/src/users.rs
+++ b/backend/windmill-api/src/users.rs
@@ -484,13 +484,13 @@ async fn update_username_in_workpsace<'c>(
     ).execute(&mut **tx)
     .await?;
 
-    sqlx::query!(
-        r#"UPDATE workspace_runnable_dependencies SET app_path = REGEXP_REPLACE(app_path,'u/' || $2 || '/(.*)','u/' || $1 || '/\1') WHERE app_path LIKE ('u/' || $2 || '/%') AND workspace_id = $3"#,
-        new_username,
-        old_username,
-        w_id
-    ).execute(&mut **tx)
-    .await?;
+    // NB: workspace_runnable_dependencies.app_path is intentionally NOT rewritten here.
+    // Its FK to app(path, workspace_id) is ON UPDATE CASCADE, so the `UPDATE app SET path`
+    // below propagates the new path automatically. Rewriting it manually here (before the
+    // app row is renamed) points the row at a not-yet-existing app path and violates
+    // fk_workspace_runnable_dependencies_app_path. (flow_path above DOES need the manual
+    // rewrite because flows are migrated via INSERT-new + DELETE-old, not UPDATE flow.path,
+    // so the cascade never fires for them.)
 
     sqlx::query!(
         r#"UPDATE workspace_runnable_dependencies SET runnable_path = REGEXP_REPLACE(runnable_path,'u/' || $2 || '/(.*)','u/' || $1 || '/\1') WHERE runnable_path LIKE ('u/' || $2 || '/%') AND workspace_id = $3"#,
diff --git a/backend/windmill-common/src/instance_config.rs b/backend/windmill-common/src/instance_config.rs
index 1872b52140..2239868982 100644
--- a/backend/windmill-common/src/instance_config.rs
+++ b/backend/windmill-common/src/instance_config.rs
@@ -586,6 +586,21 @@ pub struct OAuthConfig {
     pub req_body_auth: Option<bool>,
     #[serde(default, skip_serializing_if = "Vec::is_empty")]
     pub grant_types: Vec<String>,
+    /// Optional URL overrides for the provider's sandbox environment.
+    #[serde(skip_serializing_if = "Option::is_none")]
+    pub sandbox: Option<OAuthSandboxOverride>,
+}
+
+/// URL overrides for an OAuth provider's sandbox environment.
+#[derive(Deserialize, Serialize, Clone, Debug, Default)]
+#[cfg_attr(feature = "instance_config_schema", derive(schemars::JsonSchema))]
+pub struct OAuthSandboxOverride {
+    #[serde(skip_serializing_if = "Option::is_none")]
+    pub auth_url: Option<String>,
+    #[serde(skip_serializing_if = "Option::is_none")]
+    pub token_url: Option<String>,
+    #[serde(skip_serializing_if = "Option::is_none")]
+    pub userinfo_url: Option<String>,
 }
 
 // ---------------------------------------------------------------------------
diff --git a/backend/windmill-common/src/lib.rs b/backend/windmill-common/src/lib.rs
index 4b6abac8dd..7d74822807 100644
--- a/backend/windmill-common/src/lib.rs
+++ b/backend/windmill-common/src/lib.rs
@@ -283,6 +283,24 @@ pub async fn shutdown_signal(
         Ok(())
     }
 
+    // Defined for the whole non-unix scope (not just windows) so it can be a
+    // plain `tokio::select!` branch: that macro does not accept `#[cfg(...)]`
+    // attributes on individual branches. On non-windows non-unix targets the
+    // future never resolves, so the branch is effectively inert there.
+    #[cfg(not(any(target_os = "linux", target_os = "macos")))]
+    async fn ctrl_break() -> std::io::Result<()> {
+        #[cfg(windows)]
+        {
+            tokio::signal::windows::ctrl_break()?.recv().await;
+            Ok(())
+        }
+        #[cfg(not(windows))]
+        {
+            std::future::pending::<()>().await;
+            Ok(())
+        }
+    }
+
     #[cfg(any(target_os = "linux", target_os = "macos"))]
     tokio::select! {
         _ = terminate() => {
@@ -298,7 +316,12 @@ pub async fn shutdown_signal(
 
     #[cfg(not(any(target_os = "linux", target_os = "macos")))]
     tokio::select! {
-        _ = tokio::signal::ctrl_c() => {},
+        _ = tokio::signal::ctrl_c() => {
+            tracing::info!("shutdown monitor received ctrl-c");
+        },
+        _ = ctrl_break() => {
+            tracing::info!("shutdown monitor received ctrl-break");
+        },
         _ = rx.recv() => {
             tracing::info!("shutdown monitor received killpill");
         },
@@ -320,6 +343,9 @@ pub async fn shutdown_signal(
             _ = tokio::signal::ctrl_c() => {
                 tracing::error!("2nd shutdown monitor received ctrl-c")
             },
+            _ = ctrl_break() => {
+                tracing::error!("2nd shutdown monitor received ctrl-break")
+            },
         }
 
         tracing::info!("Second terminate signal received, forcefully exiting");
diff --git a/backend/windmill-common/src/scripts.rs b/backend/windmill-common/src/scripts.rs
index dd4c0bb42e..38cd444f29 100644
--- a/backend/windmill-common/src/scripts.rs
+++ b/backend/windmill-common/src/scripts.rs
@@ -393,6 +393,7 @@ pub async fn clone_script<'c>(
         modules: s.modules,
         auto_parent: None,
         labels: s.labels,
+        skip_draft_deletion: None,
     };
 
     let new_hash = hash_script(&ns);
diff --git a/backend/windmill-common/src/worker.rs b/backend/windmill-common/src/worker.rs
index 5a7c6d2bfa..92ebf08477 100644
--- a/backend/windmill-common/src/worker.rs
+++ b/backend/windmill-common/src/worker.rs
@@ -252,6 +252,17 @@ lazy_static::lazy_static! {
     pub static ref WORKSPACE_FAIRNESS_OVERLOADED: arc_swap::ArcSwap<Vec<String>> = arc_swap::ArcSwap::from_pointee(vec![]);
     pub static ref WORKSPACE_FAIRNESS_LAST_REFRESH_MICROS: AtomicI64 = AtomicI64::new(0);
 
+    /// Stochastic admission probability for capped workspaces, expressed in
+    /// parts per 10_000 (so `420` = 4.2%). The refresh computes this from the
+    /// observed worker-second distribution and the configured cap so that
+    /// admission converges to the target *worker-second* share — independent
+    /// of how the capped vs uncapped workspaces compare on per-job durations.
+    /// See `workspace_fairness_ee::refresh_overloaded` for the derivation.
+    /// `10_000` (= admit all) is the default until the first refresh
+    /// classifies an overloaded set — before that, no workspace is capped so
+    /// `should_admit_capped` is moot and "admit all" is the correct no-op.
+    pub static ref WORKSPACE_FAIRNESS_ADMISSION_PPM: AtomicU32 = AtomicU32::new(10_000);
+
 
     pub static ref SMTP_CONFIG: arc_swap::ArcSwap<Option<Smtp>> = arc_swap::ArcSwap::from_pointee(None);
     pub static ref INDEXER_CONFIG: arc_swap::ArcSwap<TantivyIndexerSettings> = arc_swap::ArcSwap::from_pointee(TantivyIndexerSettings::default());
diff --git a/backend/windmill-common/src/workspaces.rs b/backend/windmill-common/src/workspaces.rs
index e81a24817f..e20a896103 100644
--- a/backend/windmill-common/src/workspaces.rs
+++ b/backend/windmill-common/src/workspaces.rs
@@ -157,7 +157,7 @@ pub enum ObjectType {
     WorkspaceDependencies,
 }
 
-pub const LATEST_GIT_SYNC_SCRIPT_PATH: &str = "hub/28236/sync-script-to-git-repo-windmill";
+pub const LATEST_GIT_SYNC_SCRIPT_PATH: &str = "hub/28261/sync-script-to-git-repo-windmill";
 
 /// Prefix used to identify fork workspaces. A workspace whose id starts with this string is a
 /// fork of another workspace.
diff --git a/backend/windmill-git-sync/src/git_sync_oss.rs b/backend/windmill-git-sync/src/git_sync_oss.rs
index ee2c09cf16..a4f82aba2e 100644
--- a/backend/windmill-git-sync/src/git_sync_oss.rs
+++ b/backend/windmill-git-sync/src/git_sync_oss.rs
@@ -33,3 +33,15 @@ pub async fn handle_fork_branch_creation<'c>(
 ) -> Result<Vec<uuid::Uuid>> {
     return Ok(vec![]);
 }
+
+#[cfg(not(feature = "private"))]
+pub async fn handle_deployment_metadata_batch<'c>(
+    _email: &str,
+    _created_by: &str,
+    _db: &DB,
+    _w_id: &str,
+    _objs: Vec<DeployedObject>,
+    _deployment_message: Option<String>,
+) -> Result<()> {
+    return Ok(());
+}
diff --git a/backend/windmill-git-sync/src/lib.rs b/backend/windmill-git-sync/src/lib.rs
index efbc562cf9..b10f62e7a5 100644
--- a/backend/windmill-git-sync/src/lib.rs
+++ b/backend/windmill-git-sync/src/lib.rs
@@ -13,10 +13,14 @@ pub mod git_sync_ee;
 pub mod git_sync_oss;
 
 #[cfg(feature = "private")]
-pub use git_sync_ee::{handle_deployment_metadata, handle_fork_branch_creation};
+pub use git_sync_ee::{
+    handle_deployment_metadata, handle_deployment_metadata_batch, handle_fork_branch_creation,
+};
 
 #[cfg(not(feature = "private"))]
-pub use git_sync_oss::{handle_deployment_metadata, handle_fork_branch_creation};
+pub use git_sync_oss::{
+    handle_deployment_metadata, handle_deployment_metadata_batch, handle_fork_branch_creation,
+};
 
 #[derive(Clone, Debug)]
 pub enum DeployedObject {
diff --git a/backend/windmill-oauth/src/lib.rs b/backend/windmill-oauth/src/lib.rs
index ea65a83ba4..874a859200 100644
--- a/backend/windmill-oauth/src/lib.rs
+++ b/backend/windmill-oauth/src/lib.rs
@@ -18,9 +18,7 @@ use std::collections::HashMap;
 use std::fmt::Debug;
 
 use anyhow::anyhow;
-use base64::Engine;
 use hmac::Mac;
-use itertools::Itertools;
 use serde::{de::DeserializeOwned, Deserialize, Serialize};
 use sqlx::{Postgres, Transaction};
 use tower_cookies::{Cookie, Cookies};
@@ -89,6 +87,76 @@ pub struct OAuthConfig {
     pub req_body_auth: Option<bool>,
     #[serde(default = "default_grant_types")]
     pub grant_types: Vec<String>,
+    /// Optional URL overrides for the provider's sandbox environment. When
+    /// present and the admin has configured a `<name>_sandbox` credentials
+    /// entry, `build_oauth_clients` registers a second client under that key.
+    #[serde(skip_serializing_if = "Option::is_none")]
+    pub sandbox: Option<OAuthSandboxOverride>,
+}
+
+/// URL overrides for an OAuth provider's sandbox environment. Inherits
+/// scopes, extra_params, etc. from the parent [`OAuthConfig`].
+#[derive(Clone, Debug, Default, Serialize, Deserialize)]
+pub struct OAuthSandboxOverride {
+    #[serde(skip_serializing_if = "Option::is_none")]
+    pub auth_url: Option<String>,
+    #[serde(skip_serializing_if = "Option::is_none")]
+    pub token_url: Option<String>,
+    #[serde(skip_serializing_if = "Option::is_none")]
+    pub userinfo_url: Option<String>,
+}
+
+impl OAuthConfig {
+    /// Returns a copy of this config with sandbox URL overrides applied and
+    /// the nested `sandbox` field cleared. Returns `None` if no overrides are
+    /// set.
+    pub fn as_sandbox(&self) -> Option<OAuthConfig> {
+        let sb = self.sandbox.as_ref()?;
+        let mut out = self.clone();
+        out.sandbox = None;
+        if let Some(u) = &sb.auth_url {
+            out.auth_url = u.clone();
+        }
+        if let Some(u) = &sb.token_url {
+            out.token_url = u.clone();
+        }
+        if sb.userinfo_url.is_some() {
+            out.userinfo_url = sb.userinfo_url.clone();
+        }
+        Some(out)
+    }
+}
+
+/// Suffix appended to a provider name to identify its sandbox variant in the
+/// instance credentials map and in `account.client`.
+pub const SANDBOX_SUFFIX: &str = "_sandbox";
+
+/// Strips [`SANDBOX_SUFFIX`] from a client name, returning the canonical
+/// provider name. Returns the input unchanged if no suffix is present.
+pub fn canonical_provider_name(client_name: &str) -> &str {
+    client_name
+        .strip_suffix(SANDBOX_SUFFIX)
+        .unwrap_or(client_name)
+}
+
+/// Resolves a registry [`OAuthConfig`] for `client_name`, transparently
+/// applying the `sandbox` override block when the name carries the sandbox
+/// suffix (e.g. `docusign_sandbox` resolves to `docusign` with sandbox URLs
+/// applied). Used so callers don't need to know whether a name is a sandbox
+/// variant before looking it up.
+pub fn resolve_registry_config(
+    static_configs: &HashMap<String, OAuthConfig>,
+    client_name: &str,
+) -> Option<OAuthConfig> {
+    if let Some(cfg) = static_configs.get(client_name) {
+        return Some(cfg.clone());
+    }
+    if client_name.ends_with(SANDBOX_SUFFIX) {
+        return static_configs
+            .get(canonical_provider_name(client_name))
+            .and_then(|cfg| cfg.as_sandbox());
+    }
+    None
 }
 
 /// OAuth client credentials
@@ -181,181 +249,6 @@ pub struct OAuthCallback {
     pub state: String,
 }
 
-/// Build all OAuth clients from configuration
-pub async fn build_oauth_clients(
-    base_url: &str,
-    oauths_from_config: Option<HashMap<String, OAuthClient>>,
-    connect_configs_json: &str,
-    login_configs_json: &str,
-) -> anyhow::Result<AllClients> {
-    let connect_configs =
-        serde_json::from_str::<HashMap<String, OAuthConfig>>(connect_configs_json)?;
-    let login_configs = serde_json::from_str::<HashMap<String, OAuthConfig>>(login_configs_json)?;
-
-    let oauths = if let Some(oauths) = oauths_from_config {
-        tracing::info!("Using OAuth clients from config: {oauths:?}");
-        oauths
-    } else {
-        let path = "./oauth.json";
-        let content: String = if let Ok(e) = std::env::var("OAUTH_JSON_AS_BASE64") {
-            std::str::from_utf8(
-                &base64::engine::general_purpose::STANDARD
-                    .decode(e)
-                    .map_err(to_anyhow)?,
-            )?
-            .to_string()
-        } else if std::path::Path::new(path).exists() {
-            std::fs::read_to_string(path).map_err(to_anyhow)?
-        } else {
-            tracing::warn!("oauth.json not found, no OAuth clients loaded");
-            return Ok(AllClients {
-                logins: HashMap::new(),
-                connects: HashMap::new(),
-                slack: None,
-            });
-        };
-
-        if content.is_empty() {
-            tracing::warn!("oauth.json is empty, no OAuth clients loaded");
-            return Ok(AllClients {
-                logins: HashMap::new(),
-                connects: HashMap::new(),
-                slack: None,
-            });
-        };
-        match serde_json::from_str::<HashMap<String, OAuthClient>>(&content) {
-            Ok(clients) => clients,
-            Err(e) => {
-                tracing::error!("deserializing oauth.json: {e}");
-                HashMap::new()
-            }
-        }
-        .into_iter()
-        .collect()
-    };
-
-    tracing::info!("OAuth loaded clients: {}", oauths.keys().join(", "));
-
-    let logins = login_configs
-        .into_iter()
-        .filter_map(|x| oauths.get(&x.0).map(|c| (x.0, (c, x.1))))
-        .chain(oauths.iter().filter_map(|x| {
-            x.1.login_config
-                .as_ref()
-                .map(|c| (x.0.clone(), (x.1, c.clone())))
-        }))
-        .filter_map(|(k, (client_params, config))| {
-            let named_client = build_basic_client(
-                k.clone(),
-                config.clone(),
-                client_params.clone(),
-                true,
-                base_url,
-                None,
-            );
-            named_client
-                .map(|named_client| {
-                    (
-                        named_client.0,
-                        ClientWithScopes {
-                            client: named_client.1,
-                            scopes: config.scopes.unwrap_or(vec![]),
-                            extra_params: config.extra_params,
-                            extra_params_callback: config.extra_params_callback,
-                            allowed_domains: client_params.allowed_domains.clone(),
-                            userinfo_url: config.userinfo_url,
-                            display_name: client_params.display_name.clone(),
-                            grant_types: client_params.grant_types.clone(),
-                        },
-                    )
-                })
-                .map_err(|e| {
-                    tracing::error!("Error building oauth client {k}: {e}");
-                    e
-                })
-                .ok()
-        })
-        .collect();
-
-    let connects = connect_configs
-        .into_iter()
-        .filter_map(|x| oauths.get(&x.0).map(|c| (x.0, (c, x.1))))
-        .chain(oauths.iter().filter_map(|x| {
-            x.1.connect_config
-                .as_ref()
-                .map(|c| (x.0.clone(), (x.1, c.clone())))
-        }))
-        .filter_map(|(k, (client_params, config))| {
-            let named_client = build_basic_client(
-                k.clone(),
-                config.clone(),
-                client_params.clone(),
-                false,
-                base_url,
-                if k == "supabase_wizard" {
-                    Some(format!("{base_url}/oauth/callback_supabase"))
-                } else {
-                    None
-                },
-            );
-            named_client
-                .map(|named_client| {
-                    (
-                        named_client.0,
-                        ClientWithScopes {
-                            client: named_client.1,
-                            scopes: config.scopes.unwrap_or(vec![]),
-                            extra_params: config.extra_params,
-                            extra_params_callback: config.extra_params_callback,
-                            allowed_domains: None,
-                            userinfo_url: None,
-                            display_name: client_params.display_name.clone(),
-                            grant_types: client_params.grant_types.clone(),
-                        },
-                    )
-                })
-                .map_err(|e| {
-                    tracing::error!("Error building oauth client {k}: {e}");
-                    e
-                })
-                .ok()
-        })
-        .collect();
-
-    let slack = oauths
-        .get("slack")
-        .map(|v| {
-            build_basic_client(
-                "slack".to_string(),
-                OAuthConfig {
-                    auth_url: "https://slack.com/oauth/v2/authorize".to_string(),
-                    token_url: "https://slack.com/api/oauth.v2.access".to_string(),
-                    userinfo_url: None,
-                    scopes: None,
-                    extra_params: None,
-                    extra_params_callback: None,
-                    req_body_auth: None,
-                    grant_types: vec!["authorization_code".to_string()],
-                },
-                v.clone(),
-                false,
-                base_url,
-                Some(format!("{base_url}/oauth/callback_slack")),
-            )
-            .map(|x| x.1)
-            .map_err(|e| {
-                tracing::error!("Error building oauth slack client: {e}");
-                e
-            })
-            .ok()
-        })
-        .flatten();
-
-    let all_clients = AllClients { logins, connects, slack };
-    tracing::debug!("Final oauth config: {all_clients:#?}");
-    Ok(all_clients)
-}
-
 /// Build a basic OAuth client from configuration
 pub fn build_basic_client(
     name: String,
@@ -433,38 +326,29 @@ pub async fn build_client_credentials_oauth_client(
     let oauth_client_config: OAuthClient = serde_json::from_value(oauth_config.clone())
         .map_err(|e| error::Error::BadRequest(format!("Invalid OAuth config: {}", e)))?;
 
-    let mut connect_config = if let Some(ref config) = oauth_client_config.connect_config {
-        if !config.auth_url.is_empty() && !config.token_url.is_empty() {
-            config.clone()
-        } else {
-            let static_configs =
-                serde_json::from_str::<HashMap<String, OAuthConfig>>(connect_configs_json)
-                    .map_err(|e| {
-                        error::Error::InternalErr(format!(
-                            "Failed to parse oauth_connect.json: {}",
-                            e
-                        ))
-                    })?;
-
-            static_configs.get(client_name).cloned().ok_or_else(|| {
-                error::Error::BadRequest(format!(
-                    "OAuth configuration not found for '{}' in either global settings or static config",
-                    client_name
-                ))
-            })?
-        }
-    } else {
-        let static_configs =
-            serde_json::from_str::<HashMap<String, OAuthConfig>>(connect_configs_json).map_err(
-                |e| error::Error::InternalErr(format!("Failed to parse oauth_connect.json: {}", e)),
-            )?;
-
-        static_configs.get(client_name).cloned().ok_or_else(|| {
+    let parse_static_configs = || {
+        serde_json::from_str::<HashMap<String, OAuthConfig>>(connect_configs_json).map_err(|e| {
+            error::Error::InternalErr(format!("Failed to parse oauth_connect.json: {}", e))
+        })
+    };
+    let resolve_from_registry = |client_name: &str| -> error::Result<OAuthConfig> {
+        let static_configs = parse_static_configs()?;
+        resolve_registry_config(&static_configs, client_name).ok_or_else(|| {
             error::Error::BadRequest(format!(
                 "OAuth configuration not found for '{}' in either global settings or static config",
                 client_name
             ))
-        })?
+        })
+    };
+
+    let mut connect_config = if let Some(ref config) = oauth_client_config.connect_config {
+        if !config.auth_url.is_empty() && !config.token_url.is_empty() {
+            config.clone()
+        } else {
+            resolve_from_registry(client_name)?
+        }
+    } else {
+        resolve_from_registry(client_name)?
     };
 
     if let Some(override_url) = cc_token_url_override {
@@ -905,4 +789,103 @@ mod tests {
         let verifier = SlackVerifier::new("test_secret").unwrap();
         assert!(verifier.verify("123", "body", "wrong_sig").is_err());
     }
+
+    #[test]
+    fn canonical_provider_name_strips_sandbox_suffix() {
+        assert_eq!(canonical_provider_name("docusign_sandbox"), "docusign");
+        assert_eq!(canonical_provider_name("docusign"), "docusign");
+        assert_eq!(canonical_provider_name(""), "");
+        // Only strips the suffix once; trailing suffix on already-canonical name.
+        assert_eq!(
+            canonical_provider_name("foo_sandbox_sandbox"),
+            "foo_sandbox"
+        );
+    }
+
+    fn sample_oauth_config(with_sandbox: bool) -> OAuthConfig {
+        OAuthConfig {
+            auth_url: "https://account.example.com/oauth/auth".to_string(),
+            token_url: "https://account.example.com/oauth/token".to_string(),
+            userinfo_url: Some("https://account.example.com/userinfo".to_string()),
+            scopes: Some(vec!["signature".to_string()]),
+            extra_params: None,
+            extra_params_callback: None,
+            req_body_auth: None,
+            grant_types: default_grant_types(),
+            sandbox: with_sandbox.then(|| OAuthSandboxOverride {
+                auth_url: Some("https://account-d.example.com/oauth/auth".to_string()),
+                token_url: Some("https://account-d.example.com/oauth/token".to_string()),
+                userinfo_url: None,
+            }),
+        }
+    }
+
+    #[test]
+    fn as_sandbox_returns_none_when_no_override() {
+        assert!(sample_oauth_config(false).as_sandbox().is_none());
+    }
+
+    #[test]
+    fn as_sandbox_overlays_urls_and_inherits_rest() {
+        let resolved = sample_oauth_config(true).as_sandbox().unwrap();
+        // URLs overridden by sandbox block
+        assert_eq!(
+            resolved.auth_url,
+            "https://account-d.example.com/oauth/auth"
+        );
+        assert_eq!(
+            resolved.token_url,
+            "https://account-d.example.com/oauth/token"
+        );
+        // userinfo_url not in override → inherits from parent
+        assert_eq!(
+            resolved.userinfo_url,
+            Some("https://account.example.com/userinfo".to_string())
+        );
+        // Scopes/grant_types inherited from parent
+        assert_eq!(resolved.scopes, Some(vec!["signature".to_string()]));
+        assert_eq!(resolved.grant_types, default_grant_types());
+        // Nested sandbox field cleared on the resolved config
+        assert!(resolved.sandbox.is_none());
+    }
+
+    #[test]
+    fn resolve_registry_config_direct_lookup() {
+        let mut registry = HashMap::new();
+        registry.insert("docusign".to_string(), sample_oauth_config(true));
+
+        let resolved = resolve_registry_config(&registry, "docusign").unwrap();
+        assert_eq!(resolved.auth_url, "https://account.example.com/oauth/auth");
+        // Direct lookup returns the entry as-is (sandbox block still attached).
+        assert!(resolved.sandbox.is_some());
+    }
+
+    #[test]
+    fn resolve_registry_config_sandbox_fallback() {
+        let mut registry = HashMap::new();
+        registry.insert("docusign".to_string(), sample_oauth_config(true));
+
+        let resolved = resolve_registry_config(&registry, "docusign_sandbox").unwrap();
+        // Sandbox-suffixed lookup resolves to parent's sandbox-overlaid config.
+        assert_eq!(
+            resolved.auth_url,
+            "https://account-d.example.com/oauth/auth"
+        );
+        assert!(resolved.sandbox.is_none());
+    }
+
+    #[test]
+    fn resolve_registry_config_missing_returns_none() {
+        let registry: HashMap<String, OAuthConfig> = HashMap::new();
+        assert!(resolve_registry_config(&registry, "docusign").is_none());
+        assert!(resolve_registry_config(&registry, "docusign_sandbox").is_none());
+    }
+
+    #[test]
+    fn resolve_registry_config_sandbox_without_block_returns_none() {
+        let mut registry = HashMap::new();
+        // Parent exists but has no sandbox override.
+        registry.insert("docusign".to_string(), sample_oauth_config(false));
+        assert!(resolve_registry_config(&registry, "docusign_sandbox").is_none());
+    }
 }
diff --git a/backend/windmill-queue/src/jobs.rs b/backend/windmill-queue/src/jobs.rs
index 4cac407adf..964fd558f1 100644
--- a/backend/windmill-queue/src/jobs.rs
+++ b/backend/windmill-queue/src/jobs.rs
@@ -5387,6 +5387,7 @@ async fn push_inner<'c, 'd>(
                 cache_ttl: cache_ttl.map(|val| val as u32),
                 cache_ignore_s3_path: cache_ignore_s3_path,
                 same_worker: false,
+                preserve_step_tags: false,
                 early_return: None,
                 skip_expr: None,
                 preprocessor_module: None,
diff --git a/backend/windmill-queue/src/workspace_fairness.rs b/backend/windmill-queue/src/workspace_fairness.rs
index 9f4ba00211..8eb3a69394 100644
--- a/backend/windmill-queue/src/workspace_fairness.rs
+++ b/backend/windmill-queue/src/workspace_fairness.rs
@@ -1,15 +1,253 @@
-//! Per-workspace fairness for the shared worker pool (Enterprise feature).
+//! # Per-workspace fairness for the shared worker pool (Enterprise feature)
 //!
-//! The real algorithm — overloaded-set aggregation, coordinated refresh on
-//! `background_task_state`, audit emission, stochastic admission decision —
-//! lives in [`crate::workspace_fairness_ee`] and only compiles when the
-//! `private` feature is on. This module is the public surface used by the
-//! pull dispatch in `jobs.rs` and the integration tests; when EE is on it
-//! transparently re-exports the EE implementation, when EE is off it
-//! provides no-op stubs so the OSS build stays bit-identical to the
-//! pre-fairness pull path.
+//! On multi-tenant deployments (notably `app.windmill.dev`, and any EE
+//! cluster with a single shared worker group) a single workspace flooding
+//! the queue with jobs can degrade quality of service for everyone else.
+//! This module computes the set of "overloaded" workspaces whose share of
+//! the worker pool must be capped, and the dispatch in `jobs.rs` uses a
+//! **duration-weighted stochastic admission rule** at pull time to enforce
+//! the cap as a *worker-second* share, not a pull-count share.
 //!
-//! See [`crate::workspace_fairness_ee`] for design notes and SQL details.
+//! The full algorithm lives in [`crate::workspace_fairness_ee`] behind the
+//! `private` feature — this OSS-facing module is the public surface that
+//! the pull dispatch and integration tests call. When EE is on, the symbols
+//! here transparently re-export the EE implementation. When EE is off, they
+//! are no-ops: `maybe_refresh_overloaded` does nothing, `should_admit_capped`
+//! always returns `true`, and the pull path is bit-identical to its
+//! pre-fairness shape. **Both runtime correctness and the entire reasoning
+//! below assume the EE module is compiled in**; the OSS build is a stub.
+//!
+//! Every numerical default mentioned below (`MAX_PERCENT = 50`,
+//! `DURATION_SECS = 10`, `MIN_TOTAL = 4`, `WORKER_PING_LIVE_SECS = 60`,
+//! `ADMISSION_EPSILON_PERCENT = 5`) is tunable via global settings or
+//! constants; the values here are the as-shipped defaults at the time of
+//! writing and what the design discussion below was calibrated against.
+//!
+//! ## 1. What "overloaded" means — worker-seconds, not jobs
+//!
+//! A workspace is overloaded when, over a rolling
+//! `WORKSPACE_FAIRNESS_DURATION_SECS = 10s` window, it has consumed at least
+//! `WORKSPACE_FAIRNESS_MAX_PERCENT = 50%` of cluster worker-time. Activity
+//! is measured in **worker-seconds**: each job contributes the wall-clock
+//! time it actually held a worker, intersected with the window. A
+//! count-based signal — "what fraction of jobs in the window are from this
+//! workspace" — gets badly fooled by job-duration heterogeneity: 600
+//! short (100ms) jobs and one long (60s) job consume the same worker-time
+//! but the count-based form attributes 600× more weight to the spammy
+//! workspace. Worker-seconds put both patterns on the same scale.
+//!
+//! Two sources contribute to a workspace's worker-second total:
+//!
+//! - **Running** (live, currently-on-a-worker): driven from `v2_job_runtime`
+//!   filtered on `ping > now() - WORKER_PING_LIVE_SECS` (60s, ≈ 2× worker
+//!   heartbeat interval), then PK-joined to `v2_job` for the `kind` filter
+//!   and `v2_job_queue` for `started_at` / `suspend_until`. Contribution is
+//!   `clamp(min(now, ping) − max(started_at, window_start), 0, window)`.
+//!   End-of-interval is the per-job `ping`, which both (a) implements the
+//!   zombie defense — a worker that stopped pinging stops accruing
+//!   worker-seconds at its last heartbeat, so a backlog of stuck
+//!   `running = true` rows can't dominate the denominator — and (b) matches
+//!   the semantic of "worker-seconds the worker has confirmed". `v2_job_runtime`
+//!   is small (rows deleted on completion), so driving the scan from there
+//!   keeps the per-refresh cost bounded by the *in-flight* count rather
+//!   than by the queue size, even when one workspace has thousands of
+//!   `running = true` rows.
+//!
+//! - **Completed** (recently finished): pulled by an index scan over
+//!   `v2_job_completed (completed_at)`, then PK-joined to `v2_job`. The
+//!   index hit is critical — see "Why no `WITH params AS (...)` CTE" below.
+//!   Contribution is `clamp(min(completed_at, now) − max(started_at,
+//!   completed_at − duration_ms, window_start), 0, window)`. Clamping
+//!   start-of-interval by `completed_at − duration_ms` defends against
+//!   zombie rows that `zombie_monitor` force-failed: `started_at` may be
+//!   far in the past, but `duration_ms` reflects the actual measured worker
+//!   time, so the row only contributes its real runtime, not the idle wait
+//!   before force-fail.
+//!
+//! Both halves exclude **flow-orchestration kinds**
+//! (`flow, flowpreview, flownode, singlestepflow`) and **concurrency-
+//! suspended rows** (`suspend_until IS NOT NULL`) — these hold
+//! `running = true` but consume no worker slot. Same predicate as
+//! `handle_zombie_jobs` in `monitor.rs`.
+//!
+//! `WORKSPACE_FAIRNESS_MIN_TOTAL = 4` is also in worker-seconds (≈ 40 %
+//! utilization of one worker over a 10s window) — below the floor, the
+//! cluster is too quiet to bother capping anyone.
+//!
+//! ## 2. The cap is enforced stochastically, weighted by duration
+//!
+//! The pull dispatch in `jobs.rs` flips a coin on every pull: with
+//! probability `p_c` it uses the standard pull query (capped workspaces
+//! are admissible — FIFO will pick them if they're at the head), and with
+//! probability `1 − p_c` it uses the *fairness pull query* which excludes
+//! the overloaded workspaces. Doing it as a probabilistic split rather
+//! than a binary cap/uncap gate keeps victim latency flat instead of
+//! breathing in/out with each refresh cycle.
+//!
+//! The key design choice is how `p_c` is set. The natural first try is
+//! `p_c = (MAX_PERCENT + ε) / 100` — a constant. That converges the
+//! *pull-count* ratio to `MAX_PERCENT`, but only matches the worker-second
+//! ratio when capped and uncapped workspaces share the same mean job
+//! duration. The steady-state share equation is:
+//!
+//!   `share = p_c · D_c / (p_c · D_c + (1 − p_c) · D_u)`
+//!
+//! where `D_c` and `D_u` are the per-job mean durations of capped and
+//! uncapped workspaces respectively. With `D_c = 34s` and `D_u = 1s` (the
+//! exact numbers observed during the lancom01-prod / jps-internal cloud
+//! incident), a constant `p_c = 0.65` (60 % + 5 % ε) yields
+//!
+//!   `share = 0.65 · 34 / (0.65 · 34 + 0.35 · 1) = 22.1 / 22.45 ≈ 98%`
+//!
+//! — i.e., the "60 % cap" was in practice giving capped workspaces 98 %
+//! of worker-seconds. Victims were observed waiting 15s+ for pickup
+//! despite the cap firing on every pull.
+//!
+//! Inverting the equation for the desired share `t = (MAX_PERCENT + ε) / 100`:
+//!
+//!   `p_c = t · D_u / ((1 − t) · D_c + t · D_u)`
+//!
+//! Same numbers, target 0.65: `p_c ≈ 0.054` — about 12× tighter than the
+//! count-based form. The refresh computes `p_c` and stores it in
+//! [`WORKSPACE_FAIRNESS_ADMISSION_PPM`] (parts-per-10_000, fits in an
+//! `AtomicU32`). The pull-time check is one atomic load plus one
+//! `rand::rng().random_range(0..10_000)` draw — same hot-path cost as the
+//! count-based form.
+//!
+//! ### `D_c`/`D_u` come from a separate, longer service-time window
+//!
+//! Crucially, `D_c` and `D_u` must be **true mean service times**, because
+//! the share equation above is Little's-law-based
+//! (`occupancy = arrival_rate × mean_service_time`). They are **not** taken
+//! from the occupancy aggregation: that aggregation clamps each job's
+//! contribution to the short occupancy window (`DURATION_SECS`, 10s), so a
+//! job longer than the window contributes at most 10s — fine for measuring
+//! *share*, but it would truncate `D_c` to ≤ 10s and systematically
+//! under-admit the skew exactly when capped jobs are long (the case the cap
+//! exists for: e.g. true `D_c = 34s` clamped to 10s gives `p_c ≈ 0.157`, an
+//! 86 % effective share instead of 65 %). Instead, the refresh samples true
+//! unclamped `duration_ms` of completed jobs over a longer, decoupled
+//! service-time window (`DURATION_SAMPLE_SECS`, 60s) — long enough to avoid
+//! truncation and to keep the mean stable when few jobs complete within the
+//! 10s occupancy window. So the refresh emits two per-workspace signals:
+//! windowed occupancy worker-seconds (for classification) and a 60s
+//! service-time `(Σ duration_ms, count)` (for admission), merged per
+//! workspace.
+//!
+//! ### Why we kept the fallback when the fairness pull returns empty
+//!
+//! The 100 − `p_c` % of pulls that try the fairness query (excluding
+//! capped workspaces) fall back to the standard query if the fairness
+//! query returns no row. The alternative — idle the worker, holding the
+//! slot open in case a victim shows up — was considered but rejected for
+//! the first iteration: with `p_c` correctly tightened, victims do get the
+//! slot they need *when they exist*, and absent victims, falling back to
+//! the capped pool is the right behaviour (otherwise the cluster
+//! under-utilises itself for no benefit). Adding a reserve-capacity skip
+//! is a fine-tuning lever for bursty victim arrival patterns and is left
+//! as a follow-up.
+//!
+//! ### Degenerate cases
+//!
+//! If either bucket is empty — no capped jobs, no uncapped jobs, or a
+//! capped workspace with zero completions in the 60s service-time window
+//! (all its jobs still running) — the formula is undefined. The refresh
+//! falls back to the count-based `p_c = t` in those cases — it matches
+//! the pre-refactor behaviour and is the safest thing to do when there's
+//! no service-time signal yet to weight on.
+//!
+//! ## 3. Coordinated refresh — exactly once per cycle, cluster-wide
+//!
+//! The aggregation is too expensive to run on every worker process every
+//! pull (and would produce no new information on the sub-second
+//! timescale). It runs **at most once every `refresh_interval` seconds
+//! across the entire fleet**, gated by both a per-process CAS and a
+//! DB-side row lock:
+//!
+//! 1. **Per-process gate** — `maybe_refresh_overloaded` (called from the
+//!    pull path) does `LAST_REFRESH_MICROS.compare_exchange` to ensure at
+//!    most one in-flight refresh per process per interval. If the CAS
+//!    fails or the interval hasn't elapsed yet, the call is a no-op.
+//!    Cost on the hot path: one atomic load, optionally one CAS.
+//!
+//! 2. **DB-side claim** — `refresh_overloaded` first does a cheap upsert
+//!    (`INSERT ... ON CONFLICT ON background_task_state ... WHERE
+//!    updated_at < NOW() − refresh_interval RETURNING true`). The `VALUES`
+//!    clause is all constants, so Postgres has no expensive work to do
+//!    even for losers. Only the unique winner per cycle gets `Some(true)`;
+//!    losers get `None` and skip the aggregation entirely.
+//!
+//! 3. **Winner-only aggregation** — the winner runs the
+//!    `v2_job_runtime ∪ v2_job_completed` worker-second aggregation
+//!    returning per-workspace `(workspace_id, worker_seconds, jobs)`,
+//!    classifies into overloaded/uncapped, computes `p_c`, and writes the
+//!    new payload `{"overloaded": [...], "admission_ppm": N}` back to
+//!    `background_task_state.workspace_fairness`.
+//!
+//! 4. **Everyone reads** — winner and losers alike then `SELECT` the
+//!    current value, parse it, and update their in-process
+//!    `WORKSPACE_FAIRNESS_OVERLOADED` and `WORKSPACE_FAIRNESS_ADMISSION_PPM`
+//!    atomics. This is what makes losers eventually see the winner's
+//!    decision; they just don't pay the aggregation cost.
+//!
+//! The refresh interval is `ACTIVE_REFRESH_SECS = 2s` when the cluster
+//! currently has a capped workspace (faster — we want the cap to lift
+//! promptly once load drops) and `IDLE_REFRESH_SECS = 5s` otherwise
+//! (slower — minimise DB load during normal operation). The DB-side guard
+//! always uses the tighter `ACTIVE_REFRESH_SECS` to bound the race
+//! window; the per-process gate enforces the idle cadence.
+//!
+//! If a refresh fails (DB error, timeout > 5s), `LAST_REFRESH_MICROS` is
+//! left set to the attempt's timestamp so the next attempt has to wait a
+//! full interval — exactly the same cooldown as a successful refresh.
+//! Resetting to `0` on failure would remove the rate limit entirely
+//! precisely when DB load is highest, which is the wrong direction.
+//!
+//! ## 4. Audit logging
+//!
+//! Workspaces entering or leaving the capped set produce
+//! `workspace_fairness.capped` / `workspace_fairness.uncapped` audit
+//! entries scoped to the `admins` workspace, with the affected workspace
+//! as the `resource` field. Emitted by the refresh winner only, so a
+//! transition produces exactly one audit row regardless of fleet size.
+//! The "previous list" diffed against is the DB value (not the per-process
+//! cache) so a freshly-restarted worker that happens to win the first
+//! claim doesn't emit spurious "newly capped" entries for workspaces that
+//! were already capped before it started.
+//!
+//! ## 5. Notable SQL performance constraints
+//!
+//! - **No `WITH params AS (...)` CTE for `window_start`.** A natural
+//!   refactor would be to compute `NOW() - make_interval(secs => N)` once
+//!   in a CTE and reference it in both halves of the UNION. But Postgres
+//!   *materialises* the CTE and the optimiser can no longer push the
+//!   `completed_at > window_start` predicate down to the
+//!   `ix_job_completed_completed_at` index. On the production cloud DB
+//!   (~12M `v2_job_completed` rows), that turns a 10 ms index scan into a
+//!   ~47s full table scan. The query intentionally inlines `NOW()` and
+//!   `NOW() - make_interval(...)` at every callsite.
+//!
+//! - **Drive running side from `v2_job_runtime`, not `v2_job_queue`.**
+//!   Naive ordering ("scan v2_job_queue for `running = true`, join v2_job
+//!   for the kind filter") does a Seq Scan over ~thousands of running-or-
+//!   bookkeeping rows and does a PK lookup into `v2_job` for every one of
+//!   them — ~10 ms in prod, but worse: bounded by *queue size*. Pivoting
+//!   to drive the scan from `v2_job_runtime` filtered on
+//!   `ping > NOW() - 60s` narrows to the in-flight set (small, deletes-
+//!   on-completion) *before* any PK lookups: 1.3 ms, 9× less I/O,
+//!   bounded by *live worker count*.
+//!
+//! ## 6. Enterprise gating
+//!
+//! The cap is an Enterprise feature. `windmill-api-settings` rejects
+//! `workspace_fairness_enabled = true` writes from non-EE builds, and on a
+//! single-tenant self-hosted deployment the default
+//! `workspace_fairness_enabled = false` keeps the pull path identical to
+//! the pre-fairness baseline. At runtime the dispatch checks the atomic
+//! only — when fairness is off, `maybe_refresh_overloaded` drains the
+//! cached state in one pull cycle (resetting `WORKSPACE_FAIRNESS_OVERLOADED`
+//! to empty and `WORKSPACE_FAIRNESS_ADMISSION_PPM` to 10_000 = "admit all"),
+//! so toggling the feature off without restarting workers is safe.
 
 #[cfg(feature = "private")]
 #[allow(unused)]
diff --git a/backend/windmill-types/src/flows.rs b/backend/windmill-types/src/flows.rs
index 8b60eb0d44..9335f60d4f 100644
--- a/backend/windmill-types/src/flows.rs
+++ b/backend/windmill-types/src/flows.rs
@@ -110,6 +110,11 @@ pub struct NewFlow {
     pub ws_error_handler_muted: Option<bool>,
     #[serde(default)]
     pub labels: Option<Vec<String>>,
+    /// Caller-intent flag (set by the CLI / git sync): when true, deploying
+    /// this flow must NOT delete an existing user draft at the same path.
+    /// Transient — never persisted.
+    #[serde(default, skip_serializing_if = "Option::is_none")]
+    pub skip_draft_deletion: Option<bool>,
 }
 
 impl NewFlow {
@@ -169,6 +174,13 @@ pub struct FlowValue {
     #[serde(default)]
     #[serde(skip_serializing_if = "is_default")]
     pub same_worker: bool,
+    // When the flow runs on a custom worker tag, by default that tag is propagated to
+    // (and overrides) every step, script and nested sub-flow. Set this to true to instead
+    // let steps that declare their own non-empty tag run on it; steps without their own tag
+    // still inherit the flow's tag. Defaults to false to preserve the historical behavior.
+    #[serde(default)]
+    #[serde(skip_serializing_if = "is_default")]
+    pub preserve_step_tags: bool,
     #[serde(flatten)]
     pub concurrency_settings: ConcurrencySettings,
     #[serde(flatten)]
diff --git a/backend/windmill-types/src/scripts.rs b/backend/windmill-types/src/scripts.rs
index e9e9337e6d..c26947d8d6 100644
--- a/backend/windmill-types/src/scripts.rs
+++ b/backend/windmill-types/src/scripts.rs
@@ -540,9 +540,19 @@ pub struct NewScript {
     pub auto_parent: Option<bool>,
     #[serde(default)]
     pub labels: Option<Vec<String>>,
+    /// Caller-intent flag (set by the CLI / git sync): when true, deploying
+    /// this script must NOT delete an existing user draft at the same path.
+    /// Transient — never persisted. Deliberately excluded from `impl Hash`
+    /// below (it must not affect the version hash) and from the no-op
+    /// comparison in the deploy handler (it isn't part of what the script
+    /// *is*). See `is_noop_deploy_against_parent`.
+    #[serde(default, skip_serializing_if = "Option::is_none")]
+    pub skip_draft_deletion: Option<bool>,
 }
 
 // IMPORTANT: update this Hash impl when adding fields to NewScript
+// (exception: caller-intent flags like `skip_draft_deletion` are intentionally
+// omitted — they must not influence the computed version hash)
 impl Hash for NewScript {
     fn hash<H: Hasher>(&self, state: &mut H) {
         self.path.hash(state);
diff --git a/backend/windmill-worker/nsjail/download_deps.py.sh b/backend/windmill-worker/nsjail/download_deps.py.sh
index ce056e7e76..13fc00ddf9 100755
--- a/backend/windmill-worker/nsjail/download_deps.py.sh
+++ b/backend/windmill-worker/nsjail/download_deps.py.sh
@@ -31,6 +31,7 @@ $PY_PATH
 $INDEX_URL_ARG $EXTRA_INDEX_URL_ARG $TRUSTED_HOST_ARG
 --system
 --reinstall
+--compile-bytecode
 "
 
 echo $CMD
diff --git a/backend/windmill-worker/src/ai/mod.rs b/backend/windmill-worker/src/ai/mod.rs
index 24e877ab13..ad0986bbea 100644
--- a/backend/windmill-worker/src/ai/mod.rs
+++ b/backend/windmill-worker/src/ai/mod.rs
@@ -1,6 +1,6 @@
 // AI executor module structure
 // This module will contain all AI-related execution logic
 
-pub mod query_builder;
+pub mod stream_event_processor;
 pub mod tools;
 pub mod utils;
diff --git a/backend/windmill-worker/src/ai/query_builder.rs b/backend/windmill-worker/src/ai/stream_event_processor.rs
similarity index 100%
rename from backend/windmill-worker/src/ai/query_builder.rs
rename to backend/windmill-worker/src/ai/stream_event_processor.rs
diff --git a/backend/windmill-worker/src/ai/tools.rs b/backend/windmill-worker/src/ai/tools.rs
index fcc9cdf3c9..11100d4888 100644
--- a/backend/windmill-worker/src/ai/tools.rs
+++ b/backend/windmill-worker/src/ai/tools.rs
@@ -1,4 +1,4 @@
-use crate::ai::query_builder::StreamEventProcessor;
+use crate::ai::stream_event_processor::StreamEventProcessor;
 use crate::ai::utils::{
     add_message_to_conversation, execute_mcp_tool, get_step_name_from_flow,
     is_completed_input_transform, update_flow_status_module_with_actions,
diff --git a/backend/windmill-worker/src/ai_executor.rs b/backend/windmill-worker/src/ai_executor.rs
index 49c24eac2d..b2478e3be1 100644
--- a/backend/windmill-worker/src/ai_executor.rs
+++ b/backend/windmill-worker/src/ai_executor.rs
@@ -45,7 +45,7 @@ use windmill_common::{
 use windmill_queue::{cancel_single_job, CanceledBy, MiniPulledJob};
 
 use crate::{
-    ai::query_builder::StreamEventProcessor,
+    ai::stream_event_processor::StreamEventProcessor,
     common::{build_args_map, resolve_job_timeout, OccupancyMetrics, StreamNotifier},
     handle_child::{run_future_with_polling_update_job_poller_graceful, GracefulPollOutcome},
 };
diff --git a/backend/windmill-worker/src/python_executor.rs b/backend/windmill-worker/src/python_executor.rs
index 4bec8d44bf..3895c823b7 100644
--- a/backend/windmill-worker/src/python_executor.rs
+++ b/backend/windmill-worker/src/python_executor.rs
@@ -2095,6 +2095,9 @@ async fn spawn_uv_install(
             "--no-cache",
             // If we invoke uv pip install, then we want to overwrite existing data
             "--reinstall",
+            // Compile .py to .pyc at install time so imports are fast even
+            // through read-only nsjail mounts (no in-memory compilation per job).
+            "--compile-bytecode",
         ];
 
         if let Some(py_path) = py_path.as_ref() {
diff --git a/backend/windmill-worker/src/worker_flow.rs b/backend/windmill-worker/src/worker_flow.rs
index 6e2deb7446..281a9785c2 100644
--- a/backend/windmill-worker/src/worker_flow.rs
+++ b/backend/windmill-worker/src/worker_flow.rs
@@ -2985,6 +2985,87 @@ struct PushNextFlowJobRec {
 
 // #[async_recursion]
 // #[instrument(level = "trace", skip_all)]
+/// Resolve the worker tag for a flow's child job (step, nested sub-flow, preprocessor).
+///
+/// A child normally inherits the parent flow job's tag so the whole flow runs on one worker
+/// group. The exceptions, in order:
+/// - the preprocessor step, or a flow running on the generic `flow` / `flow-{workspace}` tag,
+///   always uses the child's own tag (`step_tag`);
+/// - when the flow opts into `preserve_step_tags` and the child declares its own non-empty tag,
+///   that tag is honored instead of being overridden by the flow tag;
+/// - otherwise the child inherits the parent flow job's tag.
+fn resolve_flow_step_tag(
+    is_preprocessor_step: bool,
+    flow_tag: &str,
+    workspace_id: &str,
+    preserve_step_tags: bool,
+    step_tag: Option<&str>,
+) -> Option<String> {
+    if is_preprocessor_step || flow_tag == "flow" || flow_tag == format!("flow-{}", workspace_id) {
+        step_tag.map(str::to_string)
+    } else if preserve_step_tags && step_tag.is_some_and(|t| !t.is_empty()) {
+        step_tag.map(str::to_string)
+    } else {
+        Some(flow_tag.to_string())
+    }
+}
+
+#[cfg(test)]
+mod tag_resolution_tests {
+    use super::resolve_flow_step_tag;
+
+    #[test]
+    fn step_inherits_custom_flow_tag_by_default() {
+        // Parent flow on a custom tag, step declares its own tag, preserve disabled:
+        // the step inherits the flow tag (historical behavior).
+        assert_eq!(
+            resolve_flow_step_tag(false, "worker-group-A", "w1", false, Some("worker-group-B")),
+            Some("worker-group-A".to_string())
+        );
+    }
+
+    #[test]
+    fn step_keeps_own_tag_when_preserve_enabled() {
+        // The exact customer scenario: a sub-flow tagged worker-group-B run as a step of a
+        // flow tagged worker-group-A now runs on worker-group-B when preserve_step_tags is on.
+        assert_eq!(
+            resolve_flow_step_tag(false, "worker-group-A", "w1", true, Some("worker-group-B")),
+            Some("worker-group-B".to_string())
+        );
+    }
+
+    #[test]
+    fn untagged_step_inherits_flow_tag_even_when_preserve_enabled() {
+        assert_eq!(
+            resolve_flow_step_tag(false, "worker-group-A", "w1", true, None),
+            Some("worker-group-A".to_string())
+        );
+        // An empty tag counts as "no tag" and still inherits.
+        assert_eq!(
+            resolve_flow_step_tag(false, "worker-group-A", "w1", true, Some("")),
+            Some("worker-group-A".to_string())
+        );
+    }
+
+    #[test]
+    fn generic_flow_tag_always_uses_step_tag() {
+        for flow_tag in ["flow", "flow-w1"] {
+            assert_eq!(
+                resolve_flow_step_tag(false, flow_tag, "w1", false, Some("worker-group-B")),
+                Some("worker-group-B".to_string())
+            );
+        }
+    }
+
+    #[test]
+    fn preprocessor_step_uses_step_tag() {
+        assert_eq!(
+            resolve_flow_step_tag(true, "worker-group-A", "w1", false, Some("worker-group-B")),
+            Some("worker-group-B".to_string())
+        );
+    }
+}
+
 async fn push_next_flow_job(
     flow_job: Arc<MiniPulledJob>,
     mut status: FlowStatus,
@@ -4118,13 +4199,13 @@ async fn push_next_flow_job(
                 .map(|x| x.into());
 
         tracing::debug!(id = %flow_job.id, root_id = %job_root, "computed perms for job {i} of {len}");
-        let tag = if step.is_preprocessor_step()
-            || (flow_job.tag == "flow" || flow_job.tag == format!("flow-{}", flow_job.workspace_id))
-        {
-            payload_tag.tag.clone()
-        } else {
-            Some(flow_job.tag.clone())
-        };
+        let tag = resolve_flow_step_tag(
+            step.is_preprocessor_step(),
+            &flow_job.tag,
+            &flow_job.workspace_id,
+            flow.preserve_step_tags,
+            payload_tag.tag.as_deref(),
+        );
 
         let (email, permissioned_as) = if let Some(on_behalf_of) = payload_tag.on_behalf_of.as_ref()
         {
@@ -4822,6 +4903,7 @@ fn payload_from_modules<'a>(
     modules_node: Option<FlowNodeId>,
     failure_module: Option<&Box<FlowModule>>,
     same_worker: bool,
+    preserve_step_tags: bool,
     id: impl FnOnce() -> String,
     path: impl FnOnce() -> String,
     opt_empty_inner_flows: bool,
@@ -4842,7 +4924,13 @@ fn payload_from_modules<'a>(
     }
 
     Some(JobPayload::RawFlow {
-        value: FlowValue { modules, failure_module, same_worker, ..Default::default() },
+        value: FlowValue {
+            modules,
+            failure_module,
+            same_worker,
+            preserve_step_tags,
+            ..Default::default()
+        },
         path: Some(path()),
         restarted_from: None,
     })
@@ -5144,6 +5232,7 @@ async fn compute_next_flow_transform(
                                 modules_node,
                                 flow.failure_module.as_ref(),
                                 flow.same_worker,
+                                flow.preserve_step_tags,
                                 || format!("{}-{i}", status.step),
                                 || format!("{}/forloop-{i}", flow_job.runnable_path()),
                                 true,
@@ -5280,6 +5369,7 @@ async fn compute_next_flow_transform(
                 modules_node,
                 flow.failure_module.as_ref(),
                 flow.same_worker,
+                flow.preserve_step_tags,
                 || status.step.to_string(),
                 || format!("{}/branchone-{}", flow_job.runnable_path(), branch_idx),
                 true,
@@ -5321,6 +5411,7 @@ async fn compute_next_flow_transform(
                                         modules_node,
                                         flow.failure_module.as_ref(),
                                         flow.same_worker,
+                                        flow.preserve_step_tags,
                                         || format!("{}-{i}", status.step),
                                         || format!("{}/branchall-{}", flow_job.runnable_path(), i),
                                         false,
@@ -5391,6 +5482,7 @@ async fn compute_next_flow_transform(
                 modules_node,
                 flow.failure_module.as_ref(),
                 flow.same_worker,
+                flow.preserve_step_tags,
                 || format!("{}-{}", status.step, branch_status.branch),
                 || {
                     format!(
@@ -5473,6 +5565,7 @@ async fn next_loop_iteration(
         modules_node,
         flow.failure_module.as_ref(),
         flow.same_worker,
+        flow.preserve_step_tags,
         || format!("{}-{}", status.step, ns.index),
         inner_path,
         true,
diff --git a/benchmarks/lib.ts b/benchmarks/lib.ts
index deb8f1cf66..dff2f0fa12 100644
--- a/benchmarks/lib.ts
+++ b/benchmarks/lib.ts
@@ -2,7 +2,7 @@ import { sleep } from "https://deno.land/x/sleep@v1.2.1/mod.ts";
 import * as windmill from "https://deno.land/x/windmill@v1.174.0/mod.ts";
 import * as api from "https://deno.land/x/windmill@v1.174.0/windmill-api/index.ts";
 
-export const VERSION = "v1.711.0";
+export const VERSION = "v1.714.0";
 
 export async function login(email: string, password: string): Promise<string> {
   return await windmill.UserService.login({
diff --git a/cli/src/commands/app/app.ts b/cli/src/commands/app/app.ts
index a6f85fde1c..6f0263c5cf 100644
--- a/cli/src/commands/app/app.ts
+++ b/cli/src/commands/app/app.ts
@@ -192,6 +192,8 @@ export async function pushApp(
           deployment_message: message,
           ...localAppBody,
           ...preserveFields,
+          // Preserve any user draft at this path (see backend skip_draft_deletion).
+          skip_draft_deletion: true,
         },
       });
     }
@@ -205,6 +207,8 @@ export async function pushApp(
         deployment_message: message,
         ...localAppBody,
         ...preserveFields,
+        // Preserve any user draft at this path (see backend skip_draft_deletion).
+        skip_draft_deletion: true,
       },
     });
   }
@@ -480,6 +484,8 @@ const command = new Command()
           on_behalf_of_email: email,
         } as any,
         preserve_on_behalf_of: true,
+        // Preserve any user draft at this path (see backend skip_draft_deletion).
+        skip_draft_deletion: true,
       },
     });
     log.info(colors.green(`Updated permissioned_as for app ${appPath} to ${email}`));
diff --git a/cli/src/commands/app/raw_apps.ts b/cli/src/commands/app/raw_apps.ts
index 5b9e880adc..fcfc68915e 100644
--- a/cli/src/commands/app/raw_apps.ts
+++ b/cli/src/commands/app/raw_apps.ts
@@ -466,6 +466,8 @@ export async function pushRawApp(
             summary: localApp.summary,
             policy: appForPolicy.policy,
             deployment_message: message,
+            // Preserve any user draft at this path (see backend skip_draft_deletion).
+            skip_draft_deletion: true,
             ...(localApp.custom_path
               ? { custom_path: localApp.custom_path }
               : {}),
@@ -486,6 +488,8 @@ export async function pushRawApp(
           summary: localApp.summary,
           policy: appForPolicy.policy,
           deployment_message: message,
+          // Preserve any user draft at this path (see backend skip_draft_deletion).
+          skip_draft_deletion: true,
           ...(localApp.custom_path
             ? { custom_path: localApp.custom_path }
             : {}),
diff --git a/cli/src/commands/flow/flow.ts b/cli/src/commands/flow/flow.ts
index 4717711ae5..c0e94c478d 100644
--- a/cli/src/commands/flow/flow.ts
+++ b/cli/src/commands/flow/flow.ts
@@ -224,6 +224,8 @@ export async function pushFlow(
           deployment_message: message,
           ...localFlowBody,
           ...preserveFields,
+          // Preserve any user draft at this path (see backend skip_draft_deletion).
+          skip_draft_deletion: true,
         },
       });
     }
@@ -237,6 +239,8 @@ export async function pushFlow(
           deployment_message: message,
           ...localFlowBody,
           ...preserveFields,
+          // Preserve any user draft at this path (see backend skip_draft_deletion).
+          skip_draft_deletion: true,
         },
       });
     } catch (e) {
@@ -1159,6 +1163,8 @@ const command = new Command()
         path: flowPath,
         on_behalf_of_email: email,
         preserve_on_behalf_of: true,
+        // Preserve any user draft at this path (see backend skip_draft_deletion).
+        skip_draft_deletion: true,
       } as any,
     });
     log.info(colors.green(`Updated permissioned_as for flow ${flowPath} to ${email}`));
diff --git a/cli/src/commands/script/script.ts b/cli/src/commands/script/script.ts
index 808456f151..0299744056 100644
--- a/cli/src/commands/script/script.ts
+++ b/cli/src/commands/script/script.ts
@@ -758,6 +758,9 @@ async function createScript(
   workspace: Workspace
 ): Promise<number> {
   const start = performance.now();
+  // Preserve any user draft at this path: a CLI / git-sync deploy must not wipe
+  // an in-progress draft the way a UI "deploy from draft" intentionally does.
+  body = { ...body, skip_draft_deletion: true };
   // skip_if_noop asks the backend to treat deploys identical to the parent
   // (same content, lockfile, and metadata) as a no-op, so the CLI does not
   // produce phantom git-sync / promotion commits on re-pushes.
@@ -1796,6 +1799,8 @@ async function setPermissionedAs(
       parent_hash: remote.hash,
       on_behalf_of_email: email,
       preserve_on_behalf_of: true,
+      // Preserve any user draft at this path (see backend skip_draft_deletion).
+      skip_draft_deletion: true,
     },
   });
   log.info(colors.green(`Updated permissioned_as for script ${scriptPath} to ${email}`));
diff --git a/cli/src/commands/sync/sync.ts b/cli/src/commands/sync/sync.ts
index 625fe69780..2070ceb590 100644
--- a/cli/src/commands/sync/sync.ts
+++ b/cli/src/commands/sync/sync.ts
@@ -22,6 +22,7 @@ import {
   showConflict,
   showDiff,
   extractNativeTriggerInfo,
+  redactEncryptionKey,
 } from "../../types.ts";
 import { downloadZip } from "./pull.ts";
 import { runLint, printReport, checkMissingLocks } from "../lint/lint.ts";
@@ -2503,8 +2504,20 @@ export async function pull(
     }
 
     if (opts.onlyCreateBranch) {
-      // Branch is checked out locally; the caller pushes it. Symmetric with
-      // the non-onlyCreateBranch path: CLI does branch + pull, never push.
+      // Branch-only publish: there is no commit here, so the GPG-cache-warmth
+      // invariant that motivated moving commit+push to the hub script (WIN-1974,
+      // #9284) does not apply — a bare `git push` of the (empty) branch ref needs
+      // no signing. The hub script only runs its in-process commit+push for the
+      // non-onlyCreateBranch path (`if (!only_create_branch) git_push(...)`), so
+      // the CLI MUST publish the fork branch here or it is never pushed at all.
+      gitSyncDeployPush({
+        items: deployItems,
+        authorName: process.env["WM_USERNAME"] || "windmill",
+        authorEmail: process.env["WM_EMAIL"] || "windmill@windmill.dev",
+        committerName: opts.gitCommitterName,
+        committerEmail: opts.gitCommitterEmail,
+        onlyCreateBranch: true,
+      });
       return;
     }
   }
@@ -3040,12 +3053,13 @@ export async function gitDeploy(
       ...(opts.extraIncludes ?? []),
       ...includes.extraIncludes,
     ],
-    includeSchedules: opts.includeSchedules || includes.includeSchedules,
-    includeGroups: opts.includeGroups || includes.includeGroups,
-    includeUsers: opts.includeUsers || includes.includeUsers,
-    includeTriggers: opts.includeTriggers || includes.includeTriggers,
-    includeSettings: opts.includeSettings || includes.includeSettings,
-    includeKey: opts.includeKey || includes.includeKey,
+    // Workspace-wide mode force-includes the deployed default-excluded kinds
+    // (full mirror). Individual-branch/promotion mode forces nothing — these
+    // keys stay ABSENT so pull resolves them from the promotion target's
+    // effective wmill.yaml filters. Spreading (not setting `false`) is what
+    // makes the deferral work: an explicit `false` would clobber the effective
+    // config in pull's Object.assign-based option merge.
+    ...includes.forcedIncludes,
     promotion,
   } as any);
 }
@@ -3095,16 +3109,22 @@ function prettyChanges(
         ),
       );
     } else if (change.name === "edited") {
+      const changeType = getTypeStrFromPath(change.path);
       log.info(
         colors.yellow(
-          `~ ${getTypeStrFromPath(change.path)} ` +
+          `~ ${changeType} ` +
             displayPath +
             colors.gray(wsNote) +
             (change.codebase ? ` (codebase changed)` : ""),
         ),
       );
       if (change.before != change.after) {
-        if (change.path.endsWith(".yaml")) {
+        if (changeType === "encryption_key") {
+          showDiff(
+            redactEncryptionKey(change.before),
+            redactEncryptionKey(change.after),
+          );
+        } else if (change.path.endsWith(".yaml")) {
           try {
             showDiff(
               yamlStringify(
@@ -4022,6 +4042,10 @@ export async function push(
                 originalWorkspaceSpecificPath,
                 permissionedAsContext,
                 isWsSpecific ? true : undefined,
+                {
+                  noninteractive: (opts.yes ?? false) || !process.stdin.isTTY,
+                  skipReencrypt: opts.skipReencryptOnKeyChange,
+                },
               );
 
               if (stateTarget) {
@@ -4107,6 +4131,10 @@ export async function push(
                 localFilePath, // Pass the actual local file path
                 permissionedAsContext,
                 isAddedWsSpecific ? true : undefined,
+                {
+                  noninteractive: (opts.yes ?? false) || !process.stdin.isTTY,
+                  skipReencrypt: opts.skipReencryptOnKeyChange,
+                },
               );
 
               if (stateTarget) {
@@ -4663,6 +4691,10 @@ const command = new Command()
   .option("--include-groups", "Include syncing groups")
   .option("--include-settings", "Include syncing workspace settings")
   .option("--include-key", "Include workspace encryption key")
+  .option(
+    "--skip-reencrypt-on-key-change",
+    "When the pushed encryption key differs from the remote, do NOT re-encrypt existing remote secrets. Only safe if they are already encrypted with the new key (e.g. workspace/instance migration). Default is to re-encrypt.",
+  )
   .option("--skip-branch-validation", "Skip git branch validation and prompts")
   .option("--json-output", "Output results in JSON format")
   .option(
diff --git a/cli/src/core/conf.ts b/cli/src/core/conf.ts
index 5656cfe9d4..c4fda73b1b 100644
--- a/cli/src/core/conf.ts
+++ b/cli/src/core/conf.ts
@@ -88,6 +88,7 @@ export interface SyncOptions {
   includeGroups?: boolean;
   includeSettings?: boolean;
   includeKey?: boolean;
+  skipReencryptOnKeyChange?: boolean;
   skipBranchValidation?: boolean;
   message?: string;
   includes?: string[];
diff --git a/cli/src/core/settings.ts b/cli/src/core/settings.ts
index 4b86cb3469..e4b618180f 100644
--- a/cli/src/core/settings.ts
+++ b/cli/src/core/settings.ts
@@ -445,11 +445,23 @@ export async function pushWorkspaceSettings(
   }
 }
 
+export interface PushWorkspaceKeyOptions {
+  // True when no prompt may be shown (e.g. `--yes` was passed or stdin is not a
+  // TTY). In that case the re-encryption decision is taken from `skipReencrypt`
+  // / the WMILL_NO_REENCRYPT_ON_KEY_CHANGE env var instead of an interactive
+  // confirmation.
+  noninteractive?: boolean;
+  // Explicit re-encryption decision from `--skip-reencrypt-on-key-change`.
+  // When set it takes precedence over the prompt and the env var.
+  skipReencrypt?: boolean;
+}
+
 export async function pushWorkspaceKey(
   workspace: string,
   _path: string,
   key: string | undefined,
-  localKey: string
+  localKey: string,
+  opts?: PushWorkspaceKeyOptions
 ) {
   try {
     key = await wmill
@@ -461,17 +473,46 @@ export async function pushWorkspaceKey(
     throw new Error(`Failed to get workspace encryption key: ${err}`);
   }
   if (localKey && key !== localKey) {
-    const confirm = await Confirm.prompt({
-      message:
-        "The local workspace encryption key does not match the remote. Do you want to reencrypt all your secrets on the remote with the new key?\nSay 'no' if your local secrets are already encrypted with the new key (e.g. workspace/instance migration)\nOtherwise, say 'yes' and pull the secrets after the reencryption.\n",
-      default: true,
-    });
+    // Changing the key on the remote means the existing ciphertexts (encrypted
+    // with the old key) become unreadable unless they are re-encrypted. By
+    // default we ask the backend to re-encrypt every secret variable with the
+    // new key, which preserves their plaintext values. The only reason to skip
+    // re-encryption is when the stored ciphertexts are *already* encrypted with
+    // the new key (e.g. a workspace/instance migration).
+    let reencrypt: boolean;
+    // Explicit choice via `--skip-reencrypt-on-key-change` or the env var wins
+    // over everything, regardless of interactivity.
+    const explicitSkip =
+      opts?.skipReencrypt ||
+      (process.env.WMILL_NO_REENCRYPT_ON_KEY_CHANGE ?? "").toLowerCase() ===
+        "true";
+    if (explicitSkip) {
+      reencrypt = false;
+      log.info(
+        "Workspace encryption key changed; leaving remote ciphertexts untouched (skip re-encryption requested)."
+      );
+    } else if (opts?.noninteractive) {
+      // No TTY (or --yes) and no explicit skip: we can't prompt, so default to
+      // re-encrypting (matches the interactive default) to preserve secret
+      // values. Pass --skip-reencrypt-on-key-change (or set
+      // WMILL_NO_REENCRYPT_ON_KEY_CHANGE=true) to opt out.
+      reencrypt = true;
+      log.info(
+        "Workspace encryption key changed; re-encrypting all remote secrets with the new key (non-interactive)."
+      );
+    } else {
+      reencrypt = await Confirm.prompt({
+        message:
+          "The local workspace encryption key does not match the remote. Do you want to reencrypt all your secrets on the remote with the new key?\nSay 'no' if your local secrets are already encrypted with the new key (e.g. workspace/instance migration)\nOtherwise, say 'yes' and pull the secrets after the reencryption.\n",
+        default: true,
+      });
+    }
     log.debug(`Updating workspace encryption key...`);
     await wmill.setWorkspaceEncryptionKey({
       workspace,
       requestBody: {
         new_key: localKey,
-        skip_reencrypt: !confirm,
+        skip_reencrypt: !reencrypt,
       },
     });
   } else {
diff --git a/cli/src/guidance/skills.gen.ts b/cli/src/guidance/skills.gen.ts
index 714fdec222..8b6f21053d 100644
--- a/cli/src/guidance/skills.gen.ts
+++ b/cli/src/guidance/skills.gen.ts
@@ -10,7 +10,7 @@ export const SKILLS: SkillMetadata[] = [
   { name: "write-script-bash", description: "MUST use when writing Bash scripts.", languageKey: "bash" },
   { name: "write-script-bigquery", description: "MUST use when writing BigQuery queries.", languageKey: "bigquery" },
   { name: "write-script-bun", description: "MUST use when writing Bun/TypeScript scripts.", languageKey: "bun" },
-  { name: "write-script-bunnative", description: "MUST use when writing Bun Native scripts.", languageKey: "bunnative" },
+  { name: "write-script-bunnative", description: "MUST use when writing Bun Native scripts. The script must start with //native to run on the native worker.", languageKey: "bunnative" },
   { name: "write-script-csharp", description: "MUST use when writing C# scripts.", languageKey: "csharp" },
   { name: "write-script-deno", description: "MUST use when writing Deno/TypeScript scripts.", languageKey: "deno" },
   { name: "write-script-duckdb", description: "MUST use when writing DuckDB queries.", languageKey: "duckdb" },
@@ -19,7 +19,6 @@ export const SKILLS: SkillMetadata[] = [
   { name: "write-script-java", description: "MUST use when writing Java scripts.", languageKey: "java" },
   { name: "write-script-mssql", description: "MUST use when writing MS SQL Server queries.", languageKey: "mssql" },
   { name: "write-script-mysql", description: "MUST use when writing MySQL queries.", languageKey: "mysql" },
-  { name: "write-script-nativets", description: "MUST use when writing Native TypeScript scripts.", languageKey: "nativets" },
   { name: "write-script-php", description: "MUST use when writing PHP scripts.", languageKey: "php" },
   { name: "write-script-postgresql", description: "MUST use when writing PostgreSQL queries.", languageKey: "postgresql" },
   { name: "write-script-powershell", description: "MUST use when writing PowerShell scripts.", languageKey: "powershell" },
@@ -926,7 +925,7 @@ ducklake(name: string = "main"): SqlTemplateFunction
 `,
   "write-script-bunnative": `---
 name: write-script-bunnative
-description: MUST use when writing Bun Native scripts.
+description: MUST use when writing Bun Native scripts. The script must start with //native to run on the native worker.
 ---
 
 ## CLI Commands
@@ -966,13 +965,14 @@ Use \`wmill resource-type list --schema\` to discover available resource types.
 
 # TypeScript (Bun Native)
 
-Native TypeScript execution with fetch only - no external imports allowed.
+Native TypeScript execution. Native scripts are Bun scripts that run on the native worker — a lightweight V8 isolate that exposes \`fetch\` and the JavaScript standard library — and can be heavily parallelized. Every script MUST start with \`//native\` on its first line so Windmill routes it to the native worker; without it the exact same script runs on the regular Bun worker. You may import npm packages and other Windmill scripts (e.g. \`./helper.ts\`) — imports are resolved and bundled just like a regular Bun script — as long as everything (your code and its dependencies) relies only on \`fetch\` and the standard library. Libraries that need Node/Bun runtime APIs (filesystem, \`node:*\` modules, child processes, native addons) will not work on the native worker; use the regular \`bun\` language for those.
 
 ## Structure
 
 Export a single **async** function called \`main\`:
 
 \`\`\`typescript
+//native
 export async function main(param1: string, param2: number) {
   // Your code here
   return { result: param1, count: param2 };
@@ -988,6 +988,7 @@ On Windmill, credentials and configuration are stored in resources and passed as
 Use the \`RT\` namespace for resource types:
 
 \`\`\`typescript
+//native
 export async function main(stripe: RT.Stripe) {
   // stripe contains API key and config from the resource
 }
@@ -999,9 +1000,10 @@ Before using a resource type, check the \`rt.d.ts\` file in the project root to
 
 ## Imports
 
-**No imports allowed.** Use the globally available \`fetch\` function:
+**The constraint is the runtime, not the import list.** You may import npm packages and relative Windmill scripts; they are resolved and bundled exactly like a regular Bun script. But the native worker only provides \`fetch\` and the JavaScript standard library, so any imported code must work using only those. Anything requiring Node/Bun built-ins (\`node:fs\`, \`child_process\`, the \`Bun\` API, native modules) belongs in a regular \`bun\` script instead. Use the globally available \`fetch\` for HTTP:
 
 \`\`\`typescript
+//native
 export async function main(url: string) {
   const response = await fetch(url);
   return await response.json();
@@ -1010,13 +1012,14 @@ export async function main(url: string) {
 
 ## Windmill Client
 
-The windmill client is not available in native TypeScript mode. Use fetch to call APIs directly.
+\`windmill-client\` is available for Windmill-specific primitives such as the S3 helpers below (\`loadS3File\`, \`loadS3FileStream\`, \`writeS3File\`, \`S3Object\`). Use \`fetch\` for plain HTTP.
 
 ## Preprocessor Scripts
 
 For preprocessor scripts, the function should be named \`preprocessor\` and receives an \`event\` parameter:
 
 \`\`\`typescript
+//native
 type Event = {
   kind:
     | "webhook"
@@ -1049,6 +1052,7 @@ Windmill provides built-in support for S3-compatible storage operations. The \`w
 ### Receiving an S3Object as a script parameter
 
 \`\`\`typescript
+//native
 import * as wmill from "windmill-client";
 
 export async function main(file: wmill.S3Object) {
@@ -1060,6 +1064,7 @@ export async function main(file: wmill.S3Object) {
 ### S3 operations
 
 \`\`\`typescript
+//native
 import * as wmill from "windmill-client";
 
 // Load file content from S3
@@ -2976,682 +2981,6 @@ All keys are optional: \`prefix\` (object key prefix), \`storage\` (named storag
 omit to use the workspace default), \`format\` (\`json\` (default), \`parquet\`, or
 \`csv\`). Use this for large result sets — rows stream directly to S3 instead of
 being buffered as the script return value.
-`,
-  "write-script-nativets": `---
-name: write-script-nativets
-description: MUST use when writing Native TypeScript scripts.
----
-
-## CLI Commands
-
-Place scripts in a folder.
-
-After writing, tell the user which command fits what they want to do:
-
-- \`wmill script preview <script_path>\` — **default when iterating on a local script.** Runs the local file without deploying.
-- \`wmill script run <path>\` — runs the script **already deployed** in the workspace. Use only when the user explicitly wants to test the deployed version, not local edits.
-- \`wmill generate-metadata\` — generate \`.script.yaml\` and \`.lock\` files for the script you modified.
-- \`wmill sync push\` — deploy local changes to the workspace. Only suggest/run this when the user explicitly asks to deploy/publish/push — not when they say "run", "try", or "test".
-
-### Preview vs run — choose by intent, not habit
-
-If the user says "run the script", "try it", "test it", "does it work" while there are **local edits to the script file**, use \`script preview\`. Do NOT push the script to then \`script run\` it — pushing is a deploy, and deploying just to test overwrites the workspace version with untested changes.
-
-Only use \`script run\` when:
-- The user explicitly says "run the deployed version" / "run what's on the server".
-- There is no local script being edited (you're just invoking an existing script).
-
-Only use \`sync push\` when:
-- The user explicitly asks to deploy, publish, push, or ship.
-- The preview has already validated the change and the user wants it in the workspace.
-
-### After writing — offer to test, don't wait passively
-
-If the user hasn't already told you to run/test/preview the script, offer it as a one-sentence next step (e.g. "Want me to run \`wmill script preview\` with sample args?"). Do not present a multi-option menu.
-
-If the user already asked to test/run/try the script in their original request, skip the offer and just execute \`wmill script preview <path> -d '<args>'\` directly — pick plausible args from the script's declared parameters. The shape varies by language: \`main(...)\` for code languages, the SQL dialect's own placeholder syntax (\`$1\` for PostgreSQL, \`?\` for MySQL/Snowflake, \`@P1\` for MSSQL, \`@name\` for BigQuery, etc.), positional \`$1\`, \`$2\`, … for Bash, \`param(...)\` for PowerShell.
-
-\`wmill script preview\` does not deploy, but it still executes script code and may cause side effects; run it yourself when the user asked to test/preview (or after confirming that execution is intended). \`wmill sync push\` and \`wmill generate-metadata\` modify workspace state or local files — only run these when the user explicitly asks; otherwise tell them which to run.
-
-For a **visual** open-the-script-in-the-dev-page preview (rather than \`script preview\`'s run-and-print-result), use the \`preview\` skill.
-
-Use \`wmill resource-type list --schema\` to discover available resource types.
-
-# TypeScript (Native)
-
-Native TypeScript execution with fetch only - no external imports allowed.
-
-## Structure
-
-Export a single **async** function called \`main\`:
-
-\`\`\`typescript
-export async function main(param1: string, param2: number) {
-  // Your code here
-  return { result: param1, count: param2 };
-}
-\`\`\`
-
-Do not call the main function.
-
-## Resource Types
-
-On Windmill, credentials and configuration are stored in resources and passed as parameters to main.
-
-Use the \`RT\` namespace for resource types:
-
-\`\`\`typescript
-export async function main(stripe: RT.Stripe) {
-  // stripe contains API key and config from the resource
-}
-\`\`\`
-
-Only use resource types if you need them to satisfy the instructions. Always use the RT namespace.
-
-Before using a resource type, check the \`rt.d.ts\` file in the project root to see all available resource types and their fields. This file is generated by \`wmill resource-type generate-namespace\`.
-
-## Imports
-
-**No imports allowed.** Use the globally available \`fetch\` function:
-
-\`\`\`typescript
-export async function main(url: string) {
-  const response = await fetch(url);
-  return await response.json();
-}
-\`\`\`
-
-## Windmill Client
-
-The windmill client is not available in native TypeScript mode. Use fetch to call APIs directly.
-
-## Preprocessor Scripts
-
-For preprocessor scripts, the function should be named \`preprocessor\` and receives an \`event\` parameter:
-
-\`\`\`typescript
-type Event = {
-  kind:
-    | "webhook"
-    | "http"
-    | "websocket"
-    | "kafka"
-    | "email"
-    | "nats"
-    | "postgres"
-    | "sqs"
-    | "mqtt"
-    | "gcp";
-  body: any;
-  headers: Record<string, string>;
-  query: Record<string, string>;
-};
-
-export async function preprocessor(event: Event) {
-  return {
-    param1: event.body.field1,
-    param2: event.query.id
-  };
-}
-\`\`\`
-
-
-# TypeScript SDK (windmill-client)
-
-Import: import * as wmill from 'windmill-client'
-
-workerHasInternalServer(): boolean
-
-/**
- * Initialize the Windmill client with authentication token and base URL
- * @param token - Authentication token (defaults to WM_TOKEN env variable)
- * @param baseUrl - API base URL (defaults to BASE_INTERNAL_URL or BASE_URL env variable)
- */
-setClient(token?: string, baseUrl?: string): void
-
-/**
- * Create a client configuration from env variables
- * @returns client configuration
- */
-getWorkspace(): string
-
-/**
- * Get a resource value by path
- * @param path path of the resource,  default to internal state path
- * @param undefinedIfEmpty if the resource does not exist, return undefined instead of throwing an error
- * @returns resource value
- */
-async getResource(path?: string, undefinedIfEmpty?: boolean): Promise<any>
-
-/**
- * Get the true root job id
- * @param jobId job id to get the root job id from (default to current job)
- * @returns root job id
- */
-async getRootJobId(jobId?: string): Promise<string>
-
-/**
- * @deprecated Use runScriptByPath or runScriptByHash instead
- */
-async runScript(path: string | null = null, hash_: string | null = null, args: Record<string, any> | null = null, verbose: boolean = false): Promise<any>
-
-/**
- * Run a script synchronously by its path and wait for the result
- * @param path - Script path in Windmill
- * @param args - Arguments to pass to the script
- * @param verbose - Enable verbose logging
- * @returns Script execution result
- */
-async runScriptByPath(path: string, args: Record<string, any> | null = null, verbose: boolean = false): Promise<any>
-
-/**
- * Run a script synchronously by its hash and wait for the result
- * @param hash_ - Script hash in Windmill
- * @param args - Arguments to pass to the script
- * @param verbose - Enable verbose logging
- * @returns Script execution result
- */
-async runScriptByHash(hash_: string, args: Record<string, any> | null = null, verbose: boolean = false): Promise<any>
-
-/**
- * Append a text to the result stream
- * @param text text to append to the result stream
- */
-appendToResultStream(text: string): void
-
-/**
- * Stream to the result stream
- * @param stream stream to stream to the result stream
- */
-async streamResult(stream: AsyncIterable<string>): Promise<void>
-
-/**
- * Run a flow synchronously by its path and wait for the result
- * @param path - Flow path in Windmill
- * @param args - Arguments to pass to the flow
- * @param verbose - Enable verbose logging
- * @returns Flow execution result
- */
-async runFlow(path: string | null = null, args: Record<string, any> | null = null, verbose: boolean = false): Promise<any>
-
-/**
- * Wait for a job to complete and return its result
- * @param jobId - ID of the job to wait for
- * @param verbose - Enable verbose logging
- * @returns Job result when completed
- */
-async waitJob(jobId: string, verbose: boolean = false): Promise<any>
-
-/**
- * Get the result of a completed job
- * @param jobId - ID of the completed job
- * @returns Job result
- */
-async getResult(jobId: string): Promise<any>
-
-/**
- * Get the result of a job if completed, or its current status
- * @param jobId - ID of the job
- * @returns Object with started, completed, success, and result properties
- */
-async getResultMaybe(jobId: string): Promise<any>
-
-/**
- * @deprecated Use runScriptByPathAsync or runScriptByHashAsync instead
- */
-async runScriptAsync(path: string | null, hash_: string | null, args: Record<string, any> | null, scheduledInSeconds: number | null = null): Promise<string>
-
-/**
- * Run a script asynchronously by its path
- * @param path - Script path in Windmill
- * @param args - Arguments to pass to the script
- * @param scheduledInSeconds - Schedule execution for a future time (in seconds)
- * @returns Job ID of the created job
- */
-async runScriptByPathAsync(path: string, args: Record<string, any> | null = null, scheduledInSeconds: number | null = null): Promise<string>
-
-/**
- * Run a script asynchronously by its hash
- * @param hash_ - Script hash in Windmill
- * @param args - Arguments to pass to the script
- * @param scheduledInSeconds - Schedule execution for a future time (in seconds)
- * @returns Job ID of the created job
- */
-async runScriptByHashAsync(hash_: string, args: Record<string, any> | null = null, scheduledInSeconds: number | null = null): Promise<string>
-
-/**
- * Run a flow asynchronously by its path
- * @param path - Flow path in Windmill
- * @param args - Arguments to pass to the flow
- * @param scheduledInSeconds - Schedule execution for a future time (in seconds)
- * @param doNotTrackInParent - If false, tracks state in parent job (only use when fully awaiting the job)
- * @returns Job ID of the created job
- */
-async runFlowAsync(path: string | null, args: Record<string, any> | null, scheduledInSeconds: number | null = null, // can only be set to false if this the job will be fully await and not concurrent with any other job // as otherwise the child flow and its own child will store their state in the parent job which will // lead to incorrectness and failures doNotTrackInParent: boolean = true): Promise<string>
-
-/**
- * Resolve a resource value in case the default value was picked because the input payload was undefined
- * @param obj resource value or path of the resource under the format \`$res:path\`
- * @returns resource value
- */
-async resolveDefaultResource(obj: any): Promise<any>
-
-/**
- * Get the state file path from environment variables
- * @returns State path string
- */
-getStatePath(): string
-
-/**
- * Set a resource value by path
- * @param path path of the resource to set, default to state path
- * @param value new value of the resource to set
- * @param initializeToTypeIfNotExist if the resource does not exist, initialize it with this type
- */
-async setResource(value: any, path?: string, initializeToTypeIfNotExist?: string): Promise<void>
-
-/**
- * Set the state
- * @param state state to set
- * @deprecated use setState instead
- */
-async setInternalState(state: any): Promise<void>
-
-/**
- * Set the state
- * @param state state to set
- * @param path Optional state resource path override. Defaults to \`getStatePath()\`.
- */
-async setState(state: any, path?: string): Promise<void>
-
-/**
- * Set the progress
- * Progress cannot go back and limited to 0% to 99% range
- * @param percent Progress to set in %
- * @param jobId? Job to set progress for
- */
-async setProgress(percent: number, jobId?: any): Promise<void>
-
-/**
- * Get the progress
- * @param jobId? Job to get progress from
- * @returns Optional clamped between 0 and 100 progress value
- */
-async getProgress(jobId?: any): Promise<number | null>
-
-/**
- * Set a flow user state
- * @param key key of the state
- * @param value value of the state
- */
-async setFlowUserState(key: string, value: any, errorIfNotPossible?: boolean): Promise<void>
-
-/**
- * Get a flow user state
- * @param path path of the variable
- */
-async getFlowUserState(key: string, errorIfNotPossible?: boolean): Promise<any>
-
-/**
- * Get the internal state
- * @deprecated use getState instead
- */
-async getInternalState(): Promise<any>
-
-/**
- * Get the state shared across executions
- * @param path Optional state resource path override. Defaults to \`getStatePath()\`.
- */
-async getState(path?: string): Promise<any>
-
-/**
- * Get a variable by path
- * @param path path of the variable
- * @returns variable value
- */
-async getVariable(path: string): Promise<string>
-
-/**
- * Set a variable by path, create if not exist
- * @param path path of the variable
- * @param value value of the variable
- * @param isSecretIfNotExist if the variable does not exist, create it as secret or not (default: false)
- * @param descriptionIfNotExist if the variable does not exist, create it with this description (default: "")
- */
-async setVariable(path: string, value: string, isSecretIfNotExist?: boolean, descriptionIfNotExist?: string): Promise<void>
-
-/**
- * Build a PostgreSQL connection URL from a database resource
- * @param path - Path to the database resource
- * @returns PostgreSQL connection URL string
- */
-async databaseUrlFromResource(path: string): Promise<string>
-
-async polarsConnectionSettings(s3_resource_path: string | undefined): Promise<any>
-
-async duckdbConnectionSettings(s3_resource_path: string | undefined): Promise<any>
-
-/**
- * Get S3 client settings from a resource or workspace default
- * @param s3_resource_path - Path to S3 resource (uses workspace default if undefined)
- * @param workspace - Workspace to read from (defaults to the \`WM_WORKSPACE\` env var)
- * @returns S3 client configuration settings
- */
-async denoS3LightClientSettings(s3_resource_path: string | undefined, workspace: string | undefined = undefined): Promise<DenoS3LightClientSettings>
-
-/**
- * Load the content of a file stored in S3. If the s3ResourcePath is undefined, it will default to the workspace S3 resource.
- * 
- * \`\`\`typescript
- * let fileContent = await wmill.loadS3FileContent(inputFile)
- * // if the file is a raw text file, it can be decoded and printed directly:
- * const text = new TextDecoder().decode(fileContentStream)
- * console.log(text);
- * \`\`\`
- * 
- * @param workspace - Workspace to read from (defaults to the \`WM_WORKSPACE\` env var)
- */
-async loadS3File(s3object: S3Object, s3ResourcePath: string | undefined = undefined, workspace: string | undefined = undefined): Promise<Uint8Array | undefined>
-
-/**
- * Load the content of a file stored in S3 as a stream. If the s3ResourcePath is undefined, it will default to the workspace S3 resource.
- * 
- * \`\`\`typescript
- * let fileContentBlob = await wmill.loadS3FileStream(inputFile)
- * // if the content is plain text, the blob can be read directly:
- * console.log(await fileContentBlob.text());
- * \`\`\`
- * 
- * @param workspace - Workspace to read from (defaults to the \`WM_WORKSPACE\` env var)
- */
-async loadS3FileStream(s3object: S3Object, s3ResourcePath: string | undefined = undefined, workspace: string | undefined = undefined): Promise<Blob | undefined>
-
-/**
- * Persist a file to the S3 bucket. If the s3ResourcePath is undefined, it will default to the workspace S3 resource.
- * 
- * \`\`\`typescript
- * const s3object = await writeS3File(s3Object, "Hello Windmill!")
- * const fileContentAsUtf8Str = (await s3object.toArray()).toString('utf-8')
- * console.log(fileContentAsUtf8Str)
- * \`\`\`
- * 
- * @param workspace - Workspace to write to (defaults to the \`WM_WORKSPACE\` env var)
- */
-async writeS3File(s3object: S3Object | undefined, fileContent: string | Blob, s3ResourcePath: string | undefined = undefined, contentType: string | undefined = undefined, contentDisposition: string | undefined = undefined, workspace: string | undefined = undefined): Promise<S3Object>
-
-/**
- * Permanently delete a file from S3 by key.
- * 
- * \`\`\`typescript
- * await wmill.deleteS3File({ s3: "path/to/file.txt" })
- * \`\`\`
- * 
- * @param s3object - S3 object identifying the file to delete (must have \`s3\` set)
- * @param workspace - Workspace to delete from (defaults to the \`WM_WORKSPACE\` env var)
- */
-async deleteS3File(s3object: S3Object, workspace: string | undefined = undefined): Promise<void>
-
-/**
- * Sign S3 objects to be used by anonymous users in public apps
- * @param s3objects s3 objects to sign
- * @returns signed s3 objects
- */
-async signS3Objects(s3objects: S3Object[]): Promise<S3Object[]>
-
-/**
- * Sign S3 object to be used by anonymous users in public apps
- * @param s3object s3 object to sign
- * @returns signed s3 object
- */
-async signS3Object(s3object: S3Object): Promise<S3Object>
-
-/**
- * Generate a presigned public URL for an array of S3 objects.
- * If an S3 object is not signed yet, it will be signed first.
- * @param s3Objects s3 objects to sign
- * @returns list of signed public URLs
- */
-async getPresignedS3PublicUrls(s3Objects: S3Object[], { baseUrl }: { baseUrl?: string } = {}): Promise<string[]>
-
-/**
- * Generate a presigned public URL for an S3 object. If the S3 object is not signed yet, it will be signed first.
- * @param s3Object s3 object to sign
- * @returns signed public URL
- */
-async getPresignedS3PublicUrl(s3Objects: S3Object, { baseUrl }: { baseUrl?: string } = {}): Promise<string>
-
-/**
- * Get URLs needed for resuming a flow after this step
- * @param approver approver name
- * @param flowLevel if true, generate resume URLs for the parent flow instead of the specific step.
- *                  This allows pre-approvals that can be consumed by any later suspend step in the same flow.
- * @returns approval page UI URL, resume and cancel API URLs for resuming the flow
- */
-async getResumeUrls(approver?: string, flowLevel?: boolean): Promise<{
-  approvalPage: string;
-  resume: string;
-  cancel: string;
-}>
-
-/**
- * @deprecated use getResumeUrls instead
- */
-getResumeEndpoints(approver?: string): Promise<{
-  approvalPage: string;
-  resume: string;
-  cancel: string;
-}>
-
-/**
- * Get an OIDC jwt token for auth to external services (e.g: Vault, AWS) (ee only)
- * @param audience audience of the token
- * @param expiresIn Optional number of seconds until the token expires
- * @returns jwt token
- */
-async getIdToken(audience: string, expiresIn?: number): Promise<string>
-
-/**
- * Convert a base64-encoded string to Uint8Array
- * @param data - Base64-encoded string
- * @returns Decoded Uint8Array
- */
-base64ToUint8Array(data: string): Uint8Array
-
-/**
- * Convert a Uint8Array to base64-encoded string
- * @param arrayBuffer - Uint8Array to encode
- * @returns Base64-encoded string
- */
-uint8ArrayToBase64(arrayBuffer: Uint8Array): string
-
-/**
- * Get email from workspace username
- * This method is particularly useful for apps that require the email address of the viewer.
- * Indeed, in the viewer context, WM_USERNAME is set to the username of the viewer but WM_EMAIL is set to the email of the creator of the app.
- * @param username
- * @returns email address
- */
-async usernameToEmail(username: string): Promise<string>
-
-/**
- * Sends an interactive approval request via Slack, allowing optional customization of the message, approver, and form fields.
- * 
- * **[Enterprise Edition Only]** To include form fields in the Slack approval request, go to **Advanced -> Suspend -> Form**
- * and define a form. Learn more at [Windmill Documentation](https://www.windmill.dev/docs/flows/flow_approval#form).
- * 
- * @param {Object} options - The configuration options for the Slack approval request.
- * @param {string} options.slackResourcePath - The path to the Slack resource in Windmill.
- * @param {string} options.channelId - The Slack channel ID where the approval request will be sent.
- * @param {string} [options.message] - Optional custom message to include in the Slack approval request.
- * @param {string} [options.approver] - Optional user ID or name of the approver for the request.
- * @param {DefaultArgs} [options.defaultArgsJson] - Optional object defining or overriding the default arguments to a form field.
- * @param {Enums} [options.dynamicEnumsJson] - Optional object overriding the enum default values of an enum form field.
- * @param {string} [options.resumeButtonText] - Optional text for the resume button.
- * @param {string} [options.cancelButtonText] - Optional text for the cancel button.
- * 
- * @returns {Promise<void>} Resolves when the Slack approval request is successfully sent.
- * 
- * @throws {Error} If the function is not called within a flow or flow preview.
- * @throws {Error} If the \`JobService.getSlackApprovalPayload\` call fails.
- * 
- * **Usage Example:**
- * \`\`\`typescript
- * await requestInteractiveSlackApproval({
- *   slackResourcePath: "/u/alex/my_slack_resource",
- *   channelId: "admins-slack-channel",
- *   message: "Please approve this request",
- *   approver: "approver123",
- *   defaultArgsJson: { key1: "value1", key2: 42 },
- *   dynamicEnumsJson: { foo: ["choice1", "choice2"], bar: ["optionA", "optionB"] },
- *   resumeButtonText: "Resume",
- *   cancelButtonText: "Cancel",
- * });
- * \`\`\`
- * 
- * **Note:** This function requires execution within a Windmill flow or flow preview.
- */
-async requestInteractiveSlackApproval({ slackResourcePath, channelId, message, approver, defaultArgsJson, dynamicEnumsJson, resumeButtonText, cancelButtonText, }: SlackApprovalOptions): Promise<void>
-
-/**
- * Sends an interactive approval request via Teams, allowing optional customization of the message, approver, and form fields.
- * 
- * **[Enterprise Edition Only]** To include form fields in the Teams approval request, go to **Advanced -> Suspend -> Form**
- * and define a form. Learn more at [Windmill Documentation](https://www.windmill.dev/docs/flows/flow_approval#form).
- * 
- * @param {Object} options - The configuration options for the Teams approval request.
- * @param {string} options.teamName - The Teams team name where the approval request will be sent.
- * @param {string} options.channelName - The Teams channel name where the approval request will be sent.
- * @param {string} [options.message] - Optional custom message to include in the Teams approval request.
- * @param {string} [options.approver] - Optional user ID or name of the approver for the request.
- * @param {DefaultArgs} [options.defaultArgsJson] - Optional object defining or overriding the default arguments to a form field.
- * @param {Enums} [options.dynamicEnumsJson] - Optional object overriding the enum default values of an enum form field.
- * 
- * @returns {Promise<void>} Resolves when the Teams approval request is successfully sent.
- * 
- * @throws {Error} If the function is not called within a flow or flow preview.
- * @throws {Error} If the \`JobService.getTeamsApprovalPayload\` call fails.
- * 
- * **Usage Example:**
- * \`\`\`typescript
- * await requestInteractiveTeamsApproval({
- *   teamName: "admins-teams",
- *   channelName: "admins-teams-channel",
- *   message: "Please approve this request",
- *   approver: "approver123",
- *   defaultArgsJson: { key1: "value1", key2: 42 },
- *   dynamicEnumsJson: { foo: ["choice1", "choice2"], bar: ["optionA", "optionB"] },
- * });
- * \`\`\`
- * 
- * **Note:** This function requires execution within a Windmill flow or flow preview.
- */
-async requestInteractiveTeamsApproval({ teamName, channelName, message, approver, defaultArgsJson, dynamicEnumsJson, }: TeamsApprovalOptions): Promise<void>
-
-/**
- * Parse an S3 object from URI string or record format
- * @param s3Object - S3 object as URI string (s3://storage/key) or record
- * @returns S3 object record with storage and s3 key
- */
-parseS3Object(s3Object: S3Object): S3ObjectRecord
-
-setWorkflowCtx(ctx: WorkflowCtx | null): void
-
-async sleep(seconds: number): Promise<void>
-
-async step<T>(name: string, fn: () => T | Promise<T>): Promise<T>
-
-/**
- * Create a task that dispatches to a separate Windmill script.
- * 
- * @example
- * const extract = taskScript("f/data/extract");
- * // inside workflow: await extract({ url: "https://..." })
- */
-taskScript(path: string, options?: TaskOptions): (...args: any[]) => PromiseLike<any>
-
-/**
- * Create a task that dispatches to a separate Windmill flow.
- * 
- * @example
- * const pipeline = taskFlow("f/etl/pipeline");
- * // inside workflow: await pipeline({ input: data })
- */
-taskFlow(path: string, options?: TaskOptions): (...args: any[]) => PromiseLike<any>
-
-/**
- * Mark an async function as a workflow-as-code entry point.
- * 
- * The function must be **deterministic**: given the same inputs it must call
- * tasks in the same order on every replay. Branching on task results is fine
- * (results are replayed from checkpoint), but branching on external state
- * (current time, random values, external API calls) must use \`step()\` to
- * checkpoint the value so replays see the same result.
- */
-workflow<T>(fn: (...args: any[]) => Promise<T>): void
-
-/**
- * Suspend the workflow and wait for an external approval.
- * 
- * Use \`getResumeUrls()\` (wrapped in \`step()\`) to obtain resume/cancel/approvalPage
- * URLs before calling this function.
- * 
- * @example
- * const urls = await step("urls", () => getResumeUrls());
- * await step("notify", () => sendEmail(urls.approvalPage));
- * const { value, approver } = await waitForApproval({ timeout: 3600 });
- */
-waitForApproval(options?: { timeout?: number; form?: object; selfApproval?: boolean; }): PromiseLike<{ value: any; approver: string; approved: boolean }>
-
-/**
- * Process items in parallel with optional concurrency control.
- * 
- * Each item is processed by calling \`fn(item)\`, which should be a task().
- * Items are dispatched in batches of \`concurrency\` (default: all at once).
- * 
- * @example
- * const process = task(async (item: string) => { ... });
- * const results = await parallel(items, process, { concurrency: 5 });
- */
-async parallel<T, R>(items: T[], fn: (item: T) => PromiseLike<R> | R, options?: { concurrency?: number },): Promise<R[]>
-
-/**
- * Commit Kafka offsets for a trigger with auto_commit disabled.
- * @param triggerPath - Path to the Kafka trigger (from event.wm_trigger.trigger_path)
- * @param topic - Kafka topic name (from event.topic)
- * @param partition - Partition number (from event.partition)
- * @param offset - Message offset to commit (from event.offset)
- */
-async commitKafkaOffsets(triggerPath: string, topic: string, partition: number, offset: number,): Promise<void>
-
-/**
- * Create a SQL template function for PostgreSQL/datatable queries
- * @param name - Database/datatable name (default: "main")
- * @returns SQL template function for building parameterized queries
- * @example
- * let sql = wmill.datatable()
- * let name = 'Robin'
- * let age = 21
- * await sql\`
- *   SELECT * FROM friends
- *     WHERE name = \${name} AND age = \${age}::int
- * \`.fetch()
- */
-datatable(name: string = "main"): DatatableSqlTemplateFunction
-
-/**
- * Create a SQL template function for DuckDB/ducklake queries
- * @param name - DuckDB database name (default: "main")
- * @returns SQL template function for building parameterized queries
- * @example
- * let sql = wmill.ducklake()
- * let name = 'Robin'
- * let age = 21
- * await sql\`
- *   SELECT * FROM friends
- *     WHERE name = \${name} AND age = \${age}
- * \`.fetch()
- */
-ducklake(name: string = "main"): SqlTemplateFunction
 `,
   "write-script-php": `---
 name: write-script-php
@@ -5502,7 +4831,7 @@ Reference a specific resource using \`$res:\` prefix:
 
 ## OpenFlow Schema
 
-{"OpenFlow":{"type":"object","description":"Top-level flow definition containing metadata, configuration, and the flow structure","properties":{"summary":{"type":"string","description":"Short description of what this flow does"},"description":{"type":"string","description":"Detailed documentation for this flow"},"value":{"$ref":"#/components/schemas/FlowValue"},"schema":{"type":"object","description":"JSON Schema for flow inputs. Use this to define input parameters, their types, defaults, and validation. For resource inputs, set type to 'object' and format to 'resource-<type>' (e.g., 'resource-stripe')"},"on_behalf_of_email":{"type":"string","description":"The flow will be run with the permissions of the user with this email."}},"required":["summary","value"]},"FlowValue":{"type":"object","description":"The flow structure containing modules and optional preprocessor/failure handlers","properties":{"modules":{"type":"array","description":"Array of steps that execute in sequence. Each step can be a script, subflow, loop, or branch","items":{"$ref":"#/components/schemas/FlowModule"}},"failure_module":{"description":"Special module that executes when the flow fails. Receives error object with message, name, stack, and step_id. Must have id 'failure'. Only supports script/rawscript types","$ref":"#/components/schemas/FlowModule"},"preprocessor_module":{"description":"Special module that runs before the first step on external triggers. Must have id 'preprocessor'. Only supports script/rawscript types. Cannot reference other step results","$ref":"#/components/schemas/FlowModule"},"same_worker":{"type":"boolean","description":"If true, all steps run on the same worker for better performance"},"concurrent_limit":{"type":"number","description":"Maximum number of concurrent executions of this flow"},"concurrency_key":{"type":"string","description":"Expression to group concurrent executions (e.g., by user ID)"},"concurrency_time_window_s":{"type":"number","description":"Time window in seconds for concurrent_limit"},"debounce_delay_s":{"type":"integer","description":"Delay in seconds to debounce flow executions"},"debounce_key":{"type":"string","description":"Expression to group debounced executions"},"debounce_args_to_accumulate":{"type":"array","description":"Arguments to accumulate across debounced executions","items":{"type":"string"}},"max_total_debouncing_time":{"type":"integer","description":"Maximum total time in seconds that a job can be debounced"},"max_total_debounces_amount":{"type":"integer","description":"Maximum number of times a job can be debounced"},"skip_expr":{"type":"string","description":"JavaScript expression to conditionally skip the entire flow"},"cache_ttl":{"type":"number","description":"Cache duration in seconds for flow results"},"cache_ignore_s3_path":{"type":"boolean"},"delete_after_secs":{"type":"integer","description":"If set, delete the flow job's args, result and logs after this many seconds following job completion"},"flow_env":{"type":"object","description":"Environment variables available to all steps. Values can be strings, JSON values, or special references: '$var:path' (workspace variable) or '$res:path' (resource).","additionalProperties":{}},"priority":{"type":"number","description":"Execution priority (higher numbers run first)"},"early_return":{"type":"string","description":"JavaScript expression to return early from the flow"},"chat_input_enabled":{"type":"boolean","description":"Whether this flow accepts chat-style input"},"notes":{"type":"array","description":"Sticky notes attached to the flow","items":{"$ref":"#/components/schemas/FlowNote"}},"groups":{"type":"array","description":"Semantic groups of modules for organizational purposes","items":{"$ref":"#/components/schemas/FlowGroup"}}},"required":["modules"]},"Retry":{"type":"object","description":"Retry configuration for failed module executions","properties":{"constant":{"type":"object","description":"Retry with constant delay between attempts","properties":{"attempts":{"type":"integer","description":"Number of retry attempts"},"seconds":{"type":"integer","description":"Seconds to wait between retries"}}},"exponential":{"type":"object","description":"Retry with exponential backoff (delay doubles each time)","properties":{"attempts":{"type":"integer","description":"Number of retry attempts"},"multiplier":{"type":"integer","description":"Multiplier for exponential backoff"},"seconds":{"type":"integer","minimum":1,"description":"Initial delay in seconds"},"random_factor":{"type":"integer","minimum":0,"maximum":100,"description":"Random jitter percentage (0-100) to avoid thundering herd"}}},"retry_if":{"$ref":"#/components/schemas/RetryIf"}}},"FlowNote":{"type":"object","description":"A sticky note attached to a flow for documentation and annotation","properties":{"id":{"type":"string","description":"Unique identifier for the note"},"text":{"type":"string","description":"Content of the note"},"position":{"type":"object","description":"Position of the note in the flow editor","properties":{"x":{"type":"number","description":"X coordinate"},"y":{"type":"number","description":"Y coordinate"}},"required":["x","y"]},"size":{"type":"object","description":"Size of the note in the flow editor","properties":{"width":{"type":"number","description":"Width in pixels"},"height":{"type":"number","description":"Height in pixels"}},"required":["width","height"]},"color":{"type":"string","description":"Color of the note (e.g., \\"yellow\\", \\"#ffff00\\")"},"type":{"type":"string","enum":["free","group"],"description":"Type of note - 'free' for standalone notes, 'group' for notes that group other nodes"},"locked":{"type":"boolean","default":false,"description":"Whether the note is locked and cannot be edited or moved"},"contained_node_ids":{"type":"array","items":{"type":"string"},"description":"For group notes, the IDs of nodes contained within this group"}},"required":["id","text","color","type"]},"FlowGroup":{"type":"object","description":"A semantic group of flow modules for organizational purposes. Does not affect execution \\u2014 modules remain in their original position in the flow. Groups provide naming and collapsibility in the editor. Members are computed dynamically from all nodes on paths between start_id and end_id.","properties":{"summary":{"type":"string","description":"Display name for this group"},"note":{"type":"string","description":"Markdown note shown below the group header"},"autocollapse":{"type":"boolean","default":false,"description":"If true, this group is collapsed by default in the flow editor. UI hint only."},"start_id":{"type":"string","description":"ID of the first flow module in this group (topological entry point)"},"end_id":{"type":"string","description":"ID of the last flow module in this group (topological exit point)"},"color":{"type":"string","description":"Color for the group in the flow editor"}},"required":["start_id","end_id"]},"RetryIf":{"type":"object","description":"Conditional retry based on error or result","properties":{"expr":{"type":"string","description":"JavaScript expression that returns true to retry. Has access to 'result' and 'error' variables"}},"required":["expr"]},"StopAfterIf":{"type":"object","description":"Early termination condition for a module","properties":{"skip_if_stopped":{"type":"boolean","description":"If true, following steps are skipped when this condition triggers"},"expr":{"type":"string","description":"JavaScript expression evaluated after the module runs. Can use 'result' (step's result) or 'flow_input'. Return true to stop"},"error_message":{"type":"string","nullable":true,"description":"Custom error message when stopping with an error. Mutually exclusive with skip_if_stopped. If set to a non-empty string, the flow stops with this error. If empty string, a default error message is used. If null or omitted, no error is raised."}},"required":["expr"]},"FlowModule":{"type":"object","description":"A single step in a flow. Can be a script, subflow, loop, or branch","properties":{"id":{"type":"string","description":"Unique identifier for this step. Used to reference results via 'results.step_id'. Must be a valid identifier (alphanumeric, underscore, hyphen)"},"value":{"$ref":"#/components/schemas/FlowModuleValue"},"stop_after_if":{"description":"Early termination condition evaluated after this step completes","$ref":"#/components/schemas/StopAfterIf"},"stop_after_all_iters_if":{"description":"For loops only - early termination condition evaluated after all iterations complete","$ref":"#/components/schemas/StopAfterIf"},"skip_if":{"type":"object","description":"Conditionally skip this step based on previous results or flow inputs","properties":{"expr":{"type":"string","description":"JavaScript expression that returns true to skip. Can use 'flow_input' or 'results.<step_id>'"}},"required":["expr"]},"sleep":{"description":"Delay before executing this step (in seconds or as expression)","$ref":"#/components/schemas/InputTransform"},"cache_ttl":{"type":"number","description":"Cache duration in seconds for this step's results"},"cache_ignore_s3_path":{"type":"boolean"},"timeout":{"description":"Maximum execution time in seconds (static value or expression)","$ref":"#/components/schemas/InputTransform"},"delete_after_secs":{"type":"integer","description":"If set, delete the step's args, result and logs after this many seconds following job completion"},"summary":{"type":"string","description":"Short description of what this step does"},"mock":{"type":"object","description":"Mock configuration for testing without executing the actual step","properties":{"enabled":{"type":"boolean","description":"If true, return mock value instead of executing"},"return_value":{"description":"Value to return when mocked"}}},"suspend":{"type":"object","description":"Configuration for approval/resume steps that wait for user input","properties":{"required_events":{"type":"integer","description":"Number of approvals required before continuing"},"timeout":{"type":"integer","description":"Timeout in seconds before auto-continuing or canceling"},"resume_form":{"type":"object","description":"Form schema for collecting input when resuming","properties":{"schema":{"type":"object","description":"JSON Schema for the resume form"}}},"user_auth_required":{"type":"boolean","description":"If true, only authenticated users can approve"},"user_groups_required":{"description":"Expression or list of groups that can approve","$ref":"#/components/schemas/InputTransform"},"self_approval_disabled":{"type":"boolean","description":"If true, the user who started the flow cannot approve"},"hide_cancel":{"type":"boolean","description":"If true, hide the cancel button on the approval form"},"continue_on_disapprove_timeout":{"type":"boolean","description":"If true, continue flow on timeout instead of canceling"}}},"priority":{"type":"number","description":"Execution priority for this step (higher numbers run first)"},"continue_on_error":{"type":"boolean","description":"If true, flow continues even if this step fails"},"retry":{"description":"Retry configuration if this step fails","$ref":"#/components/schemas/Retry"},"debouncing":{"description":"Debounce configuration for this step (EE only)","type":"object","properties":{"debounce_delay_s":{"type":"integer","description":"Delay in seconds to debounce this step's executions across flow runs"},"debounce_key":{"type":"string","description":"Expression to group debounced executions. Supports $workspace and $args[name]. Default: $workspace/flow/<flow_path>-<step_id>"},"debounce_args_to_accumulate":{"type":"array","description":"Array-type arguments to accumulate across debounced executions","items":{"type":"string"}},"max_total_debouncing_time":{"type":"integer","description":"Maximum total time in seconds before forced execution"},"max_total_debounces_amount":{"type":"integer","description":"Maximum number of debounces before forced execution"}}}},"required":["value","id"]},"InputTransform":{"description":"Maps input parameters for a step. Can be a static value or a JavaScript expression that references previous results or flow inputs","oneOf":[{"$ref":"#/components/schemas/StaticTransform"},{"$ref":"#/components/schemas/JavascriptTransform"},{"$ref":"#/components/schemas/AiTransform"}],"discriminator":{"propertyName":"type","mapping":{"static":"#/components/schemas/StaticTransform","javascript":"#/components/schemas/JavascriptTransform","ai":"#/components/schemas/AiTransform"}}},"StaticTransform":{"type":"object","description":"Static value passed directly to the step. Use for hardcoded values or resource references like '$res:path/to/resource'","properties":{"value":{"description":"The static value. For resources, use format '$res:path/to/resource'"},"type":{"type":"string","enum":["static"]}},"required":["type"]},"JavascriptTransform":{"type":"object","description":"JavaScript expression evaluated at runtime. Can reference previous step results via 'results.step_id' or flow inputs via 'flow_input.property'. Inside loops, use 'flow_input.iter.value' for the current iteration value","properties":{"expr":{"type":"string","description":"JavaScript expression returning the value. Available variables - results (object with all previous step results), flow_input (flow inputs), flow_input.iter (in loops)"},"type":{"type":"string","enum":["javascript"]}},"required":["expr","type"]},"AiTransform":{"type":"object","description":"Value resolved by the AI runtime for this input. The AI engine decides how to satisfy the parameter.","properties":{"type":{"type":"string","enum":["ai"]}},"required":["type"]},"AIProviderKind":{"type":"string","description":"Supported AI provider types","enum":["openai","azure_openai","anthropic","mistral","deepseek","googleai","groq","openrouter","togetherai","customai","aws_bedrock"]},"ProviderConfig":{"type":"object","description":"Complete AI provider configuration with resource reference and model selection","properties":{"kind":{"$ref":"#/components/schemas/AIProviderKind"},"resource":{"type":"string","description":"Resource reference in format '$res:{resource_path}' pointing to provider credentials"},"model":{"type":"string","description":"Model identifier (e.g., 'gpt-4', 'claude-3-opus-20240229', 'gemini-pro')"}},"required":["kind","resource","model"]},"StaticProviderTransform":{"type":"object","description":"Static provider configuration passed directly to the AI agent","properties":{"value":{"$ref":"#/components/schemas/ProviderConfig"},"type":{"type":"string","enum":["static"]}},"required":["type","value"]},"ProviderTransform":{"description":"Provider configuration - can be static (ProviderConfig), JavaScript expression, or AI-determined","oneOf":[{"$ref":"#/components/schemas/StaticProviderTransform"},{"$ref":"#/components/schemas/JavascriptTransform"},{"$ref":"#/components/schemas/AiTransform"}],"discriminator":{"propertyName":"type","mapping":{"static":"#/components/schemas/StaticProviderTransform","javascript":"#/components/schemas/JavascriptTransform","ai":"#/components/schemas/AiTransform"}}},"MemoryOff":{"type":"object","description":"No conversation memory/context","properties":{"kind":{"type":"string","enum":["off"]}},"required":["kind"]},"MemoryAuto":{"type":"object","description":"Automatic context management","properties":{"kind":{"type":"string","enum":["auto"]},"context_length":{"type":"integer","description":"Maximum number of messages to retain in context"},"memory_id":{"type":"string","description":"Identifier for persistent memory across agent invocations"}},"required":["kind"]},"MemoryMessage":{"type":"object","description":"A single message in conversation history","properties":{"role":{"type":"string","enum":["user","assistant","system"]},"content":{"type":"string"}},"required":["role","content"]},"MemoryManual":{"type":"object","description":"Explicit message history","properties":{"kind":{"type":"string","enum":["manual"]},"messages":{"type":"array","items":{"$ref":"#/components/schemas/MemoryMessage"}}},"required":["kind","messages"]},"MemoryConfig":{"description":"Conversation memory configuration","oneOf":[{"$ref":"#/components/schemas/MemoryOff"},{"$ref":"#/components/schemas/MemoryAuto"},{"$ref":"#/components/schemas/MemoryManual"}],"discriminator":{"propertyName":"kind","mapping":{"off":"#/components/schemas/MemoryOff","auto":"#/components/schemas/MemoryAuto","manual":"#/components/schemas/MemoryManual"}}},"StaticMemoryTransform":{"type":"object","description":"Static memory configuration passed directly to the AI agent","properties":{"value":{"$ref":"#/components/schemas/MemoryConfig"},"type":{"type":"string","enum":["static"]}},"required":["type","value"]},"MemoryTransform":{"description":"Memory configuration - can be static (MemoryConfig), JavaScript expression, or AI-determined","oneOf":[{"$ref":"#/components/schemas/StaticMemoryTransform"},{"$ref":"#/components/schemas/JavascriptTransform"},{"$ref":"#/components/schemas/AiTransform"}],"discriminator":{"propertyName":"type","mapping":{"static":"#/components/schemas/StaticMemoryTransform","javascript":"#/components/schemas/JavascriptTransform","ai":"#/components/schemas/AiTransform"}}},"FlowModuleValue":{"description":"The actual implementation of a flow step. Can be a script (inline or referenced), subflow, loop, branch, or special module type","oneOf":[{"$ref":"#/components/schemas/RawScript"},{"$ref":"#/components/schemas/PathScript"},{"$ref":"#/components/schemas/PathFlow"},{"$ref":"#/components/schemas/ForloopFlow"},{"$ref":"#/components/schemas/WhileloopFlow"},{"$ref":"#/components/schemas/BranchOne"},{"$ref":"#/components/schemas/BranchAll"},{"$ref":"#/components/schemas/Identity"},{"$ref":"#/components/schemas/AiAgent"}],"discriminator":{"propertyName":"type","mapping":{"rawscript":"#/components/schemas/RawScript","script":"#/components/schemas/PathScript","flow":"#/components/schemas/PathFlow","forloopflow":"#/components/schemas/ForloopFlow","whileloopflow":"#/components/schemas/WhileloopFlow","branchone":"#/components/schemas/BranchOne","branchall":"#/components/schemas/BranchAll","identity":"#/components/schemas/Identity","aiagent":"#/components/schemas/AiAgent"}}},"RawScript":{"type":"object","description":"Inline script with code defined directly in the flow. Use 'bun' as default language if unspecified. The script receives arguments from input_transforms","properties":{"input_transforms":{"type":"object","description":"Map of parameter names to their values (static or JavaScript expressions). These become the script's input arguments","additionalProperties":{"$ref":"#/components/schemas/InputTransform"}},"content":{"type":"string","description":"The script source code. Should export a 'main' function"},"language":{"type":"string","description":"Programming language for this script","enum":["deno","bun","python3","go","bash","powershell","postgresql","mysql","bigquery","snowflake","mssql","oracledb","graphql","nativets","php","rust","ansible","csharp","nu","java","ruby","rlang","duckdb"]},"path":{"type":"string","description":"Optional path for saving this script"},"lock":{"type":"string","description":"Lock file content for dependencies"},"type":{"type":"string","enum":["rawscript"]},"tag":{"type":"string","description":"Worker group tag for execution routing"},"concurrent_limit":{"type":"number","description":"Maximum concurrent executions of this script"},"concurrency_time_window_s":{"type":"number","description":"Time window for concurrent_limit"},"custom_concurrency_key":{"type":"string","description":"Custom key for grouping concurrent executions"},"is_trigger":{"type":"boolean","description":"If true, this script is a trigger that can start the flow"},"assets":{"type":"array","description":"External resources this script accesses (S3 objects, resources, etc.)","items":{"type":"object","required":["path","kind"],"properties":{"path":{"type":"string","description":"Path to the asset"},"kind":{"type":"string","description":"Type of asset","enum":["s3object","resource","ducklake","datatable","volume"]},"access_type":{"type":"string","nullable":true,"description":"Access level for this asset","enum":["r","w","rw"]},"alt_access_type":{"type":"string","nullable":true,"description":"Alternative access level","enum":["r","w","rw"]}}}}},"required":["type","content","language","input_transforms"]},"PathScript":{"type":"object","description":"Reference to an existing script by path. Use this when calling a previously saved script instead of writing inline code","properties":{"input_transforms":{"type":"object","description":"Map of parameter names to their values (static or JavaScript expressions). These become the script's input arguments","additionalProperties":{"$ref":"#/components/schemas/InputTransform"}},"path":{"type":"string","description":"Path to the script in the workspace (e.g., 'f/scripts/send_email')"},"hash":{"type":"string","description":"Optional specific version hash of the script to use"},"type":{"type":"string","enum":["script"]},"tag_override":{"type":"string","description":"Override the script's default worker group tag"},"is_trigger":{"type":"boolean","description":"If true, this script is a trigger that can start the flow"}},"required":["type","path","input_transforms"]},"PathFlow":{"type":"object","description":"Reference to an existing flow by path. Use this to call another flow as a subflow","properties":{"input_transforms":{"type":"object","description":"Map of parameter names to their values (static or JavaScript expressions). These become the subflow's input arguments","additionalProperties":{"$ref":"#/components/schemas/InputTransform"}},"path":{"type":"string","description":"Path to the flow in the workspace (e.g., 'f/flows/process_user')"},"type":{"type":"string","enum":["flow"]}},"required":["type","path","input_transforms"]},"ForloopFlow":{"type":"object","description":"Executes nested modules in a loop over an iterator. Inside the loop, use 'flow_input.iter.value' to access the current iteration value, and 'flow_input.iter.index' for the index. Supports parallel execution for better performance on I/O-bound operations","properties":{"modules":{"type":"array","description":"Steps to execute for each iteration. These can reference the iteration value via 'flow_input.iter.value'","items":{"$ref":"#/components/schemas/FlowModule"}},"iterator":{"description":"JavaScript expression that returns an array to iterate over. Can reference 'results.step_id' or 'flow_input'","$ref":"#/components/schemas/InputTransform"},"skip_failures":{"type":"boolean","description":"If true, iteration failures don't stop the loop. Failed iterations return null"},"type":{"type":"string","enum":["forloopflow"]},"parallel":{"type":"boolean","description":"If true, iterations run concurrently (faster for I/O-bound operations). Use with parallelism to control concurrency"},"parallelism":{"description":"Maximum number of concurrent iterations when parallel=true. Limits resource usage. Can be static number or expression","$ref":"#/components/schemas/InputTransform"},"squash":{"type":"boolean"}},"required":["modules","iterator","skip_failures","type"]},"WhileloopFlow":{"type":"object","description":"Executes nested modules repeatedly while a condition is true. The loop checks the condition after each iteration. Use stop_after_if on modules to control loop termination","properties":{"modules":{"type":"array","description":"Steps to execute in each iteration. Use stop_after_if to control when the loop ends","items":{"$ref":"#/components/schemas/FlowModule"}},"skip_failures":{"type":"boolean","description":"If true, iteration failures don't stop the loop. Failed iterations return null"},"type":{"type":"string","enum":["whileloopflow"]},"parallel":{"type":"boolean","description":"If true, iterations run concurrently (use with caution in while loops)"},"parallelism":{"description":"Maximum number of concurrent iterations when parallel=true","$ref":"#/components/schemas/InputTransform"},"squash":{"type":"boolean"}},"required":["modules","skip_failures","type"]},"BranchOne":{"type":"object","description":"Conditional branching where only the first matching branch executes. Branches are evaluated in order, and the first one with a true expression runs. If no branches match, the default branch executes","properties":{"branches":{"type":"array","description":"Array of branches to evaluate in order. The first branch with expr evaluating to true executes","items":{"type":"object","properties":{"summary":{"type":"string","description":"Short description of this branch condition"},"expr":{"type":"string","description":"JavaScript expression that returns boolean. Can use 'results.step_id' or 'flow_input'. First true expr wins"},"modules":{"type":"array","description":"Steps to execute if this branch's expr is true","items":{"$ref":"#/components/schemas/FlowModule"}}},"required":["modules","expr"]}},"default":{"type":"array","description":"Steps to execute if no branch expressions match","items":{"$ref":"#/components/schemas/FlowModule"}},"type":{"type":"string","enum":["branchone"]}},"required":["branches","default","type"]},"BranchAll":{"type":"object","description":"Parallel branching where all branches execute simultaneously. Unlike BranchOne, all branches run regardless of conditions. Useful for executing independent tasks concurrently","properties":{"branches":{"type":"array","description":"Array of branches that all execute (either in parallel or sequentially)","items":{"type":"object","properties":{"summary":{"type":"string","description":"Short description of this branch's purpose"},"skip_failure":{"type":"boolean","description":"If true, failure in this branch doesn't fail the entire flow"},"modules":{"type":"array","description":"Steps to execute in this branch","items":{"$ref":"#/components/schemas/FlowModule"}}},"required":["modules"]}},"type":{"type":"string","enum":["branchall"]},"parallel":{"type":"boolean","description":"If true, all branches execute concurrently. If false, they execute sequentially"}},"required":["branches","type"]},"AgentTool":{"type":"object","description":"A tool available to an AI agent. Can be a flow module or an external MCP (Model Context Protocol) tool","properties":{"id":{"type":"string","description":"Unique identifier for this tool. Cannot contain spaces - use underscores instead (e.g., 'get_user_data' not 'get user data')"},"summary":{"type":"string","description":"Short description of what this tool does (shown to the AI)"},"value":{"$ref":"#/components/schemas/ToolValue"}},"required":["id","value"]},"ToolValue":{"description":"The implementation of a tool. Can be a flow module (script/flow) or an MCP tool reference","oneOf":[{"$ref":"#/components/schemas/FlowModuleTool"},{"$ref":"#/components/schemas/McpToolValue"},{"$ref":"#/components/schemas/WebsearchToolValue"}],"discriminator":{"propertyName":"tool_type","mapping":{"flowmodule":"#/components/schemas/FlowModuleTool","mcp":"#/components/schemas/McpToolValue","websearch":"#/components/schemas/WebsearchToolValue"}}},"FlowModuleTool":{"description":"A tool implemented as a flow module (script, flow, etc.). The AI can call this like any other flow module","allOf":[{"type":"object","properties":{"tool_type":{"type":"string","enum":["flowmodule"]}},"required":["tool_type"]},{"$ref":"#/components/schemas/FlowModuleValue"}]},"WebsearchToolValue":{"type":"object","description":"A tool implemented as a websearch tool. The AI can call this like any other websearch tool","properties":{"tool_type":{"type":"string","enum":["websearch"]}},"required":["tool_type"]},"McpToolValue":{"type":"object","description":"Reference to an external MCP (Model Context Protocol) tool. The AI can call tools from MCP servers","properties":{"tool_type":{"type":"string","enum":["mcp"]},"resource_path":{"type":"string","description":"Path to the MCP resource/server configuration"},"include_tools":{"type":"array","description":"Whitelist of specific tools to include from this MCP server","items":{"type":"string"}},"exclude_tools":{"type":"array","description":"Blacklist of tools to exclude from this MCP server","items":{"type":"string"}}},"required":["tool_type","resource_path"]},"AiAgent":{"type":"object","description":"AI agent step that can use tools to accomplish tasks. The agent receives inputs and can call any of its configured tools to complete the task","properties":{"input_transforms":{"type":"object","description":"Input parameters for the AI agent mapped to their values","properties":{"provider":{"$ref":"#/components/schemas/ProviderTransform"},"output_type":{"allOf":[{"$ref":"#/components/schemas/InputTransform"}],"description":"Output format type.\\nValid values: 'text' (default) - plain text response, 'image' - image generation\\n"},"user_message":{"allOf":[{"$ref":"#/components/schemas/InputTransform"}],"description":"The user's prompt/message to the AI agent. Supports variable interpolation with flow.input syntax."},"system_prompt":{"allOf":[{"$ref":"#/components/schemas/InputTransform"}],"description":"System instructions that guide the AI's behavior, persona, and response style. Optional."},"streaming":{"allOf":[{"$ref":"#/components/schemas/InputTransform"}],"description":"Boolean. If true, stream the AI response incrementally.\\nStreaming events include: token_delta, tool_call, tool_call_arguments, tool_execution, tool_result\\n"},"memory":{"$ref":"#/components/schemas/MemoryTransform"},"output_schema":{"allOf":[{"$ref":"#/components/schemas/InputTransform"}],"description":"JSON Schema object defining structured output format. Used when you need the AI to return data in a specific shape.\\nSupports standard JSON Schema properties: type, properties, required, items, enum, pattern, minLength, maxLength, minimum, maximum, etc.\\nExample: { type: 'object', properties: { name: { type: 'string' }, age: { type: 'integer' } }, required: ['name'] }\\n"},"user_attachments":{"allOf":[{"$ref":"#/components/schemas/InputTransform"}],"description":"Array of file references (images or PDFs) for the AI agent.\\nFormat: Array<{ bucket: string, key: string }> - S3 object references\\nExample: [{ bucket: 'my-bucket', key: 'documents/report.pdf' }]\\n"},"max_completion_tokens":{"allOf":[{"$ref":"#/components/schemas/InputTransform"}],"description":"Integer. Maximum number of tokens the AI will generate in its response.\\nRange: 1 to 4,294,967,295. Typical values: 256-4096 for most use cases.\\n"},"temperature":{"allOf":[{"$ref":"#/components/schemas/InputTransform"}],"description":"Float. Controls randomness/creativity of responses.\\nRange: 0.0 to 2.0 (provider-dependent)\\n- 0.0 = deterministic, focused responses\\n- 0.7 = balanced (common default)\\n- 1.0+ = more creative/random\\n"},"max_iterations":{"allOf":[{"$ref":"#/components/schemas/InputTransform"}],"description":"Number. Limits how many times the agent can loop through reasoning and tool use.\\nRange: 1-1000.\\n"}},"required":["provider","user_message","output_type"]},"tools":{"type":"array","description":"Array of tools the agent can use. The agent decides which tools to call based on the task","items":{"$ref":"#/components/schemas/AgentTool"}},"type":{"type":"string","enum":["aiagent"]},"omit_output_from_conversation":{"type":"boolean","default":false,"description":"If true, this AI agent step does not persist its assistant or tool messages to the flow conversation when chat mode is enabled."},"parallel":{"type":"boolean","description":"If true, the agent can execute multiple tool calls in parallel"}},"required":["tools","type","input_transforms"]},"Identity":{"type":"object","description":"Pass-through module that returns its input unchanged. Useful for flow structure or as a placeholder","properties":{"type":{"type":"string","enum":["identity"]},"flow":{"type":"boolean","description":"If true, marks this as a flow identity (special handling)"}},"required":["type"]},"FlowStatus":{"type":"object","properties":{"step":{"type":"integer"},"modules":{"type":"array","items":{"$ref":"#/components/schemas/FlowStatusModule"}},"user_states":{"additionalProperties":true},"preprocessor_module":{"allOf":[{"$ref":"#/components/schemas/FlowStatusModule"}]},"failure_module":{"allOf":[{"$ref":"#/components/schemas/FlowStatusModule"},{"type":"object","properties":{"parent_module":{"type":"string"}}}]},"retry":{"type":"object","properties":{"fail_count":{"type":"integer"},"failed_jobs":{"type":"array","items":{"type":"string","format":"uuid"}}}}},"required":["step","modules","failure_module"]},"FlowStatusModule":{"type":"object","properties":{"type":{"type":"string","enum":["WaitingForPriorSteps","WaitingForEvents","WaitingForExecutor","InProgress","Success","Failure"]},"id":{"type":"string"},"job":{"type":"string","format":"uuid"},"count":{"type":"integer"},"progress":{"type":"integer"},"iterator":{"type":"object","properties":{"index":{"type":"integer"},"itered":{"type":"array","items":{}},"itered_len":{"type":"integer"},"args":{}}},"flow_jobs":{"type":"array","items":{"type":"string"}},"flow_jobs_success":{"type":"array","items":{"type":"boolean"}},"flow_jobs_duration":{"type":"object","properties":{"started_at":{"type":"array","items":{"type":"string"}},"duration_ms":{"type":"array","items":{"type":"integer"}}}},"branch_chosen":{"type":"object","properties":{"type":{"type":"string","enum":["branch","default"]},"branch":{"type":"integer"}},"required":["type"]},"branchall":{"type":"object","properties":{"branch":{"type":"integer"},"len":{"type":"integer"}},"required":["branch","len"]},"approvers":{"type":"array","items":{"type":"object","properties":{"resume_id":{"type":"integer"},"approver":{"type":"string"}},"required":["resume_id","approver"]}},"failed_retries":{"type":"array","items":{"type":"string","format":"uuid"}},"skipped":{"type":"boolean"},"agent_actions":{"type":"array","items":{"type":"object","oneOf":[{"type":"object","properties":{"job_id":{"type":"string","format":"uuid"},"function_name":{"type":"string"},"type":{"type":"string","enum":["tool_call"]},"module_id":{"type":"string"}},"required":["job_id","function_name","type","module_id"]},{"type":"object","properties":{"call_id":{"type":"string","format":"uuid"},"function_name":{"type":"string"},"resource_path":{"type":"string"},"type":{"type":"string","enum":["mcp_tool_call"]},"arguments":{"type":"object"}},"required":["call_id","function_name","resource_path","type"]},{"type":"object","properties":{"type":{"type":"string","enum":["web_search"]}},"required":["type"]},{"type":"object","properties":{"type":{"type":"string","enum":["message"]}},"required":["content","type"]}]}},"agent_actions_success":{"type":"array","items":{"type":"boolean"}}},"required":["type"]}}`,
+{"OpenFlow":{"type":"object","description":"Top-level flow definition containing metadata, configuration, and the flow structure","properties":{"summary":{"type":"string","description":"Short description of what this flow does"},"description":{"type":"string","description":"Detailed documentation for this flow"},"value":{"$ref":"#/components/schemas/FlowValue"},"schema":{"type":"object","description":"JSON Schema for flow inputs. Use this to define input parameters, their types, defaults, and validation. For resource inputs, set type to 'object' and format to 'resource-<type>' (e.g., 'resource-stripe')"},"on_behalf_of_email":{"type":"string","description":"The flow will be run with the permissions of the user with this email."}},"required":["summary","value"]},"FlowValue":{"type":"object","description":"The flow structure containing modules and optional preprocessor/failure handlers","properties":{"modules":{"type":"array","description":"Array of steps that execute in sequence. Each step can be a script, subflow, loop, or branch","items":{"$ref":"#/components/schemas/FlowModule"}},"failure_module":{"description":"Special module that executes when the flow fails. Receives error object with message, name, stack, and step_id. Must have id 'failure'. Only supports script/rawscript types","$ref":"#/components/schemas/FlowModule"},"preprocessor_module":{"description":"Special module that runs before the first step on external triggers. Must have id 'preprocessor'. Only supports script/rawscript types. Cannot reference other step results","$ref":"#/components/schemas/FlowModule"},"same_worker":{"type":"boolean","description":"If true, all steps run on the same worker for better performance"},"preserve_step_tags":{"type":"boolean","description":"If true and the flow runs on a custom worker tag, steps that declare their own non-empty tag run on it instead of inheriting the flow tag. Steps without their own tag still inherit the flow tag."},"concurrent_limit":{"type":"number","description":"Maximum number of concurrent executions of this flow"},"concurrency_key":{"type":"string","description":"Expression to group concurrent executions (e.g., by user ID)"},"concurrency_time_window_s":{"type":"number","description":"Time window in seconds for concurrent_limit"},"debounce_delay_s":{"type":"integer","description":"Delay in seconds to debounce flow executions"},"debounce_key":{"type":"string","description":"Expression to group debounced executions"},"debounce_args_to_accumulate":{"type":"array","description":"Arguments to accumulate across debounced executions","items":{"type":"string"}},"max_total_debouncing_time":{"type":"integer","description":"Maximum total time in seconds that a job can be debounced"},"max_total_debounces_amount":{"type":"integer","description":"Maximum number of times a job can be debounced"},"skip_expr":{"type":"string","description":"JavaScript expression to conditionally skip the entire flow"},"cache_ttl":{"type":"number","description":"Cache duration in seconds for flow results"},"cache_ignore_s3_path":{"type":"boolean"},"delete_after_secs":{"type":"integer","description":"If set, delete the flow job's args, result and logs after this many seconds following job completion"},"flow_env":{"type":"object","description":"Environment variables available to all steps. Values can be strings, JSON values, or special references: '$var:path' (workspace variable) or '$res:path' (resource).","additionalProperties":{}},"priority":{"type":"number","description":"Execution priority (higher numbers run first)"},"early_return":{"type":"string","description":"JavaScript expression to return early from the flow"},"chat_input_enabled":{"type":"boolean","description":"Whether this flow accepts chat-style input"},"notes":{"type":"array","description":"Sticky notes attached to the flow","items":{"$ref":"#/components/schemas/FlowNote"}},"groups":{"type":"array","description":"Semantic groups of modules for organizational purposes","items":{"$ref":"#/components/schemas/FlowGroup"}}},"required":["modules"]},"Retry":{"type":"object","description":"Retry configuration for failed module executions","properties":{"constant":{"type":"object","description":"Retry with constant delay between attempts","properties":{"attempts":{"type":"integer","description":"Number of retry attempts"},"seconds":{"type":"integer","description":"Seconds to wait between retries"}}},"exponential":{"type":"object","description":"Retry with exponential backoff (delay doubles each time)","properties":{"attempts":{"type":"integer","description":"Number of retry attempts"},"multiplier":{"type":"integer","description":"Multiplier for exponential backoff"},"seconds":{"type":"integer","minimum":1,"description":"Initial delay in seconds"},"random_factor":{"type":"integer","minimum":0,"maximum":100,"description":"Random jitter percentage (0-100) to avoid thundering herd"}}},"retry_if":{"$ref":"#/components/schemas/RetryIf"}}},"FlowNote":{"type":"object","description":"A sticky note attached to a flow for documentation and annotation","properties":{"id":{"type":"string","description":"Unique identifier for the note"},"text":{"type":"string","description":"Content of the note"},"position":{"type":"object","description":"Position of the note in the flow editor","properties":{"x":{"type":"number","description":"X coordinate"},"y":{"type":"number","description":"Y coordinate"}},"required":["x","y"]},"size":{"type":"object","description":"Size of the note in the flow editor","properties":{"width":{"type":"number","description":"Width in pixels"},"height":{"type":"number","description":"Height in pixels"}},"required":["width","height"]},"color":{"type":"string","description":"Color of the note (e.g., \\"yellow\\", \\"#ffff00\\")"},"type":{"type":"string","enum":["free","group"],"description":"Type of note - 'free' for standalone notes, 'group' for notes that group other nodes"},"locked":{"type":"boolean","default":false,"description":"Whether the note is locked and cannot be edited or moved"},"contained_node_ids":{"type":"array","items":{"type":"string"},"description":"For group notes, the IDs of nodes contained within this group"}},"required":["id","text","color","type"]},"FlowGroup":{"type":"object","description":"A semantic group of flow modules for organizational purposes. Does not affect execution \\u2014 modules remain in their original position in the flow. Groups provide naming and collapsibility in the editor. Members are computed dynamically from all nodes on paths between start_id and end_id.","properties":{"summary":{"type":"string","description":"Display name for this group"},"note":{"type":"string","description":"Markdown note shown below the group header"},"autocollapse":{"type":"boolean","default":false,"description":"If true, this group is collapsed by default in the flow editor. UI hint only."},"start_id":{"type":"string","description":"ID of the first flow module in this group (topological entry point)"},"end_id":{"type":"string","description":"ID of the last flow module in this group (topological exit point)"},"color":{"type":"string","description":"Color for the group in the flow editor"}},"required":["start_id","end_id"]},"RetryIf":{"type":"object","description":"Conditional retry based on error or result","properties":{"expr":{"type":"string","description":"JavaScript expression that returns true to retry. Has access to 'result' and 'error' variables"}},"required":["expr"]},"StopAfterIf":{"type":"object","description":"Early termination condition for a module","properties":{"skip_if_stopped":{"type":"boolean","description":"If true, following steps are skipped when this condition triggers"},"expr":{"type":"string","description":"JavaScript expression evaluated after the module runs. Can use 'result' (step's result) or 'flow_input'. Return true to stop"},"error_message":{"type":"string","nullable":true,"description":"Custom error message when stopping with an error. Mutually exclusive with skip_if_stopped. If set to a non-empty string, the flow stops with this error. If empty string, a default error message is used. If null or omitted, no error is raised."}},"required":["expr"]},"FlowModule":{"type":"object","description":"A single step in a flow. Can be a script, subflow, loop, or branch","properties":{"id":{"type":"string","description":"Unique identifier for this step. Used to reference results via 'results.step_id'. Must be a valid identifier (alphanumeric, underscore, hyphen)"},"value":{"$ref":"#/components/schemas/FlowModuleValue"},"stop_after_if":{"description":"Early termination condition evaluated after this step completes","$ref":"#/components/schemas/StopAfterIf"},"stop_after_all_iters_if":{"description":"For loops only - early termination condition evaluated after all iterations complete","$ref":"#/components/schemas/StopAfterIf"},"skip_if":{"type":"object","description":"Conditionally skip this step based on previous results or flow inputs","properties":{"expr":{"type":"string","description":"JavaScript expression that returns true to skip. Can use 'flow_input' or 'results.<step_id>'"}},"required":["expr"]},"sleep":{"description":"Delay before executing this step (in seconds or as expression)","$ref":"#/components/schemas/InputTransform"},"cache_ttl":{"type":"number","description":"Cache duration in seconds for this step's results"},"cache_ignore_s3_path":{"type":"boolean"},"timeout":{"description":"Maximum execution time in seconds (static value or expression)","$ref":"#/components/schemas/InputTransform"},"delete_after_secs":{"type":"integer","description":"If set, delete the step's args, result and logs after this many seconds following job completion"},"summary":{"type":"string","description":"Short description of what this step does"},"mock":{"type":"object","description":"Mock configuration for testing without executing the actual step","properties":{"enabled":{"type":"boolean","description":"If true, return mock value instead of executing"},"return_value":{"description":"Value to return when mocked"}}},"suspend":{"type":"object","description":"Configuration for approval/resume steps that wait for user input","properties":{"required_events":{"type":"integer","description":"Number of approvals required before continuing"},"timeout":{"type":"integer","description":"Timeout in seconds before auto-continuing or canceling"},"resume_form":{"type":"object","description":"Form schema for collecting input when resuming","properties":{"schema":{"type":"object","description":"JSON Schema for the resume form"}}},"user_auth_required":{"type":"boolean","description":"If true, only authenticated users can approve"},"user_groups_required":{"description":"Expression or list of groups that can approve","$ref":"#/components/schemas/InputTransform"},"self_approval_disabled":{"type":"boolean","description":"If true, the user who started the flow cannot approve"},"hide_cancel":{"type":"boolean","description":"If true, hide the cancel button on the approval form"},"continue_on_disapprove_timeout":{"type":"boolean","description":"If true, continue flow on timeout instead of canceling"}}},"priority":{"type":"number","description":"Execution priority for this step (higher numbers run first)"},"continue_on_error":{"type":"boolean","description":"If true, flow continues even if this step fails"},"retry":{"description":"Retry configuration if this step fails","$ref":"#/components/schemas/Retry"},"debouncing":{"description":"Debounce configuration for this step (EE only)","type":"object","properties":{"debounce_delay_s":{"type":"integer","description":"Delay in seconds to debounce this step's executions across flow runs"},"debounce_key":{"type":"string","description":"Expression to group debounced executions. Supports $workspace and $args[name]. Default: $workspace/flow/<flow_path>-<step_id>"},"debounce_args_to_accumulate":{"type":"array","description":"Array-type arguments to accumulate across debounced executions","items":{"type":"string"}},"max_total_debouncing_time":{"type":"integer","description":"Maximum total time in seconds before forced execution"},"max_total_debounces_amount":{"type":"integer","description":"Maximum number of debounces before forced execution"}}}},"required":["value","id"]},"InputTransform":{"description":"Maps input parameters for a step. Can be a static value or a JavaScript expression that references previous results or flow inputs","oneOf":[{"$ref":"#/components/schemas/StaticTransform"},{"$ref":"#/components/schemas/JavascriptTransform"},{"$ref":"#/components/schemas/AiTransform"}],"discriminator":{"propertyName":"type","mapping":{"static":"#/components/schemas/StaticTransform","javascript":"#/components/schemas/JavascriptTransform","ai":"#/components/schemas/AiTransform"}}},"StaticTransform":{"type":"object","description":"Static value passed directly to the step. Use for hardcoded values or resource references like '$res:path/to/resource'","properties":{"value":{"description":"The static value. For resources, use format '$res:path/to/resource'"},"type":{"type":"string","enum":["static"]}},"required":["type"]},"JavascriptTransform":{"type":"object","description":"JavaScript expression evaluated at runtime. Can reference previous step results via 'results.step_id' or flow inputs via 'flow_input.property'. Inside loops, use 'flow_input.iter.value' for the current iteration value","properties":{"expr":{"type":"string","description":"JavaScript expression returning the value. Available variables - results (object with all previous step results), flow_input (flow inputs), flow_input.iter (in loops)"},"type":{"type":"string","enum":["javascript"]}},"required":["expr","type"]},"AiTransform":{"type":"object","description":"Value resolved by the AI runtime for this input. The AI engine decides how to satisfy the parameter.","properties":{"type":{"type":"string","enum":["ai"]}},"required":["type"]},"AIProviderKind":{"type":"string","description":"Supported AI provider types","enum":["openai","azure_openai","anthropic","mistral","deepseek","googleai","groq","openrouter","togetherai","customai","aws_bedrock"]},"ProviderConfig":{"type":"object","description":"Complete AI provider configuration with resource reference and model selection","properties":{"kind":{"$ref":"#/components/schemas/AIProviderKind"},"resource":{"type":"string","description":"Resource reference in format '$res:{resource_path}' pointing to provider credentials"},"model":{"type":"string","description":"Model identifier (e.g., 'gpt-4', 'claude-3-opus-20240229', 'gemini-pro')"}},"required":["kind","resource","model"]},"StaticProviderTransform":{"type":"object","description":"Static provider configuration passed directly to the AI agent","properties":{"value":{"$ref":"#/components/schemas/ProviderConfig"},"type":{"type":"string","enum":["static"]}},"required":["type","value"]},"ProviderTransform":{"description":"Provider configuration - can be static (ProviderConfig), JavaScript expression, or AI-determined","oneOf":[{"$ref":"#/components/schemas/StaticProviderTransform"},{"$ref":"#/components/schemas/JavascriptTransform"},{"$ref":"#/components/schemas/AiTransform"}],"discriminator":{"propertyName":"type","mapping":{"static":"#/components/schemas/StaticProviderTransform","javascript":"#/components/schemas/JavascriptTransform","ai":"#/components/schemas/AiTransform"}}},"MemoryOff":{"type":"object","description":"No conversation memory/context","properties":{"kind":{"type":"string","enum":["off"]}},"required":["kind"]},"MemoryAuto":{"type":"object","description":"Automatic context management","properties":{"kind":{"type":"string","enum":["auto"]},"context_length":{"type":"integer","description":"Maximum number of messages to retain in context"},"memory_id":{"type":"string","description":"Identifier for persistent memory across agent invocations"}},"required":["kind"]},"MemoryMessage":{"type":"object","description":"A single message in conversation history","properties":{"role":{"type":"string","enum":["user","assistant","system"]},"content":{"type":"string"}},"required":["role","content"]},"MemoryManual":{"type":"object","description":"Explicit message history","properties":{"kind":{"type":"string","enum":["manual"]},"messages":{"type":"array","items":{"$ref":"#/components/schemas/MemoryMessage"}}},"required":["kind","messages"]},"MemoryConfig":{"description":"Conversation memory configuration","oneOf":[{"$ref":"#/components/schemas/MemoryOff"},{"$ref":"#/components/schemas/MemoryAuto"},{"$ref":"#/components/schemas/MemoryManual"}],"discriminator":{"propertyName":"kind","mapping":{"off":"#/components/schemas/MemoryOff","auto":"#/components/schemas/MemoryAuto","manual":"#/components/schemas/MemoryManual"}}},"StaticMemoryTransform":{"type":"object","description":"Static memory configuration passed directly to the AI agent","properties":{"value":{"$ref":"#/components/schemas/MemoryConfig"},"type":{"type":"string","enum":["static"]}},"required":["type","value"]},"MemoryTransform":{"description":"Memory configuration - can be static (MemoryConfig), JavaScript expression, or AI-determined","oneOf":[{"$ref":"#/components/schemas/StaticMemoryTransform"},{"$ref":"#/components/schemas/JavascriptTransform"},{"$ref":"#/components/schemas/AiTransform"}],"discriminator":{"propertyName":"type","mapping":{"static":"#/components/schemas/StaticMemoryTransform","javascript":"#/components/schemas/JavascriptTransform","ai":"#/components/schemas/AiTransform"}}},"FlowModuleValue":{"description":"The actual implementation of a flow step. Can be a script (inline or referenced), subflow, loop, branch, or special module type","oneOf":[{"$ref":"#/components/schemas/RawScript"},{"$ref":"#/components/schemas/PathScript"},{"$ref":"#/components/schemas/PathFlow"},{"$ref":"#/components/schemas/ForloopFlow"},{"$ref":"#/components/schemas/WhileloopFlow"},{"$ref":"#/components/schemas/BranchOne"},{"$ref":"#/components/schemas/BranchAll"},{"$ref":"#/components/schemas/Identity"},{"$ref":"#/components/schemas/AiAgent"}],"discriminator":{"propertyName":"type","mapping":{"rawscript":"#/components/schemas/RawScript","script":"#/components/schemas/PathScript","flow":"#/components/schemas/PathFlow","forloopflow":"#/components/schemas/ForloopFlow","whileloopflow":"#/components/schemas/WhileloopFlow","branchone":"#/components/schemas/BranchOne","branchall":"#/components/schemas/BranchAll","identity":"#/components/schemas/Identity","aiagent":"#/components/schemas/AiAgent"}}},"RawScript":{"type":"object","description":"Inline script with code defined directly in the flow. Use 'bun' as default language if unspecified. The script receives arguments from input_transforms","properties":{"input_transforms":{"type":"object","description":"Map of parameter names to their values (static or JavaScript expressions). These become the script's input arguments","additionalProperties":{"$ref":"#/components/schemas/InputTransform"}},"content":{"type":"string","description":"The script source code. Should export a 'main' function"},"language":{"type":"string","description":"Programming language for this script","enum":["deno","bun","python3","go","bash","powershell","postgresql","mysql","bigquery","snowflake","mssql","oracledb","graphql","nativets","php","rust","ansible","csharp","nu","java","ruby","rlang","duckdb"]},"path":{"type":"string","description":"Optional path for saving this script"},"lock":{"type":"string","description":"Lock file content for dependencies"},"type":{"type":"string","enum":["rawscript"]},"tag":{"type":"string","description":"Worker group tag for execution routing"},"concurrent_limit":{"type":"number","description":"Maximum concurrent executions of this script"},"concurrency_time_window_s":{"type":"number","description":"Time window for concurrent_limit"},"custom_concurrency_key":{"type":"string","description":"Custom key for grouping concurrent executions"},"is_trigger":{"type":"boolean","description":"If true, this script is a trigger that can start the flow"},"assets":{"type":"array","description":"External resources this script accesses (S3 objects, resources, etc.)","items":{"type":"object","required":["path","kind"],"properties":{"path":{"type":"string","description":"Path to the asset"},"kind":{"type":"string","description":"Type of asset","enum":["s3object","resource","ducklake","datatable","volume"]},"access_type":{"type":"string","nullable":true,"description":"Access level for this asset","enum":["r","w","rw"]},"alt_access_type":{"type":"string","nullable":true,"description":"Alternative access level","enum":["r","w","rw"]}}}}},"required":["type","content","language","input_transforms"]},"PathScript":{"type":"object","description":"Reference to an existing script by path. Use this when calling a previously saved script instead of writing inline code","properties":{"input_transforms":{"type":"object","description":"Map of parameter names to their values (static or JavaScript expressions). These become the script's input arguments","additionalProperties":{"$ref":"#/components/schemas/InputTransform"}},"path":{"type":"string","description":"Path to the script in the workspace (e.g., 'f/scripts/send_email')"},"hash":{"type":"string","description":"Optional specific version hash of the script to use"},"type":{"type":"string","enum":["script"]},"tag_override":{"type":"string","description":"Override the script's default worker group tag"},"is_trigger":{"type":"boolean","description":"If true, this script is a trigger that can start the flow"}},"required":["type","path","input_transforms"]},"PathFlow":{"type":"object","description":"Reference to an existing flow by path. Use this to call another flow as a subflow","properties":{"input_transforms":{"type":"object","description":"Map of parameter names to their values (static or JavaScript expressions). These become the subflow's input arguments","additionalProperties":{"$ref":"#/components/schemas/InputTransform"}},"path":{"type":"string","description":"Path to the flow in the workspace (e.g., 'f/flows/process_user')"},"type":{"type":"string","enum":["flow"]}},"required":["type","path","input_transforms"]},"ForloopFlow":{"type":"object","description":"Executes nested modules in a loop over an iterator. Inside the loop, use 'flow_input.iter.value' to access the current iteration value, and 'flow_input.iter.index' for the index. Supports parallel execution for better performance on I/O-bound operations","properties":{"modules":{"type":"array","description":"Steps to execute for each iteration. These can reference the iteration value via 'flow_input.iter.value'","items":{"$ref":"#/components/schemas/FlowModule"}},"iterator":{"description":"JavaScript expression that returns an array to iterate over. Can reference 'results.step_id' or 'flow_input'","$ref":"#/components/schemas/InputTransform"},"skip_failures":{"type":"boolean","description":"If true, iteration failures don't stop the loop. Failed iterations return null"},"type":{"type":"string","enum":["forloopflow"]},"parallel":{"type":"boolean","description":"If true, iterations run concurrently (faster for I/O-bound operations). Use with parallelism to control concurrency"},"parallelism":{"description":"Maximum number of concurrent iterations when parallel=true. Limits resource usage. Can be static number or expression","$ref":"#/components/schemas/InputTransform"},"squash":{"type":"boolean"}},"required":["modules","iterator","skip_failures","type"]},"WhileloopFlow":{"type":"object","description":"Executes nested modules repeatedly while a condition is true. The loop checks the condition after each iteration. Use stop_after_if on modules to control loop termination","properties":{"modules":{"type":"array","description":"Steps to execute in each iteration. Use stop_after_if to control when the loop ends","items":{"$ref":"#/components/schemas/FlowModule"}},"skip_failures":{"type":"boolean","description":"If true, iteration failures don't stop the loop. Failed iterations return null"},"type":{"type":"string","enum":["whileloopflow"]},"parallel":{"type":"boolean","description":"If true, iterations run concurrently (use with caution in while loops)"},"parallelism":{"description":"Maximum number of concurrent iterations when parallel=true","$ref":"#/components/schemas/InputTransform"},"squash":{"type":"boolean"}},"required":["modules","skip_failures","type"]},"BranchOne":{"type":"object","description":"Conditional branching where only the first matching branch executes. Branches are evaluated in order, and the first one with a true expression runs. If no branches match, the default branch executes","properties":{"branches":{"type":"array","description":"Array of branches to evaluate in order. The first branch with expr evaluating to true executes","items":{"type":"object","properties":{"summary":{"type":"string","description":"Short description of this branch condition"},"expr":{"type":"string","description":"JavaScript expression that returns boolean. Can use 'results.step_id' or 'flow_input'. First true expr wins"},"modules":{"type":"array","description":"Steps to execute if this branch's expr is true","items":{"$ref":"#/components/schemas/FlowModule"}}},"required":["modules","expr"]}},"default":{"type":"array","description":"Steps to execute if no branch expressions match","items":{"$ref":"#/components/schemas/FlowModule"}},"type":{"type":"string","enum":["branchone"]}},"required":["branches","default","type"]},"BranchAll":{"type":"object","description":"Parallel branching where all branches execute simultaneously. Unlike BranchOne, all branches run regardless of conditions. Useful for executing independent tasks concurrently","properties":{"branches":{"type":"array","description":"Array of branches that all execute (either in parallel or sequentially)","items":{"type":"object","properties":{"summary":{"type":"string","description":"Short description of this branch's purpose"},"skip_failure":{"type":"boolean","description":"If true, failure in this branch doesn't fail the entire flow"},"modules":{"type":"array","description":"Steps to execute in this branch","items":{"$ref":"#/components/schemas/FlowModule"}}},"required":["modules"]}},"type":{"type":"string","enum":["branchall"]},"parallel":{"type":"boolean","description":"If true, all branches execute concurrently. If false, they execute sequentially"}},"required":["branches","type"]},"AgentTool":{"type":"object","description":"A tool available to an AI agent. Can be a flow module or an external MCP (Model Context Protocol) tool","properties":{"id":{"type":"string","description":"Unique identifier for this tool. Cannot contain spaces - use underscores instead (e.g., 'get_user_data' not 'get user data')"},"summary":{"type":"string","description":"Short description of what this tool does (shown to the AI)"},"value":{"$ref":"#/components/schemas/ToolValue"}},"required":["id","value"]},"ToolValue":{"description":"The implementation of a tool. Can be a flow module (script/flow) or an MCP tool reference","oneOf":[{"$ref":"#/components/schemas/FlowModuleTool"},{"$ref":"#/components/schemas/McpToolValue"},{"$ref":"#/components/schemas/WebsearchToolValue"}],"discriminator":{"propertyName":"tool_type","mapping":{"flowmodule":"#/components/schemas/FlowModuleTool","mcp":"#/components/schemas/McpToolValue","websearch":"#/components/schemas/WebsearchToolValue"}}},"FlowModuleTool":{"description":"A tool implemented as a flow module (script, flow, etc.). The AI can call this like any other flow module","allOf":[{"type":"object","properties":{"tool_type":{"type":"string","enum":["flowmodule"]}},"required":["tool_type"]},{"$ref":"#/components/schemas/FlowModuleValue"}]},"WebsearchToolValue":{"type":"object","description":"A tool implemented as a websearch tool. The AI can call this like any other websearch tool","properties":{"tool_type":{"type":"string","enum":["websearch"]}},"required":["tool_type"]},"McpToolValue":{"type":"object","description":"Reference to an external MCP (Model Context Protocol) tool. The AI can call tools from MCP servers","properties":{"tool_type":{"type":"string","enum":["mcp"]},"resource_path":{"type":"string","description":"Path to the MCP resource/server configuration"},"include_tools":{"type":"array","description":"Whitelist of specific tools to include from this MCP server","items":{"type":"string"}},"exclude_tools":{"type":"array","description":"Blacklist of tools to exclude from this MCP server","items":{"type":"string"}}},"required":["tool_type","resource_path"]},"AiAgent":{"type":"object","description":"AI agent step that can use tools to accomplish tasks. The agent receives inputs and can call any of its configured tools to complete the task","properties":{"input_transforms":{"type":"object","description":"Input parameters for the AI agent mapped to their values","properties":{"provider":{"$ref":"#/components/schemas/ProviderTransform"},"output_type":{"allOf":[{"$ref":"#/components/schemas/InputTransform"}],"description":"Output format type.\\nValid values: 'text' (default) - plain text response, 'image' - image generation\\n"},"user_message":{"allOf":[{"$ref":"#/components/schemas/InputTransform"}],"description":"The user's prompt/message to the AI agent. Supports variable interpolation with flow.input syntax."},"system_prompt":{"allOf":[{"$ref":"#/components/schemas/InputTransform"}],"description":"System instructions that guide the AI's behavior, persona, and response style. Optional."},"streaming":{"allOf":[{"$ref":"#/components/schemas/InputTransform"}],"description":"Boolean. If true, stream the AI response incrementally.\\nStreaming events include: token_delta, tool_call, tool_call_arguments, tool_execution, tool_result\\n"},"memory":{"$ref":"#/components/schemas/MemoryTransform"},"output_schema":{"allOf":[{"$ref":"#/components/schemas/InputTransform"}],"description":"JSON Schema object defining structured output format. Used when you need the AI to return data in a specific shape.\\nSupports standard JSON Schema properties: type, properties, required, items, enum, pattern, minLength, maxLength, minimum, maximum, etc.\\nExample: { type: 'object', properties: { name: { type: 'string' }, age: { type: 'integer' } }, required: ['name'] }\\n"},"user_attachments":{"allOf":[{"$ref":"#/components/schemas/InputTransform"}],"description":"Array of file references (images or PDFs) for the AI agent.\\nFormat: Array<{ bucket: string, key: string }> - S3 object references\\nExample: [{ bucket: 'my-bucket', key: 'documents/report.pdf' }]\\n"},"max_completion_tokens":{"allOf":[{"$ref":"#/components/schemas/InputTransform"}],"description":"Integer. Maximum number of tokens the AI will generate in its response.\\nRange: 1 to 4,294,967,295. Typical values: 256-4096 for most use cases.\\n"},"temperature":{"allOf":[{"$ref":"#/components/schemas/InputTransform"}],"description":"Float. Controls randomness/creativity of responses.\\nRange: 0.0 to 2.0 (provider-dependent)\\n- 0.0 = deterministic, focused responses\\n- 0.7 = balanced (common default)\\n- 1.0+ = more creative/random\\n"},"max_iterations":{"allOf":[{"$ref":"#/components/schemas/InputTransform"}],"description":"Number. Limits how many times the agent can loop through reasoning and tool use.\\nRange: 1-1000.\\n"}},"required":["provider","user_message","output_type"]},"tools":{"type":"array","description":"Array of tools the agent can use. The agent decides which tools to call based on the task","items":{"$ref":"#/components/schemas/AgentTool"}},"type":{"type":"string","enum":["aiagent"]},"omit_output_from_conversation":{"type":"boolean","default":false,"description":"If true, this AI agent step does not persist its assistant or tool messages to the flow conversation when chat mode is enabled."},"parallel":{"type":"boolean","description":"If true, the agent can execute multiple tool calls in parallel"}},"required":["tools","type","input_transforms"]},"Identity":{"type":"object","description":"Pass-through module that returns its input unchanged. Useful for flow structure or as a placeholder","properties":{"type":{"type":"string","enum":["identity"]},"flow":{"type":"boolean","description":"If true, marks this as a flow identity (special handling)"}},"required":["type"]},"FlowStatus":{"type":"object","properties":{"step":{"type":"integer"},"modules":{"type":"array","items":{"$ref":"#/components/schemas/FlowStatusModule"}},"user_states":{"additionalProperties":true},"preprocessor_module":{"allOf":[{"$ref":"#/components/schemas/FlowStatusModule"}]},"failure_module":{"allOf":[{"$ref":"#/components/schemas/FlowStatusModule"},{"type":"object","properties":{"parent_module":{"type":"string"}}}]},"retry":{"type":"object","properties":{"fail_count":{"type":"integer"},"failed_jobs":{"type":"array","items":{"type":"string","format":"uuid"}}}}},"required":["step","modules","failure_module"]},"FlowStatusModule":{"type":"object","properties":{"type":{"type":"string","enum":["WaitingForPriorSteps","WaitingForEvents","WaitingForExecutor","InProgress","Success","Failure"]},"id":{"type":"string"},"job":{"type":"string","format":"uuid"},"count":{"type":"integer"},"progress":{"type":"integer"},"iterator":{"type":"object","properties":{"index":{"type":"integer"},"itered":{"type":"array","items":{}},"itered_len":{"type":"integer"},"args":{}}},"flow_jobs":{"type":"array","items":{"type":"string"}},"flow_jobs_success":{"type":"array","items":{"type":"boolean"}},"flow_jobs_duration":{"type":"object","properties":{"started_at":{"type":"array","items":{"type":"string"}},"duration_ms":{"type":"array","items":{"type":"integer"}}}},"branch_chosen":{"type":"object","properties":{"type":{"type":"string","enum":["branch","default"]},"branch":{"type":"integer"}},"required":["type"]},"branchall":{"type":"object","properties":{"branch":{"type":"integer"},"len":{"type":"integer"}},"required":["branch","len"]},"approvers":{"type":"array","items":{"type":"object","properties":{"resume_id":{"type":"integer"},"approver":{"type":"string"}},"required":["resume_id","approver"]}},"failed_retries":{"type":"array","items":{"type":"string","format":"uuid"}},"skipped":{"type":"boolean"},"agent_actions":{"type":"array","items":{"type":"object","oneOf":[{"type":"object","properties":{"job_id":{"type":"string","format":"uuid"},"function_name":{"type":"string"},"type":{"type":"string","enum":["tool_call"]},"module_id":{"type":"string"}},"required":["job_id","function_name","type","module_id"]},{"type":"object","properties":{"call_id":{"type":"string","format":"uuid"},"function_name":{"type":"string"},"resource_path":{"type":"string"},"type":{"type":"string","enum":["mcp_tool_call"]},"arguments":{"type":"object"}},"required":["call_id","function_name","resource_path","type"]},{"type":"object","properties":{"type":{"type":"string","enum":["web_search"]}},"required":["type"]},{"type":"object","properties":{"type":{"type":"string","enum":["message"]}},"required":["content","type"]}]}},"agent_actions_success":{"type":"array","items":{"type":"boolean"}}},"required":["type"]}}`,
   "raw-app": `---
 name: raw-app
 description: MUST use when creating raw apps.
@@ -7279,6 +6608,7 @@ sync local with a remote workspaces or the opposite (push or pull)
   - \`--include-groups\` - Include syncing groups
   - \`--include-settings\` - Include syncing workspace settings
   - \`--include-key\` - Include workspace encryption key
+  - \`--skip-reencrypt-on-key-change\` - When the pushed encryption key differs from the remote, do NOT re-encrypt existing remote secrets. Only safe if they are already encrypted with the new key (e.g. workspace/instance migration). Default is to re-encrypt.
   - \`--skip-branch-validation\` - Skip git branch validation and prompts
   - \`--json-output\` - Output results in JSON format
   - \`-i --includes <patterns:file[]>\` - Comma separated patterns to specify which file to take into account (among files that are compatible with windmill). Patterns can include * (any string until '/') and ** (any string)
diff --git a/cli/src/guidance/writer.ts b/cli/src/guidance/writer.ts
index fcaae0671a..033519bf8e 100644
--- a/cli/src/guidance/writer.ts
+++ b/cli/src/guidance/writer.ts
@@ -207,13 +207,19 @@ async function reconcileIncludingFile(options: {
 }
 
 function referencesIncludeLine(content: string, includeLine: string): boolean {
-  // Match only when the include sits on a line by itself (allowing leading
-  // and trailing whitespace). Earlier we split on `\s+`, but that
-  // false-positives on commented-out includes like `<!-- @AGENTS.cli.md -->`
-  // where the middle token equals the include. CRLF is handled by the
-  // `\r?\n` split.
+  // Match when the include appears as a whitespace-separated token on any
+  // line that isn't an HTML comment. We can't require the include to be on a
+  // line by itself: our own CLAUDE.md default is `Instructions are in
+  // @AGENTS.md` (one sentence), and a strict equality check made `wmill
+  // refresh prompts` re-prompt every run on files wmill itself wrote.
+  // Skipping comment-bearing lines keeps `<!-- @AGENTS.cli.md -->` from
+  // false-positiving.
   for (const line of content.split(/\r?\n/)) {
-    if (line.trim() === includeLine) {
+    const trimmed = line.trim();
+    if (trimmed.startsWith("<!--") || trimmed.endsWith("-->")) {
+      continue;
+    }
+    if (trimmed.split(/\s+/).includes(includeLine)) {
       return true;
     }
   }
diff --git a/cli/src/main.ts b/cli/src/main.ts
index cc8f9e80b7..da4a46da71 100755
--- a/cli/src/main.ts
+++ b/cli/src/main.ts
@@ -89,7 +89,7 @@ export {
   token,
 };
 
-export const VERSION = "1.711.0";
+export const VERSION = "1.714.0";
 
 // Re-exported from constants.ts to maintain backwards compatibility
 export { WM_FORK_PREFIX } from "./core/constants.ts";
diff --git a/cli/src/types.ts b/cli/src/types.ts
index e0d45adb66..5de6cea48b 100644
--- a/cli/src/types.ts
+++ b/cli/src/types.ts
@@ -18,7 +18,11 @@ import { pushSchedule } from "./commands/schedule/schedule.ts";
 import { pushWorkspaceUser } from "./commands/user/user.ts";
 import { pushGroup } from "./commands/user/user.ts";
 import { pushWorkspaceDependencies } from "./commands/dependencies/dependencies.ts";
-import { pushWorkspaceSettings, pushWorkspaceKey } from "./core/settings.ts";
+import {
+  pushWorkspaceSettings,
+  pushWorkspaceKey,
+  PushWorkspaceKeyOptions,
+} from "./core/settings.ts";
 import { pushTrigger, pushNativeTrigger } from "./commands/trigger/trigger.ts";
 import { pushRawApp } from "./commands/app/raw_apps.ts";
 import type { PermissionedAsContext } from "./core/permissioned_as.ts";
@@ -129,11 +133,46 @@ export function showDiff(local: string, remote: string) {
 
 export function showConflict(path: string, local: string, remote: string) {
   log.info(colors.yellow(`- ${path}`));
-  showDiff(local, remote);
+  let isEncryptionKey = false;
+  try {
+    isEncryptionKey = getTypeStrFromPath(path) === "encryption_key";
+  } catch {
+    // ignore
+  }
+  if (isEncryptionKey) {
+    showDiff(redactEncryptionKey(local), redactEncryptionKey(remote));
+  } else {
+    showDiff(local, remote);
+  }
   log.info("\x1b[31mlocal\x1b[31m - \x1b[32mremote\x1b[32m");
   log.info("\n");
 }
 
+// Reveal only the first 5 chars of the key so a rotation is still visible in
+// the diff (different prefixes), without leaking the whole secret to stdout.
+// The remaining chars are replaced with `*`, preserving length so the diff
+// keeps showing whether the key length changed.
+export function redactEncryptionKey(content: string): string {
+  if (!content) return content;
+  // The encryption_key payload is JSON-encoded (a quoted string). Parse it so
+  // we redact the key value itself, then re-serialize to JSON to preserve the
+  // file's shape; fall back to raw redaction if parsing fails.
+  try {
+    const parsed = JSON.parse(content);
+    if (typeof parsed === "string") {
+      return JSON.stringify(redactString(parsed));
+    }
+  } catch {
+    // not JSON — treat content as the raw key
+  }
+  return redactString(content);
+}
+
+function redactString(s: string): string {
+  if (s.length <= 5) return s;
+  return s.slice(0, 5) + "*".repeat(s.length - 5);
+}
+
 /**
  * Pushes an object to the workspace server based on its type
  * @param workspace - The workspace ID to push to
@@ -144,6 +183,7 @@ export function showConflict(path: string, local: string, remote: string) {
  * @param alreadySynced - Array to track already synced items
  * @param message - Optional commit/update message
  * @param originalLocalPath - The original local file path (used for branch-specific resource file resolution)
+ * @param keyPushOpts - Options for the encryption_key push: non-interactive flag and explicit re-encryption choice
  */
 export async function pushObj(
   workspace: string,
@@ -156,6 +196,7 @@ export async function pushObj(
   originalLocalPath?: string,
   permissionedAsContext?: PermissionedAsContext,
   wsSpecific?: boolean,
+  keyPushOpts?: PushWorkspaceKeyOptions,
 ) {
   const typeEnding = getTypeStrFromPath(p);
 
@@ -221,7 +262,7 @@ export async function pushObj(
   } else if (typeEnding === "settings") {
     await pushWorkspaceSettings(workspace, p, befObj, newObj);
   } else if (typeEnding === "encryption_key") {
-    await pushWorkspaceKey(workspace, p, befObj, newObj);
+    await pushWorkspaceKey(workspace, p, befObj, newObj, keyPushOpts);
   } else {
     throw new Error(
       `The item ${p} has an unrecognized type ending ${typeEnding}`
diff --git a/cli/src/utils/git.ts b/cli/src/utils/git.ts
index 6e0ba55ec9..0d2e8cb8a8 100644
--- a/cli/src/utils/git.ts
+++ b/cli/src/utils/git.ts
@@ -252,21 +252,44 @@ export function gitSyncIncludePattern(
   }
 }
 
-export interface GitSyncDeployIncludes {
-  extraIncludes: string[];
+// `forcedIncludes` carries ONLY the include-* flags that must be force-set to
+// true (overriding the repo's wmill.yaml). Kinds not present are intentionally
+// omitted (never set to false) so the caller can spread this object and let
+// the repo's effective config govern the rest — see deriveGitSyncDeployIncludes.
+export type GitSyncForcedIncludes = Partial<{
   includeSchedules: boolean;
   includeGroups: boolean;
   includeUsers: boolean;
   includeTriggers: boolean;
   includeSettings: boolean;
   includeKey: boolean;
+}>;
+
+export interface GitSyncDeployIncludes {
+  extraIncludes: string[];
+  forcedIncludes: GitSyncForcedIncludes;
 }
 
 // Mirrors the hub script's wmill_sync_pull include-derivation: build the
-// --extra-includes set from the deployed items, and (only in workspace-wide
-// mode — never with --use-individual-branch) opt object kinds that are
-// excluded by default back in. Replaces the script's regexFromPath +
+// --extra-includes set from the deployed items, and decide which default-
+// excluded object kinds (triggers, schedules, groups, users, settings, key)
+// must be force-included in the pull. Replaces the script's regexFromPath +
 // per-kind --include-* construction so the hub script can drop both.
+//
+// Branch-mode distinction (this is load-bearing — see the trigger-promotion
+// bug it fixes):
+//   - Workspace-wide mode: the repo is a full mirror of the workspace, so a
+//     deployed object of a default-excluded kind MUST be re-included, even if
+//     wmill.yaml would otherwise skip it. We force the flag on.
+//   - Individual-branch (promotion) mode: the repo is a filtered prod surface
+//     whose own wmill.yaml filters decide what gets promoted. We force NOTHING
+//     here and the keys stay absent, so the caller's pull resolves them from
+//     the target's effective config (a deployed trigger lands iff the target
+//     includes triggers). Forcing `false` (the original behavior) did NOT
+//     defer — it CLOBBERED the effective config via Object.assign in pull's
+//     option merge, silently dropping kinds the target actually wanted (e.g. a
+//     deployed trigger when the target has includeTriggers: true), and the
+//     server then omitted the object from the tarball entirely.
 export function deriveGitSyncDeployIncludes(
   items: GitSyncDeployItem[],
   useIndividualBranch: boolean,
@@ -283,18 +306,19 @@ export function deriveGitSyncDeployIncludes(
     }
   }
 
-  const has = (pred: (t: string) => boolean) =>
-    !useIndividualBranch && items.some((i) => pred(i.path_type));
+  const forcedIncludes: GitSyncForcedIncludes = {};
+  if (!useIndividualBranch) {
+    const has = (pred: (t: string) => boolean) =>
+      items.some((i) => pred(i.path_type));
+    if (has((t) => t === "schedule")) forcedIncludes.includeSchedules = true;
+    if (has((t) => t === "group")) forcedIncludes.includeGroups = true;
+    if (has((t) => t === "user")) forcedIncludes.includeUsers = true;
+    if (has((t) => t.includes("trigger"))) forcedIncludes.includeTriggers = true;
+    if (has((t) => t === "settings")) forcedIncludes.includeSettings = true;
+    if (has((t) => t === "key")) forcedIncludes.includeKey = true;
+  }
 
-  return {
-    extraIncludes,
-    includeSchedules: has((t) => t === "schedule"),
-    includeGroups: has((t) => t === "group"),
-    includeUsers: has((t) => t === "user"),
-    includeTriggers: has((t) => t.includes("trigger")),
-    includeSettings: has((t) => t === "settings"),
-    includeKey: has((t) => t === "key"),
-  };
+  return { extraIncludes, forcedIncludes };
 }
 
 function git(
diff --git a/cli/test/git_unit.test.ts b/cli/test/git_unit.test.ts
index f55e8d46b4..ebbc838f97 100644
--- a/cli/test/git_unit.test.ts
+++ b/cli/test/git_unit.test.ts
@@ -254,7 +254,7 @@ describe("deriveGitSyncDeployIncludes", () => {
     ]);
   });
 
-  test("workspace-wide mode opts excluded kinds back in", () => {
+  test("workspace-wide mode force-includes deployed default-excluded kinds", () => {
     const r = deriveGitSyncDeployIncludes(
       [
         { path_type: "schedule", path: "f/s" },
@@ -266,15 +266,36 @@ describe("deriveGitSyncDeployIncludes", () => {
       ],
       false
     );
-    expect(r.includeSchedules).toBe(true);
-    expect(r.includeGroups).toBe(true);
-    expect(r.includeTriggers).toBe(true);
-    expect(r.includeSettings).toBe(true);
-    expect(r.includeKey).toBe(true);
-    expect(r.includeUsers).toBe(true);
+    // Full-mirror repo: a deployed object of a default-excluded kind must be
+    // re-included even if wmill.yaml would skip it, so the flag is forced on.
+    expect(r.forcedIncludes).toEqual({
+      includeSchedules: true,
+      includeGroups: true,
+      includeTriggers: true,
+      includeSettings: true,
+      includeKey: true,
+      includeUsers: true,
+    });
   });
 
-  test("individual-branch mode NEVER sets include flags (matches hub script)", () => {
+  test("workspace-wide mode only forces the kinds actually deployed", () => {
+    const r = deriveGitSyncDeployIncludes(
+      [{ path_type: "script", path: "f/s" }],
+      false
+    );
+    // Scripts are included by default — nothing to force.
+    expect(r.forcedIncludes).toEqual({});
+  });
+
+  test("individual-branch (promotion) mode forces NOTHING — defers to wmill.yaml", () => {
+    // Regression: these flags used to be force-disabled (set to false) in
+    // promotion mode, which CLOBBERED the promotion target's effective
+    // wmill.yaml config (an explicit false wins in pull's Object.assign merge).
+    // The server then stripped the object from the tarball, the pull wrote
+    // nothing, and `git add '<path>**'` failed with "pathspec did not match
+    // any files". Forcing nothing leaves the keys absent so the target's
+    // effective filters govern; extraIncludes still scopes the pull to the
+    // changed object.
     const r = deriveGitSyncDeployIncludes(
       [
         { path_type: "schedule", path: "f/s" },
@@ -282,12 +303,27 @@ describe("deriveGitSyncDeployIncludes", () => {
       ],
       true
     );
-    expect(r.includeSchedules).toBe(false);
-    expect(r.includeTriggers).toBe(false);
-    // extra-includes are still derived regardless of branch mode
+    expect(r.forcedIncludes).toEqual({});
     expect(r.extraIncludes).toContain("f/s.schedule.*");
     expect(r.extraIncludes).toContain("f/t.kafka_trigger.*");
   });
+
+  test("regression: http_trigger promotion deploy does not clobber the target's includeTriggers", () => {
+    // Brad's scenario: an HTTP trigger is deployed and the promotion repo uses
+    // individual branches. path_type is "httptrigger" (the no-underscore value
+    // the backend puts on item.path_type — see git_sync_ee.rs
+    // insert_path_type_and_return_message). includeTriggers must NOT be forced
+    // false here, so the target's effective includeTriggers (true in Brad's
+    // config) is honored and the trigger file is pulled and committed.
+    const r = deriveGitSyncDeployIncludes(
+      [{ path_type: "httptrigger", path: "f/platform/on_call_chat_http_route" }],
+      true
+    );
+    expect(r.forcedIncludes.includeTriggers).toBeUndefined();
+    expect(r.extraIncludes).toContain(
+      "f/platform/on_call_chat_http_route.http_trigger.*"
+    );
+  });
 });
 
 // =============================================================================
diff --git a/cli/test/gitsync_promotion.test.ts b/cli/test/gitsync_promotion.test.ts
index 5b73e8f8e1..e33968d0fa 100644
--- a/cli/test/gitsync_promotion.test.ts
+++ b/cli/test/gitsync_promotion.test.ts
@@ -22,6 +22,18 @@ import { withTestBackend } from "./test_backend.ts";
 import { shouldSkipOnCI } from "./cargo_backend.ts";
 import { addWorkspace } from "../workspace.ts";
 
+// The HTTP-trigger promotion test creates an http_trigger, whose API routes are
+// behind the `http_trigger` cargo feature — NOT in the default EE test feature
+// set. The shared test backend reads TEST_FEATURES at construction (first
+// `withTestBackend` call), so appending here at module load enables it. Guarded
+// on shouldSkipOnCI() so we only widen the build when these EE tests actually
+// run (i.e. EE_LICENSE_KEY present); minimal CI builds stay untouched.
+if (!shouldSkipOnCI()) {
+  process.env["TEST_FEATURES"] = [process.env["TEST_FEATURES"], "http_trigger"]
+    .filter(Boolean)
+    .join(",");
+}
+
 function git(cwd: string, ...args: string[]): string {
   return execFileSync("git", args, { cwd, encoding: "utf8" }).trim();
 }
@@ -44,6 +56,24 @@ function remoteHead(bareDir: string, branch: string): string {
   ).trim();
 }
 
+// True if `filePath` exists in the tree of `branch` on the bare remote.
+function fileExistsOnBranch(
+  bareDir: string,
+  branch: string,
+  filePath: string,
+): boolean {
+  try {
+    execFileSync(
+      "git",
+      ["--git-dir", bareDir, "cat-file", "-e", `refs/heads/${branch}:${filePath}`],
+      { stdio: "ignore" },
+    );
+    return true;
+  } catch {
+    return false;
+  }
+}
+
 test.skipIf(shouldSkipOnCI())(
   "git-sync promotion: use_individual_branch pushes to wm_deploy branch, not main",
   async () => {
@@ -200,3 +230,419 @@ test.skipIf(shouldSkipOnCI())(
     });
   },
 );
+
+/**
+ * Regression test for the promotion trigger-include bug (fix/gitsync-promotion-
+ * trigger-export): deploying a trigger (or any excluded-by-default kind:
+ * schedule, group, user, settings, key) with `use_individual_branch` must still
+ * land the object file on the `wm_deploy` branch.
+ *
+ * Root cause: `deriveGitSyncDeployIncludes` used to force the per-kind include
+ * flags (`includeTriggers` etc.) to false in individual-branch mode. The
+ * server-side tarball export STRIPS those object kinds entirely when their
+ * include flag is false (`if include_triggers { … }` in workspaces_export.rs),
+ * and `extraIncludes` is only a client-side filter over what the tarball
+ * already contains — it can't recover a file the server never sent. So the
+ * pull wrote no trigger file, the wm_deploy branch was created empty of the
+ * trigger, and production's `git add '<path>**'` failed with "pathspec did not
+ * match any files". A script (always-included kind) never hit this — hence the
+ * dedicated trigger case here.
+ *
+ * Without the fix this test fails: the branch exists but the
+ * `*.http_trigger.yaml` file is absent from it.
+ */
+test.skipIf(shouldSkipOnCI())(
+  "git-sync promotion: use_individual_branch lands a trigger file on the wm_deploy branch",
+  async () => {
+    await withTestBackend(async (backend) => {
+      const ws = backend.workspace; // "test"
+      await addWorkspace(
+        {
+          remote: backend.baseUrl,
+          workspaceId: ws,
+          name: ws,
+          token: backend.token,
+        } as any,
+        { force: true, configDir: backend.testConfigDir },
+      );
+
+      // --- 1. Bare "remote" seeded with an initial `main` commit ---
+      const bareDir = await mkdtemp(join(tmpdir(), "wmill_promo_trig_bare_"));
+      execFileSync("git", ["init", "--bare", "--initial-branch=main", bareDir]);
+      const seedDir = await mkdtemp(join(tmpdir(), "wmill_promo_trig_seed_"));
+      git(seedDir, "init", "--initial-branch=main");
+      git(seedDir, "config", "user.email", "seed@windmill.dev");
+      git(seedDir, "config", "user.name", "seed");
+      await writeFile(join(seedDir, "README.md"), "# promo trigger test\n");
+      git(seedDir, "add", "-A");
+      git(seedDir, "commit", "-m", "seed");
+      git(seedDir, "remote", "add", "origin", `file://${bareDir}`);
+      git(seedDir, "push", "-u", "origin", "main");
+      const seedMain = remoteHead(bareDir, "main");
+
+      // --- 2. Workspace content: a script + an HTTP trigger pointing at it ---
+      await backend.apiRequest!(`/api/w/${ws}/folders/create`, {
+        method: "POST",
+        headers: { "Content-Type": "application/json" },
+        body: JSON.stringify({ name: "promo", owners: [], extra_perms: {} }),
+      });
+      await backend.apiRequest!(`/api/w/${ws}/scripts/create`, {
+        method: "POST",
+        headers: { "Content-Type": "application/json" },
+        body: JSON.stringify({
+          path: "f/promo/foo",
+          summary: "",
+          description: "",
+          content: "export async function main() { return 1 }",
+          language: "bun",
+        }),
+      });
+      const trigRes = await backend.apiRequest!(`/api/w/${ws}/http_triggers/create`, {
+        method: "POST",
+        headers: { "Content-Type": "application/json" },
+        body: JSON.stringify({
+          path: "f/promo/hook",
+          script_path: "f/promo/foo",
+          route_path: "promo_hook",
+          is_flow: false,
+          http_method: "post",
+          authentication_method: "none",
+          is_static_website: false,
+          request_type: "sync",
+        }),
+      });
+      // Guard against the route silently 404ing (the http_trigger cargo feature
+      // not being built) — otherwise the pull below would find nothing to sync
+      // and the real assertion would fail with a confusing message.
+      expect(trigRes.status).toBe(201);
+
+      // --- 3. git_repository resource + git-sync config (triggers included) ---
+      await backend.apiRequest!(`/api/w/${ws}/resources/create`, {
+        method: "POST",
+        headers: { "Content-Type": "application/json" },
+        body: JSON.stringify({
+          path: "u/test/promo_repo",
+          resource_type: "git_repository",
+          value: { url: `file://${bareDir}`, branch: "main", token: "" },
+        }),
+      });
+      await backend.updateGitSyncConfig!({
+        git_sync_settings: {
+          repositories: [
+            {
+              git_repo_resource_path: "u/test/promo_repo",
+              script_path: "f/**",
+              use_individual_branch: true,
+              group_by_folder: false,
+              settings: {
+                include_path: ["f/**"],
+                include_type: ["script", "trigger"],
+              },
+            },
+          ],
+        },
+      });
+
+      // The backend sets path_type "httptrigger" (no underscore) on the deploy
+      // item — see DeployedObject::HttpTrigger => "httptrigger" in git_sync_ee.rs.
+      const deployItems = JSON.stringify([
+        {
+          path_type: "httptrigger",
+          path: "f/promo/hook",
+          commit_msg: "deploy hook",
+        },
+      ]);
+
+      const work = await mkdtemp(join(tmpdir(), "wmill_promo_trig_work_"));
+      git(work, "clone", `file://${bareDir}`, ".");
+      // Option B semantic: in promotion mode the deploy forces NOTHING — the
+      // trigger lands only because THIS target's effective wmill.yaml opts
+      // triggers in. (Reverting the source fix re-introduces the force-`false`
+      // that clobbers this `includeTriggers: true`, so the file is dropped.)
+      await writeFile(
+        join(work, "wmill.yaml"),
+        "defaultTs: bun\nincludes:\n  - f/**\nexcludes: []\nincludeTriggers: true\n",
+      );
+      const res = await backend.runCLICommand(
+        [
+          "sync",
+          "git-deploy",
+          "--repository",
+          "u/test/promo_repo",
+          "--use-individual-branch",
+          "--git-deploy-items",
+          deployItems,
+        ],
+        work,
+      );
+      expect(res.code).toBe(0);
+
+      // Caller-half (mirrors the hub script): stage what the pull wrote, commit
+      // on the checked-out wm_deploy branch, push.
+      git(work, "config", "user.email", "test@windmill.dev");
+      git(work, "config", "user.name", "test");
+      git(work, "add", "-A");
+      try {
+        git(work, "diff", "--cached", "--quiet");
+      } catch {
+        git(work, "commit", "-m", "deploy hook");
+      }
+      git(work, "push", "--porcelain", "-u", "origin", "HEAD");
+
+      const expectedBranch = `refs/heads/wm_deploy/${ws}/httptrigger/f__promo__hook`;
+      expect(remoteBranches(bareDir)).toContain(expectedBranch);
+      // The regression: the trigger file MUST be present on the branch. Without
+      // the fix the include flag is false, the server strips the trigger from
+      // the tarball, the pull writes nothing, and this file is absent.
+      expect(
+        fileExistsOnBranch(
+          bareDir,
+          `wm_deploy/${ws}/httptrigger/f__promo__hook`,
+          "f/promo/hook.http_trigger.yaml",
+        ),
+      ).toBe(true);
+      // Base branch untouched (individual-branch never pushes to the base).
+      expect(remoteHead(bareDir, "main")).toBe(seedMain);
+
+      await rm(bareDir, { recursive: true, force: true });
+      await rm(seedDir, { recursive: true, force: true });
+      await rm(work, { recursive: true, force: true });
+    });
+  },
+);
+
+/**
+ * Same regression as the HTTP-trigger case above, for a `schedule` — a
+ * different excluded-by-default kind that exercises a DISTINCT path: its own
+ * include flag (`includeSchedules`), its own server-side `if include_schedules`
+ * tarball-strip branch, and its own `.schedule.yaml` extension. Unlike triggers
+ * it needs no extra cargo feature, so it guards the fix even where the
+ * trigger-specific features aren't built.
+ *
+ * Without the fix this test fails: the branch exists but the
+ * `*.schedule.yaml` file is absent from it.
+ */
+test.skipIf(shouldSkipOnCI())(
+  "git-sync promotion: use_individual_branch lands a schedule file on the wm_deploy branch",
+  async () => {
+    await withTestBackend(async (backend) => {
+      const ws = backend.workspace; // "test"
+      await addWorkspace(
+        {
+          remote: backend.baseUrl,
+          workspaceId: ws,
+          name: ws,
+          token: backend.token,
+        } as any,
+        { force: true, configDir: backend.testConfigDir },
+      );
+
+      // --- 1. Bare "remote" seeded with an initial `main` commit ---
+      const bareDir = await mkdtemp(join(tmpdir(), "wmill_promo_sched_bare_"));
+      execFileSync("git", ["init", "--bare", "--initial-branch=main", bareDir]);
+      const seedDir = await mkdtemp(join(tmpdir(), "wmill_promo_sched_seed_"));
+      git(seedDir, "init", "--initial-branch=main");
+      git(seedDir, "config", "user.email", "seed@windmill.dev");
+      git(seedDir, "config", "user.name", "seed");
+      await writeFile(join(seedDir, "README.md"), "# promo schedule test\n");
+      git(seedDir, "add", "-A");
+      git(seedDir, "commit", "-m", "seed");
+      git(seedDir, "remote", "add", "origin", `file://${bareDir}`);
+      git(seedDir, "push", "-u", "origin", "main");
+      const seedMain = remoteHead(bareDir, "main");
+
+      // --- 2. Workspace content: a script + a (disabled) schedule for it ---
+      await backend.apiRequest!(`/api/w/${ws}/folders/create`, {
+        method: "POST",
+        headers: { "Content-Type": "application/json" },
+        body: JSON.stringify({ name: "promo", owners: [], extra_perms: {} }),
+      });
+      await backend.apiRequest!(`/api/w/${ws}/scripts/create`, {
+        method: "POST",
+        headers: { "Content-Type": "application/json" },
+        body: JSON.stringify({
+          path: "f/promo/foo",
+          summary: "",
+          description: "",
+          content: "export async function main() { return 1 }",
+          language: "bun",
+        }),
+      });
+      const schedRes = await backend.apiRequest!(`/api/w/${ws}/schedules/create`, {
+        method: "POST",
+        headers: { "Content-Type": "application/json" },
+        body: JSON.stringify({
+          path: "f/promo/sched",
+          schedule: "0 0 12 * * *",
+          timezone: "UTC",
+          script_path: "f/promo/foo",
+          is_flow: false,
+          args: {},
+          enabled: false,
+        }),
+      });
+      expect(schedRes.status).toBe(200);
+
+      // --- 3. git_repository resource + git-sync config (schedules included) ---
+      await backend.apiRequest!(`/api/w/${ws}/resources/create`, {
+        method: "POST",
+        headers: { "Content-Type": "application/json" },
+        body: JSON.stringify({
+          path: "u/test/promo_repo",
+          resource_type: "git_repository",
+          value: { url: `file://${bareDir}`, branch: "main", token: "" },
+        }),
+      });
+      await backend.updateGitSyncConfig!({
+        git_sync_settings: {
+          repositories: [
+            {
+              git_repo_resource_path: "u/test/promo_repo",
+              script_path: "f/**",
+              use_individual_branch: true,
+              group_by_folder: false,
+              settings: {
+                include_path: ["f/**"],
+                include_type: ["script", "schedule"],
+              },
+            },
+          ],
+        },
+      });
+
+      const deployItems = JSON.stringify([
+        {
+          path_type: "schedule",
+          path: "f/promo/sched",
+          commit_msg: "deploy sched",
+        },
+      ]);
+
+      const work = await mkdtemp(join(tmpdir(), "wmill_promo_sched_work_"));
+      git(work, "clone", `file://${bareDir}`, ".");
+      // Option B semantic: in promotion mode the deploy forces NOTHING — the
+      // schedule lands only because THIS target's effective wmill.yaml opts
+      // schedules in. (Reverting the source fix re-introduces the force-`false`
+      // that clobbers this `includeSchedules: true`, so the file is dropped.)
+      await writeFile(
+        join(work, "wmill.yaml"),
+        "defaultTs: bun\nincludes:\n  - f/**\nexcludes: []\nincludeSchedules: true\n",
+      );
+      const res = await backend.runCLICommand(
+        [
+          "sync",
+          "git-deploy",
+          "--repository",
+          "u/test/promo_repo",
+          "--use-individual-branch",
+          "--git-deploy-items",
+          deployItems,
+        ],
+        work,
+      );
+      expect(res.code).toBe(0);
+
+      // Caller-half (mirrors the hub script): stage what the pull wrote, commit
+      // on the checked-out wm_deploy branch, push.
+      git(work, "config", "user.email", "test@windmill.dev");
+      git(work, "config", "user.name", "test");
+      git(work, "add", "-A");
+      try {
+        git(work, "diff", "--cached", "--quiet");
+      } catch {
+        git(work, "commit", "-m", "deploy sched");
+      }
+      git(work, "push", "--porcelain", "-u", "origin", "HEAD");
+
+      const expectedBranch = `refs/heads/wm_deploy/${ws}/schedule/f__promo__sched`;
+      expect(remoteBranches(bareDir)).toContain(expectedBranch);
+      // The regression: the schedule file MUST be present on the branch. Without
+      // the fix the include flag is false, the server strips the schedule from
+      // the tarball, the pull writes nothing, and this file is absent.
+      expect(
+        fileExistsOnBranch(
+          bareDir,
+          `wm_deploy/${ws}/schedule/f__promo__sched`,
+          "f/promo/sched.schedule.yaml",
+        ),
+      ).toBe(true);
+      // Base branch untouched (individual-branch never pushes to the base).
+      expect(remoteHead(bareDir, "main")).toBe(seedMain);
+
+      await rm(bareDir, { recursive: true, force: true });
+      await rm(seedDir, { recursive: true, force: true });
+      await rm(work, { recursive: true, force: true });
+    });
+  },
+);
+
+/**
+ * Regression test for WIN-1997: forking a workspace with git sync configured
+ * must publish a `wm-fork/<branch>/<id>` branch to the remote.
+ *
+ * The fork-branch callback runs the sync script with `only_create_branch:
+ * true` and no items. The hub script delegates branch checkout + push of that
+ * empty ref to `wmill sync git-deploy --only-create-branch` — its own
+ * in-process commit+push runs ONLY for the `!only_create_branch` path. So if
+ * the CLI doesn't push the freshly checked-out branch here, nothing does and
+ * the fork branch never reaches the remote (the symptom that broke the e2e
+ * test after #9284 moved commit+push to the caller). This guards that the CLI
+ * owns the push for the branch-only case.
+ */
+test.skipIf(shouldSkipOnCI())(
+  "git-sync fork: only_create_branch publishes the wm-fork branch (CLI owns the push)",
+  async () => {
+    await withTestBackend(async (backend) => {
+      // Bare "remote" seeded with an initial `main` commit.
+      const bareDir = await mkdtemp(join(tmpdir(), "wmill_fork_bare_"));
+      execFileSync("git", ["init", "--bare", "--initial-branch=main", bareDir]);
+      const seedDir = await mkdtemp(join(tmpdir(), "wmill_fork_seed_"));
+      git(seedDir, "init", "--initial-branch=main");
+      git(seedDir, "config", "user.email", "seed@windmill.dev");
+      git(seedDir, "config", "user.name", "seed");
+      await writeFile(join(seedDir, "README.md"), "# fork test\n");
+      git(seedDir, "add", "-A");
+      git(seedDir, "commit", "-m", "seed");
+      git(seedDir, "remote", "add", "origin", `file://${bareDir}`);
+      git(seedDir, "push", "-u", "origin", "main");
+      const seedMain = remoteHead(bareDir, "main");
+
+      // The CWD the hub script runs git-deploy in: a clone of the repo on main.
+      const work = await mkdtemp(join(tmpdir(), "wmill_fork_work_"));
+      git(work, "clone", `file://${bareDir}`, ".");
+      await writeFile(
+        join(work, "wmill.yaml"),
+        "defaultTs: bun\nincludes:\n  - f/**\nexcludes: []\n",
+      );
+
+      // Branch creation happens BEFORE the fork workspace exists (step 1 of the
+      // fork flow), so we pass the fork workspace id straight through — whoami
+      // returns synthetic superadmin info for it. No items, only_create_branch.
+      const forkWs = "wm-fork-clitest";
+      const res = await backend.runCLICommand(
+        [
+          "sync",
+          "git-deploy",
+          "--repository",
+          "u/test/unused_on_branch_only_path",
+          "--git-deploy-items",
+          "[]",
+          "--only-create-branch",
+        ],
+        work,
+        { workspace: forkWs },
+      );
+      expect(res.code).toBe(0);
+
+      // The regression: with NO caller-side commit/push, the fork branch must
+      // already be on the remote because the CLI pushed it.
+      expect(remoteBranches(bareDir)).toContain("refs/heads/wm-fork/main/clitest");
+      // Base branch untouched — branch-only publish creates no commit.
+      expect(remoteHead(bareDir, "main")).toBe(seedMain);
+
+      await rm(bareDir, { recursive: true, force: true });
+      await rm(seedDir, { recursive: true, force: true });
+      await rm(work, { recursive: true, force: true });
+    });
+  },
+);
diff --git a/cli/test/guidance_writer_unit.test.ts b/cli/test/guidance_writer_unit.test.ts
index fa3a91d641..cbeb494d1c 100644
--- a/cli/test/guidance_writer_unit.test.ts
+++ b/cli/test/guidance_writer_unit.test.ts
@@ -391,6 +391,13 @@ describe("writeAiGuidanceFiles — referencesAgentsCli (via reconciliation)", ()
     ["between blank lines", "before\n\n@AGENTS.cli.md\n\nafter"],
     ["leading whitespace then include", "  @AGENTS.cli.md\n"],
     ["CRLF line endings", "line one\r\n@AGENTS.cli.md\r\nline three"],
+    // Mid-sentence include: this is how our own CLAUDE.md default looks
+    // ("Instructions are in @AGENTS.md"). A strict line-equality check made
+    // `wmill refresh prompts` re-prompt every run on files wmill wrote.
+    ["mid-sentence include", "Instructions are in @AGENTS.cli.md\n"],
+    // `>` blockquote prefix doesn't disable Claude's `@`-import expansion,
+    // so we treat it as a reference too.
+    ["blockquoted include", "> @AGENTS.cli.md"],
   ])("treats %s as a reference (no append)", async (_label, content) => {
     await withTempDir(async (tempDir) => {
       await writeFile(join(tempDir, "AGENTS.md"), content, "utf8");
@@ -406,7 +413,6 @@ describe("writeAiGuidanceFiles — referencesAgentsCli (via reconciliation)", ()
     ["@AGENTS-cli-md (lookalike)", "@AGENTS-cli-md"],
     ["@AGENTS.cli.md without surrounding whitespace", "foo@AGENTS.cli.md"],
     ["commented-out include", "<!-- @AGENTS.cli.md -->"],
-    ["blockquoted include", "> @AGENTS.cli.md"],
   ])("does not treat %s as a reference (append happens)", async (_label, content) => {
     await withTempDir(async (tempDir) => {
       await writeFile(join(tempDir, "AGENTS.md"), content, "utf8");
diff --git a/cli/test/push_workspace_key_unit.test.ts b/cli/test/push_workspace_key_unit.test.ts
new file mode 100644
index 0000000000..6d8950cbec
--- /dev/null
+++ b/cli/test/push_workspace_key_unit.test.ts
@@ -0,0 +1,93 @@
+/**
+ * Unit tests for pushWorkspaceKey in settings.ts.
+ *
+ * Covers WIN-2005: changing the encryption key in encryption_key.yaml and
+ * pushing it must (by default) re-encrypt the remote secrets with the new key.
+ *
+ * Verifies that:
+ * - an unchanged key is a no-op (no setWorkspaceEncryptionKey call)
+ * - a changed key in non-interactive mode re-encrypts by default
+ *   (skip_reencrypt = false), so secret plaintext values are preserved
+ * - the --skip-reencrypt-on-key-change flag keeps the remote ciphertexts
+ *   untouched (skip_reencrypt = true)
+ * - WMILL_NO_REENCRYPT_ON_KEY_CHANGE=true does the same via env var
+ */
+
+import { expect, test, describe, beforeEach, afterEach, mock } from "bun:test";
+
+// Track calls to mocked wmill functions
+let remoteKey = "";
+let setEncryptionKeyCalls: {
+  workspace: string;
+  requestBody: { new_key: string; skip_reencrypt?: boolean };
+}[] = [];
+
+// Mock the wmill module before importing settings.ts
+mock.module("../gen/services.gen.ts", () => ({
+  getWorkspaceEncryptionKey: async (_args: { workspace: string }) => ({
+    key: remoteKey,
+  }),
+  setWorkspaceEncryptionKey: async (args: {
+    workspace: string;
+    requestBody: { new_key: string; skip_reencrypt?: boolean };
+  }) => {
+    setEncryptionKeyCalls.push(args);
+  },
+}));
+
+import { pushWorkspaceKey } from "../src/core/settings.ts";
+
+describe("pushWorkspaceKey", () => {
+  const ws = "test-workspace";
+
+  beforeEach(() => {
+    remoteKey = "";
+    setEncryptionKeyCalls = [];
+    delete process.env.WMILL_NO_REENCRYPT_ON_KEY_CHANGE;
+  });
+
+  afterEach(() => {
+    delete process.env.WMILL_NO_REENCRYPT_ON_KEY_CHANGE;
+  });
+
+  test("no-op when local key matches the remote key", async () => {
+    remoteKey = "samekey";
+    await pushWorkspaceKey(ws, "encryption_key", undefined, "samekey", {
+      noninteractive: true,
+    });
+    expect(setEncryptionKeyCalls.length).toBe(0);
+  });
+
+  test("changed key re-encrypts by default in non-interactive mode", async () => {
+    remoteKey = "oldkey";
+    await pushWorkspaceKey(ws, "encryption_key", undefined, "newkey", {
+      noninteractive: true,
+    });
+    expect(setEncryptionKeyCalls.length).toBe(1);
+    expect(setEncryptionKeyCalls[0].requestBody.new_key).toBe("newkey");
+    // skip_reencrypt false => backend re-encrypts existing secrets with new key
+    expect(setEncryptionKeyCalls[0].requestBody.skip_reencrypt).toBe(false);
+  });
+
+  test("--skip-reencrypt-on-key-change skips re-encryption", async () => {
+    remoteKey = "oldkey";
+    await pushWorkspaceKey(ws, "encryption_key", undefined, "newkey", {
+      noninteractive: true,
+      skipReencrypt: true,
+    });
+    expect(setEncryptionKeyCalls.length).toBe(1);
+    expect(setEncryptionKeyCalls[0].requestBody.new_key).toBe("newkey");
+    expect(setEncryptionKeyCalls[0].requestBody.skip_reencrypt).toBe(true);
+  });
+
+  test("WMILL_NO_REENCRYPT_ON_KEY_CHANGE=true skips re-encryption non-interactively", async () => {
+    remoteKey = "oldkey";
+    process.env.WMILL_NO_REENCRYPT_ON_KEY_CHANGE = "true";
+    await pushWorkspaceKey(ws, "encryption_key", undefined, "newkey", {
+      noninteractive: true,
+    });
+    expect(setEncryptionKeyCalls.length).toBe(1);
+    expect(setEncryptionKeyCalls[0].requestBody.new_key).toBe("newkey");
+    expect(setEncryptionKeyCalls[0].requestBody.skip_reencrypt).toBe(true);
+  });
+});
diff --git a/docker/DockerfileSlim b/docker/DockerfileSlim
index 2bfa883466..3301d73506 100644
--- a/docker/DockerfileSlim
+++ b/docker/DockerfileSlim
@@ -26,7 +26,7 @@ RUN make
 FROM ${DEBIAN_IMAGE}
 
 ARG APP=/usr/src/app
-ARG LATEST_STABLE_PY=3.11.10
+ARG LATEST_STABLE_PY=3.12.12
 
 # UV configuration
 ENV UV_CACHE_DIR=/tmp/windmill/cache/uv
@@ -39,7 +39,7 @@ ENV PATH=/usr/local/bin:/root/.local/bin:/tmp/.local/bin:$PATH
 
 # Install system dependencies
 RUN apt-get update \
-    && apt-get install -y --no-install-recommends ca-certificates wget curl git jq unzip unixodbc xmlsec1 gnupg lsb-release \
+    && apt-get install -y --no-install-recommends ca-certificates wget curl git jq unzip unixodbc xmlsec1 gnupg lsb-release libgnutls30 libgcrypt20 \
     && apt-get clean \
     && rm -rf /var/lib/apt/lists/*
 
diff --git a/docker/DockerfileSlimEe b/docker/DockerfileSlimEe
index d6616b5b97..48cd3698a1 100644
--- a/docker/DockerfileSlimEe
+++ b/docker/DockerfileSlimEe
@@ -26,7 +26,7 @@ RUN make
 FROM ${DEBIAN_IMAGE}
 
 ARG APP=/usr/src/app
-ARG LATEST_STABLE_PY=3.11.10
+ARG LATEST_STABLE_PY=3.12.12
 
 # UV configuration
 ENV UV_CACHE_DIR=/tmp/windmill/cache/uv
@@ -39,7 +39,7 @@ ENV PATH=/usr/local/bin:/root/.local/bin:/tmp/.local/bin:$PATH
 
 # Install system dependencies
 RUN apt-get update \
-    && apt-get install -y --no-install-recommends ca-certificates wget curl git jq unzip unixodbc xmlsec1 gnupg lsb-release \
+    && apt-get install -y --no-install-recommends ca-certificates wget curl git jq unzip unixodbc xmlsec1 gnupg lsb-release libgnutls30 libgcrypt20 \
     && apt-get clean \
     && rm -rf /var/lib/apt/lists/*
 
diff --git a/docker/RHEL8/Dockerfile b/docker/RHEL8/Dockerfile
index cb5f36cef5..57b74b75af 100644
--- a/docker/RHEL8/Dockerfile
+++ b/docker/RHEL8/Dockerfile
@@ -1,6 +1,5 @@
 ARG DEBIAN_IMAGE=debian:bookworm-slim
 ARG RUST_IMAGE=registry.access.redhat.com/ubi8/ubi:latest
-ARG PYTHON_IMAGE=python:3.11.10-slim-bookworm
 
 FROM ${RUST_IMAGE} AS rust_base
 
@@ -30,6 +29,7 @@ RUN npm ci
 COPY frontend .
 RUN mkdir /backend
 COPY /backend/windmill-api/openapi.yaml /backend/windmill-api/openapi.yaml
+COPY /backend/oauth_connect.json /backend/oauth_connect.json
 COPY /openflow.openapi.yaml /openflow.openapi.yaml
 COPY /backend/windmill-api/build_openapi.sh /backend/windmill-api/build_openapi.sh
 COPY /system_prompts/auto-generated /system_prompts/auto-generated
diff --git a/docker/RHEL9/Dockerfile b/docker/RHEL9/Dockerfile
index 6d96804381..21816ba8a5 100644
--- a/docker/RHEL9/Dockerfile
+++ b/docker/RHEL9/Dockerfile
@@ -1,6 +1,5 @@
 ARG DEBIAN_IMAGE=debian:bookworm-slim
 ARG RUST_IMAGE=registry.access.redhat.com/ubi9/ubi:latest
-ARG PYTHON_IMAGE=python:3.11.10-slim-bookworm
 
 FROM ${RUST_IMAGE} AS rust_base
 
@@ -30,6 +29,7 @@ RUN npm ci
 COPY frontend .
 RUN mkdir /backend
 COPY /backend/windmill-api/openapi.yaml /backend/windmill-api/openapi.yaml
+COPY /backend/oauth_connect.json /backend/oauth_connect.json
 COPY /openflow.openapi.yaml /openflow.openapi.yaml
 COPY /backend/windmill-api/build_openapi.sh /backend/windmill-api/build_openapi.sh
 COPY /system_prompts/auto-generated /system_prompts/auto-generated
diff --git a/docs/windmill-ai-refactor-plan.md b/docs/windmill-ai-refactor-plan.md
deleted file mode 100644
index 6dcd2d7605..0000000000
--- a/docs/windmill-ai-refactor-plan.md
+++ /dev/null
@@ -1,441 +0,0 @@
-# Refactor Plan: `windmill-ai` Crate
-
-## Context
-
-AI provider logic is currently split across three crates with duplicate code:
-
-- **windmill-common** — base types (`ai_types`, `ai_providers`, `ai_google`, `ai_bedrock`, `ai_cache`)
-- **windmill-api** — chat proxy routes (`ai.rs`), audit logging, caching, and DB-backed credential resolution into `ProviderCredentials`
-- **windmill-worker** — agent execution (`ai/` module) with `QueryBuilder` trait, SSE parsers, provider implementations
-
-The goal: a single `windmill-ai` crate with all AI provider logic. Worker agent execution uses `QueryBuilder`; the API proxy uses `QueryBuilder::build_proxy_request` for HTTP-forwarding providers and native proxy handlers for providers that need response conversion or SDK execution.
-
-## Dependency Direction
-
-```
-windmill-ai  →  windmill-common (for DB, Error, AgentAction, AuthedClient, etc.)
-             →  windmill-types (for S3Object)
-             →  windmill-parser (for Typ, used in OpenAPISchema)
-
-windmill-api    →  windmill-ai
-windmill-worker →  windmill-ai
-```
-
-windmill-common does **NOT** re-export from windmill-ai (would be circular). All consumers update imports.
-
-## Reviewer Note: Keep API Proxy Unification Split
-
-The crate boundary, shared utilities, SSE parsers, image handling, worker provider implementations, provider-specific API proxy transformations, and resolved runtime credential shape are now in `windmill-ai`. Raw API resources and worker agent provider payloads remain separate input/deserialization shapes and convert into `ProviderCredentials` at execution boundaries.
-
-Do not jump directly from the current state to full proxy and credential unification in one PR. The API proxy combines request transformation, endpoint selection, auth headers, custom headers, OAuth user injection, Azure URL handling, Anthropic Vertex handling, Bedrock SDK calls, and SSE keepalive behavior. Split the work by risk:
-- Introduce shared proxy request and credential types first.
-- Move the OpenAI-compatible proxy path into `windmill-ai` next, while keeping provider-native behavior unchanged.
-- Move Anthropic/Vertex, Google AI, and Bedrock in separate follow-up PRs.
-- Unify credential resolution only after all proxy request builders use the shared shape.
-
-Avoid adding modules whose only purpose is to re-export moved code. Direct imports from `windmill_ai` make ownership and dependency direction clearer at each call site.
-
-Also do not make `build_proxy_request(raw_body, path)` too narrow. The proxy path needs method, incoming headers, resolved credentials, base URL/platform, organization/user fields, custom headers, and Bedrock/Azure/Vertex-specific context. Introduce a structured `ProxyBuildArgs`/`ProviderCredentials` shape before deleting `AIRequestConfig::prepare_request`, `google.rs`, or `bedrock.rs`.
-
-## Completed Phase: Proxy Contract + OpenAI-Compatible Proxy ✅
-
-Goal: introduce the shared API proxy contract in `windmill-ai` and move the OpenAI-compatible proxy request builder there without changing provider behavior.
-
-Suggested PR title: `refactor(ai): move openai-compatible proxy building to windmill-ai`.
-
-Scope:
-- Add `windmill-ai/src/proxy.rs` and export it from `lib.rs`.
-- Define `ProviderCredentials`, `ProxyBuildArgs`, and `ProxyRequest`.
-- Include all context known to be needed by the current API proxy path: method, path, incoming headers, body, provider, base URL, API key, OAuth access token, organization/user fields, platform, 1M context flag, custom headers, region, and AWS credentials.
-- Add a conversion from API-side `AIRequestConfig` to `ProviderCredentials`.
-- Add `QueryBuilder::build_proxy_request` with a default unsupported-provider implementation.
-- Implement `build_proxy_request` for OpenAI-compatible providers (`OpenAI`, `AzureOpenAI`, `Mistral`, `DeepSeek`, `Groq`, `OpenRouter`, `TogetherAI`, `CustomAI`).
-- Route workspace and global API proxy requests for OpenAI-compatible providers through `windmill-ai`.
-- Keep FIM transformation in `windmill-api` before calling the proxy builder.
-- Keep `AIRequestConfig::prepare_request` for Anthropic/Vertex and remaining fallback paths.
-
-Out of scope:
-- Do not move Anthropic/Vertex proxy behavior yet.
-- Do not move Google AI or Bedrock proxy behavior yet.
-- Do not change credential resolution, audit logging, cache behavior, SSE keepalive behavior, or Bedrock/Google special cases.
-- Do not remove `windmill-api/src/google.rs`, `windmill-api/src/bedrock.rs`, or `AIRequestConfig::prepare_request`.
-
-Validation:
-- `cargo test -p windmill-ai proxy`
-- `cargo test -p windmill-api invalidates_all_cached_providers_for_workspace`
-- `cargo check -p windmill-ai -p windmill-api`
-- `cargo check -p windmill-ai -p windmill-api --features bedrock`
-
-Follow-up status: Anthropic/Vertex proxy handling has since moved into
-`windmill-ai`, and the dead `AIRequestConfig::prepare_request` fallback has
-been removed.
-
-## Completed Phase: Proxy Execution Mode + Google AI Proxy Migration ✅
-
-Goal: introduce a shared provider execution classifier before moving Google AI
-and Bedrock. `ProxyRequest` is a good contract for HTTP-forwarding providers
-such as OpenAI-compatible providers and Anthropic, but Google AI also converts
-responses back to OpenAI shape and Bedrock uses SDK execution. Model that split
-explicitly before moving those providers, then move the Google AI proxy
-transformation into `windmill-ai` as the first native-provider migration.
-
-Suggested PR title: `refactor(ai): add provider proxy execution mode`.
-
-Scope:
-- Add `ProxyExecutionMode` in `windmill-ai::proxy`.
-- Classify providers as HTTP-forwarding, native Google AI, or native Bedrock.
-- Make `supports_query_builder_proxy` derive from the shared execution mode.
-- Use the shared execution mode in `windmill-api/src/ai.rs` for workspace proxy routing.
-- Move Google AI workspace proxy request conversion, streaming/non-streaming response conversion, and model-list normalization into `windmill-ai::providers::google_ai`.
-- Share Google AI `GeminiTextRequest` and generation-config construction between worker agent requests and API proxy requests.
-- Delete the API-local `windmill-api/src/google.rs` module.
-- Keep global proxy behavior, Bedrock native handling, credential resolution, audit logging, caching, and SSE keepalive behavior unchanged.
-
-Out of scope:
-- Do not move `windmill-api/src/bedrock.rs`.
-- Do not unify `AIRequestConfig` and `ProviderWithResource`.
-
-Validation:
-- `cargo test -p windmill-ai google_ai`
-- `cargo test -p windmill-ai proxy`
-- `cargo test -p windmill-api invalidates_all_cached_providers_for_workspace`
-- `cargo test -p windmill-ai anthropic`
-
-Follow-up status: Bedrock native proxy handling has since moved into
-`windmill-ai`, and the API-local `windmill-api/src/bedrock.rs` module has been
-removed.
-
-## Completed Phase: Bedrock Native Proxy Migration ✅
-
-Goal: move the remaining native-provider API proxy execution out of
-`windmill-api` and into `windmill-ai`, while leaving API-owned routing,
-credential resolution, auditing, cache behavior, and Axum response conversion in
-`windmill-api`.
-
-Suggested PR title: `refactor(ai): move bedrock proxy handling to windmill-ai`.
-
-Scope:
-- Move Bedrock control-plane proxy calls (`foundation-models`,
-  `inference-profiles`) into `windmill-ai::providers::bedrock`.
-- Move Bedrock chat proxy OpenAI request parsing, Converse request execution,
-  streaming SSE conversion, non-streaming OpenAI-shaped response conversion, and
-  auth selection into `windmill-ai::providers::bedrock`.
-- Add an Axum-free `BedrockProxyResponse` shape in `windmill-ai`; the API route
-  converts it into an Axum body.
-- Move the optional `aws-sdk-bedrock` dependency from `windmill-api` to
-  `windmill-ai`.
-- Delete the API-local `windmill-api/src/bedrock.rs` module.
-
-Out of scope:
-- Do not unify `AIRequestConfig` and `ProviderWithResource`.
-- Do not change Bedrock credential resolution, audit logging, request caching,
-  or non-Bedrock proxy behavior.
-
-Validation:
-- `cargo test -p windmill-ai bedrock --features bedrock`
-- `cargo check -p windmill-ai -p windmill-api`
-- `cargo check -p windmill-ai -p windmill-api --features bedrock`
-
-## Known Follow-Ups
-
-These are not blockers for the current migration PR because they either preserve
-existing behavior or need a separate product decision, but they should stay
-visible for later hardening work.
-
-- **Google AI/Gemini native proxy custom headers**: the native Google AI proxy
-  path intentionally does not apply `AI_HTTP_HEADERS` or resource-level custom
-  headers today. Decide whether and how env/resource custom-header injection
-  should apply to Google AI once the proxy behavior is unified further.
-- **Bedrock SSE tool-call indexing**: Bedrock streaming currently increments
-  the OpenAI tool-call index on every Bedrock `ContentBlockStop`, including text
-  content blocks. This behavior existed before the move from `windmill-api` to
-  `windmill-ai`, but a later cleanup should advance the index only when the
-  stopped block was a tool-use block.
-- **Bedrock SSE keepalives**: Bedrock native SSE streams are still returned
-  directly without the API proxy keepalive injection used by other SSE paths.
-  This also preserves the pre-move behavior. A later cleanup can generalize the
-  keepalive wrapper so it works for both `reqwest::Error` streams and Bedrock's
-  SDK-backed `std::io::Error` streams.
-
-## Completed Phase: Credential Unification Phase 1 ✅
-
-Goal: make `ProviderCredentials` the shared resolved runtime credential shape
-without overloading it with raw resource input or model-selection state.
-
-`AIRequestConfig` and `ProviderWithResource` are not equivalent concepts:
-`AIRequestConfig` is API-side resolved state after DB, variable, OAuth, and
-resource handling, while `ProviderWithResource` is worker-side raw agent input
-that also carries the selected model. Keep raw/deserialization types separate and
-convert them into `ProviderCredentials` at execution boundaries.
-
-Suggested PR title: `refactor(ai): use provider credentials for worker builders`.
-
-Scope:
-- Add a worker-side conversion from `ProviderWithResource` to
-  `ProviderCredentials`.
-- Keep `model` outside `ProviderCredentials`; it remains agent request data.
-- Keep `ProviderWithResource` as the backward-compatible deserialization type for
-  existing agent payloads.
-- Use `ProviderCredentials` for worker query-builder creation.
-- Collapse `create_query_builder` and `create_proxy_query_builder` into one
-  `create_query_builder(&ProviderCredentials)` factory.
-
-Out of scope:
-- Do not remove API-local `AIRequestConfig` yet.
-- Do not change API request-cache behavior.
-- Do not change worker agent payload shape or serialized field names.
-
-Validation:
-- `cargo check -p windmill-ai -p windmill-api -p windmill-worker`
-- `cargo check -p windmill-ai -p windmill-api -p windmill-worker --features bedrock`
-
-## Completed Phase: Credential Unification Phase 2 ✅
-
-Goal: remove the API-local resolved credential wrapper after worker execution
-already uses the shared shape.
-
-Suggested PR title: `refactor(ai): resolve api proxy credentials directly`.
-
-Scope:
-- Change API credential resolution to return `ProviderCredentials` directly.
-- Replace `ExpiringAIRequestConfig` with an expiring `ProviderCredentials`
-  cache entry.
-- Remove `AIRequestConfig::into_provider_credentials`.
-- Delete `AIRequestConfig` entirely if no API-only behavior remains.
-
-Out of scope:
-- Do not merge raw worker resource input into `ProviderCredentials`.
-- Do not put model selection into `ProviderCredentials`.
-
-Validation:
-- `cargo check -p windmill-ai -p windmill-api -p windmill-worker`
-- `cargo check -p windmill-ai -p windmill-api -p windmill-worker --features bedrock`
-- `cargo test -p windmill-api invalidates_all_cached_providers_for_workspace`
-
-## Step-by-Step Plan
-
-Each step produces a compiling, working backend.
-
----
-
-### Step 1: Create `windmill-ai` crate, move base types from windmill-common ✅
-
-Create `backend/windmill-ai/Cargo.toml` and `backend/windmill-ai/src/lib.rs`.
-
-Move from `windmill-common/src/` to `windmill-ai/src/`:
-- `ai_types.rs` — OpenAI-compatible message types
-- `ai_providers.rs` — `AIProvider` enum, `AIPlatform`, base URLs, `ProviderConfig`
-- `ai_google.rs` — Gemini types and OpenAI↔Gemini conversion
-- `ai_bedrock.rs` — Bedrock SDK wrapper (feature-gated on `bedrock`)
-- `ai_cache.rs` — instance AI config revision tracking
-
-Update all imports (`windmill_common::ai_*` → `windmill_ai::ai_*`).
-
----
-
-### Step 2: Move worker AI types to windmill-ai ✅
-
-Move from `windmill-worker/src/ai/types.rs` to `windmill-ai/src/types.rs`:
-- `ProviderWithResource`, `ProviderResource` — credential types
-- `TokenUsage` — token usage tracking
-- `OutputType`, `SchemaType`, `AdditionalProperties` — output configuration
-- `OpenAPISchema` — tool parameter schema (depends on `windmill-parser::Typ`)
-- `Tool`, `Message`, `ResponseFormat`, `JsonSchemaFormat` — agent types
-- `StreamingEvent` — SSE event enum
-- `AIAgentArgs`, `AIAgentArgsRaw`, `AIAgentResult` — agent job args
-- `Memory` — agent memory enum
-- `S3ObjectWithType` — S3 image type
-- `McpToolSource` stub (with same `#[cfg(feature = "mcp")]` pattern)
-
-Worker `ai/types.rs` becomes a re-export: `pub use windmill_ai::types::*`.
-
----
-
-### Step 3: Move QueryBuilder trait, ParsedResponse, and StreamEventSink abstraction to windmill-ai ✅
-
-Move from `windmill-worker/src/ai/query_builder.rs` to `windmill-ai/src/query_builder.rs`:
-- `BuildRequestArgs` struct
-- `ParsedResponse` enum
-- `QueryBuilder` trait (with all existing methods)
-
-New `StreamEventSink` trait in windmill-ai:
-```rust
-#[async_trait]
-pub trait StreamEventSink: Send + Sync {
-    async fn send(&self, event: StreamingEvent, events_str: &mut String) -> Result<(), Error>;
-}
-```
-
-`StreamEventSink` abstracts the worker's `StreamEventProcessor` so windmill-ai doesn't depend on windmill-queue or the worker's job logger. The worker's `StreamEventProcessor` implements `StreamEventSink`. All provider `parse_streaming_response` methods and SSE parsers accept `Box<dyn StreamEventSink>`.
-
----
-
-### Step 4: Move SSE parsers to windmill-ai ✅
-
-Move from `windmill-worker/src/ai/sse.rs` to `windmill-ai/src/sse.rs`:
-- `SSEParser` trait
-- `OpenAISSEParser`, `AnthropicSSEParser`, `GeminiSSEParser`, `OpenAIResponsesSSEParser`
-- All associated types (delta types, usage types, etc.)
-
----
-
-### Step 5: Move provider implementations to windmill-ai ✅
-
-Move from `windmill-worker/src/ai/providers/` to `windmill-ai/src/providers/`:
-- `anthropic.rs` — `AnthropicQueryBuilder`
-- `openai.rs` — `OpenAIQueryBuilder`
-- `google_ai.rs` — `GoogleAIQueryBuilder`
-- `bedrock.rs` — `BedrockQueryBuilder` (feature-gated)
-- `other.rs` — `OtherQueryBuilder` (Mistral, DeepSeek, Groq, TogetherAI, CustomAI)
-- `openrouter.rs` — `OpenRouterQueryBuilder`
-- `mod.rs` with `create_query_builder` factory
-
-Move utility functions providers depend on:
-- `should_use_structured_output_tool` (from `utils.rs`)
-- `extract_text_content` (from `utils.rs`)
-
----
-
-### Step 6: Move image_handler to windmill-ai ✅
-
-Move from `windmill-worker/src/ai/image_handler.rs` to `windmill-ai/src/image_handler.rs`:
-- `download_and_encode_s3_image` — no signature change needed
-- `prepare_messages_for_api` — no signature change needed
-- `upload_image_to_s3` — **refactor**: `(base64_image, workspace_id, job_id, client)` instead of `(base64_image, &MiniPulledJob, client)` to remove windmill-queue dependency
-
----
-
-### Step 7: Move shared utilities to windmill-ai ✅
-
-Move `AI_HTTP_HEADERS` lazy_static (currently duplicated in `windmill-api/src/ai.rs` and `windmill-worker/src/ai_executor.rs`) to `windmill_ai::utils`. Both consumers import from windmill-ai.
-
----
-
-### Step 8: Add API proxy execution support to windmill-ai ✅
-
-This is the key proxy unification step. HTTP-forwarding providers use
-`QueryBuilder::build_proxy_request`:
-
-```rust
-/// Build a request from a raw OpenAI-format proxy request.
-/// Used by the API chat proxy. Handles format conversion for non-OpenAI providers.
-fn build_proxy_request(
-    &self,
-    args: &ProxyBuildArgs<'_>,
-) -> Result<ProxyRequest, Error>;
-```
-
-Where `ProxyBuildArgs` carries the API proxy context that provider implementations need:
-```rust
-pub struct ProxyBuildArgs<'a> {
-    pub method: &'a http::Method,
-    pub path: &'a str,
-    pub headers: &'a http::HeaderMap,
-    pub body: &'a [u8],
-    pub credentials: &'a ProviderCredentials,
-}
-```
-
-And `ProxyRequest` contains the transformed request:
-```rust
-pub struct ProxyRequest {
-    pub method: http::Method,
-    pub url: String,
-    pub headers: Vec<(String, String)>,
-    pub body: Vec<u8>,
-}
-```
-
-**Provider implementations:**
-- **OpenAI-compatible** (OpenAI, Mistral, DeepSeek, Groq, TogetherAI, CustomAI, OpenRouter): Minimal transformation — pass body through, build URL and auth headers.
-- **Anthropic**: Handle standard vs Vertex AI. For Vertex: transform body (extract model, add anthropic_version). For standard: pass through with appropriate headers.
-- **Google AI**: Native execution mode converts OpenAI format → Gemini format and Gemini responses → OpenAI shape. Replaces `windmill-api/src/google.rs`.
-- **Bedrock**: Native execution mode converts OpenAI format → Bedrock SDK calls and SDK responses → OpenAI shape. Replaces `windmill-api/src/bedrock.rs`.
-
-**Refactor API proxy** (`windmill-api/src/ai.rs`):
-1. Parse provider from headers, resolve credentials → `ProviderCredentials`
-2. Create `QueryBuilder` via `create_query_builder`
-3. Dispatch by `ProxyExecutionMode`:
-   - HTTP-forwarding providers call `query_builder.build_proxy_request(&proxy_args)` → `ProxyRequest`
-   - Google AI and Bedrock call native handlers in `windmill-ai`
-4. Convert the provider response to the API response body
-
-**Remove** from windmill-api:
-- `AIRequestConfig::prepare_request` — replaced by `QueryBuilder::build_proxy_request`
-- `google.rs` — replaced by `windmill_ai::providers::google_ai` native proxy handlers
-- `bedrock.rs` — replaced by `windmill_ai::providers::bedrock` native proxy handlers
-- `transform_anthropic_for_vertex` — moved to `AnthropicQueryBuilder`
-- `supports_native_fim`, `transform_fim_to_chat_completions` — moved to windmill-ai
-
-**Keep** in API:
-- credential resolution from DB, workspace settings, instance settings, variables, and OAuth into `ProviderCredentials`
-- HTTP routes, audit logging, request caching
-- `inject_keepalives`, `is_sse_response` helpers
-- `AIConfig`, `ExpiringProviderCredentials` caching types
-
----
-
-### Step 9: Unify credential resolution
-
-Make `ProviderCredentials` the single resolved runtime credential shape in
-windmill-ai, while keeping raw API and worker input/deserialization types at
-their boundaries.
-
-The API's `resolve_provider_credentials` resolves credentials from DB, workspace
-or instance settings, variables, and OAuth. The worker's `ProviderWithResource`
-gets raw credentials from the flow module definition and also carries the
-selected model. Convert both paths into `ProviderCredentials`; do not make
-`ProviderCredentials` carry raw resource state or the model.
-
-Extend `windmill_ai::proxy::ProviderCredentials` as needed so both can produce it:
-```rust
-pub struct ProviderCredentials {
-    pub provider: AIProvider,
-    pub base_url: String,
-    pub api_key: Option<String>,
-    pub access_token: Option<String>,
-    pub organization_id: Option<String>,
-    pub user: Option<String>,
-    pub platform: AIPlatform,
-    pub region: Option<String>,
-    pub aws_access_key_id: Option<String>,
-    pub aws_secret_access_key: Option<String>,
-    pub aws_session_token: Option<String>,
-    pub enable_1m_context: bool,
-    pub custom_headers: HashMap<String, String>,
-}
-```
-
-The `create_query_builder` factory takes `&ProviderCredentials` instead of `&ProviderWithResource`.
-
----
-
-## Final Crate Structure
-
-```
-windmill-ai/src/
-├── lib.rs              # module exports
-├── ai_types.rs         # OpenAI-compatible message types
-├── ai_providers.rs     # AIProvider enum, base URLs, config
-├── ai_google.rs        # Gemini types and conversions
-├── ai_bedrock.rs       # Bedrock SDK wrapper (feature: bedrock)
-├── ai_cache.rs         # Instance AI config revision
-├── types.rs            # TokenUsage, Tool, OpenAPISchema, etc.
-├── proxy.rs            # ProviderCredentials, ProxyBuildArgs, ProxyRequest
-├── query_builder.rs    # QueryBuilder trait, BuildRequestArgs, ParsedResponse, StreamEventSink
-├── sse.rs              # SSE parsers (OpenAI, Anthropic, Gemini, Responses)
-├── image_handler.rs    # S3 image upload/download
-├── utils.rs            # extract_text_content, should_use_structured_output_tool
-└── providers/
-    ├── mod.rs           # create_query_builder factory
-    ├── anthropic.rs     # build_request + build_proxy_request
-    ├── openai.rs        # build_request + build_proxy_request
-    ├── google_ai.rs     # build_request + native proxy handlers
-    ├── bedrock.rs       # build_request + native proxy handlers (feature: bedrock)
-    ├── other.rs         # build_request + build_proxy_request
-    └── openrouter.rs    # build_request + build_proxy_request
-```
-
-**windmill-worker** keeps: `ai_executor.rs`, `ai/tools.rs`, `ai/utils.rs` (flow/conversation/MCP logic), `StreamEventProcessor` (impl of `StreamEventSink`).
-
-**windmill-api** keeps: HTTP routes (`ai.rs` proxy endpoints), audit logging, caching, credential resolution from DB. `google.rs` and `bedrock.rs` deleted.
diff --git a/frontend/package-lock.json b/frontend/package-lock.json
index 67be947bde..f4780b5871 100644
--- a/frontend/package-lock.json
+++ b/frontend/package-lock.json
@@ -1,12 +1,12 @@
 {
 	"name": "@windmill-labs/components",
-	"version": "1.711.0",
+	"version": "1.714.0",
 	"lockfileVersion": 3,
 	"requires": true,
 	"packages": {
 		"": {
 			"name": "@windmill-labs/components",
-			"version": "1.711.0",
+			"version": "1.714.0",
 			"hasInstallScript": true,
 			"license": "AGPL-3.0",
 			"dependencies": {
@@ -66,6 +66,7 @@
 				"quill": "^1.3.7",
 				"rehype-github-alerts": "^3.0.0",
 				"rehype-raw": "^7.0.0",
+				"rehype-sanitize": "^6.0.0",
 				"rfc4648": "^1.5.3",
 				"runed": "^0.36.0",
 				"svelte-carousel": "^1.0.25",
@@ -6352,6 +6353,21 @@
 				"url": "https://opencollective.com/unified"
 			}
 		},
+		"node_modules/hast-util-sanitize": {
+			"version": "5.0.2",
+			"resolved": "https://registry.npmjs.org/hast-util-sanitize/-/hast-util-sanitize-5.0.2.tgz",
+			"integrity": "sha512-3yTWghByc50aGS7JlGhk61SPenfE/p1oaFeNwkOOyrscaOkMGrcW9+Cy/QAIOBpZxP1yqDIzFMR0+Np0i0+usg==",
+			"license": "MIT",
+			"dependencies": {
+				"@types/hast": "^3.0.0",
+				"@ungap/structured-clone": "^1.0.0",
+				"unist-util-position": "^5.0.0"
+			},
+			"funding": {
+				"type": "opencollective",
+				"url": "https://opencollective.com/unified"
+			}
+		},
 		"node_modules/hast-util-to-parse5": {
 			"version": "8.0.0",
 			"resolved": "https://registry.npmjs.org/hast-util-to-parse5/-/hast-util-to-parse5-8.0.0.tgz",
@@ -10888,6 +10904,20 @@
 				"url": "https://opencollective.com/unified"
 			}
 		},
+		"node_modules/rehype-sanitize": {
+			"version": "6.0.0",
+			"resolved": "https://registry.npmjs.org/rehype-sanitize/-/rehype-sanitize-6.0.0.tgz",
+			"integrity": "sha512-CsnhKNsyI8Tub6L4sm5ZFsme4puGfc6pYylvXo1AeqaGbjOYyzNv3qZPwvs0oMJ39eryyeOdmxwUIo94IpEhqg==",
+			"license": "MIT",
+			"dependencies": {
+				"@types/hast": "^3.0.0",
+				"hast-util-sanitize": "^5.0.0"
+			},
+			"funding": {
+				"type": "opencollective",
+				"url": "https://opencollective.com/unified"
+			}
+		},
 		"node_modules/remark-gfm": {
 			"version": "4.0.1",
 			"resolved": "https://registry.npmjs.org/remark-gfm/-/remark-gfm-4.0.1.tgz",
diff --git a/frontend/package.json b/frontend/package.json
index c3651f7daf..a96e7e1a3e 100644
--- a/frontend/package.json
+++ b/frontend/package.json
@@ -1,6 +1,6 @@
 {
 	"name": "@windmill-labs/components",
-	"version": "1.711.0",
+	"version": "1.714.0",
 	"scripts": {
 		"dev": "vite dev",
 		"dev:ui-builder": "mv static/ui_builder static/ui_builder.dev-disabled 2>/dev/null || true ; trap 'mv static/ui_builder.dev-disabled static/ui_builder 2>/dev/null || true' EXIT ; vite dev",
@@ -126,7 +126,6 @@
 		"lru-cache": "^11.1.0",
 		"lucide-svelte": "^0.540.0",
 		"mdast-util-find-and-replace": "^3.0.2",
-		"unist-util-visit": "^5.0.0",
 		"minimatch": "^10.0.1",
 		"monaco-editor": "npm:@codingame/monaco-vscode-editor-api@=25.0.0",
 		"monaco-languageclient": "10.6.0",
@@ -141,12 +140,14 @@
 		"quill": "^1.3.7",
 		"rehype-github-alerts": "^3.0.0",
 		"rehype-raw": "^7.0.0",
+		"rehype-sanitize": "^6.0.0",
 		"rfc4648": "^1.5.3",
 		"runed": "^0.36.0",
 		"svelte-carousel": "^1.0.25",
 		"svelte-exmarkdown": "^5.0.0",
 		"svelte-infinite-loading": "^1.4.0",
 		"tailwind-merge": "^1.13.2",
+		"unist-util-visit": "^5.0.0",
 		"vscode": "npm:@codingame/monaco-vscode-extension-api@=25.0.0",
 		"vscode-languageclient": "~9.0.1",
 		"vscode-uri": "~3.1.0",
diff --git a/frontend/scripts/ui_builder_artifact.json b/frontend/scripts/ui_builder_artifact.json
index 05a9068963..2863ec67ab 100644
--- a/frontend/scripts/ui_builder_artifact.json
+++ b/frontend/scripts/ui_builder_artifact.json
@@ -1,5 +1,5 @@
 {
 	"baseUrl": "https://pub-06154ed168a24e73a86ab84db6bf15d8.r2.dev",
-	"version": "00c9834",
-	"sha256": "5757e5b9cbf79c20d507dc4c588640368e84b873cb48f3806ca8c67fd1aa625f"
+	"version": "fe13d03",
+	"sha256": "c588569103ce065a26f334d9b625f616cd23d4204deaacd6fadcfbf16f23462c"
 }
diff --git a/frontend/src/lib/components/AppConnectInner.svelte b/frontend/src/lib/components/AppConnectInner.svelte
index 4f0a5a76b2..7b6ed37ecc 100644
--- a/frontend/src/lib/components/AppConnectInner.svelte
+++ b/frontend/src/lib/components/AppConnectInner.svelte
@@ -74,6 +74,16 @@
 	let value: string = $state('')
 	let valueToken: TokenResponse | undefined = undefined
 	let connects: string[] | undefined = $state(undefined)
+
+	const SANDBOX_SUFFIX = '_sandbox'
+	function stripSandboxSuffix(name: string): string {
+		return name.endsWith(SANDBOX_SUFFIX) ? name.slice(0, -SANDBOX_SUFFIX.length) : name
+	}
+	// `resourceType` is always the canonical type (e.g. `docusign`) so resource
+	// rows are uniform. `connectClient` carries the suffixed OAuth client name
+	// (e.g. `docusign_sandbox`) used to look up credentials/URLs at runtime
+	// and stored on `account.client` so token refresh hits the right endpoint.
+	let connectClient: string = $state('')
 	let connectsManual: { key: string; img?: string; instructions: string[] }[] | undefined =
 		$state(undefined)
 	let args: any = $state({})
@@ -152,7 +162,9 @@
 		description = ''
 		labels = undefined
 		wsSpecific = false
-		resourceType = rt ?? ''
+		const rawRt = rt ?? ''
+		connectClient = rawRt
+		resourceType = stripSandboxSuffix(rawRt)
 		valueToken = undefined
 
 		// Reset client credentials state
@@ -163,7 +175,7 @@
 		tokenUrl = ''
 
 		await loadConnects()
-		manual = !connects?.includes(resourceType)
+		manual = !connects?.includes(connectClient)
 		if (manual && express) {
 			dispatch('error', 'Express OAuth setup is not available for non OAuth resource types')
 			return
@@ -312,7 +324,8 @@
 			sendUserToast(data.error, true)
 			step = 2
 		} else if (data.type === 'success') {
-			resourceType = data.resource_type
+			connectClient = data.resource_type
+			resourceType = stripSandboxSuffix(connectClient)
 			value = data.res.access_token!
 			valueToken = data.res
 			responseExtra = data.extra ?? {}
@@ -325,7 +338,7 @@
 	}
 
 	async function getScopesAndParams() {
-		const connect = await OauthService.getOauthConnect({ client: resourceType })
+		const connect = await OauthService.getOauthConnect({ client: connectClient })
 		scopes = connect.scopes ?? []
 		extra_params = Object.entries(connect.extra_params ?? {}) as [string, string][]
 
@@ -401,7 +414,7 @@
 					}
 
 					const tokenResponse = await OauthService.connectClientCredentials({
-						client: resourceType,
+						client: connectClient,
 						requestBody
 					})
 
@@ -428,7 +441,7 @@
 				 * Requires user interaction and consent
 				 * Opens popup for user to authenticate with OAuth provider
 				 */
-				const url = new URL(`/api/oauth/connect/${resourceType}`, window.location.origin)
+				const url = new URL(`/api/oauth/connect/${connectClient}`, window.location.origin)
 				url.searchParams.append('scopes', scopes.join('+'))
 				if (extra_params.length > 0) {
 					extra_params.forEach(([key, value]) => url.searchParams.append(key, value))
@@ -490,7 +503,7 @@
 				const accountData: any = {
 					refresh_token: valueToken.refresh_token ?? '',
 					expires_in: valueToken.expires_in,
-					client: resourceType,
+					client: connectClient,
 					grant_type: valueToken.grant_type || 'authorization_code'
 				}
 
@@ -602,6 +615,7 @@
 			)
 			step = 1
 			resourceType = ''
+			connectClient = ''
 		}
 	}
 
@@ -660,10 +674,11 @@
 					<Button
 						unifiedSize="md"
 						variant="default"
-						selected={key === resourceType}
+						selected={key === connectClient}
 						on:click={() => {
 							manual = false
-							resourceType = key
+							connectClient = key
+							resourceType = stripSandboxSuffix(key)
 							next()
 						}}
 					>
@@ -703,6 +718,7 @@
 							selected={key === resourceType}
 							on:click={() => {
 								manual = true
+								connectClient = key
 								resourceType = key
 								next()
 							}}
@@ -725,6 +741,7 @@
 							btnClasses={key === resourceType ? '!border-2' : 'm-[1px]'}
 							on:click={() => {
 								manual = true
+								connectClient = key
 								resourceType = key
 								next()
 							}}
diff --git a/frontend/src/lib/components/AuthSettings.svelte b/frontend/src/lib/components/AuthSettings.svelte
index 68ebefc148..734c6a1fe3 100644
--- a/frontend/src/lib/components/AuthSettings.svelte
+++ b/frontend/src/lib/components/AuthSettings.svelte
@@ -26,6 +26,7 @@
 	import { tick } from 'svelte'
 	import { Popover } from './meltComponents'
 	import SettingsPageHeader from './settings/SettingsPageHeader.svelte'
+	import oauthConnectRegistry from '$oauth_connect_registry'
 
 	interface Props {
 		snowflakeAccountIdentifier?: string
@@ -59,7 +60,7 @@
 		}
 	})
 
-	const windmillBuiltins = [
+	const windmillBuiltinsBase = [
 		'azure_oauth',
 		'github',
 		'gitlab',
@@ -82,7 +83,22 @@
 		'teams',
 		'zoho',
 		'xero',
-		'apify'
+		'apify',
+		'docusign',
+		'salesforce'
+	]
+	// Providers whose registry entry (`backend/oauth_connect.json`) carries a
+	// `sandbox` URL block. Each one gets a sibling `<name>_sandbox` dropdown
+	// entry and is treated as a builtin so we don't render the custom-URL form
+	// — the URLs come from the registry sandbox block. Derived at build time
+	// from the registry so adding a sandbox to a provider needs no frontend
+	// change.
+	const windmillBuiltinsWithSandbox = Object.entries(oauthConnectRegistry)
+		.filter(([, cfg]) => cfg && typeof cfg === 'object' && 'sandbox' in cfg)
+		.map(([name]) => name)
+	const windmillBuiltins = [
+		...windmillBuiltinsBase,
+		...windmillBuiltinsWithSandbox.map((n) => `${n}_sandbox`)
 	]
 
 	let showCustomOAuthForm = $state(false)
@@ -175,26 +191,29 @@
 	}
 
 	function getOAuthProviderIcon(name: string) {
+		// Sandbox variants share the parent provider's icon.
+		const lookup = name.endsWith('_sandbox') ? name.slice(0, -'_sandbox'.length) : name
+
 		// Handle special cases
-		if (name === 'teams') {
+		if (lookup === 'teams') {
 			return APP_TO_ICON_COMPONENT.ms_teams_webhook
 		}
-		if (name === 'snowflake_oauth') {
+		if (lookup === 'snowflake_oauth') {
 			return APP_TO_ICON_COMPONENT.snowflake
 		}
-		if (name === 'azure_oauth') {
+		if (lookup === 'azure_oauth') {
 			return APP_TO_ICON_COMPONENT.azure
 		}
 
 		// Try direct mapping, fallback to Circle icon if not found
-		return APP_TO_ICON_COMPONENT[name as keyof typeof APP_TO_ICON_COMPONENT] || Circle
+		return APP_TO_ICON_COMPONENT[lookup as keyof typeof APP_TO_ICON_COMPONENT] || Circle
 	}
 
 	function generateOAuthDropdownItems(): Item[] {
 		const items: Item[] = []
 
 		// Add built-in providers that are not already configured
-		windmillBuiltins.forEach((name) => {
+		windmillBuiltinsBase.forEach((name) => {
 			// Only show providers that are not already in the oauths object
 			if (!oauths || !oauths[name]) {
 				const icon = getOAuthProviderIcon(name)
@@ -206,6 +225,19 @@
 			}
 		})
 
+		// Add sandbox variants for providers that have sandbox URLs in the registry
+		windmillBuiltinsWithSandbox.forEach((name) => {
+			const sandboxKey = `${name}_sandbox`
+			if (!oauths || !oauths[sandboxKey]) {
+				const icon = getOAuthProviderIcon(name)
+				items.push({
+					displayName: `${capitalize(name)} (sandbox)`,
+					action: () => createOAuthClient(sandboxKey),
+					icon: icon
+				})
+			}
+		})
+
 		// Add custom option
 		items.push({
 			displayName: `Custom OAuth client ${!$enterpriseLicense ? '(requires ee)' : ''}`,
@@ -370,11 +402,14 @@
 				{#if oauths[k] && !(oauths[k] && 'login_config' in oauths[k])}
 					{#if !['slack', 'teams'].includes(k) && oauths[k]}
 						{@const IconComponent = getOAuthProviderIcon(k) as any}
+						{@const headerLabel = k.endsWith('_sandbox')
+							? `${k.slice(0, -'_sandbox'.length)} (sandbox)`
+							: k}
 						<div class="flex flex-col gap-2 pb-6">
 							<div class="flex flex-row items-center gap-2">
 								<IconComponent size={24} width="24" height="24" class="shrink-0" />
 								<!-- svelte-ignore a11y_label_has_associated_control -->
-								<label class="text-xs font-semibold text-emphasis">{k}</label>
+								<label class="text-xs font-semibold text-emphasis">{headerLabel}</label>
 								<Button
 									variant="subtle"
 									destructive
diff --git a/frontend/src/lib/components/DiffEditor.svelte b/frontend/src/lib/components/DiffEditor.svelte
index 36d6148054..59bc8a33a5 100644
--- a/frontend/src/lib/components/DiffEditor.svelte
+++ b/frontend/src/lib/components/DiffEditor.svelte
@@ -8,6 +8,7 @@
 	import { editor as meditor, KeyMod, KeyCode } from 'monaco-editor'
 
 	import { initializeVscode } from './vscode'
+	import { editorFontSize } from '$lib/editorFontSize.svelte'
 	import { registerWebviewPaste } from '$lib/editorUtils'
 	import EditorTheme from './EditorTheme.svelte'
 	import Button from '$lib/components/common/button/Button.svelte'
@@ -70,6 +71,7 @@
 			scrollBeyondLastLine: false,
 			lineDecorationsWidth: 15,
 			lineNumbersMinChars: 2,
+			fontSize: editorFontSize.regular,
 			scrollbar: { alwaysConsumeMouseWheel: false }
 		})
 
@@ -175,6 +177,13 @@
 		}
 	})
 
+	$effect(() => {
+		const fontSize = editorFontSize.regular
+		if (diffEditor) {
+			diffEditor.updateOptions({ fontSize })
+		}
+	})
+
 	$effect(() => {
 		if (!diffEditor) {
 			return
diff --git a/frontend/src/lib/components/DropdownV2.svelte b/frontend/src/lib/components/DropdownV2.svelte
index c6243f3529..200f66f538 100644
--- a/frontend/src/lib/components/DropdownV2.svelte
+++ b/frontend/src/lib/components/DropdownV2.svelte
@@ -13,6 +13,7 @@
 	import DropdownV2Inner from './DropdownV2Inner.svelte'
 	import { pointerDownOutside } from '$lib/utils'
 	import { createDropdownMenu, melt, createSync } from '@melt-ui/svelte'
+	import type { MenubarMenuElements } from '@melt-ui/svelte'
 	import ResolveOpen from '$lib/components/common/menu/ResolveOpen.svelte'
 	import Button from '$lib/components/common/button/Button.svelte'
 	import { twMerge } from 'tailwind-merge'
@@ -40,7 +41,10 @@
 		size?: ButtonType.UnifiedSize
 		btnText?: string
 		buttonReplacement?: import('svelte').Snippet
-		menu?: import('svelte').Snippet
+		// In customMenu mode the snippet receives the melt-ui `item` action
+		// store so consumers can wrap their own rows in <MenuItem> (or
+		// `use:melt={$item}`) and get arrow-key navigation + aria wiring.
+		menu?: import('svelte').Snippet<[{ item: MenubarMenuElements['item']; close: () => void }]>
 		maxHeight?: string | undefined
 	}
 
@@ -172,7 +176,7 @@
 		transition:fly={{ duration: enableFlyTransition ? 100 : 0, y: -16 }}
 	>
 		{#if customMenu}
-			{@render menu?.()}
+			{@render menu?.({ item, close })}
 		{:else}
 			<div
 				class="bg-surface-tertiary dark:border w-56 origin-top-right rounded-lg shadow-lg focus:outline-none overflow-y-auto py-1"
diff --git a/frontend/src/lib/components/Editor.svelte b/frontend/src/lib/components/Editor.svelte
index 03f4c04642..698e799aad 100644
--- a/frontend/src/lib/components/Editor.svelte
+++ b/frontend/src/lib/components/Editor.svelte
@@ -40,6 +40,7 @@
 	} from '$lib/stores'
 
 	import { editorConfig, registerWebviewPaste, updateOptions } from '$lib/editorUtils'
+	import { editorFontSize } from '$lib/editorFontSize.svelte'
 	import { createHash as randomHash } from '$lib/editorLangUtils'
 	import { workspaceStore } from '$lib/stores'
 	import {
@@ -147,6 +148,11 @@
 		preparedAssetsSqlQueries?: InferAssetsSqlQueryDetails[] | undefined
 		// To execute preview scripts with the right worker group
 		customTag?: string
+		// Opt-in: reflect external `code` prop mutations back into Monaco (see
+		// the effect below). One-way `code={...}` callers that need live
+		// external updates — e.g. the inline flow rawscript — set this. Off by
+		// default so every other caller's behavior is unchanged.
+		syncExternalCode?: boolean
 	}
 
 	let {
@@ -178,7 +184,8 @@
 		enablePreprocessorSnippet = false,
 		rawAppRunnableKey = undefined,
 		preparedAssetsSqlQueries,
-		customTag
+		customTag,
+		syncExternalCode = false
 	}: Props = $props()
 
 	$effect.pre(() => {
@@ -1374,7 +1381,7 @@
 					$relativeLineNumbers
 				),
 				model,
-				fontSize: !small ? 13.5 : 12,
+				fontSize: small ? editorFontSize.small : editorFontSize.regular,
 				lineNumbersMinChars,
 				// overflowWidgetsDomNode: widgets,
 				tabSize: lang == 'python' ? 4 : 2,
@@ -1749,6 +1756,13 @@
 
 	let aiChatInlineWidget: AIChatInlineWidget | null = $state(null)
 
+	$effect(() => {
+		const fontSize = small ? editorFontSize.small : editorFontSize.regular
+		if (editor) {
+			editor.updateOptions({ fontSize })
+		}
+	})
+
 	let loadTimeout: number | undefined = undefined
 	onMount(async () => {
 		if (BROWSER) {
@@ -1829,6 +1843,30 @@
 	$effect(() => {
 		lang = scriptLangToEditorLang(scriptLang)
 	})
+
+	// Opt-in (syncExternalCode): reflect external `code` prop mutations into
+	// Monaco's model. Parents that pass `code={...}` one-way (no bind) — e.g.
+	// the inline rawscript in the flow editor — otherwise mutate the prop
+	// without Monaco ever showing the change (the AI chat editing a flow
+	// module's content in a session is the motivating case). Gated off by
+	// default: Editor is sensitive and most callers either bind:code (and
+	// carry their own external-sync) or treat code as init-only, so a blanket
+	// setValue would risk clobbering them. The `getValue() !== code` guard
+	// keeps the caret intact when the change originated from typing inside
+	// Monaco (which round-trips code back via `$bindable`, re-firing this
+	// effect with `code === getValue()`).
+	let lastExternalCodeSync = code
+	$effect(() => {
+		if (!syncExternalCode) return
+		if (code === lastExternalCodeSync) return
+		lastExternalCodeSync = code
+		if (!editor) return
+		untrack(() => {
+			if (editor!.getValue() !== code) {
+				editor!.setValue(code ?? '')
+			}
+		})
+	})
 	$effect(() => {
 		filePath = computePath(path)
 	})
diff --git a/frontend/src/lib/components/FakeMonacoPlaceHolder.svelte b/frontend/src/lib/components/FakeMonacoPlaceHolder.svelte
index c7f068a83f..3f486494a3 100644
--- a/frontend/src/lib/components/FakeMonacoPlaceHolder.svelte
+++ b/frontend/src/lib/components/FakeMonacoPlaceHolder.svelte
@@ -1,8 +1,8 @@
 <!-- Used to avoid height jitter when loading monaco asynchronously -->
 
 <script lang="ts">
-	import { untrack } from 'svelte'
 	import { getOS } from '$lib/utils'
+	import { editorFontSize } from '$lib/editorFontSize.svelte'
 	import { MONACO_Y_PADDING } from './vscode'
 
 	type Props = {
@@ -22,9 +22,11 @@
 		lineNumbersOffset = 0,
 		class: className = '',
 		showNumbers = true,
-		fontSize = 13.5
+		fontSize: fontSizeProp
 	}: Props = $props()
 
+	let fontSize = $derived(fontSizeProp ?? editorFontSize.regular)
+
 	let yPadding = MONACO_Y_PADDING
 
 	// https://github.com/microsoft/vscode/blob/baa2dad3cdacd97ac02eff0604984faf1167ff1e/src/vs/editor/common/config/editorOptions.ts#L5421
@@ -46,7 +48,7 @@
 
 	const charWidth = 9 // try to match as closely as possible to monaco editor
 
-	const lineHeight = untrack(() => fontSize) * GOLDEN_LINE_HEIGHT_RATIO
+	let lineHeight = $derived(fontSize * GOLDEN_LINE_HEIGHT_RATIO)
 
 	let [clientWidth, clientHeight] = $state([0, 0])
 	let showHorizontalScrollbar = $derived(
diff --git a/frontend/src/lib/components/FlowDiffViewer.svelte b/frontend/src/lib/components/FlowDiffViewer.svelte
index 86fc002795..3539cbc5fe 100644
--- a/frontend/src/lib/components/FlowDiffViewer.svelte
+++ b/frontend/src/lib/components/FlowDiffViewer.svelte
@@ -6,13 +6,28 @@
 	interface Props {
 		beforeYaml: string
 		afterYaml: string
+		/** Side-by-side vs unified. Leave undefined to let
+		 * FlowGraphDiffViewer show its own user-facing toggle (matches the
+		 * pre-fork-diff-drawer behavior). */
+		inlineDiff?: boolean
+		/** Forwarded to FlowGraphDiffViewer — render an empty surface
+		 * placeholder for the "before" / "after" pane when the item is
+		 * added / removed. */
+		beforeMissing?: boolean
+		afterMissing?: boolean
 	}
 
-	let { beforeYaml, afterYaml }: Props = $props()
+	let {
+		beforeYaml,
+		afterYaml,
+		inlineDiff = undefined,
+		beforeMissing = false,
+		afterMissing = false
+	}: Props = $props()
 	let diffMode: 'yaml' | 'graph' = $state('graph')
 </script>
 
-<div class="flex flex-col h-full min-h-[500px] gap-2">
+<div class="flex flex-col h-full min-h-[500px]">
 	<Tabs bind:selected={diffMode}>
 		<Tab value="graph" label="Graph" />
 		<Tab value="yaml" label="YAML" />
@@ -30,6 +45,7 @@
 					defaultLang="yaml"
 					defaultOriginal={beforeYaml}
 					defaultModified={afterYaml}
+					{inlineDiff}
 					readOnly
 				/>
 			{/await}
@@ -37,7 +53,7 @@
 			{#await import('$lib/components/FlowGraphDiffViewer.svelte')}
 				<Loader2 class="animate-spin" />
 			{:then Module}
-				<Module.default {beforeYaml} {afterYaml} />
+				<Module.default {beforeYaml} {afterYaml} {beforeMissing} {afterMissing} {inlineDiff} />
 			{/await}
 		{/if}
 	</div>
diff --git a/frontend/src/lib/components/FlowGraphDiffViewer.svelte b/frontend/src/lib/components/FlowGraphDiffViewer.svelte
index 3639f0955b..caab746502 100644
--- a/frontend/src/lib/components/FlowGraphDiffViewer.svelte
+++ b/frontend/src/lib/components/FlowGraphDiffViewer.svelte
@@ -2,12 +2,12 @@
 	import type { OpenFlow } from '$lib/gen'
 	import YAML from 'yaml'
 	import FlowGraphV2 from './graph/FlowGraphV2.svelte'
-	import { Alert, Button } from './common'
+	import { Alert } from './common'
 	import { computeFlowModuleDiff } from './flows/flowDiff'
 	import { Pane, Splitpanes } from 'svelte-splitpanes'
+	import { DiffIcon, Minus, Plus, SquareSplitHorizontal } from 'lucide-svelte'
 	import ToggleButtonGroup from './common/toggleButton-v2/ToggleButtonGroup.svelte'
 	import ToggleButton from './common/toggleButton-v2/ToggleButton.svelte'
-	import { DiffIcon, Minus, Plus, SquareSplitHorizontal } from 'lucide-svelte'
 	import type { Viewport } from '@xyflow/svelte'
 
 	const SIDE_BY_SIDE_MIN_WIDTH = 700
@@ -15,13 +15,54 @@
 	interface Props {
 		beforeYaml: string
 		afterYaml: string
+		/** When true, render an empty surface placeholder for the "before"
+		 * pane in side-by-side mode (use for added items where there's no
+		 * prior flow to show). */
+		beforeMissing?: boolean
+		/** Same as `beforeMissing` but for the "after" pane (use for removed
+		 * items). */
+		afterMissing?: boolean
+		/** Render the unified single-pane diff when true, side-by-side
+		 * otherwise. When undefined, the component renders its own
+		 * Unified / Side-by-side toggle in the corner (legacy behavior for
+		 * the standalone comparison page). A narrow viewer still falls back
+		 * to unified automatically. */
+		inlineDiff?: boolean | undefined
 	}
 
-	let { beforeYaml, afterYaml }: Props = $props()
+	let {
+		beforeYaml,
+		afterYaml,
+		beforeMissing = false,
+		afterMissing = false,
+		inlineDiff = undefined
+	}: Props = $props()
+
+	// Local toggle state, used only when no inlineDiff prop is supplied.
+	let localViewMode = $state<'sidebyside' | 'unified'>('sidebyside')
+	const showLocalToggle = $derived(inlineDiff === undefined)
+	const effectiveInlineDiff = $derived(
+		inlineDiff !== undefined ? inlineDiff : localViewMode === 'unified'
+	)
 
 	let viewerWidth = $state(SIDE_BY_SIDE_MIN_WIDTH)
 	let beforePaneSize = $state(50)
-	let viewMode = $state<'sidebyside' | 'unified'>('sidebyside')
+	// Track the content area's rendered height so unified-mode graphs can
+	// grow to fill the diff box (otherwise FlowGraphV2 sits at its
+	// content-fit height + small floor, leaving empty space below).
+	let contentAreaHeight = $state(0)
+
+	// Each FlowGraphV2 sizes itself to its own content (clamped to minHeight).
+	// In side-by-side mode we want both graphs to share the same height, so
+	// we track each side's reported height and feed back the max as minHeight
+	// to both. The width-graph then stays at its computed size; the shorter
+	// graph grows to match.
+	let beforeContentHeight = $state(0)
+	let afterContentHeight = $state(0)
+	const SHARED_MIN_HEIGHT = 400
+	const sharedMinHeight = $derived(
+		Math.max(SHARED_MIN_HEIGHT, beforeContentHeight, afterContentHeight)
+	)
 
 	// Shared viewport for synchronizing both graphs in side-by-side mode
 	let sharedViewport = $state<Viewport>({ x: 0, y: 0, zoom: 1 })
@@ -29,7 +70,10 @@
 	let beforeGraph: FlowGraphV2 | undefined = $state(undefined)
 	let afterGraph: FlowGraphV2 | undefined = $state(undefined)
 
-	function parseFlow(yaml: string, label: 'before' | 'after'): {
+	function parseFlow(
+		yaml: string,
+		label: 'before' | 'after'
+	): {
 		flow: OpenFlow | undefined
 		error: string | undefined
 	} {
@@ -49,14 +93,27 @@
 		}
 	}
 
-	let beforeParsed = $derived.by(() => parseFlow(beforeYaml, 'before'))
-	let afterParsed = $derived.by(() => parseFlow(afterYaml, 'after'))
+	// For added/removed items, the caller passes empty YAML and sets the
+	// corresponding *Missing flag. We swap in an empty OpenFlow stub on
+	// that side so the unified diff path still has something to compare
+	// against (every module on the present side becomes added / removed).
+	// The side-by-side rendering uses the flag directly to draw a
+	// placeholder pane instead.
+	const EMPTY_FLOW: OpenFlow = { summary: '', value: { modules: [] } }
+
+	let beforeParsed = $derived.by(() =>
+		beforeMissing ? { flow: EMPTY_FLOW, error: undefined } : parseFlow(beforeYaml, 'before')
+	)
+	let afterParsed = $derived.by(() =>
+		afterMissing ? { flow: EMPTY_FLOW, error: undefined } : parseFlow(afterYaml, 'after')
+	)
 	let parseError = $derived(beforeParsed.error ?? afterParsed.error)
 	let beforeFlow: OpenFlow | undefined = $derived(beforeParsed.flow)
 	let afterFlow: OpenFlow | undefined = $derived(afterParsed.flow)
 
-	// Determine if we should render side-by-side or unified (user controlled via toggle)
-	let isSideBySide = $derived(viewMode === 'sidebyside')
+	// Side-by-side unless the caller asked for unified, OR the viewer pane
+	// is too narrow to comfortably split (fallback to unified for legibility).
+	const isSideBySide = $derived(!effectiveInlineDiff && viewerWidth >= SIDE_BY_SIDE_MIN_WIDTH)
 
 	// Build timeline using history-based approach
 	// In side-by-side view, mark removed modules as 'shadowed' in the After graph
@@ -72,14 +129,6 @@
 			sharedViewport = viewport
 		}
 	}
-
-	$effect(() => {
-		if (viewerWidth < SIDE_BY_SIDE_MIN_WIDTH) {
-			viewMode = 'unified'
-		} else {
-			viewMode = 'sidebyside'
-		}
-	})
 </script>
 
 {#if parseError}
@@ -88,10 +137,12 @@
 	</Alert>
 {:else if beforeFlow && afterFlow}
 	<div class="h-full flex flex-col" bind:clientWidth={viewerWidth}>
-		<!-- Header with view toggle -->
-		<div class="flex flex-row items-center justify-end m-2 gap-4">
-			<div>
-				<ToggleButtonGroup bind:selected={viewMode}>
+		{#if showLocalToggle}
+			<!-- Legacy top banner — only holds the local Unified / Side-by-side
+			     toggle when the parent doesn't pre-set inlineDiff. Zoom
+			     controls live as an overlay below (same as the controlled path). -->
+			<div class="flex flex-row items-center justify-end m-2">
+				<ToggleButtonGroup bind:selected={localViewMode} noWFull>
 					{#snippet children({ item })}
 						<ToggleButton {item} value="unified" label="Unified" icon={DiffIcon} />
 						<ToggleButton
@@ -103,102 +154,131 @@
 					{/snippet}
 				</ToggleButtonGroup>
 			</div>
-			<!-- Header with controls and view toggle -->
+		{/if}
+		<!-- Main content area -->
+		<div class="flex-1 overflow-hidden relative" bind:clientHeight={contentAreaHeight}>
 			{#if isSideBySide}
-				<!-- Shared controls for both graphs in side-by-side mode -->
-				<div class="flex">
-					<Button
-						size="xs"
-						color="light"
-						variant="border"
-						onClick={() => {
+				<!-- Shared zoom controls overlay the graph viewport. Uses xy-flow's
+				     own `.svelte-flow__controls` / `.svelte-flow__controls-button`
+				     classes so it inherits the same look as FlowGraphV2's built-in
+				     controls (FlowGraphV2's global override gives the buttons
+				     bg-surface + hover bg-surface-hover with border:0). Local
+				     overrides bump the icon size from 12px to 16px and drop the
+				     xy-flow default shadow. No fit-view button — recenter can't
+				     sync across two graphs. -->
+				<div
+					class="svelte-flow__controls horizontal absolute top-[15px] right-[15px] z-10 rounded bg-surface border border-gray-200 dark:border-gray-700 overflow-hidden diff-zoom-controls"
+				>
+					<button
+						type="button"
+						aria-label="Zoom in"
+						class="svelte-flow__controls-button"
+						onclick={() => {
 							beforeGraph?.zoomIn()
 							afterGraph?.zoomIn()
 						}}
-						iconOnly
-						startIcon={{ icon: Plus }}
-					/>
-					<Button
-						size="xs"
-						color="light"
-						variant="border"
-						onClick={() => {
+					>
+						<Plus />
+					</button>
+					<button
+						type="button"
+						aria-label="Zoom out"
+						class="svelte-flow__controls-button"
+						onclick={() => {
 							beforeGraph?.zoomOut()
 							afterGraph?.zoomOut()
 						}}
-						iconOnly
-						startIcon={{ icon: Minus }}
-					/>
+					>
+						<Minus />
+					</button>
 				</div>
 			{/if}
-		</div>
-
-		<!-- Main content area -->
-		<div class="flex-1 overflow-hidden">
 			{#if isSideBySide}
 				<!-- Side-by-side view for wide screens -->
 				<Splitpanes class="!overflow-visible h-full">
 					<!-- Before (Left) -->
 					<Pane bind:size={beforePaneSize} minSize={30}>
-						<div class="flex flex-col h-full border-r border-gray-200 dark:border-gray-700">
-							<div class="flex-1 overflow-hidden">
-								<FlowGraphV2
-									bind:this={beforeGraph}
-									modules={beforeFlow.value.modules}
-									groups={beforeFlow.value.groups}
-									failureModule={beforeFlow.value.failure_module}
-									preprocessorModule={beforeFlow.value.preprocessor_module}
-									earlyStop={beforeFlow.value.skip_expr !== undefined}
-									cache={beforeFlow.value.cache_ttl !== undefined}
-									moduleActions={beforeActions}
-									notSelectable={true}
-									insertable={false}
-									editMode={false}
-									download={false}
-									scroll={false}
-									minHeight={400}
-									triggerNode={false}
-									{sharedViewport}
-									onViewportChange={handleViewportChange}
-								>
-									{#snippet leftHeader()}
-										<span class="text-sm text-primary">Before</span>
-									{/snippet}
-								</FlowGraphV2>
-							</div>
+						<div
+							class="flex flex-col h-full border-r border-gray-200 dark:border-gray-700 relative bg-surface-secondary {beforeMissing
+								? 'hatched-thin'
+								: ''}"
+						>
+							{#if beforeMissing}
+								<span class="absolute top-2 left-2 z-10 text-2xs text-tertiary">
+									Before <span class="italic">(no prior version)</span>
+								</span>
+							{:else}
+								<div class="flex-1 overflow-hidden">
+									<FlowGraphV2
+										bind:this={beforeGraph}
+										modules={beforeFlow.value.modules}
+										groups={beforeFlow.value.groups}
+										failureModule={beforeFlow.value.failure_module}
+										preprocessorModule={beforeFlow.value.preprocessor_module}
+										earlyStop={beforeFlow.value.skip_expr !== undefined}
+										cache={beforeFlow.value.cache_ttl !== undefined}
+										moduleActions={beforeActions}
+										notSelectable={true}
+										insertable={false}
+										editMode={false}
+										download={false}
+										scroll={false}
+										minHeight={sharedMinHeight}
+										triggerNode={false}
+										{sharedViewport}
+										onViewportChange={handleViewportChange}
+										onHeight={(h) => (beforeContentHeight = h)}
+									>
+										{#snippet leftHeader()}
+											<span class="text-2xs text-tertiary">Before</span>
+										{/snippet}
+									</FlowGraphV2>
+								</div>
+							{/if}
 						</div>
 					</Pane>
 
 					<!-- After (Right) - Show merged flow with shadowed removed modules -->
 					<Pane minSize={30} class="flex flex-col h-full">
-						<div class="flex flex-col h-full">
-							<div class="flex-1 overflow-hidden">
-								<FlowGraphV2
-									bind:this={afterGraph}
-									diffBeforeFlow={beforeFlow}
-									modules={afterFlow.value.modules}
-									groups={afterFlow.value.groups}
-									failureModule={afterFlow.value.failure_module}
-									preprocessorModule={afterFlow.value.preprocessor_module}
-									earlyStop={afterFlow.value.skip_expr !== undefined}
-									cache={afterFlow.value.cache_ttl !== undefined}
-									currentInputSchema={afterFlow.schema}
-									markRemovedAsShadowed={true}
-									notSelectable={true}
-									insertable={false}
-									editMode={false}
-									download={false}
-									scroll={false}
-									minHeight={400}
-									triggerNode={false}
-									{sharedViewport}
-									onViewportChange={handleViewportChange}
-								>
-									{#snippet leftHeader()}
-										<span class="text-sm text-primary">After</span>
-									{/snippet}
-								</FlowGraphV2>
-							</div>
+						<div
+							class="flex flex-col h-full relative bg-surface-secondary {afterMissing
+								? 'hatched-thin'
+								: ''}"
+						>
+							{#if afterMissing}
+								<span class="absolute top-2 left-2 z-10 text-2xs text-tertiary">
+									After <span class="italic">(flow deleted)</span>
+								</span>
+							{:else}
+								<div class="flex-1 overflow-hidden">
+									<FlowGraphV2
+										bind:this={afterGraph}
+										diffBeforeFlow={beforeFlow}
+										modules={afterFlow.value.modules}
+										groups={afterFlow.value.groups}
+										failureModule={afterFlow.value.failure_module}
+										preprocessorModule={afterFlow.value.preprocessor_module}
+										earlyStop={afterFlow.value.skip_expr !== undefined}
+										cache={afterFlow.value.cache_ttl !== undefined}
+										currentInputSchema={afterFlow.schema}
+										markRemovedAsShadowed={true}
+										notSelectable={true}
+										insertable={false}
+										editMode={false}
+										download={false}
+										scroll={false}
+										minHeight={sharedMinHeight}
+										triggerNode={false}
+										{sharedViewport}
+										onViewportChange={handleViewportChange}
+										onHeight={(h) => (afterContentHeight = h)}
+									>
+										{#snippet leftHeader()}
+											<span class="text-2xs text-tertiary">After</span>
+										{/snippet}
+									</FlowGraphV2>
+								</div>
+							{/if}
 						</div>
 					</Pane>
 				</Splitpanes>
@@ -219,7 +299,7 @@
 						editMode={false}
 						download={false}
 						scroll={false}
-						minHeight={400}
+						minHeight={Math.max(contentAreaHeight, SHARED_MIN_HEIGHT)}
 						triggerNode={false}
 					/>
 				</div>
@@ -231,3 +311,31 @@
 		<p class="text-gray-500">Loading graphs...</p>
 	</div>
 {/if}
+
+<style>
+	/* Thin diagonal hatch used as the empty-pane fill. */
+	.hatched-thin {
+		background-image: repeating-linear-gradient(
+			-45deg,
+			transparent 0,
+			transparent 6px,
+			rgba(128, 128, 128, 0.16) 6px,
+			rgba(128, 128, 128, 0.16) 7.5px
+		);
+	}
+
+	/* Shared zoom controls overlay: same xy-flow layout as the in-graph
+	   controls (`.svelte-flow__controls.horizontal`) but with bigger Plus/Minus
+	   glyphs (xy-flow caps svg at 12px by default) and no panel shadow. */
+	.diff-zoom-controls {
+		box-shadow: none !important;
+	}
+	.diff-zoom-controls :global(.svelte-flow__controls-button) {
+		width: 28px;
+		height: 28px;
+	}
+	.diff-zoom-controls :global(.svelte-flow__controls-button svg) {
+		max-width: 16px;
+		max-height: 16px;
+	}
+</style>
diff --git a/frontend/src/lib/components/GfmMarkdown.svelte b/frontend/src/lib/components/GfmMarkdown.svelte
index 83cce90fbe..377951b97b 100644
--- a/frontend/src/lib/components/GfmMarkdown.svelte
+++ b/frontend/src/lib/components/GfmMarkdown.svelte
@@ -1,19 +1,12 @@
 <script lang="ts">
-	import { Markdown, type Plugin } from 'svelte-exmarkdown'
-	import { gfmPlugin } from 'svelte-exmarkdown/gfm'
-	import rehypeRaw from 'rehype-raw'
-	import { rehypeGithubAlerts } from 'rehype-github-alerts'
+	import { Markdown } from 'svelte-exmarkdown'
+	import { markdownPlugins as plugins } from './markdownPlugins'
 	interface Props {
 		md: string
 		noPadding?: boolean
 	}
 
 	let { md, noPadding }: Props = $props()
-	const plugins: Plugin[] = [
-		gfmPlugin(),
-		{ rehypePlugin: [rehypeRaw] },
-		{ rehypePlugin: [rehypeGithubAlerts] }
-	]
 </script>
 
 <div class="!prose-xs {noPadding ? '' : 'pgap'}">
diff --git a/frontend/src/lib/components/GraphqlSchemaViewer.svelte b/frontend/src/lib/components/GraphqlSchemaViewer.svelte
index 1ab4c68f00..205d8de416 100644
--- a/frontend/src/lib/components/GraphqlSchemaViewer.svelte
+++ b/frontend/src/lib/components/GraphqlSchemaViewer.svelte
@@ -2,20 +2,19 @@
 	import { BROWSER } from 'esm-env'
 
 	import { editor as meditor, KeyMod, KeyCode } from 'monaco-editor'
+	import { editorFontSize } from '$lib/editorFontSize.svelte'
 
 	import { onDestroy, onMount } from 'svelte'
 
 	let divEl: HTMLDivElement | null = $state(null)
 	let editor: meditor.IStandaloneCodeEditor
 
-
 	interface Props {
-		code?: string;
-		class?: string;
+		code?: string
+		class?: string
 	}
 
-	let { code = '', class: className = '' }: Props = $props();
-	
+	let { code = '', class: className = '' }: Props = $props()
 
 	async function loadMonaco() {
 		editor = meditor.create(divEl as HTMLDivElement, {
@@ -25,6 +24,7 @@
 			automaticLayout: true,
 			scrollBeyondLastLine: false,
 			lineNumbers: 'off',
+			fontSize: editorFontSize.regular,
 			minimap: { enabled: false }
 		})
 
@@ -43,6 +43,13 @@
 		}
 	})
 
+	$effect(() => {
+		const fontSize = editorFontSize.regular
+		if (editor) {
+			editor.updateOptions({ fontSize })
+		}
+	})
+
 	onDestroy(() => {
 		try {
 			editor && editor.dispose()
diff --git a/frontend/src/lib/components/LocalDraftBanner.svelte b/frontend/src/lib/components/LocalDraftBanner.svelte
new file mode 100644
index 0000000000..357744c2b2
--- /dev/null
+++ b/frontend/src/lib/components/LocalDraftBanner.svelte
@@ -0,0 +1,101 @@
+<script lang="ts">
+	import { Button } from '$lib/components/common'
+	import DiffDrawer from '$lib/components/DiffDrawer.svelte'
+	import { classes } from '$lib/components/common/alert/model'
+	import { type Value } from '$lib/utils'
+	import { AlertCircle } from 'lucide-svelte'
+	import { twMerge } from 'tailwind-merge'
+	import { slide } from 'svelte/transition'
+
+	interface Props {
+		/** Whether there are unsaved local changes relative to the deployed baseline. */
+		show: boolean
+		/** Deployed/backend baseline config (the "original" side of the diff). */
+		getDeployed: () => unknown
+		/** Current form config — the local autosave (the "current" side of the diff). */
+		getCurrent: () => unknown
+		/** Drop the local changes and reset the form to the deployed baseline. */
+		onDiscard: () => void | Promise<void>
+		/** When true (e.g. no write access), hide the Discard action. */
+		disabled?: boolean
+		/** Diff drawer title. */
+		title?: string
+	}
+
+	let {
+		show,
+		getDeployed,
+		getCurrent,
+		onDiscard,
+		disabled = false,
+		title = 'Deployed <> Local changes'
+	}: Props = $props()
+
+	let diffDrawer: DiffDrawer | undefined = $state()
+
+	function showDiff() {
+		const deployed = getDeployed()
+		if (deployed == null) return
+		// Snapshot both sides at click time. They are typically Svelte `$state`
+		// proxies (resource/variable's `initialStates[ws]` and the draft handle's
+		// cell); without snapshot the diff drawer would re-read them reactively
+		// and update as the user keeps typing behind it.
+		const original = $state.snapshot(deployed) as Value
+		const current = $state.snapshot(getCurrent()) as Value
+		diffDrawer?.openDrawer()
+		// Mirror the inline Discard's `disabled` gate inside the diff drawer —
+		// otherwise a read-only user could still trigger onDiscard via the
+		// drawer button even though we hid the banner's inline action.
+		diffDrawer?.setDiff({
+			mode: 'simple',
+			original,
+			current,
+			title,
+			button: disabled
+				? undefined
+				: {
+						text: 'Discard changes',
+						onClick: async () => {
+							await onDiscard()
+							diffDrawer?.closeDrawer()
+						}
+					}
+		})
+	}
+</script>
+
+<DiffDrawer bind:this={diffDrawer} />
+
+{#if show}
+	<div
+		transition:slide|local={{ duration: 120 }}
+		class={twMerge(
+			'flex flex-row items-center justify-between gap-2 px-4 py-1',
+			classes.warning.bgClass,
+			'!border-0 !rounded-none'
+		)}
+	>
+		<div class="flex flex-row items-center gap-2 min-w-0">
+			<AlertCircle class={classes.warning.iconClass} size={16} />
+			<span class={twMerge('text-xs font-semibold truncate', classes.warning.titleClass)}>
+				You have unsaved changes
+			</span>
+		</div>
+		<div class="flex flex-row items-center gap-2 shrink-0">
+			<Button
+				unifiedSize="sm"
+				variant="subtle"
+				btnClasses={classes.warning.titleClass}
+				on:click={showDiff}>Show diff</Button
+			>
+			{#if !disabled}
+				<Button
+					unifiedSize="sm"
+					variant="subtle"
+					btnClasses={classes.warning.titleClass}
+					on:click={onDiscard}>Discard</Button
+				>
+			{/if}
+		</div>
+	</div>
+{/if}
diff --git a/frontend/src/lib/components/ResourceEditor.svelte b/frontend/src/lib/components/ResourceEditor.svelte
index 9a5c69dbd2..126ab0dc7f 100644
--- a/frontend/src/lib/components/ResourceEditor.svelte
+++ b/frontend/src/lib/components/ResourceEditor.svelte
@@ -14,7 +14,6 @@
 	import { getUserExt } from '$lib/user'
 	import type { UserExt } from '$lib/stores'
 	import { UserDraft, checkStaleness, type UserDraftHandle } from '$lib/userDraft.svelte'
-	import { notifyRestoredFromLocal } from '$lib/userDraftToast'
 	import LocalDraftStaleModal from './common/confirmationModal/LocalDraftStaleModal.svelte'
 
 	interface Props {
@@ -26,6 +25,14 @@
 		defaultValues?: Record<string, any> | undefined
 		workspace?: string | undefined
 		selected?: string | undefined
+		/** Notifies the parent drawer whether a local draft for the selected
+		 * workspace diverges from the deployed baseline, so it can show the
+		 * "unsaved changes" banner below its header. */
+		onDraftStateChange?: (hasDraft: boolean) => void
+		/** Notifies the parent drawer of write-access for the selected workspace,
+		 * so it can hide the banner's Discard button in read-only mode (matches
+		 * the trigger editors' `disabled={!can_write}` wiring). */
+		onCanWriteChange?: (canWrite: boolean) => void
 	}
 
 	let {
@@ -36,7 +43,9 @@
 		onChange,
 		defaultValues = undefined,
 		workspace = undefined,
-		selected: selectedProp = $bindable()
+		selected: selectedProp = $bindable(),
+		onDraftStateChange,
+		onCanWriteChange
 	}: Props = $props()
 
 	type ResourceState = {
@@ -189,6 +198,11 @@
 		Object.keys(states).filter((ws) => !deepEqual(states[ws].draft, initialStates[ws]))
 	)
 	const anyDirty = $derived(dirtyWorkspaces.length > 0)
+	// Banner is scoped to the selected workspace — the diff/discard only
+	// operate on it, so showing it for an unrelated dirty workspace would be
+	// misleading. The cross-workspace `otherDirty` alert below still covers
+	// that case.
+	const selectedDirty = $derived(!!selected && dirtyWorkspaces.includes(selected))
 	const otherDirty = $derived(
 		dirtyWorkspaces.length == 1
 			? dirtyWorkspaces.filter((ws) => ws !== $workspaceStore)
@@ -219,9 +233,7 @@
 			const s: ResourceState = {
 				path: '',
 				description: '',
-				args: (defaultValues && Object.keys(defaultValues).length > 0
-					? defaultValues
-					: {}) as any,
+				args: (defaultValues && Object.keys(defaultValues).length > 0 ? defaultValues : {}) as any,
 				labels: undefined,
 				wsSpecific: false
 			}
@@ -276,11 +288,6 @@
 								{ workspace: ws }
 							)
 						}
-						notifyRestoredFromLocal(false, true, {
-							onResetToDeployed: () => {
-								UserDraft.discard('resource', initialPath ?? '', s, { workspace: ws })
-							}
-						})
 					}
 				}
 				ensureHandle(ws, s)
@@ -329,6 +336,29 @@
 		canSave = anyDirty && dirtyValid && dirtyCanWrite
 	})
 
+	// Drive the parent drawer's "unsaved changes" banner. The drawer chrome
+	// (header + banner slot) lives in ResourceEditorDrawer, above this
+	// lazily-imported content, so the state is lifted up via these accessors.
+	$effect(() => {
+		onDraftStateChange?.(!!initialPath && selectedDirty)
+	})
+	$effect(() => {
+		onCanWriteChange?.(can_write)
+	})
+
+	export function localDraftDeployed(): ResourceState | undefined {
+		return selected ? initialStates[selected] : undefined
+	}
+	export function localDraftCurrent(): ResourceState | undefined {
+		return current
+	}
+	export function discardLocalDraft(): void {
+		if (!selected) return
+		UserDraft.discard('resource', initialPath ?? '', initialStates[selected], {
+			workspace: selected
+		})
+	}
+
 	$effect(() => {
 		if (current)
 			// $state.snapshot deep-reads (so the effect re-runs on nested
diff --git a/frontend/src/lib/components/ResourceEditorDrawer.svelte b/frontend/src/lib/components/ResourceEditorDrawer.svelte
index ed80717a32..919f8edeff 100644
--- a/frontend/src/lib/components/ResourceEditorDrawer.svelte
+++ b/frontend/src/lib/components/ResourceEditorDrawer.svelte
@@ -6,6 +6,7 @@
 	import { Loader2, Save } from 'lucide-svelte'
 	import WsSpecificVersions from './WsSpecificVersions.svelte'
 	import { workspaceStore } from '$lib/stores'
+	import LocalDraftBanner from './LocalDraftBanner.svelte'
 
 	let {
 		workspace = undefined,
@@ -17,7 +18,16 @@
 	let resource_type: string | undefined = $state(undefined)
 	let defaultValues: Record<string, any> | undefined = $state(undefined)
 
-	let resourceEditor: { save: () => void } | undefined = $state(undefined)
+	let resourceEditor:
+		| {
+				save: () => void
+				localDraftDeployed: () => unknown
+				localDraftCurrent: () => unknown
+				discardLocalDraft: () => void
+		  }
+		| undefined = $state(undefined)
+	let hasLocalDraft = $state(false)
+	let canWriteSelected = $state(true)
 
 	let path: string | undefined = $state(undefined)
 	let selected: string | undefined = $state(undefined)
@@ -62,8 +72,19 @@
 				bind:this={resourceEditor}
 				bind:canSave
 				bind:selected
+				onDraftStateChange={(v) => (hasLocalDraft = v)}
+				onCanWriteChange={(v) => (canWriteSelected = v)}
 			/>
 		{/await}
+		{#snippet banner()}
+			<LocalDraftBanner
+				show={hasLocalDraft}
+				getDeployed={() => resourceEditor?.localDraftDeployed()}
+				getCurrent={() => resourceEditor?.localDraftCurrent()}
+				onDiscard={() => resourceEditor?.discardLocalDraft()}
+				disabled={!canWriteSelected}
+			/>
+		{/snippet}
 		{#snippet actions()}
 			{#if mode == 'edit' && path && effectiveWorkspace}
 				<WsSpecificVersions
diff --git a/frontend/src/lib/components/ScriptBuilder.svelte b/frontend/src/lib/components/ScriptBuilder.svelte
index 710ce9bd5d..9dc36e3503 100644
--- a/frontend/src/lib/components/ScriptBuilder.svelte
+++ b/frontend/src/lib/components/ScriptBuilder.svelte
@@ -81,7 +81,7 @@
 	import { writable } from 'svelte/store'
 	import { defaultScriptLanguages, processLangs } from '$lib/scripts'
 	import DefaultScripts from './DefaultScripts.svelte'
-	import { onMount, setContext, untrack } from 'svelte'
+	import { getContext, onMount, setContext, untrack } from 'svelte'
 	import EditorHeader from './EditorHeader.svelte'
 	import LabelsInput from './LabelsInput.svelte'
 
@@ -134,7 +134,9 @@
 		onSaveDraftError,
 		onSaveDraft,
 		onNavigate,
-		disableAi
+		disableAi,
+		initialTestPanelCollapsed = false,
+		initialPathChosen = false
 	}: ScriptBuilderProps = $props()
 
 	export function getInitialAndModifiedValues(): SavedAndModifiedValue {
@@ -626,17 +628,23 @@
 			if (!disableHistoryChange) {
 				history.replaceState(history.state, '', `/scripts/edit/${script.path}`)
 			}
-			if (
+			// "Stay" deploys (explicit "Deploy & Stay here" or lib scripts) keep the
+			// editor in place rather than navigating to the deployed item.
+			const stayHere =
 				stay ||
 				(script.auto_kind === 'lib' &&
 					script.kind !== 'preprocessor' &&
 					!isWorkflowAsCode(script.content, script.language))
-			) {
+			if (stayHere) {
+				// Re-pin parent_hash so the next deploy's conflict check is against
+				// the version we just wrote.
 				script.parent_hash = newHash
-				sendUserToast('Deployed')
-			} else {
-				onDeploy?.({ path: script.path, hash: newHash })
 			}
+			// Always notify on a successful deploy; the consumer decides whether to
+			// navigate (route) or stay + sync the preview (session). Previously the
+			// stay/lib branch skipped onDeploy, so session previews didn't sync after
+			// a "Deploy & Stay here" or lib-script deploy.
+			onDeploy?.({ path: script.path, hash: newHash, stay: stayHere })
 		} catch (error) {
 			onDeployError?.({ path: script.path, error })
 			sendUserToast(`Error while saving the script: ${error.body || error.message}`, true)
@@ -793,6 +801,12 @@
 		loadingDraft = false
 	}
 
+	// Inside an AI session pane (which injects an aiChatManager via context) the
+	// extra deploy-dropdown options — Deploy & Stay here, Fork, Edit in workspace
+	// fork, Exit & See details, Export — don't make sense: the session always
+	// stays put and is already scoped to a fork. Only "Show diff" is kept.
+	const inSessionPane = !!getContext('aiChatManager')
+
 	function computeDropdownItems(
 		initialPath: string,
 		savedScript: NewScriptWithDraftAndDraftTriggers | undefined,
@@ -801,26 +815,30 @@
 		let dropdownItems: { label: string; onClick: () => void }[] =
 			initialPath != '' && customUi?.topBar?.extraDeployOptions != false
 				? [
-						{
-							label: 'Deploy & Stay here',
-							onClick: () => {
-								handleEditScript(true)
-							}
-						},
-						{
-							label: 'Fork',
-							onClick: () => {
-								window.open(`/scripts/add?template=${initialPath}`)
-							}
-						},
-						...(!isCloudHosted() && !isRuleActive('DisableWorkspaceForking')
+						...(!inSessionPane
 							? [
 									{
-										label: 'Edit in workspace fork',
+										label: 'Deploy & Stay here',
 										onClick: () => {
-											window.open(buildForkEditUrl('script', initialPath))
+											handleEditScript(true)
 										}
-									}
+									},
+									{
+										label: 'Fork',
+										onClick: () => {
+											window.open(`/scripts/add?template=${initialPath}`)
+										}
+									},
+									...(!isCloudHosted() && !isRuleActive('DisableWorkspaceForking')
+										? [
+												{
+													label: 'Edit in workspace fork',
+													onClick: () => {
+														window.open(buildForkEditUrl('script', initialPath))
+													}
+												}
+											]
+										: [])
 								]
 							: []),
 						...(customUi?.topBar?.diff !== false && savedScript && diffDrawer
@@ -852,7 +870,10 @@
 									}
 								]
 							: []),
-						...(!script.draft_only && script.kind === 'script' && !script.auto_kind
+						...(!inSessionPane &&
+						!script.draft_only &&
+						script.kind === 'script' &&
+						!script.auto_kind
 							? [
 									{
 										label: 'Exit & See details',
@@ -862,7 +883,7 @@
 									}
 								]
 							: []),
-						...(isWorkflowAsCode(script.content, script.language)
+						...(!inSessionPane && isWorkflowAsCode(script.content, script.language)
 							? [
 									{
 										label: 'Export as YAML/JSON',
@@ -875,7 +896,11 @@
 					]
 				: []
 
-		if (dropdownItems.length === 0 && isWorkflowAsCode(script.content, script.language)) {
+		if (
+			!inSessionPane &&
+			dropdownItems.length === 0 &&
+			isWorkflowAsCode(script.content, script.language)
+		) {
 			dropdownItems = [
 				{
 					label: 'Export as YAML/JSON',
@@ -901,7 +926,11 @@
 	}
 
 	let path: Path | undefined = $state(undefined)
-	let dirtyPath = $state(false)
+	// Seed "path is already chosen" so the summary→path auto-slug (which only
+	// runs for new scripts with initialPath == '') doesn't clobber a path the
+	// caller pre-assigned. The session preview opens AI-created scripts as new
+	// (empty initialPath) but with a path the AI already picked.
+	let dirtyPath = $state(initialPathChosen)
 
 	let selectedTab: 'metadata' | 'runtime' | 'ui' | 'triggers' = $state(
 		(() => {
@@ -2091,6 +2120,7 @@
 			bind:assets={script.assets}
 			bind:modules={script.modules}
 			enablePreprocessorSnippet
+			{initialTestPanelCollapsed}
 		/>
 	</div>
 {:else}
diff --git a/frontend/src/lib/components/ScriptEditor.svelte b/frontend/src/lib/components/ScriptEditor.svelte
index 744450e3d3..9a7b4aaf83 100644
--- a/frontend/src/lib/components/ScriptEditor.svelte
+++ b/frontend/src/lib/components/ScriptEditor.svelte
@@ -177,6 +177,11 @@
 		 * to clicking a run button on the graph.
 		 */
 		onTestStateChange?: (running: boolean) => void
+		// When true the right-hand test/run pane mounts collapsed. The user
+		// can still expand it via `toggleTestPanel`. Defaults to false so the
+		// regular /scripts/edit route keeps its current open-by-default UX;
+		// the session preview opts in to save vertical real estate.
+		initialTestPanelCollapsed?: boolean
 	}
 
 	let {
@@ -212,7 +217,8 @@
 		editorBarRight,
 		enablePreprocessorSnippet = false,
 		previewLayout = 'right',
-		onTestStateChange
+		onTestStateChange,
+		initialTestPanelCollapsed = false
 	}: Props = $props()
 
 	$effect(() => {
@@ -1440,8 +1446,11 @@
 	// dynamic minimum below — so when the editor shrinks, the displayed test
 	// pane grows to honor the new minimum without needing an effect. The code
 	// pane's size is purely derived from it (100 - test).
-	let rawTestPanelSize = $state(30)
-	let storedTestPanelSize = untrack(() => rawTestPanelSize)
+	// `initialTestPanelCollapsed` seeds the raw value at 0 (collapsed) while
+	// keeping the "remembered" size at 30, so the user's first toggle expands
+	// the pane to a sensible width rather than 0.
+	let rawTestPanelSize = $state(untrack(() => (initialTestPanelCollapsed ? 0 : 30)))
+	let storedTestPanelSize = 30
 	const testPanelSize = $derived(
 		rawTestPanelSize === 0 ? 0 : Math.max(rawTestPanelSize, testPaneMinPercent)
 	)
diff --git a/frontend/src/lib/components/SimpleEditor.svelte b/frontend/src/lib/components/SimpleEditor.svelte
index 50089db519..36fcffc6e6 100644
--- a/frontend/src/lib/components/SimpleEditor.svelte
+++ b/frontend/src/lib/components/SimpleEditor.svelte
@@ -14,6 +14,7 @@
 	import { BROWSER } from 'esm-env'
 
 	import { editorConfig, updateOptions } from '$lib/editorUtils'
+	import { editorFontSize } from '$lib/editorFontSize.svelte'
 	import { createHash } from '$lib/editorLangUtils'
 
 	// import {
@@ -298,7 +299,14 @@
 		}
 	})
 
-	let fontSize = $derived(small ? 12 : 13.5)
+	let fontSize = $derived(small ? editorFontSize.small : editorFontSize.regular)
+
+	$effect(() => {
+		const next = fontSize
+		if (editor) {
+			editor.updateOptions({ fontSize: next })
+		}
+	})
 
 	async function loadMonaco() {
 		setMonacoJsonOptions()
diff --git a/frontend/src/lib/components/TemplateEditor.svelte b/frontend/src/lib/components/TemplateEditor.svelte
index 85392fcdfa..2fef927c9a 100644
--- a/frontend/src/lib/components/TemplateEditor.svelte
+++ b/frontend/src/lib/components/TemplateEditor.svelte
@@ -16,6 +16,7 @@
 		registerWebviewPaste,
 		updateOptions
 	} from '$lib/editorUtils'
+	import { editorFontSize } from '$lib/editorFontSize.svelte'
 	import { createHash } from '$lib/editorLangUtils'
 
 	import libStdContent from '$lib/es6.d.ts.txt?raw'
@@ -400,11 +401,13 @@
 		extraLib = '',
 		autoHeight = true,
 		fixedOverflowWidgets = true,
-		fontSize = 12,
+		fontSize,
 		loadAsync = false,
 		class: clazz = ''
 	}: Props = $props()
 
+	let effectiveFontSize = $derived(fontSize ?? editorFontSize.regular)
+
 	let yPadding = MONACO_Y_PADDING
 
 	if (typeof code != 'string') {
@@ -472,7 +475,7 @@
 				// lineNumbers: 'on',
 				lineDecorationsWidth: 0,
 				lineNumbersMinChars: 2,
-				fontSize,
+				fontSize: effectiveFontSize,
 				suggestOnTriggerCharacters: true,
 				renderLineHighlight: 'none',
 				lineNumbers: 'off',
@@ -688,6 +691,13 @@
 	$effect(() => {
 		mounted && extraLib && initialized && untrack(() => loadExtraLib())
 	})
+
+	$effect(() => {
+		const next = effectiveFontSize
+		if (editor) {
+			editor.updateOptions({ fontSize: next })
+		}
+	})
 </script>
 
 <EditorTheme />
@@ -696,7 +706,7 @@
 	class={twMerge(inputBorderClass({ forceFocus: isFocus }), 'rounded-md overflow-auto pl-2', clazz)}
 >
 	{#if !editor}
-		<FakeMonacoPlaceHolder autoheight showNumbers={false} {code} {fontSize} />
+		<FakeMonacoPlaceHolder autoheight showNumbers={false} {code} fontSize={effectiveFontSize} />
 	{/if}
 	<div
 		bind:this={divEl}
diff --git a/frontend/src/lib/components/VariableEditor.svelte b/frontend/src/lib/components/VariableEditor.svelte
index 962009e63d..2421738fb4 100644
--- a/frontend/src/lib/components/VariableEditor.svelte
+++ b/frontend/src/lib/components/VariableEditor.svelte
@@ -17,8 +17,8 @@
 	import { getUserExt } from '$lib/user'
 	import type { UserExt } from '$lib/stores'
 	import { UserDraft, checkStaleness, type UserDraftHandle } from '$lib/userDraft.svelte'
-	import { notifyRestoredFromLocal } from '$lib/userDraftToast'
 	import LocalDraftStaleModal from './common/confirmationModal/LocalDraftStaleModal.svelte'
+	import LocalDraftBanner from './LocalDraftBanner.svelte'
 
 	const dispatch = createEventDispatcher()
 
@@ -128,6 +128,11 @@
 		Object.keys(states).filter((ws) => !deepEqual(states[ws].draft, initialStates[ws]))
 	)
 	const anyDirty = $derived(dirtyWorkspaces.length > 0)
+	// Banner is scoped to the selected workspace — the diff/discard only
+	// operate on it, so showing it for an unrelated dirty workspace would be
+	// misleading. The cross-workspace `otherDirty` alert below still covers
+	// that case.
+	const selectedDirty = $derived(!!selected && dirtyWorkspaces.includes(selected))
 	const otherDirty = $derived(
 		dirtyWorkspaces.length == 1
 			? dirtyWorkspaces.filter((ws) => ws !== $workspaceStore)
@@ -183,11 +188,6 @@
 						if (previousMeta.remoteRev === undefined && previousMeta.remoteDraftRev === undefined) {
 							UserDraft.saveMeta('variable', p, { remoteRev: v.edited_at }, { workspace: ws })
 						}
-						notifyRestoredFromLocal(false, true, {
-							onResetToDeployed: () => {
-								UserDraft.discard('variable', p, s, { workspace: ws })
-							}
-						})
 					}
 				}
 				ensureHandle(ws, s)
@@ -327,6 +327,20 @@
 		title={edit ? `Update variable at ${initialPath}` : 'Add a variable'}
 		on:close={drawer?.closeDrawer}
 	>
+		{#snippet banner()}
+			<LocalDraftBanner
+				show={edit && selectedDirty}
+				getDeployed={() => (selected ? initialStates[selected] : undefined)}
+				getCurrent={() => current}
+				onDiscard={() => {
+					if (!selected) return
+					UserDraft.discard('variable', editPath ?? '', initialStates[selected], {
+						workspace: selected
+					})
+				}}
+				disabled={!can_write}
+			/>
+		{/snippet}
 		<div class="flex flex-col gap-8">
 			{#if !can_write}
 				<Alert type="warning" title="Only read access">
diff --git a/frontend/src/lib/components/VariableForm.svelte b/frontend/src/lib/components/VariableForm.svelte
index 0ffa4d8ba6..c688759874 100644
--- a/frontend/src/lib/components/VariableForm.svelte
+++ b/frontend/src/lib/components/VariableForm.svelte
@@ -75,7 +75,7 @@
 		disabled={edit && $userStore?.operator}
 	/>
 	{#if variable.is_secret}
-		<Alert type="warning" title="Audit log for each access">
+		<Alert type="info" title="Audit log for each access">
 			Every secret is encrypted at rest and in transit with a key specific to this workspace. In
 			addition, any read of a secret variable generates an audit log whose operation name is:
 			variables.decrypt_secret
diff --git a/frontend/src/lib/components/WorkspaceItemDiffViewer.svelte b/frontend/src/lib/components/WorkspaceItemDiffViewer.svelte
new file mode 100644
index 0000000000..2ee01b4607
--- /dev/null
+++ b/frontend/src/lib/components/WorkspaceItemDiffViewer.svelte
@@ -0,0 +1,162 @@
+<!--
+@component
+Inline diff renderer for a single workspace item. Mirrors the per-kind
+rendering that DiffDrawer does in its body (`DiffDrawer.svelte:181-271`):
+
+- `flow` → `<FlowDiffViewer>` (its own Graph / YAML toggle inside)
+- has `content` (scripts) → Tabs(Content | Metadata) with two Monaco diffs
+- everything else (apps, resources, variables, schedules, triggers…) →
+  a single Monaco YAML diff over the metadata
+
+`inlineDiff` flips Monaco's `renderSideBySide` to false (unified view).
+The component is content-sized — each Monaco block is sized to fit its
+diff text (no internal scroll) using `lines * 19 + 24`; for the
+Content+Metadata case we use the max of the two so switching tabs
+doesn't reflow the parent.
+-->
+<script lang="ts">
+	import Tabs from './common/tabs/Tabs.svelte'
+	import Tab from './common/tabs/Tab.svelte'
+	import FlowDiffViewer from './FlowDiffViewer.svelte'
+	import { Loader2 } from 'lucide-svelte'
+	import { cleanValueProperties, orderedYamlStringify, replaceFalseWithUndefined } from '$lib/utils'
+	import { scriptLangToEditorLang } from '$lib/scripts'
+
+	interface Props {
+		/** Any WorkspaceItemDiff['kind'] — used only to special-case `flow`. */
+		kind: string
+		/** Raw value from `getItemValue(kind, path, parentWorkspace)`. Undefined
+		 * for "added" items (don't exist in the parent). */
+		originalRaw?: unknown
+		/** Raw value from `getItemValue(kind, path, forkWorkspace)`. Undefined
+		 * for "removed" items (don't exist in the fork). */
+		currentRaw?: unknown
+		/** Force unified diff (Monaco renderSideBySide=false). Default false. */
+		inlineDiff?: boolean
+	}
+
+	let { kind, originalRaw, currentRaw, inlineDiff = false }: Props = $props()
+
+	type Prepared = { lang?: string; content?: string; metadata: string }
+
+	function prepareValue(raw: unknown): Prepared {
+		if (!raw || typeof raw !== 'object') {
+			return { metadata: raw == null ? '' : String(raw) }
+		}
+		const cleaned = structuredClone(
+			cleanValueProperties(replaceFalseWithUndefined(raw as Record<string, unknown>))
+		)
+		const content = (cleaned as Record<string, unknown>)['content']
+		if (content !== undefined) {
+			delete (cleaned as Record<string, unknown>)['content']
+		}
+		const language = (raw as Record<string, unknown>).language
+		return {
+			lang:
+				typeof language === 'string'
+					? scriptLangToEditorLang(language as Parameters<typeof scriptLangToEditorLang>[0])
+					: undefined,
+			content: typeof content === 'string' ? content : undefined,
+			metadata: orderedYamlStringify(cleaned)
+		}
+	}
+
+	const original = $derived(prepareValue(originalRaw))
+	const current = $derived(prepareValue(currentRaw))
+	const hasContent = $derived(original.content !== undefined || current.content !== undefined)
+
+	// For added / removed flows, the missing side feeds an empty YAML so
+	// the YAML-mode editor shows the whole new (or removed) flow as a
+	// single-sided diff. FlowGraphDiffViewer uses the *Missing flag to
+	// swap in its own OpenFlow stub for parsing and to draw a placeholder
+	// pane in side-by-side mode.
+	const beforeFlowYaml = $derived(originalRaw == null ? '' : original.metadata)
+	const afterFlowYaml = $derived(currentRaw == null ? '' : current.metadata)
+
+	let contentTab: 'content' | 'metadata' = $state('content')
+
+	// Per-tab height: each Monaco block sizes to its own content. Switching
+	// tabs reflows the row, which is the expected tab behavior; we don't
+	// over-allocate to the larger tab the way the previous max() did.
+	const LINE_HEIGHT = 19
+	const EDITOR_CHROME = 24
+	function linesIn(s?: string): number {
+		return Math.max((s ?? '').split('\n').length, 1)
+	}
+	const contentHeight = $derived(
+		`${Math.max(linesIn(original.content), linesIn(current.content)) * LINE_HEIGHT + EDITOR_CHROME}px`
+	)
+	const metadataHeight = $derived(
+		`${Math.max(linesIn(original.metadata), linesIn(current.metadata)) * LINE_HEIGHT + EDITOR_CHROME}px`
+	)
+	const activeTabHeight = $derived(contentTab === 'content' ? contentHeight : metadataHeight)
+</script>
+
+{#if kind === 'flow'}
+	<div class="h-[600px]">
+		<FlowDiffViewer
+			beforeYaml={beforeFlowYaml}
+			afterYaml={afterFlowYaml}
+			beforeMissing={originalRaw == null}
+			afterMissing={currentRaw == null}
+			{inlineDiff}
+		/>
+	</div>
+{:else if hasContent}
+	<div class="flex flex-col">
+		<Tabs bind:selected={contentTab}>
+			<Tab value="content" label="Content" />
+			<Tab value="metadata" label="Metadata" />
+		</Tabs>
+		<div style="height: {activeTabHeight}">
+			{#if contentTab === 'content'}
+				{#await import('$lib/components/DiffEditor.svelte')}
+					<div class="p-3"><Loader2 class="w-3.5 h-3.5 animate-spin" /></div>
+				{:then Module}
+					<Module.default
+						open={true}
+						automaticLayout
+						className="h-full"
+						defaultLang={original.lang ?? current.lang}
+						defaultOriginal={original.content ?? ''}
+						defaultModified={current.content ?? ''}
+						{inlineDiff}
+						readOnly
+					/>
+				{/await}
+			{:else}
+				{#await import('$lib/components/DiffEditor.svelte')}
+					<div class="p-3"><Loader2 class="w-3.5 h-3.5 animate-spin" /></div>
+				{:then Module}
+					<Module.default
+						open={true}
+						automaticLayout
+						className="h-full"
+						defaultLang="yaml"
+						defaultOriginal={original.metadata}
+						defaultModified={current.metadata}
+						{inlineDiff}
+						readOnly
+					/>
+				{/await}
+			{/if}
+		</div>
+	</div>
+{:else}
+	{#await import('$lib/components/DiffEditor.svelte')}
+		<div class="p-3"><Loader2 class="w-3.5 h-3.5 animate-spin" /></div>
+	{:then Module}
+		<div style="height: {metadataHeight}">
+			<Module.default
+				open={true}
+				automaticLayout
+				className="h-full"
+				defaultLang="yaml"
+				defaultOriginal={original.metadata}
+				defaultModified={current.metadata}
+				{inlineDiff}
+				readOnly
+			/>
+		</div>
+	{/await}
+{/if}
diff --git a/frontend/src/lib/components/WorkspaceItemDrillPicker.svelte b/frontend/src/lib/components/WorkspaceItemDrillPicker.svelte
index abee584afa..dda620dad5 100644
--- a/frontend/src/lib/components/WorkspaceItemDrillPicker.svelte
+++ b/frontend/src/lib/components/WorkspaceItemDrillPicker.svelte
@@ -17,8 +17,10 @@ Clicking a row drills *down*; the chevron-left in the header walks one level
 	import { ChevronLeft, ChevronRight, Folder, Layers, Loader2, User } from 'lucide-svelte'
 	import TextInput from '$lib/components/text_input/TextInput.svelte'
 	import RowIcon from '$lib/components/common/table/RowIcon.svelte'
+	import WorkspaceItemRow from '$lib/components/WorkspaceItemRow.svelte'
 	import SearchItems from '$lib/components/SearchItems.svelte'
 	import { onMount, untrack } from 'svelte'
+	import { generateRandomString } from '$lib/utils'
 	import {
 		dirKey,
 		getCachedItems,
@@ -30,6 +32,8 @@ Clicking a row drills *down*; the chevron-left in the header walks one level
 		type WorkspaceItem,
 		type WorkspaceItemKind
 	} from './workspacePicker'
+	import { listGlobalDrafts } from '$lib/components/copilot/chat/global/userDraftAdapter'
+	import { isGlobalAiEnabled } from '$lib/components/copilot/chat/global/gate'
 
 	type Kind = WorkspaceItemKind
 	type Item = WorkspaceItem
@@ -62,7 +66,7 @@ Clicking a row drills *down*; the chevron-left in the header walks one level
 
 	let searchInput: TextInput | undefined = $state()
 	let pickerRoot: HTMLElement | undefined = $state()
-	const instanceId = crypto.randomUUID()
+	const instanceId = generateRandomString(8)
 	const listboxId = `pkr-list-${instanceId}`
 	const idFor = (key: string) => `pkr-${instanceId}-${key.replace(/[^a-zA-Z0-9-]/g, '_')}`
 
@@ -72,8 +76,16 @@ Clicking a row drills *down*; the chevron-left in the header walks one level
 
 	// Sibling-popover open: melt-ui's `openFocus` runs once during the close→open
 	// transition; the picker may not be mounted yet. Retry after settle.
+	// Also kicks off the initial scope's fetch — drill/goUp do the same from
+	// their respective branches, so `ensureLoaded` is always a callback
+	// reaction to user navigation, never a reactive consequence.
 	onMount(() => {
 		const t = setTimeout(focus, 50)
+		const initial = untrack(() => scope)
+		if (initial) {
+			if (initial.kind === 'all') for (const k of kinds) ensureLoaded(k)
+			else ensureLoaded(initial.kind)
+		}
 		return () => clearTimeout(t)
 	})
 
@@ -82,6 +94,22 @@ Clicking a row drills *down*; the chevron-left in the header walks one level
 	let scope = $state<Scope>(untrack(() => initialScope))
 	let filter = $state('')
 
+	/**
+	 * Canonical entry point for changing the picker's scope. Triggers the
+	 * fetch for the kind(s) the new scope needs at the same point in time.
+	 * Replaces the older "react to `scope` change via `$effect`" wiring,
+	 * which had a subtle bug: `ensureLoaded` reads `loaded[kind]`, so the
+	 * effect ended up subscribed to the signal it fills — every fetch
+	 * result re-fired it. With explicit callbacks the fetch is tied to
+	 * the user's action, never to a reactive consequence of that action.
+	 */
+	function setScope(next: Scope) {
+		scope = next
+		if (!next) return
+		if (next.kind === 'all') for (const k of kinds) ensureLoaded(k)
+		else ensureLoaded(next.kind)
+	}
+
 	/** Tracks whether the last user action was mouse movement (true) or
 	 * keyboard nav (false). When false, row `mouseenter` events are ignored
 	 * — prevents the cursor from stealing the keyboard-driven highlight as
@@ -90,10 +118,11 @@ Clicking a row drills *down*; the chevron-left in the header walks one level
 	 * mounts under a stationary cursor doesn't clobber `initialHighlight`. */
 	let mouseActive = $state(false)
 
-	// Seed from cache so kinds already fetched in this session render on the
-	// first frame. Read once at mount: melt-ui mounts a fresh picker per
-	// popover open, so workspace changes are picked up at the next open
-	// without needing this seed to be reactive.
+	// Seed from the last fetched snapshot so kinds already fetched in this
+	// session render on the first frame. Each entry is replaced once
+	// `loadKind` returns fresh data — stale-while-revalidate, so deploys and
+	// AI-created drafts surface on the next open without explicit cache
+	// busting.
 	let loaded = $state<Partial<Record<Kind, Item[]>>>(
 		(() => {
 			if (!$workspaceStore) return {}
@@ -109,8 +138,15 @@ Clicking a row drills *down*; the chevron-left in the header walks one level
 
 	async function ensureLoaded(kind: Kind) {
 		if (!$workspaceStore) return
-		if (loaded[kind]) return
-		loadingKind[kind] = true
+		// Always re-fetch. If we have nothing cached, show a spinner; if we do,
+		// keep displaying it and quietly swap to fresh data when it lands.
+		// `loaded[kind]` is read inside `untrack(...)` because this function is
+		// reachable from the search `$effect` below — without the untrack,
+		// that effect would subscribe to the signal `ensureLoaded` fills, and
+		// each `loaded[kind] = items` (proxy `set` notifies even when the ref
+		// is unchanged from cache) would refire it → runaway loop. Drill
+		// navigation goes through `setScope` directly so it isn't affected.
+		if (!untrack(() => loaded[kind])) loadingKind[kind] = true
 		try {
 			const items = await loadKind($workspaceStore, kind)
 			loaded[kind] = items
@@ -119,13 +155,31 @@ Clicking a row drills *down*; the chevron-left in the header walks one level
 		}
 	}
 
-	// Fetch the scope's kind on entry to a non-root level. The `'all'` scope
-	// needs every kind loaded since it merges items across them.
-	$effect(() => {
-		if (!scope) return
-		if (scope.kind === 'all') for (const k of kinds) ensureLoaded(k)
-		else ensureLoaded(scope.kind)
-	})
+	// Chat tools and session editor previews write drafts through
+	// `UserDraft` (workspace-scoped, localStorage-backed). Merge those into
+	// the picker so users can navigate to in-flight items that haven't been
+	// deployed yet. Filter to kinds the picker actually displays.
+	//
+	// Gated on the same dev flag as the rest of the sessions feature: without
+	// it there are no sessions, so the only UserDrafts present are the
+	// standalone editors' autosaves — surfacing those in the breadcrumb picker
+	// would be surprising (they'd appear as navigable items that 404 on the
+	// backend draft fetch). When the flag is off this is a no-op.
+	const KIND_TO_DRAFT_TYPE = { flow: 'flow', script: 'script', app: 'app' } as const
+	function aiDraftsForKind(k: Kind): Item[] {
+		if (!isGlobalAiEnabled()) return []
+		if (!$workspaceStore) return []
+		const targetType = KIND_TO_DRAFT_TYPE[k]
+		return listGlobalDrafts($workspaceStore)
+			.filter((d) => d.type === targetType)
+			.map((d) => ({
+				path: d.path,
+				summary: d.summary ?? '',
+				kind: k,
+				// `raw_app` lives on the draft envelope for legacy/raw-app distinction.
+				raw_app: k === 'app' ? !!(d.value as { files?: unknown })?.files : undefined
+			}))
+	}
 
 	// Searching is global → load every kind.
 	$effect(() => {
@@ -140,6 +194,17 @@ Clicking a row drills *down*; the chevron-left in the header walks one level
 		leaves: Item[]
 	}
 
+	/** Merge AI-created in-memory drafts into a kind's list. The AI may have
+	 * scaffolded a script/flow/app via chat tools without the user saving
+	 * yet — those drafts should be navigable from the picker. Existing items
+	 * (same path) win to keep the backend's metadata (summary etc.). */
+	function withAiDrafts(items: Item[], k: Kind): Item[] {
+		const ai = aiDraftsForKind(k)
+		if (ai.length === 0) return items
+		const known = new Set(items.map((it) => it.path))
+		return items.concat(ai.filter((d) => !known.has(d.path)))
+	}
+
 	/** Inject the currently-edited item into a kind's list at its live path,
 	 * dropping the saved entry when a draft rename is in progress. Other kinds
 	 * pass through untouched. */
@@ -207,7 +272,7 @@ Clicking a row drills *down*; the chevron-left in the header walks one level
 	 * cached. */
 	function buildIfActive(k: Kind, list: Item[] | undefined): DirNode[] {
 		if (!kinds.includes(k)) return []
-		const items = withCurrent(list ?? [], k)
+		const items = withAiDrafts(withCurrent(list ?? [], k), k)
 		if (items.length === 0) return []
 		return buildTreeFromItems(items)
 	}
@@ -219,7 +284,7 @@ Clicking a row drills *down*; the chevron-left in the header walks one level
 	 * one folder hierarchy. Each leaf still carries its real kind, so the row
 	 * icon and `editPathFor` routing still work; folders contain a mix. */
 	const allTree = $derived.by(() => {
-		const merged = kinds.flatMap((k) => withCurrent(loaded[k] ?? [], k))
+		const merged = kinds.flatMap((k) => withAiDrafts(withCurrent(loaded[k] ?? [], k), k))
 		return merged.length === 0 ? [] : buildTreeFromItems(merged)
 	})
 
@@ -255,7 +320,10 @@ Clicking a row drills *down*; the chevron-left in the header walks one level
 
 	let allItems = $derived<SearchInput[]>(
 		kinds.flatMap((k) =>
-			withCurrent(loaded[k] ?? [], k).map((it) => ({ ...it, _key: `${k}:${it.path}` }))
+			withAiDrafts(withCurrent(loaded[k] ?? [], k), k).map((it) => ({
+				...it,
+				_key: `${k}:${it.path}`
+			}))
 		)
 	)
 
@@ -383,9 +451,9 @@ Clicking a row drills *down*; the chevron-left in the header walks one level
 
 	function drill(entry: Entry) {
 		if (entry.type === 'kind') {
-			scope = { kind: entry.kind }
+			setScope({ kind: entry.kind })
 		} else if (entry.type === 'dir') {
-			scope = { kind: entry.kind, dir: entry.node.fullPath }
+			setScope({ kind: entry.kind, dir: entry.node.fullPath })
 		} else {
 			pick(entry.item)
 		}
@@ -397,13 +465,13 @@ Clicking a row drills *down*; the chevron-left in the header walks one level
 		// just left, so the user sees where they came from.
 		if (!scope.dir) {
 			const leaving = kindKey(scope.kind)
-			scope = undefined
+			setScope(undefined)
 			highlightedKey = leaving
 			return
 		}
 		const leaving = dirKey(scope.kind, scope.dir)
 		const parent = parentDirPath(scope.dir)
-		scope = parent ? { kind: scope.kind, dir: parent } : { kind: scope.kind }
+		setScope(parent ? { kind: scope.kind, dir: parent } : { kind: scope.kind })
 		highlightedKey = leaving
 	}
 
@@ -528,32 +596,18 @@ Clicking a row drills *down*; the chevron-left in the header walks one level
 
 {#snippet leafRow(it: Item, secondary: string, baseClass: string)}
 	{@const key = leafKey(it)}
-	{@const isHl = key === highlightedKey}
-	{@const isCur = isCurrent(it)}
-	<button
-		type="button"
+	<WorkspaceItemRow
+		kind={it.kind}
+		summary={it.summary}
+		{secondary}
+		highlighted={key === highlightedKey}
+		current={isCurrent(it)}
 		id={idFor(key)}
-		role="option"
-		aria-selected={isHl}
-		data-nav-key={key}
-		aria-current={isCur ? 'true' : undefined}
-		class="w-full text-left flex items-center gap-2 px-3 transition-colors {baseClass} {isHl
-			? 'bg-surface-hover'
-			: ''} {isCur ? 'cursor-default text-emphasis font-medium' : ''}"
-		onmousedown={(e) => e.preventDefault()}
+		navKey={key}
+		{baseClass}
 		onclick={() => pick(it)}
 		onmouseenter={() => setHoverHighlight(key)}
-	>
-		<RowIcon kind={it.kind} size={12} />
-		<div class="min-w-0 flex-1">
-			{#if it.summary}
-				<div class="text-xs text-primary truncate">{it.summary}</div>
-				<div class="text-2xs text-secondary font-normal font-mono truncate">{secondary}</div>
-			{:else}
-				<div class="text-xs text-primary font-mono truncate">{secondary}</div>
-			{/if}
-		</div>
-	</button>
+	/>
 {/snippet}
 
 <!-- svelte-ignore a11y_no_static_element_interactions -->
diff --git a/frontend/src/lib/components/WorkspaceItemRow.svelte b/frontend/src/lib/components/WorkspaceItemRow.svelte
new file mode 100644
index 0000000000..8ddd3fa317
--- /dev/null
+++ b/frontend/src/lib/components/WorkspaceItemRow.svelte
@@ -0,0 +1,148 @@
+<!--
+@component
+Visual row for a workspace item (script / flow / app / resource /
+schedule / trigger / …). Matches the leaf-row layout used by
+WorkspaceItemDrillPicker: RowIcon + summary line on top with mono path
+beneath, or just the mono path when there's no summary.
+
+Pure presentation — the caller controls highlighting / current state via
+props, supplies the onclick/onmouseenter handlers, and can pass an
+`extras` snippet for right-side adornments (status dots, badges, …).
+The button uses `onmousedown={(e) => e.preventDefault()}` so the click
+doesn't steal focus from a sibling search input (matches the picker).
+-->
+<script module lang="ts">
+	import type { ComponentProps } from 'svelte'
+	import RowIconType from '$lib/components/common/table/RowIcon.svelte'
+	export type WorkspaceItemRowKind = ComponentProps<typeof RowIconType>['kind']
+</script>
+
+<script lang="ts">
+	import RowIcon from '$lib/components/common/table/RowIcon.svelte'
+	import type { Snippet } from 'svelte'
+
+	interface Props {
+		kind: WorkspaceItemRowKind
+		/** For `kind: 'trigger'`, specifies the concrete trigger subtype.
+		 * Forwarded to RowIcon. */
+		triggerKind?: string
+		/** Optional summary text shown above the path. */
+		summary?: string
+		/** Mono path (or any secondary identifier). When summary is empty
+		 * this is the only visible text. */
+		secondary: string
+		/** Highlighted via keyboard nav. Used for `aria-selected` +
+		 * surface-hover background. */
+		highlighted?: boolean
+		/** "Currently editing this" — the picker uses this to grey out the
+		 * active row and disable its click. */
+		current?: boolean
+		/** DOM id, used for `aria-activedescendant`. */
+		id?: string
+		/** Stamped on the element as `data-nav-key` so the parent can
+		 * `pickerRoot.querySelector(...)` to scroll into view. */
+		navKey?: string
+		/** Per-row vertical padding class (e.g. `py-1` / `py-1.5`). */
+		baseClass?: string
+		/** Extra left padding (px) for tree-view indentation. Adds to the
+		 * default `px-3` horizontal padding. */
+		indent?: number
+		/** Title tooltip shown on hover; defaults to the secondary text. */
+		title?: string
+		/** When set, the row renders as an `<a href target="_blank">` link
+		 * instead of a `<button>`. Used by callers that want native
+		 * new-tab / cmd-click behaviour. `onclick` still forwards. */
+		href?: string
+		onclick?: () => void
+		onmouseenter?: () => void
+		/** Right-side adornments (status dot, badges, …). The `group` class
+		 * is always applied to the root so the snippet can use
+		 * `group-hover:*` utilities to reveal hover-only affordances. */
+		extras?: Snippet
+	}
+
+	let {
+		kind,
+		triggerKind,
+		summary,
+		secondary,
+		highlighted = false,
+		current = false,
+		id,
+		navKey,
+		baseClass = 'py-1.5',
+		indent = 0,
+		title,
+		href,
+		onclick,
+		onmouseenter,
+		extras
+	}: Props = $props()
+
+	const rootClass = $derived(
+		`group w-full text-left flex items-center gap-2 px-3 transition-colors ${baseClass} ${highlighted ? 'bg-surface-hover' : ''} ${current ? 'cursor-default text-emphasis font-medium' : ''}`
+	)
+</script>
+
+{#if href}
+	<a
+		{href}
+		target="_blank"
+		rel="noopener noreferrer"
+		{id}
+		role="option"
+		aria-selected={highlighted}
+		aria-current={current ? 'true' : undefined}
+		data-nav-key={navKey}
+		title={title ?? secondary}
+		style={indent ? `padding-left: calc(0.75rem + ${indent}px)` : undefined}
+		class={rootClass}
+		{onclick}
+		{onmouseenter}
+	>
+		<RowIcon {kind} {triggerKind} size={12} />
+		<div class="min-w-0 flex-1">
+			{#if summary}
+				<div class="text-xs text-primary truncate">{summary}</div>
+				<div class="text-2xs text-secondary font-normal font-mono truncate">{secondary}</div>
+			{:else}
+				<div class="text-xs text-primary font-mono truncate">{secondary}</div>
+			{/if}
+		</div>
+		{#if extras}
+			<div class="shrink-0 flex items-center gap-2">
+				{@render extras()}
+			</div>
+		{/if}
+	</a>
+{:else}
+	<button
+		type="button"
+		{id}
+		role="option"
+		aria-selected={highlighted}
+		aria-current={current ? 'true' : undefined}
+		data-nav-key={navKey}
+		title={title ?? secondary}
+		style={indent ? `padding-left: calc(0.75rem + ${indent}px)` : undefined}
+		class={rootClass}
+		onmousedown={(e) => e.preventDefault()}
+		{onclick}
+		{onmouseenter}
+	>
+		<RowIcon {kind} {triggerKind} size={12} />
+		<div class="min-w-0 flex-1">
+			{#if summary}
+				<div class="text-xs text-primary truncate">{summary}</div>
+				<div class="text-2xs text-secondary font-normal font-mono truncate">{secondary}</div>
+			{:else}
+				<div class="text-xs text-primary font-mono truncate">{secondary}</div>
+			{/if}
+		</div>
+		{#if extras}
+			<div class="shrink-0 flex items-center gap-2">
+				{@render extras()}
+			</div>
+		{/if}
+	</button>
+{/if}
diff --git a/frontend/src/lib/components/apps/components/display/AppMarkdown.svelte b/frontend/src/lib/components/apps/components/display/AppMarkdown.svelte
index e8ae0f8335..ff9c4263a8 100644
--- a/frontend/src/lib/components/apps/components/display/AppMarkdown.svelte
+++ b/frontend/src/lib/components/apps/components/display/AppMarkdown.svelte
@@ -5,10 +5,8 @@
 	import type { AppViewerContext, ComponentCustomCSS, RichConfigurations } from '../../types'
 	import { initCss } from '../../utils'
 	import RunnableWrapper from '../helpers/RunnableWrapper.svelte'
-	import { Markdown, type Plugin } from 'svelte-exmarkdown'
-	import { gfmPlugin } from 'svelte-exmarkdown/gfm'
-	import rehypeRaw from 'rehype-raw'
-	import { rehypeGithubAlerts } from 'rehype-github-alerts'
+	import { Markdown } from 'svelte-exmarkdown'
+	import { markdownPlugins as plugins } from '$lib/components/markdownPlugins'
 	import { classNames } from '$lib/utils'
 	import { components } from '../../editor/component'
 	import ResolveConfig from '../helpers/ResolveConfig.svelte'
@@ -31,11 +29,6 @@
 		configuration
 	}: Props = $props()
 
-	const plugins: Plugin[] = [
-		gfmPlugin(),
-		{ rehypePlugin: [rehypeRaw] },
-		{ rehypePlugin: [rehypeGithubAlerts] }
-	]
 	const { app, worldStore, mode } = getContext<AppViewerContext>('AppViewerContext')
 
 	const resolvedConfig = $state(
diff --git a/frontend/src/lib/components/apps/editor/AppEditor.svelte b/frontend/src/lib/components/apps/editor/AppEditor.svelte
index 4e62110eff..cd9acdbffa 100644
--- a/frontend/src/lib/components/apps/editor/AppEditor.svelte
+++ b/frontend/src/lib/components/apps/editor/AppEditor.svelte
@@ -3,7 +3,7 @@
 
 	const bubble = createBubbler()
 	import SplitPanesWrapper from '$lib/components/splitPanes/SplitPanesWrapper.svelte'
-	import { onMount, setContext, untrack } from 'svelte'
+	import { getContext, onMount, setContext, untrack } from 'svelte'
 	import { twMerge } from 'tailwind-merge'
 
 	import { Pane, Splitpanes } from 'svelte-splitpanes'
@@ -79,20 +79,29 @@
 		gotoFn = (path: string, opt?: Record<string, any>) => window.history.pushState(null, '', path),
 		unsavedConfirmationModal,
 		onSavedNewAppPath,
+		onNavigate,
 		initialRevs
 	}: AppEditorProps = $props()
 
 	migrateApp(untrack(() => app))
 
+	// Inside a session pane the AIChatManager is injected via context. Sessions
+	// have their own state machinery (sessionRuntime + per-fork backend), and
+	// the user-facing $workspaceStore stays on the main workspace even when
+	// the session is editing in a fork — so a UserDraft handle here would
+	// share its LS key with the regular /apps/edit route and clobber both
+	// sides' autosaves. Skip UserDraft entirely in that case.
+	const inSessionPane = !!getContext('aiChatManager')
+
 	const appDraftPath = newApp ? '' : (path ?? '')
-	const appDraftHandle = UserDraft.use<App>('app', appDraftPath)
+	const appDraftHandle = inSessionPane ? undefined : UserDraft.use<App>('app', appDraftPath)
 	// Prefer the persisted autosave over the prop when both exist (e.g.
 	// /apps/add reload: the route always initializes `app` to an empty
 	// template, but the user's last session is sitting in LS under the
 	// empty-path entry). The route is responsible for wiping the entry
 	// (`UserDraft.remove`) when it wants to force a fresh start —
 	// `?nodraft=true`, template/hub loads, etc.
-	const stateApp = $state(untrack(() => appDraftHandle.draft ?? app))
+	const stateApp = $state(untrack(() => appDraftHandle?.draft ?? app))
 	const appStore = writable<App>(stateApp)
 	// Captured once on mount: the load-time revs are only used as the
 	// seed meta on the very first persist of this entry. After that the
@@ -112,6 +121,7 @@
 	let firstMirror = true
 	$effect(() => {
 		readFieldsRecursively(stateApp)
+		if (!appDraftHandle) return
 		untrack(() => {
 			// Resolve the meta to attach BEFORE the wipe — the wipe clears
 			// in-memory meta and would otherwise force-seed `initialRevs`
@@ -165,7 +175,7 @@
 		groups: $userStore?.groups,
 		username: $userStore?.username,
 		name: $userStore?.name,
-		query: urlParamsToObject(new URL(window.location.href).searchParams),
+		query: urlParamsToObject(new URL(window.location.href).searchParams, { stripReserved: true }),
 		hash: window.location.hash.substring(1),
 		workspace: $workspaceStore,
 		mode: 'editor',
@@ -884,6 +894,7 @@
 			rightPanelHidden={rightPanelSize === 0}
 			bottomPanelHidden={runnablePanelSize === 0}
 			{onSavedNewAppPath}
+			{onNavigate}
 			onShowLeftPanel={() => showLeftPanel()}
 			onShowRightPanel={() => showRightPanel()}
 			onShowBottomPanel={() => showBottomPanel()}
diff --git a/frontend/src/lib/components/apps/editor/AppEditorHeader.svelte b/frontend/src/lib/components/apps/editor/AppEditorHeader.svelte
index 7a55f28860..5bbd0d17c7 100644
--- a/frontend/src/lib/components/apps/editor/AppEditorHeader.svelte
+++ b/frontend/src/lib/components/apps/editor/AppEditorHeader.svelte
@@ -64,7 +64,7 @@
 	import DebugPanel from './contextPanel/DebugPanel.svelte'
 
 	import EditorHeader from '$lib/components/EditorHeader.svelte'
-	import { editPathFor, invalidate as invalidatePicker } from '$lib/components/workspacePicker'
+	import { editPathFor } from '$lib/components/workspacePicker'
 	import { invalidateWorkspacePaths } from '$lib/components/PathNameAutocomplete.svelte'
 	import { goto } from '$app/navigation'
 	import HideButton from './settingsPanel/HideButton.svelte'
@@ -110,6 +110,7 @@
 		onHideRightPanel?: () => void
 		onHideLeftPanel?: () => void
 		onHideBottomPanel?: () => void
+		onNavigate?: (item: import('$lib/components/workspacePicker').WorkspaceItem) => void
 	}
 
 	let {
@@ -130,7 +131,8 @@
 		onShowBottomPanel,
 		onHideLeftPanel,
 		onHideRightPanel,
-		onHideBottomPanel
+		onHideBottomPanel,
+		onNavigate = undefined
 	}: Props = $props()
 
 	/** Mirror of the path the user is editing in the pen popover. Initialized
@@ -170,6 +172,14 @@
 	const { history, jobsDrawerOpen, refreshComponents } =
 		getContext<AppEditorContext>('AppEditorContext')
 
+	// Sessions inject an AIChatManager via context; AppEditor skips its
+	// UserDraft handle in that case, so the cleanup calls here must skip too
+	// (otherwise we'd wipe a non-session tab's autosave at the same path). The
+	// session-side equivalent is the View's `onDeploy` →
+	// `runtime.syncPreviewWithDeployed`, which discards the fork draft + reloads
+	// the preview to the deployed version.
+	const inSessionPane = !!getContext('aiChatManager')
+
 	const loading = $state({
 		publish: false,
 		save: false,
@@ -229,7 +239,7 @@
 			}
 			closeSaveDrawer()
 			sendUserToast('App deployed successfully')
-			UserDraft.remove('app', path)
+			if (!inSessionPane) UserDraft.remove('app', path)
 			onSavedNewAppPath?.(path)
 		} catch (e) {
 			sendUserToast('Error creating app', e)
@@ -313,7 +323,6 @@
 				preserve_on_behalf_of: preserveOnBehalfOf || undefined
 			}
 		})
-		invalidatePicker($workspaceStore!, 'app')
 		invalidateWorkspacePaths($workspaceStore!)
 		savedApp = {
 			summary: $summary,
@@ -330,7 +339,7 @@
 
 		closeSaveDrawer()
 		sendUserToast('App deployed successfully')
-		UserDraft.remove('app', $appPath)
+		if (!inSessionPane) UserDraft.remove('app', $appPath)
 		if ($appPath !== npath) {
 			onSavedNewAppPath?.(npath)
 		}
@@ -406,7 +415,7 @@
 			// The initial draft was promoted to a real path on the backend —
 			// drop the autosave keyed on the prior (possibly empty) path so
 			// a future "+ App" click opens on a clean slate.
-			UserDraft.remove('app', $appPath)
+			if (!inSessionPane) UserDraft.remove('app', $appPath)
 			onSavedNewAppPath?.(newEditedPath)
 		} catch (e) {
 			sendUserToast('Error saving initial draft', e)
@@ -497,7 +506,7 @@
 			}
 
 			sendUserToast('Draft saved')
-			UserDraft.remove('app', path)
+			if (!inSessionPane) UserDraft.remove('app', path)
 			loading.saveDraft = false
 			if (newApp || savedApp.draft_only) {
 				onSavedNewAppPath?.(newEditedPath || path)
@@ -1006,7 +1015,7 @@
 			bind:path={newEditedPath}
 			savedPath={$appPath || newPath || undefined}
 			kind="app"
-			onNavigate={(item) => goto(editPathFor(item))}
+			onNavigate={(item) => (onNavigate ? onNavigate(item) : goto(editPathFor(item)))}
 		/>
 		<div class="flex gap-2 {compactTopbar ? 'hidden' : ''}">
 			{#if $app}
diff --git a/frontend/src/lib/components/apps/editor/AppEditorHeaderDeploy.svelte b/frontend/src/lib/components/apps/editor/AppEditorHeaderDeploy.svelte
index 649e67ef0d..2294554f3e 100644
--- a/frontend/src/lib/components/apps/editor/AppEditorHeaderDeploy.svelte
+++ b/frontend/src/lib/components/apps/editor/AppEditorHeaderDeploy.svelte
@@ -35,7 +35,8 @@
 		newEditedPath = $bindable(),
 		newPath,
 		hideSecretUrl = false,
-		preserveOnBehalfOf = $bindable(false)
+		preserveOnBehalfOf = $bindable(false),
+		rawApp = false
 	}: {
 		policy: any
 		setPublishState: () => void
@@ -51,6 +52,11 @@
 		newPath: string
 		hideSecretUrl?: boolean
 		preserveOnBehalfOf?: boolean
+		// Raw apps need cross-origin isolation (wm_coep) to be embeddable. Classic
+		// (low-code) apps must NOT get the flag — it would force COEP on the
+		// document and break no-CORP cross-origin subresources (external images,
+		// {@html} embeds, CDN imports).
+		rawApp?: boolean
 	} = $props()
 
 	let isDeployer = $derived($userStore?.groups?.includes(WM_DEPLOYERS_GROUP) ?? false)
@@ -91,6 +97,17 @@
 			isCloudHosted() || globalWorkspacedRoute ? $workspaceStore + '/' : ''
 		}${customPath}`
 	)
+
+	// When embedding a raw app in an iframe inside another Windmill app (or any
+	// cross-origin-isolated page), the embedded document must set COEP. The
+	// `wm_coep` flag opts the public app into the cross-origin isolation headers.
+	// Only raw apps get it — for classic (low-code) apps COEP would break
+	// no-CORP cross-origin subresources, so their snippet stays a plain iframe.
+	let embedMode = $state(false)
+	function toEmbedSnippet(url: string): string {
+		const finalUrl = rawApp ? `${url}${url.includes('?') ? '&' : '?'}wm_coep=on` : url
+		return `<iframe src="${finalUrl}" title="Windmill app" width="100%" height="600"></iframe>`
+	}
 	async function getSecretUrl() {
 		secretUrl = await AppService.getPublicSecretOfApp({
 			workspace: $workspaceStore!,
@@ -122,7 +139,7 @@
 	})
 
 	$effect(() => {
-		appPath && appPath != '' && secretUrl == undefined && untrack(() => getSecretUrl())
+		appPath && appPath != '' && savedApp && secretUrl == undefined && untrack(() => getSecretUrl())
 	})
 </script>
 
@@ -247,18 +264,40 @@
 					policy.execution_mode = e.detail ? 'anonymous' : 'publisher'
 					setPublishState()
 				}}
-				disabled={appPath == ''}
+				disabled={!savedApp}
 			/>
 		</div>
-		{#if appPath == ''}
+		{#if !savedApp}
 			<ClipboardPanel content={`Save this app once to get the public secret URL`} size="md" />
 		{:else if secretUrlHref}
-			<ClipboardPanel content={secretUrlHref} size="md" />
+			<div class="flex justify-end mb-1">
+				<Toggle
+					size="xs"
+					checked={embedMode}
+					on:change={(e) => (embedMode = e.detail)}
+					options={{ left: 'URL', right: 'Embed' }}
+				/>
+			</div>
+			<ClipboardPanel
+				content={embedMode ? toEmbedSnippet(secretUrlHref) : secretUrlHref}
+				size="md"
+			/>
 		{:else}<Loader2 class="animate-spin" />
 		{/if}
 		<div class="text-xs text-secondary mt-1">
-			Share this url directly or embed it using an iframe (if requiring login, top-level domain of
-			embedding app must be the same as the one of Windmill)
+			{#if embedMode}
+				Paste this iframe snippet into another app.
+				{#if rawApp}
+					The <code>wm_coep</code> flag <Tooltip
+						>Sets the cross-origin isolation headers (COEP) so the app can be embedded inside
+						another Windmill app or any cross-origin-isolated page. Without it the browser blocks
+						the iframe.</Tooltip
+					> lets it load inside a cross-origin-isolated page.
+				{/if}
+				(if requiring login, top-level domain of embedding app must be the same as the one of Windmill)
+			{:else}
+				Share this url directly, or switch to <b>Embed</b> to get an iframe snippet.
+			{/if}
 		</div>
 
 		<div class="mt-4">
@@ -305,7 +344,10 @@
 				<div class="text-secondary text-sm flex items-center gap-1 mt-2 w-full justify-between">
 					<div>Custom public URL</div>
 				</div>
-				<ClipboardPanel content={fullCustomUrl} size="md" />
+				<ClipboardPanel
+					content={embedMode ? toEmbedSnippet(fullCustomUrl) : fullCustomUrl}
+					size="md"
+				/>
 
 				<div class="text-red-600 dark:text-red-400 text-2xs mt-1.5"
 					>{dirtyCustomPath ? customPathError : ''}
diff --git a/frontend/src/lib/components/apps/editor/PublicApp.svelte b/frontend/src/lib/components/apps/editor/PublicApp.svelte
index 48c3d5578d..fef6ba8fa3 100644
--- a/frontend/src/lib/components/apps/editor/PublicApp.svelte
+++ b/frontend/src/lib/components/apps/editor/PublicApp.svelte
@@ -145,7 +145,7 @@
 						name: $userStore?.name,
 						groups: $userStore?.groups,
 						username: $userStore?.username,
-						query: urlParamsToObject(page.url.searchParams),
+						query: urlParamsToObject(page.url.searchParams, { stripReserved: true }),
 						hash: page.url.hash.substring(1)
 					}}
 					workspace={effectiveWorkspace}
diff --git a/frontend/src/lib/components/apps/types.ts b/frontend/src/lib/components/apps/types.ts
index 2fe6536aa8..64b08d621e 100644
--- a/frontend/src/lib/components/apps/types.ts
+++ b/frontend/src/lib/components/apps/types.ts
@@ -164,6 +164,8 @@ export interface AppEditorProps {
 	gotoFn?: (path: string, opt?: Record<string, any> | undefined) => void
 	unsavedConfirmationModal?: import('svelte').Snippet<[any]>
 	onSavedNewAppPath?: (path: string) => void
+	/** Override breadcrumb-picker navigation. Defaults to goto(editPathFor(item)). */
+	onNavigate?: (item: import('$lib/components/workspacePicker').WorkspaceItem) => void
 	/**
 	 * Backend revs at the load that produced `app`. Used as the seed
 	 * `UserDraft` meta on the first local autosave: until the handle has
diff --git a/frontend/src/lib/components/common/EditableInput.svelte b/frontend/src/lib/components/common/EditableInput.svelte
index e772247c0a..e85625c58f 100644
--- a/frontend/src/lib/components/common/EditableInput.svelte
+++ b/frontend/src/lib/components/common/EditableInput.svelte
@@ -78,6 +78,15 @@ this component just proposes new values.
 		})
 	}
 
+	// External trigger (e.g. from a Melt dropdown menu item). Melt's focus trap
+	// stays active for a brief window after the menu closes — focusing our
+	// input during that window causes checkFocusIn to slam focus back out, which
+	// fires onblur=save and instantly closes the edit. A 50ms defer is enough
+	// for Melt's trap to release.
+	export function edit() {
+		setTimeout(startEditing, 50)
+	}
+
 	function save() {
 		// Re-entry guard: Enter calls `save()` and sets `editing = false`,
 		// which unmounts the `<input>` and synchronously fires its `blur`
diff --git a/frontend/src/lib/components/common/drawer/DrawerContent.svelte b/frontend/src/lib/components/common/drawer/DrawerContent.svelte
index ad89c2c725..6b76873c49 100644
--- a/frontend/src/lib/components/common/drawer/DrawerContent.svelte
+++ b/frontend/src/lib/components/common/drawer/DrawerContent.svelte
@@ -22,6 +22,8 @@
 		id?: string | undefined
 		actions?: import('svelte').Snippet
 		titleExtra?: import('svelte').Snippet
+		/** Rendered fixed below the header, above the scrollable content. */
+		banner?: import('svelte').Snippet
 		children?: import('svelte').Snippet
 	}
 
@@ -40,6 +42,7 @@
 		id,
 		actions,
 		titleExtra,
+		banner,
 		children
 	}: Props = $props()
 
@@ -83,6 +86,10 @@
 		{/if}
 	</div>
 
+	{#if banner}
+		{@render banner()}
+	{/if}
+
 	<div
 		class={classNames(
 			noPadding ? '' : 'p-4',
diff --git a/frontend/src/lib/components/copilot/autocomplete/request.ts b/frontend/src/lib/components/copilot/autocomplete/request.ts
index ef29ba9a19..cc3987ebe5 100644
--- a/frontend/src/lib/components/copilot/autocomplete/request.ts
+++ b/frontend/src/lib/components/copilot/autocomplete/request.ts
@@ -30,9 +30,9 @@ export async function autocompleteRequest(
 		throw new Error('No code completion model selected')
 	}
 
-	// Only add context lines for Mistral (native FIM) - other providers use chat completion
+	// Only add context lines for native FIM providers - other providers use chat completion
 	// too much context degrades significantly the quality of the completion
-	if (providerModel.provider === 'mistral') {
+	if (providerModel.provider === 'mistral' || providerModel.provider === 'deepseek') {
 		let commentSymbol = getCommentSymbol(context.scriptLang)
 		let contextLines = comment(
 			commentSymbol,
diff --git a/frontend/src/lib/components/copilot/chat/AIChat.svelte b/frontend/src/lib/components/copilot/chat/AIChat.svelte
index 07ccd1efb1..c6366113c9 100644
--- a/frontend/src/lib/components/copilot/chat/AIChat.svelte
+++ b/frontend/src/lib/components/copilot/chat/AIChat.svelte
@@ -3,30 +3,61 @@
 	import { untrack } from 'svelte'
 	import { type ScriptLang } from '$lib/gen'
 	import { dbSchemas, userStore, workspaceStore } from '$lib/stores'
-	import { aiChatManager, AIMode } from './AIChatManager.svelte'
+	import { AIMode } from './AIChatManager.svelte'
+	import { getAiChatManager } from './aiChatManagerContext'
+
+	const aiChatManager = getAiChatManager()
 	import { base } from '$lib/base'
 	import HideButton from '$lib/components/apps/editor/settingsPanel/HideButton.svelte'
 	import { SUPPORTED_CHAT_SCRIPT_LANGUAGES } from './script/core'
 	import { copilotInfo, copilotSessionModel } from '$lib/aiStore'
 
+	let {
+		hideHeader = false,
+		hideModeSelector = false,
+		forceDisabled = false,
+		forceDisabledMessage = '',
+		wideLayout = false,
+		emptyHint,
+		inputPreface
+	}: {
+		hideHeader?: boolean
+		hideModeSelector?: boolean
+		// External "you can't type here" override. Used by sessions when
+		// the session's committed workspace was deleted/archived so the
+		// chat is effectively read-only until the user moves or discards
+		// the session. Wins over the internal disabled derivation.
+		forceDisabled?: boolean
+		forceDisabledMessage?: string
+		// Forwarded to AIChatDisplay. When true, the messages / input
+		// columns are centered in a max-w-3xl px-8 box. Sessions opt
+		// in; the narrow global-chat panel leaves it off.
+		wideLayout?: boolean
+		emptyHint?: import('svelte').Snippet
+		inputPreface?: import('svelte').Snippet
+	} = $props()
+
 	const isAdmin = $derived($userStore?.is_admin || $userStore?.is_super_admin)
 	const hasCopilot = $derived($copilotInfo.enabled)
 	const disabled = $derived(
-		!hasCopilot ||
+		forceDisabled ||
+			!hasCopilot ||
 			(aiChatManager.mode === AIMode.SCRIPT &&
 				aiChatManager.scriptEditorOptions?.lang &&
 				!SUPPORTED_CHAT_SCRIPT_LANGUAGES.includes(aiChatManager.scriptEditorOptions.lang))
 	)
 	const disabledMessage = $derived(
-		!hasCopilot
-			? isAdmin
-				? `Enable Windmill AI in your [workspace settings](${base}/workspace_settings?tab=ai) to use this chat`
-				: 'Ask an admin to enable Windmill AI in this workspace to use this chat'
-			: aiChatManager.mode === AIMode.SCRIPT &&
-				  aiChatManager.scriptEditorOptions?.lang &&
-				  !SUPPORTED_CHAT_SCRIPT_LANGUAGES.includes(aiChatManager.scriptEditorOptions.lang)
-				? `Windmill AI does not support the ${aiChatManager.scriptEditorOptions.lang} language yet.`
-				: ''
+		forceDisabled
+			? forceDisabledMessage
+			: !hasCopilot
+				? isAdmin
+					? `Enable Windmill AI in your [workspace settings](${base}/workspace_settings?tab=ai) to use this chat`
+					: 'Ask an admin to enable Windmill AI in this workspace to use this chat'
+				: aiChatManager.mode === AIMode.SCRIPT &&
+					  aiChatManager.scriptEditorOptions?.lang &&
+					  !SUPPORTED_CHAT_SCRIPT_LANGUAGES.includes(aiChatManager.scriptEditorOptions.lang)
+					? `Windmill AI does not support the ${aiChatManager.scriptEditorOptions.lang} language yet.`
+					: ''
 	)
 
 	const suggestions = [
@@ -53,6 +84,10 @@
 		aiChatManager.sendRequest(options)
 	}
 
+	export function focusInput() {
+		aiChatDisplay?.focusInput()
+	}
+
 	const historyManager = aiChatManager.historyManager
 
 	let aiChatDisplay: AIChatDisplay | undefined = $state(undefined)
@@ -129,4 +164,9 @@
 	{disabled}
 	{disabledMessage}
 	{suggestions}
+	{hideHeader}
+	{hideModeSelector}
+	{wideLayout}
+	{emptyHint}
+	{inputPreface}
 ></AIChatDisplay>
diff --git a/frontend/src/lib/components/copilot/chat/AIChatDisplay.svelte b/frontend/src/lib/components/copilot/chat/AIChatDisplay.svelte
index bb97d61ee5..1252b999d7 100644
--- a/frontend/src/lib/components/copilot/chat/AIChatDisplay.svelte
+++ b/frontend/src/lib/components/copilot/chat/AIChatDisplay.svelte
@@ -23,7 +23,7 @@
 	import { fade } from 'svelte/transition'
 	import Popover from '$lib/components/meltComponents/Popover.svelte'
 	import DropdownV2 from '$lib/components/DropdownV2.svelte'
-	import { type DisplayMessage } from './shared'
+	import { isActiveUserQuestion, type DisplayMessage } from './shared'
 	import type { ContextElement } from './context'
 	import ChatQuickActions from './ChatQuickActions.svelte'
 	import ProviderModelSelector from './ProviderModelSelector.svelte'
@@ -271,18 +271,15 @@
 		const last = messages[messages.length - 1]
 		if (!last || last.role !== 'tool') return false
 		if (last.needsConfirmation && last.isLoading) return true
-		if (
-			last.userQuestion &&
-			last.isLoading &&
-			!last.error &&
-			!last.userQuestion.selectedChoice &&
-			!last.userQuestion.canceled
-		) {
-			return true
-		}
+		if (isActiveUserQuestion(last)) return true
 		return false
 	})
 
+	// While the AI is waiting on an answer to an askUserQuestion, the only valid
+	// input is one of the choices (or the custom answer) in the question card —
+	// so disable the main chat input until the question is answered or canceled.
+	const hasActiveUserQuestion = $derived(isActiveUserQuestion(messages[messages.length - 1]))
+
 	// Get app context for display when in APP mode
 	const appContext = $derived.by((): SelectedContext | undefined => {
 		if (aiChatManager.mode !== AIMode.APP || !aiChatManager.appAiChatHelpers) {
@@ -510,7 +507,7 @@
 				bind:this={aiChatInput}
 				bind:selectedContext
 				{availableContext}
-				{disabled}
+				disabled={disabled || hasActiveUserQuestion}
 				isFirstMessage={messages.length === 0}
 			/>
 			<div
diff --git a/frontend/src/lib/components/copilot/chat/AIChatManager.svelte.ts b/frontend/src/lib/components/copilot/chat/AIChatManager.svelte.ts
index 79bf64ffb7..a23a8da905 100644
--- a/frontend/src/lib/components/copilot/chat/AIChatManager.svelte.ts
+++ b/frontend/src/lib/components/copilot/chat/AIChatManager.svelte.ts
@@ -61,7 +61,12 @@ import { runChatLoop } from './chatLoop'
 import type { ReviewChangesOpts } from './monaco-adapter'
 import { getCurrentModel, tryGetCurrentModel, getCombinedCustomPrompt } from '$lib/aiStore'
 import type { WorkspaceMutationTarget } from './workspaceTools'
-import { globalTools, prepareGlobalSystemMessage, prepareGlobalUserMessage } from './global/core'
+import {
+	globalToolsFor,
+	prepareGlobalSystemMessage,
+	prepareGlobalUserMessage,
+	type GlobalToolHelpers
+} from './global/core'
 import { isGlobalAiEnabled } from './global/gate'
 
 // If the estimated token usage is greater than the model context window - the threshold, we delete the oldest message
@@ -208,13 +213,26 @@ export class AIChatManager {
 	private userQuestionCallbacks = new Map<string, (choice: string | undefined) => void>()
 	private appDatatablesRefreshTimeout: ReturnType<typeof setTimeout> | undefined = undefined
 
+	disabledModes: Partial<Record<AIMode, boolean>> = $state({})
+	// Set by AI sessions. Enables the session-only preview tools (open_preview /
+	// get_preview_status) and their system-prompt guidance in GLOBAL mode; the
+	// global side-panel chat leaves it false so those tools aren't offered.
+	isSessionChat = false
+	// The session this manager belongs to (session chats only). Carried into the
+	// tool `helpers` in GLOBAL mode so the preview/deploy tools dispatch to THIS
+	// session rather than the UI-active one — keeps backgrounded sessions isolated.
+	sessionId: string | undefined = undefined
+
 	allowedModes: Record<AIMode, boolean> = $derived({
-		script: this.flowAiChatHelpers === undefined && this.scriptEditorOptions !== undefined,
-		flow: this.flowAiChatHelpers !== undefined,
-		app: this.appAiChatHelpers !== undefined,
-		navigator: true,
-		ask: true,
-		API: true,
+		script:
+			this.flowAiChatHelpers === undefined &&
+			this.scriptEditorOptions !== undefined &&
+			!this.disabledModes.script,
+		flow: this.flowAiChatHelpers !== undefined && !this.disabledModes.flow,
+		app: this.appAiChatHelpers !== undefined && !this.disabledModes.app,
+		navigator: !this.disabledModes.navigator,
+		ask: !this.disabledModes.ask,
+		API: !this.disabledModes.API,
 		// Dev-only gate. See `./global/gate.ts` for how to enable.
 		global: isAIModeVisible(AIMode.GLOBAL)
 	})
@@ -495,9 +513,15 @@ export class AIChatManager {
 			this.helpers = {}
 		} else if (mode === AIMode.GLOBAL) {
 			const customPrompt = getCombinedCustomPrompt(mode)
-			this.systemMessage = prepareGlobalSystemMessage(customPrompt)
-			this.tools = [...globalTools]
-			this.helpers = {}
+			this.systemMessage = prepareGlobalSystemMessage(customPrompt, {
+				previewTools: this.isSessionChat
+			})
+			this.tools = globalToolsFor({ sessionPreview: this.isSessionChat })
+			this.helpers = {
+				...(this.isSessionChat ? { sessionId: this.sessionId } : {}),
+				testActiveFlow: async (args?: Record<string, any>) =>
+					this.flowAiChatHelpers?.testFlow(args)
+			} satisfies GlobalToolHelpers
 		} else if (mode === AIMode.APP) {
 			const customPrompt = getCombinedCustomPrompt(mode)
 			this.systemMessage = prepareAppSystemMessage(customPrompt)
@@ -681,7 +705,11 @@ export class AIChatManager {
 					} else if (this.mode === AIMode.NAVIGATOR) {
 						return prepareNavigatorUserMessage(pendingPrompt)
 					} else if (this.mode === AIMode.GLOBAL) {
-						return prepareGlobalUserMessage(pendingPrompt, this.contextManager.getSelectedContext())
+						return prepareGlobalUserMessage(
+							pendingPrompt,
+							this.contextManager.getSelectedContext(),
+							{ workspace: get(workspaceStore) }
+						)
 					}
 					return undefined
 				},
@@ -791,6 +819,12 @@ export class AIChatManager {
 		}
 	}
 
+	// Optional pre-flight hook called once per send, after validation but
+	// before any UI state mutates or backend calls go out. Sessions use
+	// this to commit/materialise the workspace (creating a staged fork via
+	// the API) so the first message targets the correct workspace.
+	beforeSend?: () => Promise<void> | void
+
 	sendRequest = async (
 		options: {
 			removeDiff?: boolean
@@ -815,6 +849,24 @@ export class AIChatManager {
 		if (!this.instructions.trim()) {
 			return
 		}
+		if (this.beforeSend) {
+			try {
+				await this.beforeSend()
+			} catch (e) {
+				// beforeSend commits the session's workspace before the first
+				// message hits the backend. If it throws, sending anyway would
+				// silently target the wrong workspace (typically the parent), so
+				// abort and tell the user — their message text stays in the input.
+				console.error('AIChatManager beforeSend hook failed', e)
+				sendUserToast(
+					`Could not prepare the session before sending: ${
+						e instanceof Error ? e.message : String(e)
+					}. Your message was not sent — please try again.`,
+					true
+				)
+				return
+			}
+		}
 		try {
 			const oldSelectedContext = this.contextManager?.getSelectedContext() ?? []
 			if (this.mode === AIMode.SCRIPT || this.mode === AIMode.FLOW) {
@@ -898,7 +950,9 @@ export class AIChatManager {
 					userMessage = prepareApiUserMessage(oldInstructions)
 					break
 				case AIMode.GLOBAL:
-					userMessage = prepareGlobalUserMessage(oldInstructions, oldSelectedContext)
+					userMessage = prepareGlobalUserMessage(oldInstructions, oldSelectedContext, {
+						workspace: get(workspaceStore)
+					})
 					break
 				case AIMode.APP:
 					userMessage = prepareAppUserMessage(
diff --git a/frontend/src/lib/components/copilot/chat/AIChatManager.test.ts b/frontend/src/lib/components/copilot/chat/AIChatManager.test.ts
index 35ebbc257d..b1c77df84d 100644
--- a/frontend/src/lib/components/copilot/chat/AIChatManager.test.ts
+++ b/frontend/src/lib/components/copilot/chat/AIChatManager.test.ts
@@ -16,7 +16,13 @@ vi.mock('$lib/gen', () => ({
 }))
 
 vi.mock('$lib/stores', () => ({
-	workspaceStore: { subscribe: () => () => undefined }
+	workspaceStore: { subscribe: () => () => undefined },
+	userStore: {
+		subscribe: (run: (value: { username: string }) => void) => {
+			run({ username: 'admin' })
+			return () => undefined
+		}
+	}
 }))
 
 vi.mock('$lib/toast', () => ({
@@ -55,10 +61,12 @@ vi.mock('esm-env', async (importOriginal) => ({
 
 function createFlowHelpers({
 	hasPendingChanges,
-	acceptAllModuleActions
+	acceptAllModuleActions,
+	testFlow = vi.fn()
 }: {
 	hasPendingChanges: () => boolean
 	acceptAllModuleActions: () => void
+	testFlow?: FlowAIChatHelpers['testFlow']
 }): FlowAIChatHelpers {
 	return {
 		getFlowAndSelectedId: vi.fn(),
@@ -74,7 +82,7 @@ function createFlowHelpers({
 		rejectAllModuleActions: vi.fn(),
 		hasPendingChanges,
 		selectStep: vi.fn(),
-		testFlow: vi.fn(),
+		testFlow,
 		getLintErrors: vi.fn()
 	} as unknown as FlowAIChatHelpers
 }
@@ -162,6 +170,27 @@ describe('AIChatManager autonomy mode', () => {
 
 		expect(applied).toBe(true)
 	})
+
+	it('does not pass the AI session id as a flow test conversation id in global mode', async () => {
+		const manager = new AIChatManager()
+		const testFlow = vi.fn(async () => 'job-flow-preview')
+
+		manager.isSessionChat = true
+		manager.sessionId = 'htc1xouxd96dcyo6ruqo39'
+		manager.setFlowHelpers(
+			createFlowHelpers({
+				hasPendingChanges: () => false,
+				acceptAllModuleActions: vi.fn(),
+				testFlow
+			})
+		)
+
+		manager.changeMode(AIMode.GLOBAL)
+		const jobId = await manager.helpers.testActiveFlow({ name: 'Ada' })
+
+		expect(jobId).toBe('job-flow-preview')
+		expect(testFlow).toHaveBeenCalledWith({ name: 'Ada' })
+	})
 })
 
 describe('AIChatManager persisted autonomy default', () => {
diff --git a/frontend/src/lib/components/copilot/chat/AiChatLayout.svelte b/frontend/src/lib/components/copilot/chat/AiChatLayout.svelte
index 27adb56ef3..2ab480a706 100644
--- a/frontend/src/lib/components/copilot/chat/AiChatLayout.svelte
+++ b/frontend/src/lib/components/copilot/chat/AiChatLayout.svelte
@@ -76,7 +76,7 @@
 								onClick={() => onMenuOpen?.()}
 								startIcon={{ icon: Menu }}
 								iconOnly
-							></Button>
+							/>
 						</div>
 						<div class="flex-1 min-h-0">
 							{@render children?.()}
@@ -96,5 +96,13 @@
 		{/if}
 	</Splitpanes>
 {:else}
-	{@render children?.()}
+	<div
+		class={classNames(
+			'flex-1 min-h-0 flex flex-col',
+			noBorder || $userStore?.operator || isMobile ? '' : isCollapsed ? 'pl-12' : 'pl-40',
+			'transition-all ease-in-out duration-200'
+		)}
+	>
+		{@render children?.()}
+	</div>
 {/if}
diff --git a/frontend/src/lib/components/copilot/chat/AskUserQuestionDisplay.svelte b/frontend/src/lib/components/copilot/chat/AskUserQuestionDisplay.svelte
index e59ed4b513..7a7a7014ea 100644
--- a/frontend/src/lib/components/copilot/chat/AskUserQuestionDisplay.svelte
+++ b/frontend/src/lib/components/copilot/chat/AskUserQuestionDisplay.svelte
@@ -1,11 +1,18 @@
 <script lang="ts">
 	import { onMount, tick } from 'svelte'
-	import { CircleHelp } from 'lucide-svelte'
+	import { CircleHelp, ArrowUp } from 'lucide-svelte'
 	import Button from '$lib/components/common/button/Button.svelte'
 	import TextInput from '$lib/components/text_input/TextInput.svelte'
-	import { aiChatManager } from './AIChatManager.svelte'
+	import { getAiChatManager } from './aiChatManagerContext'
 	import type { UserQuestionDisplay } from './shared'
 
+	// Sessions inject a per-pane `AIChatManager` via context; outside of
+	// sessions getAiChatManager falls back to the global singleton. Without
+	// this, answers clicked inside a session would dispatch to the singleton's
+	// pending callbacks map (which doesn't have the session manager's question
+	// callback), and the AI loop would stall.
+	const aiChatManager = getAiChatManager()
+
 	interface Props {
 		toolCallId: string
 		userQuestion: UserQuestionDisplay
@@ -14,21 +21,31 @@
 	let { toolCallId, userQuestion }: Props = $props()
 
 	let choiceButtons = $state<(HTMLButtonElement | undefined)[]>([])
+	let customAnswerInput = $state<TextInput | undefined>()
 	let customAnswer = $state('')
 	let canSubmitCustomAnswer = $derived(customAnswer.trim().length > 0)
 
-	onMount(() => {
-		if (userQuestion.choices.length === 0) {
-			return
-		}
+	// The custom-answer input is the last stop in the roving cursor, after all
+	// choices, so arrow navigation can reach it from the keyboard.
+	const customAnswerIndex = $derived(userQuestion.choices.length)
+	const itemCount = $derived(userQuestion.choices.length + 1)
+	// The item currently under the keyboard cursor. Mirrored onto the matching
+	// choice's `selected` prop so the highlight comes from the Button itself.
+	let activeIndex = $state(0)
 
+	onMount(() => {
 		void tick().then(() => {
-			focusChoice(0)
+			focusIndex(0)
 		})
 	})
 
-	function focusChoice(index: number) {
-		choiceButtons[index]?.focus()
+	function focusIndex(index: number) {
+		activeIndex = index
+		if (index === customAnswerIndex) {
+			customAnswerInput?.focus()
+		} else {
+			choiceButtons[index]?.focus()
+		}
 	}
 
 	function selectChoice(choice: string) {
@@ -48,14 +65,14 @@
 		if (event.key === 'ArrowDown' || event.key === 'ArrowRight') {
 			event.preventDefault()
 			event.stopPropagation()
-			focusChoice((index + 1) % userQuestion.choices.length)
+			focusIndex((index + 1) % itemCount)
 			return
 		}
 
 		if (event.key === 'ArrowUp' || event.key === 'ArrowLeft') {
 			event.preventDefault()
 			event.stopPropagation()
-			focusChoice((index - 1 + userQuestion.choices.length) % userQuestion.choices.length)
+			focusIndex((index - 1 + itemCount) % itemCount)
 			return
 		}
 
@@ -66,24 +83,68 @@
 		}
 	}
 
+	// Clicking the card's empty area must pull focus to the active item; otherwise
+	// focus stays on the chat's scroll container and arrow keys scroll the
+	// conversation instead of moving the selection. Wired as an action rather than
+	// a declarative on:click so the non-interactive card needs no keyboard handler,
+	// and on `click` rather than `pointerdown` so click-dragging to select text
+	// still works.
+	function focusActiveOnBackgroundClick(node: HTMLElement) {
+		function onClick(event: MouseEvent) {
+			const interactive = (event.target as HTMLElement | null)?.closest(
+				'button, input, textarea, a, [contenteditable]'
+			)
+			// A control inside the card (a choice, the answer input, the send button)
+			// manages its own focus — leave it alone. `closest` can also match the
+			// message-row button the chat wraps every message in, which is an ancestor
+			// of the card, so only bail out when the match is actually inside the card.
+			if (interactive && node.contains(interactive)) {
+				return
+			}
+			event.stopPropagation()
+			focusIndex(activeIndex)
+		}
+		node.addEventListener('click', onClick)
+		return {
+			destroy() {
+				node.removeEventListener('click', onClick)
+			}
+		}
+	}
+
 	function handleCustomAnswerKeydown(event: KeyboardEvent) {
-		if (event.key !== 'Enter') {
+		// Only ArrowUp/ArrowDown roam out of the input — Left/Right stay free for
+		// moving the text caret within the answer.
+		if (event.key === 'ArrowUp') {
+			event.preventDefault()
+			event.stopPropagation()
+			focusIndex((customAnswerIndex - 1 + itemCount) % itemCount)
 			return
 		}
 
-		event.preventDefault()
-		event.stopPropagation()
-		submitCustomAnswer()
+		if (event.key === 'ArrowDown') {
+			event.preventDefault()
+			event.stopPropagation()
+			focusIndex((customAnswerIndex + 1) % itemCount)
+			return
+		}
+
+		if (event.key === 'Enter') {
+			event.preventDefault()
+			event.stopPropagation()
+			submitCustomAnswer()
+		}
 	}
 </script>
 
 <div
-	class="rounded-md border border-gray-200 bg-surface p-3 text-sm dark:border-gray-700"
+	class="rounded-md border border-border-light bg-surface p-3"
 	data-chat-keyboard-scope="ask-user-question"
+	use:focusActiveOnBackgroundClick
 >
 	<div class="flex items-start gap-2">
-		<CircleHelp class="mt-0.5 h-4 w-4 shrink-0 text-blue-500" />
-		<p class="min-w-0 flex-1 whitespace-pre-wrap text-xs font-medium text-primary"
+		<CircleHelp class="mt-0.5 h-4 w-4 shrink-0 text-accent" />
+		<p class="min-w-0 flex-1 whitespace-pre-wrap text-xs font-semibold text-emphasis"
 			>{userQuestion.question}</p
 		>
 	</div>
@@ -93,37 +154,40 @@
 			<Button
 				variant="default"
 				unifiedSize="sm"
+				selected={activeIndex === index}
 				bind:element={choiceButtons[index]}
 				onClick={() => selectChoice(choice)}
 				onkeydown={(event) => handleChoiceKeydown(event, choice, index)}
-				btnClasses="!h-auto min-h-[40px] !items-start !justify-start !px-3 !py-2 !text-left !whitespace-normal"
+				onfocus={() => (activeIndex = index)}
+				btnClasses="h-auto min-h-7 justify-start whitespace-normal py-1.5 text-left focus-visible:!ring-0 focus-visible:!outline-none"
 			>
-				<span class="flex min-w-0 flex-col items-start gap-0.5">
-					<span class="max-w-full break-words text-2xs font-medium">{choice}</span>
-				</span>
+				<span class="break-words">{choice}</span>
 			</Button>
 		{/each}
 
 		<div class="flex min-w-0 gap-2 pt-1">
 			<TextInput
+				bind:this={customAnswerInput}
 				bind:value={customAnswer}
 				class="min-w-0 flex-1"
 				size="sm"
 				inputProps={{
 					'aria-label': 'Custom answer',
 					placeholder: 'Custom answer',
-					onkeydown: handleCustomAnswerKeydown
+					onkeydown: handleCustomAnswerKeydown,
+					onfocus: () => (activeIndex = customAnswerIndex)
 				}}
 			/>
 			<Button
-				variant="default"
+				variant="subtle"
 				unifiedSize="sm"
+				iconOnly
+				title="Send"
+				startIcon={{ icon: ArrowUp }}
 				disabled={!canSubmitCustomAnswer}
 				onClick={submitCustomAnswer}
 				btnClasses="shrink-0"
-			>
-				Send
-			</Button>
+			/>
 		</div>
 	</div>
 </div>
diff --git a/frontend/src/lib/components/copilot/chat/ChatMode.svelte b/frontend/src/lib/components/copilot/chat/ChatMode.svelte
index 5a40c49e36..89b714b80f 100644
--- a/frontend/src/lib/components/copilot/chat/ChatMode.svelte
+++ b/frontend/src/lib/components/copilot/chat/ChatMode.svelte
@@ -2,7 +2,10 @@
 	import { ChevronDown } from 'lucide-svelte'
 	import DropdownV2 from '$lib/components/DropdownV2.svelte'
 	import Button from '$lib/components/common/button/Button.svelte'
-	import { aiChatManager, AIMode } from './AIChatManager.svelte'
+	import { AIMode } from './AIChatManager.svelte'
+	import { getAiChatManager } from './aiChatManagerContext'
+
+	const aiChatManager = getAiChatManager()
 
 	const modeLabel = (mode: AIMode) => mode.charAt(0).toUpperCase() + mode.slice(1) + ' mode'
 
diff --git a/frontend/src/lib/components/copilot/chat/DatatableCreationPolicy.svelte b/frontend/src/lib/components/copilot/chat/DatatableCreationPolicy.svelte
index 4df548192a..65abb0e1c5 100644
--- a/frontend/src/lib/components/copilot/chat/DatatableCreationPolicy.svelte
+++ b/frontend/src/lib/components/copilot/chat/DatatableCreationPolicy.svelte
@@ -1,7 +1,9 @@
 <script lang="ts">
 	import { AlertTriangle } from 'lucide-svelte'
 	import Toggle from '$lib/components/Toggle.svelte'
-	import { aiChatManager } from './AIChatManager.svelte'
+	import { getAiChatManager } from './aiChatManagerContext'
+
+	const aiChatManager = getAiChatManager()
 	import DefaultDatabaseSelector from '$lib/components/raw_apps/DefaultDatabaseSelector.svelte'
 	import { workspaceStore } from '$lib/stores'
 	import { createDatatablesResource } from '$lib/components/raw_apps/datatableUtils.svelte'
@@ -69,4 +71,4 @@
 			description="Set the default datatable and schema for new tables. When table creation is enabled, AI can create tables here if needed."
 		/>
 	{/if}
-</div>
\ No newline at end of file
+</div>
diff --git a/frontend/src/lib/components/copilot/chat/HistoryManager.svelte.ts b/frontend/src/lib/components/copilot/chat/HistoryManager.svelte.ts
index 87be590dcc..d07f6943bd 100644
--- a/frontend/src/lib/components/copilot/chat/HistoryManager.svelte.ts
+++ b/frontend/src/lib/components/copilot/chat/HistoryManager.svelte.ts
@@ -11,6 +11,7 @@ interface ChatSchema extends IDBSchema {
 			displayMessages: DisplayMessage[]
 			title: string
 			lastModified: number
+			sessionId?: string
 		}
 	}
 }
@@ -26,14 +27,21 @@ export default class HistoryManager {
 			title: string
 			id: string
 			lastModified: number
+			sessionId?: string
 		}
 	> = $state({})
 
 	private currentChatId: string = $state(createLongHash())
 
+	// When set, this manager is bound to a session: only chats tagged with this id
+	// are surfaced and new chats are saved with this id. When undefined (singleton),
+	// session-tagged chats are excluded from history.
+	private sessionId: string | undefined = $state(undefined)
+
 	private pastChats = $derived(
 		Object.values(this.savedChats)
 			.filter((c) => c.id !== this.currentChatId)
+			.filter((c) => (this.sessionId ? c.sessionId === this.sessionId : !c.sessionId))
 			.sort((a, b) => b.lastModified - a.lastModified)
 	)
 
@@ -69,10 +77,33 @@ export default class HistoryManager {
 		return this.currentChatId
 	}
 
+	setCurrentChatId(id: string) {
+		this.currentChatId = id
+	}
+
+	setSessionId(id: string | undefined) {
+		this.sessionId = id
+	}
+
+	async tagChatWithSession(chatId: string, sessionId: string) {
+		const existing = this.savedChats[chatId]
+		if (!existing || existing.sessionId === sessionId) return
+		const snapshot = $state.snapshot(existing)
+		const updated = { ...snapshot, sessionId }
+		this.savedChats = { ...this.savedChats, [chatId]: updated }
+		if (this.indexDB) {
+			await this.indexDB.put('chats', updated)
+		}
+	}
+
 	getPastChats() {
 		return this.pastChats
 	}
 
+	getAllSavedChats() {
+		return Object.values(this.savedChats)
+	}
+
 	async saveChat(displayMessages: DisplayMessage[], messages: ChatCompletionMessageParam[]) {
 		if (displayMessages.length > 0) {
 			// we don't want to save the snapshot in the history
@@ -84,7 +115,8 @@ export default class HistoryManager {
 				})),
 				title: displayMessages[0].content.slice(0, 50),
 				id: this.currentChatId,
-				lastModified: Date.now()
+				lastModified: Date.now(),
+				...(this.sessionId ? { sessionId: this.sessionId } : {})
 			}
 			this.savedChats = {
 				...this.savedChats,
diff --git a/frontend/src/lib/components/copilot/chat/ToolExecutionDisplay.svelte b/frontend/src/lib/components/copilot/chat/ToolExecutionDisplay.svelte
index f6e5950ac6..b6d01c6b38 100644
--- a/frontend/src/lib/components/copilot/chat/ToolExecutionDisplay.svelte
+++ b/frontend/src/lib/components/copilot/chat/ToolExecutionDisplay.svelte
@@ -1,8 +1,10 @@
 <script lang="ts">
 	import { Loader2, ChevronDown, ChevronRight, XCircle, Play } from 'lucide-svelte'
 	import { Button } from '$lib/components/common'
-	import { aiChatManager } from './AIChatManager.svelte'
-	import type { ToolDisplayMessage } from './shared'
+	import { getAiChatManager } from './aiChatManagerContext'
+
+	const aiChatManager = getAiChatManager()
+	import { isActiveUserQuestion, type ToolDisplayMessage } from './shared'
 	import { twMerge } from 'tailwind-merge'
 	import ToolContentDisplay from './ToolContentDisplay.svelte'
 	import ToolMessageActions from './ToolMessageActions.svelte'
@@ -39,26 +41,19 @@
 	)
 
 	const activeUserQuestion = $derived(
-		message.userQuestion &&
-			message.isLoading &&
-			!message.error &&
-			!message.userQuestion.selectedChoice &&
-			!message.userQuestion.canceled
-			? message.userQuestion
-			: undefined
+		isActiveUserQuestion(message) ? message.userQuestion : undefined
 	)
 </script>
 
 {#if activeUserQuestion}
 	<AskUserQuestionDisplay toolCallId={message.tool_call_id} userQuestion={activeUserQuestion} />
 {:else}
-	<div
-		class="bg-surface border border-gray-200 dark:border-gray-700 rounded-md overflow-hidden font-mono text-xs"
-	>
+	<div class="bg-surface border border-border-light rounded-md overflow-hidden font-mono text-xs">
 		<!-- Collapsible Header -->
 		<button
 			class={twMerge(
-				'w-full p-2 bg-surface-secondary hover:bg-surface-hover transition-colors flex items-center justify-between text-left border-b border-gray-200 dark:border-gray-700',
+				'w-full p-2 bg-surface-secondary/30 hover:bg-surface-hover transition-colors flex items-center justify-between text-left',
+				isExpanded ? 'border-b border-border-light' : '',
 				message.needsConfirmation ? 'opacity-80' : ''
 			)}
 			onclick={() => (isExpanded = !isExpanded)}
@@ -107,7 +102,7 @@
 					<div
 						class={twMerge(
 							'mt-3 pt-3 flex flex-row items-center justify-end gap-2',
-							hasParameters ? 'border-t border-gray-200 dark:border-gray-700' : ''
+							hasParameters ? 'border-t border-border-light' : ''
 						)}
 					>
 						<Button
diff --git a/frontend/src/lib/components/copilot/chat/datatableTools.test.ts b/frontend/src/lib/components/copilot/chat/datatableTools.test.ts
new file mode 100644
index 0000000000..ff933eae20
--- /dev/null
+++ b/frontend/src/lib/components/copilot/chat/datatableTools.test.ts
@@ -0,0 +1,200 @@
+import { beforeEach, describe, expect, it, vi } from 'vitest'
+
+const { listMock, schemaMock, runSqlMock } = vi.hoisted(() => ({
+	listMock: vi.fn(),
+	schemaMock: vi.fn(),
+	runSqlMock: vi.fn()
+}))
+
+vi.mock('./shared', () => ({
+	createToolDef: (_schema: unknown, name: string, description: string) => ({
+		type: 'function',
+		function: { name, description, parameters: {} }
+	})
+}))
+
+vi.mock('$lib/gen', () => ({
+	WorkspaceService: {
+		listDataTableTables: listMock,
+		getDataTableTableSchema: schemaMock
+	}
+}))
+
+vi.mock('$lib/components/jobs/utils', () => ({
+	runScriptAndPollResult: runSqlMock
+}))
+
+import { getDatatableTools } from './datatableTools'
+
+function createToolCallbacks() {
+	return {
+		setToolStatus: vi.fn(),
+		removeToolStatus: vi.fn()
+	}
+}
+
+function getTool(name: string) {
+	const tool = getDatatableTools().find((entry) => entry.def.function.name === name)
+	if (!tool) {
+		throw new Error(`${name} tool not found`)
+	}
+	return tool
+}
+
+function run(name: string, args: Record<string, unknown> = {}) {
+	return getTool(name).fn({
+		args,
+		workspace: 'test-workspace',
+		helpers: {},
+		toolCallbacks: createToolCallbacks(),
+		toolId: `tool-${name}`
+	})
+}
+
+beforeEach(() => {
+	listMock.mockReset()
+	schemaMock.mockReset()
+	runSqlMock.mockReset()
+})
+
+describe('list_datatables', () => {
+	it('aggregates the table count across schemas and returns metadata verbatim', async () => {
+		const metadata = [
+			{ datatable_name: 'main', schemas: { public: ['users', 'orders'], analytics: ['events'] } },
+			{ datatable_name: 'warehouse', schemas: { public: ['facts'] } }
+		]
+		listMock.mockResolvedValue(metadata)
+
+		const tool = getTool('list_datatables')
+		const callbacks = createToolCallbacks()
+		const result = await tool.fn({
+			args: {},
+			workspace: 'test-workspace',
+			helpers: {},
+			toolCallbacks: callbacks,
+			toolId: 'tool-list'
+		})
+
+		expect(listMock).toHaveBeenCalledWith({ workspace: 'test-workspace' })
+		expect(JSON.parse(result)).toEqual(metadata)
+		// 2 + 1 + 1 = 4 tables across 2 datatables
+		expect(callbacks.setToolStatus).toHaveBeenCalledWith('tool-list', {
+			content: 'Listed 2 datatable(s) with 4 table(s)'
+		})
+	})
+
+	it('explains that configuring a datatable is a blocking prerequisite when none exist', async () => {
+		listMock.mockResolvedValue([])
+		const result = await run('list_datatables')
+		expect(result).toContain('No datatables are configured in this workspace')
+		expect(result).toContain('Workspace settings → Data Tables')
+		expect(result).toContain('blocked')
+		expect(result).toContain('Do not call exec_datatable_sql')
+	})
+
+	it('surfaces backend errors as a readable message', async () => {
+		listMock.mockRejectedValue(new Error('boom'))
+		const result = await run('list_datatables')
+		expect(result).toContain('Error listing datatables: boom')
+	})
+})
+
+describe('get_datatable_table_schema', () => {
+	it('returns the columns for one table', async () => {
+		schemaMock.mockResolvedValue({
+			datatable_name: 'main',
+			schema_name: 'public',
+			table_name: 'users',
+			columns: { id: 'int4', email: 'text' }
+		})
+
+		const result = await run('get_datatable_table_schema', {
+			datatable_name: 'main',
+			schema_name: 'public',
+			table_name: 'users'
+		})
+
+		expect(schemaMock).toHaveBeenCalledWith({
+			workspace: 'test-workspace',
+			datatableName: 'main',
+			schemaName: 'public',
+			tableName: 'users'
+		})
+		expect(JSON.parse(result)).toEqual({
+			datatable_name: 'main',
+			schema_name: 'public',
+			table_name: 'users',
+			columns: { id: 'int4', email: 'text' }
+		})
+	})
+})
+
+describe('exec_datatable_sql', () => {
+	it('requires confirmation', () => {
+		expect(getTool('exec_datatable_sql').requiresConfirmation).toBe(true)
+	})
+
+	it('returns all rows when the result is at or below the cap', async () => {
+		const rows = Array.from({ length: 100 }, (_, i) => ({ id: i }))
+		runSqlMock.mockResolvedValue(rows)
+
+		const result = await run('exec_datatable_sql', {
+			datatable_name: 'main',
+			sql: 'SELECT * FROM t'
+		})
+
+		const parsed = JSON.parse(result)
+		expect(parsed.success).toBe(true)
+		expect(parsed.rowCount).toBe(100)
+		expect(parsed.result).toHaveLength(100)
+		expect(parsed.note).toBeUndefined()
+		expect(runSqlMock).toHaveBeenCalledWith({
+			workspace: 'test-workspace',
+			requestBody: {
+				language: 'postgresql',
+				content: 'SELECT * FROM t',
+				args: { database: 'datatable://main' }
+			}
+		})
+	})
+
+	it('truncates results above the cap and reports the full count', async () => {
+		const rows = Array.from({ length: 150 }, (_, i) => ({ id: i }))
+		runSqlMock.mockResolvedValue(rows)
+
+		const parsed = JSON.parse(await run('exec_datatable_sql', { datatable_name: 'main', sql: 'SELECT 1' }))
+		expect(parsed.rowCount).toBe(150)
+		expect(parsed.result).toHaveLength(100)
+		expect(parsed.note).toBe('Showing first 100 of 150 rows')
+	})
+
+	it('treats a non-array result (e.g. DDL) as zero rows', async () => {
+		runSqlMock.mockResolvedValue(undefined)
+		const parsed = JSON.parse(
+			await run('exec_datatable_sql', {
+				datatable_name: 'main',
+				sql: 'CREATE TABLE t (id serial primary key)'
+			})
+		)
+		expect(parsed).toEqual({ success: true, rowCount: 0, result: [] })
+	})
+
+	it('returns a failure object when the SQL job errors', async () => {
+		runSqlMock.mockRejectedValue(new Error('syntax error'))
+		const parsed = JSON.parse(await run('exec_datatable_sql', { datatable_name: 'main', sql: 'SLECT' }))
+		expect(parsed).toEqual({ success: false, error: 'syntax error' })
+	})
+
+	it('turns the backend "datatable not found" error into an actionable, blocking message', async () => {
+		runSqlMock.mockRejectedValue(new Error('Internal: datatable main not found @workspaces.rs:565:20'))
+		const parsed = JSON.parse(
+			await run('exec_datatable_sql', { datatable_name: 'main', sql: 'CREATE TABLE t (id int)' })
+		)
+		expect(parsed.success).toBe(false)
+		expect(parsed.error).toContain('not configured in this workspace')
+		expect(parsed.error).toContain('Workspace settings → Data Tables')
+		expect(parsed.error).toContain('do not retry')
+		// The raw internal error is not surfaced to the model.
+		expect(parsed.error).not.toContain('workspaces.rs')
+	})
+})
diff --git a/frontend/src/lib/components/copilot/chat/datatableTools.ts b/frontend/src/lib/components/copilot/chat/datatableTools.ts
new file mode 100644
index 0000000000..cebde9e97e
--- /dev/null
+++ b/frontend/src/lib/components/copilot/chat/datatableTools.ts
@@ -0,0 +1,278 @@
+import { z } from 'zod'
+import { WorkspaceService } from '$lib/gen'
+import type { DataTableTables } from '$lib/gen/types.gen'
+import { runScriptAndPollResult } from '$lib/components/jobs/utils'
+import { createToolDef, type Tool } from './shared'
+
+/**
+ * Workspace-scoped datatable tools, with no app whitelist and no creation policy.
+ *
+ * Datatables are workspace-level managed PostgreSQL databases. The backend
+ * endpoints used here (`list_datatable_tables`, `get_datatable_table_schema`)
+ * and SQL execution (`datatable://<name>`) are gated only by workspace
+ * membership, so these tools need no app context and operate directly on the
+ * workspace. This is the unrestricted counterpart to the app-mode datatable
+ * tools in `app/core.ts`, which additionally filter by the app's whitelist.
+ */
+
+// ============= Utility =============
+
+/** Memoize a factory function - the factory is only called once, on first access */
+const memo = <T>(factory: () => T): (() => T) => {
+	let cached: T | undefined
+	return () => (cached ??= factory())
+}
+
+// ============= Pure workspace-scoped operations =============
+
+/** List all datatables configured in the workspace, with their schema/table names. */
+export async function listDatatables(workspace: string): Promise<DataTableTables[]> {
+	return await WorkspaceService.listDataTableTables({ workspace })
+}
+
+/** Get the columns (column_name -> compact_type) of one datatable table. */
+export async function getDatatableColumns(
+	workspace: string,
+	datatableName: string,
+	schemaName: string,
+	tableName: string
+): Promise<Record<string, string>> {
+	const schema = await WorkspaceService.getDataTableTableSchema({
+		workspace,
+		datatableName,
+		schemaName,
+		tableName
+	})
+	return schema.columns
+}
+
+/**
+ * Execute an arbitrary SQL statement against a datatable.
+ * Supports SELECT/INSERT/UPDATE/DELETE as well as DDL (CREATE/ALTER/DROP).
+ * Returns rows for SELECT-like queries, an empty array otherwise.
+ */
+export async function execDatatableSql(
+	workspace: string,
+	datatableName: string,
+	sql: string
+): Promise<
+	{ success: true; result: Record<string, any>[] } | { success: false; error: string }
+> {
+	try {
+		const result = await runScriptAndPollResult({
+			workspace,
+			requestBody: {
+				language: 'postgresql',
+				content: sql,
+				args: { database: `datatable://${datatableName}` }
+			}
+		})
+		if (Array.isArray(result)) {
+			return { success: true, result }
+		}
+		return { success: true, result: [] }
+	} catch (e) {
+		return { success: false, error: e instanceof Error ? e.message : String(e) }
+	}
+}
+
+// ============= Error helpers =============
+
+/**
+ * The backend returns "datatable <name> not found" when no datatable with that
+ * name is configured in the workspace settings. That is a hard, blocking
+ * prerequisite (not a transient failure), so we surface an explicit, actionable
+ * message instead of the raw internal error.
+ */
+function isDatatableNotConfiguredError(error: string | null | undefined): boolean {
+	return typeof error === 'string' && /datatable\s+\S+\s+not found/i.test(error)
+}
+
+function datatableNotConfiguredMessage(datatableName: string): string {
+	return (
+		`Datatable "${datatableName}" is not configured in this workspace, so this operation cannot run. ` +
+		`Datatables are not created by SQL — they must be set up first by the user in the workspace settings ` +
+		`(Workspace settings → Data Tables) before any table can be queried or created. ` +
+		`This is a required, blocking prerequisite: do not retry on this or another name. ` +
+		`Tell the user they need to configure a datatable (e.g. named "${datatableName}") in their workspace settings, then try again.`
+	)
+}
+
+const NO_DATATABLES_CONFIGURED_MESSAGE =
+	'No datatables are configured in this workspace. Datatable operations (querying data, creating or altering tables) are blocked until a datatable exists. ' +
+	'Datatables are not created by SQL — the user must set one up in the workspace settings (Workspace settings → Data Tables) first. ' +
+	'Do not call exec_datatable_sql or assume a "main" datatable exists; instead tell the user this is a required prerequisite and ask them to configure a datatable in their workspace settings.'
+
+// ============= Tool definitions =============
+
+const getListDatatablesSchema = memo(() => z.object({}))
+const getListDatatablesToolDef = memo(() =>
+	createToolDef(
+		getListDatatablesSchema(),
+		'list_datatables',
+		'List datatables configured in the workspace with schema and table names only. Does not include column definitions. Use this directly for table-list or available-tables summaries. Only call get_datatable_table_schema when column names/types are required.'
+	)
+)
+
+const getGetDatatableTableSchemaSchema = memo(() =>
+	z.object({
+		datatable_name: z.string().describe('The datatable name to inspect, e.g. "main".'),
+		schema_name: z.string().describe('The schema name, e.g. "public".'),
+		table_name: z.string().describe('The table name to inspect.')
+	})
+)
+const getGetDatatableTableSchemaToolDef = memo(() =>
+	createToolDef(
+		getGetDatatableTableSchemaSchema(),
+		'get_datatable_table_schema',
+		'Get column definitions for one datatable table. Do not call this for row counts or table-list summaries; list_datatables is enough for those.'
+	)
+)
+
+const getExecDatatableSqlSchema = memo(() =>
+	z.object({
+		datatable_name: z
+			.string()
+			.describe(
+				'The name of the datatable to query (e.g., "main"). Must be one of the datatables configured in the workspace.'
+			),
+		sql: z
+			.string()
+			.describe(
+				'The SQL query to execute. Supports SELECT, INSERT, UPDATE, DELETE, CREATE TABLE, ALTER TABLE, DROP TABLE, etc. For SELECT queries, results are returned as an array of objects. A newly created table will appear in list_datatables automatically.'
+			)
+	})
+)
+const getExecDatatableSqlToolDef = memo(() =>
+	createToolDef(
+		getExecDatatableSqlSchema(),
+		'exec_datatable_sql',
+		'Execute a SQL query on a workspace datatable. Use this to explore data, test queries, create/alter tables, or make changes. Creating a table is a normal CREATE TABLE statement — no registration step is needed.'
+	)
+)
+
+/** Maximum rows returned to the model for a SELECT query. */
+const MAX_ROWS = 100
+
+/**
+ * The unrestricted workspace datatable tools, for registration in global mode.
+ * Helper-free: each tool reads `workspace` directly from the tool call params.
+ */
+export function getDatatableTools(): Tool<{}>[] {
+	return [
+		{
+			def: getListDatatablesToolDef(),
+			fn: async ({ workspace, toolId, toolCallbacks }) => {
+				toolCallbacks.setToolStatus(toolId, { content: 'Listing datatables...' })
+				try {
+					const metadata = await listDatatables(workspace)
+					if (metadata.length === 0) {
+						toolCallbacks.setToolStatus(toolId, {
+							content: 'No datatables configured — set one up in workspace settings'
+						})
+						return NO_DATATABLES_CONFIGURED_MESSAGE
+					}
+					const totalTables = metadata.reduce(
+						(acc, datatable) =>
+							acc +
+							Object.values(datatable.schemas).reduce((sum, tables) => sum + tables.length, 0),
+						0
+					)
+					toolCallbacks.setToolStatus(toolId, {
+						content: `Listed ${metadata.length} datatable(s) with ${totalTables} table(s)`
+					})
+					return JSON.stringify(metadata, null, 2)
+				} catch (e) {
+					const errorMsg = `Error listing datatables: ${e instanceof Error ? e.message : String(e)}`
+					toolCallbacks.setToolStatus(toolId, { content: errorMsg, error: errorMsg })
+					return errorMsg
+				}
+			}
+		},
+		{
+			def: getGetDatatableTableSchemaToolDef(),
+			fn: async ({ args, workspace, toolId, toolCallbacks }) => {
+				const parsedArgs = getGetDatatableTableSchemaSchema().parse(args)
+				toolCallbacks.setToolStatus(toolId, {
+					content: `Getting schema for ${parsedArgs.datatable_name}.${parsedArgs.schema_name}.${parsedArgs.table_name}...`
+				})
+				try {
+					const columns = await getDatatableColumns(
+						workspace,
+						parsedArgs.datatable_name,
+						parsedArgs.schema_name,
+						parsedArgs.table_name
+					)
+					toolCallbacks.setToolStatus(toolId, {
+						content: `Retrieved schema for ${parsedArgs.schema_name}.${parsedArgs.table_name}`
+					})
+					return JSON.stringify(
+						{
+							datatable_name: parsedArgs.datatable_name,
+							schema_name: parsedArgs.schema_name,
+							table_name: parsedArgs.table_name,
+							columns
+						},
+						null,
+						2
+					)
+				} catch (e) {
+					const raw = e instanceof Error ? e.message : String(e)
+					const errorMsg = isDatatableNotConfiguredError(raw)
+						? datatableNotConfiguredMessage(parsedArgs.datatable_name)
+						: `Error getting table schema: ${raw}`
+					toolCallbacks.setToolStatus(toolId, { content: errorMsg, error: errorMsg })
+					return errorMsg
+				}
+			}
+		},
+		{
+			def: getExecDatatableSqlToolDef(),
+			requiresConfirmation: true,
+			confirmationMessage: 'Execute SQL on datatable',
+			showDetails: true,
+			fn: async ({ args, workspace, toolId, toolCallbacks }) => {
+				const parsedArgs = getExecDatatableSqlSchema().parse(args)
+				toolCallbacks.setToolStatus(toolId, {
+					content: `Executing SQL on "${parsedArgs.datatable_name}"...`
+				})
+				try {
+					const result = await execDatatableSql(workspace, parsedArgs.datatable_name, parsedArgs.sql)
+					if (result.success) {
+						// Successful runs always carry a `result` array (empty for DDL/DML), so
+						// SELECT rows and zero-row statements share one reporting path.
+						const rowCount = result.result.length
+						toolCallbacks.setToolStatus(toolId, { content: `Query returned ${rowCount} row(s)` })
+						if (rowCount > MAX_ROWS) {
+							return JSON.stringify(
+								{
+									success: true,
+									rowCount,
+									result: result.result.slice(0, MAX_ROWS),
+									note: `Showing first ${MAX_ROWS} of ${rowCount} rows`
+								},
+								null,
+								2
+							)
+						}
+						return JSON.stringify({ success: true, rowCount, result: result.result }, null, 2)
+					} else {
+						const raw = result.error || 'Unknown error'
+						const errorMsg = isDatatableNotConfiguredError(raw)
+							? datatableNotConfiguredMessage(parsedArgs.datatable_name)
+							: raw
+						toolCallbacks.setToolStatus(toolId, { content: `Error: ${errorMsg}`, error: errorMsg })
+						return JSON.stringify({ success: false, error: errorMsg })
+					}
+				} catch (e) {
+					const raw = e instanceof Error ? e.message : String(e)
+					const errorMsg = isDatatableNotConfiguredError(raw)
+						? datatableNotConfiguredMessage(parsedArgs.datatable_name)
+						: raw
+					toolCallbacks.setToolStatus(toolId, { content: `Error: ${errorMsg}`, error: errorMsg })
+					return JSON.stringify({ success: false, error: errorMsg })
+				}
+			}
+		}
+	]
+}
diff --git a/frontend/src/lib/components/copilot/chat/flow/FlowAIChat.svelte b/frontend/src/lib/components/copilot/chat/flow/FlowAIChat.svelte
index 9a12a04548..97af435dda 100644
--- a/frontend/src/lib/components/copilot/chat/flow/FlowAIChat.svelte
+++ b/frontend/src/lib/components/copilot/chat/flow/FlowAIChat.svelte
@@ -6,7 +6,9 @@
 	import type { FlowAIChatHelpers } from './core'
 	import { createInlineScriptSession } from './inlineScriptsUtils'
 	import { loadSchemaFromModule } from '$lib/components/flows/flowInfers'
-	import { aiChatManager } from '../AIChatManager.svelte'
+	import { getAiChatManager } from '../aiChatManagerContext'
+
+	const aiChatManager = getAiChatManager()
 	import { refreshStateStore } from '$lib/svelte5Utils.svelte'
 	import type { FlowCopilotContext } from '../../flow'
 	import type { ScriptLintResult } from '../shared'
diff --git a/frontend/src/lib/components/copilot/chat/flow/core.ts b/frontend/src/lib/components/copilot/chat/flow/core.ts
index 9de82b4132..77fc955d56 100644
--- a/frontend/src/lib/components/copilot/chat/flow/core.ts
+++ b/frontend/src/lib/components/copilot/chat/flow/core.ts
@@ -1,10 +1,4 @@
-import {
-	ScriptService,
-	type FlowModule,
-	type InputTransform,
-	type RawScript,
-	JobService
-} from '$lib/gen'
+import { type FlowModule, type InputTransform, type RawScript } from '$lib/gen'
 import type {
 	ChatCompletionSystemMessageParam,
 	ChatCompletionUserMessageParam
@@ -30,7 +24,8 @@ import {
 	formatScriptLintResult,
 	type ScriptLintResult,
 	createSearchWorkspaceTool,
-	createGetRunnableDetailsTool
+	createGetRunnableDetailsTool,
+	executeFlowStepTestRun
 } from '../shared'
 import { createWorkspaceMutationTools } from '../workspaceTools'
 import type { ContextElement } from '../context'
@@ -183,7 +178,7 @@ const setFlowJsonToolSchema = z.object({
 		.optional()
 		.nullable()
 		.describe(
-			'JSON string containing the optional array of semantic flow groups (summary, note, autocollapse, start_id, end_id, color). Pass null to clear groups.'
+			'JSON string containing the optional array of semantic flow groups. Each group has summary, note, autocollapse, start_id, end_id, color. color MUST be one of: yellow, blue, green, purple, pink, orange, red, cyan, lime, gray — never hex codes or other strings. Pass null to clear groups.'
 		)
 })
 
@@ -442,99 +437,14 @@ export const flowTools: Tool<FlowAIChatHelpers>[] = [
 			const stepId = args.stepId
 			const stepArgs = args.args || {}
 
-			// Find the step in the flow (includes preprocessor/failure modules)
-			let targetModule: FlowModule | undefined = findModuleInFlow(flow.value, stepId) ?? undefined
-
-			if (!targetModule) {
-				toolCallbacks.setToolStatus(toolId, {
-					content: `Step '${stepId}' not found in flow`,
-					error: `Step with id '${stepId}' does not exist in the current flow`
-				})
-				throw new Error(
-					`Step with id '${stepId}' not found in flow. Available steps: ${(flow.value.modules ?? []).map((m: FlowModule) => m.id).join(', ')}`
-				)
-			}
-
-			const module = targetModule
-			const moduleValue = module.value
-
-			if (moduleValue.type === 'rawscript') {
-				// Test raw script step
-
-				return executeTestRun({
-					jobStarter: () =>
-						JobService.runScriptPreview({
-							workspace: workspace,
-							requestBody: {
-								content: moduleValue.content ?? '',
-								language: moduleValue.language,
-								args:
-									module.id === SPECIAL_MODULE_IDS.PREPROCESSOR
-										? { _ENTRYPOINT_OVERRIDE: 'preprocessor', ...stepArgs }
-										: stepArgs
-							}
-						}),
-					workspace,
-					toolCallbacks,
-					toolId,
-					startMessage: `Starting test run of step '${stepId}'...`,
-					contextName: 'script'
-				})
-			} else if (moduleValue.type === 'script') {
-				// Test script step - need to get the script content
-				const script = moduleValue.hash
-					? await ScriptService.getScriptByHash({
-							workspace: workspace,
-							hash: moduleValue.hash
-						})
-					: await ScriptService.getScriptByPath({
-							workspace: workspace,
-							path: moduleValue.path
-						})
-
-				return executeTestRun({
-					jobStarter: () =>
-						JobService.runScriptPreview({
-							workspace: workspace,
-							requestBody: {
-								content: script.content,
-								language: script.language,
-								args:
-									module.id === SPECIAL_MODULE_IDS.PREPROCESSOR
-										? { _ENTRYPOINT_OVERRIDE: 'preprocessor', ...stepArgs }
-										: stepArgs
-							}
-						}),
-					workspace,
-					toolCallbacks,
-					toolId,
-					startMessage: `Starting test run of script step '${stepId}'...`,
-					contextName: 'script'
-				})
-			} else if (moduleValue.type === 'flow') {
-				// Test flow step
-				return executeTestRun({
-					jobStarter: () =>
-						JobService.runFlowByPath({
-							workspace: workspace,
-							path: moduleValue.path,
-							requestBody: stepArgs
-						}),
-					workspace,
-					toolCallbacks,
-					toolId,
-					startMessage: `Starting test run of flow step '${stepId}'...`,
-					contextName: 'flow'
-				})
-			} else {
-				toolCallbacks.setToolStatus(toolId, {
-					content: `Step type '${moduleValue.type}' not supported for testing`,
-					error: `Cannot test step of type '${moduleValue.type}'`
-				})
-				throw new Error(
-					`Cannot test step of type '${moduleValue.type}'. Supported types: rawscript, script, flow`
-				)
-			}
+			return executeFlowStepTestRun({
+				flowValue: flow.value,
+				stepId,
+				args: stepArgs,
+				workspace,
+				toolCallbacks,
+				toolId
+			})
 		},
 		requiresConfirmation: true,
 		confirmationMessage: 'Run flow step test',
@@ -949,7 +859,7 @@ Use the \`set_flow_json\` tool to set the entire flow structure at once. Provide
 - \`schema\`: Flow input schema in JSON Schema format (optional)
 - \`preprocessor_module\`: Special module that runs before \`modules\` (optional, separate from \`modules\`)
 - \`failure_module\`: Special module that runs on failure (optional, separate from \`modules\`)
-- \`groups\`: Array of semantic groups for organizing modules in the editor (optional). Each group has \`summary\` (display name), \`note\` (markdown description shown below the group header — attached directly to the group, not a separate sticky note), \`autocollapse\`, \`start_id\`, \`end_id\`, and \`color\`. \`start_id\` and \`end_id\` must reference existing module IDs in the flow (not \`preprocessor\` or \`failure\`). Groups do not affect execution — they provide naming and collapsibility in the editor. Pass \`null\` to clear existing groups.
+- \`groups\`: Array of semantic groups for organizing modules in the editor (optional). Each group has \`summary\` (display name), \`note\` (markdown description shown below the group header — attached directly to the group, not a separate sticky note), \`autocollapse\`, \`start_id\`, \`end_id\`, and \`color\`. \`start_id\` and \`end_id\` must reference existing module IDs in the flow (not \`preprocessor\` or \`failure\`). \`color\` MUST be one of these exact names: \`yellow\`, \`blue\`, \`green\`, \`purple\`, \`pink\`, \`orange\`, \`red\`, \`cyan\`, \`lime\`, \`gray\` — do NOT use hex codes, CSS colors, or any other strings. Omit \`color\` entirely if no preference and the editor will assign one automatically. Groups do not affect execution — they provide naming and collapsibility in the editor. Pass \`null\` to clear existing groups.
 
 **Example - Simple flow:**
 \`\`\`javascript
diff --git a/frontend/src/lib/components/copilot/chat/flow/helperUtils.test.ts b/frontend/src/lib/components/copilot/chat/flow/helperUtils.test.ts
index f17abdd901..75749013a8 100644
--- a/frontend/src/lib/components/copilot/chat/flow/helperUtils.test.ts
+++ b/frontend/src/lib/components/copilot/chat/flow/helperUtils.test.ts
@@ -299,4 +299,23 @@ describe('validateFlowGroups', () => {
 		const result = validateFlowGroups([{ start_id: 'a', end_id: 'c', summary: 'G' }], moduleIds)
 		expect(result).toEqual([{ start_id: 'a', end_id: 'c', summary: 'G' }])
 	})
+
+	it('rejects an unknown color name', () => {
+		expect(() => validateFlowGroups([{ start_id: 'a', end_id: 'b', color: '#ff00aa' }])).toThrow(
+			/color must be one of/
+		)
+		expect(() => validateFlowGroups([{ start_id: 'a', end_id: 'b', color: 'magenta' }])).toThrow(
+			/color must be one of/
+		)
+	})
+
+	it('accepts a known color name', () => {
+		const result = validateFlowGroups([{ start_id: 'a', end_id: 'b', color: 'blue' }])
+		expect(result).toEqual([{ start_id: 'a', end_id: 'b', color: 'blue' }])
+	})
+
+	it('accepts a group with no color', () => {
+		const result = validateFlowGroups([{ start_id: 'a', end_id: 'b' }])
+		expect(result).toEqual([{ start_id: 'a', end_id: 'b' }])
+	})
 })
diff --git a/frontend/src/lib/components/copilot/chat/flow/helperUtils.ts b/frontend/src/lib/components/copilot/chat/flow/helperUtils.ts
index 45c7c7d5fe..f424490d24 100644
--- a/frontend/src/lib/components/copilot/chat/flow/helperUtils.ts
+++ b/frontend/src/lib/components/copilot/chat/flow/helperUtils.ts
@@ -1,8 +1,14 @@
 import type { FlowModule, FlowValue, OpenFlow, RawScript } from '$lib/gen'
 import { forEachFlowModule } from '$lib/components/flows/dfs'
 import { findModuleInFlow } from '$lib/components/flows/flowTree'
+import { NoteColor } from '$lib/components/graph/noteColors'
 import type { InlineScriptSession } from './inlineScriptsUtils'
 
+/** Allowed group color names — matches the NoteColor palette the group
+ * editor uses. Other strings would render with default-blue styling at best
+ * and break the color picker UI at worst. */
+const ALLOWED_GROUP_COLORS = new Set<string>(Object.values(NoteColor))
+
 type FlowLike = Pick<OpenFlow, 'value'> & {
 	schema?: Record<string, any>
 }
@@ -71,6 +77,13 @@ export function validateFlowGroups(
 				)
 			}
 		}
+		if (g.color !== undefined && g.color !== null) {
+			if (typeof g.color !== 'string' || !ALLOWED_GROUP_COLORS.has(g.color)) {
+				throw new Error(
+					`Invalid group at index ${index}: color must be one of ${[...ALLOWED_GROUP_COLORS].join(', ')}`
+				)
+			}
+		}
 		return g as unknown as FlowGroup
 	})
 }
diff --git a/frontend/src/lib/components/copilot/chat/global/core.test.ts b/frontend/src/lib/components/copilot/chat/global/core.test.ts
index 6a7a9c8a9c..c10efce9f6 100644
--- a/frontend/src/lib/components/copilot/chat/global/core.test.ts
+++ b/frontend/src/lib/components/copilot/chat/global/core.test.ts
@@ -1,4 +1,4 @@
-import { beforeEach, describe, expect, it, vi } from 'vitest'
+import { afterEach, beforeEach, describe, expect, it, vi } from 'vitest'
 
 vi.mock('monaco-editor', () => ({
 	editor: {},
@@ -45,11 +45,30 @@ vi.mock('$lib/gen', async () => {
 		ScriptService: wrapService(actual.ScriptService, {
 			existsScriptByPath: vi.fn(async () => false),
 			createScript: vi.fn(async () => 'created'),
+			getScriptByPath: vi.fn(async () => {
+				throw new Error('getScriptByPath mock not configured')
+			}),
+			getScriptByHash: vi.fn(async () => {
+				throw new Error('getScriptByHash mock not configured')
+			}),
 			getScriptByPathWithDraft: vi.fn(async () => {
 				throw new Error('getScriptByPathWithDraft mock not configured')
 			}),
+			queryHubScripts: vi.fn(async () => []),
+			getHubScriptContentByPath: vi.fn(async () => ''),
 			listScripts: vi.fn(async () => [])
 		}),
+		JobService: wrapService(actual.JobService, {
+			runScriptPreview: vi.fn(async () => 'job-script-preview'),
+			runFlowPreview: vi.fn(async () => 'job-flow-preview'),
+			runFlowByPath: vi.fn(async () => 'job-flow-by-path'),
+			getJob: vi.fn(async () => ({
+				type: 'CompletedJob',
+				success: true,
+				result: { ok: true },
+				logs: 'test logs'
+			}))
+		}),
 		FlowService: wrapService(actual.FlowService, {
 			existsFlowByPath: vi.fn(async () => false),
 			createFlow: vi.fn(async () => 'created'),
@@ -77,6 +96,8 @@ vi.mock('$lib/gen', async () => {
 		}),
 		AppService: wrapService(actual.AppService, {
 			existsApp: vi.fn(async () => false),
+			createAppRaw: vi.fn(async () => 'created'),
+			updateAppRaw: vi.fn(async () => 'updated'),
 			getAppByPathWithDraft: vi.fn(async () => {
 				throw new Error('getAppByPathWithDraft mock not configured')
 			}),
@@ -99,13 +120,30 @@ vi.mock('$lib/gen', async () => {
 	}
 })
 
-import { globalTools, prepareGlobalSystemMessage, prepareGlobalUserMessage } from './core'
+vi.mock('./rawAppBundlerBridge', () => ({
+	bundleRawAppDraft: vi.fn(async () => ({
+		js: 'bundled js',
+		css: 'bundled css'
+	}))
+}))
+
+import {
+	globalTools,
+	globalToolsFor,
+	prepareGlobalSystemMessage,
+	prepareGlobalUserMessage,
+	setDeployedInSessionHandler,
+	setGetPreviewStatusHandler,
+	setOpenPreviewHandler
+} from './core'
 import { UserDraft, __resetUserDraftForTesting } from '$lib/userDraft.svelte'
 import { clearGlobalDrafts } from './userDraftAdapter'
+import { bundleRawAppDraft } from './rawAppBundlerBridge'
 import {
 	AppService,
 	FlowService,
 	HttpTriggerService,
+	JobService,
 	ResourceService,
 	ScheduleService,
 	ScriptService,
@@ -131,12 +169,13 @@ function getGlobalTool(name: string): Tool<{}> {
 async function callGlobalTool(
 	name: string,
 	args: Record<string, unknown>,
-	callbacks: ToolCallbacks = toolCallbacks
+	callbacks: ToolCallbacks = toolCallbacks,
+	helpers: Record<string, unknown> = {}
 ): Promise<string> {
 	return getGlobalTool(name).fn({
 		args,
 		workspace: WORKSPACE,
-		helpers: {},
+		helpers,
 		toolCallbacks: callbacks,
 		toolId: `test-${name}`
 	})
@@ -151,6 +190,17 @@ function localStorageSnapshot(): string {
 	return values.join('\n')
 }
 
+async function withCompletedTestJob<T>(run: () => Promise<T>): Promise<T> {
+	vi.useFakeTimers()
+	try {
+		const promise = run()
+		await vi.advanceTimersByTimeAsync(1000)
+		return await promise
+	} finally {
+		vi.useRealTimers()
+	}
+}
+
 describe('global AI tools', () => {
 	beforeEach(() => {
 		__resetUserDraftForTesting()
@@ -159,6 +209,63 @@ describe('global AI tools', () => {
 		vi.clearAllMocks()
 	})
 
+	it('defaults the datatable instruction subject to the TypeScript SQL SDK', async () => {
+		const result = await callGlobalTool('get_instructions', { subject: 'datatable' })
+		expect(result).toContain('wmill.datatable(')
+		expect(result).toContain('TypeScript Datatable API')
+		expect(result).toContain('fetchOne')
+		// Defaults to TypeScript only — no Python noise.
+		expect(result).not.toContain('Python Datatable API')
+	})
+
+	it('returns only the requested language SDK for the datatable subject', async () => {
+		const ts = await callGlobalTool('get_instructions', { subject: 'datatable', language: 'bun' })
+		expect(ts).toContain('TypeScript Datatable API')
+		expect(ts).not.toContain('Python Datatable API')
+
+		const py = await callGlobalTool('get_instructions', {
+			subject: 'datatable',
+			language: 'python3'
+		})
+		expect(py).toContain('Python Datatable API')
+		expect(py).not.toContain('TypeScript Datatable API')
+	})
+
+	it('exposes hub search and path-aware test tools', () => {
+		const names = globalTools.map((tool) => tool.def.function.name)
+
+		expect(names).toContain('search_hub_scripts')
+		expect(names).toContain('test_run_script')
+		expect(names).toContain('test_run_flow')
+		expect(names).toContain('test_run_step')
+	})
+
+	it('searches hub scripts without fetching script contents', async () => {
+		vi.mocked(ScriptService.queryHubScripts).mockResolvedValueOnce([
+			{
+				version_id: 7,
+				app: 'slack',
+				summary: 'Send Message'
+			}
+		] as any)
+
+		const raw = await callGlobalTool('search_hub_scripts', {
+			query: 'slack message'
+		})
+
+		expect(ScriptService.queryHubScripts).toHaveBeenCalledWith({
+			text: 'slack message',
+			kind: 'script'
+		})
+		expect(ScriptService.getHubScriptContentByPath).not.toHaveBeenCalled()
+		expect(JSON.parse(raw)).toEqual([
+			{
+				path: 'hub/7/slack/send_message',
+				summary: 'Send Message'
+			}
+		])
+	})
+
 	it('redacts variable draft values when reading workspace items', async () => {
 		await callGlobalTool('write_variable', {
 			path: 'f/secrets/api_key',
@@ -1014,6 +1121,149 @@ describe('global AI tools', () => {
 		expect(UserDraft.get('raw_app', 'f/apps/report', { workspace: WORKSPACE })).toBeUndefined()
 	})
 
+	it('deploys a new raw app draft by bundling files and creating a raw app', async () => {
+		UserDraft.save(
+			'raw_app',
+			'f/apps/report',
+			{
+				summary: 'AI report',
+				files: {
+					'/index.tsx': 'console.log("app")',
+					'/package.json': '{"dependencies":{"react":"19.0.0"}}'
+				},
+				runnables: {},
+				data: { tables: [] }
+			},
+			{ workspace: WORKSPACE }
+		)
+
+		const raw = await callGlobalTool('deploy_workspace_item', {
+			type: 'app',
+			path: 'f/apps/report',
+			deployment_message: 'ship report'
+		})
+
+		expect(bundleRawAppDraft).toHaveBeenCalledWith(
+			expect.objectContaining({
+				workspace: WORKSPACE,
+				files: expect.objectContaining({
+					'/index.tsx': 'console.log("app")'
+				})
+			})
+		)
+		expect(AppService.createAppRaw).toHaveBeenCalledWith({
+			workspace: WORKSPACE,
+			formData: {
+				app: {
+					path: 'f/apps/report',
+					value: {
+						files: {
+							'/index.tsx': 'console.log("app")',
+							'/package.json': '{"dependencies":{"react":"19.0.0"}}'
+						},
+						runnables: {},
+						data: { tables: [] }
+					},
+					summary: 'AI report',
+					policy: expect.objectContaining({ execution_mode: 'publisher' }),
+					deployment_message: 'ship report',
+					custom_path: undefined
+				},
+				js: 'bundled js',
+				css: 'bundled css'
+			}
+		})
+		expect(AppService.updateAppRaw).not.toHaveBeenCalled()
+		expect(UserDraft.get('raw_app', 'f/apps/report', { workspace: WORKSPACE })).toBeUndefined()
+		expect(JSON.parse(raw)).toMatchObject({
+			success: true,
+			type: 'app',
+			path: 'f/apps/report'
+		})
+	})
+
+	it('deploys an existing raw app draft by bundling files and updating the raw app', async () => {
+		vi.mocked(AppService.existsApp).mockResolvedValueOnce(true)
+		UserDraft.save(
+			'raw_app',
+			'f/apps/report',
+			{
+				summary: 'Updated report',
+				files: { '/index.tsx': 'console.log("updated")' },
+				runnables: {},
+				data: { tables: ['orders'] },
+				policy: { execution_mode: 'anonymous' },
+				custom_path: 'kept-by-backend'
+			},
+			{ workspace: WORKSPACE }
+		)
+
+		await callGlobalTool('deploy_workspace_item', {
+			type: 'app',
+			path: 'f/apps/report'
+		})
+
+		expect(AppService.updateAppRaw).toHaveBeenCalledWith({
+			workspace: WORKSPACE,
+			path: 'f/apps/report',
+			formData: {
+				app: {
+					path: 'f/apps/report',
+					value: {
+						files: { '/index.tsx': 'console.log("updated")' },
+						runnables: {},
+						data: { tables: ['orders'] }
+					},
+					summary: 'Updated report',
+					policy: expect.objectContaining({ execution_mode: 'anonymous' }),
+					deployment_message: undefined
+				},
+				js: 'bundled js',
+				css: 'bundled css'
+			}
+		})
+		expect(AppService.createAppRaw).not.toHaveBeenCalled()
+		expect(UserDraft.get('raw_app', 'f/apps/report', { workspace: WORKSPACE })).toBeUndefined()
+	})
+
+	it('notifies the session preview (as raw_app) after deploying a raw app', async () => {
+		const onDeployed = vi.fn()
+		setDeployedInSessionHandler(onDeployed)
+		try {
+			UserDraft.save(
+				'raw_app',
+				'f/apps/report',
+				{
+					summary: 'AI report',
+					files: { '/index.tsx': 'console.log("app")' },
+					runnables: {},
+					data: { tables: [] }
+				},
+				{ workspace: WORKSPACE }
+			)
+
+			await callGlobalTool(
+				'deploy_workspace_item',
+				{ type: 'app', path: 'f/apps/report' },
+				toolCallbacks,
+				{
+					sessionId: 'sess-123'
+				}
+			)
+
+			// A raw app deploys under type 'app' but the preview addresses it as
+			// 'raw_app'; the calling session id is threaded through so the deploy
+			// reloads the issuing session's preview, not the UI-active one.
+			expect(onDeployed).toHaveBeenCalledWith({
+				sessionId: 'sess-123',
+				kind: 'raw_app',
+				path: 'f/apps/report'
+			})
+		} finally {
+			setDeployedInSessionHandler(undefined)
+		}
+	})
+
 	it('fills an empty rawscript module through set_flow_module_code', async () => {
 		await callGlobalTool('write_flow', {
 			path: 'f/flows/empty-module',
@@ -1039,7 +1289,7 @@ describe('global AI tools', () => {
 				module_id: 'empty_step',
 				code
 			})
-		).resolves.toContain('Updated local draft flow')
+		).resolves.toContain('Updated flow')
 
 		await expect(
 			callGlobalTool('read_flow_module_code', {
@@ -1104,6 +1354,368 @@ describe('global AI tools', () => {
 		expect(item.value.value).toBeUndefined()
 	})
 
+	it('test_run_script previews local draft script content by path', async () => {
+		const content = 'export async function main(name: string) {\n\treturn `hello ${name}`\n}'
+		await callGlobalTool('write_script', {
+			path: 'f/scripts/draft-test',
+			summary: 'Draft test script',
+			language: 'bun',
+			content
+		})
+
+		const result = await withCompletedTestJob(() =>
+			callGlobalTool('test_run_script', {
+				path: 'f/scripts/draft-test',
+				args: { name: 'Ada' }
+			})
+		)
+
+		expect(JobService.runScriptPreview).toHaveBeenCalledWith({
+			workspace: WORKSPACE,
+			requestBody: {
+				path: 'f/scripts/draft-test',
+				content,
+				args: { name: 'Ada' },
+				language: 'bun'
+			}
+		})
+		expect(ScriptService.getScriptByPath).not.toHaveBeenCalled()
+		expect(result).toContain('Result (SUCCESS)')
+		expect(result).toContain('test logs')
+	})
+
+	it('test_run_script previews deployed script content when no local draft exists', async () => {
+		vi.mocked(ScriptService.getScriptByPath).mockResolvedValueOnce({
+			path: 'f/scripts/deployed-test',
+			summary: 'Deployed test script',
+			content: 'def main(name):\n    return name',
+			language: 'python3'
+		} as any)
+
+		await withCompletedTestJob(() =>
+			callGlobalTool('test_run_script', {
+				path: 'f/scripts/deployed-test',
+				args: { name: 'Grace' }
+			})
+		)
+
+		expect(ScriptService.getScriptByPath).toHaveBeenCalledWith({
+			workspace: WORKSPACE,
+			path: 'f/scripts/deployed-test'
+		})
+		expect(JobService.runScriptPreview).toHaveBeenCalledWith({
+			workspace: WORKSPACE,
+			requestBody: {
+				path: 'f/scripts/deployed-test',
+				content: 'def main(name):\n    return name',
+				args: { name: 'Grace' },
+				language: 'python3'
+			}
+		})
+	})
+
+	it('test_run_flow previews local draft flow content by path', async () => {
+		const modules = [{ id: 'start', value: { type: 'identity' } }]
+		await callGlobalTool('write_flow', {
+			path: 'f/flows/draft-test',
+			summary: 'Draft test flow',
+			modules: JSON.stringify(modules)
+		})
+
+		await withCompletedTestJob(() =>
+			callGlobalTool('test_run_flow', {
+				path: 'f/flows/draft-test',
+				args: { name: 'Ada' }
+			})
+		)
+
+		expect(FlowService.getFlowByPath).not.toHaveBeenCalled()
+		expect(JobService.runFlowPreview).toHaveBeenCalledWith({
+			workspace: WORKSPACE,
+			requestBody: {
+				path: 'f/flows/draft-test',
+				value: { modules },
+				args: { name: 'Ada' }
+			}
+		})
+	})
+
+	it('test_run_flow previews deployed flow content when no local draft exists', async () => {
+		const modules = [{ id: 'deployed_start', value: { type: 'identity' } }]
+		vi.mocked(FlowService.getFlowByPath).mockResolvedValueOnce({
+			path: 'f/flows/deployed-test',
+			summary: 'Deployed test flow',
+			value: { modules },
+			schema: {}
+		} as any)
+
+		await withCompletedTestJob(() =>
+			callGlobalTool('test_run_flow', {
+				path: 'f/flows/deployed-test',
+				args: { name: 'Grace' }
+			})
+		)
+
+		expect(FlowService.getFlowByPath).toHaveBeenCalledWith({
+			workspace: WORKSPACE,
+			path: 'f/flows/deployed-test'
+		})
+		expect(JobService.runFlowPreview).toHaveBeenCalledWith({
+			workspace: WORKSPACE,
+			requestBody: {
+				path: 'f/flows/deployed-test',
+				value: { modules },
+				args: { name: 'Grace' }
+			}
+		})
+	})
+
+	it('test_run_flow uses the live flow editor test hook when the active editor matches the path', async () => {
+		UserDraft.save(
+			'flow',
+			'',
+			{
+				path: 'u/admin/live_flow',
+				summary: 'Live flow',
+				value: { modules: [{ id: 'live_step', value: { type: 'identity' } }] },
+				schema: {},
+				edited_by: '',
+				edited_at: '',
+				archived: false,
+				extra_perms: {}
+			},
+			{ workspace: WORKSPACE }
+		)
+		UserDraft.setLiveEditorDraft({
+			workspace: WORKSPACE,
+			itemKind: 'flow',
+			storagePath: '',
+			effectivePath: 'u/admin/live_flow'
+		})
+		const testActiveFlow = vi.fn(async () => 'job-live-flow')
+
+		const result = await withCompletedTestJob(() =>
+			callGlobalTool(
+				'test_run_flow',
+				{
+					path: 'u/admin/live_flow',
+					args: { name: 'Ada' }
+				},
+				toolCallbacks,
+				{ testActiveFlow }
+			)
+		)
+
+		expect(testActiveFlow).toHaveBeenCalledWith({ name: 'Ada' })
+		expect(FlowService.getFlowByPath).not.toHaveBeenCalled()
+		expect(JobService.runFlowPreview).not.toHaveBeenCalled()
+		expect(result).toContain('Result (SUCCESS)')
+	})
+
+	it('test_run_flow falls back to preview when the live flow editor test hook returns undefined', async () => {
+		UserDraft.save(
+			'flow',
+			'',
+			{
+				path: 'u/admin/live_flow_fallback',
+				summary: 'Live flow fallback',
+				value: { modules: [{ id: 'fallback_step', value: { type: 'identity' } }] },
+				schema: {},
+				edited_by: '',
+				edited_at: '',
+				archived: false,
+				extra_perms: {}
+			},
+			{ workspace: WORKSPACE }
+		)
+		UserDraft.setLiveEditorDraft({
+			workspace: WORKSPACE,
+			itemKind: 'flow',
+			storagePath: '',
+			effectivePath: 'u/admin/live_flow_fallback'
+		})
+		const testActiveFlow = vi.fn(async () => undefined)
+
+		await withCompletedTestJob(() =>
+			callGlobalTool(
+				'test_run_flow',
+				{
+					path: 'u/admin/live_flow_fallback',
+					args: { name: 'Ada' }
+				},
+				toolCallbacks,
+				{ testActiveFlow }
+			)
+		)
+
+		expect(testActiveFlow).toHaveBeenCalledWith({ name: 'Ada' })
+		expect(FlowService.getFlowByPath).not.toHaveBeenCalled()
+		expect(JobService.runFlowPreview).toHaveBeenCalledWith({
+			workspace: WORKSPACE,
+			requestBody: {
+				path: 'u/admin/live_flow_fallback',
+				value: { modules: [{ id: 'fallback_step', value: { type: 'identity' } }] },
+				args: { name: 'Ada' }
+			}
+		})
+	})
+
+	it('test_run_step previews rawscript steps from the local draft flow', async () => {
+		const content = 'export async function main(name: string) {\n\treturn name.toUpperCase()\n}'
+		await callGlobalTool('write_flow', {
+			path: 'f/flows/rawscript-step',
+			summary: 'Flow with rawscript',
+			modules: JSON.stringify([
+				{
+					id: 'format_name',
+					value: {
+						type: 'rawscript',
+						language: 'bun',
+						content,
+						input_transforms: {}
+					}
+				}
+			])
+		})
+
+		await withCompletedTestJob(() =>
+			callGlobalTool('test_run_step', {
+				path: 'f/flows/rawscript-step',
+				stepId: 'format_name',
+				args: { name: 'Ada' }
+			})
+		)
+
+		expect(JobService.runScriptPreview).toHaveBeenCalledWith({
+			workspace: WORKSPACE,
+			requestBody: {
+				content,
+				language: 'bun',
+				args: { name: 'Ada' }
+			}
+		})
+	})
+
+	it('test_run_step prefers local script drafts for script steps', async () => {
+		const content = 'export async function main(name: string) {\n\treturn `draft ${name}`\n}'
+		await callGlobalTool('write_script', {
+			path: 'f/scripts/step-script',
+			summary: 'Step script',
+			language: 'bun',
+			content
+		})
+		await callGlobalTool('write_flow', {
+			path: 'f/flows/script-step',
+			summary: 'Flow with script step',
+			modules: JSON.stringify([
+				{
+					id: 'call_script',
+					value: {
+						type: 'script',
+						path: 'f/scripts/step-script',
+						input_transforms: {}
+					}
+				}
+			])
+		})
+
+		await withCompletedTestJob(() =>
+			callGlobalTool('test_run_step', {
+				path: 'f/flows/script-step',
+				stepId: 'call_script',
+				args: { name: 'Ada' }
+			})
+		)
+
+		expect(ScriptService.getScriptByPath).not.toHaveBeenCalled()
+		expect(JobService.runScriptPreview).toHaveBeenCalledWith({
+			workspace: WORKSPACE,
+			requestBody: {
+				path: 'f/scripts/step-script',
+				content,
+				language: 'bun',
+				args: { name: 'Ada' }
+			}
+		})
+	})
+
+	it('test_run_step previews local draft subflows for flow steps', async () => {
+		const nestedModules = [{ id: 'nested_start', value: { type: 'identity' } }]
+		await callGlobalTool('write_flow', {
+			path: 'f/flows/nested-draft',
+			summary: 'Nested draft flow',
+			modules: JSON.stringify(nestedModules)
+		})
+		await callGlobalTool('write_flow', {
+			path: 'f/flows/parent-flow',
+			summary: 'Parent flow',
+			modules: JSON.stringify([
+				{
+					id: 'call_flow',
+					value: {
+						type: 'flow',
+						path: 'f/flows/nested-draft',
+						input_transforms: {}
+					}
+				}
+			])
+		})
+
+		await withCompletedTestJob(() =>
+			callGlobalTool('test_run_step', {
+				path: 'f/flows/parent-flow',
+				stepId: 'call_flow',
+				args: { name: 'Ada' }
+			})
+		)
+
+		expect(JobService.runFlowByPath).not.toHaveBeenCalled()
+		expect(JobService.runFlowPreview).toHaveBeenCalledWith({
+			workspace: WORKSPACE,
+			requestBody: {
+				path: 'f/flows/nested-draft',
+				value: { modules: nestedModules },
+				args: { name: 'Ada' }
+			}
+		})
+	})
+
+	it('test_run_step lists nested step ids when a step is not found', async () => {
+		await callGlobalTool('write_flow', {
+			path: 'f/flows/nested-step-error',
+			summary: 'Flow with nested step',
+			modules: JSON.stringify([
+				{
+					id: 'loop_step',
+					value: {
+						type: 'forloopflow',
+						iterator: { type: 'static', value: [1] },
+						skip_failures: false,
+						modules: [
+							{
+								id: 'nested_script_step',
+								value: {
+									type: 'rawscript',
+									language: 'bun',
+									content: 'export async function main() { return 1 }',
+									input_transforms: {}
+								}
+							}
+						]
+					}
+				}
+			])
+		})
+
+		await expect(
+			callGlobalTool('test_run_step', {
+				path: 'f/flows/nested-step-error',
+				stepId: 'missing_nested_step',
+				args: {}
+			})
+		).rejects.toThrow(/Available steps: loop_step, nested_script_step/)
+	})
+
 	it('asks the user a question and returns the selected answer', async () => {
 		const callbacks: ToolCallbacks = {
 			setToolStatus: vi.fn(),
@@ -1222,6 +1834,10 @@ describe('prepareGlobalSystemMessage', () => {
 		expect(content).toContain(
 			'Use discard_local_draft to remove an unsaved local draft, including the matching open editor draft'
 		)
+		expect(content).toContain(
+			'After creating or editing a script or flow draft, run test_run_script, test_run_flow, or test_run_step'
+		)
+		expect(content).toContain('If the user message includes an ACTIVE EDITOR section')
 		expect(content).not.toContain('AI draft')
 		expect(content).not.toContain('UserDraft')
 		expect(content).not.toContain('localStorage')
@@ -1241,9 +1857,86 @@ describe('prepareGlobalSystemMessage', () => {
 		expect(discard.requiresConfirmation).toBe(true)
 		expect(deleteItem.requiresConfirmation).toBe(true)
 	})
+
+	describe('get_preview_status', () => {
+		afterEach(() => {
+			setGetPreviewStatusHandler(undefined)
+			setOpenPreviewHandler(undefined)
+		})
+
+		it('takes no arguments', () => {
+			const tool = getGlobalTool('get_preview_status')
+			expect(tool.def.function.parameters).toMatchObject({
+				type: 'object',
+				properties: {},
+				required: []
+			})
+		})
+
+		it('returns the session-only error when no handler is registered', async () => {
+			setGetPreviewStatusHandler(undefined)
+			const result = await callGlobalTool('get_preview_status', {})
+			expect(result).toBe('Error: get_preview_status is only available inside an AI session.')
+		})
+
+		it('dispatches to the registered session handler', async () => {
+			setGetPreviewStatusHandler(() => 'The preview is currently open showing script "u/me/foo".')
+			const result = await callGlobalTool('get_preview_status', {})
+			expect(result).toBe('The preview is currently open showing script "u/me/foo".')
+		})
+	})
+})
+
+describe('session-only preview tools gating', () => {
+	const toolNames = (sessionPreview: boolean) =>
+		globalToolsFor({ sessionPreview }).map((t) => t.def.function.name)
+
+	it('excludes open_preview / get_preview_status outside a session', () => {
+		const names = toolNames(false)
+		expect(names).not.toContain('open_preview')
+		expect(names).not.toContain('get_preview_status')
+		// other tools are still present
+		expect(names).toContain('write_script')
+	})
+
+	it('includes open_preview / get_preview_status inside a session', () => {
+		const names = toolNames(true)
+		expect(names).toContain('open_preview')
+		expect(names).toContain('get_preview_status')
+		// session set is the full globalTools
+		expect(names.length).toBe(globalTools.length)
+	})
+
+	it('mentions open_preview in the system prompt only when preview tools are enabled', () => {
+		const off = prepareGlobalSystemMessage(undefined, { previewTools: false }).content as string
+		const on = prepareGlobalSystemMessage(undefined, { previewTools: true }).content as string
+		expect(off).not.toContain('open_preview')
+		expect(on).toContain('open_preview')
+	})
 })
 
 describe('prepareGlobalUserMessage', () => {
+	it('injects the active editor reference without contents', () => {
+		__resetUserDraftForTesting()
+		localStorage.clear()
+		UserDraft.setLiveEditorDraft({
+			workspace: WORKSPACE,
+			itemKind: 'script',
+			storagePath: '',
+			effectivePath: 'f/scripts/live_greeting'
+		})
+
+		const message = prepareGlobalUserMessage('Update this script', [], { workspace: WORKSPACE })
+
+		expect(message.content).toContain('## ACTIVE EDITOR')
+		expect(message.content).toContain('type: script')
+		expect(message.content).toContain('path: f/scripts/live_greeting')
+		expect(message.content).toContain('isLiveDraft: true')
+		expect(message.content).toContain('## INSTRUCTIONS:\nUpdate this script')
+		expect(message.content).not.toContain('When the user says')
+		expect(message.content).not.toContain('content')
+	})
+
 	it('includes selected workspace item references without contents', () => {
 		const message = prepareGlobalUserMessage('Update these items', [
 			{
diff --git a/frontend/src/lib/components/copilot/chat/global/core.ts b/frontend/src/lib/components/copilot/chat/global/core.ts
index 10d055938c..db8ecb871f 100644
--- a/frontend/src/lib/components/copilot/chat/global/core.ts
+++ b/frontend/src/lib/components/copilot/chat/global/core.ts
@@ -4,6 +4,7 @@ import {
 	FlowService,
 	GcpTriggerService,
 	HttpTriggerService,
+	JobService,
 	KafkaTriggerService,
 	MqttTriggerService,
 	NatsTriggerService,
@@ -47,7 +48,13 @@ import {
 	validateEditableFlowJson
 } from '../flow/editableFlowJson'
 import { createInlineScriptSession } from '../flow/inlineScriptsUtils'
-import { getFlowPrompt, getRawAppPrompt, getResourcePrompt, getScriptPrompt } from '$system_prompts'
+import {
+	getDatatableSdkReference,
+	getFlowPrompt,
+	getRawAppPrompt,
+	getResourcePrompt,
+	getScriptPrompt
+} from '$system_prompts'
 import type {
 	ChatCompletionSystemMessageParam,
 	ChatCompletionUserMessageParam
@@ -55,6 +62,9 @@ import type {
 import { z } from 'zod'
 import {
 	createToolDef,
+	createSearchHubScriptsTool,
+	executeFlowStepTestRun,
+	executeTestRun,
 	findAndReplace,
 	type CreatedResourceTriggerKind,
 	type Tool,
@@ -62,8 +72,10 @@ import {
 	type ToolDisplayAction
 } from '../shared'
 import type { ContextElement } from '../context'
+import { getDatatableTools } from '../datatableTools'
 import { UserDraft, type UserDraftMeta } from '$lib/userDraft.svelte'
 import { emptySchema } from '$lib/utils'
+import { inferArgs } from '$lib/infer'
 import {
 	resourceRequestSchema,
 	scheduleRequestSchema,
@@ -83,6 +95,9 @@ import {
 	type WorkspaceItemType
 } from './workspaceItems'
 import { buildFlowDeployRequestBody, buildScriptDeployRequestBody } from './deployRequests'
+import { userStore } from '$lib/stores'
+import { get } from 'svelte/store'
+import { bundleRawAppDraft } from './rawAppBundlerBridge'
 import {
 	clearEphemeralSecretVariableDraftValue,
 	deleteGlobalDraft,
@@ -110,21 +125,50 @@ const INSTRUCTION_SUBJECTS = [
 	'resource',
 	'app'
 ] as const satisfies readonly WorkspaceItemType[]
+// `datatable` is not a workspace item type, but the model can request the
+// datatable SDK reference (the wmill.datatable() runnable API) the same way.
+const INSTRUCTION_SUBJECTS_EXTRA = ['datatable'] as const
+const ALL_INSTRUCTION_SUBJECTS = [
+	...INSTRUCTION_SUBJECTS,
+	...INSTRUCTION_SUBJECTS_EXTRA
+] as const
 const MAX_LIST_LIMIT = 100
+type ActiveGlobalEditorType = Extract<WorkspaceItemType, 'script' | 'flow' | 'app'>
+type LiveEditorDraftKind = Parameters<typeof UserDraft.getLiveEditorDraft>[0]
+
+const ACTIVE_GLOBAL_EDITOR_DRAFTS: readonly {
+	itemKind: LiveEditorDraftKind
+	type: ActiveGlobalEditorType
+}[] = [
+	{ itemKind: 'script', type: 'script' },
+	{ itemKind: 'flow', type: 'flow' },
+	{ itemKind: 'raw_app', type: 'app' }
+]
+
+export type GlobalActiveEditorContext = {
+	type: ActiveGlobalEditorType
+	path: string
+	isLiveDraft: true
+}
+
+export type GlobalUserMessageOptions = {
+	workspace?: string
+	activeEditor?: GlobalActiveEditorContext
+}
 
 const itemTypeSchema = z.enum(ITEM_TYPES)
-const instructionSubjectSchema = z.enum(INSTRUCTION_SUBJECTS)
+const instructionSubjectSchema = z.enum(ALL_INSTRUCTION_SUBJECTS)
 const triggerKindSchema = z.enum(TRIGGER_KINDS)
 const scriptLangSchema = z.enum($ScriptLang.enum)
 
 const getInstructionsSchema = z.object({
 	subject: instructionSubjectSchema.describe(
-		"The workspace item type to get authoring instructions for (script, flow, resource, app). Schedules, triggers, and variables don't need instructions — their tool schemas describe everything."
+		"What to get authoring instructions for: a workspace item type (script, flow, resource, app) or \"datatable\" for the wmill.datatable() SQL SDK used inside runnables. Schedules, triggers, and variables don't need instructions — their tool schemas describe everything."
 	),
 	language: scriptLangSchema
 		.optional()
 		.describe(
-			'Required when subject is script. Use the existing script language when modifying, or the requested target language when creating.'
+			'The target language. Required when subject is script. For subject "datatable" it selects which SDK to return (e.g. "bun" for TypeScript, "python3" for Python) and defaults to TypeScript if omitted. Use the existing language when modifying, or the requested target language when creating. Other subjects ignore it.'
 		)
 })
 
@@ -361,6 +405,49 @@ const patchFlowJsonSchema = z.object({
 		)
 })
 
+const testRunArgsSchema = z
+	.record(z.string(), z.any())
+	.nullable()
+	.optional()
+	.describe('Arguments to pass to the runnable. Omit or pass null when no arguments are needed.')
+
+const testRunScriptSchema = z.object({
+	path: z.string().describe('Workspace path of the script to test.'),
+	args: testRunArgsSchema
+})
+
+const testRunScriptToolDef = createToolDef(
+	testRunScriptSchema,
+	'test_run_script',
+	'Execute a preview-style test run of a script by path, preferring local draft content when it exists.',
+	{ strict: false }
+)
+
+const testRunFlowSchema = z.object({
+	path: z.string().describe('Workspace path of the flow to test.'),
+	args: testRunArgsSchema
+})
+
+const testRunFlowToolDef = createToolDef(
+	testRunFlowSchema,
+	'test_run_flow',
+	'Execute a preview-style test run of a flow by path, preferring local draft content when it exists.',
+	{ strict: false }
+)
+
+const testRunStepSchema = z.object({
+	path: z.string().describe('Workspace path of the flow containing the step to test.'),
+	stepId: z.string().describe('The id of the step/module to test.'),
+	args: testRunArgsSchema
+})
+
+const testRunStepToolDef = createToolDef(
+	testRunStepSchema,
+	'test_run_step',
+	'Execute a test run of one step in a flow by path, preferring local draft flow/script content when it exists.',
+	{ strict: false }
+)
+
 // ============= App tools (raw apps) =============
 
 const backendRunnableSchema = z
@@ -456,6 +543,17 @@ const deleteAppRunnableSchema = z.object({
 	key: z.string().describe('Key of the backend runnable to remove.')
 })
 
+const openPreviewSchema = z.object({
+	kind: z
+		.enum(['script', 'flow', 'raw_app'])
+		.describe(
+			'Item kind to preview. Use "raw_app" for code-based apps (created via init_app). The legacy drag-and-drop app builder ("app") is not previewable in the session panel — don\'t pass it.'
+		),
+	path: z.string().describe('Workspace path of the item to preview.')
+})
+
+const getPreviewStatusSchema = z.object({})
+
 const FRAMEWORK_KEYS = [
 	'react19',
 	'react18',
@@ -474,37 +572,43 @@ const initAppSchema = z.object({
 		.enum(FRAMEWORK_KEYS)
 		.describe(
 			'Frontend framework template. Confirm with the user before calling — never default silently. react19 is recommended for new apps.'
-		),
-	data: z
-		.object({
-			datatable: z.string().optional().describe('Default datatable name (e.g. "main").'),
-			schema: z.string().optional().describe('Default schema (PostgreSQL schema, optional).'),
-			tables: z
-				.array(z.string())
-				.optional()
-				.describe(
-					'Initially-whitelisted tables, in the format "<datatable>/<table>" or "<datatable>/<schema>:<table>".'
-				)
-		})
-		.optional()
-		.describe('Optional datatable configuration. Omit unless the user asked to wire one up.')
+		)
 })
 
-const GLOBAL_SYSTEM_PROMPT = `You are Windmill's global workspace assistant.
+const buildGlobalSystemPrompt = (
+	username: string,
+	previewTools: boolean
+) => `You are Windmill's global workspace assistant.
+
+The current user's workspace username is "${username}".
 
 Use tools to inspect workspace items and create local drafts for scripts, flows, schedules, triggers, resources, variables, and raw apps.
 
+Path conventions:
+- Every workspace path has exactly three segments and starts with one of two namespaces:
+  - \`u/${username}/<name>\` — the current user's personal scope. Default for ad-hoc, exploratory, or scratch work.
+  - \`f/<folder>/<name>\` — a shared folder scope. The folder must already exist; bare \`f/<name>\` is INVALID and will fail.
+- When the user gives a bare name without a namespace prefix (e.g. "create a flow called myflow"), default to \`u/${username}/<name>\`. Do NOT invent \`f/<name>\` — that is a structurally invalid path.
+- If the request implies shared / team work but doesn't name a specific folder (e.g. "the marketing flow"), ask which folder to use rather than guessing. Call \`list_workspace_items\` with \`type: ['folder']\` (or rely on the user's hint) before assuming a folder exists.
+- Only use an \`f/<folder>/<name>\` path when the user explicitly named the folder or you confirmed it exists.
+
 Rules:
 - Draft tools create or update local drafts only; they do not deploy or mutate deployed workspace items.
 - Use list_workspace_items to find items and read_workspace_item before changing an existing item. For triggers, pass trigger_kind.
-- If the user refers to the open editor, use the item marked isLiveDraft=true.
+- If the user message includes an ACTIVE EDITOR section, treat it as the currently open item and use it for references like "this", "current", or "open editor".
 - Use deploy_workspace_item only after the user explicitly asks to deploy. It persists a local draft to the workspace.
 - Use discard_local_draft to remove an unsaved local draft, including the matching open editor draft. Use delete_workspace_item only to delete a deployed workspace item.
 - Variable values are never readable. For secrets, create a secret variable and reference it from resources as "$var:path/to/variable".
 - Use search_resource_types before write_resource.
 - Use get_instructions before writing scripts, flows, resources, or apps. For scripts, pass the target language.
+- After creating or editing a script or flow draft, run test_run_script, test_run_flow, or test_run_step with representative args before reporting that it works. These tools prefer local drafts, so testing does not require deployment.
 - When a required decision is ambiguous, use askUserQuestion with two to ten clear proposed answer strings instead of guessing. The user can also type a custom answer when none of the proposed answers fit.
-- Keep context targeted.
+- Keep context targeted.${
+	previewTools
+		? `
+- After writing or substantially editing a script / flow / app draft, show it via open_preview(kind, path) so the user sees the editor and live preview right next to the chat. First check whether it is already shown: if unsure, call get_preview_status. Only call open_preview (or offer to) when no preview is open or it is showing a different item — don't re-open a preview already showing the item you just edited.`
+		: ''
+}
 
 Flows:
 - read_workspace_item returns compact flow JSON. Inline script bodies appear as "inline_script.<moduleId>".
@@ -516,7 +620,14 @@ Raw apps:
 - Use write_app_file, patch_app_file, and delete_app_file for frontend files.
 - Use write_app_runnable and delete_app_runnable for backend runnables.
 - Use init_app only after confirming framework, path, and summary with the user.
-- Apps cannot be deployed from chat; tell the user to open the app editor.`
+- Use deploy_workspace_item after explicit user deploy intent; raw app deploy bundles JS/CSS before saving.
+
+Data Tables:
+- Datatables are workspace-scoped managed PostgreSQL databases, shared across the workspace (not owned by any single app). They must be configured by the user in their workspace settings (Workspace settings → Data Tables); they cannot be created via SQL.
+- Use list_datatables to discover the available datatables and their tables. Reuse an existing table rather than creating a duplicate. If list_datatables reports none, this is a blocking prerequisite — tell the user to set up a datatable in their workspace settings and stop; do not assume a "main" datatable exists or call exec_datatable_sql.
+- Use get_datatable_table_schema only when you need a table's column names/types; list_datatables is enough for table-list or availability summaries.
+- Use exec_datatable_sql to explore data, run queries, mutate rows, or change schema (CREATE/ALTER/DROP). Creating a table is a normal CREATE TABLE statement — it appears in list_datatables afterward, with no registration step.
+- When writing runnable code (inline app runnables, scripts, flow modules) that reads or writes datatable data at runtime, it accesses a datatable via wmill.datatable(). Default to TypeScript (bun) unless the user asked for another language. Call get_instructions with subject "datatable" and language "bun" for the TypeScript SQL SDK reference (or language "python3" for Python) — it returns only that language so you get just what you need.`
 
 const DEFAULT_LIST_TYPES = ['script', 'flow'] as const satisfies readonly WorkspaceItemType[]
 
@@ -576,7 +687,12 @@ function serializeWorkspaceItemForRead(item: WorkspaceItem): unknown {
 		}
 	}
 
-	if (item.type === 'app' && item.value && typeof item.value === 'object' && 'files' in item.value) {
+	if (
+		item.type === 'app' &&
+		item.value &&
+		typeof item.value === 'object' &&
+		'files' in item.value
+	) {
 		return {
 			type: 'app',
 			path: item.path,
@@ -1169,7 +1285,7 @@ function getScriptInstructions(language: ScriptLang | undefined): string {
 
 - Global mode writes complete draft payloads only; it does not save, deploy, run, or generate metadata.
 - A script draft is a workspace item: \`{ type: 'script', path, summary?, language, value, isDraft }\` where \`value\` is the source code string.
-- Use workspace paths such as \`f/folder/name\` or \`u/username/name\`. Preserve the current path/language when modifying unless the user asked to change them.
+- Paths follow the conventions in the system prompt: default to \`u/<current-user>/<name>\` when the user gave a bare name; only use \`f/<folder>/<name>\` when the folder is known to exist. Preserve the current path/language when modifying unless the user asked to change them.
 - Use \`edit_script\` for small localized changes (provide \`old_string\`/\`new_string\`); use \`write_script\` for full rewrites.${note}
 
 # Windmill script authoring reference (${selected})
@@ -1181,6 +1297,7 @@ function getFlowInstructions(): string {
 	return `# Global draft flow instructions
 
 - Global mode writes complete draft payloads only; it does not save, deploy, run, scaffold local files, or generate metadata.
+- Paths follow the conventions in the system prompt: default to \`u/<current-user>/<name>\` when the user gave a bare name; only use \`f/<folder>/<name>\` when the folder is known to exist. Never invent a folder.
 - \`write_flow\` mirrors flow mode's \`set_flow_json\`: pass \`path\`, optional \`summary\`, required \`modules\`, and optional \`schema\`, \`preprocessor_module\`, \`failure_module\`, and \`groups\`. The flow-structure arguments are JSON strings, matching the tool schema descriptions.
 - \`read_workspace_item\` returns a compact flow \`value\` object with \`modules\`, \`schema\`, \`preprocessor_module\`, \`failure_module\`, and \`groups\`.
 - \`modules\` contains normal sequential modules. Use top-level \`preprocessor_module\` and \`failure_module\` for special modules; do not put \`preprocessor\` or \`failure\` in \`modules\`.
@@ -1202,20 +1319,20 @@ function getFlowInstructions(): string {
 ${getFlowPrompt()}`
 }
 
-type InstructionSubject = (typeof INSTRUCTION_SUBJECTS)[number]
+type InstructionSubject = (typeof ALL_INSTRUCTION_SUBJECTS)[number]
 
 function getAppInstructions(): string {
 	return `# Global draft app instructions
 
-- Global mode edits raw app drafts only; it does not save, deploy, or bundle.
-- App drafts are addressed by workspace path (e.g. \`f/folder/my_app\`). The first write tool snapshots the workspace app onto the draft, and subsequent writes accumulate.
+- Global mode edits raw app drafts only; it does not save or deploy unless the user explicitly asks to deploy.
+- App drafts are addressed by workspace path. Follow the path conventions in the system prompt: default to \`u/<current-user>/<name>\` for bare names; only use \`f/<folder>/<name>\` when the folder is known to exist. The first write tool snapshots the workspace app onto the draft, and subsequent writes accumulate.
 - To create a new app, use \`init_app\` with a path, optional summary, and a framework (\`react19\` / \`react18\` / \`svelte5\` / \`vue\`). Confirm framework + path + summary with the user before calling — do not silently default to \`react19\` even though it is the recommended choice. \`init_app\` errors if an app already exists at the path or a draft is already in flight; in that case, edit the existing one rather than re-initializing.
 - \`init_app\` seeds a starter inline runnable named \`a\` (bun, \`main(x: string) => string\`) so the React/Svelte demo button works on first render. Replace or remove it once you start building real backend runnables.
 - Frontend file paths start with \`/\` (e.g. \`/index.tsx\`, \`/App.tsx\`, \`/styles.css\`). Use \`write_app_file\` / \`patch_app_file\` / \`delete_app_file\`.
 - Backend inline runnables are addressed as \`backend/<key>/main.{ts|py}\` from the file tools, but you create or update them via \`write_app_runnable\` / \`delete_app_runnable\` (which take the runnable shape directly: \`{ name, type, inlineScript?, path?, staticInputs? }\`).
 - \`/wmill.d.ts\` (or \`wmill.ts\`) is generated automatically from the backend runnables — never write it directly.
 - Inline runnables only support \`bun\` or \`python3\` in chat. Path runnables (\`script\`/\`flow\`/\`hubscript\`) reference an existing item.
-- Apps cannot be deployed from chat. The app editor bundles JS/CSS before save; tell the user to open the app editor to deploy app drafts.
+- Use \`deploy_workspace_item\` after explicit user deploy intent. The deploy tool bundles JS/CSS before saving the raw app.
 - Use \`read_workspace_item\` with \`type: 'app'\` for a metadata summary (file paths and runnable list, no contents). Use \`read_app_file\` to read an individual file.
 - Note: the authoring reference below mentions the CLI on-disk layout (\`backend/<id>.<ext>\`, \`raw_app.yaml\`, \`sql_to_apply/\`). That layout is only relevant for the terminal workflow — in chat, apps are addressed via the tool surface above.
 
@@ -1241,6 +1358,19 @@ function getResourceInstructions(): string {
 ${getResourcePrompt()}`
 }
 
+function getDatatableInstructions(language?: ScriptLang): string {
+	// Default to the TypeScript SDK so we return only what's needed, not both.
+	const lang = language ?? 'bun'
+	return `# Datatable SQL SDK reference
+
+Datatables are workspace-scoped managed PostgreSQL databases. In chat, explore and shape them with the \`list_datatables\`, \`get_datatable_table_schema\`, and \`exec_datatable_sql\` tools. The reference below is for code you author inside runnables (inline app runnables, scripts, or flow rawscript modules) that reads or writes datatable data at runtime.
+
+- A runnable accesses a datatable via \`wmill.datatable()\` (the default "main") or \`wmill.datatable('<name>')\`, referencing tables as \`schema.table\`.
+- Use parameterized queries (the tagged template in TypeScript, \`$1\`/\`$2\` placeholders in Python) — never interpolate untrusted values into SQL strings.
+
+${getDatatableSdkReference(lang)}`
+}
+
 function getInstructions(subject: InstructionSubject, language?: ScriptLang): string {
 	switch (subject) {
 		case 'script':
@@ -1251,6 +1381,8 @@ function getInstructions(subject: InstructionSubject, language?: ScriptLang): st
 			return getResourceInstructions()
 		case 'app':
 			return getAppInstructions()
+		case 'datatable':
+			return getDatatableInstructions(language)
 	}
 }
 
@@ -1259,7 +1391,7 @@ export const globalTools: Tool<{}>[] = [
 		def: createToolDef(
 			getInstructionsSchema,
 			'get_instructions',
-			'Get authoring guidance for scripts, flows, resources, or apps.'
+			'Get authoring guidance for scripts, flows, resources, apps, or the datatable SQL SDK (wmill.datatable()) used inside runnables.'
 		),
 		fn: async ({ args, toolId, toolCallbacks }) => {
 			const parsed = getInstructionsSchema.parse(args)
@@ -1271,6 +1403,7 @@ export const globalTools: Tool<{}>[] = [
 			return getInstructions(parsed.subject, parsed.language)
 		}
 	},
+	createSearchHubScriptsTool(false),
 	{
 		def: createToolDef(
 			askUserQuestionSchema,
@@ -1495,6 +1628,39 @@ export const globalTools: Tool<{}>[] = [
 			return patchFlowJson(parsed, ctx)
 		}
 	},
+	{
+		def: testRunScriptToolDef,
+		fn: async (ctx) => {
+			const parsed = testRunScriptSchema.parse(ctx.args)
+			return testRunScriptByPath(parsed, ctx)
+		},
+		requiresConfirmation: true,
+		confirmationMessage: 'Run script test',
+		showDetails: true,
+		autoCollapseDetails: false
+	},
+	{
+		def: testRunFlowToolDef,
+		fn: async (ctx) => {
+			const parsed = testRunFlowSchema.parse(ctx.args)
+			return testRunFlowByPath(parsed, ctx)
+		},
+		requiresConfirmation: true,
+		confirmationMessage: 'Run flow test',
+		showDetails: true,
+		autoCollapseDetails: false
+	},
+	{
+		def: testRunStepToolDef,
+		fn: async (ctx) => {
+			const parsed = testRunStepSchema.parse(ctx.args)
+			return testRunFlowStepByPath(parsed, ctx)
+		},
+		requiresConfirmation: true,
+		confirmationMessage: 'Run flow step test',
+		showDetails: true,
+		autoCollapseDetails: false
+	},
 	{
 		def: createToolDef(
 			deployWorkspaceItemSchema,
@@ -1508,7 +1674,7 @@ export const globalTools: Tool<{}>[] = [
 		confirmationMessage: 'Deploy local draft to workspace',
 		fn: async (ctx) => {
 			const parsed = deployWorkspaceItemSchema.parse(ctx.args)
-			return deployDraft(parsed, ctx)
+			return deployDraft(parsed, { ...ctx, sessionId: sessionIdFromCtx(ctx) })
 		}
 	},
 	{
@@ -1714,13 +1880,139 @@ export const globalTools: Tool<{}>[] = [
 			const parsed = deleteAppRunnableSchema.parse(ctx.args)
 			return deleteAppRunnable(parsed, ctx)
 		}
-	}
+	},
+	{
+		def: createToolDef(
+			openPreviewSchema,
+			'open_preview',
+			'Open the live preview / editor for a workspace item in the side panel next to the chat. ONLY works inside an AI session — call this after writing or editing a script, flow, or raw app to let the user see and interact with it. The path you pass is the path of the item; for code-based apps use kind="raw_app" (legacy drag-and-drop apps are not previewable). Returns an error if there is no active session.'
+		),
+		fn: async (ctx) => {
+			const parsed = openPreviewSchema.parse(ctx.args)
+			return openSessionPreview(parsed, sessionIdFromCtx(ctx))
+		}
+	},
+	{
+		def: createToolDef(
+			getPreviewStatusSchema,
+			'get_preview_status',
+			'Check whether the side-panel preview is open in this AI session and which item (kind + path) it is showing. Call this before offering or calling open_preview so you do not re-open a preview that is already showing the item you just edited. Only meaningful inside a session.'
+		),
+		fn: async (ctx) => getSessionPreviewStatus(sessionIdFromCtx(ctx))
+	},
+	// Workspace-scoped datatable tools (unrestricted: no whitelist, no creation policy)
+	...getDatatableTools()
 ]
 
+// Tools that only make sense inside an AI session (they drive the session's
+// side-panel preview). The regular global side-panel chat shouldn't even be
+// offered them — see `globalToolsFor`.
+export const SESSION_PREVIEW_TOOL_NAMES = new Set(['open_preview', 'get_preview_status'])
+
+/**
+ * The global tool set for a given chat: the full `globalTools` for a session
+ * chat, or `globalTools` minus the session-only preview tools for the regular
+ * global side-panel chat.
+ */
+export function globalToolsFor({ sessionPreview }: { sessionPreview: boolean }): Tool<{}>[] {
+	return sessionPreview
+		? globalTools
+		: globalTools.filter((t) => !SESSION_PREVIEW_TOOL_NAMES.has(t.def.function.name))
+}
+
 type WriteDraftCtx = {
 	workspace: string
 	toolId: string
 	toolCallbacks: ToolCallbacks
+	// Calling session id (session chats only), threaded through so a deploy
+	// reloads the preview of the session that issued the deploy — not the
+	// UI-active one. Undefined for the global side-panel chat.
+	sessionId?: string
+}
+
+// Sessions are the only context where `open_preview` makes sense — the global
+// singleton chat in the right side panel has nowhere to mount an editor pane.
+// The session runtime registers a handler at construction time so the tool
+// has somewhere to dispatch. When no session is active the handler is
+// undefined and the tool returns a polite error.
+// Per-manager tool helpers for a session chat. Each session's AIChatManager
+// sets `helpers = { sessionId }`, so a tool call carries the *calling* session's
+// id even when a different session is the UI-active one. Without this the
+// handlers below would route a backgrounded session's tool call to whatever
+// session the user happens to be viewing.
+export type SessionToolHelpers = { sessionId?: string }
+export type GlobalToolHelpers = SessionToolHelpers & {
+	testActiveFlow?: (args?: Record<string, any>) => Promise<string | undefined>
+}
+
+function sessionIdFromCtx(ctx: { helpers?: unknown }): string | undefined {
+	return (ctx.helpers as GlobalToolHelpers | undefined)?.sessionId
+}
+
+function activeFlowTestFromCtx(
+	ctx: { workspace: string; helpers?: unknown },
+	path: string
+): GlobalToolHelpers['testActiveFlow'] | undefined {
+	const activeEditor = getActiveGlobalEditorContext(ctx.workspace)
+	if (activeEditor?.type !== 'flow' || activeEditor.path !== path) {
+		return undefined
+	}
+	return (ctx.helpers as GlobalToolHelpers | undefined)?.testActiveFlow
+}
+
+export type OpenPreviewHandler = (req: {
+	sessionId: string | undefined
+	kind: 'script' | 'flow' | 'raw_app'
+	path: string
+}) => string
+
+let openPreviewHandler: OpenPreviewHandler | undefined
+
+export function setOpenPreviewHandler(handler: OpenPreviewHandler | undefined): void {
+	openPreviewHandler = handler
+}
+
+function openSessionPreview(
+	args: { kind: 'script' | 'flow' | 'raw_app'; path: string },
+	sessionId: string | undefined
+) {
+	if (!openPreviewHandler) {
+		return 'Error: open_preview is only available inside an AI session. Tell the user to switch to a session to view the preview, or describe the item textually.'
+	}
+	return openPreviewHandler({ ...args, sessionId })
+}
+
+// Companion to `open_preview`: lets the assistant query the current preview
+// state (open? which item?) so it can avoid re-opening a preview already
+// showing the item it just edited. Registered by the session runtime
+// alongside the open-preview handler.
+export type GetPreviewStatusHandler = (sessionId: string | undefined) => string
+
+let getPreviewStatusHandler: GetPreviewStatusHandler | undefined
+
+export function setGetPreviewStatusHandler(handler: GetPreviewStatusHandler | undefined): void {
+	getPreviewStatusHandler = handler
+}
+
+function getSessionPreviewStatus(sessionId: string | undefined): string {
+	if (!getPreviewStatusHandler) {
+		return 'Error: get_preview_status is only available inside an AI session.'
+	}
+	return getPreviewStatusHandler(sessionId)
+}
+
+// Registered by the session runtime to reload the open preview after a chat
+// deploy. Undefined outside a session.
+export type DeployedInSessionHandler = (req: {
+	sessionId: string | undefined
+	kind: 'script' | 'flow' | 'raw_app'
+	path: string
+}) => void
+
+let deployedInSessionHandler: DeployedInSessionHandler | undefined
+
+export function setDeployedInSessionHandler(handler: DeployedInSessionHandler | undefined): void {
+	deployedInSessionHandler = handler
 }
 
 type DraftConfig = Record<string, any>
@@ -1841,7 +2133,7 @@ function buildVariableDeployRequestBody(
 
 function startDraftWrite(ctx: WriteDraftCtx, type: WorkspaceItemType, path: string): void {
 	ctx.toolCallbacks.setToolStatus(ctx.toolId, {
-		content: `Writing draft ${type} "${path}"...`
+		content: `Saving ${type} "${path}" to local storage…`
 	})
 }
 
@@ -1866,13 +2158,13 @@ function finishDraftWrite(stored: WorkspaceItem, existed: boolean, ctx: WriteDra
 			: stored
 
 	ctx.toolCallbacks.setToolStatus(ctx.toolId, {
-		content: `${verb} local draft ${stored.type} "${stored.path}"`,
-		result: `Draft ${verb.toLowerCase()}`
+		content: `${verb} ${stored.type} "${stored.path}" in local storage`,
+		result: `Saved to local storage`
 	})
 	return JSON.stringify(
 		{
 			success: true,
-			message: `${verb} local draft ${stored.type} "${stored.path}". The workspace was not saved or deployed.`,
+			message: `${verb} ${stored.type} "${stored.path}" in local storage (a browser-only local draft, not a workspace draft). It was not deployed.`,
 			item: serializedItem
 		},
 		null,
@@ -2297,17 +2589,155 @@ async function setFlowModuleCode(
 	)
 }
 
+function normalizeTestRunArgs(args: Record<string, any> | null | undefined): Record<string, any> {
+	return args ?? {}
+}
+
+function flowDraftValueForPreview(flowDraft: FlowDraftValue): FlowValue {
+	return flowDraftAsEditableInput(flowDraft).value
+}
+
+async function loadScriptForFlowStep(
+	moduleValue: { path: string; hash?: string },
+	workspace: string
+): Promise<{ content: string; language: ScriptLang }> {
+	const draft = getGlobalDraft(workspace, 'script', moduleValue.path)
+	if (draft) {
+		if (typeof draft.value !== 'string' || !draft.language) {
+			throw new Error(`Draft script "${moduleValue.path}" is missing content or language.`)
+		}
+		return { content: draft.value, language: draft.language }
+	}
+
+	const script = moduleValue.hash
+		? await ScriptService.getScriptByHash({ workspace, hash: moduleValue.hash })
+		: await ScriptService.getScriptByPath({ workspace, path: moduleValue.path })
+	return { content: script.content, language: script.language }
+}
+
+async function loadDraftFlowPreviewValue(
+	path: string,
+	workspace: string
+): Promise<FlowValue | undefined> {
+	if (!getGlobalDraft(workspace, 'flow', path)) {
+		return undefined
+	}
+	const nestedFlow = await loadFlowDraftValue(path, workspace)
+	return flowDraftValueForPreview(nestedFlow.flow)
+}
+
+async function testRunScriptByPath(
+	args: z.infer<typeof testRunScriptSchema>,
+	ctx: WriteDraftCtx
+): Promise<string> {
+	const { workspace, toolId, toolCallbacks } = ctx
+	const script = await loadScriptForEdit(args.path, workspace)
+	const testArgs = normalizeTestRunArgs(args.args)
+
+	return executeTestRun({
+		jobStarter: () =>
+			JobService.runScriptPreview({
+				workspace,
+				requestBody: {
+					path: args.path,
+					content: script.content,
+					args: testArgs,
+					language: script.language
+				}
+			}),
+		workspace,
+		toolCallbacks,
+		toolId,
+		startMessage: `Running test for script "${args.path}"...`,
+		contextName: 'script'
+	})
+}
+
+async function testRunFlowByPath(
+	args: z.infer<typeof testRunFlowSchema>,
+	ctx: WriteDraftCtx
+): Promise<string> {
+	const { workspace, toolId, toolCallbacks } = ctx
+	const testArgs = normalizeTestRunArgs(args.args)
+	const testActiveFlow = activeFlowTestFromCtx(ctx, args.path)
+
+	if (testActiveFlow) {
+		return executeTestRun({
+			jobStarter: async () => {
+				const jobId = await testActiveFlow(testArgs)
+				if (jobId) {
+					return jobId
+				}
+
+				const flow = await loadFlowDraftValue(args.path, workspace)
+				return JobService.runFlowPreview({
+					workspace,
+					requestBody: {
+						path: args.path,
+						value: flowDraftValueForPreview(flow.flow),
+						args: testArgs
+					}
+				})
+			},
+			workspace,
+			toolCallbacks,
+			toolId,
+			startMessage: `Starting flow test run for "${args.path}"...`,
+			contextName: 'flow'
+		})
+	}
+
+	const flow = await loadFlowDraftValue(args.path, workspace)
+
+	return executeTestRun({
+		jobStarter: () =>
+			JobService.runFlowPreview({
+				workspace,
+				requestBody: {
+					path: args.path,
+					value: flowDraftValueForPreview(flow.flow),
+					args: testArgs
+				}
+			}),
+		workspace,
+		toolCallbacks,
+		toolId,
+		startMessage: `Starting flow test run for "${args.path}"...`,
+		contextName: 'flow'
+	})
+}
+
+async function testRunFlowStepByPath(
+	args: z.infer<typeof testRunStepSchema>,
+	ctx: WriteDraftCtx
+): Promise<string> {
+	const { workspace, toolId, toolCallbacks } = ctx
+	const flow = await loadFlowDraftValue(args.path, workspace)
+	const flowValue = flowDraftValueForPreview(flow.flow)
+	const testArgs = normalizeTestRunArgs(args.args)
+
+	return executeFlowStepTestRun({
+		flowValue,
+		stepId: args.stepId,
+		args: testArgs,
+		workspace,
+		toolCallbacks,
+		toolId,
+		loadScript: loadScriptForFlowStep,
+		loadFlowPreviewValue: loadDraftFlowPreviewValue
+	})
+}
+
 async function initApp(
 	args: {
 		path: string
 		summary?: string
 		framework: FrameworkKey
-		data?: { datatable?: string; schema?: string; tables?: string[] }
 	},
 	ctx: WriteDraftCtx
 ): Promise<string> {
 	const { workspace, toolId, toolCallbacks } = ctx
-	const { path, summary, framework, data } = args
+	const { path, summary, framework } = args
 
 	if (getGlobalDraft(workspace, 'app', path)) {
 		throw new Error(
@@ -2321,33 +2751,26 @@ async function initApp(
 	}
 
 	toolCallbacks.setToolStatus(toolId, {
-		content: `Initializing app draft "${path}" with ${framework} template...`
+		content: `Saving app "${path}" to local storage (${framework} template)…`
 	})
 
 	const template = FRAMEWORK_TEMPLATES[framework]
 	const value: AppDraftValue = {
 		summary,
 		files: { ...template },
-		runnables: { [STARTER_RUNNABLE_KEY]: { ...STARTER_RUNNABLE } },
-		...(data && {
-			data: {
-				tables: data.tables ?? [],
-				datatable: data.datatable,
-				schema: data.schema
-			}
-		})
+		runnables: { [STARTER_RUNNABLE_KEY]: { ...STARTER_RUNNABLE } }
 	}
 	await recomputeAppPolicy(value)
 	const stored = saveAppDraft(workspace, path, value)
 
 	toolCallbacks.setToolStatus(toolId, {
-		content: `Initialized app draft "${path}" (${framework})`,
-		result: 'Draft initialized'
+		content: `Saved app "${path}" to local storage (${framework})`,
+		result: 'Saved to local storage'
 	})
 	return JSON.stringify(
 		{
 			success: true,
-			message: `Initialized local draft app "${path}" from the ${framework} template with a starter runnable "${STARTER_RUNNABLE_KEY}". Use write_app_file / write_app_runnable to evolve the draft.`,
+			message: `Initialized app "${path}" in local storage from the ${framework} template with a starter runnable "${STARTER_RUNNABLE_KEY}" (a browser-only local draft, not a workspace draft). Use write_app_file / write_app_runnable to evolve it.`,
 			item: stored
 		},
 		null,
@@ -2404,12 +2827,12 @@ async function writeAppFile(
 
 	toolCallbacks.setToolStatus(toolId, {
 		content: `Updated ${target.filePath} in app "${args.path}"`,
-		result: 'Draft updated'
+		result: 'Saved to local storage'
 	})
 	return JSON.stringify(
 		{
 			success: true,
-			message: `Updated local draft app "${args.path}" with frontend file "${target.filePath}".`,
+			message: `Updated app "${args.path}" in local storage with frontend file "${target.filePath}".`,
 			item: stored
 		},
 		null,
@@ -2444,12 +2867,12 @@ async function deleteAppFile(
 
 	toolCallbacks.setToolStatus(toolId, {
 		content: `Removed ${target.filePath} from app "${args.path}"`,
-		result: 'Draft updated'
+		result: 'Saved to local storage'
 	})
 	return JSON.stringify(
 		{
 			success: true,
-			message: `Removed "${target.filePath}" from local draft app "${args.path}".`,
+			message: `Removed "${target.filePath}" from app "${args.path}" in local storage.`,
 			item: stored
 		},
 		null,
@@ -2527,12 +2950,12 @@ async function patchAppFile(
 	const stored = saveAppDraft(workspace, path, value, meta)
 	toolCallbacks.setToolStatus(toolId, {
 		content: `Patched ${target.filePath} in app "${path}"`,
-		result: 'Draft updated'
+		result: 'Saved to local storage'
 	})
 	return JSON.stringify(
 		{
 			success: true,
-			message: `Patched "${target.filePath}" in local draft app "${path}".`,
+			message: `Patched "${target.filePath}" in app "${path}" in local storage.`,
 			item: stored
 		},
 		null,
@@ -2541,7 +2964,14 @@ async function patchAppFile(
 }
 
 async function recomputeAppPolicy(value: AppDraftValue): Promise<void> {
-	value.policy = (await updateRawAppPolicy(value.runnables as any, value.policy as any)) as any
+	const policy = (await updateRawAppPolicy(
+		value.runnables as any,
+		value.policy as any
+	)) as NonNullable<AppDraftValue['policy']>
+	if (!policy.execution_mode) {
+		policy.execution_mode = 'publisher'
+	}
+	value.policy = policy
 }
 
 async function writeAppRunnable(
@@ -2563,12 +2993,12 @@ async function writeAppRunnable(
 
 	toolCallbacks.setToolStatus(toolId, {
 		content: `Updated runnable "${key}" in app "${path}"`,
-		result: 'Draft updated'
+		result: 'Saved to local storage'
 	})
 	return JSON.stringify(
 		{
 			success: true,
-			message: `Updated local draft app "${path}" with runnable "${key}".`,
+			message: `Updated app "${path}" in local storage with runnable "${key}".`,
 			item: stored
 		},
 		null,
@@ -2597,12 +3027,12 @@ async function deleteAppRunnable(
 
 	toolCallbacks.setToolStatus(toolId, {
 		content: `Removed runnable "${key}" from app "${path}"`,
-		result: 'Draft updated'
+		result: 'Saved to local storage'
 	})
 	return JSON.stringify(
 		{
 			success: true,
-			message: `Removed runnable "${key}" from local draft app "${path}".`,
+			message: `Removed runnable "${key}" from app "${path}" in local storage.`,
 			item: stored
 		},
 		null,
@@ -2688,13 +3118,13 @@ async function discardLocalDraft(
 	deleteGlobalDraft(workspace, type, path, triggerKind)
 
 	toolCallbacks.setToolStatus(toolId, {
-		content: `Discarded local draft ${type} "${path}"`,
-		result: 'Draft discarded'
+		content: `Discarded ${type} "${path}" from local storage`,
+		result: 'Discarded from local storage'
 	})
 	return JSON.stringify(
 		{
 			success: true,
-			message: `Discarded local draft ${type} "${path}". The deployed workspace item was not changed.`,
+			message: `Discarded the local-storage draft for ${type} "${path}". The deployed workspace item was not changed.`,
 			type,
 			path,
 			triggerKind
@@ -2713,15 +3143,9 @@ async function deployDraft(
 	},
 	ctx: WriteDraftCtx
 ): Promise<string> {
-	const { workspace, toolId, toolCallbacks } = ctx
+	const { workspace, toolId, toolCallbacks, sessionId } = ctx
 	const { type, path, trigger_kind: triggerKind, deployment_message: deploymentMessage } = args
 
-	if (type === 'app') {
-		throw new Error(
-			'Apps cannot be deployed from chat. Open the app editor to deploy (the editor bundles JS/CSS before save).'
-		)
-	}
-
 	if (type === 'trigger' && !triggerKind) {
 		throw new Error('trigger_kind is required when deploying a trigger.')
 	}
@@ -2745,10 +3169,16 @@ async function deployDraft(
 			const existing = (await ScriptService.existsScriptByPath({ workspace, path }))
 				? await ScriptService.getScriptByPath({ workspace, path })
 				: undefined
-			await ScriptService.createScript({
-				workspace,
-				requestBody: buildScriptDeployRequestBody(path, draft, existing, deploymentMessage)
-			})
+			const requestBody = buildScriptDeployRequestBody(path, draft, existing, deploymentMessage)
+			// Infer the arg schema from the content so it matches the code, like the editor does.
+			try {
+				const schema = emptySchema()
+				await inferArgs(requestBody.language, requestBody.content, schema)
+				requestBody.schema = schema
+			} catch (e) {
+				console.error('Failed to infer script schema before deploy', e)
+			}
+			await ScriptService.createScript({ workspace, requestBody })
 			break
 		}
 		case 'flow': {
@@ -2817,10 +3247,102 @@ async function deployDraft(
 			actions = [createOpenVariableAction(path)]
 			break
 		}
+		case 'app': {
+			const appDraft = draft.value as AppDraftValue
+			const appValue: AppDraftValue = {
+				...appDraft,
+				files: { ...(appDraft.files ?? {}) },
+				runnables: { ...(appDraft.runnables ?? {}) },
+				data: appDraft.data ?? { ...DEFAULT_RAW_APP_DATA }
+			}
+			await recomputeAppPolicy(appValue)
+			const policy = appValue.policy
+			if (!policy) {
+				throw new Error(`Draft app "${path}" has no policy to deploy.`)
+			}
+
+			toolCallbacks.setToolStatus(toolId, {
+				content: `Bundling app "${path}"...`
+			})
+			const bundle = await bundleRawAppDraft({
+				workspace,
+				files: appValue.files,
+				onLog: (delta) => {
+					const lines = delta
+						.split('\n')
+						.map((line) => line.trim())
+						.filter(Boolean)
+					const latest = lines[lines.length - 1]
+					if (latest) {
+						toolCallbacks.setToolStatus(toolId, {
+							content: `Bundling app "${path}"... ${latest}`
+						})
+					}
+				}
+			})
+
+			toolCallbacks.setToolStatus(toolId, {
+				content: `Deploying app "${path}"...`
+			})
+			const rawAppValue = {
+				files: appValue.files,
+				runnables: appValue.runnables,
+				data: appValue.data ?? { ...DEFAULT_RAW_APP_DATA }
+			}
+			const summary = appValue.summary ?? draft.summary ?? ''
+			if (await AppService.existsApp({ workspace, path })) {
+				// Omit custom_path on update for now. The backend preserves it when absent, while
+				// sending it requires admin privileges; this chat deploy path does not yet mirror
+				// the raw app editor's user/admin-specific custom_path handling.
+				await AppService.updateAppRaw({
+					workspace,
+					path,
+					formData: {
+						app: {
+							path,
+							value: rawAppValue,
+							summary,
+							policy,
+							deployment_message: deploymentMessage
+						},
+						js: bundle.js,
+						css: bundle.css
+					}
+				})
+			} else {
+				await AppService.createAppRaw({
+					workspace,
+					formData: {
+						app: {
+							path,
+							value: rawAppValue,
+							summary,
+							policy,
+							deployment_message: deploymentMessage,
+							custom_path: appValue.custom_path
+						},
+						js: bundle.js,
+						css: bundle.css
+					}
+				})
+			}
+			break
+		}
 	}
 
 	deleteGlobalDraft(workspace, type, path, triggerKind, { preserveLiveDraft: true })
 
+	// Reload the session preview if it's open on the deployed item. Map the
+	// deploy type to the preview kind — a raw app deploys under 'app' but the
+	// preview addresses it as 'raw_app'; non-previewable types map to undefined.
+	const previewKindByType: Partial<Record<WorkspaceItemType, 'script' | 'flow' | 'raw_app'>> = {
+		script: 'script',
+		flow: 'flow',
+		app: 'raw_app'
+	}
+	const kind = previewKindByType[type]
+	if (kind) deployedInSessionHandler?.({ sessionId, kind, path })
+
 	toolCallbacks.setToolStatus(toolId, {
 		content: `Deployed ${type} "${path}"`,
 		result: 'Deployed',
@@ -2898,9 +3420,11 @@ async function deleteWorkspaceItem(
 }
 
 export function prepareGlobalSystemMessage(
-	customPrompt?: string
+	customPrompt?: string,
+	opts?: { previewTools?: boolean }
 ): ChatCompletionSystemMessageParam {
-	let content = GLOBAL_SYSTEM_PROMPT
+	const username = get(userStore)?.username ?? ''
+	let content = buildGlobalSystemPrompt(username, opts?.previewTools ?? false)
 	if (customPrompt?.trim()) {
 		content = `${content}\n\nUSER GIVEN INSTRUCTIONS:\n${customPrompt.trim()}`
 	}
@@ -2911,15 +3435,37 @@ export function prepareGlobalSystemMessage(
 	}
 }
 
+export function getActiveGlobalEditorContext(
+	workspace: string
+): GlobalActiveEditorContext | undefined {
+	for (const { itemKind, type } of ACTIVE_GLOBAL_EDITOR_DRAFTS) {
+		const liveDraft = UserDraft.getLiveEditorDraft(itemKind, { workspace })
+		const path = liveDraft?.effectivePath || liveDraft?.storagePath
+		if (!path) continue
+		return { type, path, isLiveDraft: true }
+	}
+}
+
 export function prepareGlobalUserMessage(
 	instructions: string,
-	selectedContext: ContextElement[] = []
+	selectedContext: ContextElement[] = [],
+	options: GlobalUserMessageOptions = {}
 ): ChatCompletionUserMessageParam {
 	const selectedWorkspaceItems = selectedContext.filter(
 		(context) => context.type === 'workspace_script' || context.type === 'workspace_flow'
 	)
+	const activeEditor =
+		options.activeEditor ??
+		(options.workspace ? getActiveGlobalEditorContext(options.workspace) : undefined)
 	let content = ''
 
+	if (activeEditor) {
+		content += '## ACTIVE EDITOR\n'
+		content += `type: ${activeEditor.type}\n`
+		content += `path: ${activeEditor.path}\n`
+		content += `isLiveDraft: true\n\n`
+	}
+
 	if (selectedWorkspaceItems.length > 0) {
 		content += '## SELECTED CONTEXT\n'
 		for (const context of selectedWorkspaceItems) {
diff --git a/frontend/src/lib/components/copilot/chat/global/rawAppBundlerBridge.ts b/frontend/src/lib/components/copilot/chat/global/rawAppBundlerBridge.ts
new file mode 100644
index 0000000000..27f9f5aaee
--- /dev/null
+++ b/frontend/src/lib/components/copilot/chat/global/rawAppBundlerBridge.ts
@@ -0,0 +1,144 @@
+import { WorkspaceService } from '$lib/gen'
+
+export type RawAppBundle = {
+	js: string
+	css: string
+}
+
+type BundleRawAppFilesParams = {
+	files: Record<string, string>
+	sharedUiFiles?: Record<string, string>
+	bundlerType?: 'esbuild' | 'rolldown'
+	timeoutMs?: number
+	onLog?: (delta: string) => void
+}
+
+type BundleRawAppDraftParams = BundleRawAppFilesParams & {
+	workspace: string
+}
+
+const DEFAULT_TIMEOUT_MS = 120_000
+
+function makeRequestId(): string {
+	return globalThis.crypto?.randomUUID?.() ?? Math.random().toString(36).slice(2)
+}
+
+async function loadSharedUiFiles(workspace: string): Promise<Record<string, string>> {
+	try {
+		const res = (await WorkspaceService.getSharedUi({ workspace })) as {
+			files?: Record<string, string>
+		}
+		return res.files ?? {}
+	} catch (e) {
+		console.warn('Failed to load shared UI for raw app bundling:', e)
+		return {}
+	}
+}
+
+export async function bundleRawAppDraft(params: BundleRawAppDraftParams): Promise<RawAppBundle> {
+	const sharedUiFiles = params.sharedUiFiles ?? (await loadSharedUiFiles(params.workspace))
+	return bundleRawAppFiles({
+		...params,
+		sharedUiFiles
+	})
+}
+
+export function bundleRawAppFiles({
+	files,
+	sharedUiFiles = {},
+	bundlerType = 'esbuild',
+	timeoutMs = DEFAULT_TIMEOUT_MS,
+	onLog
+}: BundleRawAppFilesParams): Promise<RawAppBundle> {
+	if (typeof window === 'undefined' || typeof document === 'undefined') {
+		return Promise.reject(new Error('Raw app bundling requires a browser environment.'))
+	}
+
+	return new Promise((resolve, reject) => {
+		const requestId = makeRequestId()
+		const iframe = document.createElement('iframe')
+		let settled = false
+		let bundleRequestSent = false
+
+		const cleanup = () => {
+			window.removeEventListener('message', onMessage)
+			clearTimeout(timeout)
+			iframe.remove()
+		}
+
+		const settle = <T>(fn: (value: T) => void, value: T) => {
+			if (settled) return
+			settled = true
+			cleanup()
+			fn(value)
+		}
+
+		const postToBundler = (message: Record<string, unknown>) => {
+			if (!iframe.contentWindow) {
+				settle(reject, new Error('Raw app bundler iframe did not initialize.'))
+				return
+			}
+			iframe.contentWindow.postMessage(message, window.location.origin)
+		}
+
+		const sendBundleProtocolRequest = () => {
+			if (settled || bundleRequestSent) return
+			bundleRequestSent = true
+			postToBundler({
+				type: 'bundleRawApp',
+				requestId,
+				files,
+				sharedUiFiles,
+				bundlerType
+			})
+		}
+
+		const timeout = window.setTimeout(() => {
+			settle(reject, new Error('Timed out while bundling raw app.'))
+		}, timeoutMs)
+
+		function onMessage(event: MessageEvent) {
+			if (event.source !== iframe.contentWindow) return
+			const data = event.data
+			if (!data) return
+
+			if (data.type === 'bundleRawAppReady') {
+				sendBundleProtocolRequest()
+				return
+			}
+
+			if (data.requestId !== requestId) return
+
+			if (data.type === 'appendLogs') {
+				onLog?.(String(data.delta ?? ''))
+			} else if (data.type === 'bundleRawAppResult') {
+				const bundle = data.bundle
+				if (!bundle?.js) {
+					settle(reject, new Error('Raw app bundler returned an empty JavaScript bundle.'))
+					return
+				}
+				settle(resolve, {
+					js: String(bundle.js),
+					css: String(bundle.css ?? '')
+				})
+			} else if (data.type === 'bundleRawAppError') {
+				settle(reject, new Error(String(data.error ?? 'Raw app bundle failed.')))
+			}
+		}
+
+		iframe.title = 'Raw app bundler'
+		iframe.tabIndex = -1
+		// Windmill pages use COEP=require-corp; the static UI builder iframe must be credentialless.
+		iframe.setAttribute('credentialless', '')
+		iframe.style.position = 'fixed'
+		iframe.style.width = '0'
+		iframe.style.height = '0'
+		iframe.style.border = '0'
+		iframe.style.opacity = '0'
+		iframe.style.pointerEvents = 'none'
+		iframe.src = '/ui_builder/index.html?mode=bundle'
+
+		window.addEventListener('message', onMessage)
+		document.body.appendChild(iframe)
+	})
+}
diff --git a/frontend/src/lib/components/copilot/chat/shared.test.ts b/frontend/src/lib/components/copilot/chat/shared.test.ts
index 69b868ee50..56b6bc4d2b 100644
--- a/frontend/src/lib/components/copilot/chat/shared.test.ts
+++ b/frontend/src/lib/components/copilot/chat/shared.test.ts
@@ -1,5 +1,6 @@
 import { describe, expect, it, vi } from 'vitest'
 import { z } from 'zod'
+import type { DisplayMessage, ToolDisplayMessage } from './shared'
 
 vi.mock('monaco-editor', () => ({
 	editor: {}
@@ -618,3 +619,65 @@ describe('processToolCall', () => {
 		)
 	})
 })
+
+describe('isActiveUserQuestion', () => {
+	function toolMessage(overrides: Partial<ToolDisplayMessage> = {}): ToolDisplayMessage {
+		return {
+			role: 'tool',
+			tool_call_id: 'call_q',
+			content: 'asking a question',
+			isLoading: true,
+			userQuestion: { question: 'Pick one', choices: ['a', 'b'] },
+			...overrides
+		}
+	}
+
+	it('is true for a loading tool message with an unanswered question', async () => {
+		const { isActiveUserQuestion } = await import('./shared')
+		expect(isActiveUserQuestion(toolMessage())).toBe(true)
+	})
+
+	it('is false once a choice has been selected', async () => {
+		const { isActiveUserQuestion } = await import('./shared')
+		expect(
+			isActiveUserQuestion(
+				toolMessage({
+					userQuestion: { question: 'Pick one', choices: ['a', 'b'], selectedChoice: 'a' }
+				})
+			)
+		).toBe(false)
+	})
+
+	it('is false when the question was canceled', async () => {
+		const { isActiveUserQuestion } = await import('./shared')
+		expect(
+			isActiveUserQuestion(
+				toolMessage({ userQuestion: { question: 'Pick one', choices: ['a', 'b'], canceled: true } })
+			)
+		).toBe(false)
+	})
+
+	it('is false when the tool errored', async () => {
+		const { isActiveUserQuestion } = await import('./shared')
+		expect(isActiveUserQuestion(toolMessage({ error: 'boom' }))).toBe(false)
+	})
+
+	it('is false when the tool is no longer loading', async () => {
+		const { isActiveUserQuestion } = await import('./shared')
+		expect(isActiveUserQuestion(toolMessage({ isLoading: false }))).toBe(false)
+	})
+
+	it('is false for a tool message without a question', async () => {
+		const { isActiveUserQuestion } = await import('./shared')
+		expect(isActiveUserQuestion(toolMessage({ userQuestion: undefined }))).toBe(false)
+	})
+
+	it('is false for non-tool messages and undefined', async () => {
+		const { isActiveUserQuestion } = await import('./shared')
+		const userMessage: DisplayMessage = { role: 'user', index: 0, content: 'hi' }
+		const assistantMessage: DisplayMessage = { role: 'assistant', content: 'hi' }
+		expect(isActiveUserQuestion(undefined)).toBe(false)
+		expect(isActiveUserQuestion(userMessage)).toBe(false)
+		expect(isActiveUserQuestion(assistantMessage)).toBe(false)
+	})
+})
diff --git a/frontend/src/lib/components/copilot/chat/shared.ts b/frontend/src/lib/components/copilot/chat/shared.ts
index 88ed20d664..7764b85f2f 100644
--- a/frontend/src/lib/components/copilot/chat/shared.ts
+++ b/frontend/src/lib/components/copilot/chat/shared.ts
@@ -19,7 +19,7 @@ import { get } from 'svelte/store'
 import type { CodePieceElement, ContextElement, FlowModuleCodePieceElement } from './context'
 import { workspaceStore } from '$lib/stores'
 import type { ExtendedOpenFlow } from '$lib/components/flows/types'
-import { findModuleInModules } from '$lib/components/flows/flowTree'
+import { findModuleInFlow, findModuleInModules } from '$lib/components/flows/flowTree'
 import type { FunctionParameters } from 'openai/resources/shared.mjs'
 import { z } from 'zod'
 import {
@@ -27,7 +27,9 @@ import {
 	FlowService,
 	JobService,
 	type CompletedJob,
+	type FlowValue,
 	type FlowModule,
+	type ScriptLang,
 	type Script,
 	type Flow
 } from '$lib/gen'
@@ -512,6 +514,22 @@ export type AssistantDisplayMessage = BaseDisplayMessage & {
 
 export type DisplayMessage = UserDisplayMessage | ToolDisplayMessage | AssistantDisplayMessage
 
+// A tool message whose askUserQuestion is still awaiting an answer: the AI loop
+// is paused on the user. Drives the question card's interactivity, the
+// "waiting for user" indicator, and disabling the main chat input — keep those
+// in sync by going through this single predicate.
+export function isActiveUserQuestion(message: DisplayMessage | undefined): boolean {
+	return Boolean(
+		message &&
+			message.role === 'tool' &&
+			message.userQuestion &&
+			message.isLoading &&
+			!message.error &&
+			!message.userQuestion.selectedChoice &&
+			!message.userQuestion.canceled
+	)
+}
+
 async function callTool<T>({
 	tools,
 	functionName,
@@ -1082,6 +1100,164 @@ export async function executeTestRun(config: TestRunConfig): Promise<string> {
 	}
 }
 
+type FlowStepScriptLoader = (
+	moduleValue: { path: string; hash?: string },
+	workspace: string
+) => Promise<{ content: string; language: ScriptLang }>
+
+type FlowStepPreviewLoader = (path: string, workspace: string) => Promise<FlowValue | undefined>
+
+export type FlowStepTestRunConfig = {
+	flowValue: FlowValue
+	stepId: string
+	args?: Record<string, any> | null
+	workspace: string
+	toolCallbacks: ToolCallbacks
+	toolId: string
+	loadScript?: FlowStepScriptLoader
+	loadFlowPreviewValue?: FlowStepPreviewLoader
+}
+
+function normalizeFlowStepArgs(args: Record<string, any> | null | undefined): Record<string, any> {
+	return args ?? {}
+}
+
+function flowStepArgsForModule(moduleId: string, args: Record<string, any>): Record<string, any> {
+	return moduleId === SPECIAL_MODULE_IDS.PREPROCESSOR
+		? { _ENTRYPOINT_OVERRIDE: 'preprocessor', ...args }
+		: args
+}
+
+function getAvailableFlowStepIds(flowValue: FlowValue): string {
+	return Array.from(
+		new Set([
+			...extractAllModules(flowValue.modules ?? []).map((module: FlowModule) => module.id),
+			...(flowValue.preprocessor_module ? [flowValue.preprocessor_module.id] : []),
+			...(flowValue.failure_module ? [flowValue.failure_module.id] : [])
+		])
+	).join(', ')
+}
+
+async function loadDeployedScriptForFlowStep(
+	moduleValue: { path: string; hash?: string },
+	workspace: string
+): Promise<{ content: string; language: ScriptLang }> {
+	const script = moduleValue.hash
+		? await ScriptService.getScriptByHash({ workspace, hash: moduleValue.hash })
+		: await ScriptService.getScriptByPath({ workspace, path: moduleValue.path })
+	return { content: script.content, language: script.language }
+}
+
+export async function executeFlowStepTestRun({
+	flowValue,
+	stepId,
+	args,
+	workspace,
+	toolCallbacks,
+	toolId,
+	loadScript = loadDeployedScriptForFlowStep,
+	loadFlowPreviewValue
+}: FlowStepTestRunConfig): Promise<string> {
+	const targetModule = findModuleInFlow(flowValue, stepId) ?? undefined
+
+	if (!targetModule) {
+		toolCallbacks.setToolStatus(toolId, {
+			content: `Step "${stepId}" not found in flow`,
+			error: `Step with id "${stepId}" does not exist in the current flow`
+		})
+		throw new Error(
+			`Step with id "${stepId}" not found in flow. Available steps: ${getAvailableFlowStepIds(flowValue)}`
+		)
+	}
+
+	const moduleValue = targetModule.value
+	const stepArgs = normalizeFlowStepArgs(args)
+
+	if (moduleValue.type === 'rawscript') {
+		return executeTestRun({
+			jobStarter: () =>
+				JobService.runScriptPreview({
+					workspace,
+					requestBody: {
+						content: moduleValue.content ?? '',
+						language: moduleValue.language,
+						args: flowStepArgsForModule(targetModule.id, stepArgs)
+					}
+				}),
+			workspace,
+			toolCallbacks,
+			toolId,
+			startMessage: `Starting test run of step "${stepId}"...`,
+			contextName: 'script'
+		})
+	}
+
+	if (moduleValue.type === 'script') {
+		const script = await loadScript(moduleValue, workspace)
+		return executeTestRun({
+			jobStarter: () =>
+				JobService.runScriptPreview({
+					workspace,
+					requestBody: {
+						path: moduleValue.path,
+						content: script.content,
+						language: script.language,
+						args: flowStepArgsForModule(targetModule.id, stepArgs)
+					}
+				}),
+			workspace,
+			toolCallbacks,
+			toolId,
+			startMessage: `Starting test run of script step "${stepId}"...`,
+			contextName: 'script'
+		})
+	}
+
+	if (moduleValue.type === 'flow') {
+		const previewValue = await loadFlowPreviewValue?.(moduleValue.path, workspace)
+		if (previewValue) {
+			return executeTestRun({
+				jobStarter: () =>
+					JobService.runFlowPreview({
+						workspace,
+						requestBody: {
+							path: moduleValue.path,
+							value: previewValue,
+							args: stepArgs
+						}
+					}),
+				workspace,
+				toolCallbacks,
+				toolId,
+				startMessage: `Starting test run of draft flow step "${stepId}"...`,
+				contextName: 'flow'
+			})
+		}
+
+		return executeTestRun({
+			jobStarter: () =>
+				JobService.runFlowByPath({
+					workspace,
+					path: moduleValue.path,
+					requestBody: stepArgs
+				}),
+			workspace,
+			toolCallbacks,
+			toolId,
+			startMessage: `Starting test run of flow step "${stepId}"...`,
+			contextName: 'flow'
+		})
+	}
+
+	toolCallbacks.setToolStatus(toolId, {
+		content: `Step type "${moduleValue.type}" not supported for testing`,
+		error: `Cannot test step of type "${moduleValue.type}"`
+	})
+	throw new Error(
+		`Cannot test step of type "${moduleValue.type}". Supported types: rawscript, script, flow`
+	)
+}
+
 function formatLogs(logs: string | undefined): undefined | string {
 	if (logs && logs.trim()) {
 		if (logs.length <= MAX_LOG_LENGTH) {
diff --git a/frontend/src/lib/components/copilot/fim.ts b/frontend/src/lib/components/copilot/fim.ts
new file mode 100644
index 0000000000..16c5d40431
--- /dev/null
+++ b/frontend/src/lib/components/copilot/fim.ts
@@ -0,0 +1,39 @@
+import type { AIProvider } from '$lib/gen'
+import { z } from 'zod'
+
+const chatFimResponseSchema = z.object({
+	choices: z.array(
+		z.object({
+			message: z.object({
+				content: z.string().optional()
+			}),
+			finish_reason: z.string().optional()
+		})
+	)
+})
+
+const deepseekFimResponseSchema = z.object({
+	choices: z.array(
+		z.object({
+			text: z.string().optional(),
+			finish_reason: z.string().optional()
+		})
+	)
+})
+
+export function parseFimCompletionChoice(
+	body: unknown,
+	provider: AIProvider
+): { content: string | undefined; finish_reason: string | undefined } | undefined {
+	if (provider === 'deepseek') {
+		const parsedBody = deepseekFimResponseSchema.parse(body)
+		const choice = parsedBody.choices[0]
+		return choice ? { content: choice.text, finish_reason: choice.finish_reason } : undefined
+	}
+
+	const parsedBody = chatFimResponseSchema.parse(body)
+	const choice = parsedBody.choices[0]
+	return choice
+		? { content: choice.message.content, finish_reason: choice.finish_reason }
+		: undefined
+}
diff --git a/frontend/src/lib/components/copilot/lib.test.ts b/frontend/src/lib/components/copilot/lib.test.ts
index f1eec17cbb..369987d53f 100644
--- a/frontend/src/lib/components/copilot/lib.test.ts
+++ b/frontend/src/lib/components/copilot/lib.test.ts
@@ -9,7 +9,9 @@ import {
 	buildAssistantToolCallMessage,
 	getReasoningContentDelta
 } from './chat/openaiReasoning'
+import { parseFimCompletionChoice } from './fim'
 import { getDefaultChatTemperature, modelDisallowsSamplingParams } from './modelConfig'
+import { supportsAutocomplete } from './utils'
 
 type AssistantMessageWithReasoning = ChatCompletionMessageParam & {
 	role: 'assistant'
@@ -43,6 +45,48 @@ describe('modelConfig', () => {
 	})
 })
 
+describe('fim autocomplete', () => {
+	it('allows DeepSeek v4 pro and Codestral autocomplete models', () => {
+		expect(supportsAutocomplete('codestral-latest')).toBe(true)
+		expect(supportsAutocomplete('Codestral-2501')).toBe(true)
+		expect(supportsAutocomplete('codestral-embed')).toBe(false)
+		expect(supportsAutocomplete('deepseek-v4-pro')).toBe(true)
+		expect(supportsAutocomplete('deepseek-chat')).toBe(false)
+	})
+
+	it('parses chat-shaped native FIM responses', () => {
+		expect(
+			parseFimCompletionChoice(
+				{
+					choices: [
+						{
+							message: { content: 'cache[key] = factory()' },
+							finish_reason: 'stop'
+						}
+					]
+				},
+				'mistral'
+			)
+		).toEqual({ content: 'cache[key] = factory()', finish_reason: 'stop' })
+	})
+
+	it('parses DeepSeek native FIM completion responses', () => {
+		expect(
+			parseFimCompletionChoice(
+				{
+					choices: [
+						{
+							text: 'items?.length ?? 0',
+							finish_reason: 'stop'
+						}
+					]
+				},
+				'deepseek'
+			)
+		).toEqual({ content: 'items?.length ?? 0', finish_reason: 'stop' })
+	})
+})
+
 describe('openaiReasoning', () => {
 	it('reads provider-specific reasoning_content deltas', () => {
 		expect(
diff --git a/frontend/src/lib/components/copilot/lib.ts b/frontend/src/lib/components/copilot/lib.ts
index de87579a23..00d2334acc 100644
--- a/frontend/src/lib/components/copilot/lib.ts
+++ b/frontend/src/lib/components/copilot/lib.ts
@@ -16,7 +16,6 @@ import { OpenAPI, ResourceService, type Script } from '../../gen'
 import { EDIT_CONFIG, FIX_CONFIG, GEN_CONFIG } from './prompts'
 import { getDefaultChatTemperature } from './modelConfig'
 import { formatResourceTypes } from './utils'
-import { z } from 'zod'
 import { processToolCall, type Tool, type ToolCallbacks } from './chat/shared'
 import {
 	getNonStreamingOpenAIResponsesCompletion,
@@ -36,6 +35,7 @@ import {
 	buildAssistantToolCallMessage,
 	getReasoningContentDelta
 } from './chat/openaiReasoning'
+import { parseFimCompletionChoice } from './fim'
 
 export const SUPPORTED_LANGUAGES = new Set(Object.keys(GEN_CONFIG.prompts))
 
@@ -74,7 +74,7 @@ export const AI_PROVIDERS: Record<AIProvider, AIProviderDetails> = {
 	},
 	deepseek: {
 		label: 'DeepSeek',
-		defaultModels: ['deepseek-chat', 'deepseek-reasoner']
+		defaultModels: ['deepseek-v4-pro', 'deepseek-chat', 'deepseek-reasoner']
 	},
 	googleai: {
 		label: 'Google AI',
@@ -816,17 +816,6 @@ export async function getNonStreamingCompletion(
 	return response
 }
 
-const mistralFimResponseSchema = z.object({
-	choices: z.array(
-		z.object({
-			message: z.object({
-				content: z.string().optional()
-			}),
-			finish_reason: z.string()
-		})
-	)
-})
-
 export const FIM_MAX_TOKENS = 256
 const FIM_MAX_LINES = 8
 export async function getFimCompletion(
@@ -864,12 +853,10 @@ export async function getFimCompletion(
 	)
 
 	const body = await response.json()
-	const parsedBody = mistralFimResponseSchema.parse(body)
+	const choice = parseFimCompletionChoice(body, providerModel.provider)
 
-	const choice = parsedBody.choices[0]
-
-	if (choice && choice.message.content !== undefined) {
-		let lines = choice.message.content.split('\n')
+	if (choice?.content !== undefined) {
+		let lines = choice.content.split('\n')
 
 		// If finish_reason is 'length', remove the last line
 		if (choice.finish_reason === 'length') {
diff --git a/frontend/src/lib/components/copilot/utils.ts b/frontend/src/lib/components/copilot/utils.ts
index 8e5150cda6..50f6513b26 100644
--- a/frontend/src/lib/components/copilot/utils.ts
+++ b/frontend/src/lib/components/copilot/utils.ts
@@ -171,10 +171,9 @@ export function yamlStringifyExceptKeys(obj: any, keys: string[]) {
 
 /**
  * Checks if a model supports FIM (Fill-in-the-Middle) autocomplete.
- * Currently only Codestral models (non-embedding) support this.
+ * Currently Codestral models (non-embedding) and DeepSeek FIM support this.
  */
 export function supportsAutocomplete(model: string): boolean {
 	const lower = model.toLowerCase()
-	return lower.includes('codestral') && !lower.includes('embed')
+	return (lower.includes('codestral') && !lower.includes('embed')) || lower === 'deepseek-v4-pro'
 }
-
diff --git a/frontend/src/lib/components/flows/FlowEditor.svelte b/frontend/src/lib/components/flows/FlowEditor.svelte
index 91afa77b58..ea32afdc52 100644
--- a/frontend/src/lib/components/flows/FlowEditor.svelte
+++ b/frontend/src/lib/components/flows/FlowEditor.svelte
@@ -13,7 +13,11 @@
 	import type { Flow, Job } from '$lib/gen'
 	import type { Trigger } from '$lib/components/triggers/utils'
 	import FlowAIChat from '../copilot/chat/flow/FlowAIChat.svelte'
-	import { aiChatManager, AIMode } from '../copilot/chat/AIChatManager.svelte'
+	import {
+		AIChatManager,
+		aiChatManager as singletonAiChatManager,
+		AIMode
+	} from '../copilot/chat/AIChatManager.svelte'
 	import type { GraphModuleState } from '../graph'
 	import { triggerableByAI } from '$lib/actions/triggerableByAI.svelte'
 	import type { ModulesTestStates } from '../modulesTest.svelte'
@@ -22,6 +26,8 @@
 	import { extractAllModules } from '../copilot/chat/shared'
 	import type { Snippet } from 'svelte'
 	const { flowStore } = getContext<FlowEditorContext>('FlowEditorContext')
+	const sessionScopedManager = getContext<AIChatManager>('aiChatManager')
+	const aiChatManager = sessionScopedManager ?? singletonAiChatManager
 
 	interface Props {
 		loading: boolean
@@ -132,14 +138,18 @@
 	})
 
 	onMount(() => {
-		aiChatManager.saveAndClear()
-		aiChatManager.changeMode(AIMode.FLOW)
+		if (!sessionScopedManager) {
+			aiChatManager.saveAndClear()
+			aiChatManager.changeMode(AIMode.FLOW)
+		}
 	})
 
 	onDestroy(() => {
 		aiChatManager.flowOptions = undefined
-		aiChatManager.saveAndClear()
-		aiChatManager.changeMode(AIMode.NAVIGATOR)
+		if (!sessionScopedManager) {
+			aiChatManager.saveAndClear()
+			aiChatManager.changeMode(AIMode.NAVIGATOR)
+		}
 	})
 </script>
 
diff --git a/frontend/src/lib/components/flows/content/FlowModuleComponent.svelte b/frontend/src/lib/components/flows/content/FlowModuleComponent.svelte
index 2b9f4a09f1..56a594ff1e 100644
--- a/frontend/src/lib/components/flows/content/FlowModuleComponent.svelte
+++ b/frontend/src/lib/components/flows/content/FlowModuleComponent.svelte
@@ -867,6 +867,7 @@
 														bind:this={editor}
 														class="h-full relative"
 														code={flowModule.value.content}
+														syncExternalCode
 														scriptLang={flowModule?.value?.language}
 														automaticLayout={true}
 														cmdEnterAction={async () => {
@@ -930,6 +931,7 @@
 												bind:this={editor}
 												class="h-full relative"
 												code={flowModule.value.content}
+												syncExternalCode
 												scriptLang={flowModule?.value?.language}
 												automaticLayout={true}
 												cmdEnterAction={async () => {
diff --git a/frontend/src/lib/components/flows/content/FlowModuleWorkerTagSelect.svelte b/frontend/src/lib/components/flows/content/FlowModuleWorkerTagSelect.svelte
index 8926863c30..139251d062 100644
--- a/frontend/src/lib/components/flows/content/FlowModuleWorkerTagSelect.svelte
+++ b/frontend/src/lib/components/flows/content/FlowModuleWorkerTagSelect.svelte
@@ -34,7 +34,7 @@
 {#if $workerTags}
 	{#if $workerTags?.length > 0}
 		<div class="w-40">
-			{#if flowStore.val.tag == undefined || isPreprocessor}
+			{#if flowStore.val.tag == undefined || isPreprocessor || flowStore.val.value?.preserve_step_tags}
 				<WorkerTagSelect
 					{noLabel}
 					{placeholder}
diff --git a/frontend/src/lib/components/flows/content/FlowSettings.svelte b/frontend/src/lib/components/flows/content/FlowSettings.svelte
index 3c6b268e00..c8ebc9c9ae 100644
--- a/frontend/src/lib/components/flows/content/FlowSettings.svelte
+++ b/frontend/src/lib/components/flows/content/FlowSettings.svelte
@@ -63,7 +63,14 @@
 	let displayWorkerTagPicker = $state(false)
 
 	run(() => {
-		flowStore.val.tag ? (displayWorkerTagPicker = true) : null
+		if (flowStore.val.tag) {
+			displayWorkerTagPicker = true
+		} else if (flowStore.val.value.preserve_step_tags) {
+			// preserve_step_tags has no effect without a flow worker tag; clear it so it
+			// doesn't linger as invisible state when the tag is removed via any path
+			// (the picker, the toggle, or the YAML editor).
+			flowStore.val.value.preserve_step_tags = undefined
+		}
 	})
 
 	let activeAdvancedOptions = $derived([
@@ -78,6 +85,7 @@
 		{ name: 'Error Handler Muted', active: Boolean(flowStore.val.ws_error_handler_muted) },
 		{ name: 'Invisible to Others', active: Boolean(flowStore.val.visible_to_runner_only) },
 		{ name: 'Shared Directory', active: Boolean(flowStore.val.value.same_worker) },
+		{ name: 'Preserve Step Tags', active: Boolean(flowStore.val.value.preserve_step_tags) },
 		{ name: 'Cache Results', active: Boolean(flowStore.val.value.cache_ttl) },
 		{ name: 'Early Stop', active: Boolean(flowStore.val.value.skip_expr) },
 		{ name: 'Early Return', active: Boolean(flowStore.val.value.early_return) },
@@ -182,6 +190,8 @@
 							on:change={() => {
 								displayWorkerTagPicker = !displayWorkerTagPicker
 								if (!displayWorkerTagPicker) {
+									// Clearing the tag triggers the reactive block above, which also
+									// resets preserve_step_tags so it doesn't linger as invisible state.
 									flowStore.val.tag = undefined
 								}
 							}}
@@ -197,6 +207,25 @@
 							<div transition:slide={{ duration: 120 }} class="mt-2">
 								<WorkerTagPicker bind:tag={flowStore.val.tag} popupPlacement="top-end" />
 							</div>
+							{#if flowStore.val.tag}
+								<div
+									transition:slide={{ duration: 120 }}
+									class="mt-2 pl-4 border-l border-surface-selected"
+								>
+									<Toggle
+										textClass="font-medium"
+										size="xs"
+										bind:checked={flowStore.val.value.preserve_step_tags}
+										options={{
+											right: 'Preserve step worker tags',
+											rightTooltip:
+												'By default the flow worker tag above is propagated to and overrides every step, script and nested sub-flow. Enable this to instead let steps that declare their own worker tag run on it. Steps without their own tag still inherit the flow tag.',
+											rightDocumentationLink:
+												'https://www.windmill.dev/docs/core_concepts/worker_groups'
+										}}
+									/>
+								</div>
+							{/if}
 						{/if}
 					</div>
 
diff --git a/frontend/src/lib/components/graph/FlowGraphV2.svelte b/frontend/src/lib/components/graph/FlowGraphV2.svelte
index 563a387184..fbe07ac7b8 100644
--- a/frontend/src/lib/components/graph/FlowGraphV2.svelte
+++ b/frontend/src/lib/components/graph/FlowGraphV2.svelte
@@ -200,6 +200,9 @@
 		markRemovedAsShadowed?: boolean
 		controlsPosition?: 'top' | 'bottom'
 		outerDivClass?: string
+		/** Fires when the computed graph height changes. Diff views can use
+		 * this to equalize heights of side-by-side graphs. */
+		onHeight?: (height: number) => void
 	}
 
 	let {
@@ -273,7 +276,8 @@
 		onMoveMultiple = undefined,
 		movingIds = undefined,
 		controlsPosition = 'top',
-		outerDivClass = ''
+		outerDivClass = '',
+		onHeight = undefined
 	}: Props = $props()
 
 	// Initialize note manager with fine-grained reactivity
@@ -759,6 +763,7 @@
 			const computed = maxBottom - minY
 			height = Math.max(Math.min(computed, maxHeight ?? computed), minHeight)
 		}
+		onHeight?.(height)
 	}
 
 	$effect(() => {
diff --git a/frontend/src/lib/components/graph/renderers/nodes/AssetNode.svelte b/frontend/src/lib/components/graph/renderers/nodes/AssetNode.svelte
index 50e4f9c87a..0d5a9a14ea 100644
--- a/frontend/src/lib/components/graph/renderers/nodes/AssetNode.svelte
+++ b/frontend/src/lib/components/graph/renderers/nodes/AssetNode.svelte
@@ -63,7 +63,7 @@
 					type: 'asset' as const,
 					parentId: node.id,
 					data: { asset, displayedAccessType: 'r' },
-					id: `${node.id}-asset-in-${asset.kind}-${asset.path}`,
+					id: `${node.id}-asset-in-${asset.kind}-${asset.path}-${i}`,
 					width: inputAssetWidth,
 					position: {
 						x:
@@ -100,7 +100,7 @@
 					type: 'asset' as const,
 					parentId: node.id,
 					data: { asset, displayedAccessType: 'w' },
-					id: `${node.id}-asset-out-${asset.kind}-${asset.path}`,
+					id: `${node.id}-asset-out-${asset.kind}-${asset.path}-${i}`,
 					width: outputAssetWidth,
 					position: {
 						x:
@@ -136,7 +136,7 @@
 			allAssetNodes.push(...(inputAssetNodes ?? []), ...(outputAssetNodes ?? []))
 
 			// If there are more than 3 assets, we create an overflow node
-			if (overflowedInputAssets.length)
+			if (overflowedInputAssets.length) {
 				allAssetNodes.push({
 					type: 'assetsOverflowed',
 					data: { overflowedAssets: overflowedInputAssets, displayedAccessType: 'r' },
@@ -148,14 +148,15 @@
 						y: READ_ASSET_Y_OFFSET
 					}
 				} satisfies Node & AssetsOverflowedN)
-			allAssetEdges.push({
-				id: `${node.id}-assets-overflowed-in-edge`,
-				source: `${node.id}-assets-overflowed-in`,
-				target: node.id,
-				type: 'empty',
-				data: { class: '!opacity-35 dark:!opacity-20' }
-			})
-			if (overflowedOutputAssets.length)
+				allAssetEdges.push({
+					id: `${node.id}-assets-overflowed-in-edge`,
+					source: `${node.id}-assets-overflowed-in`,
+					target: node.id,
+					type: 'empty',
+					data: { class: '!opacity-35 dark:!opacity-20' }
+				})
+			}
+			if (overflowedOutputAssets.length) {
 				allAssetNodes.push({
 					type: 'assetsOverflowed',
 					data: { overflowedAssets: overflowedOutputAssets, displayedAccessType: 'w' },
@@ -167,13 +168,14 @@
 						y: WRITE_ASSET_Y_OFFSET
 					}
 				} satisfies Node & AssetsOverflowedN)
-			allAssetEdges.push({
-				id: `${node.id}-assets-overflowed-out-edge`,
-				source: node.id,
-				target: `${node.id}-assets-overflowed-out`,
-				type: 'empty',
-				data: { class: '!opacity-35 dark:!opacity-25' }
-			})
+				allAssetEdges.push({
+					id: `${node.id}-assets-overflowed-out-edge`,
+					source: node.id,
+					target: `${node.id}-assets-overflowed-out`,
+					type: 'empty',
+					data: { class: '!opacity-35 dark:!opacity-25' }
+				})
+			}
 		}
 
 		let ret: ReturnType<typeof computeAssetNodes> = {
@@ -274,8 +276,8 @@
 					<Tooltip class={'pr-1 flex items-center justify-center'}>
 						<AlertTriangle size={16} class="text-orange-500" />
 						{#snippet text()}
-												Could not find resource
-											{/snippet}
+							Could not find resource
+						{/snippet}
 					</Tooltip>
 				{:else if isSelected && assetCanBeExplored(data.asset, cachedResourceMetadata) && !$userStore?.operator}
 					<div transition:slide={{ axis: 'x', duration: 100 }}>
@@ -291,29 +293,27 @@
 				{/if}
 			</div>
 			{#snippet text()}
-					
-					{#if usageCount !== undefined}
-						Used in {pluralize(usageCount, 'step')}<br />
-					{/if}
-					<a
-						href={undefined}
-						class={twMerge(
-							'text-xs',
-							data.asset.kind === 'resource' ? 'text-accent cursor-pointer' : 'text-hint'
-						)}
-						onclick={() => {
-							if (data.asset.kind === 'resource')
-								flowGraphAssetsCtx?.val.resourceEditorDrawer?.initEdit(data.asset.path)
-						}}
-					>
-						{data.asset.path}
-					</a><br />
-					<span class="text-hint text-xs">
-						{formatAssetKind({ ...data.asset, metadata: cachedResourceMetadata })}</span
-					>
-					<AssetColumnBadges columns={assetColumns} disableTooltip />
-				
-					{/snippet}
+				{#if usageCount !== undefined}
+					Used in {pluralize(usageCount, 'step')}<br />
+				{/if}
+				<a
+					href={undefined}
+					class={twMerge(
+						'text-xs',
+						data.asset.kind === 'resource' ? 'text-accent cursor-pointer' : 'text-hint'
+					)}
+					onclick={() => {
+						if (data.asset.kind === 'resource')
+							flowGraphAssetsCtx?.val.resourceEditorDrawer?.initEdit(data.asset.path)
+					}}
+				>
+					{data.asset.path}
+				</a><br />
+				<span class="text-hint text-xs">
+					{formatAssetKind({ ...data.asset, metadata: cachedResourceMetadata })}</span
+				>
+				<AssetColumnBadges columns={assetColumns} disableTooltip />
+			{/snippet}
 		</Tooltip>
 	{/snippet}
 </NodeWrapper>
diff --git a/frontend/src/lib/components/graph/renderers/nodes/assetNode.test.ts b/frontend/src/lib/components/graph/renderers/nodes/assetNode.test.ts
new file mode 100644
index 0000000000..14fd5e24e3
--- /dev/null
+++ b/frontend/src/lib/components/graph/renderers/nodes/assetNode.test.ts
@@ -0,0 +1,51 @@
+import { describe, it, expect, vi } from 'vitest'
+
+// Mock heavy transitive imports pulled in by AssetNode.svelte's instance script
+vi.mock('monaco-editor', () => ({}))
+vi.mock('$lib/components/meltComponents', () => ({ Tooltip: {} }))
+vi.mock('../../../ExploreAssetButton.svelte', () => ({
+	default: {},
+	assetCanBeExplored: () => false
+}))
+vi.mock('$lib/components/icons/AssetGenericIcon.svelte', () => ({ default: {} }))
+vi.mock('$lib/components/assets/AssetColumnBadges.svelte', () => ({ default: {} }))
+vi.mock('./NodeWrapper.svelte', () => ({ default: {} }))
+
+import { computeAssetNodes } from './AssetNode.svelte'
+
+function nodeWithAssets(id: string, assets: any[]) {
+	return { id, position: { x: 0, y: 0 }, data: { assets } }
+}
+
+describe('computeAssetNodes (WIN-1998)', () => {
+	it('produces unique node and edge ids when a module lists the same asset twice', () => {
+		// Two assets with identical kind+path (e.g. read twice, or r + rw) — both
+		// display as inputs. Before the fix these collided on the same node id and
+		// crashed SvelteFlow with `each_key_duplicate`.
+		const dup = { kind: 'resource', path: 'f/foo/bar', access_type: 'r' }
+		const { newAssetNodes, newAssetEdges } = computeAssetNodes([
+			nodeWithAssets('moduleA', [{ ...dup }, { ...dup }])
+		])
+
+		const nodeIds = newAssetNodes.map((n) => n.id)
+		expect(new Set(nodeIds).size).toBe(nodeIds.length)
+
+		const edgeIds = newAssetEdges.map((e) => e.id)
+		expect(new Set(edgeIds).size).toBe(edgeIds.length)
+	})
+
+	it('does not emit overflow edges when there is no overflow node (<=3 assets)', () => {
+		const { newAssetNodes, newAssetEdges } = computeAssetNodes([
+			nodeWithAssets('moduleB', [{ kind: 'resource', path: 'f/a/x', access_type: 'r' }])
+		])
+
+		// No overflow node should be created for a single asset...
+		expect(newAssetNodes.some((n) => n.type === 'assetsOverflowed')).toBe(false)
+		// ...and therefore no dangling edge should reference a missing overflow node.
+		const nodeIdSet = new Set(newAssetNodes.map((n) => n.id).concat('moduleB'))
+		for (const e of newAssetEdges) {
+			expect(nodeIdSet.has(e.source as string)).toBe(true)
+			expect(nodeIdSet.has(e.target as string)).toBe(true)
+		}
+	})
+})
diff --git a/frontend/src/lib/components/markdownPlugins.ts b/frontend/src/lib/components/markdownPlugins.ts
new file mode 100644
index 0000000000..4495619868
--- /dev/null
+++ b/frontend/src/lib/components/markdownPlugins.ts
@@ -0,0 +1,30 @@
+import type { Plugin } from 'svelte-exmarkdown'
+import { gfmPlugin } from 'svelte-exmarkdown/gfm'
+import rehypeRaw from 'rehype-raw'
+import rehypeSanitize from 'rehype-sanitize'
+import { rehypeGithubAlerts } from 'rehype-github-alerts'
+
+/**
+ * Shared plugin chain for rendering user-supplied Markdown (script/flow/resource
+ * descriptions, flow-graph notes, the App "Markdown" component, ...).
+ *
+ * Order matters and is security-sensitive:
+ *  1. `gfmPlugin`          — GitHub-flavored Markdown.
+ *  2. `rehypeRaw`          — re-parses embedded raw HTML into live hast nodes.
+ *  3. `rehypeSanitize`     — strips dangerous nodes (`<script>`, `<iframe>`,
+ *                            `<svg><script>`, `on*` handlers, `javascript:` URLs)
+ *                            from the raw-parsed tree. Without this stage the raw
+ *                            HTML reaches the DOM and executes (stored XSS).
+ *  4. `rehypeGithubAlerts` — runs AFTER sanitize so the trusted alert markup it
+ *                            injects (including inline SVG icons) is preserved
+ *                            without having to allowlist SVG for user input.
+ *
+ * Any Markdown sink that renders user input MUST use this chain rather than
+ * assembling its own `rehypeRaw` pipeline.
+ */
+export const markdownPlugins: Plugin[] = [
+	gfmPlugin(),
+	{ rehypePlugin: [rehypeRaw] },
+	{ rehypePlugin: [rehypeSanitize] },
+	{ rehypePlugin: [rehypeGithubAlerts] }
+]
diff --git a/frontend/src/lib/components/raw_apps/RawAppEditor.svelte b/frontend/src/lib/components/raw_apps/RawAppEditor.svelte
index 7249f0ae05..8121ca8b70 100644
--- a/frontend/src/lib/components/raw_apps/RawAppEditor.svelte
+++ b/frontend/src/lib/components/raw_apps/RawAppEditor.svelte
@@ -66,6 +66,9 @@
 			  }
 			| undefined
 		diffDrawer?: DiffDrawer | undefined
+		onNavigate?: (item: import('$lib/components/workspacePicker').WorkspaceItem) => void
+		/** Fired after a successful deploy; the session preview reloads on it. */
+		onDeploy?: (e: { path: string }) => void
 		/** Initial collapsed state for the file/runnable sidebar. The user's
 		 * toggled preference is persisted under `sidebarStorageKey`; this prop
 		 * only seeds the very first open. */
@@ -75,6 +78,14 @@
 		 * preference. */
 		sidebarStorageKey?: string
 		liveEditorDraftStoragePath?: string
+		/** Initial value for the "Split with Preview" tab-bar toggle. Defaults
+		 * to `true` (split mode, preview always pinned to the right). Set
+		 * `false` when the editor mounts inside a context that wants single-
+		 * view by default with the Preview tab selected — e.g. session
+		 * previews, where the editor pane is already narrow. The user can
+		 * still toggle the mode after mount; this prop only seeds the
+		 * initial state. */
+		defaultSplitWithPreview?: boolean
 	}
 
 	let {
@@ -88,9 +99,12 @@
 		newPath = undefined,
 		savedApp = $bindable(undefined),
 		diffDrawer = undefined,
+		onNavigate,
+		onDeploy = undefined,
 		defaultSidebarCollapsed = false,
 		sidebarStorageKey = 'raw-app-sidebar-collapsed',
-		liveEditorDraftStoragePath = undefined
+		liveEditorDraftStoragePath = undefined,
+		defaultSplitWithPreview = true
 	}: Props = $props()
 	export const version: number | undefined = undefined
 
@@ -225,7 +239,9 @@
 	}
 	let tabs: TabItem[] = $state([previewTab])
 	let activeTabId: string = $state(PREVIEW_TAB_ID)
-	let splitWithPreview: boolean = $state(true)
+	// Seed from the prop, then own the state locally so the user's toggle
+	// after mount sticks even if the prop reference changes.
+	let splitWithPreview: boolean = $state(untrack(() => defaultSplitWithPreview))
 	const activeTabKind = $derived<'file' | 'runnable' | 'preview'>(
 		activeTabId === PREVIEW_TAB_ID
 			? 'preview'
@@ -255,11 +271,23 @@
 	const showRunnable = $derived(activeTabKind === 'runnable')
 	// Mount the UI Builder iframe the first time a file is shown (paneA has
 	// width then; mounting it at 0-width breaks the VS Code workbench), and
-	// keep it mounted so tab switches don't reload it.
+	// keep it mounted so tab switches don't reload it. Mount it as soon as
+	// either pane needs it: `showSource` for the source-editor view, OR the
+	// preview tab is active — the Preview iframe is fed by `preview`
+	// postMessages bundled by the UI Builder iframe, so it needs to be
+	// mounted even when the user opens the editor straight on Preview (e.g.
+	// session previews seeded with `defaultSplitWithPreview=false`).
 	let iframeShouldMount = $state(false)
 	$effect(() => {
-		if (showSource) iframeShouldMount = true
+		if (showSource || activeTabKind === 'preview') iframeShouldMount = true
 	})
+	// Width of the editor area (both inner panes). The UI Builder iframe is
+	// pre-mounted while it's the inactive tab so the editor is ready instantly;
+	// but the VS Code workbench inside crashes if it boots at 0 size. So while
+	// inactive we keep the iframe at this real width and hide it with
+	// `visibility` instead of collapsing it — Monaco boots correctly and
+	// revealing a file is just an unhide (no reload, no relayout, no latency).
+	let editorAreaWidth = $state(0)
 
 	// Inner pane sizes are a pure function of mode + active tab → derived.
 	// `paneARatio` is the user's last manual split drag (set by rememberPaneDrag).
@@ -994,7 +1022,11 @@
 					ensureFileTab(selectedDocument)
 					// Don't auto-activate — the user's tab choice wins.
 					// But if no file tab is currently active, fall in line.
-					if (activeTabKind === 'preview' && tabs.length === 2) {
+					// Skip this auto-activation in single-view-with-preview
+					// mode (the caller seeded `defaultSplitWithPreview=false`
+					// because Preview is the intended starting tab); the
+					// iframe's first setActiveDocument shouldn't fight that.
+					if (splitWithPreview && activeTabKind === 'preview' && tabs.length === 2) {
 						activateTab(id)
 					}
 				}
@@ -1158,9 +1190,14 @@
 		})
 	})
 
-	// Open a default file on mount (boots the iframe; avoids a blank preview).
-	// Layout isn't persisted — each open starts fresh in split mode.
+	// Open a default file on mount (boots the iframe in split mode and gives
+	// the user something to edit on the left). When the caller seeded
+	// `defaultSplitWithPreview=false` we instead want the Preview tab as the
+	// only-visible / active surface, so skip the file-tab activation — the
+	// iframe still boots via `populateFiles`/`setFilesInIframe` even without
+	// a selected document.
 	onMount(() => {
+		if (!splitWithPreview) return
 		if (tabs.length === 1) {
 			const def = pickDefaultFile(files)
 			if (def) activateTab(ensureFileTab(def))
@@ -1332,6 +1369,8 @@
 		{data}
 		{runnables}
 		{getBundle}
+		{onNavigate}
+		{onDeploy}
 		canUndo={historyManager.canUndo}
 		canRedo={historyManager.canRedo}
 		onUndo={handleUndo}
@@ -1415,6 +1454,7 @@
 				Preview previously hid every tab.
 			-->
 				<div
+					bind:clientWidth={editorAreaWidth}
 					class="h-full w-full min-h-0 {splitWithPreview && activeTabKind !== 'preview'
 						? 'tabs-content-split'
 						: 'tabs-content-single'}"
@@ -1448,7 +1488,21 @@
 									{/snippet}
 								</DraggableTabs>
 								<div class="flex-1 min-h-0 relative">
-									<div class="absolute inset-0" style="display: {showSource ? 'block' : 'none'}">
+									<!--
+									Keep the UI Builder iframe mounted at a real (non-zero) size even
+									when it isn't the active tab: a hidden 0×0 mount crashes the VS
+									Code workbench's layout ("Unable to figure out browser width and
+									height") and wedges it on "Loading editor" with no recovery. While
+									inactive we size it to the editor area's width and hide it with
+									`visibility` (not `display`), so Monaco boots correctly and
+									revealing a file is an instant unhide.
+									-->
+									<div
+										class="absolute inset-0"
+										style={showSource
+											? ''
+											: `right: auto; width: ${editorAreaWidth || 800}px; visibility: hidden; pointer-events: none;`}
+									>
 										{#if iframeShouldMount}
 											<iframe
 												bind:this={iframe}
diff --git a/frontend/src/lib/components/raw_apps/RawAppEditorHeader.svelte b/frontend/src/lib/components/raw_apps/RawAppEditorHeader.svelte
index 495a4ebcc1..7f9e8e9807 100644
--- a/frontend/src/lib/components/raw_apps/RawAppEditorHeader.svelte
+++ b/frontend/src/lib/components/raw_apps/RawAppEditorHeader.svelte
@@ -2,7 +2,7 @@
 	import { Drawer, DrawerContent } from '$lib/components/common'
 	import Button from '$lib/components/common/button/Button.svelte'
 	import { isMac, userPathPrefix } from '$lib/utils'
-	import { editPathFor, invalidate as invalidatePicker } from '$lib/components/workspacePicker'
+	import { editPathFor } from '$lib/components/workspacePicker'
 	import { invalidateWorkspacePaths } from '$lib/components/PathNameAutocomplete.svelte'
 
 	import { AppService, DraftService, type Policy } from '$lib/gen'
@@ -66,6 +66,13 @@
 	// session-pane PR lands. Untyped getContext to avoid coupling to the
 	// AIChatManager class export (which lives on the chat-visuals PR).
 	const inSessionPane = !!getContext('aiChatManager')
+	// In a session pane the editor does NOT own the localStorage draft — the
+	// session runtime does, keyed by the session's (fork) workspace. So the
+	// `if (!inSessionPane) UserDraft.remove(...)` guards below skip the editor's
+	// own removal (it would target the wrong, main-`$workspaceStore` key). The
+	// session-side equivalent is RawAppEditorView's `onDeploy` →
+	// `runtime.syncPreviewWithDeployed`, which discards the fork draft + reloads
+	// the preview to the deployed version.
 	import { AIBtnClasses } from '../copilot/chat/AIButtonStyle'
 	import type { RawAppData } from './dataTableRefUtils'
 	import { isRuleActive } from '$lib/workspaceProtectionRules.svelte'
@@ -125,7 +132,10 @@
 		onOpenYamlEditor?: () => void
 		sidebarCollapsed?: boolean
 		onToggleSidebar?: () => void
+		onNavigate?: (item: import('$lib/components/workspacePicker').WorkspaceItem) => void
 		liveEditorDraftStoragePath?: string
+		// Fired after a successful deploy; lets the session preview reload.
+		onDeploy?: (e: { path: string }) => void
 	}
 
 	let {
@@ -150,13 +160,15 @@
 		onOpenYamlEditor = undefined,
 		sidebarCollapsed = false,
 		onToggleSidebar = undefined,
-		liveEditorDraftStoragePath = undefined
+		onNavigate = undefined,
+		liveEditorDraftStoragePath = undefined,
+		onDeploy = undefined
 	}: Props = $props()
 
 	let newEditedPath = $state(
 		untrack(() =>
 			newApp
-				? userPathPrefix($userStore?.username) + random_adj() + '_app'
+				? newPath || userPathPrefix($userStore?.username) + random_adj() + '_app'
 				: newPath || appPath || ''
 		)
 	)
@@ -285,8 +297,9 @@
 			}
 			closeSaveDrawer()
 			sendUserToast('App deployed successfully')
-			UserDraft.remove('raw_app', path)
+			if (!inSessionPane) UserDraft.remove('raw_app', path)
 			dispatch('savedNewAppPath', path)
+			onDeploy?.({ path })
 		} catch (e) {
 			sendUserToast(`Error creating app: ${e.body ?? e.message}`, true)
 		}
@@ -380,7 +393,6 @@
 				css
 			}
 		})
-		invalidatePicker($workspaceStore!, 'app')
 		invalidateWorkspacePaths($workspaceStore!)
 		savedApp = {
 			summary: summary,
@@ -397,10 +409,11 @@
 
 		closeSaveDrawer()
 		sendUserToast('App deployed successfully')
-		UserDraft.remove('raw_app', appPath)
+		if (!inSessionPane) UserDraft.remove('raw_app', appPath)
 		if (appPath !== npath) {
 			dispatch('savedNewAppPath', npath)
 		}
+		onDeploy?.({ path: npath })
 	}
 
 	async function setPublishState() {
@@ -479,7 +492,7 @@
 			// The initial draft was promoted to a real path on the backend —
 			// drop the autosave keyed on the prior (possibly empty) path so
 			// a future "+ App" click opens on a clean slate.
-			UserDraft.remove('raw_app', appPath)
+			if (!inSessionPane) UserDraft.remove('raw_app', appPath)
 			dispatch('savedNewAppPath', newEditedPath)
 		} catch (e) {
 			sendUserToast(`Error saving initial draft: ${e.body ?? e.message}`, true)
@@ -580,7 +593,7 @@
 			}
 
 			sendUserToast('Draft saved')
-			UserDraft.remove('raw_app', path)
+			if (!inSessionPane) UserDraft.remove('raw_app', path)
 			loading.saveDraft = false
 			if (newApp || savedApp.draft_only) {
 				dispatch('savedNewAppPath', newEditedPath || path)
@@ -725,7 +738,13 @@
 	})
 </script>
 
-<UnsavedConfirmationModal {diffDrawer} {getInitialAndModifiedValues} />
+<!-- Inside a session pane the editor's content is continuously persisted to the
+     UserDraft (localStorage), so tearing the editor down on navigation loses
+     nothing — skip the unsaved-changes prompt. The standalone /apps_raw editor
+     keeps it. -->
+{#if !inSessionPane}
+	<UnsavedConfirmationModal {diffDrawer} {getInitialAndModifiedValues} />
+{/if}
 
 <DeployOverrideConfirmationModal
 	{deployedBy}
@@ -797,7 +816,7 @@
 							button: {
 								text: 'Looks good, deploy',
 								onClick: () => {
-									if (appPath == '') {
+									if (newApp || appPath == '') {
 										createApp(newEditedPath)
 									} else {
 										handleUpdateApp(newEditedPath)
@@ -818,7 +837,7 @@
 					startIcon={{ icon: Save }}
 					disabled={pathError != '' || customPathError != '' || app == undefined}
 					on:click={() => {
-						if (appPath == '') {
+						if (newApp || appPath == '') {
 							createApp(newEditedPath)
 						} else {
 							handleUpdateApp(newEditedPath)
@@ -837,6 +856,7 @@
 			{appPath}
 			{onLatest}
 			{savedApp}
+			rawApp
 			bind:summary
 			bind:customPath
 			bind:deploymentMsg
@@ -924,7 +944,7 @@
 			savedPath={appPath || newPath || undefined}
 			kind="app"
 			raw_app
-			onNavigate={(item) => goto(editPathFor(item))}
+			onNavigate={(item) => (onNavigate ? onNavigate(item) : goto(editPathFor(item)))}
 		/>
 		<div></div>
 	</div>
diff --git a/frontend/src/lib/components/script_builder.ts b/frontend/src/lib/components/script_builder.ts
index c810003b38..e561600181 100644
--- a/frontend/src/lib/components/script_builder.ts
+++ b/frontend/src/lib/components/script_builder.ts
@@ -36,7 +36,10 @@ export interface ScriptBuilderProps {
 	savedPrimarySchedule?: ScheduleTrigger | undefined
 	functionExports?: ((exports: ScriptBuilderFunctionExports) => void) | undefined
 	children?: import('svelte').Snippet
-	onDeploy?: (e: { path: string; hash: string }) => void
+	// Fires on every successful deploy. `stay` is true for "Deploy & Stay here"
+	// and for lib scripts (the editor stays in place rather than navigating to
+	// the deployed item) — consumers should skip post-deploy navigation when set.
+	onDeploy?: (e: { path: string; hash: string; stay: boolean }) => void
 	onDeployError?: (e: { path: string; error: any }) => void
 	onSaveInitial?: (e: { path: string; hash: string }) => void
 	onHistoryRestore?: () => void
@@ -45,4 +48,12 @@ export interface ScriptBuilderProps {
 	onSeeDetails?: (e: { path: string }) => void
 	onSaveDraftError?: (e: { path: string; error: any }) => void
 	onNavigate?: (item: WorkspaceItem) => void
+	// Forwarded to the underlying ScriptEditor. When true, the right-hand
+	// test/run pane opens collapsed. Used by the session preview.
+	initialTestPanelCollapsed?: boolean
+	// Treat the path as already chosen (seeds the path "dirty" flag) so the
+	// summary→path auto-slug for new scripts (initialPath == '') doesn't
+	// overwrite it. Used by the session preview, which opens AI-created scripts
+	// as new but with a path the AI already assigned.
+	initialPathChosen?: boolean
 }
diff --git a/frontend/src/lib/components/select/MultiSelect.svelte b/frontend/src/lib/components/select/MultiSelect.svelte
index 750ab62b8c..419984b20d 100644
--- a/frontend/src/lib/components/select/MultiSelect.svelte
+++ b/frontend/src/lib/components/select/MultiSelect.svelte
@@ -72,6 +72,8 @@
 	let wrapperEl: HTMLDivElement | undefined = $state()
 	let searchInputEl: TextInput | undefined = $state()
 
+	let currentValue = $derived(value ?? [])
+
 	$effect(() => searchInputEl?.focus())
 
 	let processedItems: ProcessedItem<Value>[] = $derived.by(() => {
@@ -87,18 +89,20 @@
 	})
 
 	let valueEntry = $derived(
-		value.map((v) => processedItems.find((item) => item.value === v) ?? { value: v, label: v })
+		currentValue.map(
+			(v) => processedItems.find((item) => item.value === v) ?? { value: v, label: v }
+		)
 	)
 
 	function onAddValue(item: ProcessedItem<Value>) {
 		if (item.__is_create && onCreateItem) {
 			onCreateItem(item.value)
 		} else {
-			value = [...value, item.value]
+			value = [...currentValue, item.value]
 		}
 	}
 	function onRemoveValue(item: ProcessedItem<Value>) {
-		value = value.filter((v) => v !== item.value)
+		value = currentValue.filter((v) => v !== item.value)
 	}
 
 	function clearValue() {
@@ -132,7 +136,7 @@
 	<!-- svelte-ignore a11y_click_events_have_key_events -->
 	<!-- svelte-ignore a11y_no_noninteractive_element_interactions -->
 
-	{#if value.length === 0}
+	{#if currentValue.length === 0}
 		<span class={twMerge('text-xs h-full flex items-center flex-1 text-hint', placeholderClass)}>
 			{placeholder}
 		</span>
@@ -149,7 +153,7 @@
 				{allowClear}
 				onRemove={onRemoveValue}
 				onReorder={reorderable
-					? (oldIdx, newIdx) => (value = reorder(value, oldIdx, newIdx))
+					? (oldIdx, newIdx) => (value = reorder(currentValue, oldIdx, newIdx))
 					: undefined}
 			/>
 		</ul>
@@ -166,7 +170,7 @@
 		{disablePortal}
 		onSelectValue={onAddValue}
 		{open}
-		processedItems={processedItems.filter((item) => !value.includes(item.value))}
+		processedItems={processedItems.filter((item) => !currentValue.includes(item.value))}
 		value={undefined}
 		{disabled}
 		{filterText}
@@ -181,7 +185,7 @@
 		ulClass="options"
 	>
 		{#snippet header()}
-			{#if processedItems.length - value.length > 0 || onCreateItem}
+			{#if processedItems.length - currentValue.length > 0 || onCreateItem}
 				<div class="mx-2 mb-1 mt-2 flex items-center relative">
 					<TextInput
 						bind:this={searchInputEl}
diff --git a/frontend/src/lib/components/sessions/FlowEditorView.svelte b/frontend/src/lib/components/sessions/FlowEditorView.svelte
new file mode 100644
index 0000000000..0ea66146ac
--- /dev/null
+++ b/frontend/src/lib/components/sessions/FlowEditorView.svelte
@@ -0,0 +1,181 @@
+<script lang="ts">
+	import FlowBuilder from '$lib/components/FlowBuilder.svelte'
+	import DiffDrawer from '$lib/components/DiffDrawer.svelte'
+	import type { WorkspaceItem } from '$lib/components/workspacePicker'
+	import { untrack } from 'svelte'
+	import type { SessionRuntime } from './sessionRuntime.svelte'
+	import type { Flow } from '$lib/gen'
+	import { UserDraft } from '$lib/userDraft.svelte'
+	import { flowDraftSig } from './flowDraftSig'
+	import { initFlowState } from '$lib/components/flows/flowState'
+	import SessionItemNotFound from './SessionItemNotFound.svelte'
+	import { sendUserToast } from '$lib/toast'
+
+	let {
+		runtime,
+		path,
+		workspaceId,
+		onNavigate,
+		isActiveSession = true
+	}: {
+		runtime: SessionRuntime
+		path: string
+		workspaceId: string
+		onNavigate?: (item: WorkspaceItem) => void
+		/**
+		 * Only the visible session should claim the workspace's live-editor
+		 * slot — without this, a hidden warm-mounted session can overwrite the
+		 * active session's UserDraft live-editor target (one slot per
+		 * (workspace, kind)), so chat actions like discard / "the open editor"
+		 * resolve to the wrong session.
+		 */
+		isActiveSession?: boolean
+	} = $props()
+
+	let selectedId = $state('settings-metadata')
+	let diffDrawer: DiffDrawer | undefined = $state()
+
+	$effect(() => {
+		if (workspaceId && path) {
+			untrack(() => runtime.loadFlow(workspaceId, path))
+		}
+	})
+
+	// In a session pane, "restore" just reloads from the current state — the
+	// session target stays put. The Diff drawer's primary use here is viewing
+	// the diff; restore is best-effort.
+	async function restoreFromCurrentTarget() {
+		diffDrawer?.closeDrawer()
+		await runtime.loadFlow(workspaceId, path)
+	}
+
+	// Mark this editor as the "live editor" for the session's workspace so
+	// the chat's `isLiveDraft` hint and `discard_local_draft` tool resolve to
+	// this path. Same registration the regular /flows/edit page does on
+	// mount, scoped to the session's (forked) workspace.
+	// Gated on `isActiveSession`: warm-but-hidden session editors must not
+	// claim the workspace's single live-editor slot, else chat actions on the
+	// visible session resolve to the hidden one's path.
+	$effect(() => {
+		if (!workspaceId || !path) return
+		if (!isActiveSession) return
+		UserDraft.setLiveEditorDraft({
+			workspace: workspaceId,
+			itemKind: 'flow',
+			storagePath: path,
+			effectivePath: runtime.flowStore.val?.path ?? path
+		})
+		return () =>
+			UserDraft.clearLiveEditorDraft('flow', { workspace: workspaceId, storagePath: path })
+	})
+
+	// Bidirectional sync between this preview and `UserDraft<Flow>`.
+	// We hold a *live* handle (useMany) rather than reading via the static
+	// `UserDraft.get`. The handle materializes UserDraft's shared reactive
+	// `$state` cell for (workspace, 'flow', path), and that cell is what lets
+	// the chat's writes (UserDraft.save, from write_flow / patch_flow_json /
+	// set_flow_module_code) reach this preview. Without a live entry those
+	// writes only touch localStorage and the inbound effect below never
+	// re-fires. A reactive getter is used (not `use()`) because switching
+	// open_preview to another flow swaps `path` without remounting this view,
+	// so the handle must re-acquire.
+	//
+	// One-way-reactive discipline: inbound tracks only the handle's draft,
+	// outbound tracks only `flowStore.val`; the read on the "other side"
+	// inside each effect goes through `untrack()`. Without that asymmetry, a
+	// user keystroke would re-fire the inbound effect with the pre-keystroke
+	// stored value and revert the edit.
+	const draftHandles = UserDraft.useMany<Flow>(() => [
+		{ itemKind: 'flow', path, workspace: workspaceId }
+	])
+	let lastInboundSig: string | undefined = $state(undefined)
+
+	// Store → editor. Re-runs when the handle's draft changes (AI write from
+	// this session's chat or another session). flowStore reads are untracked
+	// so the editor's own mutations don't refire this effect.
+	$effect(() => {
+		if (!workspaceId || !path) return
+		const incoming = draftHandles[0]?.draft
+		if (!incoming) return
+		const sig = flowDraftSig(incoming)
+		untrack(() => {
+			if (runtime.loadedPath !== path) return
+			if (sig === lastInboundSig) return
+			const current = runtime.flowStore.val
+			if (!current) return
+			lastInboundSig = sig
+			runtime.flowStore.val = {
+				...current,
+				value: incoming.value,
+				schema: incoming.schema ?? current.schema,
+				summary: incoming.summary ?? current.summary
+			}
+			// flowStateStore is keyed by module_id; after an AI write the set
+			// of module ids may differ, so rebuild the UI state. This wipes
+			// per-module test args / preview output for the new flow — a
+			// known v1 trade-off, see the plan's caveats.
+			void initFlowState(runtime.flowStore.val, runtime.flowStateStore)
+		})
+	})
+
+	// Editor → store. Re-runs on any deep mutation of flowStore.val
+	// (modules, schema, module bodies). The store read is untracked.
+	// Debounced 150ms so a typing burst inside an inline rawscript editor
+	// results in one serialise-and-write instead of one per keystroke.
+	let outboundTimer: ReturnType<typeof setTimeout> | undefined
+	$effect(() => {
+		if (!workspaceId || !path) return
+		if (runtime.loadedPath !== path) return
+		const flow = runtime.flowStore.val
+		if (!flow) return
+		const sig = flowDraftSig(flow)
+		if (sig === lastInboundSig) return
+		if (outboundTimer) clearTimeout(outboundTimer)
+		outboundTimer = setTimeout(() => {
+			untrack(() => {
+				const current = UserDraft.get<Flow>('flow', path, { workspace: workspaceId })
+				if (current && flowDraftSig(current) === sig) return
+				UserDraft.save('flow', path, flow, { workspace: workspaceId })
+			})
+		}, 150)
+		return () => {
+			if (outboundTimer) clearTimeout(outboundTimer)
+		}
+	})
+</script>
+
+{#if runtime.savedFlow.val}
+	<DiffDrawer
+		bind:this={diffDrawer}
+		restoreDeployed={restoreFromCurrentTarget}
+		restoreDraft={restoreFromCurrentTarget}
+		isFlow
+	/>
+{/if}
+{#if runtime.loadingFlow && !runtime.loadedPath}
+	<div class="p-4 text-secondary text-sm">Loading flow {path}…</div>
+{:else if runtime.notFound && !runtime.loadedPath}
+	<SessionItemNotFound kind="flow" {path} {onNavigate} />
+{:else}
+	<!-- customUi hides the in-editor "Flow AI Chat" button: the session already
+	     has its own AI chat in the left pane, so the toggle is redundant here. -->
+	<FlowBuilder
+		flowStore={runtime.flowStore}
+		flowStateStore={runtime.flowStateStore}
+		initialPath={path}
+		newFlow={!runtime.savedFlow.val}
+		{selectedId}
+		loading={runtime.loadingFlow && !runtime.loadedPath}
+		bind:savedFlow={runtime.savedFlow.val}
+		{diffDrawer}
+		{onNavigate}
+		customUi={{ topBar: { aiBuilder: false } }}
+		onSaveDraft={() => runtime.scheduleForkComparisonRefresh()}
+		onDeploy={() => {
+			// FlowBuilder has no deploy toast and the session stays put, so toast
+			// here, then sync the preview to deployed (pulls the new locks + version_id).
+			sendUserToast('Deployed')
+			runtime.syncPreviewWithDeployed(workspaceId, 'flow', path)
+		}}
+	/>
+{/if}
diff --git a/frontend/src/lib/components/sessions/ForkDiffDrawer.svelte b/frontend/src/lib/components/sessions/ForkDiffDrawer.svelte
new file mode 100644
index 0000000000..acfac1f03f
--- /dev/null
+++ b/frontend/src/lib/components/sessions/ForkDiffDrawer.svelte
@@ -0,0 +1,732 @@
+<script lang="ts">
+	import { parentFolderKey } from './forkDiffNav'
+	import { Button, Drawer, DrawerContent } from '$lib/components/common'
+	import Badge from '$lib/components/common/badge/Badge.svelte'
+	import {
+		AlertTriangle,
+		ArrowRight,
+		ChevronDown,
+		ChevronRight,
+		Folder,
+		GitFork,
+		GitMerge,
+		Loader2,
+		Minus,
+		Pencil,
+		Plus,
+		User
+	} from 'lucide-svelte'
+	import { goto } from '$lib/navigation'
+	import RowIcon from '$lib/components/common/table/RowIcon.svelte'
+	import WorkspaceItemRow from '$lib/components/WorkspaceItemRow.svelte'
+	import WorkspaceItemDiffViewer from '$lib/components/WorkspaceItemDiffViewer.svelte'
+	import SearchItems from '$lib/components/SearchItems.svelte'
+	import ToggleButtonGroup from '$lib/components/common/toggleButton-v2/ToggleButtonGroup.svelte'
+	import ToggleButton from '$lib/components/common/toggleButton-v2/ToggleButton.svelte'
+	import { DiffIcon, ExternalLink, SquareSplitHorizontal } from 'lucide-svelte'
+	import { WorkspaceService, type WorkspaceComparison, type WorkspaceItemDiff } from '$lib/gen'
+	import { getItemValue } from '$lib/utils_workspace_deploy'
+	import { userWorkspaces } from '$lib/stores'
+	import { editUrlFor as buildEditUrl } from './forkEditUrl'
+
+	let {
+		forkWorkspaceId,
+		parentWorkspaceId
+	}: { forkWorkspaceId: string; parentWorkspaceId: string } = $props()
+
+	let drawer: Drawer | undefined = $state(undefined)
+	let comparison: WorkspaceComparison | undefined = $state(undefined)
+	let loading = $state(false)
+	let error: string | undefined = $state(undefined)
+	let searchQuery = $state('')
+	let diffStyle = $state<'sbs' | 'inline'>('sbs')
+	const inlineDiff = $derived(diffStyle === 'inline')
+
+	const forkWs = $derived($userWorkspaces.find((w) => w.id === forkWorkspaceId))
+	const parentWs = $derived($userWorkspaces.find((w) => w.id === parentWorkspaceId))
+
+	export function open() {
+		drawer?.openDrawer()
+		void fetchComparison()
+		// Pull focus into the filter input so keyboard nav works without an
+		// extra click — drawer transition needs a tick first.
+		setTimeout(() => searchInputEl?.focus(), 50)
+	}
+
+	function openReview() {
+		goto(`/forks/compare?workspace_id=${encodeURIComponent(forkWorkspaceId)}`)
+	}
+
+	async function fetchComparison() {
+		loading = true
+		error = undefined
+		// Per-item raw diffs are cached for the lifetime of the drawer.
+		// `loadDiffFor` early-returns on cache hit, so without this reset an
+		// edit-then-reopen would show fresh summary/counts but stale expanded
+		// raw content for any item the user had already drilled into.
+		loadedDiffs = {}
+		summaries = {}
+		try {
+			comparison = await WorkspaceService.compareWorkspaces({
+				workspace: parentWorkspaceId,
+				targetWorkspaceId: forkWorkspaceId
+			})
+			// Diffs are expanded by default, so eagerly populate each row's
+			// content. Each loadDiffFor is idempotent and per-item, so
+			// rendering proceeds as values arrive.
+			if (comparison) {
+				for (const d of comparison.diffs) {
+					void loadDiffFor(d)
+				}
+			}
+		} catch (e) {
+			console.error('Fork diff: comparison failed', e)
+			error = `Failed to load comparison: ${e}`
+			comparison = undefined
+		} finally {
+			loading = false
+		}
+	}
+
+	type DiffStatus = 'added' | 'removed' | 'modified' | 'conflict'
+
+	function statusOf(d: WorkspaceItemDiff): DiffStatus {
+		if (d.exists_in_fork && !d.exists_in_source) return 'added'
+		if (!d.exists_in_fork && d.exists_in_source) return 'removed'
+		if (d.ahead > 0 && d.behind > 0) return 'conflict'
+		return 'modified'
+	}
+
+	function itemKey(d: WorkspaceItemDiff): string {
+		return `${d.kind}/${d.path}`
+	}
+
+	// Editor URL for a diff row, scoped to the fork workspace.
+	function editUrlFor(d: WorkspaceItemDiff): string | undefined {
+		return buildEditUrl(d, forkWorkspaceId)
+	}
+
+	const KIND_LABELS: Record<string, string> = {
+		script: 'Script',
+		flow: 'Flow',
+		app: 'App',
+		raw_app: 'Raw app',
+		resource: 'Resource',
+		variable: 'Variable',
+		resource_type: 'Resource type',
+		folder: 'Folder',
+		schedule: 'Schedule',
+		http_trigger: 'HTTP route',
+		websocket_trigger: 'Websocket trigger',
+		kafka_trigger: 'Kafka trigger',
+		nats_trigger: 'NATS trigger',
+		postgres_trigger: 'Postgres trigger',
+		mqtt_trigger: 'MQTT trigger',
+		sqs_trigger: 'SQS trigger',
+		gcp_trigger: 'GCP trigger',
+		azure_trigger: 'Azure trigger',
+		email_trigger: 'Email trigger'
+	}
+
+	// Lazily-loaded raw values per item, keyed by itemKey. Shaping (content
+	// vs metadata, YAML, lang detection) is owned by WorkspaceItemDiffViewer.
+	type LoadedDiff = {
+		state: 'loading' | 'ready' | 'error'
+		error?: string
+		parentRaw?: unknown
+		forkRaw?: unknown
+	}
+	let loadedDiffs: Record<string, LoadedDiff> = $state({})
+	// Per-item summary, derived from the fetched raw value so the tree on
+	// the left can show summary above the mono path (matches the picker).
+	let summaries: Record<string, string | undefined> = $state({})
+
+	async function loadDiffFor(d: WorkspaceItemDiff) {
+		const key = itemKey(d)
+		if (loadedDiffs[key]) return
+		loadedDiffs[key] = { state: 'loading' }
+
+		try {
+			// Source (parent) — empty for items only in fork. Fork — empty for
+			// items only in source. We swallow per-side errors so an "added"
+			// item still renders cleanly against an empty original.
+			const [parentRaw, forkRaw] = await Promise.all([
+				d.exists_in_source
+					? getItemValue(d.kind, d.path, parentWorkspaceId).catch(() => undefined)
+					: Promise.resolve(undefined),
+				d.exists_in_fork
+					? getItemValue(d.kind, d.path, forkWorkspaceId).catch(() => undefined)
+					: Promise.resolve(undefined)
+			])
+			loadedDiffs[key] = { state: 'ready', parentRaw, forkRaw }
+			// Prefer the fork's summary (the "current" side); fall back to parent.
+			const summary =
+				(forkRaw && typeof forkRaw === 'object' && (forkRaw as any).summary) ||
+				(parentRaw && typeof parentRaw === 'object' && (parentRaw as any).summary) ||
+				undefined
+			if (typeof summary === 'string' && summary.trim().length > 0) {
+				summaries[key] = summary
+			}
+		} catch (e) {
+			console.error('Fork diff: loadDiff failed', d, e)
+			loadedDiffs[key] = {
+				state: 'error',
+				error: String(e)
+			}
+		}
+	}
+
+	function onDetailsToggle(d: WorkspaceItemDiff, e: Event) {
+		const target = e.currentTarget as HTMLDetailsElement | null
+		if (target?.open) {
+			void loadDiffFor(d)
+		}
+	}
+
+	function statusBadgeColor(s: DiffStatus): 'green' | 'red' | 'orange' | 'blue' {
+		if (s === 'added') return 'green'
+		if (s === 'removed') return 'red'
+		if (s === 'conflict') return 'orange'
+		return 'blue'
+	}
+
+	const statusIcons = {
+		added: Plus,
+		removed: Minus,
+		modified: Pencil,
+		conflict: AlertTriangle
+	}
+
+	// File tree built from the diff paths. Top-level rows mirror
+	// WorkspaceItemDrillPicker: `f/foo` and `u/alice` collapse to a single
+	// "scope" row, then deeper segments split per `/`. Leaves carry their
+	// diff entry.
+	type FolderNode = {
+		type: 'folder'
+		name: string
+		fullPath: string
+		isScope: boolean
+		children: TreeNode[]
+	}
+	type FileNode = { type: 'file'; name: string; diff: WorkspaceItemDiff }
+	type TreeNode = FolderNode | FileNode
+
+	function buildTree(diffs: WorkspaceItemDiff[]): FolderNode {
+		const root: FolderNode = {
+			type: 'folder',
+			name: '',
+			fullPath: '',
+			isScope: false,
+			children: []
+		}
+		const folderCache = new Map<string, FolderNode>()
+
+		for (const d of diffs) {
+			const parts = d.path.split('/')
+			if (parts.length < 2) {
+				root.children.push({ type: 'file', name: d.path, diff: d })
+				continue
+			}
+			const scopeKey = parts.slice(0, 2).join('/')
+			let scope = folderCache.get(scopeKey)
+			if (!scope) {
+				scope = {
+					type: 'folder',
+					name: scopeKey,
+					fullPath: scopeKey,
+					isScope: true,
+					children: []
+				}
+				folderCache.set(scopeKey, scope)
+				root.children.push(scope)
+			}
+			if (parts.length === 2) {
+				scope.children.push({ type: 'file', name: scopeKey, diff: d })
+				continue
+			}
+			const rest = parts.slice(2)
+			let parent = scope
+			let folderKey = scopeKey
+			for (let i = 0; i < rest.length - 1; i++) {
+				folderKey = `${folderKey}/${rest[i]}`
+				let folder = folderCache.get(folderKey)
+				if (!folder) {
+					folder = {
+						type: 'folder',
+						name: rest[i],
+						fullPath: folderKey,
+						isScope: false,
+						children: []
+					}
+					folderCache.set(folderKey, folder)
+					parent.children.push(folder)
+				}
+				parent = folder
+			}
+			parent.children.push({ type: 'file', name: rest[rest.length - 1], diff: d })
+		}
+
+		const sortRec = (n: FolderNode) => {
+			n.children.sort((a, b) => {
+				if (a.type !== b.type) return a.type === 'folder' ? -1 : 1
+				return a.name.localeCompare(b.name)
+			})
+			for (const c of n.children) if (c.type === 'folder') sortRec(c)
+		}
+		sortRec(root)
+		return root
+	}
+
+	// Searchable string per diff: path + summary (when loaded) + kind label.
+	// SearchItems' uFuzzy runs fuzzy matching over these. Reads `summaries`
+	// directly so the index re-derives as summaries trickle in from
+	// loadDiffFor.
+	function searchableText(d: WorkspaceItemDiff): string {
+		const parts = [d.path, KIND_LABELS[d.kind] ?? d.kind]
+		const s = summaries[itemKey(d)]
+		if (s) parts.push(s)
+		return parts.join(' ')
+	}
+	let searchedDiffs: (WorkspaceItemDiff & { marked?: string })[] | undefined = $state(undefined)
+
+	// Empty query bypasses SearchItems entirely so we don't wait a tick for
+	// the async filter to run after open.
+	const filteredDiffs = $derived.by(() => {
+		const c = comparison
+		if (!c) return [] as WorkspaceItemDiff[]
+		const q = searchQuery.trim()
+		if (!q) return c.diffs
+		return (searchedDiffs ?? []) as WorkspaceItemDiff[]
+	})
+
+	const tree = $derived.by(() => {
+		const c = comparison
+		return c ? buildTree(filteredDiffs) : undefined
+	})
+
+	function rowId(d: WorkspaceItemDiff): string {
+		return `fork-diff-${itemKey(d)}`
+	}
+
+	function scrollToDiff(d: WorkspaceItemDiff) {
+		const el = document.getElementById(rowId(d)) as HTMLDetailsElement | null
+		if (!el) return
+		el.open = true
+		el.scrollIntoView({ behavior: 'smooth', block: 'start' })
+	}
+
+	// ── Keyboard nav (matches WorkspaceItemDrillPicker) ─────────────────────
+	// Per-folder open/closed state. Defaults to open; user toggles via the
+	// <details> summary or via Enter when a folder row is highlighted.
+	let folderOpen: Record<string, boolean> = $state({})
+	function isFolderOpen(key: string): boolean {
+		return folderOpen[key] ?? true
+	}
+	function folderKey(node: FolderNode): string {
+		return `folder:${node.fullPath}`
+	}
+
+	type NavEntry =
+		| { type: 'folder'; key: string; node: FolderNode }
+		| { type: 'file'; key: string; diff: WorkspaceItemDiff }
+
+	function flattenVisible(node: FolderNode): NavEntry[] {
+		const out: NavEntry[] = []
+		const walk = (n: TreeNode) => {
+			if (n.type === 'file') {
+				out.push({ type: 'file', key: itemKey(n.diff), diff: n.diff })
+				return
+			}
+			const fkey = folderKey(n)
+			out.push({ type: 'folder', key: fkey, node: n })
+			if (isFolderOpen(fkey)) for (const c of n.children) walk(c)
+		}
+		for (const c of node.children) walk(c)
+		return out
+	}
+	const navEntries = $derived(tree ? flattenVisible(tree) : [])
+	const navKeys = $derived(navEntries.map((e) => e.key))
+	const entryByKey = $derived(new Map(navEntries.map((e) => [e.key, e])))
+
+	let highlightedKey: string | undefined = $state(undefined)
+	let mouseActive = $state(false)
+	let searchInputEl: HTMLInputElement | undefined = $state()
+	let sidebarRoot: HTMLElement | undefined = $state()
+
+	$effect(() => {
+		if (navKeys.length === 0) return
+		if (!highlightedKey || !navKeys.includes(highlightedKey)) {
+			highlightedKey = navKeys[0]
+		}
+	})
+
+	function scrollHighlightIntoView() {
+		if (!sidebarRoot || !highlightedKey) return
+		const el = sidebarRoot.querySelector<HTMLElement>(
+			`[data-nav-key="${CSS.escape(highlightedKey)}"]`
+		)
+		el?.scrollIntoView({ block: 'nearest', behavior: 'smooth' })
+	}
+
+	function moveHighlight(delta: 1 | -1) {
+		if (navKeys.length === 0) return
+		const cur = navKeys.indexOf(highlightedKey ?? '')
+		const next = cur < 0 ? 0 : (cur + delta + navKeys.length) % navKeys.length
+		highlightedKey = navKeys[next]
+		mouseActive = false
+		requestAnimationFrame(scrollHighlightIntoView)
+	}
+
+	function setHoverHighlight(key: string) {
+		// Same defense as the picker: ignore until the user actually moves the
+		// mouse, so a cursor parked over a row doesn't clobber the keyboard
+		// highlight when the layout shifts.
+		if (mouseActive) highlightedKey = key
+	}
+
+	function activateHighlighted() {
+		if (!highlightedKey) return
+		const entry = entryByKey.get(highlightedKey)
+		if (!entry) return
+		if (entry.type === 'file') {
+			scrollToDiff(entry.diff)
+		} else {
+			folderOpen[entry.key] = !isFolderOpen(entry.key)
+		}
+	}
+
+	// The folder containing an entry, as a folder key (or undefined if the
+	// entry is at the top scope and has no parent folder). Pure logic lives in
+	// forkDiffNav.parentFolderKey (unit-tested).
+	function parentFolderKeyFor(entry: NavEntry): string | undefined {
+		const path = entry.type === 'folder' ? entry.node.fullPath : entry.diff.path
+		return parentFolderKey(entry.type, path)
+	}
+
+	function firstChildKey(node: FolderNode): string | undefined {
+		const c = node.children[0]
+		if (!c) return undefined
+		return c.type === 'folder' ? folderKey(c) : itemKey(c.diff)
+	}
+
+	function selectKey(key: string) {
+		highlightedKey = key
+		mouseActive = false
+		requestAnimationFrame(scrollHighlightIntoView)
+	}
+
+	function handleSearchKeydown(e: KeyboardEvent) {
+		if (e.key === 'ArrowDown') {
+			e.preventDefault()
+			moveHighlight(1)
+		} else if (e.key === 'ArrowUp') {
+			e.preventDefault()
+			moveHighlight(-1)
+		} else if (e.key === 'Enter') {
+			e.preventDefault()
+			activateHighlighted()
+		} else if (e.key === 'ArrowRight') {
+			// On a closed folder: open it. On an open folder: jump to its first
+			// child (folder or file). On a file: no-op.
+			const entry = highlightedKey ? entryByKey.get(highlightedKey) : undefined
+			if (!entry || entry.type !== 'folder') return
+			if (!isFolderOpen(entry.key)) {
+				e.preventDefault()
+				folderOpen[entry.key] = true
+				return
+			}
+			const child = firstChildKey(entry.node)
+			if (child) {
+				e.preventDefault()
+				selectKey(child)
+			}
+		} else if (e.key === 'ArrowLeft') {
+			// On an open folder: collapse it. On a closed folder (or a file):
+			// jump to the parent folder.
+			const entry = highlightedKey ? entryByKey.get(highlightedKey) : undefined
+			if (!entry) return
+			if (entry.type === 'folder' && isFolderOpen(entry.key)) {
+				e.preventDefault()
+				folderOpen[entry.key] = false
+				return
+			}
+			const parent = parentFolderKeyFor(entry)
+			if (parent && entryByKey.has(parent)) {
+				e.preventDefault()
+				selectKey(parent)
+			}
+		}
+	}
+</script>
+
+<SearchItems
+	filter={searchQuery}
+	items={comparison?.diffs ?? []}
+	bind:filteredItems={searchedDiffs}
+	f={(d: WorkspaceItemDiff) => searchableText(d)}
+/>
+
+{#snippet renderTreeNode(node: TreeNode, depth: number)}
+	{#if node.type === 'folder'}
+		{@const isUserScope = node.isScope && node.name.startsWith('u/')}
+		{@const fkey = folderKey(node)}
+		{@const open = isFolderOpen(fkey)}
+		{@const isHl = fkey === highlightedKey}
+		<details
+			{open}
+			ontoggle={(e) => (folderOpen[fkey] = (e.currentTarget as HTMLDetailsElement).open)}
+			class="select-none"
+		>
+			<summary
+				role="option"
+				aria-selected={isHl}
+				data-nav-key={fkey}
+				onmouseenter={() => setHoverHighlight(fkey)}
+				class="flex items-center gap-1.5 px-3 py-1 cursor-pointer text-xs font-medium font-mono text-emphasis hover:bg-surface-hover list-none [&::-webkit-details-marker]:hidden tree-summary {isHl
+					? 'bg-surface-hover'
+					: ''}"
+				style="padding-left: {depth * 12 + 8}px"
+			>
+				<ChevronDown class="w-3 h-3 shrink-0 text-tertiary tree-chevron-open" />
+				<ChevronRight class="w-3 h-3 shrink-0 text-tertiary tree-chevron-closed" />
+				{#if isUserScope}
+					<User size={12} class="shrink-0 text-tertiary" />
+				{:else}
+					<Folder size={12} class="shrink-0 text-tertiary" />
+				{/if}
+				<span class="truncate" title={node.name}>{node.name}</span>
+			</summary>
+			<div>
+				{#each node.children as child}
+					{@render renderTreeNode(child, depth + 1)}
+				{/each}
+			</div>
+		</details>
+	{:else}
+		{@const status = statusOf(node.diff)}
+		{@const key = itemKey(node.diff)}
+		<WorkspaceItemRow
+			kind={node.diff.kind}
+			summary={summaries[key]}
+			secondary={node.name}
+			highlighted={key === highlightedKey}
+			navKey={key}
+			indent={depth * 12 + 20}
+			title={node.diff.path}
+			onclick={() => {
+				highlightedKey = key
+				scrollToDiff(node.diff)
+			}}
+			onmouseenter={() => setHoverHighlight(key)}
+		>
+			{#snippet extras()}
+				<span
+					class="w-1.5 h-1.5 rounded-full shrink-0 {status === 'added'
+						? 'bg-green-500'
+						: status === 'removed'
+							? 'bg-red-500'
+							: status === 'conflict'
+								? 'bg-orange-500'
+								: 'bg-blue-500'}"
+				></span>
+			{/snippet}
+		</WorkspaceItemRow>
+	{/if}
+{/snippet}
+
+<Drawer bind:this={drawer} size="1200px">
+	<DrawerContent
+		title="Fork changes"
+		on:close={() => drawer?.closeDrawer()}
+		documentationLink={undefined}
+		noPadding
+		overflow_y={false}
+	>
+		{#snippet titleExtra()}
+			<div class="flex items-center gap-2 text-xs text-secondary">
+				<GitFork class="w-3.5 h-3.5 shrink-0" />
+				<span class="font-medium truncate">{forkWs?.name ?? forkWorkspaceId}</span>
+				<ArrowRight class="w-3 h-3 shrink-0 text-tertiary" />
+				<span class="font-medium truncate">{parentWs?.name ?? parentWorkspaceId}</span>
+				{#if comparison}
+					<Badge color="transparent" class="ml-2">
+						{comparison.summary.total_diffs} item{comparison.summary.total_diffs !== 1 ? 's' : ''}
+					</Badge>
+					{#if comparison.summary.conflicts > 0}
+						<Badge color="orange">
+							<AlertTriangle class="w-3 h-3 inline mr-1" />
+							{comparison.summary.conflicts} conflict{comparison.summary.conflicts !== 1 ? 's' : ''}
+						</Badge>
+					{/if}
+				{/if}
+			</div>
+		{/snippet}
+		{#snippet actions()}
+			<ToggleButtonGroup bind:selected={diffStyle} noWFull>
+				{#snippet children({ item })}
+					<ToggleButton
+						value="sbs"
+						label="Side-by-side"
+						icon={SquareSplitHorizontal}
+						tooltip="Side-by-side diff"
+						iconOnly
+						{item}
+					/>
+					<ToggleButton
+						value="inline"
+						label="Unified"
+						icon={DiffIcon}
+						tooltip="Unified diff"
+						iconOnly
+						{item}
+					/>
+				{/snippet}
+			</ToggleButtonGroup>
+			<Button variant="accent" unifiedSize="sm" startIcon={{ icon: GitMerge }} onclick={openReview}>
+				Review
+			</Button>
+		{/snippet}
+		<div class="flex flex-row h-full min-h-0">
+			{#if comparison && comparison.diffs.length > 0}
+				<aside
+					bind:this={sidebarRoot}
+					onmousemove={() => (mouseActive = true)}
+					class="flex-none w-56 border-r border-light flex flex-col min-h-0"
+				>
+					<div class="px-3 pt-3 pb-2 shrink-0">
+						<input
+							bind:this={searchInputEl}
+							type="search"
+							bind:value={searchQuery}
+							placeholder="Filter files..."
+							onkeydown={handleSearchKeydown}
+							class="w-full text-xs px-2 py-1 rounded border border-light bg-surface focus:outline-none focus:border-accent"
+						/>
+					</div>
+					<div class="flex-1 min-h-0 overflow-y-auto pb-3 flex flex-col gap-1">
+						{#if tree && tree.children.length > 0}
+							{#each tree.children as child}
+								{@render renderTreeNode(child, 0)}
+							{/each}
+						{:else}
+							<div class="text-2xs text-tertiary px-3 py-2">No matches</div>
+						{/if}
+					</div>
+				</aside>
+			{/if}
+			<main class="flex-1 min-w-0 overflow-y-auto">
+				<div class="px-3 pt-3 pb-4 flex flex-col gap-3">
+					{#if loading && !comparison}
+						<div class="flex items-center gap-2 text-sm text-secondary py-8 self-center">
+							<Loader2 class="w-4 h-4 animate-spin" />
+							Loading comparison...
+						</div>
+					{:else if error}
+						<div class="text-sm text-red-600 dark:text-red-400 py-4">{error}</div>
+					{:else if comparison?.skipped_comparison}
+						<div class="text-sm text-secondary py-4">
+							This fork was created before change tracking was added — diffs are not available.
+						</div>
+					{:else if comparison && comparison.diffs.length === 0}
+						<div class="text-sm text-secondary py-4"
+							>No changes between this fork and its parent.</div
+						>
+					{:else if comparison && filteredDiffs.length === 0}
+						<div class="text-sm text-secondary py-4">No files match "{searchQuery}".</div>
+					{:else if comparison}
+						<div class="flex flex-col gap-2">
+							{#each filteredDiffs as d (itemKey(d))}
+								{@const key = itemKey(d)}
+								{@const status = statusOf(d)}
+								{@const StatusIcon = statusIcons[status]}
+								{@const loaded = loadedDiffs[key]}
+								{@const editUrl = editUrlFor(d)}
+								<details
+									open
+									id={rowId(d)}
+									class="border border-light rounded-md bg-surface scroll-mt-2"
+									ontoggle={(e) => onDetailsToggle(d, e)}
+								>
+									<summary
+										class="sticky top-0 z-30 bg-surface flex items-center gap-2 px-3 py-2 cursor-pointer list-none [&::-webkit-details-marker]:hidden border-b border-transparent rounded-md relative before:content-[''] before:absolute before:inset-0 before:bg-surface-hover before:opacity-0 before:pointer-events-none before:transition-opacity hover:before:opacity-100"
+									>
+										<ChevronDown
+											class="w-3.5 h-3.5 shrink-0 text-tertiary transition-transform chevron"
+										/>
+										<RowIcon kind={d.kind} size={14} />
+										<div class="min-w-0 flex-1">
+											{#if editUrl}
+												<a
+													href={editUrl}
+													target="_blank"
+													rel="noopener noreferrer"
+													title={d.path}
+													onclick={(e) => e.stopPropagation()}
+													class="group inline-flex items-center gap-1 max-w-full text-xs text-primary font-mono truncate hover:underline"
+												>
+													<span class="truncate">{d.path}</span>
+													<ExternalLink
+														class="w-3 h-3 shrink-0 opacity-0 group-hover:opacity-60 transition-opacity"
+													/>
+												</a>
+											{:else}
+												<div class="text-xs text-primary font-mono truncate" title={d.path}>
+													{d.path}
+												</div>
+											{/if}
+										</div>
+										<div class="shrink-0 flex items-center gap-2">
+											{#if d.ahead > 0}
+												<span class="text-2xs text-secondary">{d.ahead} ahead</span>
+											{/if}
+											{#if d.behind > 0}
+												<span class="text-2xs text-secondary">{d.behind} behind</span>
+											{/if}
+											<Badge color={statusBadgeColor(status)}>
+												<StatusIcon class="w-3 h-3 inline mr-0.5" />
+												{status}
+											</Badge>
+										</div>
+									</summary>
+									<div
+										class="border-t border-light bg-surface-tertiary rounded-b-md overflow-hidden"
+									>
+										{#if !loaded || loaded.state === 'loading'}
+											<div class="flex items-center gap-2 text-xs text-secondary p-3">
+												<Loader2 class="w-3.5 h-3.5 animate-spin" />
+												Loading diff…
+											</div>
+										{:else if loaded.state === 'error'}
+											<div class="text-xs text-red-600 dark:text-red-400">{loaded.error}</div>
+										{:else if loaded.state === 'ready'}
+											<WorkspaceItemDiffViewer
+												kind={d.kind}
+												originalRaw={loaded.parentRaw}
+												currentRaw={loaded.forkRaw}
+												{inlineDiff}
+											/>
+										{/if}
+									</div>
+								</details>
+							{/each}
+						</div>
+					{/if}
+				</div></main
+			></div
+		>
+	</DrawerContent>
+</Drawer>
+
+<style>
+	/* Diff rows use a ChevronDown; rotate it back when collapsed. */
+	details:not([open]) :global(.chevron) {
+		transform: rotate(-90deg);
+	}
+	/* Tree folder rows: swap chevrons based on the folder's open state. */
+	details:not([open]) > .tree-summary :global(.tree-chevron-open) {
+		display: none;
+	}
+	details[open] > .tree-summary :global(.tree-chevron-closed) {
+		display: none;
+	}
+</style>
diff --git a/frontend/src/lib/components/sessions/RawAppEditorView.svelte b/frontend/src/lib/components/sessions/RawAppEditorView.svelte
new file mode 100644
index 0000000000..af77298a87
--- /dev/null
+++ b/frontend/src/lib/components/sessions/RawAppEditorView.svelte
@@ -0,0 +1,158 @@
+<script lang="ts">
+	import RawAppEditor from '$lib/components/raw_apps/RawAppEditor.svelte'
+	import DiffDrawer from '$lib/components/DiffDrawer.svelte'
+	import type { WorkspaceItem } from '$lib/components/workspacePicker'
+	import { untrack } from 'svelte'
+	import type { SessionRuntime } from './sessionRuntime.svelte'
+	import { UserDraft } from '$lib/userDraft.svelte'
+	import type { RawAppDraft } from './appDraftCodec'
+	import { applyDraftToRuntimeRawApp, runtimeRawAppToDraft } from './appDraftCodec'
+	import SessionItemNotFound from './SessionItemNotFound.svelte'
+
+	let {
+		runtime,
+		path,
+		workspaceId,
+		onNavigate,
+		isActiveSession = true
+	}: {
+		runtime: SessionRuntime
+		path: string
+		workspaceId: string
+		onNavigate?: (item: WorkspaceItem) => void
+		/**
+		 * Only the visible session should claim the workspace's live-editor
+		 * slot — without this, a hidden warm-mounted session can overwrite the
+		 * active session's UserDraft live-editor target (one slot per
+		 * (workspace, kind)), so chat actions like discard / "the open editor"
+		 * resolve to the wrong session.
+		 */
+		isActiveSession?: boolean
+	} = $props()
+
+	let diffDrawer: DiffDrawer | undefined = $state()
+
+	$effect(() => {
+		if (workspaceId && path) {
+			untrack(() => runtime.loadRawApp(workspaceId, path))
+		}
+	})
+
+	async function restoreFromCurrentTarget() {
+		diffDrawer?.closeDrawer()
+		await runtime.loadRawApp(workspaceId, path)
+	}
+
+	// Mark this editor as the live editor draft for the session's workspace
+	// so the chat's `isLiveDraft` hint / `discard_local_draft` tool resolve
+	// to this path — same registration the regular /apps_raw/edit page does.
+	// Gated on `isActiveSession`: warm-but-hidden session editors must not
+	// claim the workspace's single live-editor slot, else chat actions on the
+	// visible session resolve to the hidden one's path.
+	$effect(() => {
+		if (!workspaceId || !path) return
+		if (!isActiveSession) return
+		UserDraft.setLiveEditorDraft({
+			workspace: workspaceId,
+			itemKind: 'raw_app',
+			storagePath: path,
+			effectivePath: runtime.rawApp.val?.path ?? path
+		})
+		return () =>
+			UserDraft.clearLiveEditorDraft('raw_app', { workspace: workspaceId, storagePath: path })
+	})
+
+	// Bidirectional sync between this preview and `UserDraft<RawAppDraft>`.
+	// We hold a *live* handle (useMany) rather than reading via the static
+	// `UserDraft.get`: the handle materializes UserDraft's shared reactive
+	// `$state` cell for (workspace, 'raw_app', path), and that cell is what
+	// lets the chat's writes (UserDraft.save / setDraftAndMeta, from
+	// write_app_file / patch_app_file / write_app_runnable) reach this preview.
+	// Without a live entry those writes only touch localStorage and the inbound
+	// effect below never re-fires. A reactive getter is used (not `use()`)
+	// because switching open_preview to another app swaps `path` without
+	// remounting this view, so the handle must re-acquire.
+	//
+	// Same one-way-reactive discipline as ScriptEditorView: inbound tracks only
+	// the handle's draft, outbound tracks only rawApp.val; each side's read of
+	// the other goes through untrack() to break the keystroke-revert race.
+	const draftHandles = UserDraft.useMany<RawAppDraft>(() => [
+		{ itemKind: 'raw_app', path, workspace: workspaceId }
+	])
+	let lastInboundSig: string | undefined = $state(undefined)
+
+	// Store → editor. Re-runs when the handle's draft changes (chat write,
+	// other session edit).
+	$effect(() => {
+		if (!workspaceId || !path) return
+		const incoming = draftHandles[0]?.draft
+		if (!incoming) return
+		const sig = JSON.stringify(incoming)
+		untrack(() => {
+			if (runtime.loadedRawAppPath !== path) return
+			if (sig === lastInboundSig) return
+			const current = runtime.rawApp.val
+			if (!current) return
+			lastInboundSig = sig
+			runtime.rawApp.val = applyDraftToRuntimeRawApp(current, incoming)
+		})
+	})
+
+	// Editor → store. Debounced 150ms so a typing burst inside a frontend
+	// file's Monaco editor coalesces into one store write.
+	let outboundTimer: ReturnType<typeof setTimeout> | undefined
+	$effect(() => {
+		if (!workspaceId || !path) return
+		if (runtime.loadedRawAppPath !== path) return
+		const raw = runtime.rawApp.val
+		if (!raw) return
+		const draft = runtimeRawAppToDraft(raw)
+		const sig = JSON.stringify(draft)
+		if (sig === lastInboundSig) return
+		if (outboundTimer) clearTimeout(outboundTimer)
+		outboundTimer = setTimeout(() => {
+			untrack(() => {
+				const current = UserDraft.get<RawAppDraft>('raw_app', path, { workspace: workspaceId })
+				if (current && JSON.stringify(current) === sig) return
+				UserDraft.save('raw_app', path, draft, { workspace: workspaceId })
+			})
+		}, 150)
+		return () => {
+			if (outboundTimer) clearTimeout(outboundTimer)
+		}
+	})
+</script>
+
+{#if runtime.savedRawApp.val}
+	<DiffDrawer
+		bind:this={diffDrawer}
+		restoreDeployed={restoreFromCurrentTarget}
+		restoreDraft={restoreFromCurrentTarget}
+	/>
+{/if}
+{#if runtime.loadingRawApp && !runtime.loadedRawAppPath}
+	<div class="p-4 text-secondary text-sm">Loading raw app {path}…</div>
+{:else if runtime.notFoundRawApp && !runtime.loadedRawAppPath}
+	<SessionItemNotFound kind="raw_app" {path} {onNavigate} />
+{:else if runtime.rawApp.val}
+	<RawAppEditor
+		bind:files={runtime.rawApp.val.files}
+		bind:runnables={runtime.rawApp.val.runnables}
+		bind:data={runtime.rawApp.val.data}
+		bind:summary={runtime.rawApp.val.summary}
+		newPath={runtime.rawApp.val.path}
+		{path}
+		policy={runtime.rawApp.val.policy}
+		bind:savedApp={runtime.savedRawApp.val}
+		newApp={!runtime.savedRawApp.val}
+		{diffDrawer}
+		{onNavigate}
+		onDeploy={(e) => {
+			// Sync the preview to deployed (raw apps deploy only from this editor).
+			runtime.syncPreviewWithDeployed(workspaceId, 'raw_app', e.path)
+		}}
+		defaultSidebarCollapsed
+		sidebarStorageKey="raw-app-sidebar-collapsed-preview"
+		defaultSplitWithPreview={false}
+	/>
+{/if}
diff --git a/frontend/src/lib/components/sessions/ScriptEditorView.svelte b/frontend/src/lib/components/sessions/ScriptEditorView.svelte
new file mode 100644
index 0000000000..da7b7fcb53
--- /dev/null
+++ b/frontend/src/lib/components/sessions/ScriptEditorView.svelte
@@ -0,0 +1,224 @@
+<script lang="ts">
+	import ScriptBuilder from '$lib/components/ScriptBuilder.svelte'
+	import DiffDrawer from '$lib/components/DiffDrawer.svelte'
+	import type { WorkspaceItem } from '$lib/components/workspacePicker'
+	import { untrack } from 'svelte'
+	import type { SessionRuntime } from './sessionRuntime.svelte'
+	import { DraftService, ScriptService, type NewScript } from '$lib/gen'
+	import { UserDraft } from '$lib/userDraft.svelte'
+	import SessionItemNotFound from './SessionItemNotFound.svelte'
+	import { sendUserToast } from '$lib/toast'
+
+	let {
+		runtime,
+		path,
+		workspaceId,
+		onNavigate,
+		initialTestPanelCollapsed = false,
+		isActiveSession = true
+	}: {
+		runtime: SessionRuntime
+		path: string
+		workspaceId: string
+		onNavigate?: (item: WorkspaceItem) => void
+		initialTestPanelCollapsed?: boolean
+		/**
+		 * Only the visible session should claim the workspace's live-editor
+		 * slot — without this, a hidden warm-mounted session can overwrite the
+		 * active session's UserDraft live-editor target (one slot per
+		 * (workspace, kind)), so chat actions like discard / "the open editor"
+		 * resolve to the wrong session.
+		 */
+		isActiveSession?: boolean
+	} = $props()
+
+	let diffDrawer: DiffDrawer | undefined = $state()
+
+	$effect(() => {
+		if (workspaceId && path) {
+			untrack(() => runtime.loadScript(workspaceId, path))
+		}
+	})
+
+	// Restore actions for the diff drawer. The previous shared
+	// `loadScript`-based handler was a no-op: loadScript early-returns on the
+	// already-loaded path (and would re-read the local draft anyway). Instead
+	// reset the live UserDraft handle to the target baseline — the inbound
+	// effect then syncs the editor preview. Mirrors /scripts/edit's restore.
+	async function restoreDeployed() {
+		const saved = runtime.savedScript.val
+		if (!saved) {
+			sendUserToast('Could not restore to deployed', true)
+			return
+		}
+		diffDrawer?.closeDrawer()
+		// Drop the backend (DB) draft too, so "deployed" sticks across a reload.
+		if (saved.draft) {
+			try {
+				await DraftService.deleteDraft({ workspace: workspaceId, kind: 'script', path: saved.path })
+				saved.draft = undefined
+			} catch (e: any) {
+				sendUserToast(`Could not delete draft: ${e?.body ?? e}`, true)
+				return
+			}
+		}
+		const deployed = structuredClone($state.snapshot(saved)) as NewScript & { draft?: unknown }
+		delete deployed.draft
+		UserDraft.discard<NewScript>('script', path, deployed, { workspace: workspaceId })
+	}
+
+	async function restoreDraft() {
+		const backendDraft = runtime.savedScript.val?.draft as NewScript | undefined
+		if (!backendDraft) {
+			sendUserToast('Could not restore to draft', true)
+			return
+		}
+		diffDrawer?.closeDrawer()
+		UserDraft.discard<NewScript>('script', path, structuredClone($state.snapshot(backendDraft)), {
+			workspace: workspaceId
+		})
+	}
+
+	// Mark this editor as the live editor draft for the session's workspace
+	// so the chat's `isLiveDraft` hint / `discard_local_draft` tool resolve
+	// to this path — same registration the regular /scripts/edit page does.
+	// Gated on `isActiveSession`: warm-but-hidden session editors must not
+	// claim the workspace's single live-editor slot, else chat actions on the
+	// visible session resolve to the hidden one's path.
+	$effect(() => {
+		if (!workspaceId || !path) return
+		if (!isActiveSession) return
+		UserDraft.setLiveEditorDraft({
+			workspace: workspaceId,
+			itemKind: 'script',
+			storagePath: path,
+			effectivePath: runtime.scriptStore.val?.path ?? path
+		})
+		return () =>
+			UserDraft.clearLiveEditorDraft('script', { workspace: workspaceId, storagePath: path })
+	})
+
+	// Bidirectional sync between this preview and `UserDraft<NewScript>`.
+	// The same path under the same workspace is shared with the session's
+	// chat (read_workspace_item / write_script / edit_script) and any other
+	// open editor on the same workspace.
+	//
+	// We hold a *live* handle (useMany) instead of reading via the static
+	// `UserDraft.get`. The handle materializes UserDraft's shared reactive
+	// `$state` cell for (workspace, 'script', path) — and that cell is what
+	// lets the chat's writes (UserDraft.save, from write_script / edit_script)
+	// reach this preview. Without a live entry those writes only touch
+	// localStorage and the inbound effect below never re-fires. A reactive
+	// getter is used (not `use()`) because switching open_preview to another
+	// script swaps `path` without remounting this view, so the handle must
+	// re-acquire.
+	//
+	// One-way-reactive discipline: inbound tracks ONLY the handle's `draft`
+	// (and reads `script.content` via untrack); outbound tracks ONLY
+	// `script.content` (and reads UserDraft via untrack). Without that
+	// asymmetry, a user keystroke would re-fire the inbound effect with the
+	// pre-keystroke stored value and revert the edit.
+	const draftHandles = UserDraft.useMany<NewScript>(() => [
+		{ itemKind: 'script', path, workspace: workspaceId }
+	])
+	let lastInboundContent: string | undefined = $state(undefined)
+
+	// Store → editor. Re-runs when the handle's draft changes (chat write,
+	// other session edit, …). `script.content` is read inside untrack so user
+	// keystrokes don't refire this effect.
+	$effect(() => {
+		if (!workspaceId || !path) return
+		const draft = draftHandles[0]?.draft
+		if (!draft || typeof draft.content !== 'string') return
+		const incoming = draft.content
+		untrack(() => {
+			if (runtime.loadedScriptPath !== path) return
+			const script = runtime.scriptStore.val
+			if (!script) return
+			if (incoming === script.content) return
+			lastInboundContent = incoming
+			script.content = incoming
+			if (draft.language) script.language = draft.language
+			if (draft.summary !== undefined) script.summary = draft.summary
+		})
+	})
+
+	// Editor → store. Re-runs on `script.content` mutation (user typing
+	// or inbound write). UserDraft is read inside untrack so writing here
+	// doesn't ping-pong the inbound effect. `UserDraft.save` persists
+	// immediately and, now that the entry is live, updates the same cell the
+	// inbound effect reads (the content guard there makes it a no-op).
+	$effect(() => {
+		if (!workspaceId || !path) return
+		if (runtime.loadedScriptPath !== path) return
+		const script = runtime.scriptStore.val
+		if (!script) return
+		const content = script.content
+		if (content === lastInboundContent) return
+		untrack(() => {
+			const current = UserDraft.get<NewScript>('script', path, { workspace: workspaceId })
+			if (current && current.content === content) return
+			UserDraft.save<NewScript>(
+				'script',
+				path,
+				{ ...(current ?? script), ...script },
+				{
+					workspace: workspaceId
+				}
+			)
+		})
+	})
+</script>
+
+{#if runtime.savedScript.val}
+	<DiffDrawer bind:this={diffDrawer} {restoreDeployed} {restoreDraft} />
+{/if}
+{#if runtime.loadingScript && !runtime.loadedScriptPath}
+	<div class="p-4 text-secondary text-sm">Loading script {path}…</div>
+{:else if runtime.notFoundScript && !runtime.loadedScriptPath}
+	<SessionItemNotFound kind="script" {path} {onNavigate} />
+{:else if runtime.scriptStore.val}
+	<!--
+		A script with no backend version yet (AI-created, never saved or deployed
+		→ savedScript undefined) is a *new* script: pass an empty initialPath so
+		ScriptBuilder behaves exactly like /scripts/add — Save draft is enabled and
+		creates it on first save. On that save ScriptBuilder writes savedScript back
+		through the bind and sets its own initialPath to the path, flipping us into
+		edit mode (Save draft + Show diff) without navigating away.
+	-->
+	<ScriptBuilder
+		bind:script={runtime.scriptStore.val}
+		bind:savedScript={runtime.savedScript.val}
+		initialPath={runtime.savedScript.val ? path : ''}
+		initialPathChosen={true}
+		neverShowMeta={true}
+		fullyLoaded={!runtime.loadingScript}
+		disableHistoryChange={true}
+		{diffDrawer}
+		{onNavigate}
+		{initialTestPanelCollapsed}
+		onSaveDraft={async (e) => {
+			runtime.scheduleForkComparisonRefresh()
+			// Re-pin parent_hash to the latest version so the next Deploy's conflict
+			// check (which runs before deploy, while the session stays mounted)
+			// doesn't misfire.
+			try {
+				const latest = await ScriptService.getScriptLatestVersion({
+					workspace: workspaceId,
+					path: e.path
+				})
+				const cur = runtime.scriptStore.val
+				if (latest?.script_hash && cur) cur.parent_hash = latest.script_hash
+			} catch (err) {
+				console.error('Failed to sync parent_hash after save draft', err)
+			}
+		}}
+		onDeploy={(e) => {
+			// Fires on every deploy (primary, "Deploy & Stay here", and lib — we
+			// ignore e.stay since the session always stays). Toast, then sync the
+			// preview to the deployed version.
+			sendUserToast('Deployed')
+			runtime.syncPreviewWithDeployed(workspaceId, 'script', e.path)
+		}}
+	/>
+{/if}
diff --git a/frontend/src/lib/components/sessions/SessionForkBar.svelte b/frontend/src/lib/components/sessions/SessionForkBar.svelte
new file mode 100644
index 0000000000..9205c4c087
--- /dev/null
+++ b/frontend/src/lib/components/sessions/SessionForkBar.svelte
@@ -0,0 +1,213 @@
+<script lang="ts">
+	import {
+		Archive,
+		ArrowRight,
+		GitCompareArrows,
+		GitFork,
+		GitMerge,
+		GitPullRequestArrow,
+		GitPullRequestClosed,
+		MoveRight,
+		Trash2
+	} from 'lucide-svelte'
+	import { Button } from '$lib/components/common'
+	import WorkspaceFamilyPicker from './WorkspaceFamilyPicker.svelte'
+	import { userWorkspaces, workspaceStore } from '$lib/stores'
+	import { goto } from '$lib/navigation'
+	import { isRuleActive } from '$lib/workspaceProtectionRules.svelte'
+	import { isCloudHosted } from '$lib/cloud'
+	import { deriveForkStatus, sessionState, type Session } from './sessionState.svelte'
+	import { getRuntime } from './sessionRuntime.svelte'
+	import ForkDiffDrawer from './ForkDiffDrawer.svelte'
+
+	let {
+		session,
+		onMove,
+		onCreateForkAndMove,
+		onArchive,
+		onDelete
+	}: {
+		session: Session
+		onMove?: (workspaceId: string) => void
+		onCreateForkAndMove?: (fork: {
+			parent_workspace_id: string
+			id: string
+			name: string
+		}) => void | Promise<void>
+		onArchive?: () => void
+		onDelete?: () => void
+	} = $props()
+
+	// The fork bar surfaces a committed workspace relationship — only
+	// visible after the session locked its workspace at first send. Drafts
+	// (workspace_id undefined) get nothing here.
+	const committedId = $derived(session.workspace_id)
+	const sessionWorkspace = $derived(
+		committedId ? $userWorkspaces.find((w) => w.id === committedId) : undefined
+	)
+	const parentWorkspaceId = $derived(sessionWorkspace?.parent_workspace_id ?? undefined)
+	const parentWorkspace = $derived(
+		parentWorkspaceId ? $userWorkspaces.find((w) => w.id === parentWorkspaceId) : undefined
+	)
+	const isFork = $derived(!!parentWorkspaceId)
+
+	// Same gate as the sidebar WorkspaceMenu / SessionWorkspaceBar.
+	// When forking isn't available the diff/review surface is moot.
+	const forksAllowed = $derived(
+		!isCloudHosted() && !isRuleActive('DisableWorkspaceForking') && $workspaceStore !== 'admins'
+	)
+
+	let diffDrawer: ForkDiffDrawer | undefined = $state(undefined)
+
+	// Comparison data lives on the shared SessionRuntime resource so any
+	// future consumer (e.g. the diff drawer, a merge action) reads the
+	// same cache and can invalidate it after mutating the fork.
+	const runtime = $derived(getRuntime(session.id))
+	const comparison = $derived(runtime?.forkComparison.val)
+	const totalDiffs = $derived(comparison?.summary?.total_diffs ?? 0)
+	const forkStatus = $derived(deriveForkStatus(session, $userWorkspaces, comparison))
+	const isUnavailable = $derived(forkStatus === 'unavailable')
+
+	$effect(() => {
+		if (!runtime || !committedId || !parentWorkspaceId) return
+		void runtime.ensureForkComparison(parentWorkspaceId, committedId)
+	})
+
+	function refreshComparison() {
+		if (!runtime || !committedId || !parentWorkspaceId) return
+		runtime.invalidateForkComparison()
+		void runtime.ensureForkComparison(parentWorkspaceId, committedId)
+	}
+
+	// Refresh when the AI finishes a turn (loading transitions true →
+	// false). Tool calls in that turn may have created / edited / deleted
+	// fork items, so the diff count needs to reflect them immediately.
+	let wasLoading = $state(false)
+	$effect(() => {
+		const isLoading = runtime?.manager.loading ?? false
+		if (wasLoading && !isLoading) refreshComparison()
+		wasLoading = isLoading
+	})
+
+	// Refresh when the tab regains visibility — covers edits made in
+	// another tab or by another user while we were away.
+	$effect(() => {
+		if (!runtime || !committedId || !parentWorkspaceId) return
+		function onVisibilityChange() {
+			if (document.visibilityState !== 'visible') return
+			if (sessionState.currentSessionId !== session.id) return
+			refreshComparison()
+		}
+		document.addEventListener('visibilitychange', onVisibilityChange)
+		return () => document.removeEventListener('visibilitychange', onVisibilityChange)
+	})
+
+	export const refresh = refreshComparison
+
+	function openReview() {
+		if (!committedId || isUnavailable) return
+		goto(`/forks/compare?workspace_id=${encodeURIComponent(committedId)}`)
+	}
+</script>
+
+{#if committedId && isUnavailable}
+	<!-- Fork workspace is no longer in the user's list (deleted, archived,
+	     or access revoked). Surface an actionable banner: move the session
+	     to a still-valid workspace, or discard it (archive / delete). The
+	     chat input is disabled by SessionWrapper while this is shown. -->
+	<div class="flex flex-col gap-2 py-2 px-3 text-xs border rounded-md bg-surface-tertiary">
+		<div class="flex flex-row items-start gap-2">
+			<GitPullRequestClosed class="w-4 h-4 shrink-0 text-tertiary mt-0.5" />
+			<div class="flex flex-col min-w-0 flex-1">
+				<span class="text-primary font-medium">The fork has been archived or deleted</span>
+				<span class="text-2xs text-tertiary">
+					Move this session to another workspace, or discard it.
+					<span class="font-mono text-tertiary" title={committedId}>{committedId}</span>
+				</span>
+			</div>
+		</div>
+		<div class="flex flex-row items-center justify-end gap-1.5">
+			<WorkspaceFamilyPicker
+				onPick={(workspaceId) => onMove?.(workspaceId)}
+				onCreateFork={async (fork) => {
+					await onCreateForkAndMove?.(fork)
+				}}
+				createForkCaption="Created immediately and the session moved into it."
+			>
+				{#snippet trigger()}
+					<Button variant="default" unifiedSize="sm" startIcon={{ icon: MoveRight }}>
+						Move to workspace
+					</Button>
+				{/snippet}
+			</WorkspaceFamilyPicker>
+			<Button
+				variant="default"
+				unifiedSize="sm"
+				startIcon={{ icon: Archive }}
+				dropdownItems={[{ label: 'Delete', icon: Trash2, onClick: () => onDelete?.() }]}
+				onclick={() => onArchive?.()}
+			>
+				Archive
+			</Button>
+		</div>
+	</div>
+{:else if forksAllowed && isFork && sessionWorkspace && parentWorkspace && parentWorkspaceId && committedId}
+	{@const StatusIcon =
+		forkStatus === 'ahead'
+			? GitPullRequestArrow
+			: forkStatus === 'diverged'
+				? GitCompareArrows
+				: GitFork}
+	{@const statusColor =
+		forkStatus === 'ahead'
+			? 'text-blue-500'
+			: forkStatus === 'diverged'
+				? 'text-amber-500'
+				: 'text-secondary'}
+	{@const statusTitle =
+		forkStatus === 'ahead'
+			? 'Ahead of parent'
+			: forkStatus === 'diverged'
+				? 'Diverged from parent'
+				: forkStatus === 'in_sync'
+					? 'In sync with parent'
+					: 'Fork'}
+	<div
+		class="flex flex-row items-center justify-between gap-2 py-2 px-3 text-xs border rounded-md bg-surface-tertiary"
+	>
+		<div class="flex items-center gap-1.5 min-w-0">
+			<span title={statusTitle} class="inline-flex shrink-0">
+				<StatusIcon class="w-3.5 h-3.5 {statusColor}" />
+			</span>
+			<span class="truncate text-secondary" title={sessionWorkspace.name}>
+				{sessionWorkspace.name}
+			</span>
+			<ArrowRight class="w-3 h-3 shrink-0 text-tertiary" />
+			<span class="truncate text-secondary" title={parentWorkspace.name}>
+				{parentWorkspace.name}
+			</span>
+		</div>
+		<div class="flex items-center gap-1 shrink-0">
+			<Button
+				variant="subtle"
+				unifiedSize="xs"
+				startIcon={{ icon: GitCompareArrows }}
+				disabled={totalDiffs === 0}
+				title="{totalDiffs} modified item{totalDiffs === 1 ? '' : 's'}"
+				onclick={() => diffDrawer?.open()}
+			>
+				{totalDiffs}
+			</Button>
+			<Button
+				variant="default"
+				unifiedSize="xs"
+				startIcon={{ icon: GitMerge }}
+				onclick={openReview}
+			>
+				Review
+			</Button>
+		</div>
+	</div>
+
+	<ForkDiffDrawer bind:this={diffDrawer} forkWorkspaceId={committedId} {parentWorkspaceId} />
+{/if}
diff --git a/frontend/src/lib/components/sessions/SessionItemNotFound.svelte b/frontend/src/lib/components/sessions/SessionItemNotFound.svelte
new file mode 100644
index 0000000000..dc1a088c53
--- /dev/null
+++ b/frontend/src/lib/components/sessions/SessionItemNotFound.svelte
@@ -0,0 +1,54 @@
+<script lang="ts">
+	import EditorHeader from '$lib/components/EditorHeader.svelte'
+	import type { WorkspaceItem, WorkspaceItemKind } from '$lib/components/workspacePicker'
+	import type { SessionTarget } from './sessionState.svelte'
+
+	const KIND_NOT_FOUND_LABEL: Record<SessionTarget['kind'], string> = {
+		flow: 'Flow',
+		script: 'Script',
+		raw_app: 'Raw app'
+	}
+
+	let {
+		kind,
+		path,
+		onNavigate
+	}: {
+		kind: SessionTarget['kind']
+		path: string
+		onNavigate?: (item: WorkspaceItem) => void
+	} = $props()
+
+	// EditorHeader's `kind` prop is 'flow' | 'script' | 'app'; raw apps are
+	// flagged via the `raw_app` boolean so the picker routes to /apps_raw/...
+	const headerKind: WorkspaceItemKind = $derived(kind === 'raw_app' ? 'app' : kind)
+	const isRawApp = $derived(kind === 'raw_app')
+
+	// Local read-only mirrors so EditorHeader's bind:* doesn't write back into
+	// the parent's session state. The pen popover is disabled below so these
+	// stay quiet — but bindable references are still required by the API.
+	let summary = $state('')
+	let displayPath = $state(path)
+	$effect(() => {
+		displayPath = path
+	})
+</script>
+
+<div class="flex flex-col h-full">
+	<div class="flex h-12 items-center px-4 border-b border-border-light">
+		<EditorHeader
+			bind:summary
+			bind:path={displayPath}
+			savedPath={path}
+			kind={headerKind}
+			raw_app={isRawApp}
+			summaryEditable={false}
+			pathEditable={false}
+			{onNavigate}
+		/>
+	</div>
+	<div class="p-4 text-secondary text-sm">
+		{KIND_NOT_FOUND_LABEL[kind]} not found at path
+		<code class="font-mono">{path}</code>.
+	</div>
+</div>
diff --git a/frontend/src/lib/components/sessions/SessionPicker.svelte b/frontend/src/lib/components/sessions/SessionPicker.svelte
new file mode 100644
index 0000000000..31c463e79f
--- /dev/null
+++ b/frontend/src/lib/components/sessions/SessionPicker.svelte
@@ -0,0 +1,629 @@
+<script lang="ts">
+	import { Button } from '$lib/components/common'
+	import ConfirmationModal from '$lib/components/common/confirmationModal/ConfirmationModal.svelte'
+	import {
+		Archive,
+		ArchiveRestore,
+		ChevronDown,
+		ChevronRight,
+		EllipsisVertical,
+		Filter,
+		MessageSquare,
+		Pencil,
+		PencilLine,
+		Plus,
+		Trash2
+	} from 'lucide-svelte'
+	import { twMerge } from 'tailwind-merge'
+	import { goto } from '$lib/navigation'
+	import { page } from '$app/state'
+	import { useLocalStorageValue } from '$lib/svelte5Utils.svelte'
+	import { slide } from 'svelte/transition'
+	import {
+		createSession,
+		deriveForkStatus,
+		getEffectiveWorkspaceId,
+		isForkSession,
+		renameSession,
+		selectSession,
+		sessionState,
+		setSessionArchived,
+		syncWorkspaceTo,
+		type Session
+	} from './sessionState.svelte'
+	import { forgetSessionSeen, unreadCountFor } from './sessionUnread.svelte'
+	import Popover from '$lib/components/meltComponents/Popover.svelte'
+	import Toggle from '$lib/components/Toggle.svelte'
+	import {
+		getOrCreateRuntime,
+		getRuntime,
+		getSessionChatStatus,
+		removeSession
+	} from './sessionRuntime.svelte'
+	import SessionStatusDot from './SessionStatusDot.svelte'
+	import { Menu, Menubar, MenuItem } from '$lib/components/meltComponents'
+	import MenuButton from '$lib/components/sidebar/MenuButton.svelte'
+	import DropdownV2 from '$lib/components/DropdownV2.svelte'
+	import { visibleWorkspaceIds } from './sessionScope.svelte'
+	import { isGlobalAiEnabled } from '$lib/components/copilot/chat/global/gate'
+	import { userWorkspaces, usersWorkspaceStore, workspaceStore } from '$lib/stores'
+	import { WorkspaceService } from '$lib/gen'
+	import { sendUserToast } from '$lib/toast'
+
+	// Look up the cached fork comparison for a session through its runtime
+	// (if any). The deriveForkStatus helper handles the "no runtime yet"
+	// and "comparison not loaded" cases by returning undefined; we render
+	// a neutral fork icon in that interim, then upgrade to the proper
+	// status icon once the comparison lands.
+	function forkStatusFor(session: Session) {
+		return deriveForkStatus(session, $userWorkspaces, getRuntime(session.id)?.forkComparison.val)
+	}
+
+	function isForkFor(session: Session): boolean {
+		return isForkSession(session, $userWorkspaces)
+	}
+
+	// Compute the unread count for a session. Driven by the per-runtime
+	// displayMessages array vs. the localStorage-backed lastSeen map;
+	// both are reactive so the badge updates without polling.
+	function unreadFor(session: Session): number {
+		return unreadCountFor(session.id, getRuntime(session.id))
+	}
+
+	// Whether the composer for a session holds non-whitespace text. We
+	// read manager.instructions directly (not the derived chat status)
+	// so the draft cue still shows during streaming/needs-confirmation —
+	// those override the icon slot but shouldn't hide the fact that the
+	// user has unsent text in this session.
+	function hasDraft(session: Session): boolean {
+		const rt = getRuntime(session.id)
+		return !!rt && rt.manager.instructions.trim().length > 0
+	}
+
+	// Sessions piggyback on the same dev gate as the global AI chat — when
+	// the feature flag is off, the sidebar section is hidden entirely.
+	const globalEnabled = isGlobalAiEnabled()
+
+	// Only highlight the active session while we're actually on the session
+	// page — once the user navigates away, `currentSessionId` lingers but no
+	// row should appear selected.
+	const onSessionsPage = $derived(page.route.id?.includes('/sessions') ?? false)
+
+	interface Props {
+		isCollapsed?: boolean
+	}
+
+	let { isCollapsed = false }: Props = $props()
+
+	const sectionCollapsed = useLocalStorageValue(
+		'windmill_sessions_section_collapsed',
+		false,
+		'boolean'
+	)
+	const showArchived = useLocalStorageValue('windmill_sessions_show_archived', false, 'boolean')
+
+	let listRoot: HTMLDivElement | undefined = $state()
+
+	// Sessions visible in the current workspace (active workspace + its
+	// forks). Drafts (no committed workspace) are scoped by their
+	// pending workspace pick — set at create time to the workspace the
+	// user was in. Archived sessions are filtered out unless the user
+	// has opted in via the filter popover.
+	const visibleSessions = $derived(
+		sessionState.sessions.filter((s) => {
+			// Transient (not-yet-sent) sessions live as their own page but
+			// don't clutter the sidebar list.
+			if (s.transient) return false
+			if (s.archived && !showArchived.val) return false
+			const ws = getEffectiveWorkspaceId(s)
+			if (!ws) return false
+			if ($visibleWorkspaceIds.has(ws)) return true
+			// Unavailable sessions (committed workspace was deleted /
+			// archived / access revoked) stay visible everywhere so the
+			// user can resolve them — move, archive, or delete. They'd
+			// otherwise be permanently hidden the moment their workspace
+			// disappeared.
+			if (s.workspace_id && !$userWorkspaces.find((w) => w.id === s.workspace_id)) return true
+			return false
+		})
+	)
+	const archivedCount = $derived(
+		sessionState.sessions.filter((s) => {
+			if (!s.archived || s.transient) return false
+			const ws = getEffectiveWorkspaceId(s)
+			if (!ws) return false
+			if ($visibleWorkspaceIds.has(ws)) return true
+			if (s.workspace_id && !$userWorkspaces.find((w) => w.id === s.workspace_id)) return true
+			return false
+		}).length
+	)
+
+	// Sum of unread across every visible session — surfaced on the
+	// collapsed-sidebar chat icon so the user sees there's pending
+	// AI activity in some session without expanding the sidebar.
+	const totalUnread = $derived(visibleSessions.reduce((acc, s) => acc + unreadFor(s), 0))
+
+	// Clear any persisted collapsed state while the list is empty. The
+	// empty-state header is a plain label with no toggle, so a collapse
+	// carried over from a previous session (or another workspace) would
+	// otherwise hide the user's first new session with no way to expand
+	// it. Resetting here keeps the section expanded by default whenever
+	// the first session arrives. Guarded on the current value so it writes
+	// once (true → false) rather than looping.
+	$effect(() => {
+		if (visibleSessions.length === 0 && sectionCollapsed.val) {
+			sectionCollapsed.val = false
+		}
+	})
+
+	// Eagerly create a runtime per VISIBLE session so the status dot reflects
+	// the persisted chat (last message, pending confirmation, etc.) without
+	// requiring the user to open the session first. Sessions outside the
+	// current workspace scope are left cold to avoid opening IDB connections
+	// for unrelated work.
+	$effect(() => {
+		for (const session of visibleSessions) {
+			getOrCreateRuntime(session)
+		}
+	})
+
+	// Pre-fetch the fork comparison for every visible fork session so the
+	// sidebar icons reflect the right ahead/diverged state without
+	// requiring the user to click into each session. Cheap enough at
+	// typical session counts; falls back to a plain dot until the
+	// fetch lands.
+	$effect(() => {
+		if (sectionCollapsed.val) return
+		for (const session of visibleSessions) {
+			if (!session.workspace_id) continue
+			const ws = $userWorkspaces.find((w) => w.id === session.workspace_id)
+			if (!ws?.parent_workspace_id) continue
+			const rt = getRuntime(session.id)
+			if (!rt) continue
+			void rt.ensureForkComparison(ws.parent_workspace_id, session.workspace_id)
+		}
+	})
+
+	function isUnavailableFork(session: Session): boolean {
+		return !!session.workspace_id && !$userWorkspaces.find((w) => w.id === session.workspace_id)
+	}
+
+	async function activate(session: Session, restoreFocus: boolean = false) {
+		selectSession(session.id)
+		// If the session has a committed workspace different from the
+		// active one, switch globally so the editor/forks resolve correctly.
+		// Skip for unavailable forks — switching to a deleted workspace
+		// would error out and leave the user in limbo.
+		if (!isUnavailableFork(session)) {
+			syncWorkspaceTo(session.workspace_id)
+		}
+		// Refresh the fork diff count — users typically click back into a
+		// session after editing items elsewhere in the SPA, where neither
+		// the visibility-change nor the AI-loading signal would fire.
+		void getRuntime(session.id)?.refreshForkComparison()
+		await goto(`/sessions?session_name=${encodeURIComponent(session.name)}`)
+		if (restoreFocus) {
+			// goto() resets focus to <body> — put it back on the active session button
+			// so subsequent arrow keys keep navigating the list.
+			requestAnimationFrame(() => {
+				const selected = listRoot?.querySelector<HTMLButtonElement>(
+					'button[data-session-button][aria-selected="true"]'
+				)
+				selected?.focus()
+			})
+		}
+	}
+
+	async function createAndOpen() {
+		await activate(createSession())
+	}
+
+	let editingId: string | undefined = $state(undefined)
+	let renameDraft = $state('')
+
+	function startRename(session: Session) {
+		editingId = session.id
+		renameDraft = session.summary ?? ''
+	}
+
+	function commitRename() {
+		const id = editingId
+		if (!id) return
+		renameSession(id, renameDraft)
+		editingId = undefined
+	}
+
+	function cancelRename() {
+		editingId = undefined
+	}
+
+	let pendingDelete: Session | undefined = $state(undefined)
+	// Default to also deleting the fork: it's tied to this session and would be
+	// orphaned otherwise. The user can still untick it in the modal.
+	let deleteAlsoFork = $state(true)
+	// Fork workspace tied to `pendingDelete`, if any, and still accessible.
+	const pendingDeleteForkId = $derived.by(() => {
+		const wsId = pendingDelete?.workspace_id
+		if (!wsId || !wsId.startsWith('wm-fork-')) return undefined
+		const ws = $userWorkspaces.find((w) => w.id === wsId)
+		if (!ws || !ws.parent_workspace_id) return undefined
+		return wsId
+	})
+
+	async function handleConfirmedDelete() {
+		const session = pendingDelete
+		const forkToDelete = deleteAlsoFork ? pendingDeleteForkId : undefined
+		// Capture the fork's parent before the workspace list is refreshed
+		// below — afterwards the fork is gone from $userWorkspaces and the
+		// lookup would return undefined.
+		const forkParentId = forkToDelete
+			? $userWorkspaces.find((w) => w.id === forkToDelete)?.parent_workspace_id
+			: undefined
+		pendingDelete = undefined
+		deleteAlsoFork = true
+		if (!session) return
+		const wasActive = sessionState.currentSessionId === session.id
+		removeSession(session.id)
+		forgetSessionSeen(session.id)
+		if (forkToDelete) {
+			try {
+				await WorkspaceService.deleteWorkspace({ workspace: forkToDelete })
+				sendUserToast(`Deleted forked workspace ${forkToDelete}`)
+				usersWorkspaceStore.set(await WorkspaceService.listUserWorkspaces())
+			} catch (e: any) {
+				sendUserToast(`Failed to delete fork ${forkToDelete}: ${e?.body ?? e}`, true)
+			}
+		}
+		// If the deleted fork was the active workspace, fall back to its parent
+		// so the user isn't stranded on a workspace that no longer exists.
+		if (forkToDelete && forkParentId && $workspaceStore === forkToDelete) {
+			syncWorkspaceTo(forkParentId)
+		}
+		if (wasActive) {
+			const next = sessionState.sessions[0]
+			if (next) await activate(next)
+			else await goto('/sessions')
+		}
+	}
+
+	function focusAt(index: number) {
+		const buttons = listRoot
+			? Array.from(listRoot.querySelectorAll<HTMLButtonElement>('button[data-session-button]'))
+			: []
+		if (buttons.length === 0) return
+		const wrapped = ((index % buttons.length) + buttons.length) % buttons.length
+		buttons[wrapped]?.focus()
+	}
+
+	function handleListKeydown(e: KeyboardEvent) {
+		if (e.key !== 'ArrowDown' && e.key !== 'ArrowUp' && e.key !== 'Home' && e.key !== 'End') {
+			return
+		}
+		const buttons = listRoot
+			? Array.from(listRoot.querySelectorAll<HTMLButtonElement>('button[data-session-button]'))
+			: []
+		if (buttons.length === 0) return
+		const current = buttons.indexOf(document.activeElement as HTMLButtonElement)
+		e.preventDefault()
+		if (e.key === 'ArrowDown') focusAt(current < 0 ? 0 : current + 1)
+		else if (e.key === 'ArrowUp') focusAt(current < 0 ? buttons.length - 1 : current - 1)
+		else if (e.key === 'Home') focusAt(0)
+		else if (e.key === 'End') focusAt(buttons.length - 1)
+	}
+
+	const menuItemBase = twMerge(
+		'text-secondary text-left font-normal text-xs',
+		'flex flex-row items-center gap-2 px-3 py-1.5 w-full',
+		'data-[highlighted]:bg-surface-hover data-[highlighted]:text-primary'
+	)
+</script>
+
+{#if !globalEnabled}
+	<!-- Sessions hidden until the global-ai dev gate is enabled. -->
+{:else if isCollapsed}
+	<div class="px-2 pt-3 pb-2 border-b border-light dark:border-gray-700">
+		<Menubar>
+			{#snippet children({ createMenu })}
+				<Menu {createMenu} usePointerDownOutside>
+					{#snippet triggr({ trigger })}
+						<div class="relative">
+							<MenuButton
+								class="!text-xs"
+								icon={MessageSquare}
+								label="AI sessions"
+								{isCollapsed}
+								{trigger}
+							/>
+							{#if totalUnread > 0}
+								<span
+									class="absolute top-1 right-1 pointer-events-none inline-block w-2 h-2 rounded-full bg-blue-500"
+									aria-label="{totalUnread} unread message{totalUnread === 1
+										? ''
+										: 's'} across all sessions"
+								></span>
+							{/if}
+						</div>
+					{/snippet}
+					{#snippet children({ item })}
+						<div class="divide-y min-w-48" role="none">
+							<div class="py-1" role="none">
+								<MenuItem class={menuItemBase} onClick={createAndOpen} {item}>
+									<Plus size={14} />
+									New session
+								</MenuItem>
+							</div>
+							<div class="py-1" role="none">
+								{#each visibleSessions as session (session.id)}
+									{@const runtime = getRuntime(session.id)}
+									{@const status = runtime ? getSessionChatStatus(runtime) : 'idle'}
+									{@const isSelected =
+										onSessionsPage && session.id === sessionState.currentSessionId}
+									{@const unread = unreadFor(session)}
+									{@const draft = hasDraft(session)}
+									<MenuItem
+										class={twMerge(menuItemBase, isSelected ? 'bg-surface-hover' : '')}
+										onClick={() => activate(session)}
+										{item}
+									>
+										<SessionStatusDot
+											{status}
+											isFork={isForkFor(session)}
+											forkStatus={forkStatusFor(session)}
+										/>
+										<span
+											class={twMerge(
+												'truncate flex-1 text-left',
+												unread > 0 ? 'font-semibold text-primary' : ''
+											)}
+										>
+											{session.summary ?? 'Untitled session'}
+										</span>
+										{#if draft || unread > 0}
+											<span class="ml-auto shrink-0 inline-flex items-center gap-1">
+												{#if draft}
+													<PencilLine class="w-3 h-3 text-tertiary" aria-label="Unsent draft" />
+												{/if}
+												{#if unread > 0}
+													<span
+														class="inline-flex items-center justify-center rounded-full bg-blue-500 text-white font-medium leading-none min-w-4 h-4 px-1 text-[10px]"
+														aria-label="{unread} unread message{unread === 1 ? '' : 's'}"
+													>
+														{unread > 9 ? '9+' : unread}
+													</span>
+												{/if}
+											</span>
+										{/if}
+									</MenuItem>
+								{/each}
+							</div>
+						</div>
+					{/snippet}
+				</Menu>
+			{/snippet}
+		</Menubar>
+	</div>
+{:else}
+	<div class="px-2 pt-3 pb-2 flex flex-col gap-1 border-b border-light dark:border-gray-700">
+		<div class="flex flex-row items-center justify-between pl-1 pr-0.5">
+			{#if visibleSessions.length > 0}
+				<button
+					type="button"
+					onclick={() => (sectionCollapsed.val = !sectionCollapsed.val)}
+					class="text-secondary text-[0.5rem] uppercase flex flex-row items-center gap-1 rounded px-1 -mx-1 py-0.5 hover:bg-surface-hover focus:outline-none"
+					aria-expanded={!sectionCollapsed.val}
+				>
+					AI sessions
+					{#if sectionCollapsed.val}
+						<ChevronRight size={10} />
+					{:else}
+						<ChevronDown size={10} />
+					{/if}
+				</button>
+			{:else}
+				<!-- No sessions yet: render the label as plain text (no collapse toggle). -->
+				<span
+					class="text-secondary text-[0.5rem] uppercase flex flex-row items-center gap-1 px-1 -mx-1 py-0.5"
+				>
+					AI sessions
+				</span>
+			{/if}
+			<div class="flex flex-row items-center gap-0.5">
+				<Popover placement="bottom-end" usePointerDownOutside disableFocusTrap class="inline-flex">
+					{#snippet trigger()}
+						<button
+							type="button"
+							title="Filter sessions"
+							aria-label="Filter sessions"
+							class="inline-flex items-center justify-center w-5 h-5 rounded text-tertiary hover:bg-surface-hover hover:text-primary {showArchived.val
+								? 'text-emphasis'
+								: ''}"
+						>
+							<Filter size={12} />
+						</button>
+					{/snippet}
+					{#snippet content()}
+						<div
+							class="w-56 p-2 bg-surface-tertiary dark:border rounded-md shadow-lg flex flex-col gap-1"
+						>
+							<Toggle
+								bind:checked={showArchived.val}
+								size="xs"
+								options={{ right: 'Show archived' }}
+							/>
+							{#if archivedCount > 0}
+								<span class="text-2xs text-tertiary pl-1">
+									{archivedCount} archived session{archivedCount === 1 ? '' : 's'}
+								</span>
+							{/if}
+						</div>
+					{/snippet}
+				</Popover>
+				<Button
+					variant="subtle"
+					size="xs2"
+					iconOnly
+					startIcon={{ icon: Plus }}
+					onclick={createAndOpen}
+					title="New session"
+				/>
+			</div>
+		</div>
+		{#if !sectionCollapsed.val}
+			<div
+				bind:this={listRoot}
+				transition:slide={{ duration: 180 }}
+				class="flex flex-col gap-0.5 max-h-[40vh] overflow-y-auto"
+				onkeydown={handleListKeydown}
+				role="listbox"
+				tabindex="-1"
+			>
+				{#each visibleSessions as session (session.id)}
+					{@const runtime = getRuntime(session.id)}
+					{@const status = runtime ? getSessionChatStatus(runtime) : 'idle'}
+					{@const isSelected = onSessionsPage && session.id === sessionState.currentSessionId}
+					{@const isEditing = editingId === session.id}
+					{@const unread = unreadFor(session)}
+					{@const draft = hasDraft(session)}
+					<div
+						class={twMerge(
+							'flex flex-row items-center group rounded',
+							isSelected ? 'bg-surface-hover text-primary' : 'hover:bg-surface-hover',
+							session.archived ? 'italic opacity-60' : ''
+						)}
+					>
+						{#if isEditing}
+							<span class="flex flex-row items-center gap-2 flex-1 px-2 py-1 min-w-0">
+								<SessionStatusDot
+									{status}
+									isFork={isForkFor(session)}
+									forkStatus={forkStatusFor(session)}
+								/>
+								<!-- svelte-ignore a11y_autofocus -->
+								<input
+									type="text"
+									bind:value={renameDraft}
+									onkeydown={(e) => {
+										if (e.key === 'Enter') commitRename()
+										else if (e.key === 'Escape') cancelRename()
+									}}
+									onblur={commitRename}
+									placeholder="Untitled session"
+									autofocus
+									spellcheck="false"
+									class="flex-1 min-w-0 bg-transparent border-0 outline-none text-xs font-normal text-primary"
+								/>
+							</span>
+						{:else}
+							<button
+								type="button"
+								data-session-button
+								role="option"
+								aria-selected={isSelected}
+								onclick={() => activate(session)}
+								class={twMerge(
+									'flex flex-row items-center gap-2 text-left text-xs font-normal focus:outline-none flex-1 min-w-0 px-2 py-1',
+									unread > 0 ? 'text-primary font-semibold' : 'text-secondary'
+								)}
+							>
+								<SessionStatusDot
+									{status}
+									isFork={isForkFor(session)}
+									forkStatus={forkStatusFor(session)}
+								/>
+								<span class="truncate flex-1">{session.summary ?? 'Untitled session'}</span>
+								{#if draft || unread > 0}
+									<span class="shrink-0 inline-flex items-center gap-1">
+										{#if draft}
+											<PencilLine class="w-3 h-3 text-tertiary" aria-label="Unsent draft" />
+										{/if}
+										{#if unread > 0}
+											<span
+												class="inline-flex items-center justify-center rounded-full bg-blue-500 text-white font-medium leading-none min-w-4 h-4 px-1 text-[10px]"
+												aria-label="{unread} unread message{unread === 1 ? '' : 's'}"
+											>
+												{unread > 9 ? '9+' : unread}
+											</span>
+										{/if}
+									</span>
+								{/if}
+							</button>
+							<div
+								class="opacity-0 group-hover:opacity-100 focus-within:opacity-100 transition-opacity pr-0.5"
+							>
+								<DropdownV2
+									fixedHeight={false}
+									placement="bottom-end"
+									items={[
+										{
+											displayName: 'Rename',
+											icon: Pencil,
+											action: () => startRename(session)
+										},
+										session.archived
+											? {
+													displayName: 'Unarchive',
+													icon: ArchiveRestore,
+													action: () => setSessionArchived(session.id, false)
+												}
+											: {
+													displayName: 'Archive',
+													icon: Archive,
+													action: () => setSessionArchived(session.id, true)
+												},
+										{
+											displayName: 'Delete',
+											icon: Trash2,
+											type: 'delete',
+											action: () => (pendingDelete = session)
+										}
+									]}
+								>
+									{#snippet buttonReplacement()}
+										<span
+											class="inline-flex items-center justify-center w-5 h-5 rounded text-tertiary hover:bg-surface-hover hover:text-primary"
+											title="More"
+										>
+											<EllipsisVertical size={14} />
+										</span>
+									{/snippet}
+								</DropdownV2>
+							</div>
+						{/if}
+					</div>
+				{/each}
+			</div>
+		{/if}
+	</div>
+{/if}
+
+<ConfirmationModal
+	open={!!pendingDelete}
+	title="Delete session"
+	confirmationText="Delete"
+	onConfirmed={handleConfirmedDelete}
+	onCanceled={() => {
+		pendingDelete = undefined
+		deleteAlsoFork = true
+	}}
+>
+	<div class="flex flex-col gap-3">
+		<p>
+			Delete session <span class="font-medium text-primary"
+				>{pendingDelete?.summary ?? pendingDelete?.name}</span
+			>? This cannot be undone.
+		</p>
+		{#if pendingDeleteForkId}
+			<div class="flex items-start gap-2 border rounded-md p-3 bg-surface-secondary">
+				<Toggle size="xs" bind:checked={deleteAlsoFork} />
+				<div class="flex flex-col">
+					<span class="text-xs font-medium text-primary"
+						>Also delete forked workspace <span class="font-mono">{pendingDeleteForkId}</span></span
+					>
+					<span class="text-3xs text-tertiary"
+						>The fork won't be reachable from any other session — leaving it would orphan it.</span
+					>
+				</div>
+			</div>
+		{/if}
+	</div>
+</ConfirmationModal>
diff --git a/frontend/src/lib/components/sessions/SessionStatusDot.svelte b/frontend/src/lib/components/sessions/SessionStatusDot.svelte
new file mode 100644
index 0000000000..b47816ab19
--- /dev/null
+++ b/frontend/src/lib/components/sessions/SessionStatusDot.svelte
@@ -0,0 +1,98 @@
+<script lang="ts">
+	import {
+		AlertCircle,
+		AlertTriangle,
+		Building,
+		GitCompareArrows,
+		GitFork,
+		GitPullRequestArrow,
+		GitPullRequestClosed
+	} from 'lucide-svelte'
+	import type { SessionChatStatus } from './sessionRuntime.svelte'
+	import type { ForkStatus } from './sessionState.svelte'
+
+	let {
+		status,
+		isFork,
+		forkStatus
+	}: { status: SessionChatStatus; isFork: boolean; forkStatus?: ForkStatus } = $props()
+
+	const statusTooltip: Record<SessionChatStatus, string> = {
+		idle: 'No chat activity',
+		streaming: 'Generating response…',
+		'awaiting-user': 'Waiting for your reply',
+		'needs-confirmation': 'Needs your confirmation',
+		draft: 'Unsent draft',
+		error: 'Last message had an error'
+	}
+
+	const forkTooltip: Record<ForkStatus, string> = {
+		in_sync: 'Fork — in sync with parent',
+		ahead: 'Fork — ahead of parent',
+		diverged: 'Fork — diverged from parent',
+		unavailable: 'Fork — no longer available'
+	}
+
+	// Live chat signals take precedence over the persistent kind/fork
+	// indicator: streaming, needs-confirmation, and error are time-critical
+	// and warrant briefly hijacking the icon slot.
+	const liveOverride = $derived(
+		status === 'streaming' || status === 'needs-confirmation' || status === 'error'
+	)
+
+	const persistentTitle = $derived(
+		isFork ? (forkStatus ? forkTooltip[forkStatus] : 'Fork session') : 'Root workspace session'
+	)
+
+	const title = $derived(liveOverride ? statusTooltip[status] : persistentTitle)
+</script>
+
+<span class="inline-flex items-center justify-center w-4 h-3 shrink-0" {title}>
+	{#if status === 'streaming'}
+		<span class="inline-flex items-end gap-0.5">
+			<span class="w-1 h-1 rounded-full bg-blue-500 typing-dot"></span>
+			<span class="w-1 h-1 rounded-full bg-blue-500 typing-dot dot-2"></span>
+			<span class="w-1 h-1 rounded-full bg-blue-500 typing-dot dot-3"></span>
+		</span>
+	{:else if status === 'needs-confirmation'}
+		<AlertCircle class="w-3 h-3 text-amber-500" />
+	{:else if status === 'error'}
+		<AlertTriangle class="w-3 h-3 text-red-500" />
+	{:else if isFork}
+		{#if forkStatus === 'ahead'}
+			<GitPullRequestArrow class="w-3 h-3 text-blue-500" />
+		{:else if forkStatus === 'diverged'}
+			<GitCompareArrows class="w-3 h-3 text-amber-500" />
+		{:else if forkStatus === 'unavailable'}
+			<GitPullRequestClosed class="w-3 h-3 text-red-500" />
+		{:else}
+			<GitFork class="w-3 h-3 text-tertiary" />
+		{/if}
+	{:else}
+		<Building class="w-3 h-3 text-tertiary" />
+	{/if}
+</span>
+
+<style>
+	.typing-dot {
+		animation: typing 1.2s ease-in-out infinite;
+	}
+	.dot-2 {
+		animation-delay: 0.15s;
+	}
+	.dot-3 {
+		animation-delay: 0.3s;
+	}
+	@keyframes typing {
+		0%,
+		60%,
+		100% {
+			opacity: 0.3;
+			transform: translateY(0);
+		}
+		30% {
+			opacity: 1;
+			transform: translateY(-1px);
+		}
+	}
+</style>
diff --git a/frontend/src/lib/components/sessions/SessionWorkspaceBar.svelte b/frontend/src/lib/components/sessions/SessionWorkspaceBar.svelte
new file mode 100644
index 0000000000..310d43e5be
--- /dev/null
+++ b/frontend/src/lib/components/sessions/SessionWorkspaceBar.svelte
@@ -0,0 +1,75 @@
+<script lang="ts">
+	import { userWorkspaces, workspaceStore, type UserWorkspace } from '$lib/stores'
+	import {
+		getEffectiveWorkspaceId,
+		setSessionPendingFork,
+		setSessionPendingWorkspace,
+		syncWorkspaceTo,
+		type Session
+	} from './sessionState.svelte'
+	import WorkspaceFamilyPicker from './WorkspaceFamilyPicker.svelte'
+	import { Building, ChevronDown, GitFork } from 'lucide-svelte'
+
+	let { session }: { session: Session } = $props()
+
+	function findRoot(id: string | undefined, all: UserWorkspace[]): UserWorkspace | undefined {
+		if (!id) return undefined
+		let current = all.find((w) => w.id === id)
+		while (current?.parent_workspace_id) {
+			const parent = all.find((w) => w.id === current!.parent_workspace_id)
+			if (!parent) break
+			current = parent
+		}
+		return current
+	}
+
+	// Effective workspace for display: committed → pending pick → active store.
+	const effectiveId = $derived(getEffectiveWorkspaceId(session) ?? $workspaceStore ?? undefined)
+	const root = $derived(findRoot(effectiveId, $userWorkspaces))
+	const currentWs = $derived(
+		effectiveId ? $userWorkspaces.find((w) => w.id === effectiveId) : undefined
+	)
+	const pendingFork = $derived(session.pending_fork)
+
+	function pick(id: string) {
+		// Pre-send only: writes the pending pick. workspace_id stays
+		// undefined until the user sends their first message.
+		setSessionPendingWorkspace(session.id, id)
+		syncWorkspaceTo(id)
+	}
+
+	function stageFork(req: { parent_workspace_id: string; id: string; name: string }) {
+		setSessionPendingFork(session.id, req)
+		syncWorkspaceTo(req.parent_workspace_id)
+	}
+</script>
+
+<div class="flex flex-row items-center gap-1 py-0.5 px-1 text-2xs text-secondary">
+	<span class="shrink-0">Run in</span>
+	<WorkspaceFamilyPicker
+		selectedId={effectiveId}
+		{pendingFork}
+		onPick={pick}
+		onCreateFork={stageFork}
+		createForkCaption="Created when you send your first message."
+	>
+		{#snippet trigger()}
+			<span
+				class="inline-flex flex-row items-center gap-1 px-1.5 py-0.5 rounded hover:bg-surface-hover text-2xs"
+			>
+				{#if pendingFork || (currentWs && currentWs.id !== root?.id)}
+					<GitFork class="w-3 h-3 shrink-0" />
+				{:else}
+					<Building class="w-3 h-3 shrink-0" />
+				{/if}
+				<span class="font-medium text-primary truncate max-w-[180px]">
+					{pendingFork?.name ?? currentWs?.name ?? effectiveId ?? 'Pick workspace'}
+				</span>
+				{#if pendingFork}
+					<span class="text-2xs text-tertiary italic shrink-0">(new)</span>
+				{/if}
+				<ChevronDown class="w-3 h-3 shrink-0 text-tertiary" />
+			</span>
+		{/snippet}
+	</WorkspaceFamilyPicker>
+</div>
diff --git a/frontend/src/lib/components/sessions/SessionWrapper.svelte b/frontend/src/lib/components/sessions/SessionWrapper.svelte
new file mode 100644
index 0000000000..002ecbfef0
--- /dev/null
+++ b/frontend/src/lib/components/sessions/SessionWrapper.svelte
@@ -0,0 +1,513 @@
+<script lang="ts">
+	import { setContext } from 'svelte'
+	import { Pane, Splitpanes } from 'svelte-splitpanes'
+	import AIChat from '$lib/components/copilot/chat/AIChat.svelte'
+	import EditableInput from '$lib/components/common/EditableInput.svelte'
+	import { Button } from '$lib/components/common'
+	import ConfirmationModal from '$lib/components/common/confirmationModal/ConfirmationModal.svelte'
+	import DropdownV2 from '$lib/components/DropdownV2.svelte'
+	import { AIChatManager } from '$lib/components/copilot/chat/AIChatManager.svelte'
+	import { userWorkspaces, usersWorkspaceStore, workspaceStore } from '$lib/stores'
+	import { WorkspaceService } from '$lib/gen'
+	import { sendUserToast } from '$lib/toast'
+	import Toggle from '$lib/components/Toggle.svelte'
+	import { copilotInfo, loadCopilot } from '$lib/aiStore'
+	import {
+		Archive,
+		ArchiveRestore,
+		EllipsisVertical,
+		PanelRightClose,
+		PanelRightOpen,
+		Pencil,
+		Trash2
+	} from 'lucide-svelte'
+	import type { WorkspaceItem } from '$lib/components/workspacePicker'
+	import Popover from '$lib/components/meltComponents/Popover.svelte'
+	import WorkspaceItemDrillPicker from '$lib/components/WorkspaceItemDrillPicker.svelte'
+	import FlowEditorView from './FlowEditorView.svelte'
+	import ScriptEditorView from './ScriptEditorView.svelte'
+	import RawAppEditorView from './RawAppEditorView.svelte'
+	import SessionWorkspaceBar from './SessionWorkspaceBar.svelte'
+	import SessionForkBar from './SessionForkBar.svelte'
+	import {
+		createSession,
+		getEffectiveWorkspaceId,
+		moveSessionToNewFork,
+		moveSessionToWorkspace,
+		persistSessions,
+		selectSession,
+		sessionState,
+		setSessionArchived,
+		setSessionTarget,
+		syncWorkspaceTo,
+		type SessionTarget
+	} from './sessionState.svelte'
+	import { editorWarmIds, getOrCreateRuntime, removeSession } from './sessionRuntime.svelte'
+	import { goto } from '$lib/navigation'
+	import { slide } from 'svelte/transition'
+
+	let { sessionId }: { sessionId: string } = $props()
+
+	// LRU-warm sessions get their editor pane mounted; others render
+	// chat-only. Reading from the reactive Set keeps SessionWrapper in
+	// sync with promoteEditorWarm without an explicit prop round-trip
+	// through the page route.
+	const mountEditor = $derived(editorWarmIds.has(sessionId))
+
+	// Parent keys by sessionId; this wrapper only mounts when the session exists.
+	// Captured at script-init so we can synchronously bind context.
+	const initialSession = sessionState.sessions.find((s) => s.id === sessionId)
+	const runtime = initialSession ? getOrCreateRuntime(initialSession) : undefined
+
+	if (runtime) {
+		setContext<AIChatManager>('aiChatManager', runtime.manager)
+	}
+
+	// Reactive session reference (mutations to summary/target propagate via the $state proxy)
+	const session = $derived(sessionState.sessions.find((s) => s.id === sessionId))
+
+	$effect(() => {
+		if ($workspaceStore) {
+			loadCopilot($workspaceStore)
+		}
+	})
+
+	let summaryInput: EditableInput | undefined = $state(undefined)
+
+	// Drop the user on a fresh new-session page. Used after archiving or
+	// deleting the open session: the session they were on is no longer
+	// usable, and routing to a sibling would feel arbitrary.
+	async function resetToNewSession() {
+		const fresh = createSession()
+		selectSession(fresh.id)
+		await goto(`/sessions?session_name=${encodeURIComponent(fresh.name)}`)
+	}
+
+	// If the session targets a forked workspace that's still accessible,
+	// offer to delete / archive the fork alongside the session — otherwise
+	// the fork lingers as an orphan whose only purpose was this session.
+	const sessionForkId = $derived.by(() => {
+		const wsId = session?.workspace_id
+		if (!wsId || !wsId.startsWith('wm-fork-')) return undefined
+		const ws = $userWorkspaces.find((w) => w.id === wsId)
+		// Don't offer the option if the fork is gone or not user-accessible.
+		if (!ws || !ws.parent_workspace_id) return undefined
+		return wsId
+	})
+
+	let deleteConfirmOpen = $state(false)
+	let deleteAlsoFork = $state(false)
+	let archiveConfirmOpen = $state(false)
+	let archiveAlsoFork = $state(false)
+
+	async function refreshWorkspaceList() {
+		// Match the SidebarContent.deleteFork pattern: replace the in-memory
+		// list rather than nulling it. See B1 fix.
+		try {
+			usersWorkspaceStore.set(await WorkspaceService.listUserWorkspaces())
+		} catch (e) {
+			console.error('Failed to refresh workspaces', e)
+		}
+	}
+
+	async function handleConfirmedDelete() {
+		deleteConfirmOpen = false
+		if (!session) return
+		const forkToDelete = deleteAlsoFork ? sessionForkId : undefined
+		// Capture the fork's parent before the workspace list is refreshed
+		// below — afterwards the fork is gone from $userWorkspaces.
+		const forkParentId = forkToDelete
+			? $userWorkspaces.find((w) => w.id === forkToDelete)?.parent_workspace_id
+			: undefined
+		deleteAlsoFork = false
+		removeSession(session.id)
+		if (forkToDelete) {
+			try {
+				await WorkspaceService.deleteWorkspace({ workspace: forkToDelete })
+				sendUserToast(`Deleted forked workspace ${forkToDelete}`)
+				await refreshWorkspaceList()
+			} catch (e: any) {
+				sendUserToast(`Failed to delete fork ${forkToDelete}: ${e?.body ?? e}`, true)
+			}
+		}
+		// If the deleted fork was the active workspace, fall back to its parent
+		// so the new session (created below) opens against a live workspace
+		// instead of the one we just removed.
+		if (forkToDelete && forkParentId && $workspaceStore === forkToDelete) {
+			syncWorkspaceTo(forkParentId)
+		}
+		await resetToNewSession()
+	}
+
+	async function handleConfirmedArchive() {
+		archiveConfirmOpen = false
+		if (!session) return
+		const forkToArchive = archiveAlsoFork ? sessionForkId : undefined
+		archiveAlsoFork = false
+		setSessionArchived(session.id, true)
+		if (forkToArchive) {
+			try {
+				await WorkspaceService.archiveWorkspace({ workspace: forkToArchive })
+				sendUserToast(`Archived forked workspace ${forkToArchive}`)
+				await refreshWorkspaceList()
+			} catch (e: any) {
+				sendUserToast(`Failed to archive fork ${forkToArchive}: ${e?.body ?? e}`, true)
+			}
+		}
+		await resetToNewSession()
+	}
+
+	// Kept for the "Archive" entry that doesn't go through the confirmation
+	// modal — when the session isn't in a fork, no extra question to ask.
+	async function archiveAndReset() {
+		if (!session) return
+		// If the session is in a fork, route through the confirm modal so the
+		// user can opt into archiving the fork. Otherwise skip the modal.
+		if (sessionForkId) {
+			archiveAlsoFork = false
+			archiveConfirmOpen = true
+			return
+		}
+		setSessionArchived(session.id, true)
+		await resetToNewSession()
+	}
+
+	// Workspace bar is shown only before the session sends its first user
+	// message — after that the session's workspace is immutable. The
+	// commit itself happens in `AIChatManager.beforeSend` (wired in
+	// `createRuntime`) so it fires exactly once at send-time. A reactive
+	// commit here would retry forever on backend failures (e.g. fork-id
+	// collision after a previously-successful create whose response was
+	// dropped) — restoration self-heal lives in `initRuntime` instead.
+	const hasFirstUserMessage = $derived(
+		runtime?.manager.displayMessages.some((m) => m.role === 'user') ?? false
+	)
+
+	// Effective workspace for routing editor views — committed if set,
+	// otherwise the pending pick, otherwise the current active workspace.
+	const effectiveWorkspaceId = $derived(
+		session ? (getEffectiveWorkspaceId(session) ?? $workspaceStore ?? '') : ''
+	)
+
+	// Core mutation: assign a target via the canonical setter, then re-open
+	// the editor pane. Shared by every code path that swaps the session's
+	// editor target (drill picker, fork-bar dropdown, …).
+	function applyEditorTarget(target: SessionTarget, summary?: string) {
+		if (!session) return
+		setSessionTarget(session.id, target, summary)
+		// Picking a target also re-opens the editor pane (the user just chose
+		// what to view).
+		editorVisible = true
+	}
+
+	function pickEditorTarget(item: WorkspaceItem) {
+		// Legacy drag-and-drop apps aren't hosted in the session preview pane —
+		// open them in the standalone app editor instead. Only code-based raw
+		// apps (item.raw_app) are previewable here.
+		if (item.kind === 'app' && !item.raw_app) {
+			goto(`/apps/edit/${item.path}?workspace=${effectiveWorkspaceId}`)
+			return
+		}
+		// WorkspaceItem.kind is 'flow'|'script'|'app'; any 'app' reaching here is
+		// a raw app. The diff-API uses 'raw_app' as its kind so we align
+		// SessionTarget on the same canonical string.
+		const kind: SessionTarget['kind'] = item.kind === 'app' ? 'raw_app' : item.kind
+		applyEditorTarget({ kind, path: item.path }, item.summary)
+	}
+
+	// Editor pane visibility. Toggling this just hides/shows the pane via CSS
+	// — the editor stays mounted, so re-opening doesn't pay a remount cost
+	// and xy-flow / Monaco keep their viewport state.
+	let editorVisible = $state(true)
+
+	// Focus the chat input whenever this session is the active one.
+	// The textarea is disabled until copilotInfo loads (otherwise focus is
+	// a silent no-op), so we wait for that too. Triggers on initial mount,
+	// warm-session switch via the picker, and the moment copilot finishes
+	// loading.
+	let aiChat: AIChat | undefined = $state(undefined)
+	$effect(() => {
+		if (sessionState.currentSessionId !== sessionId) return
+		if (!aiChat) return
+		if (!$copilotInfo.enabled) return
+		const chat = aiChat
+		setTimeout(() => chat.focusInput(), 0)
+	})
+
+	// True when the session committed to a workspace that's no longer in
+	// the user's list (deleted / archived / access revoked). The chat is
+	// disabled and SessionForkBar shows a move/discard banner.
+	const isUnavailable = $derived(
+		!!session?.workspace_id && !$userWorkspaces.find((w) => w.id === session!.workspace_id)
+	)
+
+	async function moveAndActivate(targetWorkspaceId: string) {
+		if (!session) return
+		moveSessionToWorkspace(session.id, targetWorkspaceId)
+		// Point the app at the moved-to workspace too. Without this the global
+		// workspace stays on the old (now-unavailable) one, so scope/editor keep
+		// resolving against a dead workspace — mirrors what moveSessionToNewFork
+		// does internally and handleConfirmedDelete does explicitly.
+		syncWorkspaceTo(targetWorkspaceId)
+	}
+
+	async function createForkAndMove(fork: {
+		parent_workspace_id: string
+		id: string
+		name: string
+	}) {
+		if (!session) return
+		await moveSessionToNewFork(session.id, fork)
+	}
+</script>
+
+{#if !session || !runtime}
+	<div class="p-8 text-secondary text-sm">Session not found</div>
+{:else}
+	{@const hasTarget =
+		session.target?.kind === 'flow' ||
+		session.target?.kind === 'script' ||
+		session.target?.kind === 'raw_app'}
+	{@const hasEditor = mountEditor && hasTarget && editorVisible}
+
+	{#snippet inputPreface()}
+		{#if !hasFirstUserMessage}
+			<SessionWorkspaceBar {session} />
+		{/if}
+		<SessionForkBar
+			{session}
+			onMove={(workspaceId) => moveAndActivate(workspaceId)}
+			onCreateForkAndMove={(fork) => createForkAndMove(fork)}
+			onArchive={() => archiveAndReset()}
+			onDelete={() => (deleteConfirmOpen = true)}
+		/>
+	{/snippet}
+
+	<!-- Override the chat's default keyboard-shortcut hint with nothing —
+	     sessions have their own empty-state affordances above. -->
+	{#snippet sessionEmptyHint()}{/snippet}
+
+	<Splitpanes horizontal={false} class="flex-1 min-h-0 splitter-hidden">
+		<Pane size={hasEditor ? 50 : 100} minSize={25} class="flex flex-col min-h-0 pb-2">
+			<header class="flex flex-row items-center gap-1 pl-4 pr-4 py-2 shrink-0">
+				<EditableInput
+					bind:this={summaryInput}
+					value={session.summary ?? ''}
+					placeholder="Untitled session"
+					onSave={(v) => {
+						session.summary = v
+						persistSessions()
+					}}
+					class="text-sm font-semibold"
+					inputClass="!text-sm !font-semibold"
+				/>
+				<DropdownV2
+					fixedHeight={false}
+					placement="bottom-start"
+					items={[
+						{
+							displayName: 'Rename',
+							icon: Pencil,
+							action: () => summaryInput?.edit()
+						},
+						session.archived
+							? {
+									displayName: 'Unarchive',
+									icon: ArchiveRestore,
+									action: () => setSessionArchived(session.id, false)
+								}
+							: {
+									displayName: 'Archive',
+									icon: Archive,
+									action: () => archiveAndReset()
+								},
+						{
+							displayName: 'Delete',
+							icon: Trash2,
+							type: 'delete',
+							action: () => (deleteConfirmOpen = true)
+						}
+					]}
+				>
+					{#snippet buttonReplacement()}
+						<span
+							class="inline-flex items-center justify-center w-5 h-5 rounded text-tertiary hover:bg-surface-hover hover:text-primary"
+							title="More"
+						>
+							<EllipsisVertical size={14} />
+						</span>
+					{/snippet}
+				</DropdownV2>
+				{#if !session.target && hasFirstUserMessage}
+					<!-- Drill-picker for sessions that have started but haven't
+				     picked an editor target yet. Hidden on fresh sessions
+				     (no messages yet) — the workspace bar is the only
+				     header affordance during the empty state. -->
+					<div class="ml-auto">
+						<Popover
+							placement="bottom-end"
+							usePointerDownOutside
+							disableFocusTrap
+							class="inline-flex"
+						>
+							{#snippet trigger()}
+								<Button variant="default" unifiedSize="xs" startIcon={{ icon: PanelRightOpen }}>
+									Open editor
+								</Button>
+							{/snippet}
+							{#snippet content()}
+								<WorkspaceItemDrillPicker
+									onPick={(item: WorkspaceItem) => pickEditorTarget(item)}
+								/>
+							{/snippet}
+						</Popover>
+					</div>
+				{:else if hasTarget && mountEditor && !editorVisible}
+					<div class="ml-auto">
+						<Button
+							variant="subtle"
+							unifiedSize="xs"
+							startIcon={{ icon: PanelRightOpen }}
+							onclick={() => (editorVisible = true)}
+						>
+							Show editor
+						</Button>
+					</div>
+				{:else if hasEditor}
+					<div class="ml-auto flex flex-row items-center gap-1">
+						<button
+							type="button"
+							onclick={() => (editorVisible = false)}
+							title="Close editor"
+							aria-label="Close editor"
+							class="inline-flex items-center justify-center w-6 h-6 rounded text-tertiary hover:text-primary hover:bg-surface-hover"
+						>
+							<PanelRightClose size={14} />
+						</button>
+					</div>
+				{/if}
+			</header>
+			<div class="flex-1 min-h-0 w-full flex flex-col {hasFirstUserMessage ? '' : 'pt-8'}">
+				<AIChat
+					bind:this={aiChat}
+					hideHeader
+					hideModeSelector
+					wideLayout
+					forceDisabled={isUnavailable}
+					forceDisabledMessage={isUnavailable
+						? 'This session is linked to a workspace that no longer exists. Move it or discard it from the banner above to keep working.'
+						: ''}
+					emptyHint={sessionEmptyHint}
+					{inputPreface}
+				/>
+			</div>
+		</Pane>
+		{#if hasEditor && session.target}
+			<Pane size={50} minSize={30} class="flex flex-col min-h-0 p-2 pl-0">
+				<div
+					transition:slide={{ axis: 'x', duration: 200 }}
+					class="flex flex-col flex-1 min-h-0 rounded-md border border-light overflow-hidden relative"
+				>
+					{#if session.target.kind === 'flow'}
+						<FlowEditorView
+							{runtime}
+							path={session.target.path}
+							workspaceId={effectiveWorkspaceId}
+							onNavigate={pickEditorTarget}
+							isActiveSession={sessionState.currentSessionId === sessionId}
+						/>
+					{:else if session.target.kind === 'script'}
+						<ScriptEditorView
+							{runtime}
+							path={session.target.path}
+							workspaceId={effectiveWorkspaceId}
+							onNavigate={pickEditorTarget}
+							initialTestPanelCollapsed
+							isActiveSession={sessionState.currentSessionId === sessionId}
+						/>
+					{:else if session.target.kind === 'raw_app'}
+						<RawAppEditorView
+							{runtime}
+							path={session.target.path}
+							workspaceId={effectiveWorkspaceId}
+							onNavigate={pickEditorTarget}
+							isActiveSession={sessionState.currentSessionId === sessionId}
+						/>
+					{/if}
+				</div>
+			</Pane>
+		{/if}
+	</Splitpanes>
+
+	<ConfirmationModal
+		open={deleteConfirmOpen}
+		title="Delete session"
+		confirmationText="Delete"
+		onConfirmed={handleConfirmedDelete}
+		onCanceled={() => {
+			deleteConfirmOpen = false
+			deleteAlsoFork = false
+		}}
+	>
+		<div class="flex flex-col gap-3">
+			<p>
+				Delete session <span class="font-medium text-primary"
+					>{session?.summary ?? session?.name}</span
+				>? This cannot be undone.
+			</p>
+			{#if sessionForkId}
+				<div class="flex items-start gap-2 border rounded-md p-3 bg-surface-secondary">
+					<Toggle size="xs" bind:checked={deleteAlsoFork} />
+					<div class="flex flex-col">
+						<span class="text-xs font-medium text-primary"
+							>Also delete forked workspace <span class="font-mono">{sessionForkId}</span></span
+						>
+						<span class="text-3xs text-tertiary"
+							>The fork won't be reachable from any other session — leaving it would orphan it.</span
+						>
+					</div>
+				</div>
+			{/if}
+		</div>
+	</ConfirmationModal>
+
+	<ConfirmationModal
+		open={archiveConfirmOpen}
+		title="Archive session"
+		confirmationText="Archive"
+		onConfirmed={handleConfirmedArchive}
+		onCanceled={() => {
+			archiveConfirmOpen = false
+			archiveAlsoFork = false
+		}}
+	>
+		<div class="flex flex-col gap-3">
+			<p>
+				Archive session <span class="font-medium text-primary"
+					>{session?.summary ?? session?.name}</span
+				>? You can restore it later from the archived list.
+			</p>
+			{#if sessionForkId}
+				<div class="flex items-start gap-2 border rounded-md p-3 bg-surface-secondary">
+					<Toggle size="xs" bind:checked={archiveAlsoFork} />
+					<div class="flex flex-col">
+						<span class="text-xs font-medium text-primary"
+							>Also archive forked workspace <span class="font-mono">{sessionForkId}</span></span
+						>
+						<span class="text-3xs text-tertiary"
+							>Archived workspaces can be unarchived later from instance settings.</span
+						>
+					</div>
+				</div>
+			{/if}
+		</div>
+	</ConfirmationModal>
+{/if}
+
+<style>
+	:global(.splitter-hidden .splitpanes__splitter) {
+		background-color: transparent !important;
+		border: none !important;
+		opacity: 0 !important;
+	}
+</style>
diff --git a/frontend/src/lib/components/sessions/WorkspaceFamilyPicker.svelte b/frontend/src/lib/components/sessions/WorkspaceFamilyPicker.svelte
new file mode 100644
index 0000000000..61b18a53b9
--- /dev/null
+++ b/frontend/src/lib/components/sessions/WorkspaceFamilyPicker.svelte
@@ -0,0 +1,312 @@
+<script lang="ts">
+	import { tick, type Snippet } from 'svelte'
+	import { userWorkspaces, workspaceStore, type UserWorkspace } from '$lib/stores'
+	import { findWorkspaceDescendants } from '$lib/utils/workspaceHierarchy'
+	import { isRuleActive } from '$lib/workspaceProtectionRules.svelte'
+	import { isCloudHosted } from '$lib/cloud'
+	import { random_adj } from '$lib/components/random_positive_adjetive'
+	import DropdownV2 from '$lib/components/DropdownV2.svelte'
+	import InputError from '$lib/components/InputError.svelte'
+	import TextInput from '$lib/components/text_input/TextInput.svelte'
+	import { Building, Check, GitFork, Plus } from 'lucide-svelte'
+
+	type PendingFork = { id: string; name: string }
+	type ForkRequest = { parent_workspace_id: string; id: string; name: string }
+
+	let {
+		// Workspace currently associated with the consumer (for display only —
+		// drives the family-root resolution and the "selected" highlight).
+		// Defaults to the active workspace store when not set.
+		selectedId,
+		// A staged-but-not-yet-created fork (e.g. SessionWorkspaceBar's
+		// pre-send draft). Highlighted as the active row when set.
+		pendingFork,
+		onPick,
+		onCreateFork,
+		allowCreateFork = true,
+		// Optional caption rendered under the new-fork input. Lets the
+		// consumer differentiate "staged for first send" vs. "will be
+		// created immediately" semantics.
+		createForkCaption = '',
+		trigger
+	}: {
+		selectedId?: string
+		pendingFork?: PendingFork
+		onPick: (workspaceId: string) => void | Promise<void>
+		onCreateFork?: (fork: ForkRequest) => void | Promise<void>
+		allowCreateFork?: boolean
+		createForkCaption?: string
+		trigger: Snippet<[{ open: boolean }]>
+	} = $props()
+
+	const WM_FORK_PREFIX = 'wm-fork-'
+
+	function findRoot(id: string | undefined, all: UserWorkspace[]): UserWorkspace | undefined {
+		if (!id) return undefined
+		let current = all.find((w) => w.id === id)
+		while (current?.parent_workspace_id) {
+			const parent = all.find((w) => w.id === current!.parent_workspace_id)
+			if (!parent) break
+			current = parent
+		}
+		return current
+	}
+
+	const effectiveId = $derived(selectedId ?? $workspaceStore ?? undefined)
+	const root = $derived(findRoot(effectiveId, $userWorkspaces))
+	const forks = $derived(root ? findWorkspaceDescendants(root.id, $userWorkspaces) : [])
+
+	// Same gate as the sidebar WorkspaceMenu / SessionWorkspaceBar.
+	const forksGateOpen = $derived(
+		!isCloudHosted() && !isRuleActive('DisableWorkspaceForking') && $workspaceStore !== 'admins'
+	)
+	const showCreateFork = $derived(allowCreateFork && forksGateOpen && !!onCreateFork && !!root)
+
+	let dropdownOpen = $state(false)
+	let creatingFork = $state(false)
+	let newForkName = $state('')
+	let forkInput: TextInput | undefined = $state(undefined)
+
+	// Manual keyboard navigation, modelled after SelectDropdown. melt's
+	// menu API couples Enter/Space to closing the menu, which we explicitly
+	// don't want for the "Create new fork" row — it swaps to inline input.
+	type NavRow = { kind: 'create' } | { kind: 'root'; id: string } | { kind: 'fork'; id: string }
+	const navRows = $derived<NavRow[]>([
+		...(showCreateFork ? [{ kind: 'create' as const }] : []),
+		...(root ? [{ kind: 'root' as const, id: root.id }] : []),
+		...forks.map((f) => ({ kind: 'fork' as const, id: f.id }))
+	])
+	let keyArrowPos = $state<number | undefined>(undefined)
+	$effect(() => {
+		if (!dropdownOpen) keyArrowPos = undefined
+	})
+
+	function activateRow(row: NavRow) {
+		if (row.kind === 'create') {
+			void enterCreateMode()
+		} else if (row.kind === 'root' || row.kind === 'fork') {
+			void pick(row.id)
+		}
+	}
+
+	function defaultForkName(): string {
+		const taken = new Set($userWorkspaces.map((w) => w.id))
+		if (pendingFork) taken.add(pendingFork.id)
+		for (let i = 0; i < 50; i++) {
+			const name = `${random_adj()}-fork`
+			if (!taken.has(`${WM_FORK_PREFIX}${name}`)) return name
+		}
+		const base = `${random_adj()}-fork`
+		let n = 1
+		while (taken.has(`${WM_FORK_PREFIX}${base}-${n}`)) n++
+		return `${base}-${n}`
+	}
+
+	async function pick(id: string) {
+		dropdownOpen = false
+		creatingFork = false
+		await onPick(id)
+	}
+
+	async function enterCreateMode(initialName?: string) {
+		creatingFork = true
+		newForkName = initialName ?? defaultForkName()
+		await tick()
+		forkInput?.focus()
+		forkInput?.select()
+	}
+
+	function cancelCreate() {
+		creatingFork = false
+		newForkName = ''
+	}
+
+	function slugForkBaseId(name: string): string {
+		return name
+			.toLowerCase()
+			.replace(/[^a-z0-9-]/g, '-')
+			.replace(/-+/g, '-')
+			.replace(/^-|-$/g, '')
+	}
+
+	const forkNameError = $derived.by<string | undefined>(() => {
+		const trimmed = newForkName.trim()
+		if (!trimmed) return undefined
+		const baseId = slugForkBaseId(trimmed)
+		if (!baseId) return 'Name must contain at least one letter or number'
+		const prefixed = `${WM_FORK_PREFIX}${baseId}`
+		const taken = new Set($userWorkspaces.map((w) => w.id))
+		if (pendingFork) taken.delete(pendingFork.id)
+		if (taken.has(prefixed)) return 'A workspace with this name already exists'
+		return undefined
+	})
+
+	async function stageNewFork() {
+		const name = newForkName.trim()
+		if (!root || !name || forkNameError || !onCreateFork) return
+		const baseId = slugForkBaseId(name)
+		if (!baseId) return
+		const prefixed = `${WM_FORK_PREFIX}${baseId}`
+		// Close optimistically; consumer can re-open + toast on error.
+		creatingFork = false
+		newForkName = ''
+		dropdownOpen = false
+		await onCreateFork({ parent_workspace_id: root.id, id: prefixed, name })
+	}
+
+	function isSelected(id: string): boolean {
+		if (pendingFork?.id === id) return true
+		return !pendingFork && effectiveId === id
+	}
+
+	// Reopening the dropdown while a pending fork is staged drops the user
+	// directly into edit mode so they can refine the name. Avoids re-
+	// entering edit mode after an explicit cancel.
+	let lastDropdownOpen = $state(false)
+	$effect(() => {
+		const wasOpen = lastDropdownOpen
+		lastDropdownOpen = dropdownOpen
+		if (dropdownOpen && !wasOpen && pendingFork && !creatingFork && showCreateFork) {
+			void enterCreateMode(pendingFork.name)
+		}
+	})
+</script>
+
+<svelte:window
+	onkeydown={(e) => {
+		if (!dropdownOpen) return
+		if (creatingFork) return
+		if (navRows.length === 0) return
+		if (e.key === 'ArrowDown') {
+			keyArrowPos = keyArrowPos === undefined ? 0 : Math.min(navRows.length - 1, keyArrowPos + 1)
+			e.preventDefault()
+		} else if (e.key === 'ArrowUp') {
+			keyArrowPos = keyArrowPos === undefined ? navRows.length - 1 : Math.max(0, keyArrowPos - 1)
+			e.preventDefault()
+		} else if (e.key === 'Enter' && keyArrowPos !== undefined) {
+			activateRow(navRows[keyArrowPos])
+			e.preventDefault()
+		} else if (e.key === 'Escape') {
+			dropdownOpen = false
+			e.preventDefault()
+		}
+	}}
+/>
+
+<DropdownV2
+	bind:open={dropdownOpen}
+	customMenu
+	placement="bottom-start"
+	fixedHeight={false}
+	usePointerDownOutside
+>
+	{#snippet buttonReplacement()}
+		{@render trigger({ open: dropdownOpen })}
+	{/snippet}
+	{#snippet menu()}
+		{@const rowBase =
+			'px-3 py-1.5 text-xs text-primary flex flex-row gap-2 items-center text-left rounded-sm w-full'}
+		<div
+			class="bg-surface-tertiary dark:border w-64 origin-top-left rounded-lg shadow-lg focus:outline-none py-1 flex flex-col max-h-80 overflow-y-auto"
+		>
+			{#if showCreateFork}
+				{#if creatingFork}
+					<div class="flex flex-col gap-1 px-2 py-1.5">
+						<div class="flex flex-row items-center gap-1.5">
+							<Plus size={14} class="shrink-0 text-tertiary" />
+							<!-- svelte-ignore a11y_autofocus -->
+							<TextInput
+								bind:this={forkInput}
+								bind:value={newForkName}
+								size="xs"
+								error={forkNameError}
+								class="flex-1 min-w-0"
+								inputProps={{
+									placeholder: 'Fork name',
+									autofocus: true,
+									'aria-invalid': forkNameError ? 'true' : undefined,
+									onkeydown: (e: KeyboardEvent) => {
+										if (e.key === 'Enter') {
+											e.preventDefault()
+											e.stopPropagation()
+											void stageNewFork()
+										} else if (e.key === 'Escape') {
+											e.preventDefault()
+											e.stopPropagation()
+											cancelCreate()
+										}
+									}
+								}}
+							/>
+							<button
+								type="button"
+								aria-label="Confirm"
+								title="Stage fork"
+								onclick={() => void stageNewFork()}
+								disabled={!newForkName.trim() || !!forkNameError}
+								class="inline-flex items-center justify-center w-5 h-5 rounded text-accent hover:bg-surface-hover disabled:opacity-40 disabled:cursor-not-allowed"
+							>
+								<Check size={14} />
+							</button>
+						</div>
+						{#if forkNameError || createForkCaption}
+							<div class="pl-6">
+								<InputError error={forkNameError} />
+								{#if !forkNameError && createForkCaption}
+									<span class="text-2xs text-tertiary">{createForkCaption}</span>
+								{/if}
+							</div>
+						{/if}
+					</div>
+				{:else}
+					{@const createIdx = 0}
+					<button
+						type="button"
+						class={`${rowBase} ${keyArrowPos === createIdx ? 'bg-surface-hover' : 'hover:bg-surface-hover'}`}
+						onmouseenter={() => (keyArrowPos = createIdx)}
+						onclick={() => enterCreateMode()}
+					>
+						<Plus size={14} class="shrink-0 text-tertiary" />
+						<span>Create new fork…</span>
+					</button>
+				{/if}
+				<div class="my-1 border-t border-border-light shrink-0"></div>
+			{/if}
+
+			{#if root}
+				{@const rootIdx = showCreateFork ? 1 : 0}
+				<button
+					type="button"
+					class={`${rowBase} ${isSelected(root.id) && !pendingFork ? 'bg-surface-selected' : ''} ${keyArrowPos === rootIdx ? 'bg-surface-hover' : 'hover:bg-surface-hover'}`}
+					onmouseenter={() => (keyArrowPos = rootIdx)}
+					onclick={() => void pick(root.id)}
+				>
+					<Building size={14} class="shrink-0 text-tertiary" />
+					<span class="truncate">{root.name}</span>
+					<span class="text-2xs text-tertiary shrink-0 ml-auto">root</span>
+				</button>
+			{/if}
+			{#each forks as f, fi (f.id)}
+				{@const forkIdx = (showCreateFork ? 1 : 0) + (root ? 1 : 0) + fi}
+				<button
+					type="button"
+					class={`${rowBase} ${isSelected(f.id) ? 'bg-surface-selected' : ''} ${keyArrowPos === forkIdx ? 'bg-surface-hover' : 'hover:bg-surface-hover'}`}
+					onmouseenter={() => (keyArrowPos = forkIdx)}
+					onclick={() => void pick(f.id)}
+				>
+					<GitFork size={14} class="shrink-0 text-tertiary" />
+					<span class="truncate">{f.name}</span>
+				</button>
+			{/each}
+			{#if pendingFork && !creatingFork}
+				<div
+					class="px-3 py-1.5 text-xs text-primary flex flex-row gap-2 items-center text-left rounded-sm bg-surface-selected cursor-default"
+				>
+					<GitFork size={14} class="shrink-0 text-tertiary" />
+					<span class="truncate">{pendingFork.name}</span>
+					<span class="text-2xs text-tertiary italic shrink-0 ml-auto">New</span>
+				</div>
+			{/if}
+		</div>
+	{/snippet}
+</DropdownV2>
diff --git a/frontend/src/lib/components/sessions/appDraftCodec.test.ts b/frontend/src/lib/components/sessions/appDraftCodec.test.ts
new file mode 100644
index 0000000000..f83e1e590b
--- /dev/null
+++ b/frontend/src/lib/components/sessions/appDraftCodec.test.ts
@@ -0,0 +1,61 @@
+import { describe, it, expect } from 'vitest'
+import {
+	runtimeRawAppToDraft,
+	applyDraftToRuntimeRawApp,
+	type RuntimeRawApp,
+	type RawAppDraft
+} from './appDraftCodec'
+
+function runtime(over: Partial<RuntimeRawApp> = {}): RuntimeRawApp {
+	return {
+		summary: 'app',
+		path: 'f/foo/app',
+		files: { '/index.tsx': 'x' },
+		runnables: {},
+		data: { tables: [] } as any,
+		policy: { execution_mode: 'publisher' },
+		...over
+	}
+}
+
+describe('appDraftCodec — custom_path round-trip', () => {
+	it('carries custom_path from runtime → draft', () => {
+		const draft = runtimeRawAppToDraft(runtime({ custom_path: 'my-url' }))
+		expect(draft.custom_path).toBe('my-url')
+	})
+
+	it('carries custom_path from draft → runtime', () => {
+		const base = runtime({ custom_path: undefined })
+		const dv: RawAppDraft = {
+			summary: 'app',
+			files: {},
+			runnables: {},
+			data: { tables: [] } as any,
+			policy: { execution_mode: 'publisher' },
+			custom_path: 'kept-url'
+		}
+		expect(applyDraftToRuntimeRawApp(base, dv).custom_path).toBe('kept-url')
+	})
+
+	it('survives a full runtime → draft → runtime round-trip', () => {
+		const original = runtime({ custom_path: 'round-trip-url' })
+		const back = applyDraftToRuntimeRawApp(
+			runtime({ custom_path: undefined }),
+			runtimeRawAppToDraft(original)
+		)
+		expect(back.custom_path).toBe('round-trip-url')
+		// runtime-only `path` is preserved from the target, not the draft
+		expect(back.path).toBe('f/foo/app')
+	})
+
+	it('falls back to the runtime custom_path when the draft omits it', () => {
+		const base = runtime({ custom_path: 'existing' })
+		const dv: RawAppDraft = {
+			summary: 'app',
+			files: {},
+			runnables: {},
+			data: { tables: [] } as any
+		}
+		expect(applyDraftToRuntimeRawApp(base, dv).custom_path).toBe('existing')
+	})
+})
diff --git a/frontend/src/lib/components/sessions/appDraftCodec.ts b/frontend/src/lib/components/sessions/appDraftCodec.ts
new file mode 100644
index 0000000000..47493da3f2
--- /dev/null
+++ b/frontend/src/lib/components/sessions/appDraftCodec.ts
@@ -0,0 +1,55 @@
+import type { RawAppData } from '$lib/components/raw_apps/dataTableRefUtils'
+
+// The raw-app draft shape stored under `UserDraft<RawAppDraft>` — matches the
+// regular `/apps_raw/edit` route's UserDraft handle exactly. The chat's
+// `userDraftAdapter.saveGlobalAppDraft` writes through the same shape, so
+// session previews and the chat round-trip identically.
+export type RawAppDraft = {
+	files: Record<string, string>
+	runnables: Record<string, any>
+	data: RawAppData
+	summary: string
+	policy?: any
+	custom_path?: string
+}
+
+// The shape `runtime.rawApp.val` actually holds (see SessionRuntime in
+// sessionRuntime.svelte.ts). Adds `path` (a key, not a draft field) and
+// makes `policy` required for the editor's live binding.
+export type RuntimeRawApp = {
+	summary: string
+	path: string
+	files: Record<string, string>
+	runnables: Record<string, any>
+	data: RawAppData
+	policy: any
+	custom_path?: string
+}
+
+// Strip runtime-only metadata (just `path`, the storage key) when persisting
+// to UserDraft. `custom_path` is a real draft field and must round-trip — else
+// session sync erases a draft's custom URL.
+export function runtimeRawAppToDraft(raw: RuntimeRawApp): RawAppDraft {
+	return {
+		summary: raw.summary,
+		files: raw.files,
+		runnables: raw.runnables,
+		data: raw.data,
+		policy: raw.policy,
+		custom_path: raw.custom_path
+	}
+}
+
+// Overlay a UserDraft-stored raw-app draft onto an existing runtime raw app,
+// preserving the runtime-only `path` field.
+export function applyDraftToRuntimeRawApp(raw: RuntimeRawApp, dv: RawAppDraft): RuntimeRawApp {
+	return {
+		...raw,
+		summary: dv.summary,
+		files: dv.files,
+		runnables: dv.runnables,
+		data: dv.data,
+		policy: dv.policy ?? raw.policy,
+		custom_path: dv.custom_path ?? raw.custom_path
+	}
+}
diff --git a/frontend/src/lib/components/sessions/flowDraftSig.test.ts b/frontend/src/lib/components/sessions/flowDraftSig.test.ts
new file mode 100644
index 0000000000..052ef2faea
--- /dev/null
+++ b/frontend/src/lib/components/sessions/flowDraftSig.test.ts
@@ -0,0 +1,22 @@
+import { describe, it, expect } from 'vitest'
+import { flowDraftSig } from './flowDraftSig'
+
+describe('flowDraftSig', () => {
+	it('changes when only the summary changes (the regression this guards)', () => {
+		const base = { value: { modules: [] }, schema: {}, summary: 'a' }
+		const renamed = { ...base, summary: 'b' }
+		expect(flowDraftSig(base)).not.toBe(flowDraftSig(renamed))
+	})
+
+	it('is stable for equal value/schema/summary', () => {
+		const a = { value: { modules: [1] }, schema: { x: 1 }, summary: 's' }
+		const b = { value: { modules: [1] }, schema: { x: 1 }, summary: 's' }
+		expect(flowDraftSig(a)).toBe(flowDraftSig(b))
+	})
+
+	it('changes when the value changes', () => {
+		expect(flowDraftSig({ value: { modules: [] }, summary: 's' })).not.toBe(
+			flowDraftSig({ value: { modules: [1] }, summary: 's' })
+		)
+	})
+})
diff --git a/frontend/src/lib/components/sessions/flowDraftSig.ts b/frontend/src/lib/components/sessions/flowDraftSig.ts
new file mode 100644
index 0000000000..5b4137e908
--- /dev/null
+++ b/frontend/src/lib/components/sessions/flowDraftSig.ts
@@ -0,0 +1,9 @@
+// Dedup signature for the session flow preview's two-way sync (FlowEditorView).
+//
+// The inbound (draft → editor) and outbound (editor → draft) effects compare
+// this signature to skip no-op work. It MUST include `summary` — otherwise a
+// summary-only change produces an identical signature and never propagates or
+// persists.
+export function flowDraftSig(x: { value?: unknown; schema?: unknown; summary?: unknown }): string {
+	return JSON.stringify({ value: x.value, schema: x.schema, summary: x.summary })
+}
diff --git a/frontend/src/lib/components/sessions/forkDiffCache.test.ts b/frontend/src/lib/components/sessions/forkDiffCache.test.ts
new file mode 100644
index 0000000000..2d38320a6a
--- /dev/null
+++ b/frontend/src/lib/components/sessions/forkDiffCache.test.ts
@@ -0,0 +1,87 @@
+import { describe, it, expect } from 'vitest'
+
+// Documents the cache-invalidation contract that ForkDiffDrawer.fetchComparison
+// relies on. The bug (cubic P2): per-item raw diffs (`loadedDiffs[key]`) and
+// per-item `summaries` are component-local $state that persist for the
+// drawer's lifetime. fetchComparison re-fetches the comparison on every
+// open(), but loadDiffFor short-circuits on `loadedDiffs[key]` — so an
+// edit-then-reopen would show fresh counts but the prior open's cached
+// expanded raw content. The fix clears both records at the top of
+// fetchComparison before the await. This test pins the contract from the
+// outside: nothing is allowed to read a stale per-item value across a
+// fetchComparison invocation.
+
+type LoadedDiff = { state: 'ready'; parentRaw: string; forkRaw: string }
+
+function simulateFetchComparison(
+	state: { loadedDiffs: Record<string, LoadedDiff>; summaries: Record<string, string> },
+	items: Array<{ key: string; parentRaw: string; forkRaw: string; summary: string }>
+) {
+	// The fix: clear caches *before* re-populating, matching the production
+	// code's `loadedDiffs = {}; summaries = {}` at the top of fetchComparison.
+	state.loadedDiffs = {}
+	state.summaries = {}
+	for (const it of items) {
+		// loadDiffFor's cache-hit shortcut: if state.loadedDiffs[key] exists,
+		// it returns early. With the reset above this is always false here, so
+		// every item gets fresh content.
+		if (state.loadedDiffs[it.key]) continue
+		state.loadedDiffs[it.key] = { state: 'ready', parentRaw: it.parentRaw, forkRaw: it.forkRaw }
+		state.summaries[it.key] = it.summary
+	}
+}
+
+describe('ForkDiffDrawer.fetchComparison — cache invalidation', () => {
+	it('reopen after edit replaces stale per-item raw content', () => {
+		const state = {
+			loadedDiffs: {} as Record<string, LoadedDiff>,
+			summaries: {} as Record<string, string>
+		}
+
+		// First open: populate.
+		simulateFetchComparison(state, [
+			{ key: 'script/f/foo', parentRaw: 'v1', forkRaw: 'v1-fork', summary: 'summary v1' }
+		])
+		expect(state.loadedDiffs['script/f/foo']).toEqual({
+			state: 'ready',
+			parentRaw: 'v1',
+			forkRaw: 'v1-fork'
+		})
+		expect(state.summaries['script/f/foo']).toBe('summary v1')
+
+		// User edits the script in the session editor, closes drawer, reopens.
+		// Without the reset, the cache-hit shortcut would keep 'v1-fork'.
+		simulateFetchComparison(state, [
+			{ key: 'script/f/foo', parentRaw: 'v1', forkRaw: 'v2-fork', summary: 'summary v2' }
+		])
+		expect(state.loadedDiffs['script/f/foo']).toEqual({
+			state: 'ready',
+			parentRaw: 'v1',
+			forkRaw: 'v2-fork'
+		})
+		expect(state.summaries['script/f/foo']).toBe('summary v2')
+	})
+
+	it('reopen drops entries for items that vanished from the new comparison', () => {
+		const state = {
+			loadedDiffs: {} as Record<string, LoadedDiff>,
+			summaries: {} as Record<string, string>
+		}
+
+		simulateFetchComparison(state, [
+			{ key: 'script/f/a', parentRaw: 'x', forkRaw: 'x-fork', summary: 'a' },
+			{ key: 'flow/f/b', parentRaw: 'y', forkRaw: 'y-fork', summary: 'b' }
+		])
+		expect(Object.keys(state.loadedDiffs).sort()).toEqual(['flow/f/b', 'script/f/a'])
+
+		// User merges 'flow/f/b' so it's no longer ahead of parent.
+		simulateFetchComparison(state, [
+			{ key: 'script/f/a', parentRaw: 'x', forkRaw: 'x-fork', summary: 'a' }
+		])
+		// Without the reset, the orphan entry would linger in loadedDiffs and
+		// the tree could render a row whose raw content references a path no
+		// longer in the live comparison.
+		expect(Object.keys(state.loadedDiffs)).toEqual(['script/f/a'])
+		expect(state.summaries['flow/f/b']).toBeUndefined()
+	})
+})
diff --git a/frontend/src/lib/components/sessions/forkDiffNav.test.ts b/frontend/src/lib/components/sessions/forkDiffNav.test.ts
new file mode 100644
index 0000000000..3266ffaa9f
--- /dev/null
+++ b/frontend/src/lib/components/sessions/forkDiffNav.test.ts
@@ -0,0 +1,32 @@
+import { describe, it, expect } from 'vitest'
+import { parentFolderKey } from './forkDiffNav'
+
+describe('parentFolderKey', () => {
+	describe('folders', () => {
+		it('a scope folder (2 segments) has no parent', () => {
+			expect(parentFolderKey('folder', 'f/foo')).toBeUndefined()
+			expect(parentFolderKey('folder', 'u/alice')).toBeUndefined()
+		})
+		it('a nested folder belongs to its parent folder', () => {
+			expect(parentFolderKey('folder', 'f/foo/sub')).toBe('folder:f/foo')
+			expect(parentFolderKey('folder', 'f/foo/sub/deep')).toBe('folder:f/foo/sub')
+		})
+	})
+
+	describe('files', () => {
+		it('a single-segment leaf has no scope folder', () => {
+			expect(parentFolderKey('file', 'orphan')).toBeUndefined()
+		})
+		it('a 2-segment file maps to its scope folder (the cubic fix)', () => {
+			// Regression: previously returned `folder:f` (nonexistent) → ArrowLeft broke.
+			expect(parentFolderKey('file', 'f/foo')).toBe('folder:f/foo')
+		})
+		it('a 3-segment file (directly under scope) maps to the scope folder', () => {
+			expect(parentFolderKey('file', 'f/foo/bar')).toBe('folder:f/foo')
+			expect(parentFolderKey('file', 'u/alice/script')).toBe('folder:u/alice')
+		})
+		it('a deeper file belongs to its immediate folder', () => {
+			expect(parentFolderKey('file', 'f/foo/sub/bar')).toBe('folder:f/foo/sub')
+		})
+	})
+})
diff --git a/frontend/src/lib/components/sessions/forkDiffNav.ts b/frontend/src/lib/components/sessions/forkDiffNav.ts
new file mode 100644
index 0000000000..6dfe829cf3
--- /dev/null
+++ b/frontend/src/lib/components/sessions/forkDiffNav.ts
@@ -0,0 +1,25 @@
+// Keyboard-navigation helpers for the fork-diff tree (ForkDiffDrawer).
+//
+// The tree groups diffs by "scope" (the first two path segments, e.g. `f/foo`
+// or `u/alice`); deeper segments become nested folders. Folder keys are
+// `folder:<fullPath>`. See ForkDiffDrawer's tree builder.
+
+/**
+ * The folder key that contains an entry (for ArrowLeft "go to parent"), or
+ * `undefined` when the entry sits at the top with no parent folder.
+ *
+ * - A scope folder (≤2 segments) has no parent.
+ * - A single-segment file leaf sits at the tree root with no scope folder.
+ * - A file directly at its scope (`f/foo` or `f/foo/bar`) belongs to the scope
+ *   folder = first two segments (`folder:f/foo`).
+ * - Anything deeper belongs to its immediate folder.
+ */
+export function parentFolderKey(kind: 'folder' | 'file', path: string): string | undefined {
+	const parts = path.split('/')
+	if (kind === 'folder' && parts.length <= 2) return undefined
+	if (kind === 'file') {
+		if (parts.length < 2) return undefined
+		if (parts.length <= 3) return `folder:${parts.slice(0, 2).join('/')}`
+	}
+	return `folder:${parts.slice(0, -1).join('/')}`
+}
diff --git a/frontend/src/lib/components/sessions/forkEditUrl.ts b/frontend/src/lib/components/sessions/forkEditUrl.ts
new file mode 100644
index 0000000000..e2cecb5c02
--- /dev/null
+++ b/frontend/src/lib/components/sessions/forkEditUrl.ts
@@ -0,0 +1,14 @@
+import type { WorkspaceItemDiff } from '$lib/gen'
+
+// Editor URL for a workspace-item diff, scoped to a given workspace. Returns
+// undefined for kinds we don't have a dedicated editor for (resource,
+// variable, schedule, triggers, …).
+export function editUrlFor(d: WorkspaceItemDiff, workspaceId: string): string | undefined {
+	const ws = encodeURIComponent(workspaceId)
+	const path = d.path
+	if (d.kind === 'flow') return `/flows/edit/${path}?workspace=${ws}`
+	if (d.kind === 'script') return `/scripts/edit/${path}?workspace=${ws}`
+	if (d.kind === 'app') return `/apps/edit/${path}?workspace=${ws}`
+	if (d.kind === 'raw_app') return `/apps_raw/edit/${path}?workspace=${ws}`
+	return undefined
+}
diff --git a/frontend/src/lib/components/sessions/sessionRuntime.svelte.ts b/frontend/src/lib/components/sessions/sessionRuntime.svelte.ts
new file mode 100644
index 0000000000..15912a28e9
--- /dev/null
+++ b/frontend/src/lib/components/sessions/sessionRuntime.svelte.ts
@@ -0,0 +1,700 @@
+import { SvelteMap, SvelteSet } from 'svelte/reactivity'
+import { get } from 'svelte/store'
+import { AIChatManager, AIMode } from '$lib/components/copilot/chat/AIChatManager.svelte'
+import { initFlow } from '$lib/components/flows/flowStore.svelte'
+import {
+	AppService,
+	FlowService,
+	ScriptService,
+	WorkspaceService,
+	type Flow,
+	type NewScript,
+	type NewScriptWithDraft,
+	type WorkspaceComparison
+} from '$lib/gen'
+import type { HiddenRunnable } from '$lib/components/apps/types'
+import { type RawAppData, DEFAULT_DATA } from '$lib/components/raw_apps/dataTableRefUtils'
+import { workspaceStore } from '$lib/stores'
+import { emptySchema, type StateStore } from '$lib/utils'
+import {
+	commitSessionWorkspace,
+	deleteSession as deleteSessionState,
+	ensureChatIdsSeeded,
+	materializeTransient,
+	sessionState,
+	setSessionChatId,
+	setSessionTarget,
+	type Session,
+	type SessionTarget
+} from './sessionState.svelte'
+import { UserDraft } from '$lib/userDraft.svelte'
+import { applyDraftToRuntimeRawApp, runtimeRawAppToDraft, type RawAppDraft } from './appDraftCodec'
+import {
+	setDeployedInSessionHandler,
+	setGetPreviewStatusHandler,
+	setOpenPreviewHandler
+} from '$lib/components/copilot/chat/global/core'
+
+export interface SessionRuntime {
+	readonly sessionId: string
+	readonly manager: AIChatManager
+	// Flow target state
+	readonly flowStore: StateStore<Flow>
+	readonly flowStateStore: { val: Record<string, any> }
+	readonly savedFlow: { val: (Flow & { draft?: Flow | undefined }) | undefined }
+	readonly loadingFlow: boolean
+	readonly notFound: boolean
+	readonly loadedPath: string | undefined
+	loadFlow(workspace: string, path: string, force?: boolean): Promise<void>
+	// Script target state (parallel to flow, populated only for script-targeted sessions)
+	readonly scriptStore: { val: NewScript | undefined }
+	readonly savedScript: { val: NewScriptWithDraft | undefined }
+	readonly loadingScript: boolean
+	readonly notFoundScript: boolean
+	readonly loadedScriptPath: string | undefined
+	loadScript(workspace: string, path: string, force?: boolean): Promise<void>
+	// Note: legacy drag-and-drop apps are intentionally NOT hosted in the
+	// session preview pane (only code-based raw apps are), so there's no
+	// app target state here.
+	// Raw App (HTML-based) target state
+	readonly rawApp: {
+		val:
+			| {
+					files: Record<string, string>
+					runnables: Record<string, any>
+					data: RawAppData
+					policy: any
+					summary: string
+					path: string
+					custom_path?: string
+			  }
+			| undefined
+	}
+	readonly savedRawApp: {
+		val:
+			| {
+					value: {
+						files: Record<string, { code: string }>
+						runnables: Record<string, HiddenRunnable>
+					}
+					draft?: any
+					path: string
+					summary: string
+					policy: any
+					draft_only?: boolean
+					custom_path?: string
+			  }
+			| undefined
+	}
+	readonly loadingRawApp: boolean
+	readonly notFoundRawApp: boolean
+	readonly loadedRawAppPath: string | undefined
+	loadRawApp(workspace: string, path: string, force?: boolean): Promise<void>
+	// Discard the local draft + refresh the fork diff + force-reload the editor,
+	// so the preview matches the deployed version. Used by editor onDeploy + the
+	// chat deploy handler.
+	syncPreviewWithDeployed(
+		workspace: string,
+		kind: 'script' | 'flow' | 'raw_app',
+		path: string
+	): void
+	// Fork comparison cache: shared between SessionForkBar (count + dropdown)
+	// and any future consumer that needs the parent ↔ fork diff list. Keyed
+	// implicitly by the (parent, fork) pair last passed to ensureForkComparison;
+	// invalidateForkComparison() forces a refresh after a known-mutating action.
+	readonly forkComparison: { val: WorkspaceComparison | undefined }
+	readonly loadingForkComparison: boolean
+	ensureForkComparison(parent: string, fork: string): Promise<void>
+	invalidateForkComparison(): void
+	// Force-refresh against the last (parent, fork) pair the runtime
+	// fetched for. No-op if no comparison has ever been loaded. Useful
+	// for session-activation hooks that need a fresh count regardless of
+	// the dedupe key match.
+	refreshForkComparison(): Promise<void>
+	// Re-fetch the comparison shortly after a local mutation (e.g. an
+	// editor "Save draft"). The backend tally that registers the change
+	// lands asynchronously, so an immediate refresh races it — this
+	// schedules a couple of delayed refreshes so the fork-bar count
+	// updates without waiting for an AI turn or a tab refocus.
+	scheduleForkComparisonRefresh(): void
+	// Cancel pending fork-comparison refresh timers. Called by disposeRuntime so
+	// a torn-down (e.g. LRU-evicted, deleted) runtime can't fire a stray
+	// refreshForkComparisonNow / compareWorkspaces after it's gone.
+	dispose(): void
+}
+
+const runtimes = new SvelteMap<string, SessionRuntime>()
+
+function emptyFlow(): Flow {
+	return {
+		summary: '',
+		value: { modules: [] },
+		path: '',
+		edited_at: '',
+		edited_by: '',
+		archived: false,
+		extra_perms: {},
+		schema: emptySchema()
+	}
+}
+
+function createRuntime(session: Session): SessionRuntime {
+	const manager = new AIChatManager()
+	manager.disabledModes = { navigator: true }
+	// Sessions always operate in GLOBAL mode (workspace-item tools across
+	// the session's workspace). The page-level gate already requires the
+	// global-AI flag, so this is always available here. Mode is locked
+	// and the dropdown is hidden in the chat UI.
+	manager.mode = AIMode.GLOBAL
+	// Session chats drive a side-panel preview, so they get the session-only
+	// preview tools (open_preview / get_preview_status); the global side-panel
+	// chat does not.
+	manager.isSessionChat = true
+	// Carried into the tool helpers so this session's preview/deploy tool calls
+	// dispatch to THIS session even when another session is the UI-active one.
+	manager.sessionId = session.id
+	// Pre-flight: materialise the (still-transient) session, then commit
+	// the workspace (creating a staged fork if needed) before any send.
+	// AIChatManager awaits this so the first message hits a persisted
+	// session targeting the right workspace. Both calls are idempotent.
+	manager.beforeSend = async () => {
+		materializeTransient(session.id)
+		const committed = await commitSessionWorkspace(session.id, get(workspaceStore) ?? undefined)
+		// commitSessionWorkspace returns undefined only when the session did NOT
+		// commit to a workspace — most importantly when a staged fork failed to
+		// materialise (materializeFork is built to toast + return undefined rather
+		// than throw). Throwing here is what makes AIChatManager.sendRequest abort:
+		// otherwise the send proceeds against get(workspaceStore) (the parent for a
+		// staged-new-fork draft), shipping the message + its tool calls to the
+		// wrong workspace while the pending_fork is silently dropped.
+		if (!committed) {
+			throw new Error(
+				'the session workspace could not be created or committed (fork creation may have failed)'
+			)
+		}
+	}
+
+	const flowStore: StateStore<Flow> = $state({ val: emptyFlow() })
+	const flowStateStore: { val: Record<string, any> } = $state({ val: {} })
+	const savedFlow: { val: (Flow & { draft?: Flow | undefined }) | undefined } = $state({
+		val: undefined
+	})
+
+	let loadingFlow = $state(false)
+	let notFound = $state(false)
+	let loadedPath = $state<string | undefined>(undefined)
+
+	const scriptStore: { val: NewScript | undefined } = $state({ val: undefined })
+	const savedScript: { val: NewScriptWithDraft | undefined } = $state({ val: undefined })
+	let loadingScript = $state(false)
+	let notFoundScript = $state(false)
+	let loadedScriptPath = $state<string | undefined>(undefined)
+
+	const rawApp: { val: SessionRuntime['rawApp']['val'] } = $state({ val: undefined })
+	const savedRawApp: { val: SessionRuntime['savedRawApp']['val'] } = $state({ val: undefined })
+	let loadingRawApp = $state(false)
+	let notFoundRawApp = $state(false)
+	let loadedRawAppPath = $state<string | undefined>(undefined)
+
+	const forkComparison: { val: WorkspaceComparison | undefined } = $state({ val: undefined })
+	let loadingForkComparison = $state(false)
+	let forkComparisonKey: string | undefined = undefined
+	let forkRefreshTimers: ReturnType<typeof setTimeout>[] = []
+
+	// Stale-while-revalidate re-fetch against the last (parent, fork) pair.
+	// Shared by refreshForkComparison() and scheduleForkComparisonRefresh().
+	async function refreshForkComparisonNow() {
+		const key = forkComparisonKey
+		if (!key) return
+		const sep = key.indexOf('|')
+		if (sep < 0) return
+		const parent = key.slice(0, sep)
+		const fork = key.slice(sep + 1)
+		if (loadingForkComparison) return
+		loadingForkComparison = true
+		try {
+			forkComparison.val = await WorkspaceService.compareWorkspaces({
+				workspace: parent,
+				targetWorkspaceId: fork
+			})
+		} catch (e) {
+			console.error('SessionRuntime: forkComparison refresh failed', e)
+		} finally {
+			loadingForkComparison = false
+		}
+	}
+
+	return {
+		sessionId: session.id,
+		manager,
+		flowStore,
+		flowStateStore,
+		savedFlow,
+		get loadingFlow() {
+			return loadingFlow
+		},
+		get notFound() {
+			return notFound
+		},
+		get loadedPath() {
+			return loadedPath
+		},
+
+		async loadFlow(workspace: string, path: string, force = false) {
+			if (loadedPath === path && !force) return
+			// See loadScript: forced reload remounts via the render gate.
+			if (force) loadedPath = undefined
+			loadingFlow = true
+			notFound = false
+			try {
+				// Draft first. UserDraft is the shared authoritative content
+				// source — the chat (write_flow / patch_flow_json /
+				// set_flow_module_code) and the editor's outbound $effect both
+				// write through it. If a draft exists we render from it, even
+				// when the path has never been deployed.
+				const aiDraft = UserDraft.get<Flow>('flow', path, { workspace })
+
+				// getFlowByPathWithDraft omits version_id (the diff's deployed side,
+				// via getFlowByPath, has it) — stamp it onto the editing flow so it
+				// doesn't always diff. Best-effort (a never-deployed flow has none).
+				let deployedVersionId: number | undefined
+				try {
+					deployedVersionId = (await FlowService.getFlowByPath({ workspace, path }))?.version_id
+				} catch {
+					deployedVersionId = undefined
+				}
+
+				if (aiDraft) {
+					// Best-effort fetch the backend baseline for the diff
+					// drawer. Don't fail the load if the path doesn't exist
+					// yet on the backend — draft-only flows are a valid state.
+					try {
+						const result = await FlowService.getFlowByPathWithDraft({ workspace, path })
+						savedFlow.val = result
+					} catch {
+						savedFlow.val = undefined
+					}
+					await initFlow(aiDraft, flowStore, flowStateStore)
+					if (deployedVersionId != null && flowStore.val)
+						flowStore.val.version_id = deployedVersionId
+					loadedPath = path
+					return
+				}
+
+				// No draft yet. Seed one from the last deploy (or the
+				// backend-side draft, if one exists).
+				const result = await FlowService.getFlowByPathWithDraft({ workspace, path })
+				savedFlow.val = result
+				const flow: Flow = (result.draft as Flow | undefined) ?? (result as Flow)
+				UserDraft.save('flow', path, flow, { workspace })
+				await initFlow(flow, flowStore, flowStateStore)
+				if (deployedVersionId != null && flowStore.val) flowStore.val.version_id = deployedVersionId
+				loadedPath = path
+			} catch (err) {
+				console.error('Failed to load flow', err)
+				notFound = true
+			} finally {
+				loadingFlow = false
+			}
+		},
+
+		scriptStore,
+		savedScript,
+		get loadingScript() {
+			return loadingScript
+		},
+		get notFoundScript() {
+			return notFoundScript
+		},
+		get loadedScriptPath() {
+			return loadedScriptPath
+		},
+
+		async loadScript(workspace: string, path: string, force = false) {
+			if (loadedScriptPath === path && !force) return
+			// Forced reload: clearing loadedScriptPath drops us into the
+			// `{#if loading && !loadedScriptPath}` gate, which unmounts then remounts
+			// the editor — avoids the Monaco init race a synchronous {#key} would hit.
+			if (force) loadedScriptPath = undefined
+			loadingScript = true
+			notFoundScript = false
+			try {
+				// Draft first. UserDraft is the shared authoritative content
+				// source — the chat (write_script / edit_script) and the
+				// editor's outbound $effect both write through it. If a draft
+				// exists we render from it, even when the path has never been
+				// deployed.
+				const aiDraft = UserDraft.get<NewScript>('script', path, { workspace })
+
+				if (aiDraft && typeof aiDraft.content === 'string') {
+					// Best-effort fetch the backend baseline for the diff
+					// drawer + parent_hash. 404 means draft-only — leave
+					// savedScript undefined and skip parent_hash.
+					try {
+						const result = await ScriptService.getScriptByPathWithDraft({ workspace, path })
+						savedScript.val = result
+					} catch {
+						savedScript.val = undefined
+					}
+					// Clone the deployed/backend baseline before layering the AI
+					// draft on top — otherwise we'd mutate `savedScript.val` in
+					// place (it's the same object) and lose the pristine baseline
+					// that the diff drawer + the deploy/discard affordance compare
+					// against.
+					const baseline: NewScript = savedScript.val
+						? (structuredClone(
+								$state.snapshot(
+									(savedScript.val.draft as NewScript | undefined) ?? (savedScript.val as NewScript)
+								)
+							) as NewScript)
+						: {
+								path,
+								summary: aiDraft.summary ?? '',
+								content: '',
+								description: '',
+								schema: emptySchema(),
+								language: (aiDraft.language ?? 'bun') as any
+							}
+					if (savedScript.val?.hash) {
+						baseline.parent_hash = savedScript.val.hash
+					}
+					baseline.content = aiDraft.content
+					if (aiDraft.language) baseline.language = aiDraft.language
+					if (aiDraft.summary !== undefined) baseline.summary = aiDraft.summary
+					scriptStore.val = baseline
+					loadedScriptPath = path
+					return
+				}
+
+				// No draft yet. Seed from backend.
+				const result = await ScriptService.getScriptByPathWithDraft({ workspace, path })
+				savedScript.val = result
+				// Clone before mutating: when result.draft is falsy, `baseline` would
+				// otherwise alias `result` (= savedScript.val), so baseline.parent_hash
+				// would corrupt the pristine deployed baseline the diff drawer reads.
+				const baseline = structuredClone(
+					(result.draft as NewScript | undefined) ?? (result as NewScript)
+				)
+				baseline.parent_hash = result.hash
+				UserDraft.save<NewScript>('script', path, baseline, { workspace })
+				scriptStore.val = baseline
+				loadedScriptPath = path
+			} catch (err) {
+				console.error('Failed to load script', err)
+				notFoundScript = true
+			} finally {
+				loadingScript = false
+			}
+		},
+
+		rawApp,
+		savedRawApp,
+		get loadingRawApp() {
+			return loadingRawApp
+		},
+		get notFoundRawApp() {
+			return notFoundRawApp
+		},
+		get loadedRawAppPath() {
+			return loadedRawAppPath
+		},
+
+		async loadRawApp(workspace: string, path: string, force = false) {
+			if (loadedRawAppPath === path && !force) return
+			// See loadScript: forced reload remounts via the render gate.
+			if (force) loadedRawAppPath = undefined
+			loadingRawApp = true
+			notFoundRawApp = false
+			try {
+				// Draft first. UserDraft is the shared authoritative content
+				// source — the chat (init_app / write_app_file / ...) and the
+				// editor's outbound $effect both write through it. If a draft
+				// exists we render from it, even when the path has never been
+				// deployed.
+				const aiDraft = UserDraft.get<RawAppDraft>('raw_app', path, { workspace })
+
+				if (aiDraft) {
+					// Best-effort fetch the backend baseline for the diff
+					// drawer. Don't fail the load if the path doesn't exist
+					// yet on the backend — draft-only apps are a valid state.
+					try {
+						const result = await AppService.getAppByPathWithDraft({ workspace, path })
+						savedRawApp.val = {
+							summary: result.summary,
+							value: result.value as any,
+							path: result.path,
+							policy: result.policy,
+							draft_only: result.draft_only,
+							draft: result.draft,
+							custom_path: result.custom_path
+						}
+					} catch {
+						savedRawApp.val = undefined
+					}
+					rawApp.val = applyDraftToRuntimeRawApp(
+						{
+							files: {},
+							runnables: {},
+							data: { ...DEFAULT_DATA },
+							policy: undefined,
+							summary: aiDraft.summary ?? '',
+							path
+						},
+						aiDraft
+					)
+					loadedRawAppPath = path
+					return
+				}
+
+				// No draft yet. Seed one from the last deploy (or the
+				// backend-side draft, if one exists — that's the user's
+				// "Save draft" content from the standalone editor and is
+				// fresher than `value`).
+				const result = await AppService.getAppByPathWithDraft({ workspace, path })
+				savedRawApp.val = {
+					summary: result.summary,
+					value: result.value as any,
+					path: result.path,
+					policy: result.policy,
+					draft_only: result.draft_only,
+					draft: result.draft,
+					custom_path: result.custom_path
+				}
+				const sourceValue: any = result.draft ?? result.value
+				let data: RawAppData = { ...DEFAULT_DATA }
+				if (sourceValue?.data) {
+					const d = sourceValue.data
+					if (d.creation) {
+						data = {
+							tables: d.tables ?? [],
+							datatable: d.creation.datatable,
+							schema: d.creation.schema
+						}
+					} else {
+						data = d
+					}
+				} else if (sourceValue?.datatables) {
+					data = { ...DEFAULT_DATA, tables: sourceValue.datatables }
+				}
+				const runtimeValue = {
+					files: (sourceValue?.files ?? {}) as Record<string, string>,
+					runnables: (sourceValue?.runnables ?? {}) as Record<string, any>,
+					data,
+					policy: result.policy,
+					summary: result.summary ?? '',
+					path: result.path,
+					custom_path: result.custom_path
+				}
+				UserDraft.save('raw_app', path, runtimeRawAppToDraft(runtimeValue), { workspace })
+				rawApp.val = runtimeValue
+				loadedRawAppPath = path
+			} catch (err) {
+				console.error('Failed to load raw app', err)
+				notFoundRawApp = true
+			} finally {
+				loadingRawApp = false
+			}
+		},
+
+		syncPreviewWithDeployed(workspace, kind, path) {
+			this.scheduleForkComparisonRefresh()
+			UserDraft.discard(kind, path, undefined, { workspace })
+			if (kind === 'script') void this.loadScript(workspace, path, true)
+			else if (kind === 'flow') void this.loadFlow(workspace, path, true)
+			else void this.loadRawApp(workspace, path, true)
+		},
+
+		forkComparison,
+		get loadingForkComparison() {
+			return loadingForkComparison
+		},
+
+		async ensureForkComparison(parent: string, fork: string) {
+			const key = `${parent}|${fork}`
+			if (forkComparisonKey === key && forkComparison.val) return
+			if (loadingForkComparison && forkComparisonKey === key) return
+			forkComparisonKey = key
+			loadingForkComparison = true
+			try {
+				forkComparison.val = await WorkspaceService.compareWorkspaces({
+					workspace: parent,
+					targetWorkspaceId: fork
+				})
+			} catch (e) {
+				console.error('SessionRuntime: forkComparison fetch failed', e)
+				forkComparison.val = undefined
+				// On error, clear the key so the next call retries.
+				if (forkComparisonKey === key) forkComparisonKey = undefined
+			} finally {
+				loadingForkComparison = false
+			}
+		},
+
+		invalidateForkComparison() {
+			forkComparisonKey = undefined
+			forkComparison.val = undefined
+		},
+
+		// Stale-while-revalidate: re-fetch in place so the cached status
+		// (driving the sidebar dot, fork bar, etc.) stays put until the new
+		// result lands. Clearing forkComparison.val here flickered the icon
+		// back to the neutral GitFork on every session-activate refresh.
+		refreshForkComparison() {
+			return refreshForkComparisonNow()
+		},
+
+		scheduleForkComparisonRefresh() {
+			// The backend fork tally registers a draft save (createScript
+			// draft_only / DraftService.createDraft) asynchronously — ~300ms
+			// after the API call returns — so an immediate refresh races it.
+			// Fetch once after the tally typically lands, then again as a
+			// backstop for slower backends. Coalesce rapid saves by clearing
+			// any still-pending timers first.
+			for (const t of forkRefreshTimers) clearTimeout(t)
+			forkRefreshTimers = [
+				setTimeout(() => void refreshForkComparisonNow(), 700),
+				setTimeout(() => void refreshForkComparisonNow(), 2200)
+			]
+		},
+		dispose() {
+			for (const t of forkRefreshTimers) clearTimeout(t)
+			forkRefreshTimers = []
+		}
+	}
+}
+
+async function initRuntime(runtime: SessionRuntime, session: Session) {
+	const { manager } = runtime
+	await manager.historyManager.init()
+	manager.historyManager.setSessionId(session.id)
+	await ensureChatIdsSeeded(manager.historyManager)
+
+	if (session.chatId) {
+		manager.historyManager.setCurrentChatId(session.chatId)
+		await manager.historyManager.tagChatWithSession(session.chatId, session.id)
+		await manager.loadPastChat(session.chatId)
+	} else {
+		setSessionChatId(session.id, manager.historyManager.getCurrentChatId())
+	}
+}
+
+export function getOrCreateRuntime(session: Session): SessionRuntime {
+	let runtime = runtimes.get(session.id)
+	if (!runtime) {
+		runtime = createRuntime(session)
+		runtimes.set(session.id, runtime)
+		initRuntime(runtime, session).catch((e) => console.error('Failed to init session runtime', e))
+	}
+	return runtime
+}
+
+export function disposeRuntime(sessionId: string) {
+	const runtime = runtimes.get(sessionId)
+	if (!runtime) return
+	runtime.dispose()
+	runtime.manager.cancel('runtime disposed')
+	runtime.manager.historyManager.close()
+	runtimes.delete(sessionId)
+}
+
+export function listRuntimes(): SessionRuntime[] {
+	return Array.from(runtimes.values())
+}
+
+export function getRuntime(sessionId: string): SessionRuntime | undefined {
+	return runtimes.get(sessionId)
+}
+
+export type SessionChatStatus =
+	| 'idle'
+	| 'streaming'
+	| 'awaiting-user'
+	| 'needs-confirmation'
+	| 'draft'
+	| 'error'
+
+// MRU set of session ids whose FlowEditorView is currently mounted. Capped at
+// MAX_WARM_EDITORS — sessions outside the set show chat-only. Module-scoped so
+// both the page (which mutates) and the sidebar (which reads for the dev clue)
+// see the same state.
+const MAX_WARM_EDITORS = 3
+export const editorWarmIds = new SvelteSet<string>()
+
+// Full session teardown: dispose the runtime, drop the LRU entry, and remove
+// from sessionState in one call. Callers (sidebar / header dropdowns) just
+// invoke this; navigation away from a deleted active session is the caller's
+// responsibility.
+export function removeSession(sessionId: string): void {
+	disposeRuntime(sessionId)
+	editorWarmIds.delete(sessionId)
+	deleteSessionState(sessionId)
+}
+
+export function promoteEditorWarm(sessionId: string): void {
+	editorWarmIds.delete(sessionId)
+	editorWarmIds.add(sessionId)
+	while (editorWarmIds.size > MAX_WARM_EDITORS) {
+		const oldest = editorWarmIds.values().next().value
+		if (oldest === undefined) break
+		editorWarmIds.delete(oldest)
+	}
+}
+
+// Register the global open_preview tool handler once at module load. It
+// dispatches to the *calling* session (sessionId threaded from the tool ctx),
+// falling back to the UI-active session only when none was passed — so a
+// backgrounded session's tool call opens its OWN preview, not the one the user
+// happens to be viewing. Outside a session there is no calling/active id and
+// the tool returns a polite error.
+setOpenPreviewHandler(({ sessionId: callerSessionId, kind, path }) => {
+	const sessionId = callerSessionId ?? sessionState.currentSessionId
+	if (!sessionId) {
+		return 'Error: no active session to open the preview in.'
+	}
+	const current = sessionState.sessions.find((s) => s.id === sessionId)?.target
+	if (current && current.kind === kind && current.path === path) {
+		return `Preview is already open showing ${kind} "${path}".`
+	}
+	const target: SessionTarget = { kind, path }
+	setSessionTarget(sessionId, target)
+	promoteEditorWarm(sessionId)
+	return `Opened ${kind} preview for ${path} in the side panel.`
+})
+
+// Companion to the open_preview handler: report whether the calling session's
+// preview is open and which item it shows, so the assistant can avoid
+// re-opening a preview already showing the item it just edited.
+setGetPreviewStatusHandler((callerSessionId) => {
+	const sessionId = callerSessionId ?? sessionState.currentSessionId
+	if (!sessionId) return 'No active session; the preview panel is unavailable.'
+	const target = sessionState.sessions.find((s) => s.id === sessionId)?.target
+	if (!target) return 'No preview is currently open in the side panel.'
+	return `The preview is currently open showing ${target.kind} "${target.path}".`
+})
+
+// After a chat deploy, reload the calling session's preview — only if it's open
+// showing that exact item.
+setDeployedInSessionHandler(({ sessionId: callerSessionId, kind, path }) => {
+	const sessionId = callerSessionId ?? sessionState.currentSessionId
+	if (!sessionId) return
+	const session = sessionState.sessions.find((s) => s.id === sessionId)
+	const runtime = runtimes.get(sessionId)
+	if (!session?.workspace_id || !runtime) return
+	const open =
+		(kind === 'script' && runtime.loadedScriptPath === path) ||
+		(kind === 'flow' && runtime.loadedPath === path) ||
+		(kind === 'raw_app' && runtime.loadedRawAppPath === path)
+	if (!open) return
+	runtime.syncPreviewWithDeployed(session.workspace_id, kind, path)
+})
+
+export function getSessionChatStatus(runtime: SessionRuntime): SessionChatStatus {
+	const m = runtime.manager
+	if (m.loading) return 'streaming'
+	if (m.instructions.trim().length > 0) return 'draft'
+	const last = m.displayMessages[m.displayMessages.length - 1]
+	if (last?.role === 'tool' && last.needsConfirmation) return 'needs-confirmation'
+	if (last?.role === 'user' && last.error) return 'error'
+	if (last && (last.role === 'assistant' || last.role === 'tool')) return 'awaiting-user'
+	return 'idle'
+}
diff --git a/frontend/src/lib/components/sessions/sessionScope.svelte.ts b/frontend/src/lib/components/sessions/sessionScope.svelte.ts
new file mode 100644
index 0000000000..a69074fdf8
--- /dev/null
+++ b/frontend/src/lib/components/sessions/sessionScope.svelte.ts
@@ -0,0 +1,32 @@
+import { derived, type Readable } from 'svelte/store'
+import { workspaceStore, userWorkspaces, type UserWorkspace } from '$lib/stores'
+import { findWorkspaceDescendants } from '$lib/utils/workspaceHierarchy'
+
+// Walk up parent_workspace_id chain to find the root of the fork family
+// containing `id`. Falls back to the workspace itself if it has no parent
+// (or its parent isn't in the user's list).
+function findFamilyRoot(id: string, all: UserWorkspace[]): UserWorkspace | undefined {
+	let current = all.find((w) => w.id === id)
+	while (current?.parent_workspace_id) {
+		const parent = all.find((w) => w.id === current!.parent_workspace_id)
+		if (!parent) break
+		current = parent
+	}
+	return current
+}
+
+// Set of workspace ids a session must belong to for the user to see it in
+// the sidebar list. The whole fork family is visible from any node: when
+// the user is inside fork A whose root is R, sessions belonging to R or
+// any sibling fork of A are listed too. Recomputes when the user switches
+// workspace or when the workspace list refreshes.
+export const visibleWorkspaceIds: Readable<Set<string>> = derived(
+	[workspaceStore, userWorkspaces],
+	([ws, all]) => {
+		if (!ws) return new Set<string>()
+		const root = findFamilyRoot(ws, all) ?? ({ id: ws } as UserWorkspace)
+		const ids = new Set<string>([root.id])
+		for (const d of findWorkspaceDescendants(root.id, all)) ids.add(d.id)
+		return ids
+	}
+)
diff --git a/frontend/src/lib/components/sessions/sessionState.svelte.ts b/frontend/src/lib/components/sessions/sessionState.svelte.ts
new file mode 100644
index 0000000000..6c1411eb35
--- /dev/null
+++ b/frontend/src/lib/components/sessions/sessionState.svelte.ts
@@ -0,0 +1,501 @@
+import { BROWSER } from 'esm-env'
+import { get } from 'svelte/store'
+import { createLongHash } from '$lib/editorLangUtils'
+import { random_adj } from '$lib/components/random_positive_adjetive'
+import {
+	userWorkspaces,
+	usersWorkspaceStore,
+	workspaceStore,
+	type UserWorkspace
+} from '$lib/stores'
+import { switchWorkspace } from '$lib/storeUtils'
+
+// Switch the global workspace iff the target differs from the active one
+// and is non-empty. Centralises the "session needs its workspace in focus"
+// rule so picker, deep-link, and workspace-bar paths agree on the same
+// semantic. No-op for `undefined` / empty.
+export function syncWorkspaceTo(workspaceId: string | undefined): void {
+	if (!workspaceId) return
+	if (workspaceId === get(workspaceStore)) return
+	switchWorkspace(workspaceId)
+}
+import { WorkspaceService, type WorkspaceComparison } from '$lib/gen'
+import { sendUserToast } from '$lib/toast'
+import type HistoryManager from '$lib/components/copilot/chat/HistoryManager.svelte'
+
+// Kinds the in-session editor pane can host. Legacy drag-and-drop apps are
+// intentionally not previewable — only code-based 'raw_app' apps are.
+export type SessionTarget = { kind: 'flow' | 'script' | 'raw_app'; path: string }
+
+// Useful for filtering dropdowns / pickers to "items the side panel can open".
+export const EDITOR_TARGET_KINDS: ReadonlySet<SessionTarget['kind']> = new Set([
+	'flow',
+	'script',
+	'raw_app'
+])
+
+// Lifecycle status for a fork session. Git-parallel:
+//   in_sync     — fork is up to date with parent (or only behind — treated
+//                 the same since the user has no unmerged work either way).
+//   ahead       — fork has unmerged changes vs parent (branch ahead).
+//   diverged    — fork has unmerged changes AND parent has moved (branch
+//                 diverged from upstream — potential conflicts).
+//   unavailable — fork workspace is no longer in the user's list (deleted,
+//                 archived, or access revoked). Read-only fallback.
+//
+// `undefined` is the loading / not-applicable state (root session,
+// comparison not yet fetched).
+export type ForkStatus = 'in_sync' | 'ahead' | 'diverged' | 'unavailable'
+
+// Whether the session points at a workspace that is itself a fork (i.e.
+// has a parent). Independent of comparison-fetch state — used by the
+// sidebar to pick between a root (Building) icon and a fork-status icon
+// before the comparison has loaded.
+//
+// Sessions whose committed workspace is no longer in the user's list are
+// still treated as forks (the "unavailable" terminal state) so we don't
+// flip them back to Building once access is lost.
+export function isForkSession(session: Session, allWorkspaces: UserWorkspace[]): boolean {
+	const wsId = session.workspace_id ?? session.pending_workspace_id
+	if (!wsId) return false
+	const ws = allWorkspaces.find((w) => w.id === wsId)
+	if (!ws) return !!session.workspace_id
+	return !!ws.parent_workspace_id
+}
+
+export function deriveForkStatus(
+	session: Session,
+	allWorkspaces: UserWorkspace[],
+	comparison: WorkspaceComparison | undefined
+): ForkStatus | undefined {
+	const wsId = session.workspace_id ?? session.pending_workspace_id
+	if (!wsId) return undefined
+	const ws = allWorkspaces.find((w) => w.id === wsId)
+	// Committed fork workspaces that disappear from the user's list
+	// (deleted, archived, or access lost) are flagged unavailable so
+	// the UI can render a terminal state without trying to switch into
+	// them. Drafts whose pending workspace also vanished get the same
+	// treatment.
+	if (!ws) return session.workspace_id ? 'unavailable' : undefined
+	if (!ws.parent_workspace_id) return undefined
+	if (!comparison) return undefined
+	const ahead = comparison.summary?.total_ahead ?? 0
+	const behind = comparison.summary?.total_behind ?? 0
+	if (ahead > 0 && behind > 0) return 'diverged'
+	if (ahead > 0) return 'ahead'
+	return 'in_sync'
+}
+
+export type PendingFork = {
+	// Existing workspace to fork from (drives routing/scope pre-send).
+	parent_workspace_id: string
+	// Slug the new fork will use, e.g. `wm-fork-foo`.
+	id: string
+	// Display name shown in the workspace bar.
+	name: string
+}
+
+export type Session = {
+	id: string
+	name: string
+	// Committed strictly at first user-message send. Undefined for drafts
+	// that have never been sent — those scope by `pending_workspace_id`
+	// instead and don't show the fork bar.
+	workspace_id?: string
+	// Pre-send draft workspace, picked via SessionWorkspaceBar. Drives
+	// scope/editor/display while workspace_id is undefined; gets copied
+	// into workspace_id at first send and then becomes irrelevant.
+	pending_workspace_id?: string
+	// Pre-send intent to create a new fork. The actual API call is
+	// deferred to first send (via commitSessionWorkspace) so cancelling
+	// the draft doesn't leave an orphan fork behind.
+	pending_fork?: PendingFork
+	chatId?: string
+	target?: SessionTarget
+	summary?: string
+	createdAt: number
+	// User-archived sessions are hidden from the sidebar by default
+	// (toggleable via the picker filter). Archive is reversible — distinct
+	// from delete, which removes the session entirely.
+	archived?: boolean
+	// In-memory-only flag: the session exists but isn't written to
+	// localStorage until the user sends their first message. Avoids
+	// piling abandoned drafts across `+` clicks — createSession reuses
+	// the existing transient if one is already open.
+	transient?: boolean
+}
+
+const STORAGE_KEY = 'windmill_sessions'
+
+// New users (empty/cleared/private-browsing localStorage) start with no
+// sessions — the sidebar + /sessions page render their empty states and the
+// user creates the first session with `+`. Do NOT seed placeholder sessions
+// here: hardcoded example paths won't resolve for other users and render as
+// "session not found".
+const defaultSessions: Session[] = []
+
+function loadSessions(): Session[] {
+	if (!BROWSER) return defaultSessions
+	try {
+		const raw = localStorage.getItem(STORAGE_KEY)
+		if (raw) {
+			const parsed = JSON.parse(raw)
+			if (Array.isArray(parsed) && parsed.length > 0) {
+				// Drop empty-string workspace_id (older sessions used '' as a
+				// missing-value marker) so the undefined-until-first-send invariant
+				// holds for legacy drafts. Also migrate the deprecated
+				// 'rawapp' target.kind to the canonical 'raw_app'.
+				let mutated = false
+				for (const s of parsed) {
+					if (s.workspace_id === '') {
+						delete s.workspace_id
+						mutated = true
+					}
+					if (s.target?.kind === 'rawapp') {
+						s.target.kind = 'raw_app'
+						mutated = true
+					}
+				}
+				if (mutated) {
+					try {
+						localStorage.setItem(STORAGE_KEY, JSON.stringify(parsed))
+					} catch (e) {
+						console.error('Failed to persist normalised sessions', e)
+					}
+				}
+				return parsed as Session[]
+			}
+		}
+	} catch (e) {
+		console.error('Failed to load sessions from localStorage', e)
+	}
+	return defaultSessions
+}
+
+export const sessionState = $state<{
+	sessions: Session[]
+	currentSessionId: string | undefined
+}>({
+	sessions: loadSessions(),
+	currentSessionId: undefined
+})
+
+export function persistSessions() {
+	if (!BROWSER) return
+	try {
+		// Transient (unsent) sessions stay in memory only. They get
+		// materialised — and from then on written to storage — when the
+		// user sends their first message.
+		const toPersist = $state.snapshot(sessionState.sessions).filter((s) => !s.transient)
+		localStorage.setItem(STORAGE_KEY, JSON.stringify(toPersist))
+	} catch (e) {
+		console.error('Failed to persist sessions', e)
+	}
+}
+
+export function findSessionByName(name: string): Session | undefined {
+	return sessionState.sessions.find((s) => s.name === name)
+}
+
+// Walk up parent_workspace_id to the family root, given a starting
+// workspace id. Returns the input id if no parent chain is visible.
+function familyRootId(id: string | undefined, all: UserWorkspace[]): string | undefined {
+	if (!id) return undefined
+	let cur = all.find((w) => w.id === id)
+	while (cur?.parent_workspace_id) {
+		const parent = all.find((w) => w.id === cur!.parent_workspace_id)
+		if (!parent) break
+		cur = parent
+	}
+	return cur?.id ?? id
+}
+
+export function createSession(): Session {
+	// Reuse the existing transient session (if any) so the user can hit
+	// the "+" button repeatedly without piling drafts. The transient
+	// becomes a real session at first-message-send time.
+	const existingTransient = sessionState.sessions.find((s) => s.transient)
+	if (existingTransient) {
+		sessionState.currentSessionId = existingTransient.id
+		return existingTransient
+	}
+	const existingNumbers = sessionState.sessions
+		.map((s) => /^session-(\d+)$/.exec(s.name)?.[1])
+		.map((n) => (n ? parseInt(n, 10) : 0))
+	const next = (existingNumbers.length ? Math.max(...existingNumbers) : 0) + 1
+	// Default to the family root rather than wherever the user happens
+	// to be — sessions usually start from "the canonical workspace" and
+	// the picker lets them switch to a fork later.
+	const currentWs = get(workspaceStore)
+	const root = familyRootId(currentWs ?? undefined, get(userWorkspaces))
+	const pending = root ?? currentWs
+	// Friendly default summary so the header reads like "Zippy session"
+	// rather than "Untitled session" — assigned at create time, the user
+	// can still rename it (or it gets overwritten by an editor target).
+	const adj = random_adj()
+	const summary = `${adj.charAt(0).toUpperCase() + adj.slice(1)} session`
+	const session: Session = {
+		id: createLongHash(),
+		name: `session-${next}`,
+		summary,
+		pending_workspace_id: pending && pending.length > 0 ? pending : undefined,
+		createdAt: Date.now(),
+		transient: true
+	}
+	sessionState.sessions = [session, ...sessionState.sessions]
+	sessionState.currentSessionId = session.id
+	// persistSessions() filters out transients — this call is a no-op for
+	// the new draft, but kept so any other session mutations get flushed.
+	persistSessions()
+	return session
+}
+
+// Promote an in-memory transient session to a persisted one. No-op when
+// the session isn't transient. Called by the chat manager's beforeSend
+// hook so the session is only written to localStorage once the user
+// commits to it by sending their first message.
+export function materializeTransient(id: string): void {
+	const s = sessionState.sessions.find((x) => x.id === id)
+	if (!s || !s.transient) return
+	delete s.transient
+	persistSessions()
+}
+
+export function setSessionPendingWorkspace(id: string, workspace_id: string) {
+	const s = sessionState.sessions.find((x) => x.id === id)
+	if (!s) return
+	const changed = s.pending_workspace_id !== workspace_id || s.pending_fork !== undefined
+	s.pending_workspace_id = workspace_id
+	// Picking an existing workspace cancels any pending fork intent.
+	s.pending_fork = undefined
+	if (changed) persistSessions()
+}
+
+// Records the user's intent to create a new fork without firing the API
+// call yet. Routing/scope stay on the parent workspace until commit.
+export function setSessionPendingFork(id: string, fork: PendingFork) {
+	const s = sessionState.sessions.find((x) => x.id === id)
+	if (!s) return
+	s.pending_fork = { ...fork }
+	s.pending_workspace_id = fork.parent_workspace_id
+	persistSessions()
+}
+
+// One-shot commit: locks in workspace_id at first user-message send.
+// If a pending fork is set, materialises it via the API first, then
+// switches the global workspace to the freshly created fork. Falls back
+// to the pending pick, then the active workspace. Clears pending so it
+// doesn't shadow later reads.
+export async function commitSessionWorkspace(
+	id: string,
+	fallback?: string
+): Promise<string | undefined> {
+	const s = sessionState.sessions.find((x) => x.id === id)
+	if (!s) return undefined
+	if (s.workspace_id) return s.workspace_id
+
+	if (s.pending_fork) {
+		const fork = s.pending_fork
+		const newId = await materializeFork(fork)
+		if (!newId) {
+			// Real failure (not a recovered duplicate). Drop the pending
+			// fork so the session falls through to the workspace-pick
+			// fallback on the next call and the unavailable-banner UX
+			// can take over instead of looping on the same broken intent.
+			s.pending_fork = undefined
+			persistSessions()
+			return undefined
+		}
+		if (get(workspaceStore) !== newId) switchWorkspace(newId)
+		s.workspace_id = newId
+		s.pending_fork = undefined
+		s.pending_workspace_id = undefined
+		persistSessions()
+		return newId
+	}
+
+	const ws = s.pending_workspace_id ?? fallback
+	if (!ws) return undefined
+	s.workspace_id = ws
+	s.pending_workspace_id = undefined
+	// `pending_workspace_id` defaults to the family root when created from
+	// inside a fork, so the committed workspace can differ from the active
+	// workspaceStore. Without this sync, the very first AI request's
+	// `logAiChat` and tool calls read the stale fork from workspaceStore
+	// while the session metadata says root. Mirrors the `switchWorkspace`
+	// in the pending_fork branch above.
+	if (get(workspaceStore) !== ws) syncWorkspaceTo(ws)
+	persistSessions()
+	return ws
+}
+
+// Effective workspace for scope/routing — committed if set, otherwise the
+// pre-send pending pick (which defaults to the workspace at create time).
+// Pending forks route via their parent until creation lands.
+export function getEffectiveWorkspaceId(session: Session): string | undefined {
+	return session.workspace_id ?? session.pending_workspace_id
+}
+
+// Canonical mutation for session.target. Persists, optionally seeds the
+// session summary, and centralises the path so callers don't reach into
+// session.target directly.
+export function setSessionTarget(id: string, target: SessionTarget, summary?: string): void {
+	const s = sessionState.sessions.find((x) => x.id === id)
+	if (!s) return
+	s.target = target
+	if (!s.summary && summary) s.summary = summary
+	persistSessions()
+}
+
+export function selectSession(id: string) {
+	sessionState.currentSessionId = id
+}
+
+export function renameSession(id: string, newSummary: string) {
+	const trimmed = newSummary.trim()
+	const s = sessionState.sessions.find((x) => x.id === id)
+	if (!s) return
+	s.summary = trimmed.length > 0 ? trimmed : undefined
+	persistSessions()
+}
+
+// Create a new fork workspace via the API, refresh the user-workspaces
+// store, and return the new fork id. Used by both the first-send commit
+// path (commitSessionWorkspace) and the move-session-to-a-new-fork path
+// in the unavailable-session banner. Returns undefined on failure (a
+// user-facing toast is already emitted).
+//
+// Self-heal: if `fork.id` is already present in the user-workspaces
+// store, the previous create succeeded (whose response we apparently
+// lost). Adopt it silently instead of re-POSTing — the API would
+// otherwise reject with workspace_pkey. Likewise, if the API returns a
+// duplicate-key error we refresh the store and adopt the existing row.
+export async function materializeFork(fork: PendingFork): Promise<string | undefined> {
+	if (get(userWorkspaces).some((w) => w.id === fork.id)) return fork.id
+	try {
+		await WorkspaceService.createWorkspaceFork({
+			workspace: fork.parent_workspace_id,
+			requestBody: { id: fork.id, name: fork.name }
+		})
+		usersWorkspaceStore.set(await WorkspaceService.listUserWorkspaces())
+		sendUserToast(`Created fork ${fork.name}`)
+		return fork.id
+	} catch (e: any) {
+		const msg = String(e?.body ?? e?.message ?? e)
+		if (/workspace_pkey|duplicate key/i.test(msg)) {
+			// Self-heal: the create likely already succeeded. Refresh + adopt the
+			// existing row. Guard this refresh — a second network failure here must
+			// NOT rethrow out of materializeFork (callers rely on the
+			// toast-and-return-undefined contract; an uncaught throw would bypass
+			// it and propagate up through commitSessionWorkspace/beforeSend).
+			try {
+				usersWorkspaceStore.set(await WorkspaceService.listUserWorkspaces())
+				if (get(userWorkspaces).some((w) => w.id === fork.id)) return fork.id
+			} catch (refreshErr) {
+				console.error('Failed to refresh workspaces during fork self-heal', refreshErr)
+			}
+		}
+		sendUserToast(`Could not create fork: ${msg}`, true)
+		return undefined
+	}
+}
+
+// Re-assign a committed session to a different workspace. Used to rescue
+// sessions whose original workspace was deleted / archived / had access
+// revoked — the chat history (stored in IndexedDB keyed by session id) is
+// preserved; only the workspace pointer changes. Drops pending fields
+// since the session is already past the draft stage by definition.
+export function moveSessionToWorkspace(id: string, newWorkspaceId: string) {
+	const s = sessionState.sessions.find((x) => x.id === id)
+	if (!s) return
+	if (s.workspace_id === newWorkspaceId) return
+	s.workspace_id = newWorkspaceId
+	delete s.pending_workspace_id
+	delete s.pending_fork
+	persistSessions()
+}
+
+// Create a brand-new fork and re-assign a committed session to it. Used
+// by the unavailable-session banner's "Create new fork" path in the
+// move dropdown. On success the global workspace is switched to the
+// freshly created fork.
+export async function moveSessionToNewFork(
+	id: string,
+	fork: PendingFork
+): Promise<string | undefined> {
+	const s = sessionState.sessions.find((x) => x.id === id)
+	if (!s) return undefined
+	const newId = await materializeFork(fork)
+	if (!newId) return undefined
+	if (get(workspaceStore) !== newId) switchWorkspace(newId)
+	moveSessionToWorkspace(id, newId)
+	return newId
+}
+
+export function setSessionArchived(id: string, archived: boolean) {
+	const s = sessionState.sessions.find((x) => x.id === id)
+	if (!s) return
+	const next = archived ? true : undefined
+	if (s.archived === next) return
+	if (archived) s.archived = true
+	else delete s.archived
+	persistSessions()
+}
+
+export function deleteSession(id: string) {
+	const idx = sessionState.sessions.findIndex((s) => s.id === id)
+	if (idx < 0) return
+	sessionState.sessions = sessionState.sessions.filter((s) => s.id !== id)
+	if (sessionState.currentSessionId === id) {
+		sessionState.currentSessionId = sessionState.sessions[0]?.id
+	}
+	persistSessions()
+}
+
+export function setSessionChatId(sessionId: string, chatId: string) {
+	const s = sessionState.sessions.find((x) => x.id === sessionId)
+	if (s && s.chatId !== chatId) {
+		s.chatId = chatId
+		persistSessions()
+	}
+}
+
+let seedPromise: Promise<void> | undefined
+
+// One-shot pairing of the user's two most-recently-modified saved chats with
+// the two seeded sessions. Idempotent across all callers / SessionWrappers.
+export function ensureChatIdsSeeded(historyManager: HistoryManager): Promise<void> {
+	if (!seedPromise) {
+		seedPromise = (async () => {
+			try {
+				await historyManager.init()
+				// Read directly from storage so we see chats regardless of this manager's
+				// own session-scope filter (getPastChats would hide already-tagged ones).
+				const pastChats = historyManager.getAllSavedChats()
+				const untagged = pastChats
+					.filter((c) => !c.sessionId)
+					.sort((a, b) => b.lastModified - a.lastModified)
+				// Only seed pre-existing (persisted) sessions. Transient
+				// sessions are freshly created via the "+" button and must
+				// start with an empty chat — if the seed catches one (e.g. the
+				// user clicks "New session" before this one-shot runs), it
+				// would graft a previous discussion onto the new session.
+				const seedable = sessionState.sessions.filter((s) => !s.transient)
+				let mutated = false
+				for (let i = 0; i < Math.min(seedable.length, untagged.length); i++) {
+					if (!seedable[i].chatId) {
+						const chatId = untagged[i].id
+						const sessionId = seedable[i].id
+						seedable[i].chatId = chatId
+						await historyManager.tagChatWithSession(chatId, sessionId)
+						mutated = true
+					}
+				}
+				if (mutated) persistSessions()
+			} catch (e) {
+				console.error('Failed to seed chat ids from history', e)
+			}
+		})()
+	}
+	return seedPromise
+}
diff --git a/frontend/src/lib/components/sessions/sessionState.test.ts b/frontend/src/lib/components/sessions/sessionState.test.ts
new file mode 100644
index 0000000000..eda5890580
--- /dev/null
+++ b/frontend/src/lib/components/sessions/sessionState.test.ts
@@ -0,0 +1,196 @@
+import { describe, it, expect, vi } from 'vitest'
+import { get } from 'svelte/store'
+import {
+	commitSessionWorkspace,
+	deriveForkStatus,
+	isForkSession,
+	sessionState,
+	type Session
+} from './sessionState.svelte'
+import { workspaceStore, type UserWorkspace } from '$lib/stores'
+import type { WorkspaceComparison } from '$lib/gen'
+
+// Force createWorkspaceFork to fail so we can pin commitSessionWorkspace's
+// failure contract (the invariant the beforeSend abort fix relies on).
+vi.mock('$lib/gen', async (orig) => {
+	const actual = await orig<typeof import('$lib/gen')>()
+	return {
+		...actual,
+		WorkspaceService: {
+			...actual.WorkspaceService,
+			createWorkspaceFork: vi.fn().mockRejectedValue(new Error('fork creation failed')),
+			listUserWorkspaces: vi.fn().mockResolvedValue([])
+		}
+	}
+})
+
+// Minimal fixtures — only the fields these pure helpers read matter; the rest
+// is filled via cast so we don't track unrelated schema churn.
+function session(over: Partial<Session> = {}): Session {
+	return { id: 's1', name: 'sess', createdAt: 0, ...over }
+}
+function ws(id: string, parent?: string): UserWorkspace {
+	return { id, name: id, parent_workspace_id: parent } as unknown as UserWorkspace
+}
+function comparison(total_ahead: number, total_behind: number): WorkspaceComparison {
+	return { summary: { total_ahead, total_behind } } as unknown as WorkspaceComparison
+}
+
+describe('isForkSession', () => {
+	it('is false for a draft with no workspace at all', () => {
+		expect(isForkSession(session(), [])).toBe(false)
+	})
+
+	it('is false when the workspace is a (non-fork) root', () => {
+		expect(isForkSession(session({ workspace_id: 'root' }), [ws('root')])).toBe(false)
+	})
+
+	it('is true when the workspace has a parent (is a fork)', () => {
+		expect(isForkSession(session({ workspace_id: 'fork' }), [ws('fork', 'root')])).toBe(true)
+	})
+
+	it('treats a committed-but-missing workspace as a fork (terminal unavailable state)', () => {
+		expect(isForkSession(session({ workspace_id: 'gone' }), [])).toBe(true)
+	})
+
+	it('is false for a draft whose pending workspace is missing', () => {
+		expect(isForkSession(session({ pending_workspace_id: 'gone' }), [])).toBe(false)
+	})
+
+	it('resolves a draft via its pending workspace', () => {
+		expect(isForkSession(session({ pending_workspace_id: 'fork' }), [ws('fork', 'root')])).toBe(
+			true
+		)
+	})
+})
+
+describe('deriveForkStatus', () => {
+	it('is undefined for a draft with no workspace', () => {
+		expect(deriveForkStatus(session(), [], undefined)).toBeUndefined()
+	})
+
+	it('is unavailable when a committed workspace is no longer in the list', () => {
+		expect(deriveForkStatus(session({ workspace_id: 'gone' }), [], comparison(0, 0))).toBe(
+			'unavailable'
+		)
+	})
+
+	it('is undefined when a draft pending workspace is missing (not yet committed)', () => {
+		expect(
+			deriveForkStatus(session({ pending_workspace_id: 'gone' }), [], undefined)
+		).toBeUndefined()
+	})
+
+	it('is undefined for a non-fork (root) workspace', () => {
+		expect(
+			deriveForkStatus(session({ workspace_id: 'root' }), [ws('root')], comparison(3, 3))
+		).toBeUndefined()
+	})
+
+	it('is undefined for a fork before the comparison has loaded', () => {
+		expect(
+			deriveForkStatus(session({ workspace_id: 'fork' }), [ws('fork', 'root')], undefined)
+		).toBeUndefined()
+	})
+
+	it('is diverged when the fork is both ahead and behind', () => {
+		expect(
+			deriveForkStatus(session({ workspace_id: 'fork' }), [ws('fork', 'root')], comparison(2, 1))
+		).toBe('diverged')
+	})
+
+	it('is ahead when the fork has unmerged changes and the parent has not moved', () => {
+		expect(
+			deriveForkStatus(session({ workspace_id: 'fork' }), [ws('fork', 'root')], comparison(2, 0))
+		).toBe('ahead')
+	})
+
+	it('is in_sync when neither side is ahead', () => {
+		expect(
+			deriveForkStatus(session({ workspace_id: 'fork' }), [ws('fork', 'root')], comparison(0, 0))
+		).toBe('in_sync')
+	})
+
+	it('is in_sync when only the parent moved (behind-only, fork has no local changes)', () => {
+		expect(
+			deriveForkStatus(session({ workspace_id: 'fork' }), [ws('fork', 'root')], comparison(0, 2))
+		).toBe('in_sync')
+	})
+})
+
+describe('commitSessionWorkspace — fork-creation failure', () => {
+	it('returns undefined and drops pending_fork (so beforeSend aborts the send)', async () => {
+		const id = 'test-commit-fork-fail'
+		sessionState.sessions.push({
+			id,
+			name: 'fork-fail',
+			createdAt: 0,
+			pending_fork: { parent_workspace_id: 'parent_ws', id: 'wm-fork-nope', name: 'nope' }
+		} as Session)
+		try {
+			const committed = await commitSessionWorkspace(id, 'parent_ws')
+			// Not committed → undefined. This is what makes beforeSend throw rather
+			// than letting the first message ship to the parent workspace.
+			expect(committed).toBeUndefined()
+			const s = sessionState.sessions.find((x) => x.id === id)
+			expect(s?.workspace_id).toBeUndefined()
+			expect(s?.pending_fork).toBeUndefined()
+		} finally {
+			const i = sessionState.sessions.findIndex((x) => x.id === id)
+			if (i >= 0) sessionState.sessions.splice(i, 1)
+		}
+	})
+})
+
+describe('commitSessionWorkspace — workspaceStore sync (non-fork branch)', () => {
+	it('syncs workspaceStore to the committed workspace when they differ', async () => {
+		// Repro: user is sitting in a fork workspace (wm-fork-x) and creates a
+		// new session whose pending_workspace_id defaults to the family root.
+		// Without the syncWorkspaceTo call in commitSessionWorkspace's non-fork
+		// branch, the session metadata says root while the active workspace
+		// stays on the fork — so AIChatManager.chatRequest's logAiChat and tool
+		// calls would target the wrong workspace.
+		const id = 'test-commit-ws-sync'
+		const prev = get(workspaceStore)
+		workspaceStore.set('wm-fork-x')
+		sessionState.sessions.push({
+			id,
+			name: 'ws-sync',
+			createdAt: 0,
+			pending_workspace_id: 'root_ws'
+		} as Session)
+		try {
+			const committed = await commitSessionWorkspace(id, undefined)
+			expect(committed).toBe('root_ws')
+			const s = sessionState.sessions.find((x) => x.id === id)
+			expect(s?.workspace_id).toBe('root_ws')
+			expect(s?.pending_workspace_id).toBeUndefined()
+			expect(get(workspaceStore)).toBe('root_ws')
+		} finally {
+			const i = sessionState.sessions.findIndex((x) => x.id === id)
+			if (i >= 0) sessionState.sessions.splice(i, 1)
+			workspaceStore.set(prev)
+		}
+	})
+
+	it('is a no-op on workspaceStore when it already matches the committed workspace', async () => {
+		const id = 'test-commit-ws-match'
+		const prev = get(workspaceStore)
+		workspaceStore.set('root_ws')
+		sessionState.sessions.push({
+			id,
+			name: 'ws-match',
+			createdAt: 0,
+			pending_workspace_id: 'root_ws'
+		} as Session)
+		try {
+			const committed = await commitSessionWorkspace(id, undefined)
+			expect(committed).toBe('root_ws')
+			expect(get(workspaceStore)).toBe('root_ws')
+		} finally {
+			const i = sessionState.sessions.findIndex((x) => x.id === id)
+			if (i >= 0) sessionState.sessions.splice(i, 1)
+			workspaceStore.set(prev)
+		}
+	})
+})
diff --git a/frontend/src/lib/components/sessions/sessionUnread.svelte.ts b/frontend/src/lib/components/sessions/sessionUnread.svelte.ts
new file mode 100644
index 0000000000..aec1f9e47a
--- /dev/null
+++ b/frontend/src/lib/components/sessions/sessionUnread.svelte.ts
@@ -0,0 +1,60 @@
+import type { SessionRuntime } from './sessionRuntime.svelte'
+
+// Per-user, per-session "last seen" marker — count of displayMessages the
+// last time the user was actually on that session's page. Compared against
+// the runtime's current message count to derive an unread badge.
+//
+// Stored as a single localStorage entry holding Record<sessionId, count>.
+// Module-level $state for cross-session reactivity; can't use
+// `useLocalStorageValue` here because its internal $effect requires a
+// component-initialization context (we run at import time).
+const LS_KEY = 'windmill_sessions_last_seen_counts'
+
+function readInitial(): Record<string, number> {
+	if (typeof window === 'undefined') return {}
+	try {
+		const raw = localStorage.getItem(LS_KEY)
+		return raw ? JSON.parse(raw) : {}
+	} catch {
+		return {}
+	}
+}
+
+const lastSeen = $state<{ val: Record<string, number> }>({ val: readInitial() })
+
+function persist(): void {
+	if (typeof window === 'undefined') return
+	try {
+		localStorage.setItem(LS_KEY, JSON.stringify(lastSeen.val))
+	} catch (e) {
+		console.error('sessionUnread: localStorage write failed', e)
+	}
+}
+
+// Mark the session as seen up to `count` messages. No-op when already at
+// or past that count (idempotent — call freely from $effects).
+export function markSessionSeen(sessionId: string, count: number) {
+	const current = lastSeen.val[sessionId] ?? 0
+	if (current >= count) return
+	lastSeen.val = { ...lastSeen.val, [sessionId]: count }
+	persist()
+}
+
+// Drop the session entry entirely (used on delete so we don't leak
+// stale ids into localStorage indefinitely).
+export function forgetSessionSeen(sessionId: string) {
+	if (!(sessionId in lastSeen.val)) return
+	const next = { ...lastSeen.val }
+	delete next[sessionId]
+	lastSeen.val = next
+	persist()
+}
+
+// Number of unread messages for a session. Undefined / unloaded runtime
+// returns 0 — until messages are hydrated we don't know what's new.
+export function unreadCountFor(sessionId: string, runtime: SessionRuntime | undefined): number {
+	if (!runtime) return 0
+	const seen = lastSeen.val[sessionId] ?? 0
+	const total = runtime.manager.displayMessages.length
+	return Math.max(0, total - seen)
+}
diff --git a/frontend/src/lib/components/sidebar/MenuButton.svelte b/frontend/src/lib/components/sidebar/MenuButton.svelte
index 05451cb4a2..3499f530a5 100644
--- a/frontend/src/lib/components/sidebar/MenuButton.svelte
+++ b/frontend/src/lib/components/sidebar/MenuButton.svelte
@@ -122,7 +122,12 @@
 				{:else}
 					<SvelteComponent
 						size={16}
-						class={twMerge('flex-shrink-0', sidebarClasses.iconText, 'transition-colors', iconClasses)}
+						class={twMerge(
+							'flex-shrink-0',
+							sidebarClasses.iconText,
+							'transition-colors',
+							iconClasses
+						)}
 						{...iconProps}
 					/>
 				{/if}
@@ -140,9 +145,7 @@
 						title={label}
 					>
 						{label}
-						<span
-							class="pl-2 text-xs text-secondary font-semibold"
-						>
+						<span class="pl-2 text-xs text-secondary font-semibold">
 							{shortcut}
 						</span>
 					</div>
@@ -162,7 +165,7 @@
 			</div>
 
 			{#if isCollapsed && notificationsCount > 0}
-				<div class="absolute translate-x-1/2 translate-y-1/2 -top-2 right-1 flex h-fit w-fit">
+				<div class="absolute top-1 right-1 flex h-fit w-fit">
 					<SideBarNotification notificationCount={notificationsCount} small={true} />
 				</div>
 			{:else if notificationsCount > 0}
diff --git a/frontend/src/lib/components/sidebar/SideBarNotification.svelte b/frontend/src/lib/components/sidebar/SideBarNotification.svelte
index 33ccb39dcb..327a15d69a 100644
--- a/frontend/src/lib/components/sidebar/SideBarNotification.svelte
+++ b/frontend/src/lib/components/sidebar/SideBarNotification.svelte
@@ -2,15 +2,15 @@
 	import Notification from '$lib/components/common/alert/Notification.svelte'
 
 	interface Props {
-		notificationCount?: number;
-		small?: boolean;
+		notificationCount?: number
+		small?: boolean
 	}
 
-	let { notificationCount = 0, small = false }: Props = $props();
+	let { notificationCount = 0, small = false }: Props = $props()
 </script>
 
 {#if !small}
 	<Notification {notificationCount} notificationLimit={9} />
 {:else}
-	<div class="bg-red-500 rounded-md w-3 h-3 flex items-center justify-center"></div>
+	<div class="bg-red-500 rounded-full w-2 h-2 flex items-center justify-center"></div>
 {/if}
diff --git a/frontend/src/lib/components/sidebar/SidebarContent.svelte b/frontend/src/lib/components/sidebar/SidebarContent.svelte
index f95d242657..dc90a32f7e 100644
--- a/frontend/src/lib/components/sidebar/SidebarContent.svelte
+++ b/frontend/src/lib/components/sidebar/SidebarContent.svelte
@@ -4,6 +4,7 @@
 		superadmin,
 		usedTriggerKinds,
 		userStore,
+		usersWorkspaceStore,
 		userWorkspaces,
 		workspaceStore,
 		isCriticalAlertsUIOpen,
@@ -41,13 +42,17 @@
 		Database,
 		Pyramid,
 		Trash2,
-		MailIcon
+		MailIcon,
+		ChevronDown,
+		ChevronRight
 	} from 'lucide-svelte'
+	import { useLocalStorageValue } from '$lib/svelte5Utils.svelte'
+	import { slide } from 'svelte/transition'
 	import UserMenu from './UserMenu.svelte'
 	import DiscordIcon from '../icons/brands/Discord.svelte'
 	import { WorkspaceService } from '$lib/gen'
 	import { sendUserToast } from '$lib/toast'
-	import { clearStores } from '$lib/storeUtils'
+	import { clearStores, switchWorkspace } from '$lib/storeUtils'
 	import Toggle from '$lib/components/Toggle.svelte'
 	import { goto } from '$lib/navigation'
 	import ConfirmationModal from '../common/confirmationModal/ConfirmationModal.svelte'
@@ -113,6 +118,11 @@
 
 	async function deleteFork() {
 		const workspace = $workspaceStore ?? ''
+		// Capture the parent before delete so we can land the user there
+		// instead of dropping them back on the workspace-picker menu.
+		// Only valid if the parent is still in the user's workspace list.
+		const parentId = $userWorkspaces.find((w) => w.id === workspace)?.parent_workspace_id
+		const parentStillAccessible = !!(parentId && $userWorkspaces.find((w) => w.id === parentId))
 		const dbsToDrop = forkedDatatables.filter((dt) => dt.dropOnDelete).map((dt) => dt.name)
 
 		if (dbsToDrop.length > 0) {
@@ -138,8 +148,27 @@
 
 		await WorkspaceService.deleteWorkspace({ workspace })
 		sendUserToast('You deleted the workspace')
-		clearStores()
-		goto('/user/workspaces')
+		if (parentStillAccessible && parentId) {
+			// Refresh the workspace list before landing on the parent.
+			// `clearStores()` would null `usersWorkspaceStore`, which the
+			// sidebar's `visibleSessions` filter reads via `$userWorkspaces`
+			// — with an empty list, every committed session falls into the
+			// "workspace_id set but not in user's list" branch and renders
+			// as "Fork — no longer available" until a hard reload.
+			try {
+				usersWorkspaceStore.set(await WorkspaceService.listUserWorkspaces())
+			} catch (e) {
+				// A transient list-refresh failure must not strand the user on the
+				// just-deleted workspace — still switch + navigate (the list reloads
+				// on the next page load).
+				console.error('Failed to refresh workspaces after delete', e)
+			}
+			switchWorkspace(parentId)
+			await goto('/')
+		} else {
+			clearStores()
+			await goto('/user/workspaces')
+		}
 	}
 
 	let deleteForkedChildren = $state(false)
@@ -173,6 +202,12 @@
 
 	loadAvailableNativeTriggers()
 
+	const triggersCollapsed = useLocalStorageValue(
+		'windmill_triggers_section_collapsed',
+		false,
+		'boolean'
+	)
+
 	onMount(async () => {
 		if (lastOpened) {
 			// @ts-ignore
@@ -612,188 +647,214 @@
 		'grow flex flex-col overflow-x-hidden scrollbar-hidden px-2 md:pb-2 justify-between gap-2'
 	)}
 >
-	<div class={twMerge('pt-4 mb-6 md:mb-10')}>
+	<div class={twMerge('pt-4 flex flex-col grow')}>
 		<div class="space-y-1">
 			{#each mainMenuLinks as menuLink (menuLink.href ?? menuLink.label)}
 				<MenuLink class="!text-xs" {...menuLink} {isCollapsed} />
 			{/each}
 		</div>
 		<div class="pt-4">
-			<div
-				class="text-secondary text-[0.5rem] uppercase transition-opacity"
-				class:opacity-0={isCollapsed}>Triggers</div
-			>
-			<Menubar class="flex flex-col gap-1">
-				{#snippet children({ createMenu })}
-					{#each triggerMenuLinks as menuLink (menuLink.href ?? menuLink.label)}
-						<MenuLink class="!text-xs" {...menuLink} {isCollapsed} />
-					{/each}
-					{#if extraTriggerLinks.length > 0 && !$userStore?.operator}
-						<Menu {createMenu} usePointerDownOutside>
-							{#snippet triggr({ trigger })}
-								<MeltButton
-									aiId="sidebar-menu-link-add-trigger"
-									aiDescription="Button to add a new trigger. Can be HTTP, WebSocket, Postgres, Kafka, NATS, SQS, GCP Pub/Sub, or MQTT"
-									class={twMerge(
-										'w-full text-secondary text-2xs flex flex-row gap-1 py-1 items-center px-2 hover:bg-surface-hover rounded',
-										'data-[highlighted]:bg-surface-hover'
-									)}
-									meltElement={trigger}
-								>
-									<Plus size={14} />
-								</MeltButton>
-							{/snippet}
-							{#snippet children({ item })}
-								{#each extraTriggerLinks as subItem (subItem.href ?? subItem.label)}
-									<MenuItem
-										aiId={subItem.aiId}
-										aiDescription={subItem.aiDescription}
-										href={subItem.disabled ? '' : subItem.href}
-										class={twMerge(
-											itemClass,
-											subItem.disabled ? 'pointer-events-none opacity-50' : ''
-										)}
-										{item}
-										disabled={subItem.disabled}
-									>
-										<div class="flex flex-row items-center gap-2">
-											{#if subItem.icon}
-												<subItem.icon size={16} />
-											{/if}
-											{subItem.label}
-										</div>
-									</MenuItem>
-								{/each}
-							{/snippet}
-						</Menu>
+			{#if isCollapsed}
+				<div class="text-secondary text-[0.5rem] uppercase transition-opacity opacity-0">
+					Triggers
+				</div>
+			{:else}
+				<button
+					type="button"
+					onclick={() => (triggersCollapsed.val = !triggersCollapsed.val)}
+					class="text-secondary text-[0.5rem] uppercase flex flex-row items-center gap-1 rounded px-1 -mx-1 py-0.5 hover:bg-surface-hover focus:outline-none"
+					aria-expanded={!triggersCollapsed.val}
+				>
+					Triggers
+					{#if triggersCollapsed.val}
+						<ChevronRight size={10} />
+					{:else}
+						<ChevronDown size={10} />
 					{/if}
+				</button>
+			{/if}
+			{#if isCollapsed || !triggersCollapsed.val}
+				<div transition:slide={{ duration: 180 }}>
+					<Menubar class="flex flex-col gap-1">
+						{#snippet children({ createMenu })}
+							{#each triggerMenuLinks as menuLink (menuLink.href ?? menuLink.label)}
+								<MenuLink class="!text-xs" {...menuLink} {isCollapsed} />
+							{/each}
+							{#if extraTriggerLinks.length > 0 && !$userStore?.operator}
+								<Menu {createMenu} usePointerDownOutside>
+									{#snippet triggr({ trigger })}
+										<MeltButton
+											aiId="sidebar-menu-link-add-trigger"
+											aiDescription="Button to add a new trigger. Can be HTTP, WebSocket, Postgres, Kafka, NATS, SQS, GCP Pub/Sub, or MQTT"
+											class={twMerge(
+												'w-full text-secondary text-2xs flex flex-row gap-1 py-1 items-center px-2 hover:bg-surface-hover rounded',
+												'data-[highlighted]:bg-surface-hover'
+											)}
+											meltElement={trigger}
+										>
+											<Plus size={14} />
+										</MeltButton>
+									{/snippet}
+									{#snippet children({ item })}
+										{#each extraTriggerLinks as subItem (subItem.href ?? subItem.label)}
+											<MenuItem
+												aiId={subItem.aiId}
+												aiDescription={subItem.aiDescription}
+												href={subItem.disabled ? '' : subItem.href}
+												class={twMerge(
+													itemClass,
+													subItem.disabled ? 'pointer-events-none opacity-50' : ''
+												)}
+												{item}
+												disabled={subItem.disabled}
+											>
+												<div class="flex flex-row items-center gap-2">
+													{#if subItem.icon}
+														<subItem.icon size={16} />
+													{/if}
+													{subItem.label}
+												</div>
+											</MenuItem>
+										{/each}
+									{/snippet}
+								</Menu>
+							{/if}
+						{/snippet}
+					</Menubar>
+				</div>
+			{/if}
+		</div>
+		<div class="flex flex-col gap-2 mt-auto pt-4">
+			<!-- Single Menubar so melt-ui's hover-to-switch spans the whole bottom
+			     group (Settings/Workers/Folders/Logs AND Help). With Help in its own
+			     Menubar the menus stack instead of switching (WIN-1993). Each group
+			     keeps its own flex container for spacing. -->
+			<Menubar class="flex flex-col gap-2">
+				{#snippet children({ createMenu })}
+					<div class="flex flex-col gap-1">
+						<UserMenu {isCollapsed} {createMenu} />
+
+						{#each secondaryMenuLinks as menuLink (menuLink.href ?? menuLink.label)}
+							{#if menuLink.subItems}
+								{@const notificationsCount = computeAllNotificationsCount(menuLink.subItems)}
+								<Menu {createMenu} usePointerDownOutside>
+									{#snippet triggr({ trigger })}
+										<MenuButton
+											class="!text-2xs"
+											{...menuLink}
+											{isCollapsed}
+											{notificationsCount}
+											{trigger}
+										/>
+									{/snippet}
+
+									{#snippet children({ item })}
+										{#each menuLink.subItems as subItem (subItem.href ?? subItem.label)}
+											<MenuItem
+												class={itemClass}
+												href={subItem.href}
+												{item}
+												onClick={() => {
+													subItem?.['action']?.()
+												}}
+												aiId={subItem.aiId}
+												aiDescription={subItem.aiDescription}
+											>
+												<div class="flex flex-row items-center gap-2">
+													{#if subItem.icon}
+														<subItem.icon size={16} />
+													{/if}
+													{subItem.label}
+													{#if subItem?.['notificationCount']}
+														<div class="ml-auto">
+															<SideBarNotification
+																notificationCount={subItem['notificationCount']}
+															/>
+														</div>
+													{/if}
+												</div>
+											</MenuItem>
+										{/each}
+									{/snippet}
+								</Menu>
+							{:else}
+								<MenuSingleItem>
+									{#snippet children({})}
+										<MenuLink class="!text-2xs" {...menuLink} {isCollapsed} />
+									{/snippet}
+								</MenuSingleItem>
+							{/if}
+						{/each}
+					</div>
+
+					<div class="flex flex-col gap-1">
+						{#each thirdMenuLinks as menuLink (menuLink)}
+							{#if menuLink.subItems}
+								<Menu {createMenu} usePointerDownOutside>
+									{#snippet triggr({ trigger })}
+										<button
+											class="relative w-full"
+											onclick={() => {
+												if (menuLink.label === 'Help') {
+													openChangelogs()
+												}
+											}}
+										>
+											<MenuButton class="!text-2xs" {...menuLink} {isCollapsed} {trigger} />
+											{#if menuLink.label === 'Help' && hasNewChangelogs}
+												<span
+													class={twMerge(
+														'flex h-2 w-2 absolute',
+														isCollapsed ? 'top-1 right-1' : 'right-2 top-1/2 -translate-y-1/2'
+													)}
+												>
+													<span
+														class="animate-ping absolute inline-flex h-full w-full rounded-full bg-frost-400 opacity-75"
+													></span>
+													<span class="relative inline-flex rounded-full h-2 w-2 bg-frost-500"
+													></span>
+												</span>
+											{/if}
+										</button>
+									{/snippet}
+									{#snippet children({ item })}
+										{#each menuLink.subItems as subItem (subItem.href ?? subItem.label)}
+											<MenuItem
+												href={subItem.href}
+												class={itemClass}
+												target={subItem.external !== false ? '_blank' : undefined}
+												{item}
+											>
+												<div class="flex flex-row items-center gap-2">
+													{#if subItem.icon}
+														<subItem.icon size={16} />
+													{/if}
+
+													{subItem.label}
+												</div>
+											</MenuItem>
+										{/each}
+										{#if recentChangelogs.length > 0}
+											<div class="w-full h-1 border-t"></div>
+											<span class="text-xs px-4 font-bold"> Latest changelogs </span>
+											{#each recentChangelogs as changelog}
+												<MenuItem href={changelog.href} class={itemClass} target="_blank" {item}>
+													<div class="flex flex-row items-center gap-2">
+														{changelog.label}
+													</div>
+												</MenuItem>
+											{/each}
+										{/if}
+									{/snippet}
+								</Menu>
+							{/if}
+						{/each}
+					</div>
 				{/snippet}
 			</Menubar>
 		</div>
-	</div>
-	<div class="flex flex-col h-full justify-end">
-		<Menubar class="flex flex-col gap-1 mb-6 md:mb-10">
-			{#snippet children({ createMenu })}
-				<UserMenu {isCollapsed} {createMenu} />
-
-				{#each secondaryMenuLinks as menuLink (menuLink.href ?? menuLink.label)}
-					{#if menuLink.subItems}
-						{@const notificationsCount = computeAllNotificationsCount(menuLink.subItems)}
-						<Menu {createMenu} usePointerDownOutside>
-							{#snippet triggr({ trigger })}
-								<MenuButton
-									class="!text-2xs"
-									{...menuLink}
-									{isCollapsed}
-									{notificationsCount}
-									{trigger}
-								/>
-							{/snippet}
-
-							{#snippet children({ item })}
-								{#each menuLink.subItems as subItem (subItem.href ?? subItem.label)}
-									<MenuItem
-										class={itemClass}
-										href={subItem.href}
-										{item}
-										onClick={() => {
-											subItem?.['action']?.()
-										}}
-										aiId={subItem.aiId}
-										aiDescription={subItem.aiDescription}
-									>
-										<div class="flex flex-row items-center gap-2">
-											{#if subItem.icon}
-												<subItem.icon size={16} />
-											{/if}
-											{subItem.label}
-											{#if subItem?.['notificationCount']}
-												<div class="ml-auto">
-													<SideBarNotification notificationCount={subItem['notificationCount']} />
-												</div>
-											{/if}
-										</div>
-									</MenuItem>
-								{/each}
-							{/snippet}
-						</Menu>
-					{:else}
-						<MenuSingleItem>
-							{#snippet children({})}
-								<MenuLink class="!text-2xs" {...menuLink} {isCollapsed} />
-							{/snippet}
-						</MenuSingleItem>
-					{/if}
-				{/each}
-			{/snippet}
-		</Menubar>
-
-		<Menubar class="flex flex-col gap-1">
-			{#snippet children({ createMenu })}
-				{#each thirdMenuLinks as menuLink (menuLink)}
-					{#if menuLink.subItems}
-						<Menu {createMenu} usePointerDownOutside>
-							{#snippet triggr({ trigger })}
-								<button
-									class="relative w-full"
-									onclick={() => {
-										if (menuLink.label === 'Help') {
-											openChangelogs()
-										}
-									}}
-								>
-									<MenuButton class="!text-2xs" {...menuLink} {isCollapsed} {trigger} />
-									{#if menuLink.label === 'Help' && hasNewChangelogs}
-										<span
-											class={twMerge(
-												'flex h-2 w-2 absolute',
-												isCollapsed ? 'top-1 right-1' : 'right-2 top-1/2 -translate-y-1/2'
-											)}
-										>
-											<span
-												class="animate-ping absolute inline-flex h-full w-full rounded-full bg-frost-400 opacity-75"
-											></span>
-											<span class="relative inline-flex rounded-full h-2 w-2 bg-frost-500"></span>
-										</span>
-									{/if}
-								</button>
-							{/snippet}
-							{#snippet children({ item })}
-								{#each menuLink.subItems as subItem (subItem.href ?? subItem.label)}
-									<MenuItem
-										href={subItem.href}
-										class={itemClass}
-										target={subItem.external !== false ? '_blank' : undefined}
-										{item}
-									>
-										<div class="flex flex-row items-center gap-2">
-											{#if subItem.icon}
-												<subItem.icon size={16} />
-											{/if}
-
-											{subItem.label}
-										</div>
-									</MenuItem>
-								{/each}
-								{#if recentChangelogs.length > 0}
-									<div class="w-full h-1 border-t"></div>
-									<span class="text-xs px-4 font-bold"> Latest changelogs </span>
-									{#each recentChangelogs as changelog}
-										<MenuItem href={changelog.href} class={itemClass} target="_blank" {item}>
-											<div class="flex flex-row items-center gap-2">
-												{changelog.label}
-											</div>
-										</MenuItem>
-									{/each}
-								{/if}
-							{/snippet}
-						</Menu>
-					{/if}
-				{/each}
-			{/snippet}
-		</Menubar>
-	</div>
-</nav>
+	</div></nav
+>
 
 <ConfirmationModal
 	open={leaveWorkspaceModal}
diff --git a/frontend/src/lib/components/sidebar/WorkspaceMenu.svelte b/frontend/src/lib/components/sidebar/WorkspaceMenu.svelte
index 084661366b..a834d00317 100644
--- a/frontend/src/lib/components/sidebar/WorkspaceMenu.svelte
+++ b/frontend/src/lib/components/sidebar/WorkspaceMenu.svelte
@@ -1,4 +1,5 @@
 <script lang="ts">
+	import { workspaceMenuHref } from './workspaceMenuHref'
 	import {
 		isPremiumStore,
 		superadmin,
@@ -58,22 +59,30 @@
 			'/apps/get/'
 		]
 		const isOnEditPage = editPages.some((editPage) => page.route.id?.includes(editPage) ?? false)
+		// An AI session is scoped to its (forked) workspace, so it makes no sense
+		// to keep showing it after the user switches workspace — go home instead.
+		const isOnSessionPage = page.route.id?.includes('/sessions') ?? false
 
-		if (!isOnEditPage) {
-			switchWorkspace(id)
-			if (page.url.searchParams.get('workspace')) {
-				page.url.searchParams.set('workspace', id)
-			}
-		} else {
-			switchWorkspace(id)
+		switchWorkspace(id)
+		if (isOnEditPage || isOnSessionPage) {
 			await goto('/')
+		} else if (page.url.searchParams.get('workspace')) {
+			page.url.searchParams.set('workspace', id)
 		}
 	}
 
+	// An AI session is scoped to its (forked) workspace, so switching workspace
+	// should leave for home (the link's navigation wins over onClick's
+	// preventDefault; onClick still performs the switch). Pure logic +
+	// new-tab/workspace-param handling lives in workspaceMenuHref (unit-tested).
 	function workspaceHref(id: string): string {
-		const params = new URLSearchParams(page.url.searchParams)
-		params.set('workspace', id)
-		return `${page.url.pathname}?${params.toString()}`
+		return workspaceMenuHref({
+			routeId: page.route.id,
+			base,
+			pathname: page.url.pathname,
+			searchParams: page.url.searchParams,
+			id
+		})
 	}
 
 	function onWorkspaceItemClick(e: MouseEvent, workspace: { id: string; disabled?: boolean }) {
diff --git a/frontend/src/lib/components/sidebar/workspaceMenuHref.test.ts b/frontend/src/lib/components/sidebar/workspaceMenuHref.test.ts
new file mode 100644
index 0000000000..2291d2d125
--- /dev/null
+++ b/frontend/src/lib/components/sidebar/workspaceMenuHref.test.ts
@@ -0,0 +1,52 @@
+import { describe, it, expect } from 'vitest'
+import { workspaceMenuHref } from './workspaceMenuHref'
+
+describe('workspaceMenuHref', () => {
+	it('on a session route, keeps the workspace id (so new-tab lands in the right workspace)', () => {
+		expect(
+			workspaceMenuHref({
+				routeId: '/(root)/(logged)/sessions',
+				base: '',
+				pathname: '/sessions',
+				searchParams: new URLSearchParams('session_name=foo'),
+				id: 'wm-fork-bar'
+			})
+		).toBe('/?workspace=wm-fork-bar')
+	})
+
+	it('respects the base prefix on a session route', () => {
+		expect(
+			workspaceMenuHref({
+				routeId: '/(root)/(logged)/sessions',
+				base: '/wm',
+				pathname: '/wm/sessions',
+				searchParams: new URLSearchParams(),
+				id: 'ws2'
+			})
+		).toBe('/wm/?workspace=ws2')
+	})
+
+	it('off a session route, swaps the workspace param on the current path', () => {
+		expect(
+			workspaceMenuHref({
+				routeId: '/(root)/(logged)/scripts/edit/[...path]',
+				base: '',
+				pathname: '/scripts/edit/u/me/x',
+				searchParams: new URLSearchParams('workspace=old&foo=1'),
+				id: 'new_ws'
+			})
+		).toBe('/scripts/edit/u/me/x?workspace=new_ws&foo=1')
+	})
+
+	it('adds the workspace param when none was present', () => {
+		expect(
+			workspaceMenuHref({
+				routeId: '/(root)/(logged)/runs',
+				base: '',
+				pathname: '/runs',
+				searchParams: new URLSearchParams(),
+				id: 'w'
+			})
+		).toBe('/runs?workspace=w')
+	})
+})
diff --git a/frontend/src/lib/components/sidebar/workspaceMenuHref.ts b/frontend/src/lib/components/sidebar/workspaceMenuHref.ts
new file mode 100644
index 0000000000..5e5ec11325
--- /dev/null
+++ b/frontend/src/lib/components/sidebar/workspaceMenuHref.ts
@@ -0,0 +1,21 @@
+// Href for a workspace-switch link in the sidebar WorkspaceMenu.
+//
+// On an AI-session route, switching workspace leaves for home — but we keep the
+// `?workspace=<id>` param so a modifier/middle click (open in new tab, which
+// bypasses the onClick fast-path) still lands in the *clicked* workspace's home
+// rather than the default one. Everywhere else, stay on the current path and
+// just swap the `workspace` query param.
+export function workspaceMenuHref(args: {
+	routeId: string | null | undefined
+	base: string
+	pathname: string
+	searchParams: URLSearchParams
+	id: string
+}): string {
+	if (args.routeId?.includes('/sessions')) {
+		return `${args.base}/?workspace=${args.id}`
+	}
+	const params = new URLSearchParams(args.searchParams)
+	params.set('workspace', args.id)
+	return `${args.pathname}?${params.toString()}`
+}
diff --git a/frontend/src/lib/components/triggers/azure/AzureTriggerEditorInner.svelte b/frontend/src/lib/components/triggers/azure/AzureTriggerEditorInner.svelte
index e29ab8703c..3293a171da 100644
--- a/frontend/src/lib/components/triggers/azure/AzureTriggerEditorInner.svelte
+++ b/frontend/src/lib/components/triggers/azure/AzureTriggerEditorInner.svelte
@@ -26,6 +26,7 @@
 	import { getHandlerType, handleConfigChange, type Trigger } from '../utils'
 	import { deepEqual } from 'fast-equals'
 	import { useTriggerDraftSync } from '../useTriggerDraftSync.svelte'
+	import LocalDraftBanner from '$lib/components/LocalDraftBanner.svelte'
 	import TriggerSuspendedJobsAlert from '../TriggerSuspendedJobsAlert.svelte'
 	import TriggerSuspendedJobsModal from '../TriggerSuspendedJobsModal.svelte'
 	import { base } from '$lib/base'
@@ -139,7 +140,7 @@
 				initialConfig = structuredClone($state.snapshot(getAzureConfig()))
 			}
 			originalConfig = structuredClone($state.snapshot(getAzureConfig()))
-			await draftSync.maybeRestore(ePath)
+			await draftSync.maybeRestore()
 		} catch (err) {
 			sendUserToast(`Could not load Azure trigger: ${err.body}`, true)
 		} finally {
@@ -342,6 +343,15 @@
 			{#snippet actions()}
 				{@render actionsButtons()}
 			{/snippet}
+			{#snippet banner()}
+				<LocalDraftBanner
+					show={draftSync.hasDraft}
+					getDeployed={() => draftSync.deployed}
+					getCurrent={() => draftSync.current}
+					onDiscard={() => draftSync.resetToDeployed(initialPath)}
+					disabled={!can_write}
+				/>
+			{/snippet}
 			{@render config()}
 		</DrawerContent>
 	</Drawer>
diff --git a/frontend/src/lib/components/triggers/email/EmailTriggerEditorInner.svelte b/frontend/src/lib/components/triggers/email/EmailTriggerEditorInner.svelte
index f1cae9ce90..7b1cac1264 100644
--- a/frontend/src/lib/components/triggers/email/EmailTriggerEditorInner.svelte
+++ b/frontend/src/lib/components/triggers/email/EmailTriggerEditorInner.svelte
@@ -31,6 +31,7 @@
 	import { saveEmailTriggerFromCfg } from './utils'
 	import { deepEqual } from 'fast-equals'
 	import { useTriggerDraftSync } from '../useTriggerDraftSync.svelte'
+	import LocalDraftBanner from '$lib/components/LocalDraftBanner.svelte'
 	import TriggerSuspendedJobsAlert from '../TriggerSuspendedJobsAlert.svelte'
 	import TriggerSuspendedJobsModal from '../TriggerSuspendedJobsModal.svelte'
 
@@ -139,7 +140,7 @@
 				initialConfig = structuredClone($state.snapshot(getEmailTriggerConfig()))
 			}
 			originalConfig = structuredClone($state.snapshot(getEmailTriggerConfig()))
-			await draftSync.maybeRestore(ePath)
+			await draftSync.maybeRestore()
 		} catch (err) {
 			sendUserToast(`Could not load email trigger: ${err}`, true)
 		} finally {
@@ -475,6 +476,15 @@
 			{#snippet actions()}
 				{@render saveButton()}
 			{/snippet}
+			{#snippet banner()}
+				<LocalDraftBanner
+					show={draftSync.hasDraft}
+					getDeployed={() => draftSync.deployed}
+					getCurrent={() => draftSync.current}
+					onDiscard={() => draftSync.resetToDeployed(initialPath)}
+					disabled={!can_write}
+				/>
+			{/snippet}
 			{@render config()}
 		</DrawerContent>
 	</Drawer>
diff --git a/frontend/src/lib/components/triggers/gcp/GcpTriggerEditorInner.svelte b/frontend/src/lib/components/triggers/gcp/GcpTriggerEditorInner.svelte
index a969eeaccc..6e464d3f3a 100644
--- a/frontend/src/lib/components/triggers/gcp/GcpTriggerEditorInner.svelte
+++ b/frontend/src/lib/components/triggers/gcp/GcpTriggerEditorInner.svelte
@@ -29,6 +29,7 @@
 	import { getHandlerType, handleConfigChange, type Trigger } from '../utils'
 	import { deepEqual } from 'fast-equals'
 	import { useTriggerDraftSync } from '../useTriggerDraftSync.svelte'
+	import LocalDraftBanner from '$lib/components/LocalDraftBanner.svelte'
 	import TriggerSuspendedJobsAlert from '../TriggerSuspendedJobsAlert.svelte'
 	import TriggerSuspendedJobsModal from '../TriggerSuspendedJobsModal.svelte'
 	import { base } from '$lib/base'
@@ -144,7 +145,7 @@
 				initialConfig = structuredClone($state.snapshot(getGcpConfig()))
 			}
 			originalConfig = structuredClone($state.snapshot(getGcpConfig()))
-			await draftSync.maybeRestore(ePath)
+			await draftSync.maybeRestore()
 		} catch (err) {
 			sendUserToast(`Could not load GCP Pub/Sub trigger: ${err.body}`, true)
 		} finally {
@@ -362,6 +363,15 @@
 			{#snippet actions()}
 				{@render actionsButtons()}
 			{/snippet}
+			{#snippet banner()}
+				<LocalDraftBanner
+					show={draftSync.hasDraft}
+					getDeployed={() => draftSync.deployed}
+					getCurrent={() => draftSync.current}
+					onDiscard={() => draftSync.resetToDeployed(initialPath)}
+					disabled={!can_write}
+				/>
+			{/snippet}
 			{@render config()}
 		</DrawerContent>
 	</Drawer>
diff --git a/frontend/src/lib/components/triggers/http/RouteEditorInner.svelte b/frontend/src/lib/components/triggers/http/RouteEditorInner.svelte
index fef0cdb11a..3f281be23b 100644
--- a/frontend/src/lib/components/triggers/http/RouteEditorInner.svelte
+++ b/frontend/src/lib/components/triggers/http/RouteEditorInner.svelte
@@ -56,6 +56,7 @@
 	import TriggerAdvancedBadges from '../TriggerAdvancedBadges.svelte'
 	import { deepEqual } from 'fast-equals'
 	import { useTriggerDraftSync } from '../useTriggerDraftSync.svelte'
+	import LocalDraftBanner from '$lib/components/LocalDraftBanner.svelte'
 	import TriggerSuspendedJobsAlert from '../TriggerSuspendedJobsAlert.svelte'
 	import TriggerSuspendedJobsModal from '../TriggerSuspendedJobsModal.svelte'
 	import UserSettings from '$lib/components/UserSettings.svelte'
@@ -235,7 +236,7 @@
 				initialConfig = structuredClone($state.snapshot(getRouteConfig()))
 			}
 			originalConfig = structuredClone($state.snapshot(getRouteConfig()))
-			await draftSync.maybeRestore(ePath)
+			await draftSync.maybeRestore()
 		} catch (err) {
 			sendUserToast(`Could not load route: ${err}`, true)
 		} finally {
@@ -1000,6 +1001,15 @@
 			{#snippet actions()}
 				{@render saveButton()}
 			{/snippet}
+			{#snippet banner()}
+				<LocalDraftBanner
+					show={draftSync.hasDraft}
+					getDeployed={() => draftSync.deployed}
+					getCurrent={() => draftSync.current}
+					onDiscard={() => draftSync.resetToDeployed(initialPath)}
+					disabled={!can_write}
+				/>
+			{/snippet}
 			{@render config()}
 		</DrawerContent>
 	</Drawer>
diff --git a/frontend/src/lib/components/triggers/kafka/KafkaTriggerEditorInner.svelte b/frontend/src/lib/components/triggers/kafka/KafkaTriggerEditorInner.svelte
index a159658c57..9f4d0c1c7c 100644
--- a/frontend/src/lib/components/triggers/kafka/KafkaTriggerEditorInner.svelte
+++ b/frontend/src/lib/components/triggers/kafka/KafkaTriggerEditorInner.svelte
@@ -26,6 +26,7 @@
 	import TriggerAdvancedBadges from '../TriggerAdvancedBadges.svelte'
 	import { deepEqual } from 'fast-equals'
 	import { useTriggerDraftSync } from '../useTriggerDraftSync.svelte'
+	import LocalDraftBanner from '$lib/components/LocalDraftBanner.svelte'
 	import TriggerSuspendedJobsAlert from '../TriggerSuspendedJobsAlert.svelte'
 	import TriggerSuspendedJobsModal from '../TriggerSuspendedJobsModal.svelte'
 	import TriggerFilters from '../TriggerFilters.svelte'
@@ -166,7 +167,7 @@
 				initialConfig = structuredClone($state.snapshot(getSaveCfg()))
 			}
 			originalConfig = structuredClone($state.snapshot(getSaveCfg()))
-			await draftSync.maybeRestore(ePath)
+			await draftSync.maybeRestore()
 		} catch (err) {
 			sendUserToast(`Could not load Kafka trigger: ${err}`, true)
 		} finally {
@@ -412,6 +413,15 @@
 			{#snippet actions()}
 				{@render actionsButtons('sm')}
 			{/snippet}
+			{#snippet banner()}
+				<LocalDraftBanner
+					show={draftSync.hasDraft}
+					getDeployed={() => draftSync.deployed}
+					getCurrent={() => draftSync.current}
+					onDiscard={() => draftSync.resetToDeployed(initialPath)}
+					disabled={!can_write}
+				/>
+			{/snippet}
 			{@render config()}
 		</DrawerContent>
 	</Drawer>
diff --git a/frontend/src/lib/components/triggers/mqtt/MqttTriggerEditorInner.svelte b/frontend/src/lib/components/triggers/mqtt/MqttTriggerEditorInner.svelte
index 4de704cec3..3d99a2b56d 100644
--- a/frontend/src/lib/components/triggers/mqtt/MqttTriggerEditorInner.svelte
+++ b/frontend/src/lib/components/triggers/mqtt/MqttTriggerEditorInner.svelte
@@ -41,6 +41,7 @@
 	import TriggerSuspendedJobsModal from '../TriggerSuspendedJobsModal.svelte'
 	import { deepEqual } from 'fast-equals'
 	import { useTriggerDraftSync } from '../useTriggerDraftSync.svelte'
+	import LocalDraftBanner from '$lib/components/LocalDraftBanner.svelte'
 
 	interface Props {
 		useDrawer?: boolean
@@ -162,7 +163,7 @@
 				initialConfig = structuredClone($state.snapshot(getSaveCfg()))
 			}
 			originalConfig = structuredClone($state.snapshot(getSaveCfg()))
-			await draftSync.maybeRestore(ePath)
+			await draftSync.maybeRestore()
 		} catch (err) {
 			sendUserToast(`Could not load mqtt trigger: ${err.body}`, true)
 		} finally {
@@ -386,6 +387,15 @@
 			{#snippet actions()}
 				{@render actionsSnippet()}
 			{/snippet}
+			{#snippet banner()}
+				<LocalDraftBanner
+					show={draftSync.hasDraft}
+					getDeployed={() => draftSync.deployed}
+					getCurrent={() => draftSync.current}
+					onDiscard={() => draftSync.resetToDeployed(initialPath)}
+					disabled={!can_write}
+				/>
+			{/snippet}
 			{@render config()}
 		</DrawerContent>
 	</Drawer>
diff --git a/frontend/src/lib/components/triggers/nats/NatsTriggerEditorInner.svelte b/frontend/src/lib/components/triggers/nats/NatsTriggerEditorInner.svelte
index 849d25f518..404bf21477 100644
--- a/frontend/src/lib/components/triggers/nats/NatsTriggerEditorInner.svelte
+++ b/frontend/src/lib/components/triggers/nats/NatsTriggerEditorInner.svelte
@@ -25,6 +25,7 @@
 	import TriggerAdvancedBadges from '../TriggerAdvancedBadges.svelte'
 	import { deepEqual } from 'fast-equals'
 	import { useTriggerDraftSync } from '../useTriggerDraftSync.svelte'
+	import LocalDraftBanner from '$lib/components/LocalDraftBanner.svelte'
 	import TriggerSuspendedJobsAlert from '../TriggerSuspendedJobsAlert.svelte'
 	import TriggerSuspendedJobsModal from '../TriggerSuspendedJobsModal.svelte'
 
@@ -150,7 +151,7 @@
 				initialConfig = structuredClone($state.snapshot(getSaveCfg()))
 			}
 			originalConfig = structuredClone($state.snapshot(getSaveCfg()))
-			await draftSync.maybeRestore(ePath)
+			await draftSync.maybeRestore()
 		} catch (err) {
 			sendUserToast(`Could not load nats trigger: ${err}`, true)
 		} finally {
@@ -370,6 +371,15 @@
 			{#snippet actions()}
 				{@render actionsSnippet()}
 			{/snippet}
+			{#snippet banner()}
+				<LocalDraftBanner
+					show={draftSync.hasDraft}
+					getDeployed={() => draftSync.deployed}
+					getCurrent={() => draftSync.current}
+					onDiscard={() => draftSync.resetToDeployed(initialPath)}
+					disabled={!can_write}
+				/>
+			{/snippet}
 			{@render config()}
 		</DrawerContent>
 	</Drawer>
diff --git a/frontend/src/lib/components/triggers/postgres/PostgresTriggerEditorInner.svelte b/frontend/src/lib/components/triggers/postgres/PostgresTriggerEditorInner.svelte
index a811935a20..20659cf9c2 100644
--- a/frontend/src/lib/components/triggers/postgres/PostgresTriggerEditorInner.svelte
+++ b/frontend/src/lib/components/triggers/postgres/PostgresTriggerEditorInner.svelte
@@ -47,6 +47,7 @@
 	import TriggerSuspendedJobsModal from '../TriggerSuspendedJobsModal.svelte'
 	import { deepEqual } from 'fast-equals'
 	import { useTriggerDraftSync } from '../useTriggerDraftSync.svelte'
+	import LocalDraftBanner from '$lib/components/LocalDraftBanner.svelte'
 	import { capitalize } from '$lib/utils'
 
 	interface Props {
@@ -257,7 +258,7 @@
 				initialConfig = structuredClone($state.snapshot(getSaveCfg()))
 			}
 			originalConfig = structuredClone($state.snapshot(getSaveCfg()))
-			await draftSync.maybeRestore(ePath)
+			await draftSync.maybeRestore()
 		} catch (err) {
 			sendUserToast(`Could not load postgres trigger: ${err.body}`, true)
 		} finally {
@@ -544,6 +545,15 @@
 			on:close={drawer.closeDrawer}
 		>
 			{#snippet actions()}{@render actionsSnippet()}{/snippet}
+			{#snippet banner()}
+				<LocalDraftBanner
+					show={draftSync.hasDraft}
+					getDeployed={() => draftSync.deployed}
+					getCurrent={() => draftSync.current}
+					onDiscard={() => draftSync.resetToDeployed(initialPath)}
+					disabled={!can_write}
+				/>
+			{/snippet}
 			{@render content()}
 		</DrawerContent>
 	</Drawer>
diff --git a/frontend/src/lib/components/triggers/schedules/ScheduleEditorInner.svelte b/frontend/src/lib/components/triggers/schedules/ScheduleEditorInner.svelte
index 657f2147c8..0c4c23551d 100644
--- a/frontend/src/lib/components/triggers/schedules/ScheduleEditorInner.svelte
+++ b/frontend/src/lib/components/triggers/schedules/ScheduleEditorInner.svelte
@@ -40,6 +40,7 @@
 	import { handleConfigChange } from '../utils'
 	import { withForkConflictRetry } from '$lib/utils/forkConflict'
 	import { useTriggerDraftSync } from '../useTriggerDraftSync.svelte'
+	import LocalDraftBanner from '$lib/components/LocalDraftBanner.svelte'
 	import TextInput from '$lib/components/text_input/TextInput.svelte'
 	import { twMerge } from 'tailwind-merge'
 	import PermissionedAsLine from '../PermissionedAsLine.svelte'
@@ -167,7 +168,7 @@
 			if (!defaultCfg) {
 				initialConfig = structuredClone($state.snapshot(getScheduleCfg()))
 			}
-			await draftSync.maybeRestore(ePath)
+			await draftSync.maybeRestore()
 		} finally {
 			clearTimeout(loadingTimeout)
 			drawerLoading = false
@@ -308,6 +309,11 @@
 			drawer?.openDrawer()
 			runnable = undefined
 			edit = false
+			// No deployed baseline for a brand-new schedule. The editor instance
+			// is reused across open() calls, so clear any baseline left by a prior
+			// openEdit — otherwise the "unsaved changes" banner / dirty check would
+			// compare against a stale config.
+			initialConfig = undefined
 			itemKind = (s?.is_flow ?? nis_flow) ? 'flow' : 'script'
 			initialScriptPath = initial_script_path ?? ''
 			fixedScriptPath = fixedScriptPath_ ?? ''
@@ -709,7 +715,7 @@
 							variant="default"
 							startIcon={{ icon: List }}
 							disabled={!allowSchedule || pathError != '' || emptyString(script_path)}
-							href={`${base}/runs/${script_path}?show_schedules=true&show_future_jobs=true`}
+							href={`${base}/runs/?schedule_path=${path}&job_trigger_kind=schedule&show_future_jobs=true`}
 						>
 							View runs
 						</Button>
@@ -1356,6 +1362,15 @@
 					{@render saveButton()}
 				</div>
 			{/snippet}
+			{#snippet banner()}
+				<LocalDraftBanner
+					show={draftSync.hasDraft}
+					getDeployed={() => draftSync.deployed}
+					getCurrent={() => draftSync.current}
+					onDiscard={() => draftSync.resetToDeployed(initialPath)}
+					disabled={!can_write}
+				/>
+			{/snippet}
 			{@render content()}
 		</DrawerContent>
 	</Drawer>
diff --git a/frontend/src/lib/components/triggers/sqs/SqsTriggerEditorInner.svelte b/frontend/src/lib/components/triggers/sqs/SqsTriggerEditorInner.svelte
index 76f61f0429..90eb5d44c7 100644
--- a/frontend/src/lib/components/triggers/sqs/SqsTriggerEditorInner.svelte
+++ b/frontend/src/lib/components/triggers/sqs/SqsTriggerEditorInner.svelte
@@ -33,6 +33,7 @@
 	import TriggerSuspendedJobsModal from '../TriggerSuspendedJobsModal.svelte'
 	import { deepEqual } from 'fast-equals'
 	import { useTriggerDraftSync } from '../useTriggerDraftSync.svelte'
+	import LocalDraftBanner from '$lib/components/LocalDraftBanner.svelte'
 
 	interface Props {
 		useDrawer?: boolean
@@ -148,7 +149,7 @@
 				initialConfig = structuredClone($state.snapshot(getSaveCfg()))
 			}
 			originalConfig = structuredClone($state.snapshot(getSaveCfg()))
-			await draftSync.maybeRestore(ePath)
+			await draftSync.maybeRestore()
 		} catch (err) {
 			sendUserToast(`Could not load sqs trigger: ${err.body}`, true)
 		} finally {
@@ -364,6 +365,15 @@
 			{#snippet actions()}
 				{@render actionsSnippet()}
 			{/snippet}
+			{#snippet banner()}
+				<LocalDraftBanner
+					show={draftSync.hasDraft}
+					getDeployed={() => draftSync.deployed}
+					getCurrent={() => draftSync.current}
+					onDiscard={() => draftSync.resetToDeployed(initialPath)}
+					disabled={!can_write}
+				/>
+			{/snippet}
 			{@render config()}
 		</DrawerContent>
 	</Drawer>
diff --git a/frontend/src/lib/components/triggers/useTriggerDraftSync.svelte.ts b/frontend/src/lib/components/triggers/useTriggerDraftSync.svelte.ts
index d8e868559f..88c1d62232 100644
--- a/frontend/src/lib/components/triggers/useTriggerDraftSync.svelte.ts
+++ b/frontend/src/lib/components/triggers/useTriggerDraftSync.svelte.ts
@@ -1,6 +1,5 @@
 import { untrack } from 'svelte'
 import { UserDraft, localDraftDiffers, type UserDraftItemKind } from '$lib/userDraft.svelte'
-import { notifyRestoredFromLocal } from '$lib/userDraftToast'
 
 type Cfg = Record<string, any>
 
@@ -28,11 +27,27 @@ export interface TriggerDraftSync {
 	/** The local autosave for the active (workspace, path), if any. */
 	readonly draft: Cfg | undefined
 	/**
-	 * Restore-on-open: if a local autosave diverges from the just-loaded
-	 * backend config, overlay it and toast a "Reset to deployed" action.
-	 * Call right after the backend load, before clearing `drawerLoading`.
+	 * Whether the form currently diverges from the deployed baseline — i.e. a
+	 * live local draft exists. Drives the "unsaved changes" banner. False while
+	 * loading and for brand-new triggers (no deployed baseline yet).
 	 */
-	maybeRestore(path: string): Promise<void>
+	readonly hasDraft: boolean
+	/** The deployed baseline the dirty check compares against. */
+	readonly deployed: Cfg | undefined
+	/** The current form config (the live local draft). */
+	readonly current: Cfg | undefined
+	/**
+	 * Restore-on-open: if a local autosave diverges from the just-loaded
+	 * backend config, overlay it onto the form. Call right after the backend
+	 * load, before clearing `drawerLoading`, so the drawer opens on the draft
+	 * without a deployed→draft flash. The banner (via `hasDraft`) surfaces it.
+	 */
+	maybeRestore(): Promise<void>
+	/**
+	 * Drop the local draft for `path` and reset the form to the deployed
+	 * baseline. Backs the banner's "Discard" action.
+	 */
+	resetToDeployed(path: string): Promise<void>
 	/**
 	 * Clear the draft for `path` and reset the handle's in-memory cell to
 	 * `fallback`. Use after a successful deploy, passing the just-saved cfg —
@@ -63,6 +78,16 @@ export function useTriggerDraftSync(opts: TriggerDraftSyncOptions): TriggerDraft
 	})
 	const handle = $derived(handles[0])
 
+	// Live "is there a local draft?" — the form diverges from the deployed
+	// baseline. Gated on `!drawerLoading` (the baseline isn't settled yet
+	// mid-load) and on a non-null baseline (a brand-new trigger has none, so
+	// "unsaved changes" / discard-to-deployed is meaningless there).
+	const hasDraft = $derived(
+		!opts.drawerLoading() &&
+			opts.deployed() != null &&
+			localDraftDiffers(opts.getCfg() as Cfg, opts.deployed() as Cfg)
+	)
+
 	function discard(path: string, fallback: Cfg | undefined): void {
 		UserDraft.discard(opts.itemKind, path, fallback, {
 			workspace: opts.workspace() ?? undefined
@@ -102,19 +127,25 @@ export function useTriggerDraftSync(opts: TriggerDraftSyncOptions): TriggerDraft
 		get draft() {
 			return handle?.draft
 		},
-		async maybeRestore(path: string) {
+		get hasDraft() {
+			return hasDraft
+		},
+		get deployed() {
+			return opts.deployed()
+		},
+		get current() {
+			return opts.getCfg()
+		},
+		async maybeRestore() {
 			const d = handle?.draft
 			if (!localDraftDiffers(d, opts.getCfg() as Cfg)) return
-			// Snapshot the just-loaded backend config so "Reset to deployed"
-			// can re-apply it, then overlay the local autosave.
-			const deployedCfg = structuredClone($state.snapshot(opts.getCfg())) as Cfg
+			// Overlay the local autosave on the just-loaded backend config.
 			await opts.applyCfg(d)
-			notifyRestoredFromLocal(false, true, {
-				onResetToDeployed: async () => {
-					discard(path, deployedCfg)
-					await opts.applyCfg(deployedCfg)
-				}
-			})
+		},
+		async resetToDeployed(path: string) {
+			const deployedCfg = structuredClone($state.snapshot(opts.deployed())) as Cfg
+			discard(path, deployedCfg)
+			await opts.applyCfg(deployedCfg)
 		},
 		discard
 	}
diff --git a/frontend/src/lib/components/triggers/websocket/WebsocketTriggerEditorInner.svelte b/frontend/src/lib/components/triggers/websocket/WebsocketTriggerEditorInner.svelte
index 181e6ff2b3..0567071bae 100644
--- a/frontend/src/lib/components/triggers/websocket/WebsocketTriggerEditorInner.svelte
+++ b/frontend/src/lib/components/triggers/websocket/WebsocketTriggerEditorInner.svelte
@@ -43,6 +43,7 @@
 	import TriggerAdvancedBadges from '../TriggerAdvancedBadges.svelte'
 	import { deepEqual } from 'fast-equals'
 	import { useTriggerDraftSync } from '../useTriggerDraftSync.svelte'
+	import LocalDraftBanner from '$lib/components/LocalDraftBanner.svelte'
 	import TriggerSuspendedJobsAlert from '../TriggerSuspendedJobsAlert.svelte'
 	import TriggerSuspendedJobsModal from '../TriggerSuspendedJobsModal.svelte'
 	import { capitalize } from '$lib/utils'
@@ -191,7 +192,7 @@
 				initialConfig = structuredClone($state.snapshot(getSaveCfg()))
 			}
 			originalConfig = structuredClone($state.snapshot(getSaveCfg()))
-			await draftSync.maybeRestore(ePath)
+			await draftSync.maybeRestore()
 		} catch (err) {
 			sendUserToast(`Could not load websocket trigger: ${err}`, true)
 		} finally {
@@ -451,6 +452,15 @@
 			{#snippet actions()}
 				{@render actionsButtons()}
 			{/snippet}
+			{#snippet banner()}
+				<LocalDraftBanner
+					show={draftSync.hasDraft}
+					getDeployed={() => draftSync.deployed}
+					getCurrent={() => draftSync.current}
+					onDiscard={() => draftSync.resetToDeployed(initialPath)}
+					disabled={!can_write}
+				/>
+			{/snippet}
 			{@render config()}
 		</DrawerContent>
 	</Drawer>
diff --git a/frontend/src/lib/components/workspaceSettings/AISettings.svelte b/frontend/src/lib/components/workspaceSettings/AISettings.svelte
index dd3cc6e0d0..922492d6ac 100644
--- a/frontend/src/lib/components/workspaceSettings/AISettings.svelte
+++ b/frontend/src/lib/components/workspaceSettings/AISettings.svelte
@@ -353,7 +353,7 @@
 	{#if showWorkspaceOverrideEditor}
 		<SettingCard label="AI Providers">
 			<div class="flex flex-col gap-4 p-4 rounded-md border bg-surface-tertiary">
-				{#each Object.entries(AI_PROVIDERS) as [provider, details]}
+				{#each Object.entries(AI_PROVIDERS) as [provider, details] (provider)}
 					<div class="flex flex-col">
 						<div class="flex flex-row gap-2">
 							<Toggle
@@ -493,7 +493,8 @@
 					disabled={autocompleteModels.length == 0}
 					options={{
 						right: 'Enable code completion',
-						rightTooltip: 'We currently only support Mistral Codestral models for code completion.'
+						rightTooltip:
+							'We currently support Mistral Codestral and DeepSeek FIM models for code completion.'
 					}}
 				/>
 			</SettingCard>
diff --git a/frontend/src/lib/components/workspaceSettings/CustomInstanceDbSelect.svelte b/frontend/src/lib/components/workspaceSettings/CustomInstanceDbSelect.svelte
index 9fccaa8b35..222e5606c8 100644
--- a/frontend/src/lib/components/workspaceSettings/CustomInstanceDbSelect.svelte
+++ b/frontend/src/lib/components/workspaceSettings/CustomInstanceDbSelect.svelte
@@ -9,6 +9,8 @@
 	import { ArrowRight, TriangleAlert } from 'lucide-svelte'
 	import type { ConfirmationModalHandle } from '../common/confirmationModal/asyncConfirmationModal.svelte'
 	import type { Snippet } from 'svelte'
+	import Tooltip from '../meltComponents/Tooltip.svelte'
+	import { workspaceStore } from '$lib/stores'
 
 	type Props = {
 		value: string | undefined
@@ -37,6 +39,11 @@
 		)
 	)
 	let open = $state(false)
+
+	function otherWorkspaces(dbname: string): string[] {
+		const all = customInstanceDbs.current?.[dbname]?.used_by_workspaces ?? []
+		return all.filter((w) => w !== $workspaceStore)
+	}
 </script>
 
 <div class="flex relative items-center {className}">
@@ -52,11 +59,17 @@
 		disabled={!$isCustomInstanceDbEnabled}
 	>
 		{#snippet endSnippet({ item })}
-			{@render customInstanceDbWizardButton(item.value)}
+			<div class="flex items-center gap-1">
+				{@render sharedWorkspacesWarning(item.value)}
+				{@render customInstanceDbWizardButton(item.value)}
+			</div>
 		{/snippet}
 	</Select>
 	{#if value}
-		{@render customInstanceDbWizardButton(value, 'absolute right-1.5')}
+		<div class="absolute right-1.5 flex items-center gap-1">
+			{@render sharedWorkspacesWarning(value)}
+			{@render customInstanceDbWizardButton(value)}
+		</div>
 	{/if}
 </div>
 
@@ -74,12 +87,12 @@
 	}
 />
 
-{#snippet customInstanceDbWizardButton(dbname: string, clazz: string = '')}
+{#snippet customInstanceDbWizardButton(dbname: string)}
 	{@const status = customInstanceDbs.current?.[dbname]}
 	<Button
 		spacingSize="xs2"
 		variant="default"
-		wrapperClasses="bg-surface-input h-6 -my-2 {clazz}"
+		wrapperClasses="bg-surface-input h-6 -my-2"
 		onClick={() => ((openedDbNameWizard = dbname), (open = false))}
 	>
 		{#if !status}
@@ -95,3 +108,21 @@
 		{/if}
 	</Button>
 {/snippet}
+
+{#snippet sharedWorkspacesWarning(dbname: string)}
+	{@const others = otherWorkspaces(dbname)}
+	{#if others.length > 0}
+		<Tooltip placement="top">
+			<TriangleAlert
+				class="text-orange-500 dark:text-orange-400"
+				size={16}
+				aria-label="Database is shared with other workspaces"
+			/>
+			{#snippet text()}
+				This database is also used by workspace{others.length > 1 ? 's' : ''}
+				<span class="font-semibold">{others.join(', ')}</span>. Any data written here will be shared
+				with {others.length > 1 ? 'them' : 'it'}.
+			{/snippet}
+		</Tooltip>
+	{/if}
+{/snippet}
diff --git a/frontend/src/lib/editorFontSize.svelte.ts b/frontend/src/lib/editorFontSize.svelte.ts
new file mode 100644
index 0000000000..13d99915e3
--- /dev/null
+++ b/frontend/src/lib/editorFontSize.svelte.ts
@@ -0,0 +1,25 @@
+// Reactive Monaco font sizes that follow the global `:root` font-size
+// breakpoint set in `frontend/src/lib/assets/app.css` (18px at ≥1760px).
+// The values mirror Tailwind's `text-xs` (0.75rem) computed pixel size so
+// editors visually match the surrounding UI.
+
+const LARGE_VIEWPORT_QUERY = '(min-width: 1760px)'
+
+let isLargeViewport = $state(false)
+
+if (typeof window !== 'undefined') {
+	const mq = window.matchMedia(LARGE_VIEWPORT_QUERY)
+	isLargeViewport = mq.matches
+	mq.addEventListener('change', (e) => {
+		isLargeViewport = e.matches
+	})
+}
+
+export const editorFontSize = {
+	get regular(): number {
+		return isLargeViewport ? 13.5 : 12
+	},
+	get small(): number {
+		return isLargeViewport ? 12 : 11
+	}
+}
diff --git a/frontend/src/lib/hubPaths.json b/frontend/src/lib/hubPaths.json
index 902a90c9d1..2ae15d931b 100644
--- a/frontend/src/lib/hubPaths.json
+++ b/frontend/src/lib/hubPaths.json
@@ -1,16 +1,16 @@
 {
 	"gitSyncTest": "hub/28184/git-repo-test-read-write-windmill",
-	"gitInitRepo": "hub/28219/git-sync%3A-init-repository-windmill",
-	"slackErrorHandler": "hub/19741/workspace-or-schedule-error-handler-slack",
+	"gitInitRepo": "hub/28229/git-sync%3A-init-repository-windmill",
+	"slackErrorHandler": "hub/28241/workspace-or-schedule-error-handler-slack",
 	"emailErrorHandler": "hub/19795/workspace-or-error-handler-email",
-	"slackRecoveryHandler": "hub/9080/slack/schedule-recovery-handler-slack",
-	"slackSuccessHandler": "hub/28220/slack/schedule-success-handler-slack",
+	"slackRecoveryHandler": "hub/28239/slack/schedule-recovery-handler-slack",
+	"slackSuccessHandler": "hub/28240/slack/schedule-success-handler-slack",
 	"teamsErrorHandler": "hub/19742/workspace-or-schedule-error-handler-teams",
 	"teamsRecoveryHandler": "hub/11593/schedule-recovery-handler-teams",
 	"teamsSuccessHandler": "hub/11596/schedule-success-handler-teams",
 	"slackReport": "hub/9084/slack",
 	"discordReport": "hub/9085/discord",
-	"smtpReport": "hub/9086/smtp",
-	"appReport": "hub/28076/app-report",
+	"smtpReport": "hub/28242/smtp",
+	"appReport": "hub/28243/app-report",
 	"cloneRepoToS3forGitRepoViewer": "hub/28216/clone_repo_and_upload_to_instance_storage"
 }
diff --git a/frontend/src/lib/userDraft.svelte.ts b/frontend/src/lib/userDraft.svelte.ts
index 03db43dc1a..69a9bba5d8 100644
--- a/frontend/src/lib/userDraft.svelte.ts
+++ b/frontend/src/lib/userDraft.svelte.ts
@@ -582,6 +582,12 @@ export const UserDraft = {
 	 * `fallback` in-memory (so reactive readers see it immediately) and
 	 * skips re-persisting it, leaving the LS slot empty until the next real
 	 * edit. Pass the deployed baseline as `fallback`.
+	 *
+	 * `fallback` is deep-cloned before being installed — otherwise a caller
+	 * who passes their own live `$state` baseline (e.g. resource/variable
+	 * editors' `initialStates[ws]`) would end up with `handle.draft` and the
+	 * baseline pointing at the *same* proxy; subsequent edits would mutate
+	 * both sides in lock-step and the dirty check would never fire.
 	 */
 	discard<V>(
 		itemKind: UserDraftItemKind,
@@ -592,12 +598,13 @@ export const UserDraft = {
 		const ws = resolveWorkspace(opts)
 		const mk = mapKey(ws, itemKind, path)
 		const entry = entries.get(mk)
+		const safeFallback = snapshotDraftValue(fallback)
 		if (entry) {
 			// Drop any queued debounced write owned by this live entry before
 			// resetting the in-memory value. Otherwise a timer from the old
 			// entry can outlive unmount and later delete a freshly written
 			// draft for the same key.
-			entry.state.setWithoutPersist(wrap(fallback) as StoredDraft<unknown> | undefined)
+			entry.state.setWithoutPersist(wrap(safeFallback) as StoredDraft<unknown> | undefined)
 		}
 		try {
 			localStorage.removeItem(localStorageKey(ws, itemKind, path))
diff --git a/frontend/src/lib/userDraft.test.ts b/frontend/src/lib/userDraft.test.ts
index e2dd97418f..05679b823b 100644
--- a/frontend/src/lib/userDraft.test.ts
+++ b/frontend/src/lib/userDraft.test.ts
@@ -172,6 +172,93 @@ describe('UserDraft live editor draft registry', () => {
 		expect(UserDraft.getLiveEditorDraft('raw_app')).toBeUndefined()
 	})
 
+	// Pins the slot-collision contract behind the SessionWrapper
+	// `isActiveSession` gate. Without the gate, two warm-mounted session
+	// editors on the same (workspace, kind) — e.g. `/sessions` keeping 3
+	// warm sessions and two of them have script editors open in the same
+	// workspace — both call setLiveEditorDraft and the hidden one can
+	// clobber the visible one's claim. The fix in
+	// {Script,Flow,RawApp}EditorView returns early when `isActiveSession`
+	// is false, so only the visible session writes to the slot.
+	it('collides per (workspace, kind) when two callers both set — the hidden session can hijack', () => {
+		UserDraft.setLiveEditorDraft({
+			workspace: 'ws_collide',
+			itemKind: 'script',
+			storagePath: 'session_a_path',
+			effectivePath: 'u/me/a'
+		})
+		UserDraft.setLiveEditorDraft({
+			workspace: 'ws_collide',
+			itemKind: 'script',
+			storagePath: 'session_b_path',
+			effectivePath: 'u/me/b'
+		})
+		// Last write wins — exactly the bug Codex flagged: a hidden warm
+		// session B mounted after the active A overwrites A's claim.
+		expect(UserDraft.getLiveEditorDraft('script', { workspace: 'ws_collide' })).toMatchObject({
+			storagePath: 'session_b_path',
+			effectivePath: 'u/me/b'
+		})
+	})
+
+	it('with the active-session gate, only the visible session claims the slot', () => {
+		// Simulate the effect bodies in {Script,Flow,RawApp}EditorView: each
+		// returns early when isActiveSession is false. Session A is active,
+		// Session B is warm-mounted but hidden.
+		function registerIfActive(opts: {
+			isActive: boolean
+			workspace: string
+			storagePath: string
+			effectivePath: string
+		}) {
+			if (!opts.isActive) return
+			UserDraft.setLiveEditorDraft({
+				workspace: opts.workspace,
+				itemKind: 'flow',
+				storagePath: opts.storagePath,
+				effectivePath: opts.effectivePath
+			})
+		}
+		registerIfActive({
+			isActive: true,
+			workspace: 'ws_gate',
+			storagePath: 'session_a_path',
+			effectivePath: 'u/me/a'
+		})
+		registerIfActive({
+			isActive: false,
+			workspace: 'ws_gate',
+			storagePath: 'session_b_path',
+			effectivePath: 'u/me/b'
+		})
+		expect(UserDraft.getLiveEditorDraft('flow', { workspace: 'ws_gate' })).toMatchObject({
+			storagePath: 'session_a_path',
+			effectivePath: 'u/me/a'
+		})
+	})
+
+	it('cleanup on the deactivating session is a no-op once the new active session has claimed the slot', () => {
+		// Active-session swap: A becomes hidden (cleanup runs), B becomes
+		// active and registers. Even if Svelte flushes B's effect before
+		// A's cleanup, A's cleanup is keyed on its own storagePath and is
+		// guarded so it doesn't clobber B's claim. Verified here by running
+		// the cleanups in reverse order.
+		UserDraft.setLiveEditorDraft({
+			workspace: 'ws_swap',
+			itemKind: 'raw_app',
+			storagePath: 'session_b_path',
+			effectivePath: 'u/me/b'
+		})
+		// A's cleanup runs after — should be a no-op.
+		UserDraft.clearLiveEditorDraft('raw_app', {
+			workspace: 'ws_swap',
+			storagePath: 'session_a_path'
+		})
+		expect(UserDraft.getLiveEditorDraft('raw_app', { workspace: 'ws_swap' })).toMatchObject({
+			storagePath: 'session_b_path'
+		})
+	})
+
 	it('can remove persisted global draft storage without blanking the live editor', () => {
 		const draft = { path: 'u/me/live_script', content: 'export async function main() {}' }
 		localStorage.setItem('userdraft/w/test_ws/script/', wrapped(draft))
diff --git a/frontend/src/lib/utils.ts b/frontend/src/lib/utils.ts
index 8fb6475806..2e6302fb6c 100644
--- a/frontend/src/lib/utils.ts
+++ b/frontend/src/lib/utils.ts
@@ -1186,9 +1186,22 @@ export function isCodeInjection(expr: string | undefined): boolean {
 	return dynamicTemplateRegex.test(expr)
 }
 
-export function urlParamsToObject(params: URLSearchParams): Record<string, string> {
+// Query params Windmill consumes internally and that should not be exposed to
+// app logic via the `query` context. Only params we actually own are listed
+// here — the `wm_` prefix is a naming convention, not a reserved namespace, so
+// we don't strip it wholesale (that would break apps reading their own `wm_*`
+// params). `wm_coep` is a transport flag for cross-origin isolation headers.
+export const WINDMILL_RESERVED_QUERY_PARAMS = new Set(['wm_coep'])
+
+export function urlParamsToObject(
+	params: URLSearchParams,
+	opts?: { stripReserved?: boolean }
+): Record<string, string> {
 	const result: Record<string, string> = {}
 	params.forEach((value, key) => {
+		if (opts?.stripReserved && WINDMILL_RESERVED_QUERY_PARAMS.has(key)) {
+			return
+		}
 		result[key] = value
 	})
 	return result
diff --git a/frontend/src/routes/(root)/(logged)/+layout.svelte b/frontend/src/routes/(root)/(logged)/+layout.svelte
index c6fca60e37..01461b78cb 100644
--- a/frontend/src/routes/(root)/(logged)/+layout.svelte
+++ b/frontend/src/routes/(root)/(logged)/+layout.svelte
@@ -65,6 +65,7 @@
 	import { Menubar } from '$lib/components/meltComponents'
 	import { aiChatManager } from '$lib/components/copilot/chat/AIChatManager.svelte'
 	import AiChatLayout from '$lib/components/copilot/chat/AiChatLayout.svelte'
+	import SessionPicker from '$lib/components/sessions/SessionPicker.svelte'
 	import { DEFAULT_HUB_BASE_URL } from '$lib/hub'
 	import DBManagerDrawer from '$lib/components/DBManagerDrawer.svelte'
 	import { useIsDarkMode } from '$lib/components/DarkModeObserver.svelte'
@@ -330,6 +331,9 @@
 	}
 
 	let devOnly = $derived(page.url.pathname.startsWith(base + '/scripts/dev'))
+	// Sessions own their own chat pane; suppress the global Ask-AI chat on the /sessions route
+	// so it doesn't render a second chat overlay on top of the session.
+	let inSessionRoute = $derived(page.url.pathname.startsWith(base + '/sessions'))
 
 	async function loadDefaultScripts(workspace: string, user: UserExt | undefined) {
 		if (!user?.operator) {
@@ -677,6 +681,8 @@
 								/>
 							</div>
 
+							<SessionPicker {isCollapsed} />
+
 							<SidebarContent
 								{isCollapsed}
 								numUnacknowledgedCriticalAlerts={isCriticalAlertsUiMuted
@@ -838,6 +844,7 @@
 			<AiChatLayout
 				{children}
 				noPadding={devOnly}
+				disableAi={inSessionRoute}
 				{isCollapsed}
 				isMobile={innerWidth < 768}
 				onMenuOpen={() => {
diff --git a/frontend/src/routes/(root)/(logged)/apps/get/[...path]/+page.svelte b/frontend/src/routes/(root)/(logged)/apps/get/[...path]/+page.svelte
index bd900b38f0..737ebb2e33 100644
--- a/frontend/src/routes/(root)/(logged)/apps/get/[...path]/+page.svelte
+++ b/frontend/src/routes/(root)/(logged)/apps/get/[...path]/+page.svelte
@@ -56,7 +56,7 @@
 					name: $userStore?.name,
 					username: $userStore?.username,
 					groups: $userStore?.groups,
-					query: urlParamsToObject(page.url.searchParams),
+					query: urlParamsToObject(page.url.searchParams, { stripReserved: true }),
 					hash: page.url.hash.substring(1)
 				}}
 				workspace={$workspaceStore ?? ''}
diff --git a/frontend/src/routes/(root)/(logged)/flows/edit/[...path]/+page.svelte b/frontend/src/routes/(root)/(logged)/flows/edit/[...path]/+page.svelte
index 7d3d3c14b4..b979a09758 100644
--- a/frontend/src/routes/(root)/(logged)/flows/edit/[...path]/+page.svelte
+++ b/frontend/src/routes/(root)/(logged)/flows/edit/[...path]/+page.svelte
@@ -20,10 +20,15 @@
 	import LocalDraftStaleModal from '$lib/components/common/confirmationModal/LocalDraftStaleModal.svelte'
 	import type { ScheduleTrigger } from '$lib/components/triggers'
 	import type { Trigger } from '$lib/components/triggers/utils'
-	import { untrack } from 'svelte'
+	import { tick, untrack } from 'svelte'
 	import type { stepState } from '$lib/components/stepHistoryLoader.svelte'
 	import { page } from '$app/state'
-	import { UserDraft, checkStaleness, type UserDraftMeta } from '$lib/userDraft.svelte'
+	import {
+		UserDraft,
+		checkStaleness,
+		type UserDraftMeta,
+		type UserDraftHandle
+	} from '$lib/userDraft.svelte'
 	import { notifyRestoredFromLocal } from '$lib/userDraftToast'
 
 	let version: undefined | number = $state(undefined)
@@ -48,7 +53,8 @@
 		  })
 		| undefined = $state(undefined)
 
-	const flowDraftPath = page.params.path ?? ''
+	// Derived so client-side nav (breadcrumb) re-keys the handle to the new path.
+	let flowDraftPath = $derived(page.params.path ?? '')
 
 	// `?nodraft=true` is the callers' way of saying "skip the local autosave
 	// on this load." Wipe the UserDraft entry and strip the flag from the
@@ -61,7 +67,27 @@
 		window.history.replaceState(window.history.state, '', url.toString())
 	}
 
-	const flowHandle = UserDraft.use<Flow>('flow', flowDraftPath)
+	// `useMany` keyed off the reactive `flowDraftPath` re-keys the handle on nav;
+	// `flowHandle` proxies the current handle so `flowStore` keeps a fixed ref.
+	const flowHandles = UserDraft.useMany<Flow>(() => [{ itemKind: 'flow', path: flowDraftPath }])
+	const flowHandle: UserDraftHandle<Flow> = {
+		get draft() {
+			return flowHandles[0]?.draft
+		},
+		set draft(value) {
+			const handle = flowHandles[0]
+			if (handle) handle.draft = value
+		},
+		get meta() {
+			return flowHandles[0]?.meta ?? {}
+		},
+		setDraftAndMeta(value, meta) {
+			flowHandles[0]?.setDraftAndMeta(value, meta)
+		},
+		setMeta(meta, opts) {
+			flowHandles[0]?.setMeta(meta, opts)
+		}
+	}
 
 	function emptyFlow(): Flow {
 		return {
@@ -88,6 +114,10 @@
 
 	let loading = $state(false)
 
+	// Remounts FlowBuilder on nav: false while a reload runs, true once data is
+	// ready, so it mounts fresh instead of reusing the previous flow's state.
+	let renderEditor = $state(false)
+
 	let selectedId: string = $state('settings-metadata')
 
 	let nobackenddraft = false
@@ -138,6 +168,11 @@
 		const tok = ++loadFlowToken
 		loading = true
 		let flow: Flow
+		// Builder-dependent setup is captured here and applied AFTER the builder
+		// remounts (see end of loadFlow): during a reload renderEditor is false,
+		// so flowBuilder is unmounted and direct calls would no-op.
+		let draftTriggersToApply: Trigger[] | undefined = undefined
+		let applyPrimarySchedule = false
 		// Currently there is no way to get version of flow with flow.
 		// So we have to request it here
 		const v = (
@@ -231,8 +266,8 @@
 
 		if (flowWithDraft.draft != undefined && !nobackenddraft) {
 			savedPrimarySchedule = flowWithDraft?.draft?.['primary_schedule']
-			flowBuilder?.setPrimarySchedule(savedPrimarySchedule)
-			flowBuilder?.setDraftTriggers(flowWithDraft?.draft?.['draft_triggers'])
+			applyPrimarySchedule = true
+			draftTriggersToApply = flowWithDraft?.draft?.['draft_triggers']
 
 			if (!flowWithDraft.draft_only && localDraft == undefined) {
 				const deployed = cleanValueProperties(flowWithDraft)
@@ -276,13 +311,21 @@
 				])
 			}
 		} else {
-			flowBuilder?.setDraftTriggers(undefined)
+			draftTriggersToApply = undefined
 		}
 
 		await initFlow(flow, flowStore, flowStateStore)
 		if (tok !== loadFlowToken) return
 		loading = false
 		selectedId = page.url.searchParams.get('selected') ?? 'settings-metadata'
+		// Remount the builder first, then apply builder-dependent setup once it
+		// has mounted — otherwise (during a reload) these would no-op on the
+		// unmounted builder and editor state restoration would be skipped.
+		renderEditor = true
+		await tick()
+		if (tok !== loadFlowToken) return
+		if (applyPrimarySchedule) flowBuilder?.setPrimarySchedule(savedPrimarySchedule)
+		flowBuilder?.setDraftTriggers(draftTriggersToApply)
 		flowBuilder?.loadFlowState()
 	}
 
@@ -291,7 +334,18 @@
 		// to another (e.g. via the workspace picker) reloads the new flow.
 		page.params.path
 		if ($workspaceStore) {
-			untrack(() => loadFlow())
+			untrack(() => {
+				nobackenddraft = false // fresh nav reconsiders the backend draft
+				renderEditor = false // remount the builder for the navigated-to flow
+				loadFlow().catch((e: any) => {
+					// A failed load must NOT leave renderEditor stuck false — otherwise
+					// the editor pane disappears and never remounts. Surface the error
+					// and remount so the user isn't stranded on a blank pane.
+					console.error('Failed to load flow', e)
+					sendUserToast(`Failed to load flow: ${e?.body ?? e?.message ?? e}`, true)
+					renderEditor = true
+				})
+			})
 		}
 	})
 
@@ -347,7 +401,7 @@
 		<h1 class="text-2xl font-bold">Flow not found at path {page.params.path}</h1>
 		<p class="text-gray-500">The flow you are looking for does not exist.</p>
 	</div>
-{:else}
+{:else if renderEditor}
 	<FlowBuilder
 		onDeploy={(e) => {
 			UserDraft.remove('flow', flowDraftPath)
diff --git a/frontend/src/routes/(root)/(logged)/forks/compare/+page.svelte b/frontend/src/routes/(root)/(logged)/forks/compare/+page.svelte
index 77ad35ffae..a6be7b1044 100644
--- a/frontend/src/routes/(root)/(logged)/forks/compare/+page.svelte
+++ b/frontend/src/routes/(root)/(logged)/forks/compare/+page.svelte
@@ -2,10 +2,16 @@
 	import CompareWorkspaces from '$lib/components/CompareWorkspaces.svelte'
 	import { WorkspaceService, type WorkspaceComparison } from '$lib/gen'
 	import { page } from '$app/state'
-	import { userWorkspaces } from '$lib/stores'
+	import { userWorkspaces, usersWorkspaceStore } from '$lib/stores'
 	import { untrack } from 'svelte'
 	import CenteredPage from '$lib/components/CenteredPage.svelte'
 	import PageHeader from '$lib/components/PageHeader.svelte'
+	import Button from '$lib/components/common/button/Button.svelte'
+	import ConfirmationModal from '$lib/components/common/confirmationModal/ConfirmationModal.svelte'
+	import { Archive, Trash2 } from 'lucide-svelte'
+	import { sendUserToast } from '$lib/toast'
+	import { switchWorkspace } from '$lib/storeUtils'
+	import { goto } from '$lib/navigation'
 
 	let comparison: WorkspaceComparison | undefined = $state(undefined)
 
@@ -21,25 +27,15 @@
 			return
 		}
 
-		// loading = true
-		// error = undefined
-
 		try {
-			// Compare with parent workspace
 			const result = await WorkspaceService.compareWorkspaces({
 				workspace: parentWorkspaceId,
 				targetWorkspaceId: currentWorkspaceId
 			})
 
 			comparison = result
-			// isVisible = result.summary.total_diffs > 0
 		} catch (e) {
 			console.error('Failed to compare workspaces:', e)
-			// error = 'Failed to check for changes'
-			// Still show banner if there's an error, but with error message
-			// isVisible = true
-		} finally {
-			// loading = false
 		}
 	}
 
@@ -48,19 +44,93 @@
 
 		untrack(() => checkForChanges())
 	})
+
+	// Fork lifecycle actions — placed in the page header so they're available
+	// regardless of merge state. Both go through a confirmation modal because
+	// archive is reversible-ish but delete is irreversible, and either way the
+	// user is about to navigate away from this page.
+	let archiveConfirmOpen = $state(false)
+	let deleteConfirmOpen = $state(false)
+	let acting = $state(false)
+
+	async function afterForkGone() {
+		// Mirror SidebarContent.deleteFork (B1): refresh the workspace list
+		// rather than letting `clearStores()` null it, then land the user on
+		// the parent if still accessible.
+		try {
+			usersWorkspaceStore.set(await WorkspaceService.listUserWorkspaces())
+		} catch (e) {
+			console.error('Failed to refresh workspaces', e)
+		}
+		if (parentWorkspaceId && $userWorkspaces.find((w) => w.id === parentWorkspaceId)) {
+			switchWorkspace(parentWorkspaceId)
+			await goto('/')
+		} else {
+			await goto('/user/workspaces')
+		}
+	}
+
+	async function confirmArchive() {
+		archiveConfirmOpen = false
+		if (!currentWorkspaceId) return
+		acting = true
+		try {
+			await WorkspaceService.archiveWorkspace({ workspace: currentWorkspaceId })
+			sendUserToast(`Archived fork ${currentWorkspaceId}`)
+			await afterForkGone()
+		} catch (e: any) {
+			sendUserToast(`Failed to archive fork: ${e?.body ?? e}`, true)
+		} finally {
+			acting = false
+		}
+	}
+
+	async function confirmDelete() {
+		deleteConfirmOpen = false
+		if (!currentWorkspaceId) return
+		acting = true
+		try {
+			await WorkspaceService.deleteWorkspace({ workspace: currentWorkspaceId })
+			sendUserToast(`Deleted fork ${currentWorkspaceId}`)
+			await afterForkGone()
+		} catch (e: any) {
+			sendUserToast(`Failed to delete fork: ${e?.body ?? e}`, true)
+		} finally {
+			acting = false
+		}
+	}
+
+	const isFork = $derived(!!parentWorkspaceId && currentWorkspaceId?.startsWith('wm-fork-'))
 </script>
 
 <CenteredPage>
-	<PageHeader title="Merge workspaces" />
+	<PageHeader title="Merge workspaces">
+		{#if isFork}
+			<div class="flex flex-row gap-2 items-center">
+				<Button
+					variant="default"
+					color="light"
+					size="xs"
+					startIcon={{ icon: Archive }}
+					disabled={acting}
+					on:click={() => (archiveConfirmOpen = true)}
+				>
+					Archive fork
+				</Button>
+				<Button
+					variant="default"
+					color="red"
+					size="xs"
+					startIcon={{ icon: Trash2 }}
+					disabled={acting}
+					on:click={() => (deleteConfirmOpen = true)}
+				>
+					Delete fork
+				</Button>
+			</div>
+		{/if}
+	</PageHeader>
 	{#if currentWorkspaceId && parentWorkspaceId}
-		<!-- <WorkspaceComparisonDrawer -->
-		<!-- 	{comparison} -->
-		<!-- 	sourceWorkspace={currentWorkspaceId} -->
-		<!-- 	targetWorkspace={parentWorkspaceId} -->
-		<!-- 	on:deployed={() => { -->
-		<!-- 		sendUserToast('Changes deployed successfully') -->
-		<!-- 	}} -->
-		<!-- /> -->
 		<CompareWorkspaces {currentWorkspaceId} {parentWorkspaceId} {comparison} />
 	{/if}
 	{#if !currentWorkspaceId}
@@ -69,3 +139,33 @@
 		workspace {currentWorkspaceId} has no parent workspace
 	{/if}
 </CenteredPage>
+
+<ConfirmationModal
+	open={archiveConfirmOpen}
+	title="Archive fork"
+	confirmationText="Archive"
+	onConfirmed={confirmArchive}
+	onCanceled={() => (archiveConfirmOpen = false)}
+>
+	<p>
+		Archive forked workspace <span class="font-mono font-medium text-primary"
+			>{currentWorkspaceId}</span
+		>? It will be hidden from the workspace picker; a superadmin can restore it from instance
+		settings later.
+	</p>
+</ConfirmationModal>
+
+<ConfirmationModal
+	open={deleteConfirmOpen}
+	title="Delete fork"
+	confirmationText="Delete"
+	onConfirmed={confirmDelete}
+	onCanceled={() => (deleteConfirmOpen = false)}
+>
+	<p>
+		Permanently delete forked workspace <span class="font-mono font-medium text-primary"
+			>{currentWorkspaceId}</span
+		>? This cannot be undone. Any sessions still bound to this fork will show as "Fork — no longer
+		available" in the sidebar.
+	</p>
+</ConfirmationModal>
diff --git a/frontend/src/routes/(root)/(logged)/schedules/+page.svelte b/frontend/src/routes/(root)/(logged)/schedules/+page.svelte
index b9731394a0..2a88266c4e 100644
--- a/frontend/src/routes/(root)/(logged)/schedules/+page.svelte
+++ b/frontend/src/routes/(root)/(logged)/schedules/+page.svelte
@@ -462,7 +462,7 @@
 								{/key}
 								<div class="flex gap-2 items-center justify-end">
 									<Button
-										href={`${base}/runs/?schedule_path=${path}&show_schedules=true&show_future_jobs=true`}
+										href={`${base}/runs/?schedule_path=${path}&job_trigger_kind=schedule&show_future_jobs=true`}
 										unifiedSize="md"
 										startIcon={{ icon: List }}
 										variant="subtle"
@@ -532,11 +532,7 @@
 											{
 												displayName: 'View runs',
 												icon: List,
-												href:
-													base +
-													'/runs/?schedule_path=' +
-													path +
-													'&show_schedules=true&show_future_jobs=true'
+												href: `${base}/runs/?schedule_path=${path}&job_trigger_kind=schedule&show_future_jobs=true`
 											},
 											{
 												displayName: 'Audit logs',
diff --git a/frontend/src/routes/(root)/(logged)/scripts/add/+page.svelte b/frontend/src/routes/(root)/(logged)/scripts/add/+page.svelte
index 15cd910668..b107f76767 100644
--- a/frontend/src/routes/(root)/(logged)/scripts/add/+page.svelte
+++ b/frontend/src/routes/(root)/(logged)/scripts/add/+page.svelte
@@ -4,7 +4,7 @@
 	import { page } from '$app/state'
 	import { defaultScripts, initialArgsStore, workspaceStore } from '$lib/stores'
 	import ScriptBuilder from '$lib/components/ScriptBuilder.svelte'
-	import { editPathFor, invalidate } from '$lib/components/workspacePicker'
+	import { editPathFor } from '$lib/components/workspacePicker'
 	import type { Schema } from '$lib/common'
 	import {
 		cleanValueProperties,
@@ -324,11 +324,14 @@
 					? 'wac_typescript'
 					: 'script')}
 		onDeploy={(e) => {
-			if ($workspaceStore) invalidate($workspaceStore, 'script')
+			// "Deploy & Stay here" / lib: stay on the editor (just confirm).
+			if (e.stay) {
+				sendUserToast('Deployed')
+				return
+			}
 			goto(`/scripts/get/${e.hash}?workspace=${$workspaceStore}`)
 		}}
 		onSaveInitial={(e) => {
-			if ($workspaceStore) invalidate($workspaceStore, 'script')
 			goto(`/scripts/edit/${e.path}`)
 		}}
 		onNavigate={(item) => goto(editPathFor(item))}
diff --git a/frontend/src/routes/(root)/(logged)/scripts/edit/[...path]/+page.svelte b/frontend/src/routes/(root)/(logged)/scripts/edit/[...path]/+page.svelte
index bc382baea2..b76c03a804 100644
--- a/frontend/src/routes/(root)/(logged)/scripts/edit/[...path]/+page.svelte
+++ b/frontend/src/routes/(root)/(logged)/scripts/edit/[...path]/+page.svelte
@@ -20,7 +20,12 @@
 	import { get } from 'svelte/store'
 	import { untrack } from 'svelte'
 	import { page } from '$app/state'
-	import { UserDraft, checkStaleness, type UserDraftMeta } from '$lib/userDraft.svelte'
+	import {
+		UserDraft,
+		checkStaleness,
+		type UserDraftMeta,
+		type UserDraftHandle
+	} from '$lib/userDraft.svelte'
 	import { notifyRestoredFromLocal } from '$lib/userDraftToast'
 
 	type EditableScript = NewScript & { draft_triggers?: Trigger[] }
@@ -30,14 +35,38 @@
 	let initialArgs = get(initialArgsStore) ?? {}
 	if (get(initialArgsStore)) $initialArgsStore = undefined
 
-	let topHash = page.url.searchParams.get('topHash') ?? undefined
+	// Derived so client-side nav (breadcrumb) re-reads the URL, not mount-time values.
+	let topHash = $derived(page.url.searchParams.get('topHash') ?? undefined)
 
-	let hash = page.url.searchParams.get('hash') ?? undefined
+	let hash = $derived(page.url.searchParams.get('hash') ?? undefined)
 
 	// When viewing a specific historical hash we don't want to load or write a
 	// local draft — that view is read-only relative to drafts.
-	const draftPath = hash ? '' : (page.params.path ?? '')
-	const scriptHandle = UserDraft.use<EditableScript>('script', draftPath)
+	let draftPath = $derived(hash ? '' : (page.params.path ?? ''))
+
+	// `useMany` keyed off the reactive `draftPath` re-keys the handle on nav;
+	// `scriptHandle` proxies the current handle so `bind:script` stays a fixed lvalue.
+	const scriptHandles = UserDraft.useMany<EditableScript>(() => [
+		{ itemKind: 'script', path: draftPath }
+	])
+	const scriptHandle: UserDraftHandle<EditableScript> = {
+		get draft() {
+			return scriptHandles[0]?.draft
+		},
+		set draft(value) {
+			const handle = scriptHandles[0]
+			if (handle) handle.draft = value
+		},
+		get meta() {
+			return scriptHandles[0]?.meta ?? {}
+		},
+		setDraftAndMeta(value, meta) {
+			scriptHandles[0]?.setDraftAndMeta(value, meta)
+		},
+		setMeta(meta, opts) {
+			scriptHandles[0]?.setMeta(meta, opts)
+		}
+	}
 
 	$effect(() => {
 		if (hash || !$workspaceStore) return
@@ -85,6 +114,11 @@
 	let savedScript: NewScriptWithDraft | undefined = $state(undefined)
 	let fullyLoaded = $state(false)
 
+	// Remounts ScriptBuilder on nav: false while a reload runs, true once data is
+	// ready. A synchronous `{#key}` swap instead races Monaco's init against the
+	// torn-down container (mirrors how the raw-app editor clears `files`).
+	let renderEditor = $state(false)
+
 	let savedPrimarySchedule: ScheduleTrigger | undefined = $state(undefined)
 
 	// Local-draft staleness modal: opened when the remote (deployed or DB
@@ -336,6 +370,7 @@
 			scriptBuilder?.setCode(scriptHandle.draft.content)
 		}
 		fullyLoaded = true
+		renderEditor = true
 	}
 
 	$effect(() => {
@@ -343,7 +378,17 @@
 		// to another (e.g. via the workspace picker) reloads the new script.
 		page.params.path
 		if ($workspaceStore) {
-			untrack(() => loadScript())
+			untrack(() => {
+				renderEditor = false // remount the builder for the navigated-to script
+				loadScript().catch((e: any) => {
+					// A failed load must NOT leave renderEditor stuck false — otherwise
+					// the editor pane disappears and never remounts. Surface the error
+					// and remount so the user isn't stranded on a blank pane.
+					console.error('Failed to load script', e)
+					sendUserToast(`Failed to load script: ${e?.body ?? e?.message ?? e}`, true)
+					renderEditor = true
+				})
+			})
 		}
 	})
 
@@ -424,7 +469,7 @@
 	onLoadLatest={onUrlConflictUseUrl}
 	onKeepDraft={onUrlConflictKeepLocal}
 />
-{#if scriptHandle.draft}
+{#if scriptHandle.draft && renderEditor}
 	<ScriptBuilder
 		bind:this={scriptBuilder}
 		{initialPath}
@@ -436,12 +481,16 @@
 		{savedPrimarySchedule}
 		searchParams={page.url.searchParams}
 		onDeploy={(e) => {
+			// "Deploy & Stay here" / lib: stay on the editor (just confirm).
+			if (e.stay) {
+				sendUserToast('Deployed')
+				return
+			}
 			UserDraft.remove('script', draftPath)
 			if ($workspaceStore) invalidate($workspaceStore, 'script')
 			goto(`/scripts/get/${e.hash}?workspace=${$workspaceStore}`)
 		}}
 		onSaveInitial={(e) => {
-			if ($workspaceStore) invalidate($workspaceStore, 'script')
 			goto(`/scripts/edit/${e.path}`)
 		}}
 		onSeeDetails={(e) => {
diff --git a/frontend/src/routes/(root)/(logged)/sessions/+page.svelte b/frontend/src/routes/(root)/(logged)/sessions/+page.svelte
new file mode 100644
index 0000000000..a733c325d6
--- /dev/null
+++ b/frontend/src/routes/(root)/(logged)/sessions/+page.svelte
@@ -0,0 +1,176 @@
+<script lang="ts">
+	import { untrack } from 'svelte'
+	import { page } from '$app/state'
+	import { Plus } from 'lucide-svelte'
+	import { Button } from '$lib/components/common'
+	import { goto } from '$lib/navigation'
+	import SessionWrapper from '$lib/components/sessions/SessionWrapper.svelte'
+	import {
+		createSession,
+		getEffectiveWorkspaceId,
+		selectSession,
+		sessionState,
+		syncWorkspaceTo
+	} from '$lib/components/sessions/sessionState.svelte'
+	import {
+		getOrCreateRuntime,
+		getRuntime,
+		listRuntimes,
+		promoteEditorWarm
+	} from '$lib/components/sessions/sessionRuntime.svelte'
+	import { markSessionSeen } from '$lib/components/sessions/sessionUnread.svelte'
+	import { visibleWorkspaceIds } from '$lib/components/sessions/sessionScope.svelte'
+	import { isGlobalAiEnabled } from '$lib/components/copilot/chat/global/gate'
+	import { userWorkspaces } from '$lib/stores'
+
+	const globalEnabled = isGlobalAiEnabled()
+
+	const sessionName = $derived(page.url.searchParams.get('session_name') ?? '')
+
+	// Unfiltered resolution by name — used to drive workspace switching
+	// when a deep-linked session lives outside the current workspace.
+	const sessionByName = $derived(
+		sessionName ? sessionState.sessions.find((s) => s.name === sessionName) : undefined
+	)
+
+	// If the deep-linked session committed to a workspace different from
+	// the active one, switch globally so visibility resolves and the
+	// editor loads against the right workspace. Skip the switch when the
+	// target workspace is no longer in the user's list — pointing the
+	// global workspace at a deleted id would break sidebar scope and the
+	// editor; SessionWrapper handles the unavailable state separately.
+	$effect(() => {
+		const ws = sessionByName?.workspace_id
+		if (!ws) return
+		if (!$userWorkspaces.find((w) => w.id === ws)) return
+		untrack(() => syncWorkspaceTo(ws))
+	})
+
+	// Resolve the active session if its effective workspace is in scope
+	// (active workspace + its forks). Unavailable sessions — committed to
+	// a workspace that no longer exists — also resolve so the user can
+	// land on the move/discard banner instead of hitting "Session not
+	// found".
+	const activeSession = $derived(
+		sessionState.sessions.find((s) => {
+			if (s.name !== sessionName) return false
+			const ws = getEffectiveWorkspaceId(s)
+			if (!ws) return false
+			if ($visibleWorkspaceIds.has(ws)) return true
+			if (s.workspace_id && !$userWorkspaces.find((w) => w.id === s.workspace_id)) return true
+			return false
+		})
+	)
+
+	// Touch the runtime for the active session so it gets created on first visit
+	// and the pane shows up. Subsequent renders find it via listRuntimes().
+	// Also refresh the fork diff count: deep-link / back-button navigation
+	// changes the URL but doesn't fire the picker.activate path nor the
+	// visibility-change signal, so this is the only hook that catches a
+	// user returning from another route in the same tab.
+	//
+	// Gate on session identity (id) rather than the full activeSession
+	// derived — sessionState.sessions mutates on every persisted change
+	// (including token-by-token last_message updates during AI streaming),
+	// so a value-trigger would re-fetch compareWorkspaces dozens of times
+	// per turn. We only want to refresh when the user actually arrives at
+	// a new session.
+	let lastArrivedSessionId: string | undefined
+	$effect(() => {
+		const session = activeSession
+		if (!session) {
+			lastArrivedSessionId = undefined
+			return
+		}
+		if (lastArrivedSessionId === session.id) return
+		lastArrivedSessionId = session.id
+		untrack(() => {
+			// Keep currentSessionId in sync with the URL so consumers
+			// (refresh hooks, picker selection) react to deep links the
+			// same way they react to picker clicks.
+			selectSession(session.id)
+			const rt = getOrCreateRuntime(session)
+			void rt.refreshForkComparison()
+		})
+	})
+
+	// Warm = has a live runtime (module-scoped) AND its workspace is in
+	// scope (or its workspace is unavailable — those sessions still need
+	// to render the move/discard banner instead of vanishing on us).
+	const warmSessions = $derived(
+		listRuntimes()
+			.map((r) => sessionState.sessions.find((s) => s.id === r.sessionId))
+			.filter((s): s is NonNullable<typeof s> => s != null)
+			.filter((s) => {
+				const ws = getEffectiveWorkspaceId(s)
+				if (!ws) return false
+				if ($visibleWorkspaceIds.has(ws)) return true
+				if (s.workspace_id && !$userWorkspaces.find((w) => w.id === s.workspace_id)) return true
+				return false
+			})
+	)
+
+	// Promote the active session in the LRU. Mutations untracked so the effect
+	// only re-runs when activeSession changes, not on its own writes.
+	$effect(() => {
+		const id = activeSession?.id
+		if (!id) return
+		untrack(() => promoteEditorWarm(id))
+	})
+
+	// Mark the active session "seen" up to its current displayMessages
+	// length. Watching messages.length here means: arrive at the page →
+	// clear unread; AI streams a new message while you're on the page →
+	// clear unread again so the badge never lights up for a session
+	// you're actively looking at. The effect only depends on the
+	// length, not the array contents, so token-by-token streams within
+	// a single message don't fire it on every chunk.
+	$effect(() => {
+		const id = activeSession?.id
+		if (!id) return
+		const rt = getRuntime(id)
+		if (!rt) return
+		const count = rt.manager.displayMessages.length
+		untrack(() => markSessionSeen(id, count))
+	})
+
+	async function startNewSession() {
+		const fresh = createSession()
+		await goto(`/sessions?session_name=${encodeURIComponent(fresh.name)}`)
+	}
+</script>
+
+{#if !globalEnabled}
+	<div class="p-8 text-secondary text-sm">
+		Sessions are gated on the global-AI dev flag. Enable with
+		<code class="text-2xs font-mono">localStorage.setItem('wm_dev_global_ai', '1')</code> and reload.
+	</div>
+{:else if !sessionName}
+	<div class="p-8 text-secondary">No session selected — pick one in the sidebar.</div>
+{:else if !sessionByName}
+	<!-- A session_name is in the URL but no session by that name exists — e.g. a
+	     deleted session or a link opened in a different browser. -->
+	<div class="p-8 flex flex-col items-start gap-3 text-secondary text-sm">
+		<div class="flex flex-col gap-1">
+			<p class="text-primary font-medium">Session not found</p>
+			<p>
+				No session named <code class="font-mono text-2xs">{sessionName}</code> exists. It may have been
+				deleted, or this link was created in a different browser.
+			</p>
+		</div>
+		<Button size="xs" startIcon={{ icon: Plus }} onclick={startNewSession}>New session</Button>
+	</div>
+{:else}
+	<div class="relative flex-1 min-h-0">
+		{#each warmSessions as s (s.id)}
+			<div
+				class="absolute inset-0 flex flex-col {s.id === activeSession?.id
+					? 'z-10 opacity-100 pointer-events-auto'
+					: 'z-0 opacity-0 pointer-events-none'}"
+				aria-hidden={s.id !== activeSession?.id}
+			>
+				<SessionWrapper sessionId={s.id} />
+			</div>
+		{/each}
+	</div>
+{/if}
diff --git a/frontend/src/routes/(root)/(logged)/workspace_settings/+page.svelte b/frontend/src/routes/(root)/(logged)/workspace_settings/+page.svelte
index aa873f83a9..e71f0bb71e 100644
--- a/frontend/src/routes/(root)/(logged)/workspace_settings/+page.svelte
+++ b/frontend/src/routes/(root)/(logged)/workspace_settings/+page.svelte
@@ -30,10 +30,12 @@
 		enterpriseLicense,
 		superadmin,
 		userStore,
+		userWorkspaces,
 		usersWorkspaceStore,
 		workspaceStore,
 		isCriticalAlertsUIOpen
 	} from '$lib/stores'
+	import { switchWorkspace } from '$lib/storeUtils'
 	import { sendUserToast } from '$lib/toast'
 	import { clone, emptyString, encodeState, hasUnsavedChanges } from '$lib/utils'
 	import { downloadViaClient, shouldDownloadViaClient } from '$lib/utils/downloadFile'
@@ -1542,11 +1544,32 @@
 									unifiedSize="md"
 									btnClasses="mt-2"
 									on:click={async () => {
-										await WorkspaceService.archiveWorkspace({ workspace: $workspaceStore ?? '' })
-										sendUserToast(`Archived workspace ${$workspaceStore}`)
-										workspaceStore.set(undefined)
-										usersWorkspaceStore.set(undefined)
-										goto('/user/workspaces')
+										const ws = $workspaceStore ?? ''
+										// Land on the parent workspace if this is a fork and the
+										// parent is still accessible — otherwise fall back to the
+										// workspace picker.
+										const parentId = $userWorkspaces.find((w) => w.id === ws)?.parent_workspace_id
+										const parentStillAccessible = !!(
+											parentId && $userWorkspaces.find((w) => w.id === parentId)
+										)
+										await WorkspaceService.archiveWorkspace({ workspace: ws })
+										sendUserToast(`Archived workspace ${ws}`)
+										if (parentStillAccessible && parentId) {
+											// Refresh the list so the just-archived workspace drops out before
+											// we land on the parent. Guarded: a refresh failure must not block
+											// the switch (the list reloads on next page load).
+											try {
+												usersWorkspaceStore.set(await WorkspaceService.listUserWorkspaces())
+											} catch (e) {
+												console.error('Failed to refresh workspaces after archive', e)
+											}
+											switchWorkspace(parentId)
+											await goto('/')
+										} else {
+											workspaceStore.set(undefined)
+											usersWorkspaceStore.set(undefined)
+											await goto('/user/workspaces')
+										}
 									}}
 								>
 									Archive workspace
diff --git a/frontend/svelte.config.js b/frontend/svelte.config.js
index 8ba411c131..4b318efcd5 100644
--- a/frontend/svelte.config.js
+++ b/frontend/svelte.config.js
@@ -28,7 +28,8 @@ const config = {
 			base: process.env.VITE_BASE_URL ?? ''
 		},
 		alias: {
-			'$system_prompts': '../system_prompts/auto-generated'
+			$system_prompts: '../system_prompts/auto-generated',
+			$oauth_connect_registry: '../backend/oauth_connect.json'
 		}
 	},
 
diff --git a/lsp/Pipfile b/lsp/Pipfile
index 199fbdf672..af8a1add3b 100644
--- a/lsp/Pipfile
+++ b/lsp/Pipfile
@@ -4,7 +4,7 @@ verify_ssl = true
 name = "pypi"
 
 [packages]
-wmill = ">=1.711.0"
+wmill = ">=1.714.0"
 sendgrid = "*"
 mysql-connector-python = "*"
 pymongo = "*"
diff --git a/openflow.openapi.yaml b/openflow.openapi.yaml
index 0ef3bbaa85..34944d78de 100644
--- a/openflow.openapi.yaml
+++ b/openflow.openapi.yaml
@@ -1,7 +1,7 @@
 openapi: '3.0.3'
 
 info:
-  version: 1.711.0
+  version: 1.714.0
   title: OpenFlow Spec
   contact:
     name: Ruben Fiszel
@@ -60,6 +60,9 @@ components:
         same_worker:
           type: boolean
           description: If true, all steps run on the same worker for better performance
+        preserve_step_tags:
+          type: boolean
+          description: If true and the flow runs on a custom worker tag, steps that declare their own non-empty tag run on it instead of inheriting the flow tag. Steps without their own tag still inherit the flow tag.
         concurrent_limit:
           type: number
           description: Maximum number of concurrent executions of this flow
diff --git a/powershell-client/WindmillClient/WindmillClient.psd1 b/powershell-client/WindmillClient/WindmillClient.psd1
index ee0f88f1b2..c7b31520cc 100644
--- a/powershell-client/WindmillClient/WindmillClient.psd1
+++ b/powershell-client/WindmillClient/WindmillClient.psd1
@@ -12,7 +12,7 @@
     RootModule        = 'WindmillClient.psm1'
 
     # Version number of this module.
-    ModuleVersion     = '1.711.0'
+    ModuleVersion     = '1.714.0'
 
     # Supported PSEditions
     # CompatiblePSEditions = @()
diff --git a/python-client/wmill/pyproject.toml b/python-client/wmill/pyproject.toml
index ecc68d1c18..d82c98e4cf 100644
--- a/python-client/wmill/pyproject.toml
+++ b/python-client/wmill/pyproject.toml
@@ -1,6 +1,6 @@
 [tool.poetry]
 name = "wmill"
-version = "1.711.0"
+version = "1.714.0"
 description = "A client library for accessing Windmill server wrapping the Windmill client API"
 license = "Apache-2.0"
 homepage = "https://windmill.dev"
diff --git a/system_prompts/auto-generated/cli/cli-commands.md b/system_prompts/auto-generated/cli/cli-commands.md
index b02aabefe0..662bb58a53 100644
--- a/system_prompts/auto-generated/cli/cli-commands.md
+++ b/system_prompts/auto-generated/cli/cli-commands.md
@@ -583,6 +583,7 @@ sync local with a remote workspaces or the opposite (push or pull)
   - `--include-groups` - Include syncing groups
   - `--include-settings` - Include syncing workspace settings
   - `--include-key` - Include workspace encryption key
+  - `--skip-reencrypt-on-key-change` - When the pushed encryption key differs from the remote, do NOT re-encrypt existing remote secrets. Only safe if they are already encrypted with the new key (e.g. workspace/instance migration). Default is to re-encrypt.
   - `--skip-branch-validation` - Skip git branch validation and prompts
   - `--json-output` - Output results in JSON format
   - `-i --includes <patterns:file[]>` - Comma separated patterns to specify which file to take into account (among files that are compatible with windmill). Patterns can include * (any string until '/') and ** (any string)
diff --git a/system_prompts/auto-generated/flow.md b/system_prompts/auto-generated/flow.md
index 806e279767..6a2fe07ba2 100644
--- a/system_prompts/auto-generated/flow.md
+++ b/system_prompts/auto-generated/flow.md
@@ -295,4 +295,4 @@ Reference a specific resource using `$res:` prefix:
 
 ## OpenFlow Schema
 
-{"OpenFlow":{"type":"object","description":"Top-level flow definition containing metadata, configuration, and the flow structure","properties":{"summary":{"type":"string","description":"Short description of what this flow does"},"description":{"type":"string","description":"Detailed documentation for this flow"},"value":{"$ref":"#/components/schemas/FlowValue"},"schema":{"type":"object","description":"JSON Schema for flow inputs. Use this to define input parameters, their types, defaults, and validation. For resource inputs, set type to 'object' and format to 'resource-<type>' (e.g., 'resource-stripe')"},"on_behalf_of_email":{"type":"string","description":"The flow will be run with the permissions of the user with this email."}},"required":["summary","value"]},"FlowValue":{"type":"object","description":"The flow structure containing modules and optional preprocessor/failure handlers","properties":{"modules":{"type":"array","description":"Array of steps that execute in sequence. Each step can be a script, subflow, loop, or branch","items":{"$ref":"#/components/schemas/FlowModule"}},"failure_module":{"description":"Special module that executes when the flow fails. Receives error object with message, name, stack, and step_id. Must have id 'failure'. Only supports script/rawscript types","$ref":"#/components/schemas/FlowModule"},"preprocessor_module":{"description":"Special module that runs before the first step on external triggers. Must have id 'preprocessor'. Only supports script/rawscript types. Cannot reference other step results","$ref":"#/components/schemas/FlowModule"},"same_worker":{"type":"boolean","description":"If true, all steps run on the same worker for better performance"},"concurrent_limit":{"type":"number","description":"Maximum number of concurrent executions of this flow"},"concurrency_key":{"type":"string","description":"Expression to group concurrent executions (e.g., by user ID)"},"concurrency_time_window_s":{"type":"number","description":"Time window in seconds for concurrent_limit"},"debounce_delay_s":{"type":"integer","description":"Delay in seconds to debounce flow executions"},"debounce_key":{"type":"string","description":"Expression to group debounced executions"},"debounce_args_to_accumulate":{"type":"array","description":"Arguments to accumulate across debounced executions","items":{"type":"string"}},"max_total_debouncing_time":{"type":"integer","description":"Maximum total time in seconds that a job can be debounced"},"max_total_debounces_amount":{"type":"integer","description":"Maximum number of times a job can be debounced"},"skip_expr":{"type":"string","description":"JavaScript expression to conditionally skip the entire flow"},"cache_ttl":{"type":"number","description":"Cache duration in seconds for flow results"},"cache_ignore_s3_path":{"type":"boolean"},"delete_after_secs":{"type":"integer","description":"If set, delete the flow job's args, result and logs after this many seconds following job completion"},"flow_env":{"type":"object","description":"Environment variables available to all steps. Values can be strings, JSON values, or special references: '$var:path' (workspace variable) or '$res:path' (resource).","additionalProperties":{}},"priority":{"type":"number","description":"Execution priority (higher numbers run first)"},"early_return":{"type":"string","description":"JavaScript expression to return early from the flow"},"chat_input_enabled":{"type":"boolean","description":"Whether this flow accepts chat-style input"},"notes":{"type":"array","description":"Sticky notes attached to the flow","items":{"$ref":"#/components/schemas/FlowNote"}},"groups":{"type":"array","description":"Semantic groups of modules for organizational purposes","items":{"$ref":"#/components/schemas/FlowGroup"}}},"required":["modules"]},"Retry":{"type":"object","description":"Retry configuration for failed module executions","properties":{"constant":{"type":"object","description":"Retry with constant delay between attempts","properties":{"attempts":{"type":"integer","description":"Number of retry attempts"},"seconds":{"type":"integer","description":"Seconds to wait between retries"}}},"exponential":{"type":"object","description":"Retry with exponential backoff (delay doubles each time)","properties":{"attempts":{"type":"integer","description":"Number of retry attempts"},"multiplier":{"type":"integer","description":"Multiplier for exponential backoff"},"seconds":{"type":"integer","minimum":1,"description":"Initial delay in seconds"},"random_factor":{"type":"integer","minimum":0,"maximum":100,"description":"Random jitter percentage (0-100) to avoid thundering herd"}}},"retry_if":{"$ref":"#/components/schemas/RetryIf"}}},"FlowNote":{"type":"object","description":"A sticky note attached to a flow for documentation and annotation","properties":{"id":{"type":"string","description":"Unique identifier for the note"},"text":{"type":"string","description":"Content of the note"},"position":{"type":"object","description":"Position of the note in the flow editor","properties":{"x":{"type":"number","description":"X coordinate"},"y":{"type":"number","description":"Y coordinate"}},"required":["x","y"]},"size":{"type":"object","description":"Size of the note in the flow editor","properties":{"width":{"type":"number","description":"Width in pixels"},"height":{"type":"number","description":"Height in pixels"}},"required":["width","height"]},"color":{"type":"string","description":"Color of the note (e.g., \"yellow\", \"#ffff00\")"},"type":{"type":"string","enum":["free","group"],"description":"Type of note - 'free' for standalone notes, 'group' for notes that group other nodes"},"locked":{"type":"boolean","default":false,"description":"Whether the note is locked and cannot be edited or moved"},"contained_node_ids":{"type":"array","items":{"type":"string"},"description":"For group notes, the IDs of nodes contained within this group"}},"required":["id","text","color","type"]},"FlowGroup":{"type":"object","description":"A semantic group of flow modules for organizational purposes. Does not affect execution \u2014 modules remain in their original position in the flow. Groups provide naming and collapsibility in the editor. Members are computed dynamically from all nodes on paths between start_id and end_id.","properties":{"summary":{"type":"string","description":"Display name for this group"},"note":{"type":"string","description":"Markdown note shown below the group header"},"autocollapse":{"type":"boolean","default":false,"description":"If true, this group is collapsed by default in the flow editor. UI hint only."},"start_id":{"type":"string","description":"ID of the first flow module in this group (topological entry point)"},"end_id":{"type":"string","description":"ID of the last flow module in this group (topological exit point)"},"color":{"type":"string","description":"Color for the group in the flow editor"}},"required":["start_id","end_id"]},"RetryIf":{"type":"object","description":"Conditional retry based on error or result","properties":{"expr":{"type":"string","description":"JavaScript expression that returns true to retry. Has access to 'result' and 'error' variables"}},"required":["expr"]},"StopAfterIf":{"type":"object","description":"Early termination condition for a module","properties":{"skip_if_stopped":{"type":"boolean","description":"If true, following steps are skipped when this condition triggers"},"expr":{"type":"string","description":"JavaScript expression evaluated after the module runs. Can use 'result' (step's result) or 'flow_input'. Return true to stop"},"error_message":{"type":"string","nullable":true,"description":"Custom error message when stopping with an error. Mutually exclusive with skip_if_stopped. If set to a non-empty string, the flow stops with this error. If empty string, a default error message is used. If null or omitted, no error is raised."}},"required":["expr"]},"FlowModule":{"type":"object","description":"A single step in a flow. Can be a script, subflow, loop, or branch","properties":{"id":{"type":"string","description":"Unique identifier for this step. Used to reference results via 'results.step_id'. Must be a valid identifier (alphanumeric, underscore, hyphen)"},"value":{"$ref":"#/components/schemas/FlowModuleValue"},"stop_after_if":{"description":"Early termination condition evaluated after this step completes","$ref":"#/components/schemas/StopAfterIf"},"stop_after_all_iters_if":{"description":"For loops only - early termination condition evaluated after all iterations complete","$ref":"#/components/schemas/StopAfterIf"},"skip_if":{"type":"object","description":"Conditionally skip this step based on previous results or flow inputs","properties":{"expr":{"type":"string","description":"JavaScript expression that returns true to skip. Can use 'flow_input' or 'results.<step_id>'"}},"required":["expr"]},"sleep":{"description":"Delay before executing this step (in seconds or as expression)","$ref":"#/components/schemas/InputTransform"},"cache_ttl":{"type":"number","description":"Cache duration in seconds for this step's results"},"cache_ignore_s3_path":{"type":"boolean"},"timeout":{"description":"Maximum execution time in seconds (static value or expression)","$ref":"#/components/schemas/InputTransform"},"delete_after_secs":{"type":"integer","description":"If set, delete the step's args, result and logs after this many seconds following job completion"},"summary":{"type":"string","description":"Short description of what this step does"},"mock":{"type":"object","description":"Mock configuration for testing without executing the actual step","properties":{"enabled":{"type":"boolean","description":"If true, return mock value instead of executing"},"return_value":{"description":"Value to return when mocked"}}},"suspend":{"type":"object","description":"Configuration for approval/resume steps that wait for user input","properties":{"required_events":{"type":"integer","description":"Number of approvals required before continuing"},"timeout":{"type":"integer","description":"Timeout in seconds before auto-continuing or canceling"},"resume_form":{"type":"object","description":"Form schema for collecting input when resuming","properties":{"schema":{"type":"object","description":"JSON Schema for the resume form"}}},"user_auth_required":{"type":"boolean","description":"If true, only authenticated users can approve"},"user_groups_required":{"description":"Expression or list of groups that can approve","$ref":"#/components/schemas/InputTransform"},"self_approval_disabled":{"type":"boolean","description":"If true, the user who started the flow cannot approve"},"hide_cancel":{"type":"boolean","description":"If true, hide the cancel button on the approval form"},"continue_on_disapprove_timeout":{"type":"boolean","description":"If true, continue flow on timeout instead of canceling"}}},"priority":{"type":"number","description":"Execution priority for this step (higher numbers run first)"},"continue_on_error":{"type":"boolean","description":"If true, flow continues even if this step fails"},"retry":{"description":"Retry configuration if this step fails","$ref":"#/components/schemas/Retry"},"debouncing":{"description":"Debounce configuration for this step (EE only)","type":"object","properties":{"debounce_delay_s":{"type":"integer","description":"Delay in seconds to debounce this step's executions across flow runs"},"debounce_key":{"type":"string","description":"Expression to group debounced executions. Supports $workspace and $args[name]. Default: $workspace/flow/<flow_path>-<step_id>"},"debounce_args_to_accumulate":{"type":"array","description":"Array-type arguments to accumulate across debounced executions","items":{"type":"string"}},"max_total_debouncing_time":{"type":"integer","description":"Maximum total time in seconds before forced execution"},"max_total_debounces_amount":{"type":"integer","description":"Maximum number of debounces before forced execution"}}}},"required":["value","id"]},"InputTransform":{"description":"Maps input parameters for a step. Can be a static value or a JavaScript expression that references previous results or flow inputs","oneOf":[{"$ref":"#/components/schemas/StaticTransform"},{"$ref":"#/components/schemas/JavascriptTransform"},{"$ref":"#/components/schemas/AiTransform"}],"discriminator":{"propertyName":"type","mapping":{"static":"#/components/schemas/StaticTransform","javascript":"#/components/schemas/JavascriptTransform","ai":"#/components/schemas/AiTransform"}}},"StaticTransform":{"type":"object","description":"Static value passed directly to the step. Use for hardcoded values or resource references like '$res:path/to/resource'","properties":{"value":{"description":"The static value. For resources, use format '$res:path/to/resource'"},"type":{"type":"string","enum":["static"]}},"required":["type"]},"JavascriptTransform":{"type":"object","description":"JavaScript expression evaluated at runtime. Can reference previous step results via 'results.step_id' or flow inputs via 'flow_input.property'. Inside loops, use 'flow_input.iter.value' for the current iteration value","properties":{"expr":{"type":"string","description":"JavaScript expression returning the value. Available variables - results (object with all previous step results), flow_input (flow inputs), flow_input.iter (in loops)"},"type":{"type":"string","enum":["javascript"]}},"required":["expr","type"]},"AiTransform":{"type":"object","description":"Value resolved by the AI runtime for this input. The AI engine decides how to satisfy the parameter.","properties":{"type":{"type":"string","enum":["ai"]}},"required":["type"]},"AIProviderKind":{"type":"string","description":"Supported AI provider types","enum":["openai","azure_openai","anthropic","mistral","deepseek","googleai","groq","openrouter","togetherai","customai","aws_bedrock"]},"ProviderConfig":{"type":"object","description":"Complete AI provider configuration with resource reference and model selection","properties":{"kind":{"$ref":"#/components/schemas/AIProviderKind"},"resource":{"type":"string","description":"Resource reference in format '$res:{resource_path}' pointing to provider credentials"},"model":{"type":"string","description":"Model identifier (e.g., 'gpt-4', 'claude-3-opus-20240229', 'gemini-pro')"}},"required":["kind","resource","model"]},"StaticProviderTransform":{"type":"object","description":"Static provider configuration passed directly to the AI agent","properties":{"value":{"$ref":"#/components/schemas/ProviderConfig"},"type":{"type":"string","enum":["static"]}},"required":["type","value"]},"ProviderTransform":{"description":"Provider configuration - can be static (ProviderConfig), JavaScript expression, or AI-determined","oneOf":[{"$ref":"#/components/schemas/StaticProviderTransform"},{"$ref":"#/components/schemas/JavascriptTransform"},{"$ref":"#/components/schemas/AiTransform"}],"discriminator":{"propertyName":"type","mapping":{"static":"#/components/schemas/StaticProviderTransform","javascript":"#/components/schemas/JavascriptTransform","ai":"#/components/schemas/AiTransform"}}},"MemoryOff":{"type":"object","description":"No conversation memory/context","properties":{"kind":{"type":"string","enum":["off"]}},"required":["kind"]},"MemoryAuto":{"type":"object","description":"Automatic context management","properties":{"kind":{"type":"string","enum":["auto"]},"context_length":{"type":"integer","description":"Maximum number of messages to retain in context"},"memory_id":{"type":"string","description":"Identifier for persistent memory across agent invocations"}},"required":["kind"]},"MemoryMessage":{"type":"object","description":"A single message in conversation history","properties":{"role":{"type":"string","enum":["user","assistant","system"]},"content":{"type":"string"}},"required":["role","content"]},"MemoryManual":{"type":"object","description":"Explicit message history","properties":{"kind":{"type":"string","enum":["manual"]},"messages":{"type":"array","items":{"$ref":"#/components/schemas/MemoryMessage"}}},"required":["kind","messages"]},"MemoryConfig":{"description":"Conversation memory configuration","oneOf":[{"$ref":"#/components/schemas/MemoryOff"},{"$ref":"#/components/schemas/MemoryAuto"},{"$ref":"#/components/schemas/MemoryManual"}],"discriminator":{"propertyName":"kind","mapping":{"off":"#/components/schemas/MemoryOff","auto":"#/components/schemas/MemoryAuto","manual":"#/components/schemas/MemoryManual"}}},"StaticMemoryTransform":{"type":"object","description":"Static memory configuration passed directly to the AI agent","properties":{"value":{"$ref":"#/components/schemas/MemoryConfig"},"type":{"type":"string","enum":["static"]}},"required":["type","value"]},"MemoryTransform":{"description":"Memory configuration - can be static (MemoryConfig), JavaScript expression, or AI-determined","oneOf":[{"$ref":"#/components/schemas/StaticMemoryTransform"},{"$ref":"#/components/schemas/JavascriptTransform"},{"$ref":"#/components/schemas/AiTransform"}],"discriminator":{"propertyName":"type","mapping":{"static":"#/components/schemas/StaticMemoryTransform","javascript":"#/components/schemas/JavascriptTransform","ai":"#/components/schemas/AiTransform"}}},"FlowModuleValue":{"description":"The actual implementation of a flow step. Can be a script (inline or referenced), subflow, loop, branch, or special module type","oneOf":[{"$ref":"#/components/schemas/RawScript"},{"$ref":"#/components/schemas/PathScript"},{"$ref":"#/components/schemas/PathFlow"},{"$ref":"#/components/schemas/ForloopFlow"},{"$ref":"#/components/schemas/WhileloopFlow"},{"$ref":"#/components/schemas/BranchOne"},{"$ref":"#/components/schemas/BranchAll"},{"$ref":"#/components/schemas/Identity"},{"$ref":"#/components/schemas/AiAgent"}],"discriminator":{"propertyName":"type","mapping":{"rawscript":"#/components/schemas/RawScript","script":"#/components/schemas/PathScript","flow":"#/components/schemas/PathFlow","forloopflow":"#/components/schemas/ForloopFlow","whileloopflow":"#/components/schemas/WhileloopFlow","branchone":"#/components/schemas/BranchOne","branchall":"#/components/schemas/BranchAll","identity":"#/components/schemas/Identity","aiagent":"#/components/schemas/AiAgent"}}},"RawScript":{"type":"object","description":"Inline script with code defined directly in the flow. Use 'bun' as default language if unspecified. The script receives arguments from input_transforms","properties":{"input_transforms":{"type":"object","description":"Map of parameter names to their values (static or JavaScript expressions). These become the script's input arguments","additionalProperties":{"$ref":"#/components/schemas/InputTransform"}},"content":{"type":"string","description":"The script source code. Should export a 'main' function"},"language":{"type":"string","description":"Programming language for this script","enum":["deno","bun","python3","go","bash","powershell","postgresql","mysql","bigquery","snowflake","mssql","oracledb","graphql","nativets","php","rust","ansible","csharp","nu","java","ruby","rlang","duckdb"]},"path":{"type":"string","description":"Optional path for saving this script"},"lock":{"type":"string","description":"Lock file content for dependencies"},"type":{"type":"string","enum":["rawscript"]},"tag":{"type":"string","description":"Worker group tag for execution routing"},"concurrent_limit":{"type":"number","description":"Maximum concurrent executions of this script"},"concurrency_time_window_s":{"type":"number","description":"Time window for concurrent_limit"},"custom_concurrency_key":{"type":"string","description":"Custom key for grouping concurrent executions"},"is_trigger":{"type":"boolean","description":"If true, this script is a trigger that can start the flow"},"assets":{"type":"array","description":"External resources this script accesses (S3 objects, resources, etc.)","items":{"type":"object","required":["path","kind"],"properties":{"path":{"type":"string","description":"Path to the asset"},"kind":{"type":"string","description":"Type of asset","enum":["s3object","resource","ducklake","datatable","volume"]},"access_type":{"type":"string","nullable":true,"description":"Access level for this asset","enum":["r","w","rw"]},"alt_access_type":{"type":"string","nullable":true,"description":"Alternative access level","enum":["r","w","rw"]}}}}},"required":["type","content","language","input_transforms"]},"PathScript":{"type":"object","description":"Reference to an existing script by path. Use this when calling a previously saved script instead of writing inline code","properties":{"input_transforms":{"type":"object","description":"Map of parameter names to their values (static or JavaScript expressions). These become the script's input arguments","additionalProperties":{"$ref":"#/components/schemas/InputTransform"}},"path":{"type":"string","description":"Path to the script in the workspace (e.g., 'f/scripts/send_email')"},"hash":{"type":"string","description":"Optional specific version hash of the script to use"},"type":{"type":"string","enum":["script"]},"tag_override":{"type":"string","description":"Override the script's default worker group tag"},"is_trigger":{"type":"boolean","description":"If true, this script is a trigger that can start the flow"}},"required":["type","path","input_transforms"]},"PathFlow":{"type":"object","description":"Reference to an existing flow by path. Use this to call another flow as a subflow","properties":{"input_transforms":{"type":"object","description":"Map of parameter names to their values (static or JavaScript expressions). These become the subflow's input arguments","additionalProperties":{"$ref":"#/components/schemas/InputTransform"}},"path":{"type":"string","description":"Path to the flow in the workspace (e.g., 'f/flows/process_user')"},"type":{"type":"string","enum":["flow"]}},"required":["type","path","input_transforms"]},"ForloopFlow":{"type":"object","description":"Executes nested modules in a loop over an iterator. Inside the loop, use 'flow_input.iter.value' to access the current iteration value, and 'flow_input.iter.index' for the index. Supports parallel execution for better performance on I/O-bound operations","properties":{"modules":{"type":"array","description":"Steps to execute for each iteration. These can reference the iteration value via 'flow_input.iter.value'","items":{"$ref":"#/components/schemas/FlowModule"}},"iterator":{"description":"JavaScript expression that returns an array to iterate over. Can reference 'results.step_id' or 'flow_input'","$ref":"#/components/schemas/InputTransform"},"skip_failures":{"type":"boolean","description":"If true, iteration failures don't stop the loop. Failed iterations return null"},"type":{"type":"string","enum":["forloopflow"]},"parallel":{"type":"boolean","description":"If true, iterations run concurrently (faster for I/O-bound operations). Use with parallelism to control concurrency"},"parallelism":{"description":"Maximum number of concurrent iterations when parallel=true. Limits resource usage. Can be static number or expression","$ref":"#/components/schemas/InputTransform"},"squash":{"type":"boolean"}},"required":["modules","iterator","skip_failures","type"]},"WhileloopFlow":{"type":"object","description":"Executes nested modules repeatedly while a condition is true. The loop checks the condition after each iteration. Use stop_after_if on modules to control loop termination","properties":{"modules":{"type":"array","description":"Steps to execute in each iteration. Use stop_after_if to control when the loop ends","items":{"$ref":"#/components/schemas/FlowModule"}},"skip_failures":{"type":"boolean","description":"If true, iteration failures don't stop the loop. Failed iterations return null"},"type":{"type":"string","enum":["whileloopflow"]},"parallel":{"type":"boolean","description":"If true, iterations run concurrently (use with caution in while loops)"},"parallelism":{"description":"Maximum number of concurrent iterations when parallel=true","$ref":"#/components/schemas/InputTransform"},"squash":{"type":"boolean"}},"required":["modules","skip_failures","type"]},"BranchOne":{"type":"object","description":"Conditional branching where only the first matching branch executes. Branches are evaluated in order, and the first one with a true expression runs. If no branches match, the default branch executes","properties":{"branches":{"type":"array","description":"Array of branches to evaluate in order. The first branch with expr evaluating to true executes","items":{"type":"object","properties":{"summary":{"type":"string","description":"Short description of this branch condition"},"expr":{"type":"string","description":"JavaScript expression that returns boolean. Can use 'results.step_id' or 'flow_input'. First true expr wins"},"modules":{"type":"array","description":"Steps to execute if this branch's expr is true","items":{"$ref":"#/components/schemas/FlowModule"}}},"required":["modules","expr"]}},"default":{"type":"array","description":"Steps to execute if no branch expressions match","items":{"$ref":"#/components/schemas/FlowModule"}},"type":{"type":"string","enum":["branchone"]}},"required":["branches","default","type"]},"BranchAll":{"type":"object","description":"Parallel branching where all branches execute simultaneously. Unlike BranchOne, all branches run regardless of conditions. Useful for executing independent tasks concurrently","properties":{"branches":{"type":"array","description":"Array of branches that all execute (either in parallel or sequentially)","items":{"type":"object","properties":{"summary":{"type":"string","description":"Short description of this branch's purpose"},"skip_failure":{"type":"boolean","description":"If true, failure in this branch doesn't fail the entire flow"},"modules":{"type":"array","description":"Steps to execute in this branch","items":{"$ref":"#/components/schemas/FlowModule"}}},"required":["modules"]}},"type":{"type":"string","enum":["branchall"]},"parallel":{"type":"boolean","description":"If true, all branches execute concurrently. If false, they execute sequentially"}},"required":["branches","type"]},"AgentTool":{"type":"object","description":"A tool available to an AI agent. Can be a flow module or an external MCP (Model Context Protocol) tool","properties":{"id":{"type":"string","description":"Unique identifier for this tool. Cannot contain spaces - use underscores instead (e.g., 'get_user_data' not 'get user data')"},"summary":{"type":"string","description":"Short description of what this tool does (shown to the AI)"},"value":{"$ref":"#/components/schemas/ToolValue"}},"required":["id","value"]},"ToolValue":{"description":"The implementation of a tool. Can be a flow module (script/flow) or an MCP tool reference","oneOf":[{"$ref":"#/components/schemas/FlowModuleTool"},{"$ref":"#/components/schemas/McpToolValue"},{"$ref":"#/components/schemas/WebsearchToolValue"}],"discriminator":{"propertyName":"tool_type","mapping":{"flowmodule":"#/components/schemas/FlowModuleTool","mcp":"#/components/schemas/McpToolValue","websearch":"#/components/schemas/WebsearchToolValue"}}},"FlowModuleTool":{"description":"A tool implemented as a flow module (script, flow, etc.). The AI can call this like any other flow module","allOf":[{"type":"object","properties":{"tool_type":{"type":"string","enum":["flowmodule"]}},"required":["tool_type"]},{"$ref":"#/components/schemas/FlowModuleValue"}]},"WebsearchToolValue":{"type":"object","description":"A tool implemented as a websearch tool. The AI can call this like any other websearch tool","properties":{"tool_type":{"type":"string","enum":["websearch"]}},"required":["tool_type"]},"McpToolValue":{"type":"object","description":"Reference to an external MCP (Model Context Protocol) tool. The AI can call tools from MCP servers","properties":{"tool_type":{"type":"string","enum":["mcp"]},"resource_path":{"type":"string","description":"Path to the MCP resource/server configuration"},"include_tools":{"type":"array","description":"Whitelist of specific tools to include from this MCP server","items":{"type":"string"}},"exclude_tools":{"type":"array","description":"Blacklist of tools to exclude from this MCP server","items":{"type":"string"}}},"required":["tool_type","resource_path"]},"AiAgent":{"type":"object","description":"AI agent step that can use tools to accomplish tasks. The agent receives inputs and can call any of its configured tools to complete the task","properties":{"input_transforms":{"type":"object","description":"Input parameters for the AI agent mapped to their values","properties":{"provider":{"$ref":"#/components/schemas/ProviderTransform"},"output_type":{"allOf":[{"$ref":"#/components/schemas/InputTransform"}],"description":"Output format type.\nValid values: 'text' (default) - plain text response, 'image' - image generation\n"},"user_message":{"allOf":[{"$ref":"#/components/schemas/InputTransform"}],"description":"The user's prompt/message to the AI agent. Supports variable interpolation with flow.input syntax."},"system_prompt":{"allOf":[{"$ref":"#/components/schemas/InputTransform"}],"description":"System instructions that guide the AI's behavior, persona, and response style. Optional."},"streaming":{"allOf":[{"$ref":"#/components/schemas/InputTransform"}],"description":"Boolean. If true, stream the AI response incrementally.\nStreaming events include: token_delta, tool_call, tool_call_arguments, tool_execution, tool_result\n"},"memory":{"$ref":"#/components/schemas/MemoryTransform"},"output_schema":{"allOf":[{"$ref":"#/components/schemas/InputTransform"}],"description":"JSON Schema object defining structured output format. Used when you need the AI to return data in a specific shape.\nSupports standard JSON Schema properties: type, properties, required, items, enum, pattern, minLength, maxLength, minimum, maximum, etc.\nExample: { type: 'object', properties: { name: { type: 'string' }, age: { type: 'integer' } }, required: ['name'] }\n"},"user_attachments":{"allOf":[{"$ref":"#/components/schemas/InputTransform"}],"description":"Array of file references (images or PDFs) for the AI agent.\nFormat: Array<{ bucket: string, key: string }> - S3 object references\nExample: [{ bucket: 'my-bucket', key: 'documents/report.pdf' }]\n"},"max_completion_tokens":{"allOf":[{"$ref":"#/components/schemas/InputTransform"}],"description":"Integer. Maximum number of tokens the AI will generate in its response.\nRange: 1 to 4,294,967,295. Typical values: 256-4096 for most use cases.\n"},"temperature":{"allOf":[{"$ref":"#/components/schemas/InputTransform"}],"description":"Float. Controls randomness/creativity of responses.\nRange: 0.0 to 2.0 (provider-dependent)\n- 0.0 = deterministic, focused responses\n- 0.7 = balanced (common default)\n- 1.0+ = more creative/random\n"},"max_iterations":{"allOf":[{"$ref":"#/components/schemas/InputTransform"}],"description":"Number. Limits how many times the agent can loop through reasoning and tool use.\nRange: 1-1000.\n"}},"required":["provider","user_message","output_type"]},"tools":{"type":"array","description":"Array of tools the agent can use. The agent decides which tools to call based on the task","items":{"$ref":"#/components/schemas/AgentTool"}},"type":{"type":"string","enum":["aiagent"]},"omit_output_from_conversation":{"type":"boolean","default":false,"description":"If true, this AI agent step does not persist its assistant or tool messages to the flow conversation when chat mode is enabled."},"parallel":{"type":"boolean","description":"If true, the agent can execute multiple tool calls in parallel"}},"required":["tools","type","input_transforms"]},"Identity":{"type":"object","description":"Pass-through module that returns its input unchanged. Useful for flow structure or as a placeholder","properties":{"type":{"type":"string","enum":["identity"]},"flow":{"type":"boolean","description":"If true, marks this as a flow identity (special handling)"}},"required":["type"]},"FlowStatus":{"type":"object","properties":{"step":{"type":"integer"},"modules":{"type":"array","items":{"$ref":"#/components/schemas/FlowStatusModule"}},"user_states":{"additionalProperties":true},"preprocessor_module":{"allOf":[{"$ref":"#/components/schemas/FlowStatusModule"}]},"failure_module":{"allOf":[{"$ref":"#/components/schemas/FlowStatusModule"},{"type":"object","properties":{"parent_module":{"type":"string"}}}]},"retry":{"type":"object","properties":{"fail_count":{"type":"integer"},"failed_jobs":{"type":"array","items":{"type":"string","format":"uuid"}}}}},"required":["step","modules","failure_module"]},"FlowStatusModule":{"type":"object","properties":{"type":{"type":"string","enum":["WaitingForPriorSteps","WaitingForEvents","WaitingForExecutor","InProgress","Success","Failure"]},"id":{"type":"string"},"job":{"type":"string","format":"uuid"},"count":{"type":"integer"},"progress":{"type":"integer"},"iterator":{"type":"object","properties":{"index":{"type":"integer"},"itered":{"type":"array","items":{}},"itered_len":{"type":"integer"},"args":{}}},"flow_jobs":{"type":"array","items":{"type":"string"}},"flow_jobs_success":{"type":"array","items":{"type":"boolean"}},"flow_jobs_duration":{"type":"object","properties":{"started_at":{"type":"array","items":{"type":"string"}},"duration_ms":{"type":"array","items":{"type":"integer"}}}},"branch_chosen":{"type":"object","properties":{"type":{"type":"string","enum":["branch","default"]},"branch":{"type":"integer"}},"required":["type"]},"branchall":{"type":"object","properties":{"branch":{"type":"integer"},"len":{"type":"integer"}},"required":["branch","len"]},"approvers":{"type":"array","items":{"type":"object","properties":{"resume_id":{"type":"integer"},"approver":{"type":"string"}},"required":["resume_id","approver"]}},"failed_retries":{"type":"array","items":{"type":"string","format":"uuid"}},"skipped":{"type":"boolean"},"agent_actions":{"type":"array","items":{"type":"object","oneOf":[{"type":"object","properties":{"job_id":{"type":"string","format":"uuid"},"function_name":{"type":"string"},"type":{"type":"string","enum":["tool_call"]},"module_id":{"type":"string"}},"required":["job_id","function_name","type","module_id"]},{"type":"object","properties":{"call_id":{"type":"string","format":"uuid"},"function_name":{"type":"string"},"resource_path":{"type":"string"},"type":{"type":"string","enum":["mcp_tool_call"]},"arguments":{"type":"object"}},"required":["call_id","function_name","resource_path","type"]},{"type":"object","properties":{"type":{"type":"string","enum":["web_search"]}},"required":["type"]},{"type":"object","properties":{"type":{"type":"string","enum":["message"]}},"required":["content","type"]}]}},"agent_actions_success":{"type":"array","items":{"type":"boolean"}}},"required":["type"]}}
\ No newline at end of file
+{"OpenFlow":{"type":"object","description":"Top-level flow definition containing metadata, configuration, and the flow structure","properties":{"summary":{"type":"string","description":"Short description of what this flow does"},"description":{"type":"string","description":"Detailed documentation for this flow"},"value":{"$ref":"#/components/schemas/FlowValue"},"schema":{"type":"object","description":"JSON Schema for flow inputs. Use this to define input parameters, their types, defaults, and validation. For resource inputs, set type to 'object' and format to 'resource-<type>' (e.g., 'resource-stripe')"},"on_behalf_of_email":{"type":"string","description":"The flow will be run with the permissions of the user with this email."}},"required":["summary","value"]},"FlowValue":{"type":"object","description":"The flow structure containing modules and optional preprocessor/failure handlers","properties":{"modules":{"type":"array","description":"Array of steps that execute in sequence. Each step can be a script, subflow, loop, or branch","items":{"$ref":"#/components/schemas/FlowModule"}},"failure_module":{"description":"Special module that executes when the flow fails. Receives error object with message, name, stack, and step_id. Must have id 'failure'. Only supports script/rawscript types","$ref":"#/components/schemas/FlowModule"},"preprocessor_module":{"description":"Special module that runs before the first step on external triggers. Must have id 'preprocessor'. Only supports script/rawscript types. Cannot reference other step results","$ref":"#/components/schemas/FlowModule"},"same_worker":{"type":"boolean","description":"If true, all steps run on the same worker for better performance"},"preserve_step_tags":{"type":"boolean","description":"If true and the flow runs on a custom worker tag, steps that declare their own non-empty tag run on it instead of inheriting the flow tag. Steps without their own tag still inherit the flow tag."},"concurrent_limit":{"type":"number","description":"Maximum number of concurrent executions of this flow"},"concurrency_key":{"type":"string","description":"Expression to group concurrent executions (e.g., by user ID)"},"concurrency_time_window_s":{"type":"number","description":"Time window in seconds for concurrent_limit"},"debounce_delay_s":{"type":"integer","description":"Delay in seconds to debounce flow executions"},"debounce_key":{"type":"string","description":"Expression to group debounced executions"},"debounce_args_to_accumulate":{"type":"array","description":"Arguments to accumulate across debounced executions","items":{"type":"string"}},"max_total_debouncing_time":{"type":"integer","description":"Maximum total time in seconds that a job can be debounced"},"max_total_debounces_amount":{"type":"integer","description":"Maximum number of times a job can be debounced"},"skip_expr":{"type":"string","description":"JavaScript expression to conditionally skip the entire flow"},"cache_ttl":{"type":"number","description":"Cache duration in seconds for flow results"},"cache_ignore_s3_path":{"type":"boolean"},"delete_after_secs":{"type":"integer","description":"If set, delete the flow job's args, result and logs after this many seconds following job completion"},"flow_env":{"type":"object","description":"Environment variables available to all steps. Values can be strings, JSON values, or special references: '$var:path' (workspace variable) or '$res:path' (resource).","additionalProperties":{}},"priority":{"type":"number","description":"Execution priority (higher numbers run first)"},"early_return":{"type":"string","description":"JavaScript expression to return early from the flow"},"chat_input_enabled":{"type":"boolean","description":"Whether this flow accepts chat-style input"},"notes":{"type":"array","description":"Sticky notes attached to the flow","items":{"$ref":"#/components/schemas/FlowNote"}},"groups":{"type":"array","description":"Semantic groups of modules for organizational purposes","items":{"$ref":"#/components/schemas/FlowGroup"}}},"required":["modules"]},"Retry":{"type":"object","description":"Retry configuration for failed module executions","properties":{"constant":{"type":"object","description":"Retry with constant delay between attempts","properties":{"attempts":{"type":"integer","description":"Number of retry attempts"},"seconds":{"type":"integer","description":"Seconds to wait between retries"}}},"exponential":{"type":"object","description":"Retry with exponential backoff (delay doubles each time)","properties":{"attempts":{"type":"integer","description":"Number of retry attempts"},"multiplier":{"type":"integer","description":"Multiplier for exponential backoff"},"seconds":{"type":"integer","minimum":1,"description":"Initial delay in seconds"},"random_factor":{"type":"integer","minimum":0,"maximum":100,"description":"Random jitter percentage (0-100) to avoid thundering herd"}}},"retry_if":{"$ref":"#/components/schemas/RetryIf"}}},"FlowNote":{"type":"object","description":"A sticky note attached to a flow for documentation and annotation","properties":{"id":{"type":"string","description":"Unique identifier for the note"},"text":{"type":"string","description":"Content of the note"},"position":{"type":"object","description":"Position of the note in the flow editor","properties":{"x":{"type":"number","description":"X coordinate"},"y":{"type":"number","description":"Y coordinate"}},"required":["x","y"]},"size":{"type":"object","description":"Size of the note in the flow editor","properties":{"width":{"type":"number","description":"Width in pixels"},"height":{"type":"number","description":"Height in pixels"}},"required":["width","height"]},"color":{"type":"string","description":"Color of the note (e.g., \"yellow\", \"#ffff00\")"},"type":{"type":"string","enum":["free","group"],"description":"Type of note - 'free' for standalone notes, 'group' for notes that group other nodes"},"locked":{"type":"boolean","default":false,"description":"Whether the note is locked and cannot be edited or moved"},"contained_node_ids":{"type":"array","items":{"type":"string"},"description":"For group notes, the IDs of nodes contained within this group"}},"required":["id","text","color","type"]},"FlowGroup":{"type":"object","description":"A semantic group of flow modules for organizational purposes. Does not affect execution \u2014 modules remain in their original position in the flow. Groups provide naming and collapsibility in the editor. Members are computed dynamically from all nodes on paths between start_id and end_id.","properties":{"summary":{"type":"string","description":"Display name for this group"},"note":{"type":"string","description":"Markdown note shown below the group header"},"autocollapse":{"type":"boolean","default":false,"description":"If true, this group is collapsed by default in the flow editor. UI hint only."},"start_id":{"type":"string","description":"ID of the first flow module in this group (topological entry point)"},"end_id":{"type":"string","description":"ID of the last flow module in this group (topological exit point)"},"color":{"type":"string","description":"Color for the group in the flow editor"}},"required":["start_id","end_id"]},"RetryIf":{"type":"object","description":"Conditional retry based on error or result","properties":{"expr":{"type":"string","description":"JavaScript expression that returns true to retry. Has access to 'result' and 'error' variables"}},"required":["expr"]},"StopAfterIf":{"type":"object","description":"Early termination condition for a module","properties":{"skip_if_stopped":{"type":"boolean","description":"If true, following steps are skipped when this condition triggers"},"expr":{"type":"string","description":"JavaScript expression evaluated after the module runs. Can use 'result' (step's result) or 'flow_input'. Return true to stop"},"error_message":{"type":"string","nullable":true,"description":"Custom error message when stopping with an error. Mutually exclusive with skip_if_stopped. If set to a non-empty string, the flow stops with this error. If empty string, a default error message is used. If null or omitted, no error is raised."}},"required":["expr"]},"FlowModule":{"type":"object","description":"A single step in a flow. Can be a script, subflow, loop, or branch","properties":{"id":{"type":"string","description":"Unique identifier for this step. Used to reference results via 'results.step_id'. Must be a valid identifier (alphanumeric, underscore, hyphen)"},"value":{"$ref":"#/components/schemas/FlowModuleValue"},"stop_after_if":{"description":"Early termination condition evaluated after this step completes","$ref":"#/components/schemas/StopAfterIf"},"stop_after_all_iters_if":{"description":"For loops only - early termination condition evaluated after all iterations complete","$ref":"#/components/schemas/StopAfterIf"},"skip_if":{"type":"object","description":"Conditionally skip this step based on previous results or flow inputs","properties":{"expr":{"type":"string","description":"JavaScript expression that returns true to skip. Can use 'flow_input' or 'results.<step_id>'"}},"required":["expr"]},"sleep":{"description":"Delay before executing this step (in seconds or as expression)","$ref":"#/components/schemas/InputTransform"},"cache_ttl":{"type":"number","description":"Cache duration in seconds for this step's results"},"cache_ignore_s3_path":{"type":"boolean"},"timeout":{"description":"Maximum execution time in seconds (static value or expression)","$ref":"#/components/schemas/InputTransform"},"delete_after_secs":{"type":"integer","description":"If set, delete the step's args, result and logs after this many seconds following job completion"},"summary":{"type":"string","description":"Short description of what this step does"},"mock":{"type":"object","description":"Mock configuration for testing without executing the actual step","properties":{"enabled":{"type":"boolean","description":"If true, return mock value instead of executing"},"return_value":{"description":"Value to return when mocked"}}},"suspend":{"type":"object","description":"Configuration for approval/resume steps that wait for user input","properties":{"required_events":{"type":"integer","description":"Number of approvals required before continuing"},"timeout":{"type":"integer","description":"Timeout in seconds before auto-continuing or canceling"},"resume_form":{"type":"object","description":"Form schema for collecting input when resuming","properties":{"schema":{"type":"object","description":"JSON Schema for the resume form"}}},"user_auth_required":{"type":"boolean","description":"If true, only authenticated users can approve"},"user_groups_required":{"description":"Expression or list of groups that can approve","$ref":"#/components/schemas/InputTransform"},"self_approval_disabled":{"type":"boolean","description":"If true, the user who started the flow cannot approve"},"hide_cancel":{"type":"boolean","description":"If true, hide the cancel button on the approval form"},"continue_on_disapprove_timeout":{"type":"boolean","description":"If true, continue flow on timeout instead of canceling"}}},"priority":{"type":"number","description":"Execution priority for this step (higher numbers run first)"},"continue_on_error":{"type":"boolean","description":"If true, flow continues even if this step fails"},"retry":{"description":"Retry configuration if this step fails","$ref":"#/components/schemas/Retry"},"debouncing":{"description":"Debounce configuration for this step (EE only)","type":"object","properties":{"debounce_delay_s":{"type":"integer","description":"Delay in seconds to debounce this step's executions across flow runs"},"debounce_key":{"type":"string","description":"Expression to group debounced executions. Supports $workspace and $args[name]. Default: $workspace/flow/<flow_path>-<step_id>"},"debounce_args_to_accumulate":{"type":"array","description":"Array-type arguments to accumulate across debounced executions","items":{"type":"string"}},"max_total_debouncing_time":{"type":"integer","description":"Maximum total time in seconds before forced execution"},"max_total_debounces_amount":{"type":"integer","description":"Maximum number of debounces before forced execution"}}}},"required":["value","id"]},"InputTransform":{"description":"Maps input parameters for a step. Can be a static value or a JavaScript expression that references previous results or flow inputs","oneOf":[{"$ref":"#/components/schemas/StaticTransform"},{"$ref":"#/components/schemas/JavascriptTransform"},{"$ref":"#/components/schemas/AiTransform"}],"discriminator":{"propertyName":"type","mapping":{"static":"#/components/schemas/StaticTransform","javascript":"#/components/schemas/JavascriptTransform","ai":"#/components/schemas/AiTransform"}}},"StaticTransform":{"type":"object","description":"Static value passed directly to the step. Use for hardcoded values or resource references like '$res:path/to/resource'","properties":{"value":{"description":"The static value. For resources, use format '$res:path/to/resource'"},"type":{"type":"string","enum":["static"]}},"required":["type"]},"JavascriptTransform":{"type":"object","description":"JavaScript expression evaluated at runtime. Can reference previous step results via 'results.step_id' or flow inputs via 'flow_input.property'. Inside loops, use 'flow_input.iter.value' for the current iteration value","properties":{"expr":{"type":"string","description":"JavaScript expression returning the value. Available variables - results (object with all previous step results), flow_input (flow inputs), flow_input.iter (in loops)"},"type":{"type":"string","enum":["javascript"]}},"required":["expr","type"]},"AiTransform":{"type":"object","description":"Value resolved by the AI runtime for this input. The AI engine decides how to satisfy the parameter.","properties":{"type":{"type":"string","enum":["ai"]}},"required":["type"]},"AIProviderKind":{"type":"string","description":"Supported AI provider types","enum":["openai","azure_openai","anthropic","mistral","deepseek","googleai","groq","openrouter","togetherai","customai","aws_bedrock"]},"ProviderConfig":{"type":"object","description":"Complete AI provider configuration with resource reference and model selection","properties":{"kind":{"$ref":"#/components/schemas/AIProviderKind"},"resource":{"type":"string","description":"Resource reference in format '$res:{resource_path}' pointing to provider credentials"},"model":{"type":"string","description":"Model identifier (e.g., 'gpt-4', 'claude-3-opus-20240229', 'gemini-pro')"}},"required":["kind","resource","model"]},"StaticProviderTransform":{"type":"object","description":"Static provider configuration passed directly to the AI agent","properties":{"value":{"$ref":"#/components/schemas/ProviderConfig"},"type":{"type":"string","enum":["static"]}},"required":["type","value"]},"ProviderTransform":{"description":"Provider configuration - can be static (ProviderConfig), JavaScript expression, or AI-determined","oneOf":[{"$ref":"#/components/schemas/StaticProviderTransform"},{"$ref":"#/components/schemas/JavascriptTransform"},{"$ref":"#/components/schemas/AiTransform"}],"discriminator":{"propertyName":"type","mapping":{"static":"#/components/schemas/StaticProviderTransform","javascript":"#/components/schemas/JavascriptTransform","ai":"#/components/schemas/AiTransform"}}},"MemoryOff":{"type":"object","description":"No conversation memory/context","properties":{"kind":{"type":"string","enum":["off"]}},"required":["kind"]},"MemoryAuto":{"type":"object","description":"Automatic context management","properties":{"kind":{"type":"string","enum":["auto"]},"context_length":{"type":"integer","description":"Maximum number of messages to retain in context"},"memory_id":{"type":"string","description":"Identifier for persistent memory across agent invocations"}},"required":["kind"]},"MemoryMessage":{"type":"object","description":"A single message in conversation history","properties":{"role":{"type":"string","enum":["user","assistant","system"]},"content":{"type":"string"}},"required":["role","content"]},"MemoryManual":{"type":"object","description":"Explicit message history","properties":{"kind":{"type":"string","enum":["manual"]},"messages":{"type":"array","items":{"$ref":"#/components/schemas/MemoryMessage"}}},"required":["kind","messages"]},"MemoryConfig":{"description":"Conversation memory configuration","oneOf":[{"$ref":"#/components/schemas/MemoryOff"},{"$ref":"#/components/schemas/MemoryAuto"},{"$ref":"#/components/schemas/MemoryManual"}],"discriminator":{"propertyName":"kind","mapping":{"off":"#/components/schemas/MemoryOff","auto":"#/components/schemas/MemoryAuto","manual":"#/components/schemas/MemoryManual"}}},"StaticMemoryTransform":{"type":"object","description":"Static memory configuration passed directly to the AI agent","properties":{"value":{"$ref":"#/components/schemas/MemoryConfig"},"type":{"type":"string","enum":["static"]}},"required":["type","value"]},"MemoryTransform":{"description":"Memory configuration - can be static (MemoryConfig), JavaScript expression, or AI-determined","oneOf":[{"$ref":"#/components/schemas/StaticMemoryTransform"},{"$ref":"#/components/schemas/JavascriptTransform"},{"$ref":"#/components/schemas/AiTransform"}],"discriminator":{"propertyName":"type","mapping":{"static":"#/components/schemas/StaticMemoryTransform","javascript":"#/components/schemas/JavascriptTransform","ai":"#/components/schemas/AiTransform"}}},"FlowModuleValue":{"description":"The actual implementation of a flow step. Can be a script (inline or referenced), subflow, loop, branch, or special module type","oneOf":[{"$ref":"#/components/schemas/RawScript"},{"$ref":"#/components/schemas/PathScript"},{"$ref":"#/components/schemas/PathFlow"},{"$ref":"#/components/schemas/ForloopFlow"},{"$ref":"#/components/schemas/WhileloopFlow"},{"$ref":"#/components/schemas/BranchOne"},{"$ref":"#/components/schemas/BranchAll"},{"$ref":"#/components/schemas/Identity"},{"$ref":"#/components/schemas/AiAgent"}],"discriminator":{"propertyName":"type","mapping":{"rawscript":"#/components/schemas/RawScript","script":"#/components/schemas/PathScript","flow":"#/components/schemas/PathFlow","forloopflow":"#/components/schemas/ForloopFlow","whileloopflow":"#/components/schemas/WhileloopFlow","branchone":"#/components/schemas/BranchOne","branchall":"#/components/schemas/BranchAll","identity":"#/components/schemas/Identity","aiagent":"#/components/schemas/AiAgent"}}},"RawScript":{"type":"object","description":"Inline script with code defined directly in the flow. Use 'bun' as default language if unspecified. The script receives arguments from input_transforms","properties":{"input_transforms":{"type":"object","description":"Map of parameter names to their values (static or JavaScript expressions). These become the script's input arguments","additionalProperties":{"$ref":"#/components/schemas/InputTransform"}},"content":{"type":"string","description":"The script source code. Should export a 'main' function"},"language":{"type":"string","description":"Programming language for this script","enum":["deno","bun","python3","go","bash","powershell","postgresql","mysql","bigquery","snowflake","mssql","oracledb","graphql","nativets","php","rust","ansible","csharp","nu","java","ruby","rlang","duckdb"]},"path":{"type":"string","description":"Optional path for saving this script"},"lock":{"type":"string","description":"Lock file content for dependencies"},"type":{"type":"string","enum":["rawscript"]},"tag":{"type":"string","description":"Worker group tag for execution routing"},"concurrent_limit":{"type":"number","description":"Maximum concurrent executions of this script"},"concurrency_time_window_s":{"type":"number","description":"Time window for concurrent_limit"},"custom_concurrency_key":{"type":"string","description":"Custom key for grouping concurrent executions"},"is_trigger":{"type":"boolean","description":"If true, this script is a trigger that can start the flow"},"assets":{"type":"array","description":"External resources this script accesses (S3 objects, resources, etc.)","items":{"type":"object","required":["path","kind"],"properties":{"path":{"type":"string","description":"Path to the asset"},"kind":{"type":"string","description":"Type of asset","enum":["s3object","resource","ducklake","datatable","volume"]},"access_type":{"type":"string","nullable":true,"description":"Access level for this asset","enum":["r","w","rw"]},"alt_access_type":{"type":"string","nullable":true,"description":"Alternative access level","enum":["r","w","rw"]}}}}},"required":["type","content","language","input_transforms"]},"PathScript":{"type":"object","description":"Reference to an existing script by path. Use this when calling a previously saved script instead of writing inline code","properties":{"input_transforms":{"type":"object","description":"Map of parameter names to their values (static or JavaScript expressions). These become the script's input arguments","additionalProperties":{"$ref":"#/components/schemas/InputTransform"}},"path":{"type":"string","description":"Path to the script in the workspace (e.g., 'f/scripts/send_email')"},"hash":{"type":"string","description":"Optional specific version hash of the script to use"},"type":{"type":"string","enum":["script"]},"tag_override":{"type":"string","description":"Override the script's default worker group tag"},"is_trigger":{"type":"boolean","description":"If true, this script is a trigger that can start the flow"}},"required":["type","path","input_transforms"]},"PathFlow":{"type":"object","description":"Reference to an existing flow by path. Use this to call another flow as a subflow","properties":{"input_transforms":{"type":"object","description":"Map of parameter names to their values (static or JavaScript expressions). These become the subflow's input arguments","additionalProperties":{"$ref":"#/components/schemas/InputTransform"}},"path":{"type":"string","description":"Path to the flow in the workspace (e.g., 'f/flows/process_user')"},"type":{"type":"string","enum":["flow"]}},"required":["type","path","input_transforms"]},"ForloopFlow":{"type":"object","description":"Executes nested modules in a loop over an iterator. Inside the loop, use 'flow_input.iter.value' to access the current iteration value, and 'flow_input.iter.index' for the index. Supports parallel execution for better performance on I/O-bound operations","properties":{"modules":{"type":"array","description":"Steps to execute for each iteration. These can reference the iteration value via 'flow_input.iter.value'","items":{"$ref":"#/components/schemas/FlowModule"}},"iterator":{"description":"JavaScript expression that returns an array to iterate over. Can reference 'results.step_id' or 'flow_input'","$ref":"#/components/schemas/InputTransform"},"skip_failures":{"type":"boolean","description":"If true, iteration failures don't stop the loop. Failed iterations return null"},"type":{"type":"string","enum":["forloopflow"]},"parallel":{"type":"boolean","description":"If true, iterations run concurrently (faster for I/O-bound operations). Use with parallelism to control concurrency"},"parallelism":{"description":"Maximum number of concurrent iterations when parallel=true. Limits resource usage. Can be static number or expression","$ref":"#/components/schemas/InputTransform"},"squash":{"type":"boolean"}},"required":["modules","iterator","skip_failures","type"]},"WhileloopFlow":{"type":"object","description":"Executes nested modules repeatedly while a condition is true. The loop checks the condition after each iteration. Use stop_after_if on modules to control loop termination","properties":{"modules":{"type":"array","description":"Steps to execute in each iteration. Use stop_after_if to control when the loop ends","items":{"$ref":"#/components/schemas/FlowModule"}},"skip_failures":{"type":"boolean","description":"If true, iteration failures don't stop the loop. Failed iterations return null"},"type":{"type":"string","enum":["whileloopflow"]},"parallel":{"type":"boolean","description":"If true, iterations run concurrently (use with caution in while loops)"},"parallelism":{"description":"Maximum number of concurrent iterations when parallel=true","$ref":"#/components/schemas/InputTransform"},"squash":{"type":"boolean"}},"required":["modules","skip_failures","type"]},"BranchOne":{"type":"object","description":"Conditional branching where only the first matching branch executes. Branches are evaluated in order, and the first one with a true expression runs. If no branches match, the default branch executes","properties":{"branches":{"type":"array","description":"Array of branches to evaluate in order. The first branch with expr evaluating to true executes","items":{"type":"object","properties":{"summary":{"type":"string","description":"Short description of this branch condition"},"expr":{"type":"string","description":"JavaScript expression that returns boolean. Can use 'results.step_id' or 'flow_input'. First true expr wins"},"modules":{"type":"array","description":"Steps to execute if this branch's expr is true","items":{"$ref":"#/components/schemas/FlowModule"}}},"required":["modules","expr"]}},"default":{"type":"array","description":"Steps to execute if no branch expressions match","items":{"$ref":"#/components/schemas/FlowModule"}},"type":{"type":"string","enum":["branchone"]}},"required":["branches","default","type"]},"BranchAll":{"type":"object","description":"Parallel branching where all branches execute simultaneously. Unlike BranchOne, all branches run regardless of conditions. Useful for executing independent tasks concurrently","properties":{"branches":{"type":"array","description":"Array of branches that all execute (either in parallel or sequentially)","items":{"type":"object","properties":{"summary":{"type":"string","description":"Short description of this branch's purpose"},"skip_failure":{"type":"boolean","description":"If true, failure in this branch doesn't fail the entire flow"},"modules":{"type":"array","description":"Steps to execute in this branch","items":{"$ref":"#/components/schemas/FlowModule"}}},"required":["modules"]}},"type":{"type":"string","enum":["branchall"]},"parallel":{"type":"boolean","description":"If true, all branches execute concurrently. If false, they execute sequentially"}},"required":["branches","type"]},"AgentTool":{"type":"object","description":"A tool available to an AI agent. Can be a flow module or an external MCP (Model Context Protocol) tool","properties":{"id":{"type":"string","description":"Unique identifier for this tool. Cannot contain spaces - use underscores instead (e.g., 'get_user_data' not 'get user data')"},"summary":{"type":"string","description":"Short description of what this tool does (shown to the AI)"},"value":{"$ref":"#/components/schemas/ToolValue"}},"required":["id","value"]},"ToolValue":{"description":"The implementation of a tool. Can be a flow module (script/flow) or an MCP tool reference","oneOf":[{"$ref":"#/components/schemas/FlowModuleTool"},{"$ref":"#/components/schemas/McpToolValue"},{"$ref":"#/components/schemas/WebsearchToolValue"}],"discriminator":{"propertyName":"tool_type","mapping":{"flowmodule":"#/components/schemas/FlowModuleTool","mcp":"#/components/schemas/McpToolValue","websearch":"#/components/schemas/WebsearchToolValue"}}},"FlowModuleTool":{"description":"A tool implemented as a flow module (script, flow, etc.). The AI can call this like any other flow module","allOf":[{"type":"object","properties":{"tool_type":{"type":"string","enum":["flowmodule"]}},"required":["tool_type"]},{"$ref":"#/components/schemas/FlowModuleValue"}]},"WebsearchToolValue":{"type":"object","description":"A tool implemented as a websearch tool. The AI can call this like any other websearch tool","properties":{"tool_type":{"type":"string","enum":["websearch"]}},"required":["tool_type"]},"McpToolValue":{"type":"object","description":"Reference to an external MCP (Model Context Protocol) tool. The AI can call tools from MCP servers","properties":{"tool_type":{"type":"string","enum":["mcp"]},"resource_path":{"type":"string","description":"Path to the MCP resource/server configuration"},"include_tools":{"type":"array","description":"Whitelist of specific tools to include from this MCP server","items":{"type":"string"}},"exclude_tools":{"type":"array","description":"Blacklist of tools to exclude from this MCP server","items":{"type":"string"}}},"required":["tool_type","resource_path"]},"AiAgent":{"type":"object","description":"AI agent step that can use tools to accomplish tasks. The agent receives inputs and can call any of its configured tools to complete the task","properties":{"input_transforms":{"type":"object","description":"Input parameters for the AI agent mapped to their values","properties":{"provider":{"$ref":"#/components/schemas/ProviderTransform"},"output_type":{"allOf":[{"$ref":"#/components/schemas/InputTransform"}],"description":"Output format type.\nValid values: 'text' (default) - plain text response, 'image' - image generation\n"},"user_message":{"allOf":[{"$ref":"#/components/schemas/InputTransform"}],"description":"The user's prompt/message to the AI agent. Supports variable interpolation with flow.input syntax."},"system_prompt":{"allOf":[{"$ref":"#/components/schemas/InputTransform"}],"description":"System instructions that guide the AI's behavior, persona, and response style. Optional."},"streaming":{"allOf":[{"$ref":"#/components/schemas/InputTransform"}],"description":"Boolean. If true, stream the AI response incrementally.\nStreaming events include: token_delta, tool_call, tool_call_arguments, tool_execution, tool_result\n"},"memory":{"$ref":"#/components/schemas/MemoryTransform"},"output_schema":{"allOf":[{"$ref":"#/components/schemas/InputTransform"}],"description":"JSON Schema object defining structured output format. Used when you need the AI to return data in a specific shape.\nSupports standard JSON Schema properties: type, properties, required, items, enum, pattern, minLength, maxLength, minimum, maximum, etc.\nExample: { type: 'object', properties: { name: { type: 'string' }, age: { type: 'integer' } }, required: ['name'] }\n"},"user_attachments":{"allOf":[{"$ref":"#/components/schemas/InputTransform"}],"description":"Array of file references (images or PDFs) for the AI agent.\nFormat: Array<{ bucket: string, key: string }> - S3 object references\nExample: [{ bucket: 'my-bucket', key: 'documents/report.pdf' }]\n"},"max_completion_tokens":{"allOf":[{"$ref":"#/components/schemas/InputTransform"}],"description":"Integer. Maximum number of tokens the AI will generate in its response.\nRange: 1 to 4,294,967,295. Typical values: 256-4096 for most use cases.\n"},"temperature":{"allOf":[{"$ref":"#/components/schemas/InputTransform"}],"description":"Float. Controls randomness/creativity of responses.\nRange: 0.0 to 2.0 (provider-dependent)\n- 0.0 = deterministic, focused responses\n- 0.7 = balanced (common default)\n- 1.0+ = more creative/random\n"},"max_iterations":{"allOf":[{"$ref":"#/components/schemas/InputTransform"}],"description":"Number. Limits how many times the agent can loop through reasoning and tool use.\nRange: 1-1000.\n"}},"required":["provider","user_message","output_type"]},"tools":{"type":"array","description":"Array of tools the agent can use. The agent decides which tools to call based on the task","items":{"$ref":"#/components/schemas/AgentTool"}},"type":{"type":"string","enum":["aiagent"]},"omit_output_from_conversation":{"type":"boolean","default":false,"description":"If true, this AI agent step does not persist its assistant or tool messages to the flow conversation when chat mode is enabled."},"parallel":{"type":"boolean","description":"If true, the agent can execute multiple tool calls in parallel"}},"required":["tools","type","input_transforms"]},"Identity":{"type":"object","description":"Pass-through module that returns its input unchanged. Useful for flow structure or as a placeholder","properties":{"type":{"type":"string","enum":["identity"]},"flow":{"type":"boolean","description":"If true, marks this as a flow identity (special handling)"}},"required":["type"]},"FlowStatus":{"type":"object","properties":{"step":{"type":"integer"},"modules":{"type":"array","items":{"$ref":"#/components/schemas/FlowStatusModule"}},"user_states":{"additionalProperties":true},"preprocessor_module":{"allOf":[{"$ref":"#/components/schemas/FlowStatusModule"}]},"failure_module":{"allOf":[{"$ref":"#/components/schemas/FlowStatusModule"},{"type":"object","properties":{"parent_module":{"type":"string"}}}]},"retry":{"type":"object","properties":{"fail_count":{"type":"integer"},"failed_jobs":{"type":"array","items":{"type":"string","format":"uuid"}}}}},"required":["step","modules","failure_module"]},"FlowStatusModule":{"type":"object","properties":{"type":{"type":"string","enum":["WaitingForPriorSteps","WaitingForEvents","WaitingForExecutor","InProgress","Success","Failure"]},"id":{"type":"string"},"job":{"type":"string","format":"uuid"},"count":{"type":"integer"},"progress":{"type":"integer"},"iterator":{"type":"object","properties":{"index":{"type":"integer"},"itered":{"type":"array","items":{}},"itered_len":{"type":"integer"},"args":{}}},"flow_jobs":{"type":"array","items":{"type":"string"}},"flow_jobs_success":{"type":"array","items":{"type":"boolean"}},"flow_jobs_duration":{"type":"object","properties":{"started_at":{"type":"array","items":{"type":"string"}},"duration_ms":{"type":"array","items":{"type":"integer"}}}},"branch_chosen":{"type":"object","properties":{"type":{"type":"string","enum":["branch","default"]},"branch":{"type":"integer"}},"required":["type"]},"branchall":{"type":"object","properties":{"branch":{"type":"integer"},"len":{"type":"integer"}},"required":["branch","len"]},"approvers":{"type":"array","items":{"type":"object","properties":{"resume_id":{"type":"integer"},"approver":{"type":"string"}},"required":["resume_id","approver"]}},"failed_retries":{"type":"array","items":{"type":"string","format":"uuid"}},"skipped":{"type":"boolean"},"agent_actions":{"type":"array","items":{"type":"object","oneOf":[{"type":"object","properties":{"job_id":{"type":"string","format":"uuid"},"function_name":{"type":"string"},"type":{"type":"string","enum":["tool_call"]},"module_id":{"type":"string"}},"required":["job_id","function_name","type","module_id"]},{"type":"object","properties":{"call_id":{"type":"string","format":"uuid"},"function_name":{"type":"string"},"resource_path":{"type":"string"},"type":{"type":"string","enum":["mcp_tool_call"]},"arguments":{"type":"object"}},"required":["call_id","function_name","resource_path","type"]},{"type":"object","properties":{"type":{"type":"string","enum":["web_search"]}},"required":["type"]},{"type":"object","properties":{"type":{"type":"string","enum":["message"]}},"required":["content","type"]}]}},"agent_actions_success":{"type":"array","items":{"type":"boolean"}}},"required":["type"]}}
\ No newline at end of file
diff --git a/system_prompts/auto-generated/index.d.ts b/system_prompts/auto-generated/index.d.ts
index 6018d7ef92..f7d8d632b4 100644
--- a/system_prompts/auto-generated/index.d.ts
+++ b/system_prompts/auto-generated/index.d.ts
@@ -3,5 +3,5 @@ export declare function getScriptPrompt(language: string): string;
 export declare function getFlowPrompt(): string;
 export declare function getResourcePrompt(): string;
 export declare function getRawAppPrompt(): string;
-export declare function getDatatableSdkReference(): string;
+export declare function getDatatableSdkReference(language?: string): string;
 export declare function getWorkflowAsCodePrompt(language?: string): string;
diff --git a/system_prompts/auto-generated/index.ts b/system_prompts/auto-generated/index.ts
index bbd90e1066..6ee3e20f4a 100644
--- a/system_prompts/auto-generated/index.ts
+++ b/system_prompts/auto-generated/index.ts
@@ -54,8 +54,22 @@ export function getRawAppPrompt(): string {
   return prompts.RAW_APP_BASE;
 }
 
-// Helper to get datatable SDK reference for app mode
-export function getDatatableSdkReference(): string {
+// Helper to get the datatable SQL SDK reference (wmill.datatable()).
+// Pass a language to get only that SDK; omit it to get both.
+export function getDatatableSdkReference(language?: string): string {
+  if (language == null) {
+    return [
+      prompts.DATATABLE_SDK_TYPESCRIPT,
+      prompts.DATATABLE_SDK_PYTHON
+    ].filter(Boolean).join('\n\n');
+  }
+  if (TS_SDK_LANGUAGES.includes(language)) {
+    return prompts.DATATABLE_SDK_TYPESCRIPT;
+  }
+  if (PY_SDK_LANGUAGES.includes(language)) {
+    return prompts.DATATABLE_SDK_PYTHON;
+  }
+  // Unknown language: return both rather than nothing.
   return [
     prompts.DATATABLE_SDK_TYPESCRIPT,
     prompts.DATATABLE_SDK_PYTHON
diff --git a/system_prompts/auto-generated/prompts.ts b/system_prompts/auto-generated/prompts.ts
index 9ce0d56e01..b0341495d3 100644
--- a/system_prompts/auto-generated/prompts.ts
+++ b/system_prompts/auto-generated/prompts.ts
@@ -2546,7 +2546,7 @@ class SqlQuery:
 
 export const OPENFLOW_SCHEMA = `## OpenFlow Schema
 
-{"OpenFlow":{"type":"object","description":"Top-level flow definition containing metadata, configuration, and the flow structure","properties":{"summary":{"type":"string","description":"Short description of what this flow does"},"description":{"type":"string","description":"Detailed documentation for this flow"},"value":{"$ref":"#/components/schemas/FlowValue"},"schema":{"type":"object","description":"JSON Schema for flow inputs. Use this to define input parameters, their types, defaults, and validation. For resource inputs, set type to 'object' and format to 'resource-<type>' (e.g., 'resource-stripe')"},"on_behalf_of_email":{"type":"string","description":"The flow will be run with the permissions of the user with this email."}},"required":["summary","value"]},"FlowValue":{"type":"object","description":"The flow structure containing modules and optional preprocessor/failure handlers","properties":{"modules":{"type":"array","description":"Array of steps that execute in sequence. Each step can be a script, subflow, loop, or branch","items":{"$ref":"#/components/schemas/FlowModule"}},"failure_module":{"description":"Special module that executes when the flow fails. Receives error object with message, name, stack, and step_id. Must have id 'failure'. Only supports script/rawscript types","$ref":"#/components/schemas/FlowModule"},"preprocessor_module":{"description":"Special module that runs before the first step on external triggers. Must have id 'preprocessor'. Only supports script/rawscript types. Cannot reference other step results","$ref":"#/components/schemas/FlowModule"},"same_worker":{"type":"boolean","description":"If true, all steps run on the same worker for better performance"},"concurrent_limit":{"type":"number","description":"Maximum number of concurrent executions of this flow"},"concurrency_key":{"type":"string","description":"Expression to group concurrent executions (e.g., by user ID)"},"concurrency_time_window_s":{"type":"number","description":"Time window in seconds for concurrent_limit"},"debounce_delay_s":{"type":"integer","description":"Delay in seconds to debounce flow executions"},"debounce_key":{"type":"string","description":"Expression to group debounced executions"},"debounce_args_to_accumulate":{"type":"array","description":"Arguments to accumulate across debounced executions","items":{"type":"string"}},"max_total_debouncing_time":{"type":"integer","description":"Maximum total time in seconds that a job can be debounced"},"max_total_debounces_amount":{"type":"integer","description":"Maximum number of times a job can be debounced"},"skip_expr":{"type":"string","description":"JavaScript expression to conditionally skip the entire flow"},"cache_ttl":{"type":"number","description":"Cache duration in seconds for flow results"},"cache_ignore_s3_path":{"type":"boolean"},"delete_after_secs":{"type":"integer","description":"If set, delete the flow job's args, result and logs after this many seconds following job completion"},"flow_env":{"type":"object","description":"Environment variables available to all steps. Values can be strings, JSON values, or special references: '$var:path' (workspace variable) or '$res:path' (resource).","additionalProperties":{}},"priority":{"type":"number","description":"Execution priority (higher numbers run first)"},"early_return":{"type":"string","description":"JavaScript expression to return early from the flow"},"chat_input_enabled":{"type":"boolean","description":"Whether this flow accepts chat-style input"},"notes":{"type":"array","description":"Sticky notes attached to the flow","items":{"$ref":"#/components/schemas/FlowNote"}},"groups":{"type":"array","description":"Semantic groups of modules for organizational purposes","items":{"$ref":"#/components/schemas/FlowGroup"}}},"required":["modules"]},"Retry":{"type":"object","description":"Retry configuration for failed module executions","properties":{"constant":{"type":"object","description":"Retry with constant delay between attempts","properties":{"attempts":{"type":"integer","description":"Number of retry attempts"},"seconds":{"type":"integer","description":"Seconds to wait between retries"}}},"exponential":{"type":"object","description":"Retry with exponential backoff (delay doubles each time)","properties":{"attempts":{"type":"integer","description":"Number of retry attempts"},"multiplier":{"type":"integer","description":"Multiplier for exponential backoff"},"seconds":{"type":"integer","minimum":1,"description":"Initial delay in seconds"},"random_factor":{"type":"integer","minimum":0,"maximum":100,"description":"Random jitter percentage (0-100) to avoid thundering herd"}}},"retry_if":{"$ref":"#/components/schemas/RetryIf"}}},"FlowNote":{"type":"object","description":"A sticky note attached to a flow for documentation and annotation","properties":{"id":{"type":"string","description":"Unique identifier for the note"},"text":{"type":"string","description":"Content of the note"},"position":{"type":"object","description":"Position of the note in the flow editor","properties":{"x":{"type":"number","description":"X coordinate"},"y":{"type":"number","description":"Y coordinate"}},"required":["x","y"]},"size":{"type":"object","description":"Size of the note in the flow editor","properties":{"width":{"type":"number","description":"Width in pixels"},"height":{"type":"number","description":"Height in pixels"}},"required":["width","height"]},"color":{"type":"string","description":"Color of the note (e.g., \\"yellow\\", \\"#ffff00\\")"},"type":{"type":"string","enum":["free","group"],"description":"Type of note - 'free' for standalone notes, 'group' for notes that group other nodes"},"locked":{"type":"boolean","default":false,"description":"Whether the note is locked and cannot be edited or moved"},"contained_node_ids":{"type":"array","items":{"type":"string"},"description":"For group notes, the IDs of nodes contained within this group"}},"required":["id","text","color","type"]},"FlowGroup":{"type":"object","description":"A semantic group of flow modules for organizational purposes. Does not affect execution \\u2014 modules remain in their original position in the flow. Groups provide naming and collapsibility in the editor. Members are computed dynamically from all nodes on paths between start_id and end_id.","properties":{"summary":{"type":"string","description":"Display name for this group"},"note":{"type":"string","description":"Markdown note shown below the group header"},"autocollapse":{"type":"boolean","default":false,"description":"If true, this group is collapsed by default in the flow editor. UI hint only."},"start_id":{"type":"string","description":"ID of the first flow module in this group (topological entry point)"},"end_id":{"type":"string","description":"ID of the last flow module in this group (topological exit point)"},"color":{"type":"string","description":"Color for the group in the flow editor"}},"required":["start_id","end_id"]},"RetryIf":{"type":"object","description":"Conditional retry based on error or result","properties":{"expr":{"type":"string","description":"JavaScript expression that returns true to retry. Has access to 'result' and 'error' variables"}},"required":["expr"]},"StopAfterIf":{"type":"object","description":"Early termination condition for a module","properties":{"skip_if_stopped":{"type":"boolean","description":"If true, following steps are skipped when this condition triggers"},"expr":{"type":"string","description":"JavaScript expression evaluated after the module runs. Can use 'result' (step's result) or 'flow_input'. Return true to stop"},"error_message":{"type":"string","nullable":true,"description":"Custom error message when stopping with an error. Mutually exclusive with skip_if_stopped. If set to a non-empty string, the flow stops with this error. If empty string, a default error message is used. If null or omitted, no error is raised."}},"required":["expr"]},"FlowModule":{"type":"object","description":"A single step in a flow. Can be a script, subflow, loop, or branch","properties":{"id":{"type":"string","description":"Unique identifier for this step. Used to reference results via 'results.step_id'. Must be a valid identifier (alphanumeric, underscore, hyphen)"},"value":{"$ref":"#/components/schemas/FlowModuleValue"},"stop_after_if":{"description":"Early termination condition evaluated after this step completes","$ref":"#/components/schemas/StopAfterIf"},"stop_after_all_iters_if":{"description":"For loops only - early termination condition evaluated after all iterations complete","$ref":"#/components/schemas/StopAfterIf"},"skip_if":{"type":"object","description":"Conditionally skip this step based on previous results or flow inputs","properties":{"expr":{"type":"string","description":"JavaScript expression that returns true to skip. Can use 'flow_input' or 'results.<step_id>'"}},"required":["expr"]},"sleep":{"description":"Delay before executing this step (in seconds or as expression)","$ref":"#/components/schemas/InputTransform"},"cache_ttl":{"type":"number","description":"Cache duration in seconds for this step's results"},"cache_ignore_s3_path":{"type":"boolean"},"timeout":{"description":"Maximum execution time in seconds (static value or expression)","$ref":"#/components/schemas/InputTransform"},"delete_after_secs":{"type":"integer","description":"If set, delete the step's args, result and logs after this many seconds following job completion"},"summary":{"type":"string","description":"Short description of what this step does"},"mock":{"type":"object","description":"Mock configuration for testing without executing the actual step","properties":{"enabled":{"type":"boolean","description":"If true, return mock value instead of executing"},"return_value":{"description":"Value to return when mocked"}}},"suspend":{"type":"object","description":"Configuration for approval/resume steps that wait for user input","properties":{"required_events":{"type":"integer","description":"Number of approvals required before continuing"},"timeout":{"type":"integer","description":"Timeout in seconds before auto-continuing or canceling"},"resume_form":{"type":"object","description":"Form schema for collecting input when resuming","properties":{"schema":{"type":"object","description":"JSON Schema for the resume form"}}},"user_auth_required":{"type":"boolean","description":"If true, only authenticated users can approve"},"user_groups_required":{"description":"Expression or list of groups that can approve","$ref":"#/components/schemas/InputTransform"},"self_approval_disabled":{"type":"boolean","description":"If true, the user who started the flow cannot approve"},"hide_cancel":{"type":"boolean","description":"If true, hide the cancel button on the approval form"},"continue_on_disapprove_timeout":{"type":"boolean","description":"If true, continue flow on timeout instead of canceling"}}},"priority":{"type":"number","description":"Execution priority for this step (higher numbers run first)"},"continue_on_error":{"type":"boolean","description":"If true, flow continues even if this step fails"},"retry":{"description":"Retry configuration if this step fails","$ref":"#/components/schemas/Retry"},"debouncing":{"description":"Debounce configuration for this step (EE only)","type":"object","properties":{"debounce_delay_s":{"type":"integer","description":"Delay in seconds to debounce this step's executions across flow runs"},"debounce_key":{"type":"string","description":"Expression to group debounced executions. Supports $workspace and $args[name]. Default: $workspace/flow/<flow_path>-<step_id>"},"debounce_args_to_accumulate":{"type":"array","description":"Array-type arguments to accumulate across debounced executions","items":{"type":"string"}},"max_total_debouncing_time":{"type":"integer","description":"Maximum total time in seconds before forced execution"},"max_total_debounces_amount":{"type":"integer","description":"Maximum number of debounces before forced execution"}}}},"required":["value","id"]},"InputTransform":{"description":"Maps input parameters for a step. Can be a static value or a JavaScript expression that references previous results or flow inputs","oneOf":[{"$ref":"#/components/schemas/StaticTransform"},{"$ref":"#/components/schemas/JavascriptTransform"},{"$ref":"#/components/schemas/AiTransform"}],"discriminator":{"propertyName":"type","mapping":{"static":"#/components/schemas/StaticTransform","javascript":"#/components/schemas/JavascriptTransform","ai":"#/components/schemas/AiTransform"}}},"StaticTransform":{"type":"object","description":"Static value passed directly to the step. Use for hardcoded values or resource references like '$res:path/to/resource'","properties":{"value":{"description":"The static value. For resources, use format '$res:path/to/resource'"},"type":{"type":"string","enum":["static"]}},"required":["type"]},"JavascriptTransform":{"type":"object","description":"JavaScript expression evaluated at runtime. Can reference previous step results via 'results.step_id' or flow inputs via 'flow_input.property'. Inside loops, use 'flow_input.iter.value' for the current iteration value","properties":{"expr":{"type":"string","description":"JavaScript expression returning the value. Available variables - results (object with all previous step results), flow_input (flow inputs), flow_input.iter (in loops)"},"type":{"type":"string","enum":["javascript"]}},"required":["expr","type"]},"AiTransform":{"type":"object","description":"Value resolved by the AI runtime for this input. The AI engine decides how to satisfy the parameter.","properties":{"type":{"type":"string","enum":["ai"]}},"required":["type"]},"AIProviderKind":{"type":"string","description":"Supported AI provider types","enum":["openai","azure_openai","anthropic","mistral","deepseek","googleai","groq","openrouter","togetherai","customai","aws_bedrock"]},"ProviderConfig":{"type":"object","description":"Complete AI provider configuration with resource reference and model selection","properties":{"kind":{"$ref":"#/components/schemas/AIProviderKind"},"resource":{"type":"string","description":"Resource reference in format '$res:{resource_path}' pointing to provider credentials"},"model":{"type":"string","description":"Model identifier (e.g., 'gpt-4', 'claude-3-opus-20240229', 'gemini-pro')"}},"required":["kind","resource","model"]},"StaticProviderTransform":{"type":"object","description":"Static provider configuration passed directly to the AI agent","properties":{"value":{"$ref":"#/components/schemas/ProviderConfig"},"type":{"type":"string","enum":["static"]}},"required":["type","value"]},"ProviderTransform":{"description":"Provider configuration - can be static (ProviderConfig), JavaScript expression, or AI-determined","oneOf":[{"$ref":"#/components/schemas/StaticProviderTransform"},{"$ref":"#/components/schemas/JavascriptTransform"},{"$ref":"#/components/schemas/AiTransform"}],"discriminator":{"propertyName":"type","mapping":{"static":"#/components/schemas/StaticProviderTransform","javascript":"#/components/schemas/JavascriptTransform","ai":"#/components/schemas/AiTransform"}}},"MemoryOff":{"type":"object","description":"No conversation memory/context","properties":{"kind":{"type":"string","enum":["off"]}},"required":["kind"]},"MemoryAuto":{"type":"object","description":"Automatic context management","properties":{"kind":{"type":"string","enum":["auto"]},"context_length":{"type":"integer","description":"Maximum number of messages to retain in context"},"memory_id":{"type":"string","description":"Identifier for persistent memory across agent invocations"}},"required":["kind"]},"MemoryMessage":{"type":"object","description":"A single message in conversation history","properties":{"role":{"type":"string","enum":["user","assistant","system"]},"content":{"type":"string"}},"required":["role","content"]},"MemoryManual":{"type":"object","description":"Explicit message history","properties":{"kind":{"type":"string","enum":["manual"]},"messages":{"type":"array","items":{"$ref":"#/components/schemas/MemoryMessage"}}},"required":["kind","messages"]},"MemoryConfig":{"description":"Conversation memory configuration","oneOf":[{"$ref":"#/components/schemas/MemoryOff"},{"$ref":"#/components/schemas/MemoryAuto"},{"$ref":"#/components/schemas/MemoryManual"}],"discriminator":{"propertyName":"kind","mapping":{"off":"#/components/schemas/MemoryOff","auto":"#/components/schemas/MemoryAuto","manual":"#/components/schemas/MemoryManual"}}},"StaticMemoryTransform":{"type":"object","description":"Static memory configuration passed directly to the AI agent","properties":{"value":{"$ref":"#/components/schemas/MemoryConfig"},"type":{"type":"string","enum":["static"]}},"required":["type","value"]},"MemoryTransform":{"description":"Memory configuration - can be static (MemoryConfig), JavaScript expression, or AI-determined","oneOf":[{"$ref":"#/components/schemas/StaticMemoryTransform"},{"$ref":"#/components/schemas/JavascriptTransform"},{"$ref":"#/components/schemas/AiTransform"}],"discriminator":{"propertyName":"type","mapping":{"static":"#/components/schemas/StaticMemoryTransform","javascript":"#/components/schemas/JavascriptTransform","ai":"#/components/schemas/AiTransform"}}},"FlowModuleValue":{"description":"The actual implementation of a flow step. Can be a script (inline or referenced), subflow, loop, branch, or special module type","oneOf":[{"$ref":"#/components/schemas/RawScript"},{"$ref":"#/components/schemas/PathScript"},{"$ref":"#/components/schemas/PathFlow"},{"$ref":"#/components/schemas/ForloopFlow"},{"$ref":"#/components/schemas/WhileloopFlow"},{"$ref":"#/components/schemas/BranchOne"},{"$ref":"#/components/schemas/BranchAll"},{"$ref":"#/components/schemas/Identity"},{"$ref":"#/components/schemas/AiAgent"}],"discriminator":{"propertyName":"type","mapping":{"rawscript":"#/components/schemas/RawScript","script":"#/components/schemas/PathScript","flow":"#/components/schemas/PathFlow","forloopflow":"#/components/schemas/ForloopFlow","whileloopflow":"#/components/schemas/WhileloopFlow","branchone":"#/components/schemas/BranchOne","branchall":"#/components/schemas/BranchAll","identity":"#/components/schemas/Identity","aiagent":"#/components/schemas/AiAgent"}}},"RawScript":{"type":"object","description":"Inline script with code defined directly in the flow. Use 'bun' as default language if unspecified. The script receives arguments from input_transforms","properties":{"input_transforms":{"type":"object","description":"Map of parameter names to their values (static or JavaScript expressions). These become the script's input arguments","additionalProperties":{"$ref":"#/components/schemas/InputTransform"}},"content":{"type":"string","description":"The script source code. Should export a 'main' function"},"language":{"type":"string","description":"Programming language for this script","enum":["deno","bun","python3","go","bash","powershell","postgresql","mysql","bigquery","snowflake","mssql","oracledb","graphql","nativets","php","rust","ansible","csharp","nu","java","ruby","rlang","duckdb"]},"path":{"type":"string","description":"Optional path for saving this script"},"lock":{"type":"string","description":"Lock file content for dependencies"},"type":{"type":"string","enum":["rawscript"]},"tag":{"type":"string","description":"Worker group tag for execution routing"},"concurrent_limit":{"type":"number","description":"Maximum concurrent executions of this script"},"concurrency_time_window_s":{"type":"number","description":"Time window for concurrent_limit"},"custom_concurrency_key":{"type":"string","description":"Custom key for grouping concurrent executions"},"is_trigger":{"type":"boolean","description":"If true, this script is a trigger that can start the flow"},"assets":{"type":"array","description":"External resources this script accesses (S3 objects, resources, etc.)","items":{"type":"object","required":["path","kind"],"properties":{"path":{"type":"string","description":"Path to the asset"},"kind":{"type":"string","description":"Type of asset","enum":["s3object","resource","ducklake","datatable","volume"]},"access_type":{"type":"string","nullable":true,"description":"Access level for this asset","enum":["r","w","rw"]},"alt_access_type":{"type":"string","nullable":true,"description":"Alternative access level","enum":["r","w","rw"]}}}}},"required":["type","content","language","input_transforms"]},"PathScript":{"type":"object","description":"Reference to an existing script by path. Use this when calling a previously saved script instead of writing inline code","properties":{"input_transforms":{"type":"object","description":"Map of parameter names to their values (static or JavaScript expressions). These become the script's input arguments","additionalProperties":{"$ref":"#/components/schemas/InputTransform"}},"path":{"type":"string","description":"Path to the script in the workspace (e.g., 'f/scripts/send_email')"},"hash":{"type":"string","description":"Optional specific version hash of the script to use"},"type":{"type":"string","enum":["script"]},"tag_override":{"type":"string","description":"Override the script's default worker group tag"},"is_trigger":{"type":"boolean","description":"If true, this script is a trigger that can start the flow"}},"required":["type","path","input_transforms"]},"PathFlow":{"type":"object","description":"Reference to an existing flow by path. Use this to call another flow as a subflow","properties":{"input_transforms":{"type":"object","description":"Map of parameter names to their values (static or JavaScript expressions). These become the subflow's input arguments","additionalProperties":{"$ref":"#/components/schemas/InputTransform"}},"path":{"type":"string","description":"Path to the flow in the workspace (e.g., 'f/flows/process_user')"},"type":{"type":"string","enum":["flow"]}},"required":["type","path","input_transforms"]},"ForloopFlow":{"type":"object","description":"Executes nested modules in a loop over an iterator. Inside the loop, use 'flow_input.iter.value' to access the current iteration value, and 'flow_input.iter.index' for the index. Supports parallel execution for better performance on I/O-bound operations","properties":{"modules":{"type":"array","description":"Steps to execute for each iteration. These can reference the iteration value via 'flow_input.iter.value'","items":{"$ref":"#/components/schemas/FlowModule"}},"iterator":{"description":"JavaScript expression that returns an array to iterate over. Can reference 'results.step_id' or 'flow_input'","$ref":"#/components/schemas/InputTransform"},"skip_failures":{"type":"boolean","description":"If true, iteration failures don't stop the loop. Failed iterations return null"},"type":{"type":"string","enum":["forloopflow"]},"parallel":{"type":"boolean","description":"If true, iterations run concurrently (faster for I/O-bound operations). Use with parallelism to control concurrency"},"parallelism":{"description":"Maximum number of concurrent iterations when parallel=true. Limits resource usage. Can be static number or expression","$ref":"#/components/schemas/InputTransform"},"squash":{"type":"boolean"}},"required":["modules","iterator","skip_failures","type"]},"WhileloopFlow":{"type":"object","description":"Executes nested modules repeatedly while a condition is true. The loop checks the condition after each iteration. Use stop_after_if on modules to control loop termination","properties":{"modules":{"type":"array","description":"Steps to execute in each iteration. Use stop_after_if to control when the loop ends","items":{"$ref":"#/components/schemas/FlowModule"}},"skip_failures":{"type":"boolean","description":"If true, iteration failures don't stop the loop. Failed iterations return null"},"type":{"type":"string","enum":["whileloopflow"]},"parallel":{"type":"boolean","description":"If true, iterations run concurrently (use with caution in while loops)"},"parallelism":{"description":"Maximum number of concurrent iterations when parallel=true","$ref":"#/components/schemas/InputTransform"},"squash":{"type":"boolean"}},"required":["modules","skip_failures","type"]},"BranchOne":{"type":"object","description":"Conditional branching where only the first matching branch executes. Branches are evaluated in order, and the first one with a true expression runs. If no branches match, the default branch executes","properties":{"branches":{"type":"array","description":"Array of branches to evaluate in order. The first branch with expr evaluating to true executes","items":{"type":"object","properties":{"summary":{"type":"string","description":"Short description of this branch condition"},"expr":{"type":"string","description":"JavaScript expression that returns boolean. Can use 'results.step_id' or 'flow_input'. First true expr wins"},"modules":{"type":"array","description":"Steps to execute if this branch's expr is true","items":{"$ref":"#/components/schemas/FlowModule"}}},"required":["modules","expr"]}},"default":{"type":"array","description":"Steps to execute if no branch expressions match","items":{"$ref":"#/components/schemas/FlowModule"}},"type":{"type":"string","enum":["branchone"]}},"required":["branches","default","type"]},"BranchAll":{"type":"object","description":"Parallel branching where all branches execute simultaneously. Unlike BranchOne, all branches run regardless of conditions. Useful for executing independent tasks concurrently","properties":{"branches":{"type":"array","description":"Array of branches that all execute (either in parallel or sequentially)","items":{"type":"object","properties":{"summary":{"type":"string","description":"Short description of this branch's purpose"},"skip_failure":{"type":"boolean","description":"If true, failure in this branch doesn't fail the entire flow"},"modules":{"type":"array","description":"Steps to execute in this branch","items":{"$ref":"#/components/schemas/FlowModule"}}},"required":["modules"]}},"type":{"type":"string","enum":["branchall"]},"parallel":{"type":"boolean","description":"If true, all branches execute concurrently. If false, they execute sequentially"}},"required":["branches","type"]},"AgentTool":{"type":"object","description":"A tool available to an AI agent. Can be a flow module or an external MCP (Model Context Protocol) tool","properties":{"id":{"type":"string","description":"Unique identifier for this tool. Cannot contain spaces - use underscores instead (e.g., 'get_user_data' not 'get user data')"},"summary":{"type":"string","description":"Short description of what this tool does (shown to the AI)"},"value":{"$ref":"#/components/schemas/ToolValue"}},"required":["id","value"]},"ToolValue":{"description":"The implementation of a tool. Can be a flow module (script/flow) or an MCP tool reference","oneOf":[{"$ref":"#/components/schemas/FlowModuleTool"},{"$ref":"#/components/schemas/McpToolValue"},{"$ref":"#/components/schemas/WebsearchToolValue"}],"discriminator":{"propertyName":"tool_type","mapping":{"flowmodule":"#/components/schemas/FlowModuleTool","mcp":"#/components/schemas/McpToolValue","websearch":"#/components/schemas/WebsearchToolValue"}}},"FlowModuleTool":{"description":"A tool implemented as a flow module (script, flow, etc.). The AI can call this like any other flow module","allOf":[{"type":"object","properties":{"tool_type":{"type":"string","enum":["flowmodule"]}},"required":["tool_type"]},{"$ref":"#/components/schemas/FlowModuleValue"}]},"WebsearchToolValue":{"type":"object","description":"A tool implemented as a websearch tool. The AI can call this like any other websearch tool","properties":{"tool_type":{"type":"string","enum":["websearch"]}},"required":["tool_type"]},"McpToolValue":{"type":"object","description":"Reference to an external MCP (Model Context Protocol) tool. The AI can call tools from MCP servers","properties":{"tool_type":{"type":"string","enum":["mcp"]},"resource_path":{"type":"string","description":"Path to the MCP resource/server configuration"},"include_tools":{"type":"array","description":"Whitelist of specific tools to include from this MCP server","items":{"type":"string"}},"exclude_tools":{"type":"array","description":"Blacklist of tools to exclude from this MCP server","items":{"type":"string"}}},"required":["tool_type","resource_path"]},"AiAgent":{"type":"object","description":"AI agent step that can use tools to accomplish tasks. The agent receives inputs and can call any of its configured tools to complete the task","properties":{"input_transforms":{"type":"object","description":"Input parameters for the AI agent mapped to their values","properties":{"provider":{"$ref":"#/components/schemas/ProviderTransform"},"output_type":{"allOf":[{"$ref":"#/components/schemas/InputTransform"}],"description":"Output format type.\\nValid values: 'text' (default) - plain text response, 'image' - image generation\\n"},"user_message":{"allOf":[{"$ref":"#/components/schemas/InputTransform"}],"description":"The user's prompt/message to the AI agent. Supports variable interpolation with flow.input syntax."},"system_prompt":{"allOf":[{"$ref":"#/components/schemas/InputTransform"}],"description":"System instructions that guide the AI's behavior, persona, and response style. Optional."},"streaming":{"allOf":[{"$ref":"#/components/schemas/InputTransform"}],"description":"Boolean. If true, stream the AI response incrementally.\\nStreaming events include: token_delta, tool_call, tool_call_arguments, tool_execution, tool_result\\n"},"memory":{"$ref":"#/components/schemas/MemoryTransform"},"output_schema":{"allOf":[{"$ref":"#/components/schemas/InputTransform"}],"description":"JSON Schema object defining structured output format. Used when you need the AI to return data in a specific shape.\\nSupports standard JSON Schema properties: type, properties, required, items, enum, pattern, minLength, maxLength, minimum, maximum, etc.\\nExample: { type: 'object', properties: { name: { type: 'string' }, age: { type: 'integer' } }, required: ['name'] }\\n"},"user_attachments":{"allOf":[{"$ref":"#/components/schemas/InputTransform"}],"description":"Array of file references (images or PDFs) for the AI agent.\\nFormat: Array<{ bucket: string, key: string }> - S3 object references\\nExample: [{ bucket: 'my-bucket', key: 'documents/report.pdf' }]\\n"},"max_completion_tokens":{"allOf":[{"$ref":"#/components/schemas/InputTransform"}],"description":"Integer. Maximum number of tokens the AI will generate in its response.\\nRange: 1 to 4,294,967,295. Typical values: 256-4096 for most use cases.\\n"},"temperature":{"allOf":[{"$ref":"#/components/schemas/InputTransform"}],"description":"Float. Controls randomness/creativity of responses.\\nRange: 0.0 to 2.0 (provider-dependent)\\n- 0.0 = deterministic, focused responses\\n- 0.7 = balanced (common default)\\n- 1.0+ = more creative/random\\n"},"max_iterations":{"allOf":[{"$ref":"#/components/schemas/InputTransform"}],"description":"Number. Limits how many times the agent can loop through reasoning and tool use.\\nRange: 1-1000.\\n"}},"required":["provider","user_message","output_type"]},"tools":{"type":"array","description":"Array of tools the agent can use. The agent decides which tools to call based on the task","items":{"$ref":"#/components/schemas/AgentTool"}},"type":{"type":"string","enum":["aiagent"]},"omit_output_from_conversation":{"type":"boolean","default":false,"description":"If true, this AI agent step does not persist its assistant or tool messages to the flow conversation when chat mode is enabled."},"parallel":{"type":"boolean","description":"If true, the agent can execute multiple tool calls in parallel"}},"required":["tools","type","input_transforms"]},"Identity":{"type":"object","description":"Pass-through module that returns its input unchanged. Useful for flow structure or as a placeholder","properties":{"type":{"type":"string","enum":["identity"]},"flow":{"type":"boolean","description":"If true, marks this as a flow identity (special handling)"}},"required":["type"]},"FlowStatus":{"type":"object","properties":{"step":{"type":"integer"},"modules":{"type":"array","items":{"$ref":"#/components/schemas/FlowStatusModule"}},"user_states":{"additionalProperties":true},"preprocessor_module":{"allOf":[{"$ref":"#/components/schemas/FlowStatusModule"}]},"failure_module":{"allOf":[{"$ref":"#/components/schemas/FlowStatusModule"},{"type":"object","properties":{"parent_module":{"type":"string"}}}]},"retry":{"type":"object","properties":{"fail_count":{"type":"integer"},"failed_jobs":{"type":"array","items":{"type":"string","format":"uuid"}}}}},"required":["step","modules","failure_module"]},"FlowStatusModule":{"type":"object","properties":{"type":{"type":"string","enum":["WaitingForPriorSteps","WaitingForEvents","WaitingForExecutor","InProgress","Success","Failure"]},"id":{"type":"string"},"job":{"type":"string","format":"uuid"},"count":{"type":"integer"},"progress":{"type":"integer"},"iterator":{"type":"object","properties":{"index":{"type":"integer"},"itered":{"type":"array","items":{}},"itered_len":{"type":"integer"},"args":{}}},"flow_jobs":{"type":"array","items":{"type":"string"}},"flow_jobs_success":{"type":"array","items":{"type":"boolean"}},"flow_jobs_duration":{"type":"object","properties":{"started_at":{"type":"array","items":{"type":"string"}},"duration_ms":{"type":"array","items":{"type":"integer"}}}},"branch_chosen":{"type":"object","properties":{"type":{"type":"string","enum":["branch","default"]},"branch":{"type":"integer"}},"required":["type"]},"branchall":{"type":"object","properties":{"branch":{"type":"integer"},"len":{"type":"integer"}},"required":["branch","len"]},"approvers":{"type":"array","items":{"type":"object","properties":{"resume_id":{"type":"integer"},"approver":{"type":"string"}},"required":["resume_id","approver"]}},"failed_retries":{"type":"array","items":{"type":"string","format":"uuid"}},"skipped":{"type":"boolean"},"agent_actions":{"type":"array","items":{"type":"object","oneOf":[{"type":"object","properties":{"job_id":{"type":"string","format":"uuid"},"function_name":{"type":"string"},"type":{"type":"string","enum":["tool_call"]},"module_id":{"type":"string"}},"required":["job_id","function_name","type","module_id"]},{"type":"object","properties":{"call_id":{"type":"string","format":"uuid"},"function_name":{"type":"string"},"resource_path":{"type":"string"},"type":{"type":"string","enum":["mcp_tool_call"]},"arguments":{"type":"object"}},"required":["call_id","function_name","resource_path","type"]},{"type":"object","properties":{"type":{"type":"string","enum":["web_search"]}},"required":["type"]},{"type":"object","properties":{"type":{"type":"string","enum":["message"]}},"required":["content","type"]}]}},"agent_actions_success":{"type":"array","items":{"type":"boolean"}}},"required":["type"]}}`;
+{"OpenFlow":{"type":"object","description":"Top-level flow definition containing metadata, configuration, and the flow structure","properties":{"summary":{"type":"string","description":"Short description of what this flow does"},"description":{"type":"string","description":"Detailed documentation for this flow"},"value":{"$ref":"#/components/schemas/FlowValue"},"schema":{"type":"object","description":"JSON Schema for flow inputs. Use this to define input parameters, their types, defaults, and validation. For resource inputs, set type to 'object' and format to 'resource-<type>' (e.g., 'resource-stripe')"},"on_behalf_of_email":{"type":"string","description":"The flow will be run with the permissions of the user with this email."}},"required":["summary","value"]},"FlowValue":{"type":"object","description":"The flow structure containing modules and optional preprocessor/failure handlers","properties":{"modules":{"type":"array","description":"Array of steps that execute in sequence. Each step can be a script, subflow, loop, or branch","items":{"$ref":"#/components/schemas/FlowModule"}},"failure_module":{"description":"Special module that executes when the flow fails. Receives error object with message, name, stack, and step_id. Must have id 'failure'. Only supports script/rawscript types","$ref":"#/components/schemas/FlowModule"},"preprocessor_module":{"description":"Special module that runs before the first step on external triggers. Must have id 'preprocessor'. Only supports script/rawscript types. Cannot reference other step results","$ref":"#/components/schemas/FlowModule"},"same_worker":{"type":"boolean","description":"If true, all steps run on the same worker for better performance"},"preserve_step_tags":{"type":"boolean","description":"If true and the flow runs on a custom worker tag, steps that declare their own non-empty tag run on it instead of inheriting the flow tag. Steps without their own tag still inherit the flow tag."},"concurrent_limit":{"type":"number","description":"Maximum number of concurrent executions of this flow"},"concurrency_key":{"type":"string","description":"Expression to group concurrent executions (e.g., by user ID)"},"concurrency_time_window_s":{"type":"number","description":"Time window in seconds for concurrent_limit"},"debounce_delay_s":{"type":"integer","description":"Delay in seconds to debounce flow executions"},"debounce_key":{"type":"string","description":"Expression to group debounced executions"},"debounce_args_to_accumulate":{"type":"array","description":"Arguments to accumulate across debounced executions","items":{"type":"string"}},"max_total_debouncing_time":{"type":"integer","description":"Maximum total time in seconds that a job can be debounced"},"max_total_debounces_amount":{"type":"integer","description":"Maximum number of times a job can be debounced"},"skip_expr":{"type":"string","description":"JavaScript expression to conditionally skip the entire flow"},"cache_ttl":{"type":"number","description":"Cache duration in seconds for flow results"},"cache_ignore_s3_path":{"type":"boolean"},"delete_after_secs":{"type":"integer","description":"If set, delete the flow job's args, result and logs after this many seconds following job completion"},"flow_env":{"type":"object","description":"Environment variables available to all steps. Values can be strings, JSON values, or special references: '$var:path' (workspace variable) or '$res:path' (resource).","additionalProperties":{}},"priority":{"type":"number","description":"Execution priority (higher numbers run first)"},"early_return":{"type":"string","description":"JavaScript expression to return early from the flow"},"chat_input_enabled":{"type":"boolean","description":"Whether this flow accepts chat-style input"},"notes":{"type":"array","description":"Sticky notes attached to the flow","items":{"$ref":"#/components/schemas/FlowNote"}},"groups":{"type":"array","description":"Semantic groups of modules for organizational purposes","items":{"$ref":"#/components/schemas/FlowGroup"}}},"required":["modules"]},"Retry":{"type":"object","description":"Retry configuration for failed module executions","properties":{"constant":{"type":"object","description":"Retry with constant delay between attempts","properties":{"attempts":{"type":"integer","description":"Number of retry attempts"},"seconds":{"type":"integer","description":"Seconds to wait between retries"}}},"exponential":{"type":"object","description":"Retry with exponential backoff (delay doubles each time)","properties":{"attempts":{"type":"integer","description":"Number of retry attempts"},"multiplier":{"type":"integer","description":"Multiplier for exponential backoff"},"seconds":{"type":"integer","minimum":1,"description":"Initial delay in seconds"},"random_factor":{"type":"integer","minimum":0,"maximum":100,"description":"Random jitter percentage (0-100) to avoid thundering herd"}}},"retry_if":{"$ref":"#/components/schemas/RetryIf"}}},"FlowNote":{"type":"object","description":"A sticky note attached to a flow for documentation and annotation","properties":{"id":{"type":"string","description":"Unique identifier for the note"},"text":{"type":"string","description":"Content of the note"},"position":{"type":"object","description":"Position of the note in the flow editor","properties":{"x":{"type":"number","description":"X coordinate"},"y":{"type":"number","description":"Y coordinate"}},"required":["x","y"]},"size":{"type":"object","description":"Size of the note in the flow editor","properties":{"width":{"type":"number","description":"Width in pixels"},"height":{"type":"number","description":"Height in pixels"}},"required":["width","height"]},"color":{"type":"string","description":"Color of the note (e.g., \\"yellow\\", \\"#ffff00\\")"},"type":{"type":"string","enum":["free","group"],"description":"Type of note - 'free' for standalone notes, 'group' for notes that group other nodes"},"locked":{"type":"boolean","default":false,"description":"Whether the note is locked and cannot be edited or moved"},"contained_node_ids":{"type":"array","items":{"type":"string"},"description":"For group notes, the IDs of nodes contained within this group"}},"required":["id","text","color","type"]},"FlowGroup":{"type":"object","description":"A semantic group of flow modules for organizational purposes. Does not affect execution \\u2014 modules remain in their original position in the flow. Groups provide naming and collapsibility in the editor. Members are computed dynamically from all nodes on paths between start_id and end_id.","properties":{"summary":{"type":"string","description":"Display name for this group"},"note":{"type":"string","description":"Markdown note shown below the group header"},"autocollapse":{"type":"boolean","default":false,"description":"If true, this group is collapsed by default in the flow editor. UI hint only."},"start_id":{"type":"string","description":"ID of the first flow module in this group (topological entry point)"},"end_id":{"type":"string","description":"ID of the last flow module in this group (topological exit point)"},"color":{"type":"string","description":"Color for the group in the flow editor"}},"required":["start_id","end_id"]},"RetryIf":{"type":"object","description":"Conditional retry based on error or result","properties":{"expr":{"type":"string","description":"JavaScript expression that returns true to retry. Has access to 'result' and 'error' variables"}},"required":["expr"]},"StopAfterIf":{"type":"object","description":"Early termination condition for a module","properties":{"skip_if_stopped":{"type":"boolean","description":"If true, following steps are skipped when this condition triggers"},"expr":{"type":"string","description":"JavaScript expression evaluated after the module runs. Can use 'result' (step's result) or 'flow_input'. Return true to stop"},"error_message":{"type":"string","nullable":true,"description":"Custom error message when stopping with an error. Mutually exclusive with skip_if_stopped. If set to a non-empty string, the flow stops with this error. If empty string, a default error message is used. If null or omitted, no error is raised."}},"required":["expr"]},"FlowModule":{"type":"object","description":"A single step in a flow. Can be a script, subflow, loop, or branch","properties":{"id":{"type":"string","description":"Unique identifier for this step. Used to reference results via 'results.step_id'. Must be a valid identifier (alphanumeric, underscore, hyphen)"},"value":{"$ref":"#/components/schemas/FlowModuleValue"},"stop_after_if":{"description":"Early termination condition evaluated after this step completes","$ref":"#/components/schemas/StopAfterIf"},"stop_after_all_iters_if":{"description":"For loops only - early termination condition evaluated after all iterations complete","$ref":"#/components/schemas/StopAfterIf"},"skip_if":{"type":"object","description":"Conditionally skip this step based on previous results or flow inputs","properties":{"expr":{"type":"string","description":"JavaScript expression that returns true to skip. Can use 'flow_input' or 'results.<step_id>'"}},"required":["expr"]},"sleep":{"description":"Delay before executing this step (in seconds or as expression)","$ref":"#/components/schemas/InputTransform"},"cache_ttl":{"type":"number","description":"Cache duration in seconds for this step's results"},"cache_ignore_s3_path":{"type":"boolean"},"timeout":{"description":"Maximum execution time in seconds (static value or expression)","$ref":"#/components/schemas/InputTransform"},"delete_after_secs":{"type":"integer","description":"If set, delete the step's args, result and logs after this many seconds following job completion"},"summary":{"type":"string","description":"Short description of what this step does"},"mock":{"type":"object","description":"Mock configuration for testing without executing the actual step","properties":{"enabled":{"type":"boolean","description":"If true, return mock value instead of executing"},"return_value":{"description":"Value to return when mocked"}}},"suspend":{"type":"object","description":"Configuration for approval/resume steps that wait for user input","properties":{"required_events":{"type":"integer","description":"Number of approvals required before continuing"},"timeout":{"type":"integer","description":"Timeout in seconds before auto-continuing or canceling"},"resume_form":{"type":"object","description":"Form schema for collecting input when resuming","properties":{"schema":{"type":"object","description":"JSON Schema for the resume form"}}},"user_auth_required":{"type":"boolean","description":"If true, only authenticated users can approve"},"user_groups_required":{"description":"Expression or list of groups that can approve","$ref":"#/components/schemas/InputTransform"},"self_approval_disabled":{"type":"boolean","description":"If true, the user who started the flow cannot approve"},"hide_cancel":{"type":"boolean","description":"If true, hide the cancel button on the approval form"},"continue_on_disapprove_timeout":{"type":"boolean","description":"If true, continue flow on timeout instead of canceling"}}},"priority":{"type":"number","description":"Execution priority for this step (higher numbers run first)"},"continue_on_error":{"type":"boolean","description":"If true, flow continues even if this step fails"},"retry":{"description":"Retry configuration if this step fails","$ref":"#/components/schemas/Retry"},"debouncing":{"description":"Debounce configuration for this step (EE only)","type":"object","properties":{"debounce_delay_s":{"type":"integer","description":"Delay in seconds to debounce this step's executions across flow runs"},"debounce_key":{"type":"string","description":"Expression to group debounced executions. Supports $workspace and $args[name]. Default: $workspace/flow/<flow_path>-<step_id>"},"debounce_args_to_accumulate":{"type":"array","description":"Array-type arguments to accumulate across debounced executions","items":{"type":"string"}},"max_total_debouncing_time":{"type":"integer","description":"Maximum total time in seconds before forced execution"},"max_total_debounces_amount":{"type":"integer","description":"Maximum number of debounces before forced execution"}}}},"required":["value","id"]},"InputTransform":{"description":"Maps input parameters for a step. Can be a static value or a JavaScript expression that references previous results or flow inputs","oneOf":[{"$ref":"#/components/schemas/StaticTransform"},{"$ref":"#/components/schemas/JavascriptTransform"},{"$ref":"#/components/schemas/AiTransform"}],"discriminator":{"propertyName":"type","mapping":{"static":"#/components/schemas/StaticTransform","javascript":"#/components/schemas/JavascriptTransform","ai":"#/components/schemas/AiTransform"}}},"StaticTransform":{"type":"object","description":"Static value passed directly to the step. Use for hardcoded values or resource references like '$res:path/to/resource'","properties":{"value":{"description":"The static value. For resources, use format '$res:path/to/resource'"},"type":{"type":"string","enum":["static"]}},"required":["type"]},"JavascriptTransform":{"type":"object","description":"JavaScript expression evaluated at runtime. Can reference previous step results via 'results.step_id' or flow inputs via 'flow_input.property'. Inside loops, use 'flow_input.iter.value' for the current iteration value","properties":{"expr":{"type":"string","description":"JavaScript expression returning the value. Available variables - results (object with all previous step results), flow_input (flow inputs), flow_input.iter (in loops)"},"type":{"type":"string","enum":["javascript"]}},"required":["expr","type"]},"AiTransform":{"type":"object","description":"Value resolved by the AI runtime for this input. The AI engine decides how to satisfy the parameter.","properties":{"type":{"type":"string","enum":["ai"]}},"required":["type"]},"AIProviderKind":{"type":"string","description":"Supported AI provider types","enum":["openai","azure_openai","anthropic","mistral","deepseek","googleai","groq","openrouter","togetherai","customai","aws_bedrock"]},"ProviderConfig":{"type":"object","description":"Complete AI provider configuration with resource reference and model selection","properties":{"kind":{"$ref":"#/components/schemas/AIProviderKind"},"resource":{"type":"string","description":"Resource reference in format '$res:{resource_path}' pointing to provider credentials"},"model":{"type":"string","description":"Model identifier (e.g., 'gpt-4', 'claude-3-opus-20240229', 'gemini-pro')"}},"required":["kind","resource","model"]},"StaticProviderTransform":{"type":"object","description":"Static provider configuration passed directly to the AI agent","properties":{"value":{"$ref":"#/components/schemas/ProviderConfig"},"type":{"type":"string","enum":["static"]}},"required":["type","value"]},"ProviderTransform":{"description":"Provider configuration - can be static (ProviderConfig), JavaScript expression, or AI-determined","oneOf":[{"$ref":"#/components/schemas/StaticProviderTransform"},{"$ref":"#/components/schemas/JavascriptTransform"},{"$ref":"#/components/schemas/AiTransform"}],"discriminator":{"propertyName":"type","mapping":{"static":"#/components/schemas/StaticProviderTransform","javascript":"#/components/schemas/JavascriptTransform","ai":"#/components/schemas/AiTransform"}}},"MemoryOff":{"type":"object","description":"No conversation memory/context","properties":{"kind":{"type":"string","enum":["off"]}},"required":["kind"]},"MemoryAuto":{"type":"object","description":"Automatic context management","properties":{"kind":{"type":"string","enum":["auto"]},"context_length":{"type":"integer","description":"Maximum number of messages to retain in context"},"memory_id":{"type":"string","description":"Identifier for persistent memory across agent invocations"}},"required":["kind"]},"MemoryMessage":{"type":"object","description":"A single message in conversation history","properties":{"role":{"type":"string","enum":["user","assistant","system"]},"content":{"type":"string"}},"required":["role","content"]},"MemoryManual":{"type":"object","description":"Explicit message history","properties":{"kind":{"type":"string","enum":["manual"]},"messages":{"type":"array","items":{"$ref":"#/components/schemas/MemoryMessage"}}},"required":["kind","messages"]},"MemoryConfig":{"description":"Conversation memory configuration","oneOf":[{"$ref":"#/components/schemas/MemoryOff"},{"$ref":"#/components/schemas/MemoryAuto"},{"$ref":"#/components/schemas/MemoryManual"}],"discriminator":{"propertyName":"kind","mapping":{"off":"#/components/schemas/MemoryOff","auto":"#/components/schemas/MemoryAuto","manual":"#/components/schemas/MemoryManual"}}},"StaticMemoryTransform":{"type":"object","description":"Static memory configuration passed directly to the AI agent","properties":{"value":{"$ref":"#/components/schemas/MemoryConfig"},"type":{"type":"string","enum":["static"]}},"required":["type","value"]},"MemoryTransform":{"description":"Memory configuration - can be static (MemoryConfig), JavaScript expression, or AI-determined","oneOf":[{"$ref":"#/components/schemas/StaticMemoryTransform"},{"$ref":"#/components/schemas/JavascriptTransform"},{"$ref":"#/components/schemas/AiTransform"}],"discriminator":{"propertyName":"type","mapping":{"static":"#/components/schemas/StaticMemoryTransform","javascript":"#/components/schemas/JavascriptTransform","ai":"#/components/schemas/AiTransform"}}},"FlowModuleValue":{"description":"The actual implementation of a flow step. Can be a script (inline or referenced), subflow, loop, branch, or special module type","oneOf":[{"$ref":"#/components/schemas/RawScript"},{"$ref":"#/components/schemas/PathScript"},{"$ref":"#/components/schemas/PathFlow"},{"$ref":"#/components/schemas/ForloopFlow"},{"$ref":"#/components/schemas/WhileloopFlow"},{"$ref":"#/components/schemas/BranchOne"},{"$ref":"#/components/schemas/BranchAll"},{"$ref":"#/components/schemas/Identity"},{"$ref":"#/components/schemas/AiAgent"}],"discriminator":{"propertyName":"type","mapping":{"rawscript":"#/components/schemas/RawScript","script":"#/components/schemas/PathScript","flow":"#/components/schemas/PathFlow","forloopflow":"#/components/schemas/ForloopFlow","whileloopflow":"#/components/schemas/WhileloopFlow","branchone":"#/components/schemas/BranchOne","branchall":"#/components/schemas/BranchAll","identity":"#/components/schemas/Identity","aiagent":"#/components/schemas/AiAgent"}}},"RawScript":{"type":"object","description":"Inline script with code defined directly in the flow. Use 'bun' as default language if unspecified. The script receives arguments from input_transforms","properties":{"input_transforms":{"type":"object","description":"Map of parameter names to their values (static or JavaScript expressions). These become the script's input arguments","additionalProperties":{"$ref":"#/components/schemas/InputTransform"}},"content":{"type":"string","description":"The script source code. Should export a 'main' function"},"language":{"type":"string","description":"Programming language for this script","enum":["deno","bun","python3","go","bash","powershell","postgresql","mysql","bigquery","snowflake","mssql","oracledb","graphql","nativets","php","rust","ansible","csharp","nu","java","ruby","rlang","duckdb"]},"path":{"type":"string","description":"Optional path for saving this script"},"lock":{"type":"string","description":"Lock file content for dependencies"},"type":{"type":"string","enum":["rawscript"]},"tag":{"type":"string","description":"Worker group tag for execution routing"},"concurrent_limit":{"type":"number","description":"Maximum concurrent executions of this script"},"concurrency_time_window_s":{"type":"number","description":"Time window for concurrent_limit"},"custom_concurrency_key":{"type":"string","description":"Custom key for grouping concurrent executions"},"is_trigger":{"type":"boolean","description":"If true, this script is a trigger that can start the flow"},"assets":{"type":"array","description":"External resources this script accesses (S3 objects, resources, etc.)","items":{"type":"object","required":["path","kind"],"properties":{"path":{"type":"string","description":"Path to the asset"},"kind":{"type":"string","description":"Type of asset","enum":["s3object","resource","ducklake","datatable","volume"]},"access_type":{"type":"string","nullable":true,"description":"Access level for this asset","enum":["r","w","rw"]},"alt_access_type":{"type":"string","nullable":true,"description":"Alternative access level","enum":["r","w","rw"]}}}}},"required":["type","content","language","input_transforms"]},"PathScript":{"type":"object","description":"Reference to an existing script by path. Use this when calling a previously saved script instead of writing inline code","properties":{"input_transforms":{"type":"object","description":"Map of parameter names to their values (static or JavaScript expressions). These become the script's input arguments","additionalProperties":{"$ref":"#/components/schemas/InputTransform"}},"path":{"type":"string","description":"Path to the script in the workspace (e.g., 'f/scripts/send_email')"},"hash":{"type":"string","description":"Optional specific version hash of the script to use"},"type":{"type":"string","enum":["script"]},"tag_override":{"type":"string","description":"Override the script's default worker group tag"},"is_trigger":{"type":"boolean","description":"If true, this script is a trigger that can start the flow"}},"required":["type","path","input_transforms"]},"PathFlow":{"type":"object","description":"Reference to an existing flow by path. Use this to call another flow as a subflow","properties":{"input_transforms":{"type":"object","description":"Map of parameter names to their values (static or JavaScript expressions). These become the subflow's input arguments","additionalProperties":{"$ref":"#/components/schemas/InputTransform"}},"path":{"type":"string","description":"Path to the flow in the workspace (e.g., 'f/flows/process_user')"},"type":{"type":"string","enum":["flow"]}},"required":["type","path","input_transforms"]},"ForloopFlow":{"type":"object","description":"Executes nested modules in a loop over an iterator. Inside the loop, use 'flow_input.iter.value' to access the current iteration value, and 'flow_input.iter.index' for the index. Supports parallel execution for better performance on I/O-bound operations","properties":{"modules":{"type":"array","description":"Steps to execute for each iteration. These can reference the iteration value via 'flow_input.iter.value'","items":{"$ref":"#/components/schemas/FlowModule"}},"iterator":{"description":"JavaScript expression that returns an array to iterate over. Can reference 'results.step_id' or 'flow_input'","$ref":"#/components/schemas/InputTransform"},"skip_failures":{"type":"boolean","description":"If true, iteration failures don't stop the loop. Failed iterations return null"},"type":{"type":"string","enum":["forloopflow"]},"parallel":{"type":"boolean","description":"If true, iterations run concurrently (faster for I/O-bound operations). Use with parallelism to control concurrency"},"parallelism":{"description":"Maximum number of concurrent iterations when parallel=true. Limits resource usage. Can be static number or expression","$ref":"#/components/schemas/InputTransform"},"squash":{"type":"boolean"}},"required":["modules","iterator","skip_failures","type"]},"WhileloopFlow":{"type":"object","description":"Executes nested modules repeatedly while a condition is true. The loop checks the condition after each iteration. Use stop_after_if on modules to control loop termination","properties":{"modules":{"type":"array","description":"Steps to execute in each iteration. Use stop_after_if to control when the loop ends","items":{"$ref":"#/components/schemas/FlowModule"}},"skip_failures":{"type":"boolean","description":"If true, iteration failures don't stop the loop. Failed iterations return null"},"type":{"type":"string","enum":["whileloopflow"]},"parallel":{"type":"boolean","description":"If true, iterations run concurrently (use with caution in while loops)"},"parallelism":{"description":"Maximum number of concurrent iterations when parallel=true","$ref":"#/components/schemas/InputTransform"},"squash":{"type":"boolean"}},"required":["modules","skip_failures","type"]},"BranchOne":{"type":"object","description":"Conditional branching where only the first matching branch executes. Branches are evaluated in order, and the first one with a true expression runs. If no branches match, the default branch executes","properties":{"branches":{"type":"array","description":"Array of branches to evaluate in order. The first branch with expr evaluating to true executes","items":{"type":"object","properties":{"summary":{"type":"string","description":"Short description of this branch condition"},"expr":{"type":"string","description":"JavaScript expression that returns boolean. Can use 'results.step_id' or 'flow_input'. First true expr wins"},"modules":{"type":"array","description":"Steps to execute if this branch's expr is true","items":{"$ref":"#/components/schemas/FlowModule"}}},"required":["modules","expr"]}},"default":{"type":"array","description":"Steps to execute if no branch expressions match","items":{"$ref":"#/components/schemas/FlowModule"}},"type":{"type":"string","enum":["branchone"]}},"required":["branches","default","type"]},"BranchAll":{"type":"object","description":"Parallel branching where all branches execute simultaneously. Unlike BranchOne, all branches run regardless of conditions. Useful for executing independent tasks concurrently","properties":{"branches":{"type":"array","description":"Array of branches that all execute (either in parallel or sequentially)","items":{"type":"object","properties":{"summary":{"type":"string","description":"Short description of this branch's purpose"},"skip_failure":{"type":"boolean","description":"If true, failure in this branch doesn't fail the entire flow"},"modules":{"type":"array","description":"Steps to execute in this branch","items":{"$ref":"#/components/schemas/FlowModule"}}},"required":["modules"]}},"type":{"type":"string","enum":["branchall"]},"parallel":{"type":"boolean","description":"If true, all branches execute concurrently. If false, they execute sequentially"}},"required":["branches","type"]},"AgentTool":{"type":"object","description":"A tool available to an AI agent. Can be a flow module or an external MCP (Model Context Protocol) tool","properties":{"id":{"type":"string","description":"Unique identifier for this tool. Cannot contain spaces - use underscores instead (e.g., 'get_user_data' not 'get user data')"},"summary":{"type":"string","description":"Short description of what this tool does (shown to the AI)"},"value":{"$ref":"#/components/schemas/ToolValue"}},"required":["id","value"]},"ToolValue":{"description":"The implementation of a tool. Can be a flow module (script/flow) or an MCP tool reference","oneOf":[{"$ref":"#/components/schemas/FlowModuleTool"},{"$ref":"#/components/schemas/McpToolValue"},{"$ref":"#/components/schemas/WebsearchToolValue"}],"discriminator":{"propertyName":"tool_type","mapping":{"flowmodule":"#/components/schemas/FlowModuleTool","mcp":"#/components/schemas/McpToolValue","websearch":"#/components/schemas/WebsearchToolValue"}}},"FlowModuleTool":{"description":"A tool implemented as a flow module (script, flow, etc.). The AI can call this like any other flow module","allOf":[{"type":"object","properties":{"tool_type":{"type":"string","enum":["flowmodule"]}},"required":["tool_type"]},{"$ref":"#/components/schemas/FlowModuleValue"}]},"WebsearchToolValue":{"type":"object","description":"A tool implemented as a websearch tool. The AI can call this like any other websearch tool","properties":{"tool_type":{"type":"string","enum":["websearch"]}},"required":["tool_type"]},"McpToolValue":{"type":"object","description":"Reference to an external MCP (Model Context Protocol) tool. The AI can call tools from MCP servers","properties":{"tool_type":{"type":"string","enum":["mcp"]},"resource_path":{"type":"string","description":"Path to the MCP resource/server configuration"},"include_tools":{"type":"array","description":"Whitelist of specific tools to include from this MCP server","items":{"type":"string"}},"exclude_tools":{"type":"array","description":"Blacklist of tools to exclude from this MCP server","items":{"type":"string"}}},"required":["tool_type","resource_path"]},"AiAgent":{"type":"object","description":"AI agent step that can use tools to accomplish tasks. The agent receives inputs and can call any of its configured tools to complete the task","properties":{"input_transforms":{"type":"object","description":"Input parameters for the AI agent mapped to their values","properties":{"provider":{"$ref":"#/components/schemas/ProviderTransform"},"output_type":{"allOf":[{"$ref":"#/components/schemas/InputTransform"}],"description":"Output format type.\\nValid values: 'text' (default) - plain text response, 'image' - image generation\\n"},"user_message":{"allOf":[{"$ref":"#/components/schemas/InputTransform"}],"description":"The user's prompt/message to the AI agent. Supports variable interpolation with flow.input syntax."},"system_prompt":{"allOf":[{"$ref":"#/components/schemas/InputTransform"}],"description":"System instructions that guide the AI's behavior, persona, and response style. Optional."},"streaming":{"allOf":[{"$ref":"#/components/schemas/InputTransform"}],"description":"Boolean. If true, stream the AI response incrementally.\\nStreaming events include: token_delta, tool_call, tool_call_arguments, tool_execution, tool_result\\n"},"memory":{"$ref":"#/components/schemas/MemoryTransform"},"output_schema":{"allOf":[{"$ref":"#/components/schemas/InputTransform"}],"description":"JSON Schema object defining structured output format. Used when you need the AI to return data in a specific shape.\\nSupports standard JSON Schema properties: type, properties, required, items, enum, pattern, minLength, maxLength, minimum, maximum, etc.\\nExample: { type: 'object', properties: { name: { type: 'string' }, age: { type: 'integer' } }, required: ['name'] }\\n"},"user_attachments":{"allOf":[{"$ref":"#/components/schemas/InputTransform"}],"description":"Array of file references (images or PDFs) for the AI agent.\\nFormat: Array<{ bucket: string, key: string }> - S3 object references\\nExample: [{ bucket: 'my-bucket', key: 'documents/report.pdf' }]\\n"},"max_completion_tokens":{"allOf":[{"$ref":"#/components/schemas/InputTransform"}],"description":"Integer. Maximum number of tokens the AI will generate in its response.\\nRange: 1 to 4,294,967,295. Typical values: 256-4096 for most use cases.\\n"},"temperature":{"allOf":[{"$ref":"#/components/schemas/InputTransform"}],"description":"Float. Controls randomness/creativity of responses.\\nRange: 0.0 to 2.0 (provider-dependent)\\n- 0.0 = deterministic, focused responses\\n- 0.7 = balanced (common default)\\n- 1.0+ = more creative/random\\n"},"max_iterations":{"allOf":[{"$ref":"#/components/schemas/InputTransform"}],"description":"Number. Limits how many times the agent can loop through reasoning and tool use.\\nRange: 1-1000.\\n"}},"required":["provider","user_message","output_type"]},"tools":{"type":"array","description":"Array of tools the agent can use. The agent decides which tools to call based on the task","items":{"$ref":"#/components/schemas/AgentTool"}},"type":{"type":"string","enum":["aiagent"]},"omit_output_from_conversation":{"type":"boolean","default":false,"description":"If true, this AI agent step does not persist its assistant or tool messages to the flow conversation when chat mode is enabled."},"parallel":{"type":"boolean","description":"If true, the agent can execute multiple tool calls in parallel"}},"required":["tools","type","input_transforms"]},"Identity":{"type":"object","description":"Pass-through module that returns its input unchanged. Useful for flow structure or as a placeholder","properties":{"type":{"type":"string","enum":["identity"]},"flow":{"type":"boolean","description":"If true, marks this as a flow identity (special handling)"}},"required":["type"]},"FlowStatus":{"type":"object","properties":{"step":{"type":"integer"},"modules":{"type":"array","items":{"$ref":"#/components/schemas/FlowStatusModule"}},"user_states":{"additionalProperties":true},"preprocessor_module":{"allOf":[{"$ref":"#/components/schemas/FlowStatusModule"}]},"failure_module":{"allOf":[{"$ref":"#/components/schemas/FlowStatusModule"},{"type":"object","properties":{"parent_module":{"type":"string"}}}]},"retry":{"type":"object","properties":{"fail_count":{"type":"integer"},"failed_jobs":{"type":"array","items":{"type":"string","format":"uuid"}}}}},"required":["step","modules","failure_module"]},"FlowStatusModule":{"type":"object","properties":{"type":{"type":"string","enum":["WaitingForPriorSteps","WaitingForEvents","WaitingForExecutor","InProgress","Success","Failure"]},"id":{"type":"string"},"job":{"type":"string","format":"uuid"},"count":{"type":"integer"},"progress":{"type":"integer"},"iterator":{"type":"object","properties":{"index":{"type":"integer"},"itered":{"type":"array","items":{}},"itered_len":{"type":"integer"},"args":{}}},"flow_jobs":{"type":"array","items":{"type":"string"}},"flow_jobs_success":{"type":"array","items":{"type":"boolean"}},"flow_jobs_duration":{"type":"object","properties":{"started_at":{"type":"array","items":{"type":"string"}},"duration_ms":{"type":"array","items":{"type":"integer"}}}},"branch_chosen":{"type":"object","properties":{"type":{"type":"string","enum":["branch","default"]},"branch":{"type":"integer"}},"required":["type"]},"branchall":{"type":"object","properties":{"branch":{"type":"integer"},"len":{"type":"integer"}},"required":["branch","len"]},"approvers":{"type":"array","items":{"type":"object","properties":{"resume_id":{"type":"integer"},"approver":{"type":"string"}},"required":["resume_id","approver"]}},"failed_retries":{"type":"array","items":{"type":"string","format":"uuid"}},"skipped":{"type":"boolean"},"agent_actions":{"type":"array","items":{"type":"object","oneOf":[{"type":"object","properties":{"job_id":{"type":"string","format":"uuid"},"function_name":{"type":"string"},"type":{"type":"string","enum":["tool_call"]},"module_id":{"type":"string"}},"required":["job_id","function_name","type","module_id"]},{"type":"object","properties":{"call_id":{"type":"string","format":"uuid"},"function_name":{"type":"string"},"resource_path":{"type":"string"},"type":{"type":"string","enum":["mcp_tool_call"]},"arguments":{"type":"object"}},"required":["call_id","function_name","resource_path","type"]},{"type":"object","properties":{"type":{"type":"string","enum":["web_search"]}},"required":["type"]},{"type":"object","properties":{"type":{"type":"string","enum":["message"]}},"required":["content","type"]}]}},"agent_actions_success":{"type":"array","items":{"type":"boolean"}}},"required":["type"]}}`;
 
 export const CLI_COMMANDS = `# Windmill CLI Commands
 
@@ -3133,6 +3133,7 @@ sync local with a remote workspaces or the opposite (push or pull)
   - \`--include-groups\` - Include syncing groups
   - \`--include-settings\` - Include syncing workspace settings
   - \`--include-key\` - Include workspace encryption key
+  - \`--skip-reencrypt-on-key-change\` - When the pushed encryption key differs from the remote, do NOT re-encrypt existing remote secrets. Only safe if they are already encrypted with the new key (e.g. workspace/instance migration). Default is to re-encrypt.
   - \`--skip-branch-validation\` - Skip git branch validation and prompts
   - \`--json-output\` - Output results in JSON format
   - \`-i --includes <patterns:file[]>\` - Comma separated patterns to specify which file to take into account (among files that are compatible with windmill). Patterns can include * (any string until '/') and ** (any string)
@@ -3524,13 +3525,14 @@ const result: wmill.S3Object = await wmill.writeS3File(
 
 export const LANG_BUNNATIVE = `# TypeScript (Bun Native)
 
-Native TypeScript execution with fetch only - no external imports allowed.
+Native TypeScript execution. Native scripts are Bun scripts that run on the native worker — a lightweight V8 isolate that exposes \`fetch\` and the JavaScript standard library — and can be heavily parallelized. Every script MUST start with \`//native\` on its first line so Windmill routes it to the native worker; without it the exact same script runs on the regular Bun worker. You may import npm packages and other Windmill scripts (e.g. \`./helper.ts\`) — imports are resolved and bundled just like a regular Bun script — as long as everything (your code and its dependencies) relies only on \`fetch\` and the standard library. Libraries that need Node/Bun runtime APIs (filesystem, \`node:*\` modules, child processes, native addons) will not work on the native worker; use the regular \`bun\` language for those.
 
 ## Structure
 
 Export a single **async** function called \`main\`:
 
 \`\`\`typescript
+//native
 export async function main(param1: string, param2: number) {
   // Your code here
   return { result: param1, count: param2 };
@@ -3546,6 +3548,7 @@ On Windmill, credentials and configuration are stored in resources and passed as
 Use the \`RT\` namespace for resource types:
 
 \`\`\`typescript
+//native
 export async function main(stripe: RT.Stripe) {
   // stripe contains API key and config from the resource
 }
@@ -3557,9 +3560,10 @@ Before using a resource type, check the \`rt.d.ts\` file in the project root to
 
 ## Imports
 
-**No imports allowed.** Use the globally available \`fetch\` function:
+**The constraint is the runtime, not the import list.** You may import npm packages and relative Windmill scripts; they are resolved and bundled exactly like a regular Bun script. But the native worker only provides \`fetch\` and the JavaScript standard library, so any imported code must work using only those. Anything requiring Node/Bun built-ins (\`node:fs\`, \`child_process\`, the \`Bun\` API, native modules) belongs in a regular \`bun\` script instead. Use the globally available \`fetch\` for HTTP:
 
 \`\`\`typescript
+//native
 export async function main(url: string) {
   const response = await fetch(url);
   return await response.json();
@@ -3568,13 +3572,14 @@ export async function main(url: string) {
 
 ## Windmill Client
 
-The windmill client is not available in native TypeScript mode. Use fetch to call APIs directly.
+\`windmill-client\` is available for Windmill-specific primitives such as the S3 helpers below (\`loadS3File\`, \`loadS3FileStream\`, \`writeS3File\`, \`S3Object\`). Use \`fetch\` for plain HTTP.
 
 ## Preprocessor Scripts
 
 For preprocessor scripts, the function should be named \`preprocessor\` and receives an \`event\` parameter:
 
 \`\`\`typescript
+//native
 type Event = {
   kind:
     | "webhook"
@@ -3607,6 +3612,7 @@ Windmill provides built-in support for S3-compatible storage operations. The \`w
 ### Receiving an S3Object as a script parameter
 
 \`\`\`typescript
+//native
 import * as wmill from "windmill-client";
 
 export async function main(file: wmill.S3Object) {
@@ -3618,6 +3624,7 @@ export async function main(file: wmill.S3Object) {
 ### S3 operations
 
 \`\`\`typescript
+//native
 import * as wmill from "windmill-client";
 
 // Load file content from S3
@@ -4108,85 +4115,6 @@ omit to use the workspace default), \`format\` (\`json\` (default), \`parquet\`,
 being buffered as the script return value.
 `;
 
-export const LANG_NATIVETS = `# TypeScript (Native)
-
-Native TypeScript execution with fetch only - no external imports allowed.
-
-## Structure
-
-Export a single **async** function called \`main\`:
-
-\`\`\`typescript
-export async function main(param1: string, param2: number) {
-  // Your code here
-  return { result: param1, count: param2 };
-}
-\`\`\`
-
-Do not call the main function.
-
-## Resource Types
-
-On Windmill, credentials and configuration are stored in resources and passed as parameters to main.
-
-Use the \`RT\` namespace for resource types:
-
-\`\`\`typescript
-export async function main(stripe: RT.Stripe) {
-  // stripe contains API key and config from the resource
-}
-\`\`\`
-
-Only use resource types if you need them to satisfy the instructions. Always use the RT namespace.
-
-Before using a resource type, check the \`rt.d.ts\` file in the project root to see all available resource types and their fields. This file is generated by \`wmill resource-type generate-namespace\`.
-
-## Imports
-
-**No imports allowed.** Use the globally available \`fetch\` function:
-
-\`\`\`typescript
-export async function main(url: string) {
-  const response = await fetch(url);
-  return await response.json();
-}
-\`\`\`
-
-## Windmill Client
-
-The windmill client is not available in native TypeScript mode. Use fetch to call APIs directly.
-
-## Preprocessor Scripts
-
-For preprocessor scripts, the function should be named \`preprocessor\` and receives an \`event\` parameter:
-
-\`\`\`typescript
-type Event = {
-  kind:
-    | "webhook"
-    | "http"
-    | "websocket"
-    | "kafka"
-    | "email"
-    | "nats"
-    | "postgres"
-    | "sqs"
-    | "mqtt"
-    | "gcp";
-  body: any;
-  headers: Record<string, string>;
-  query: Record<string, string>;
-};
-
-export async function preprocessor(event: Event) {
-  return {
-    param1: event.body.field1,
-    param2: event.query.id
-  };
-}
-\`\`\`
-`;
-
 export const LANG_PHP = `# PHP
 
 ## Structure
diff --git a/system_prompts/auto-generated/script.md b/system_prompts/auto-generated/script.md
index b7b97326a2..7515b2bec4 100644
--- a/system_prompts/auto-generated/script.md
+++ b/system_prompts/auto-generated/script.md
@@ -239,13 +239,14 @@ const result: wmill.S3Object = await wmill.writeS3File(
 
 # TypeScript (Bun Native)
 
-Native TypeScript execution with fetch only - no external imports allowed.
+Native TypeScript execution. Native scripts are Bun scripts that run on the native worker — a lightweight V8 isolate that exposes `fetch` and the JavaScript standard library — and can be heavily parallelized. Every script MUST start with `//native` on its first line so Windmill routes it to the native worker; without it the exact same script runs on the regular Bun worker. You may import npm packages and other Windmill scripts (e.g. `./helper.ts`) — imports are resolved and bundled just like a regular Bun script — as long as everything (your code and its dependencies) relies only on `fetch` and the standard library. Libraries that need Node/Bun runtime APIs (filesystem, `node:*` modules, child processes, native addons) will not work on the native worker; use the regular `bun` language for those.
 
 ## Structure
 
 Export a single **async** function called `main`:
 
 ```typescript
+//native
 export async function main(param1: string, param2: number) {
   // Your code here
   return { result: param1, count: param2 };
@@ -261,6 +262,7 @@ On Windmill, credentials and configuration are stored in resources and passed as
 Use the `RT` namespace for resource types:
 
 ```typescript
+//native
 export async function main(stripe: RT.Stripe) {
   // stripe contains API key and config from the resource
 }
@@ -272,9 +274,10 @@ Before using a resource type, check the `rt.d.ts` file in the project root to se
 
 ## Imports
 
-**No imports allowed.** Use the globally available `fetch` function:
+**The constraint is the runtime, not the import list.** You may import npm packages and relative Windmill scripts; they are resolved and bundled exactly like a regular Bun script. But the native worker only provides `fetch` and the JavaScript standard library, so any imported code must work using only those. Anything requiring Node/Bun built-ins (`node:fs`, `child_process`, the `Bun` API, native modules) belongs in a regular `bun` script instead. Use the globally available `fetch` for HTTP:
 
 ```typescript
+//native
 export async function main(url: string) {
   const response = await fetch(url);
   return await response.json();
@@ -283,13 +286,14 @@ export async function main(url: string) {
 
 ## Windmill Client
 
-The windmill client is not available in native TypeScript mode. Use fetch to call APIs directly.
+`windmill-client` is available for Windmill-specific primitives such as the S3 helpers below (`loadS3File`, `loadS3FileStream`, `writeS3File`, `S3Object`). Use `fetch` for plain HTTP.
 
 ## Preprocessor Scripts
 
 For preprocessor scripts, the function should be named `preprocessor` and receives an `event` parameter:
 
 ```typescript
+//native
 type Event = {
   kind:
     | "webhook"
@@ -322,6 +326,7 @@ Windmill provides built-in support for S3-compatible storage operations. The `wm
 ### Receiving an S3Object as a script parameter
 
 ```typescript
+//native
 import * as wmill from "windmill-client";
 
 export async function main(file: wmill.S3Object) {
@@ -333,6 +338,7 @@ export async function main(file: wmill.S3Object) {
 ### S3 operations
 
 ```typescript
+//native
 import * as wmill from "windmill-client";
 
 // Load file content from S3
@@ -823,85 +829,6 @@ omit to use the workspace default), `format` (`json` (default), `parquet`, or
 being buffered as the script return value.
 
 
-# TypeScript (Native)
-
-Native TypeScript execution with fetch only - no external imports allowed.
-
-## Structure
-
-Export a single **async** function called `main`:
-
-```typescript
-export async function main(param1: string, param2: number) {
-  // Your code here
-  return { result: param1, count: param2 };
-}
-```
-
-Do not call the main function.
-
-## Resource Types
-
-On Windmill, credentials and configuration are stored in resources and passed as parameters to main.
-
-Use the `RT` namespace for resource types:
-
-```typescript
-export async function main(stripe: RT.Stripe) {
-  // stripe contains API key and config from the resource
-}
-```
-
-Only use resource types if you need them to satisfy the instructions. Always use the RT namespace.
-
-Before using a resource type, check the `rt.d.ts` file in the project root to see all available resource types and their fields. This file is generated by `wmill resource-type generate-namespace`.
-
-## Imports
-
-**No imports allowed.** Use the globally available `fetch` function:
-
-```typescript
-export async function main(url: string) {
-  const response = await fetch(url);
-  return await response.json();
-}
-```
-
-## Windmill Client
-
-The windmill client is not available in native TypeScript mode. Use fetch to call APIs directly.
-
-## Preprocessor Scripts
-
-For preprocessor scripts, the function should be named `preprocessor` and receives an `event` parameter:
-
-```typescript
-type Event = {
-  kind:
-    | "webhook"
-    | "http"
-    | "websocket"
-    | "kafka"
-    | "email"
-    | "nats"
-    | "postgres"
-    | "sqs"
-    | "mqtt"
-    | "gcp";
-  body: any;
-  headers: Record<string, string>;
-  query: Record<string, string>;
-};
-
-export async function preprocessor(event: Event) {
-  return {
-    param1: event.body.field1,
-    param2: event.query.id
-  };
-}
-```
-
-
 # PHP
 
 ## Structure
diff --git a/system_prompts/auto-generated/skills/cli-commands/SKILL.md b/system_prompts/auto-generated/skills/cli-commands/SKILL.md
index 4b3e72a8b7..9eade530c7 100644
--- a/system_prompts/auto-generated/skills/cli-commands/SKILL.md
+++ b/system_prompts/auto-generated/skills/cli-commands/SKILL.md
@@ -588,6 +588,7 @@ sync local with a remote workspaces or the opposite (push or pull)
   - `--include-groups` - Include syncing groups
   - `--include-settings` - Include syncing workspace settings
   - `--include-key` - Include workspace encryption key
+  - `--skip-reencrypt-on-key-change` - When the pushed encryption key differs from the remote, do NOT re-encrypt existing remote secrets. Only safe if they are already encrypted with the new key (e.g. workspace/instance migration). Default is to re-encrypt.
   - `--skip-branch-validation` - Skip git branch validation and prompts
   - `--json-output` - Output results in JSON format
   - `-i --includes <patterns:file[]>` - Comma separated patterns to specify which file to take into account (among files that are compatible with windmill). Patterns can include * (any string until '/') and ** (any string)
diff --git a/system_prompts/auto-generated/skills/write-flow/SKILL.md b/system_prompts/auto-generated/skills/write-flow/SKILL.md
index fd8eacb9c0..a8b57a93e4 100644
--- a/system_prompts/auto-generated/skills/write-flow/SKILL.md
+++ b/system_prompts/auto-generated/skills/write-flow/SKILL.md
@@ -381,4 +381,4 @@ Reference a specific resource using `$res:` prefix:
 
 ## OpenFlow Schema
 
-{"OpenFlow":{"type":"object","description":"Top-level flow definition containing metadata, configuration, and the flow structure","properties":{"summary":{"type":"string","description":"Short description of what this flow does"},"description":{"type":"string","description":"Detailed documentation for this flow"},"value":{"$ref":"#/components/schemas/FlowValue"},"schema":{"type":"object","description":"JSON Schema for flow inputs. Use this to define input parameters, their types, defaults, and validation. For resource inputs, set type to 'object' and format to 'resource-<type>' (e.g., 'resource-stripe')"},"on_behalf_of_email":{"type":"string","description":"The flow will be run with the permissions of the user with this email."}},"required":["summary","value"]},"FlowValue":{"type":"object","description":"The flow structure containing modules and optional preprocessor/failure handlers","properties":{"modules":{"type":"array","description":"Array of steps that execute in sequence. Each step can be a script, subflow, loop, or branch","items":{"$ref":"#/components/schemas/FlowModule"}},"failure_module":{"description":"Special module that executes when the flow fails. Receives error object with message, name, stack, and step_id. Must have id 'failure'. Only supports script/rawscript types","$ref":"#/components/schemas/FlowModule"},"preprocessor_module":{"description":"Special module that runs before the first step on external triggers. Must have id 'preprocessor'. Only supports script/rawscript types. Cannot reference other step results","$ref":"#/components/schemas/FlowModule"},"same_worker":{"type":"boolean","description":"If true, all steps run on the same worker for better performance"},"concurrent_limit":{"type":"number","description":"Maximum number of concurrent executions of this flow"},"concurrency_key":{"type":"string","description":"Expression to group concurrent executions (e.g., by user ID)"},"concurrency_time_window_s":{"type":"number","description":"Time window in seconds for concurrent_limit"},"debounce_delay_s":{"type":"integer","description":"Delay in seconds to debounce flow executions"},"debounce_key":{"type":"string","description":"Expression to group debounced executions"},"debounce_args_to_accumulate":{"type":"array","description":"Arguments to accumulate across debounced executions","items":{"type":"string"}},"max_total_debouncing_time":{"type":"integer","description":"Maximum total time in seconds that a job can be debounced"},"max_total_debounces_amount":{"type":"integer","description":"Maximum number of times a job can be debounced"},"skip_expr":{"type":"string","description":"JavaScript expression to conditionally skip the entire flow"},"cache_ttl":{"type":"number","description":"Cache duration in seconds for flow results"},"cache_ignore_s3_path":{"type":"boolean"},"delete_after_secs":{"type":"integer","description":"If set, delete the flow job's args, result and logs after this many seconds following job completion"},"flow_env":{"type":"object","description":"Environment variables available to all steps. Values can be strings, JSON values, or special references: '$var:path' (workspace variable) or '$res:path' (resource).","additionalProperties":{}},"priority":{"type":"number","description":"Execution priority (higher numbers run first)"},"early_return":{"type":"string","description":"JavaScript expression to return early from the flow"},"chat_input_enabled":{"type":"boolean","description":"Whether this flow accepts chat-style input"},"notes":{"type":"array","description":"Sticky notes attached to the flow","items":{"$ref":"#/components/schemas/FlowNote"}},"groups":{"type":"array","description":"Semantic groups of modules for organizational purposes","items":{"$ref":"#/components/schemas/FlowGroup"}}},"required":["modules"]},"Retry":{"type":"object","description":"Retry configuration for failed module executions","properties":{"constant":{"type":"object","description":"Retry with constant delay between attempts","properties":{"attempts":{"type":"integer","description":"Number of retry attempts"},"seconds":{"type":"integer","description":"Seconds to wait between retries"}}},"exponential":{"type":"object","description":"Retry with exponential backoff (delay doubles each time)","properties":{"attempts":{"type":"integer","description":"Number of retry attempts"},"multiplier":{"type":"integer","description":"Multiplier for exponential backoff"},"seconds":{"type":"integer","minimum":1,"description":"Initial delay in seconds"},"random_factor":{"type":"integer","minimum":0,"maximum":100,"description":"Random jitter percentage (0-100) to avoid thundering herd"}}},"retry_if":{"$ref":"#/components/schemas/RetryIf"}}},"FlowNote":{"type":"object","description":"A sticky note attached to a flow for documentation and annotation","properties":{"id":{"type":"string","description":"Unique identifier for the note"},"text":{"type":"string","description":"Content of the note"},"position":{"type":"object","description":"Position of the note in the flow editor","properties":{"x":{"type":"number","description":"X coordinate"},"y":{"type":"number","description":"Y coordinate"}},"required":["x","y"]},"size":{"type":"object","description":"Size of the note in the flow editor","properties":{"width":{"type":"number","description":"Width in pixels"},"height":{"type":"number","description":"Height in pixels"}},"required":["width","height"]},"color":{"type":"string","description":"Color of the note (e.g., \"yellow\", \"#ffff00\")"},"type":{"type":"string","enum":["free","group"],"description":"Type of note - 'free' for standalone notes, 'group' for notes that group other nodes"},"locked":{"type":"boolean","default":false,"description":"Whether the note is locked and cannot be edited or moved"},"contained_node_ids":{"type":"array","items":{"type":"string"},"description":"For group notes, the IDs of nodes contained within this group"}},"required":["id","text","color","type"]},"FlowGroup":{"type":"object","description":"A semantic group of flow modules for organizational purposes. Does not affect execution \u2014 modules remain in their original position in the flow. Groups provide naming and collapsibility in the editor. Members are computed dynamically from all nodes on paths between start_id and end_id.","properties":{"summary":{"type":"string","description":"Display name for this group"},"note":{"type":"string","description":"Markdown note shown below the group header"},"autocollapse":{"type":"boolean","default":false,"description":"If true, this group is collapsed by default in the flow editor. UI hint only."},"start_id":{"type":"string","description":"ID of the first flow module in this group (topological entry point)"},"end_id":{"type":"string","description":"ID of the last flow module in this group (topological exit point)"},"color":{"type":"string","description":"Color for the group in the flow editor"}},"required":["start_id","end_id"]},"RetryIf":{"type":"object","description":"Conditional retry based on error or result","properties":{"expr":{"type":"string","description":"JavaScript expression that returns true to retry. Has access to 'result' and 'error' variables"}},"required":["expr"]},"StopAfterIf":{"type":"object","description":"Early termination condition for a module","properties":{"skip_if_stopped":{"type":"boolean","description":"If true, following steps are skipped when this condition triggers"},"expr":{"type":"string","description":"JavaScript expression evaluated after the module runs. Can use 'result' (step's result) or 'flow_input'. Return true to stop"},"error_message":{"type":"string","nullable":true,"description":"Custom error message when stopping with an error. Mutually exclusive with skip_if_stopped. If set to a non-empty string, the flow stops with this error. If empty string, a default error message is used. If null or omitted, no error is raised."}},"required":["expr"]},"FlowModule":{"type":"object","description":"A single step in a flow. Can be a script, subflow, loop, or branch","properties":{"id":{"type":"string","description":"Unique identifier for this step. Used to reference results via 'results.step_id'. Must be a valid identifier (alphanumeric, underscore, hyphen)"},"value":{"$ref":"#/components/schemas/FlowModuleValue"},"stop_after_if":{"description":"Early termination condition evaluated after this step completes","$ref":"#/components/schemas/StopAfterIf"},"stop_after_all_iters_if":{"description":"For loops only - early termination condition evaluated after all iterations complete","$ref":"#/components/schemas/StopAfterIf"},"skip_if":{"type":"object","description":"Conditionally skip this step based on previous results or flow inputs","properties":{"expr":{"type":"string","description":"JavaScript expression that returns true to skip. Can use 'flow_input' or 'results.<step_id>'"}},"required":["expr"]},"sleep":{"description":"Delay before executing this step (in seconds or as expression)","$ref":"#/components/schemas/InputTransform"},"cache_ttl":{"type":"number","description":"Cache duration in seconds for this step's results"},"cache_ignore_s3_path":{"type":"boolean"},"timeout":{"description":"Maximum execution time in seconds (static value or expression)","$ref":"#/components/schemas/InputTransform"},"delete_after_secs":{"type":"integer","description":"If set, delete the step's args, result and logs after this many seconds following job completion"},"summary":{"type":"string","description":"Short description of what this step does"},"mock":{"type":"object","description":"Mock configuration for testing without executing the actual step","properties":{"enabled":{"type":"boolean","description":"If true, return mock value instead of executing"},"return_value":{"description":"Value to return when mocked"}}},"suspend":{"type":"object","description":"Configuration for approval/resume steps that wait for user input","properties":{"required_events":{"type":"integer","description":"Number of approvals required before continuing"},"timeout":{"type":"integer","description":"Timeout in seconds before auto-continuing or canceling"},"resume_form":{"type":"object","description":"Form schema for collecting input when resuming","properties":{"schema":{"type":"object","description":"JSON Schema for the resume form"}}},"user_auth_required":{"type":"boolean","description":"If true, only authenticated users can approve"},"user_groups_required":{"description":"Expression or list of groups that can approve","$ref":"#/components/schemas/InputTransform"},"self_approval_disabled":{"type":"boolean","description":"If true, the user who started the flow cannot approve"},"hide_cancel":{"type":"boolean","description":"If true, hide the cancel button on the approval form"},"continue_on_disapprove_timeout":{"type":"boolean","description":"If true, continue flow on timeout instead of canceling"}}},"priority":{"type":"number","description":"Execution priority for this step (higher numbers run first)"},"continue_on_error":{"type":"boolean","description":"If true, flow continues even if this step fails"},"retry":{"description":"Retry configuration if this step fails","$ref":"#/components/schemas/Retry"},"debouncing":{"description":"Debounce configuration for this step (EE only)","type":"object","properties":{"debounce_delay_s":{"type":"integer","description":"Delay in seconds to debounce this step's executions across flow runs"},"debounce_key":{"type":"string","description":"Expression to group debounced executions. Supports $workspace and $args[name]. Default: $workspace/flow/<flow_path>-<step_id>"},"debounce_args_to_accumulate":{"type":"array","description":"Array-type arguments to accumulate across debounced executions","items":{"type":"string"}},"max_total_debouncing_time":{"type":"integer","description":"Maximum total time in seconds before forced execution"},"max_total_debounces_amount":{"type":"integer","description":"Maximum number of debounces before forced execution"}}}},"required":["value","id"]},"InputTransform":{"description":"Maps input parameters for a step. Can be a static value or a JavaScript expression that references previous results or flow inputs","oneOf":[{"$ref":"#/components/schemas/StaticTransform"},{"$ref":"#/components/schemas/JavascriptTransform"},{"$ref":"#/components/schemas/AiTransform"}],"discriminator":{"propertyName":"type","mapping":{"static":"#/components/schemas/StaticTransform","javascript":"#/components/schemas/JavascriptTransform","ai":"#/components/schemas/AiTransform"}}},"StaticTransform":{"type":"object","description":"Static value passed directly to the step. Use for hardcoded values or resource references like '$res:path/to/resource'","properties":{"value":{"description":"The static value. For resources, use format '$res:path/to/resource'"},"type":{"type":"string","enum":["static"]}},"required":["type"]},"JavascriptTransform":{"type":"object","description":"JavaScript expression evaluated at runtime. Can reference previous step results via 'results.step_id' or flow inputs via 'flow_input.property'. Inside loops, use 'flow_input.iter.value' for the current iteration value","properties":{"expr":{"type":"string","description":"JavaScript expression returning the value. Available variables - results (object with all previous step results), flow_input (flow inputs), flow_input.iter (in loops)"},"type":{"type":"string","enum":["javascript"]}},"required":["expr","type"]},"AiTransform":{"type":"object","description":"Value resolved by the AI runtime for this input. The AI engine decides how to satisfy the parameter.","properties":{"type":{"type":"string","enum":["ai"]}},"required":["type"]},"AIProviderKind":{"type":"string","description":"Supported AI provider types","enum":["openai","azure_openai","anthropic","mistral","deepseek","googleai","groq","openrouter","togetherai","customai","aws_bedrock"]},"ProviderConfig":{"type":"object","description":"Complete AI provider configuration with resource reference and model selection","properties":{"kind":{"$ref":"#/components/schemas/AIProviderKind"},"resource":{"type":"string","description":"Resource reference in format '$res:{resource_path}' pointing to provider credentials"},"model":{"type":"string","description":"Model identifier (e.g., 'gpt-4', 'claude-3-opus-20240229', 'gemini-pro')"}},"required":["kind","resource","model"]},"StaticProviderTransform":{"type":"object","description":"Static provider configuration passed directly to the AI agent","properties":{"value":{"$ref":"#/components/schemas/ProviderConfig"},"type":{"type":"string","enum":["static"]}},"required":["type","value"]},"ProviderTransform":{"description":"Provider configuration - can be static (ProviderConfig), JavaScript expression, or AI-determined","oneOf":[{"$ref":"#/components/schemas/StaticProviderTransform"},{"$ref":"#/components/schemas/JavascriptTransform"},{"$ref":"#/components/schemas/AiTransform"}],"discriminator":{"propertyName":"type","mapping":{"static":"#/components/schemas/StaticProviderTransform","javascript":"#/components/schemas/JavascriptTransform","ai":"#/components/schemas/AiTransform"}}},"MemoryOff":{"type":"object","description":"No conversation memory/context","properties":{"kind":{"type":"string","enum":["off"]}},"required":["kind"]},"MemoryAuto":{"type":"object","description":"Automatic context management","properties":{"kind":{"type":"string","enum":["auto"]},"context_length":{"type":"integer","description":"Maximum number of messages to retain in context"},"memory_id":{"type":"string","description":"Identifier for persistent memory across agent invocations"}},"required":["kind"]},"MemoryMessage":{"type":"object","description":"A single message in conversation history","properties":{"role":{"type":"string","enum":["user","assistant","system"]},"content":{"type":"string"}},"required":["role","content"]},"MemoryManual":{"type":"object","description":"Explicit message history","properties":{"kind":{"type":"string","enum":["manual"]},"messages":{"type":"array","items":{"$ref":"#/components/schemas/MemoryMessage"}}},"required":["kind","messages"]},"MemoryConfig":{"description":"Conversation memory configuration","oneOf":[{"$ref":"#/components/schemas/MemoryOff"},{"$ref":"#/components/schemas/MemoryAuto"},{"$ref":"#/components/schemas/MemoryManual"}],"discriminator":{"propertyName":"kind","mapping":{"off":"#/components/schemas/MemoryOff","auto":"#/components/schemas/MemoryAuto","manual":"#/components/schemas/MemoryManual"}}},"StaticMemoryTransform":{"type":"object","description":"Static memory configuration passed directly to the AI agent","properties":{"value":{"$ref":"#/components/schemas/MemoryConfig"},"type":{"type":"string","enum":["static"]}},"required":["type","value"]},"MemoryTransform":{"description":"Memory configuration - can be static (MemoryConfig), JavaScript expression, or AI-determined","oneOf":[{"$ref":"#/components/schemas/StaticMemoryTransform"},{"$ref":"#/components/schemas/JavascriptTransform"},{"$ref":"#/components/schemas/AiTransform"}],"discriminator":{"propertyName":"type","mapping":{"static":"#/components/schemas/StaticMemoryTransform","javascript":"#/components/schemas/JavascriptTransform","ai":"#/components/schemas/AiTransform"}}},"FlowModuleValue":{"description":"The actual implementation of a flow step. Can be a script (inline or referenced), subflow, loop, branch, or special module type","oneOf":[{"$ref":"#/components/schemas/RawScript"},{"$ref":"#/components/schemas/PathScript"},{"$ref":"#/components/schemas/PathFlow"},{"$ref":"#/components/schemas/ForloopFlow"},{"$ref":"#/components/schemas/WhileloopFlow"},{"$ref":"#/components/schemas/BranchOne"},{"$ref":"#/components/schemas/BranchAll"},{"$ref":"#/components/schemas/Identity"},{"$ref":"#/components/schemas/AiAgent"}],"discriminator":{"propertyName":"type","mapping":{"rawscript":"#/components/schemas/RawScript","script":"#/components/schemas/PathScript","flow":"#/components/schemas/PathFlow","forloopflow":"#/components/schemas/ForloopFlow","whileloopflow":"#/components/schemas/WhileloopFlow","branchone":"#/components/schemas/BranchOne","branchall":"#/components/schemas/BranchAll","identity":"#/components/schemas/Identity","aiagent":"#/components/schemas/AiAgent"}}},"RawScript":{"type":"object","description":"Inline script with code defined directly in the flow. Use 'bun' as default language if unspecified. The script receives arguments from input_transforms","properties":{"input_transforms":{"type":"object","description":"Map of parameter names to their values (static or JavaScript expressions). These become the script's input arguments","additionalProperties":{"$ref":"#/components/schemas/InputTransform"}},"content":{"type":"string","description":"The script source code. Should export a 'main' function"},"language":{"type":"string","description":"Programming language for this script","enum":["deno","bun","python3","go","bash","powershell","postgresql","mysql","bigquery","snowflake","mssql","oracledb","graphql","nativets","php","rust","ansible","csharp","nu","java","ruby","rlang","duckdb"]},"path":{"type":"string","description":"Optional path for saving this script"},"lock":{"type":"string","description":"Lock file content for dependencies"},"type":{"type":"string","enum":["rawscript"]},"tag":{"type":"string","description":"Worker group tag for execution routing"},"concurrent_limit":{"type":"number","description":"Maximum concurrent executions of this script"},"concurrency_time_window_s":{"type":"number","description":"Time window for concurrent_limit"},"custom_concurrency_key":{"type":"string","description":"Custom key for grouping concurrent executions"},"is_trigger":{"type":"boolean","description":"If true, this script is a trigger that can start the flow"},"assets":{"type":"array","description":"External resources this script accesses (S3 objects, resources, etc.)","items":{"type":"object","required":["path","kind"],"properties":{"path":{"type":"string","description":"Path to the asset"},"kind":{"type":"string","description":"Type of asset","enum":["s3object","resource","ducklake","datatable","volume"]},"access_type":{"type":"string","nullable":true,"description":"Access level for this asset","enum":["r","w","rw"]},"alt_access_type":{"type":"string","nullable":true,"description":"Alternative access level","enum":["r","w","rw"]}}}}},"required":["type","content","language","input_transforms"]},"PathScript":{"type":"object","description":"Reference to an existing script by path. Use this when calling a previously saved script instead of writing inline code","properties":{"input_transforms":{"type":"object","description":"Map of parameter names to their values (static or JavaScript expressions). These become the script's input arguments","additionalProperties":{"$ref":"#/components/schemas/InputTransform"}},"path":{"type":"string","description":"Path to the script in the workspace (e.g., 'f/scripts/send_email')"},"hash":{"type":"string","description":"Optional specific version hash of the script to use"},"type":{"type":"string","enum":["script"]},"tag_override":{"type":"string","description":"Override the script's default worker group tag"},"is_trigger":{"type":"boolean","description":"If true, this script is a trigger that can start the flow"}},"required":["type","path","input_transforms"]},"PathFlow":{"type":"object","description":"Reference to an existing flow by path. Use this to call another flow as a subflow","properties":{"input_transforms":{"type":"object","description":"Map of parameter names to their values (static or JavaScript expressions). These become the subflow's input arguments","additionalProperties":{"$ref":"#/components/schemas/InputTransform"}},"path":{"type":"string","description":"Path to the flow in the workspace (e.g., 'f/flows/process_user')"},"type":{"type":"string","enum":["flow"]}},"required":["type","path","input_transforms"]},"ForloopFlow":{"type":"object","description":"Executes nested modules in a loop over an iterator. Inside the loop, use 'flow_input.iter.value' to access the current iteration value, and 'flow_input.iter.index' for the index. Supports parallel execution for better performance on I/O-bound operations","properties":{"modules":{"type":"array","description":"Steps to execute for each iteration. These can reference the iteration value via 'flow_input.iter.value'","items":{"$ref":"#/components/schemas/FlowModule"}},"iterator":{"description":"JavaScript expression that returns an array to iterate over. Can reference 'results.step_id' or 'flow_input'","$ref":"#/components/schemas/InputTransform"},"skip_failures":{"type":"boolean","description":"If true, iteration failures don't stop the loop. Failed iterations return null"},"type":{"type":"string","enum":["forloopflow"]},"parallel":{"type":"boolean","description":"If true, iterations run concurrently (faster for I/O-bound operations). Use with parallelism to control concurrency"},"parallelism":{"description":"Maximum number of concurrent iterations when parallel=true. Limits resource usage. Can be static number or expression","$ref":"#/components/schemas/InputTransform"},"squash":{"type":"boolean"}},"required":["modules","iterator","skip_failures","type"]},"WhileloopFlow":{"type":"object","description":"Executes nested modules repeatedly while a condition is true. The loop checks the condition after each iteration. Use stop_after_if on modules to control loop termination","properties":{"modules":{"type":"array","description":"Steps to execute in each iteration. Use stop_after_if to control when the loop ends","items":{"$ref":"#/components/schemas/FlowModule"}},"skip_failures":{"type":"boolean","description":"If true, iteration failures don't stop the loop. Failed iterations return null"},"type":{"type":"string","enum":["whileloopflow"]},"parallel":{"type":"boolean","description":"If true, iterations run concurrently (use with caution in while loops)"},"parallelism":{"description":"Maximum number of concurrent iterations when parallel=true","$ref":"#/components/schemas/InputTransform"},"squash":{"type":"boolean"}},"required":["modules","skip_failures","type"]},"BranchOne":{"type":"object","description":"Conditional branching where only the first matching branch executes. Branches are evaluated in order, and the first one with a true expression runs. If no branches match, the default branch executes","properties":{"branches":{"type":"array","description":"Array of branches to evaluate in order. The first branch with expr evaluating to true executes","items":{"type":"object","properties":{"summary":{"type":"string","description":"Short description of this branch condition"},"expr":{"type":"string","description":"JavaScript expression that returns boolean. Can use 'results.step_id' or 'flow_input'. First true expr wins"},"modules":{"type":"array","description":"Steps to execute if this branch's expr is true","items":{"$ref":"#/components/schemas/FlowModule"}}},"required":["modules","expr"]}},"default":{"type":"array","description":"Steps to execute if no branch expressions match","items":{"$ref":"#/components/schemas/FlowModule"}},"type":{"type":"string","enum":["branchone"]}},"required":["branches","default","type"]},"BranchAll":{"type":"object","description":"Parallel branching where all branches execute simultaneously. Unlike BranchOne, all branches run regardless of conditions. Useful for executing independent tasks concurrently","properties":{"branches":{"type":"array","description":"Array of branches that all execute (either in parallel or sequentially)","items":{"type":"object","properties":{"summary":{"type":"string","description":"Short description of this branch's purpose"},"skip_failure":{"type":"boolean","description":"If true, failure in this branch doesn't fail the entire flow"},"modules":{"type":"array","description":"Steps to execute in this branch","items":{"$ref":"#/components/schemas/FlowModule"}}},"required":["modules"]}},"type":{"type":"string","enum":["branchall"]},"parallel":{"type":"boolean","description":"If true, all branches execute concurrently. If false, they execute sequentially"}},"required":["branches","type"]},"AgentTool":{"type":"object","description":"A tool available to an AI agent. Can be a flow module or an external MCP (Model Context Protocol) tool","properties":{"id":{"type":"string","description":"Unique identifier for this tool. Cannot contain spaces - use underscores instead (e.g., 'get_user_data' not 'get user data')"},"summary":{"type":"string","description":"Short description of what this tool does (shown to the AI)"},"value":{"$ref":"#/components/schemas/ToolValue"}},"required":["id","value"]},"ToolValue":{"description":"The implementation of a tool. Can be a flow module (script/flow) or an MCP tool reference","oneOf":[{"$ref":"#/components/schemas/FlowModuleTool"},{"$ref":"#/components/schemas/McpToolValue"},{"$ref":"#/components/schemas/WebsearchToolValue"}],"discriminator":{"propertyName":"tool_type","mapping":{"flowmodule":"#/components/schemas/FlowModuleTool","mcp":"#/components/schemas/McpToolValue","websearch":"#/components/schemas/WebsearchToolValue"}}},"FlowModuleTool":{"description":"A tool implemented as a flow module (script, flow, etc.). The AI can call this like any other flow module","allOf":[{"type":"object","properties":{"tool_type":{"type":"string","enum":["flowmodule"]}},"required":["tool_type"]},{"$ref":"#/components/schemas/FlowModuleValue"}]},"WebsearchToolValue":{"type":"object","description":"A tool implemented as a websearch tool. The AI can call this like any other websearch tool","properties":{"tool_type":{"type":"string","enum":["websearch"]}},"required":["tool_type"]},"McpToolValue":{"type":"object","description":"Reference to an external MCP (Model Context Protocol) tool. The AI can call tools from MCP servers","properties":{"tool_type":{"type":"string","enum":["mcp"]},"resource_path":{"type":"string","description":"Path to the MCP resource/server configuration"},"include_tools":{"type":"array","description":"Whitelist of specific tools to include from this MCP server","items":{"type":"string"}},"exclude_tools":{"type":"array","description":"Blacklist of tools to exclude from this MCP server","items":{"type":"string"}}},"required":["tool_type","resource_path"]},"AiAgent":{"type":"object","description":"AI agent step that can use tools to accomplish tasks. The agent receives inputs and can call any of its configured tools to complete the task","properties":{"input_transforms":{"type":"object","description":"Input parameters for the AI agent mapped to their values","properties":{"provider":{"$ref":"#/components/schemas/ProviderTransform"},"output_type":{"allOf":[{"$ref":"#/components/schemas/InputTransform"}],"description":"Output format type.\nValid values: 'text' (default) - plain text response, 'image' - image generation\n"},"user_message":{"allOf":[{"$ref":"#/components/schemas/InputTransform"}],"description":"The user's prompt/message to the AI agent. Supports variable interpolation with flow.input syntax."},"system_prompt":{"allOf":[{"$ref":"#/components/schemas/InputTransform"}],"description":"System instructions that guide the AI's behavior, persona, and response style. Optional."},"streaming":{"allOf":[{"$ref":"#/components/schemas/InputTransform"}],"description":"Boolean. If true, stream the AI response incrementally.\nStreaming events include: token_delta, tool_call, tool_call_arguments, tool_execution, tool_result\n"},"memory":{"$ref":"#/components/schemas/MemoryTransform"},"output_schema":{"allOf":[{"$ref":"#/components/schemas/InputTransform"}],"description":"JSON Schema object defining structured output format. Used when you need the AI to return data in a specific shape.\nSupports standard JSON Schema properties: type, properties, required, items, enum, pattern, minLength, maxLength, minimum, maximum, etc.\nExample: { type: 'object', properties: { name: { type: 'string' }, age: { type: 'integer' } }, required: ['name'] }\n"},"user_attachments":{"allOf":[{"$ref":"#/components/schemas/InputTransform"}],"description":"Array of file references (images or PDFs) for the AI agent.\nFormat: Array<{ bucket: string, key: string }> - S3 object references\nExample: [{ bucket: 'my-bucket', key: 'documents/report.pdf' }]\n"},"max_completion_tokens":{"allOf":[{"$ref":"#/components/schemas/InputTransform"}],"description":"Integer. Maximum number of tokens the AI will generate in its response.\nRange: 1 to 4,294,967,295. Typical values: 256-4096 for most use cases.\n"},"temperature":{"allOf":[{"$ref":"#/components/schemas/InputTransform"}],"description":"Float. Controls randomness/creativity of responses.\nRange: 0.0 to 2.0 (provider-dependent)\n- 0.0 = deterministic, focused responses\n- 0.7 = balanced (common default)\n- 1.0+ = more creative/random\n"},"max_iterations":{"allOf":[{"$ref":"#/components/schemas/InputTransform"}],"description":"Number. Limits how many times the agent can loop through reasoning and tool use.\nRange: 1-1000.\n"}},"required":["provider","user_message","output_type"]},"tools":{"type":"array","description":"Array of tools the agent can use. The agent decides which tools to call based on the task","items":{"$ref":"#/components/schemas/AgentTool"}},"type":{"type":"string","enum":["aiagent"]},"omit_output_from_conversation":{"type":"boolean","default":false,"description":"If true, this AI agent step does not persist its assistant or tool messages to the flow conversation when chat mode is enabled."},"parallel":{"type":"boolean","description":"If true, the agent can execute multiple tool calls in parallel"}},"required":["tools","type","input_transforms"]},"Identity":{"type":"object","description":"Pass-through module that returns its input unchanged. Useful for flow structure or as a placeholder","properties":{"type":{"type":"string","enum":["identity"]},"flow":{"type":"boolean","description":"If true, marks this as a flow identity (special handling)"}},"required":["type"]},"FlowStatus":{"type":"object","properties":{"step":{"type":"integer"},"modules":{"type":"array","items":{"$ref":"#/components/schemas/FlowStatusModule"}},"user_states":{"additionalProperties":true},"preprocessor_module":{"allOf":[{"$ref":"#/components/schemas/FlowStatusModule"}]},"failure_module":{"allOf":[{"$ref":"#/components/schemas/FlowStatusModule"},{"type":"object","properties":{"parent_module":{"type":"string"}}}]},"retry":{"type":"object","properties":{"fail_count":{"type":"integer"},"failed_jobs":{"type":"array","items":{"type":"string","format":"uuid"}}}}},"required":["step","modules","failure_module"]},"FlowStatusModule":{"type":"object","properties":{"type":{"type":"string","enum":["WaitingForPriorSteps","WaitingForEvents","WaitingForExecutor","InProgress","Success","Failure"]},"id":{"type":"string"},"job":{"type":"string","format":"uuid"},"count":{"type":"integer"},"progress":{"type":"integer"},"iterator":{"type":"object","properties":{"index":{"type":"integer"},"itered":{"type":"array","items":{}},"itered_len":{"type":"integer"},"args":{}}},"flow_jobs":{"type":"array","items":{"type":"string"}},"flow_jobs_success":{"type":"array","items":{"type":"boolean"}},"flow_jobs_duration":{"type":"object","properties":{"started_at":{"type":"array","items":{"type":"string"}},"duration_ms":{"type":"array","items":{"type":"integer"}}}},"branch_chosen":{"type":"object","properties":{"type":{"type":"string","enum":["branch","default"]},"branch":{"type":"integer"}},"required":["type"]},"branchall":{"type":"object","properties":{"branch":{"type":"integer"},"len":{"type":"integer"}},"required":["branch","len"]},"approvers":{"type":"array","items":{"type":"object","properties":{"resume_id":{"type":"integer"},"approver":{"type":"string"}},"required":["resume_id","approver"]}},"failed_retries":{"type":"array","items":{"type":"string","format":"uuid"}},"skipped":{"type":"boolean"},"agent_actions":{"type":"array","items":{"type":"object","oneOf":[{"type":"object","properties":{"job_id":{"type":"string","format":"uuid"},"function_name":{"type":"string"},"type":{"type":"string","enum":["tool_call"]},"module_id":{"type":"string"}},"required":["job_id","function_name","type","module_id"]},{"type":"object","properties":{"call_id":{"type":"string","format":"uuid"},"function_name":{"type":"string"},"resource_path":{"type":"string"},"type":{"type":"string","enum":["mcp_tool_call"]},"arguments":{"type":"object"}},"required":["call_id","function_name","resource_path","type"]},{"type":"object","properties":{"type":{"type":"string","enum":["web_search"]}},"required":["type"]},{"type":"object","properties":{"type":{"type":"string","enum":["message"]}},"required":["content","type"]}]}},"agent_actions_success":{"type":"array","items":{"type":"boolean"}}},"required":["type"]}}
\ No newline at end of file
+{"OpenFlow":{"type":"object","description":"Top-level flow definition containing metadata, configuration, and the flow structure","properties":{"summary":{"type":"string","description":"Short description of what this flow does"},"description":{"type":"string","description":"Detailed documentation for this flow"},"value":{"$ref":"#/components/schemas/FlowValue"},"schema":{"type":"object","description":"JSON Schema for flow inputs. Use this to define input parameters, their types, defaults, and validation. For resource inputs, set type to 'object' and format to 'resource-<type>' (e.g., 'resource-stripe')"},"on_behalf_of_email":{"type":"string","description":"The flow will be run with the permissions of the user with this email."}},"required":["summary","value"]},"FlowValue":{"type":"object","description":"The flow structure containing modules and optional preprocessor/failure handlers","properties":{"modules":{"type":"array","description":"Array of steps that execute in sequence. Each step can be a script, subflow, loop, or branch","items":{"$ref":"#/components/schemas/FlowModule"}},"failure_module":{"description":"Special module that executes when the flow fails. Receives error object with message, name, stack, and step_id. Must have id 'failure'. Only supports script/rawscript types","$ref":"#/components/schemas/FlowModule"},"preprocessor_module":{"description":"Special module that runs before the first step on external triggers. Must have id 'preprocessor'. Only supports script/rawscript types. Cannot reference other step results","$ref":"#/components/schemas/FlowModule"},"same_worker":{"type":"boolean","description":"If true, all steps run on the same worker for better performance"},"preserve_step_tags":{"type":"boolean","description":"If true and the flow runs on a custom worker tag, steps that declare their own non-empty tag run on it instead of inheriting the flow tag. Steps without their own tag still inherit the flow tag."},"concurrent_limit":{"type":"number","description":"Maximum number of concurrent executions of this flow"},"concurrency_key":{"type":"string","description":"Expression to group concurrent executions (e.g., by user ID)"},"concurrency_time_window_s":{"type":"number","description":"Time window in seconds for concurrent_limit"},"debounce_delay_s":{"type":"integer","description":"Delay in seconds to debounce flow executions"},"debounce_key":{"type":"string","description":"Expression to group debounced executions"},"debounce_args_to_accumulate":{"type":"array","description":"Arguments to accumulate across debounced executions","items":{"type":"string"}},"max_total_debouncing_time":{"type":"integer","description":"Maximum total time in seconds that a job can be debounced"},"max_total_debounces_amount":{"type":"integer","description":"Maximum number of times a job can be debounced"},"skip_expr":{"type":"string","description":"JavaScript expression to conditionally skip the entire flow"},"cache_ttl":{"type":"number","description":"Cache duration in seconds for flow results"},"cache_ignore_s3_path":{"type":"boolean"},"delete_after_secs":{"type":"integer","description":"If set, delete the flow job's args, result and logs after this many seconds following job completion"},"flow_env":{"type":"object","description":"Environment variables available to all steps. Values can be strings, JSON values, or special references: '$var:path' (workspace variable) or '$res:path' (resource).","additionalProperties":{}},"priority":{"type":"number","description":"Execution priority (higher numbers run first)"},"early_return":{"type":"string","description":"JavaScript expression to return early from the flow"},"chat_input_enabled":{"type":"boolean","description":"Whether this flow accepts chat-style input"},"notes":{"type":"array","description":"Sticky notes attached to the flow","items":{"$ref":"#/components/schemas/FlowNote"}},"groups":{"type":"array","description":"Semantic groups of modules for organizational purposes","items":{"$ref":"#/components/schemas/FlowGroup"}}},"required":["modules"]},"Retry":{"type":"object","description":"Retry configuration for failed module executions","properties":{"constant":{"type":"object","description":"Retry with constant delay between attempts","properties":{"attempts":{"type":"integer","description":"Number of retry attempts"},"seconds":{"type":"integer","description":"Seconds to wait between retries"}}},"exponential":{"type":"object","description":"Retry with exponential backoff (delay doubles each time)","properties":{"attempts":{"type":"integer","description":"Number of retry attempts"},"multiplier":{"type":"integer","description":"Multiplier for exponential backoff"},"seconds":{"type":"integer","minimum":1,"description":"Initial delay in seconds"},"random_factor":{"type":"integer","minimum":0,"maximum":100,"description":"Random jitter percentage (0-100) to avoid thundering herd"}}},"retry_if":{"$ref":"#/components/schemas/RetryIf"}}},"FlowNote":{"type":"object","description":"A sticky note attached to a flow for documentation and annotation","properties":{"id":{"type":"string","description":"Unique identifier for the note"},"text":{"type":"string","description":"Content of the note"},"position":{"type":"object","description":"Position of the note in the flow editor","properties":{"x":{"type":"number","description":"X coordinate"},"y":{"type":"number","description":"Y coordinate"}},"required":["x","y"]},"size":{"type":"object","description":"Size of the note in the flow editor","properties":{"width":{"type":"number","description":"Width in pixels"},"height":{"type":"number","description":"Height in pixels"}},"required":["width","height"]},"color":{"type":"string","description":"Color of the note (e.g., \"yellow\", \"#ffff00\")"},"type":{"type":"string","enum":["free","group"],"description":"Type of note - 'free' for standalone notes, 'group' for notes that group other nodes"},"locked":{"type":"boolean","default":false,"description":"Whether the note is locked and cannot be edited or moved"},"contained_node_ids":{"type":"array","items":{"type":"string"},"description":"For group notes, the IDs of nodes contained within this group"}},"required":["id","text","color","type"]},"FlowGroup":{"type":"object","description":"A semantic group of flow modules for organizational purposes. Does not affect execution \u2014 modules remain in their original position in the flow. Groups provide naming and collapsibility in the editor. Members are computed dynamically from all nodes on paths between start_id and end_id.","properties":{"summary":{"type":"string","description":"Display name for this group"},"note":{"type":"string","description":"Markdown note shown below the group header"},"autocollapse":{"type":"boolean","default":false,"description":"If true, this group is collapsed by default in the flow editor. UI hint only."},"start_id":{"type":"string","description":"ID of the first flow module in this group (topological entry point)"},"end_id":{"type":"string","description":"ID of the last flow module in this group (topological exit point)"},"color":{"type":"string","description":"Color for the group in the flow editor"}},"required":["start_id","end_id"]},"RetryIf":{"type":"object","description":"Conditional retry based on error or result","properties":{"expr":{"type":"string","description":"JavaScript expression that returns true to retry. Has access to 'result' and 'error' variables"}},"required":["expr"]},"StopAfterIf":{"type":"object","description":"Early termination condition for a module","properties":{"skip_if_stopped":{"type":"boolean","description":"If true, following steps are skipped when this condition triggers"},"expr":{"type":"string","description":"JavaScript expression evaluated after the module runs. Can use 'result' (step's result) or 'flow_input'. Return true to stop"},"error_message":{"type":"string","nullable":true,"description":"Custom error message when stopping with an error. Mutually exclusive with skip_if_stopped. If set to a non-empty string, the flow stops with this error. If empty string, a default error message is used. If null or omitted, no error is raised."}},"required":["expr"]},"FlowModule":{"type":"object","description":"A single step in a flow. Can be a script, subflow, loop, or branch","properties":{"id":{"type":"string","description":"Unique identifier for this step. Used to reference results via 'results.step_id'. Must be a valid identifier (alphanumeric, underscore, hyphen)"},"value":{"$ref":"#/components/schemas/FlowModuleValue"},"stop_after_if":{"description":"Early termination condition evaluated after this step completes","$ref":"#/components/schemas/StopAfterIf"},"stop_after_all_iters_if":{"description":"For loops only - early termination condition evaluated after all iterations complete","$ref":"#/components/schemas/StopAfterIf"},"skip_if":{"type":"object","description":"Conditionally skip this step based on previous results or flow inputs","properties":{"expr":{"type":"string","description":"JavaScript expression that returns true to skip. Can use 'flow_input' or 'results.<step_id>'"}},"required":["expr"]},"sleep":{"description":"Delay before executing this step (in seconds or as expression)","$ref":"#/components/schemas/InputTransform"},"cache_ttl":{"type":"number","description":"Cache duration in seconds for this step's results"},"cache_ignore_s3_path":{"type":"boolean"},"timeout":{"description":"Maximum execution time in seconds (static value or expression)","$ref":"#/components/schemas/InputTransform"},"delete_after_secs":{"type":"integer","description":"If set, delete the step's args, result and logs after this many seconds following job completion"},"summary":{"type":"string","description":"Short description of what this step does"},"mock":{"type":"object","description":"Mock configuration for testing without executing the actual step","properties":{"enabled":{"type":"boolean","description":"If true, return mock value instead of executing"},"return_value":{"description":"Value to return when mocked"}}},"suspend":{"type":"object","description":"Configuration for approval/resume steps that wait for user input","properties":{"required_events":{"type":"integer","description":"Number of approvals required before continuing"},"timeout":{"type":"integer","description":"Timeout in seconds before auto-continuing or canceling"},"resume_form":{"type":"object","description":"Form schema for collecting input when resuming","properties":{"schema":{"type":"object","description":"JSON Schema for the resume form"}}},"user_auth_required":{"type":"boolean","description":"If true, only authenticated users can approve"},"user_groups_required":{"description":"Expression or list of groups that can approve","$ref":"#/components/schemas/InputTransform"},"self_approval_disabled":{"type":"boolean","description":"If true, the user who started the flow cannot approve"},"hide_cancel":{"type":"boolean","description":"If true, hide the cancel button on the approval form"},"continue_on_disapprove_timeout":{"type":"boolean","description":"If true, continue flow on timeout instead of canceling"}}},"priority":{"type":"number","description":"Execution priority for this step (higher numbers run first)"},"continue_on_error":{"type":"boolean","description":"If true, flow continues even if this step fails"},"retry":{"description":"Retry configuration if this step fails","$ref":"#/components/schemas/Retry"},"debouncing":{"description":"Debounce configuration for this step (EE only)","type":"object","properties":{"debounce_delay_s":{"type":"integer","description":"Delay in seconds to debounce this step's executions across flow runs"},"debounce_key":{"type":"string","description":"Expression to group debounced executions. Supports $workspace and $args[name]. Default: $workspace/flow/<flow_path>-<step_id>"},"debounce_args_to_accumulate":{"type":"array","description":"Array-type arguments to accumulate across debounced executions","items":{"type":"string"}},"max_total_debouncing_time":{"type":"integer","description":"Maximum total time in seconds before forced execution"},"max_total_debounces_amount":{"type":"integer","description":"Maximum number of debounces before forced execution"}}}},"required":["value","id"]},"InputTransform":{"description":"Maps input parameters for a step. Can be a static value or a JavaScript expression that references previous results or flow inputs","oneOf":[{"$ref":"#/components/schemas/StaticTransform"},{"$ref":"#/components/schemas/JavascriptTransform"},{"$ref":"#/components/schemas/AiTransform"}],"discriminator":{"propertyName":"type","mapping":{"static":"#/components/schemas/StaticTransform","javascript":"#/components/schemas/JavascriptTransform","ai":"#/components/schemas/AiTransform"}}},"StaticTransform":{"type":"object","description":"Static value passed directly to the step. Use for hardcoded values or resource references like '$res:path/to/resource'","properties":{"value":{"description":"The static value. For resources, use format '$res:path/to/resource'"},"type":{"type":"string","enum":["static"]}},"required":["type"]},"JavascriptTransform":{"type":"object","description":"JavaScript expression evaluated at runtime. Can reference previous step results via 'results.step_id' or flow inputs via 'flow_input.property'. Inside loops, use 'flow_input.iter.value' for the current iteration value","properties":{"expr":{"type":"string","description":"JavaScript expression returning the value. Available variables - results (object with all previous step results), flow_input (flow inputs), flow_input.iter (in loops)"},"type":{"type":"string","enum":["javascript"]}},"required":["expr","type"]},"AiTransform":{"type":"object","description":"Value resolved by the AI runtime for this input. The AI engine decides how to satisfy the parameter.","properties":{"type":{"type":"string","enum":["ai"]}},"required":["type"]},"AIProviderKind":{"type":"string","description":"Supported AI provider types","enum":["openai","azure_openai","anthropic","mistral","deepseek","googleai","groq","openrouter","togetherai","customai","aws_bedrock"]},"ProviderConfig":{"type":"object","description":"Complete AI provider configuration with resource reference and model selection","properties":{"kind":{"$ref":"#/components/schemas/AIProviderKind"},"resource":{"type":"string","description":"Resource reference in format '$res:{resource_path}' pointing to provider credentials"},"model":{"type":"string","description":"Model identifier (e.g., 'gpt-4', 'claude-3-opus-20240229', 'gemini-pro')"}},"required":["kind","resource","model"]},"StaticProviderTransform":{"type":"object","description":"Static provider configuration passed directly to the AI agent","properties":{"value":{"$ref":"#/components/schemas/ProviderConfig"},"type":{"type":"string","enum":["static"]}},"required":["type","value"]},"ProviderTransform":{"description":"Provider configuration - can be static (ProviderConfig), JavaScript expression, or AI-determined","oneOf":[{"$ref":"#/components/schemas/StaticProviderTransform"},{"$ref":"#/components/schemas/JavascriptTransform"},{"$ref":"#/components/schemas/AiTransform"}],"discriminator":{"propertyName":"type","mapping":{"static":"#/components/schemas/StaticProviderTransform","javascript":"#/components/schemas/JavascriptTransform","ai":"#/components/schemas/AiTransform"}}},"MemoryOff":{"type":"object","description":"No conversation memory/context","properties":{"kind":{"type":"string","enum":["off"]}},"required":["kind"]},"MemoryAuto":{"type":"object","description":"Automatic context management","properties":{"kind":{"type":"string","enum":["auto"]},"context_length":{"type":"integer","description":"Maximum number of messages to retain in context"},"memory_id":{"type":"string","description":"Identifier for persistent memory across agent invocations"}},"required":["kind"]},"MemoryMessage":{"type":"object","description":"A single message in conversation history","properties":{"role":{"type":"string","enum":["user","assistant","system"]},"content":{"type":"string"}},"required":["role","content"]},"MemoryManual":{"type":"object","description":"Explicit message history","properties":{"kind":{"type":"string","enum":["manual"]},"messages":{"type":"array","items":{"$ref":"#/components/schemas/MemoryMessage"}}},"required":["kind","messages"]},"MemoryConfig":{"description":"Conversation memory configuration","oneOf":[{"$ref":"#/components/schemas/MemoryOff"},{"$ref":"#/components/schemas/MemoryAuto"},{"$ref":"#/components/schemas/MemoryManual"}],"discriminator":{"propertyName":"kind","mapping":{"off":"#/components/schemas/MemoryOff","auto":"#/components/schemas/MemoryAuto","manual":"#/components/schemas/MemoryManual"}}},"StaticMemoryTransform":{"type":"object","description":"Static memory configuration passed directly to the AI agent","properties":{"value":{"$ref":"#/components/schemas/MemoryConfig"},"type":{"type":"string","enum":["static"]}},"required":["type","value"]},"MemoryTransform":{"description":"Memory configuration - can be static (MemoryConfig), JavaScript expression, or AI-determined","oneOf":[{"$ref":"#/components/schemas/StaticMemoryTransform"},{"$ref":"#/components/schemas/JavascriptTransform"},{"$ref":"#/components/schemas/AiTransform"}],"discriminator":{"propertyName":"type","mapping":{"static":"#/components/schemas/StaticMemoryTransform","javascript":"#/components/schemas/JavascriptTransform","ai":"#/components/schemas/AiTransform"}}},"FlowModuleValue":{"description":"The actual implementation of a flow step. Can be a script (inline or referenced), subflow, loop, branch, or special module type","oneOf":[{"$ref":"#/components/schemas/RawScript"},{"$ref":"#/components/schemas/PathScript"},{"$ref":"#/components/schemas/PathFlow"},{"$ref":"#/components/schemas/ForloopFlow"},{"$ref":"#/components/schemas/WhileloopFlow"},{"$ref":"#/components/schemas/BranchOne"},{"$ref":"#/components/schemas/BranchAll"},{"$ref":"#/components/schemas/Identity"},{"$ref":"#/components/schemas/AiAgent"}],"discriminator":{"propertyName":"type","mapping":{"rawscript":"#/components/schemas/RawScript","script":"#/components/schemas/PathScript","flow":"#/components/schemas/PathFlow","forloopflow":"#/components/schemas/ForloopFlow","whileloopflow":"#/components/schemas/WhileloopFlow","branchone":"#/components/schemas/BranchOne","branchall":"#/components/schemas/BranchAll","identity":"#/components/schemas/Identity","aiagent":"#/components/schemas/AiAgent"}}},"RawScript":{"type":"object","description":"Inline script with code defined directly in the flow. Use 'bun' as default language if unspecified. The script receives arguments from input_transforms","properties":{"input_transforms":{"type":"object","description":"Map of parameter names to their values (static or JavaScript expressions). These become the script's input arguments","additionalProperties":{"$ref":"#/components/schemas/InputTransform"}},"content":{"type":"string","description":"The script source code. Should export a 'main' function"},"language":{"type":"string","description":"Programming language for this script","enum":["deno","bun","python3","go","bash","powershell","postgresql","mysql","bigquery","snowflake","mssql","oracledb","graphql","nativets","php","rust","ansible","csharp","nu","java","ruby","rlang","duckdb"]},"path":{"type":"string","description":"Optional path for saving this script"},"lock":{"type":"string","description":"Lock file content for dependencies"},"type":{"type":"string","enum":["rawscript"]},"tag":{"type":"string","description":"Worker group tag for execution routing"},"concurrent_limit":{"type":"number","description":"Maximum concurrent executions of this script"},"concurrency_time_window_s":{"type":"number","description":"Time window for concurrent_limit"},"custom_concurrency_key":{"type":"string","description":"Custom key for grouping concurrent executions"},"is_trigger":{"type":"boolean","description":"If true, this script is a trigger that can start the flow"},"assets":{"type":"array","description":"External resources this script accesses (S3 objects, resources, etc.)","items":{"type":"object","required":["path","kind"],"properties":{"path":{"type":"string","description":"Path to the asset"},"kind":{"type":"string","description":"Type of asset","enum":["s3object","resource","ducklake","datatable","volume"]},"access_type":{"type":"string","nullable":true,"description":"Access level for this asset","enum":["r","w","rw"]},"alt_access_type":{"type":"string","nullable":true,"description":"Alternative access level","enum":["r","w","rw"]}}}}},"required":["type","content","language","input_transforms"]},"PathScript":{"type":"object","description":"Reference to an existing script by path. Use this when calling a previously saved script instead of writing inline code","properties":{"input_transforms":{"type":"object","description":"Map of parameter names to their values (static or JavaScript expressions). These become the script's input arguments","additionalProperties":{"$ref":"#/components/schemas/InputTransform"}},"path":{"type":"string","description":"Path to the script in the workspace (e.g., 'f/scripts/send_email')"},"hash":{"type":"string","description":"Optional specific version hash of the script to use"},"type":{"type":"string","enum":["script"]},"tag_override":{"type":"string","description":"Override the script's default worker group tag"},"is_trigger":{"type":"boolean","description":"If true, this script is a trigger that can start the flow"}},"required":["type","path","input_transforms"]},"PathFlow":{"type":"object","description":"Reference to an existing flow by path. Use this to call another flow as a subflow","properties":{"input_transforms":{"type":"object","description":"Map of parameter names to their values (static or JavaScript expressions). These become the subflow's input arguments","additionalProperties":{"$ref":"#/components/schemas/InputTransform"}},"path":{"type":"string","description":"Path to the flow in the workspace (e.g., 'f/flows/process_user')"},"type":{"type":"string","enum":["flow"]}},"required":["type","path","input_transforms"]},"ForloopFlow":{"type":"object","description":"Executes nested modules in a loop over an iterator. Inside the loop, use 'flow_input.iter.value' to access the current iteration value, and 'flow_input.iter.index' for the index. Supports parallel execution for better performance on I/O-bound operations","properties":{"modules":{"type":"array","description":"Steps to execute for each iteration. These can reference the iteration value via 'flow_input.iter.value'","items":{"$ref":"#/components/schemas/FlowModule"}},"iterator":{"description":"JavaScript expression that returns an array to iterate over. Can reference 'results.step_id' or 'flow_input'","$ref":"#/components/schemas/InputTransform"},"skip_failures":{"type":"boolean","description":"If true, iteration failures don't stop the loop. Failed iterations return null"},"type":{"type":"string","enum":["forloopflow"]},"parallel":{"type":"boolean","description":"If true, iterations run concurrently (faster for I/O-bound operations). Use with parallelism to control concurrency"},"parallelism":{"description":"Maximum number of concurrent iterations when parallel=true. Limits resource usage. Can be static number or expression","$ref":"#/components/schemas/InputTransform"},"squash":{"type":"boolean"}},"required":["modules","iterator","skip_failures","type"]},"WhileloopFlow":{"type":"object","description":"Executes nested modules repeatedly while a condition is true. The loop checks the condition after each iteration. Use stop_after_if on modules to control loop termination","properties":{"modules":{"type":"array","description":"Steps to execute in each iteration. Use stop_after_if to control when the loop ends","items":{"$ref":"#/components/schemas/FlowModule"}},"skip_failures":{"type":"boolean","description":"If true, iteration failures don't stop the loop. Failed iterations return null"},"type":{"type":"string","enum":["whileloopflow"]},"parallel":{"type":"boolean","description":"If true, iterations run concurrently (use with caution in while loops)"},"parallelism":{"description":"Maximum number of concurrent iterations when parallel=true","$ref":"#/components/schemas/InputTransform"},"squash":{"type":"boolean"}},"required":["modules","skip_failures","type"]},"BranchOne":{"type":"object","description":"Conditional branching where only the first matching branch executes. Branches are evaluated in order, and the first one with a true expression runs. If no branches match, the default branch executes","properties":{"branches":{"type":"array","description":"Array of branches to evaluate in order. The first branch with expr evaluating to true executes","items":{"type":"object","properties":{"summary":{"type":"string","description":"Short description of this branch condition"},"expr":{"type":"string","description":"JavaScript expression that returns boolean. Can use 'results.step_id' or 'flow_input'. First true expr wins"},"modules":{"type":"array","description":"Steps to execute if this branch's expr is true","items":{"$ref":"#/components/schemas/FlowModule"}}},"required":["modules","expr"]}},"default":{"type":"array","description":"Steps to execute if no branch expressions match","items":{"$ref":"#/components/schemas/FlowModule"}},"type":{"type":"string","enum":["branchone"]}},"required":["branches","default","type"]},"BranchAll":{"type":"object","description":"Parallel branching where all branches execute simultaneously. Unlike BranchOne, all branches run regardless of conditions. Useful for executing independent tasks concurrently","properties":{"branches":{"type":"array","description":"Array of branches that all execute (either in parallel or sequentially)","items":{"type":"object","properties":{"summary":{"type":"string","description":"Short description of this branch's purpose"},"skip_failure":{"type":"boolean","description":"If true, failure in this branch doesn't fail the entire flow"},"modules":{"type":"array","description":"Steps to execute in this branch","items":{"$ref":"#/components/schemas/FlowModule"}}},"required":["modules"]}},"type":{"type":"string","enum":["branchall"]},"parallel":{"type":"boolean","description":"If true, all branches execute concurrently. If false, they execute sequentially"}},"required":["branches","type"]},"AgentTool":{"type":"object","description":"A tool available to an AI agent. Can be a flow module or an external MCP (Model Context Protocol) tool","properties":{"id":{"type":"string","description":"Unique identifier for this tool. Cannot contain spaces - use underscores instead (e.g., 'get_user_data' not 'get user data')"},"summary":{"type":"string","description":"Short description of what this tool does (shown to the AI)"},"value":{"$ref":"#/components/schemas/ToolValue"}},"required":["id","value"]},"ToolValue":{"description":"The implementation of a tool. Can be a flow module (script/flow) or an MCP tool reference","oneOf":[{"$ref":"#/components/schemas/FlowModuleTool"},{"$ref":"#/components/schemas/McpToolValue"},{"$ref":"#/components/schemas/WebsearchToolValue"}],"discriminator":{"propertyName":"tool_type","mapping":{"flowmodule":"#/components/schemas/FlowModuleTool","mcp":"#/components/schemas/McpToolValue","websearch":"#/components/schemas/WebsearchToolValue"}}},"FlowModuleTool":{"description":"A tool implemented as a flow module (script, flow, etc.). The AI can call this like any other flow module","allOf":[{"type":"object","properties":{"tool_type":{"type":"string","enum":["flowmodule"]}},"required":["tool_type"]},{"$ref":"#/components/schemas/FlowModuleValue"}]},"WebsearchToolValue":{"type":"object","description":"A tool implemented as a websearch tool. The AI can call this like any other websearch tool","properties":{"tool_type":{"type":"string","enum":["websearch"]}},"required":["tool_type"]},"McpToolValue":{"type":"object","description":"Reference to an external MCP (Model Context Protocol) tool. The AI can call tools from MCP servers","properties":{"tool_type":{"type":"string","enum":["mcp"]},"resource_path":{"type":"string","description":"Path to the MCP resource/server configuration"},"include_tools":{"type":"array","description":"Whitelist of specific tools to include from this MCP server","items":{"type":"string"}},"exclude_tools":{"type":"array","description":"Blacklist of tools to exclude from this MCP server","items":{"type":"string"}}},"required":["tool_type","resource_path"]},"AiAgent":{"type":"object","description":"AI agent step that can use tools to accomplish tasks. The agent receives inputs and can call any of its configured tools to complete the task","properties":{"input_transforms":{"type":"object","description":"Input parameters for the AI agent mapped to their values","properties":{"provider":{"$ref":"#/components/schemas/ProviderTransform"},"output_type":{"allOf":[{"$ref":"#/components/schemas/InputTransform"}],"description":"Output format type.\nValid values: 'text' (default) - plain text response, 'image' - image generation\n"},"user_message":{"allOf":[{"$ref":"#/components/schemas/InputTransform"}],"description":"The user's prompt/message to the AI agent. Supports variable interpolation with flow.input syntax."},"system_prompt":{"allOf":[{"$ref":"#/components/schemas/InputTransform"}],"description":"System instructions that guide the AI's behavior, persona, and response style. Optional."},"streaming":{"allOf":[{"$ref":"#/components/schemas/InputTransform"}],"description":"Boolean. If true, stream the AI response incrementally.\nStreaming events include: token_delta, tool_call, tool_call_arguments, tool_execution, tool_result\n"},"memory":{"$ref":"#/components/schemas/MemoryTransform"},"output_schema":{"allOf":[{"$ref":"#/components/schemas/InputTransform"}],"description":"JSON Schema object defining structured output format. Used when you need the AI to return data in a specific shape.\nSupports standard JSON Schema properties: type, properties, required, items, enum, pattern, minLength, maxLength, minimum, maximum, etc.\nExample: { type: 'object', properties: { name: { type: 'string' }, age: { type: 'integer' } }, required: ['name'] }\n"},"user_attachments":{"allOf":[{"$ref":"#/components/schemas/InputTransform"}],"description":"Array of file references (images or PDFs) for the AI agent.\nFormat: Array<{ bucket: string, key: string }> - S3 object references\nExample: [{ bucket: 'my-bucket', key: 'documents/report.pdf' }]\n"},"max_completion_tokens":{"allOf":[{"$ref":"#/components/schemas/InputTransform"}],"description":"Integer. Maximum number of tokens the AI will generate in its response.\nRange: 1 to 4,294,967,295. Typical values: 256-4096 for most use cases.\n"},"temperature":{"allOf":[{"$ref":"#/components/schemas/InputTransform"}],"description":"Float. Controls randomness/creativity of responses.\nRange: 0.0 to 2.0 (provider-dependent)\n- 0.0 = deterministic, focused responses\n- 0.7 = balanced (common default)\n- 1.0+ = more creative/random\n"},"max_iterations":{"allOf":[{"$ref":"#/components/schemas/InputTransform"}],"description":"Number. Limits how many times the agent can loop through reasoning and tool use.\nRange: 1-1000.\n"}},"required":["provider","user_message","output_type"]},"tools":{"type":"array","description":"Array of tools the agent can use. The agent decides which tools to call based on the task","items":{"$ref":"#/components/schemas/AgentTool"}},"type":{"type":"string","enum":["aiagent"]},"omit_output_from_conversation":{"type":"boolean","default":false,"description":"If true, this AI agent step does not persist its assistant or tool messages to the flow conversation when chat mode is enabled."},"parallel":{"type":"boolean","description":"If true, the agent can execute multiple tool calls in parallel"}},"required":["tools","type","input_transforms"]},"Identity":{"type":"object","description":"Pass-through module that returns its input unchanged. Useful for flow structure or as a placeholder","properties":{"type":{"type":"string","enum":["identity"]},"flow":{"type":"boolean","description":"If true, marks this as a flow identity (special handling)"}},"required":["type"]},"FlowStatus":{"type":"object","properties":{"step":{"type":"integer"},"modules":{"type":"array","items":{"$ref":"#/components/schemas/FlowStatusModule"}},"user_states":{"additionalProperties":true},"preprocessor_module":{"allOf":[{"$ref":"#/components/schemas/FlowStatusModule"}]},"failure_module":{"allOf":[{"$ref":"#/components/schemas/FlowStatusModule"},{"type":"object","properties":{"parent_module":{"type":"string"}}}]},"retry":{"type":"object","properties":{"fail_count":{"type":"integer"},"failed_jobs":{"type":"array","items":{"type":"string","format":"uuid"}}}}},"required":["step","modules","failure_module"]},"FlowStatusModule":{"type":"object","properties":{"type":{"type":"string","enum":["WaitingForPriorSteps","WaitingForEvents","WaitingForExecutor","InProgress","Success","Failure"]},"id":{"type":"string"},"job":{"type":"string","format":"uuid"},"count":{"type":"integer"},"progress":{"type":"integer"},"iterator":{"type":"object","properties":{"index":{"type":"integer"},"itered":{"type":"array","items":{}},"itered_len":{"type":"integer"},"args":{}}},"flow_jobs":{"type":"array","items":{"type":"string"}},"flow_jobs_success":{"type":"array","items":{"type":"boolean"}},"flow_jobs_duration":{"type":"object","properties":{"started_at":{"type":"array","items":{"type":"string"}},"duration_ms":{"type":"array","items":{"type":"integer"}}}},"branch_chosen":{"type":"object","properties":{"type":{"type":"string","enum":["branch","default"]},"branch":{"type":"integer"}},"required":["type"]},"branchall":{"type":"object","properties":{"branch":{"type":"integer"},"len":{"type":"integer"}},"required":["branch","len"]},"approvers":{"type":"array","items":{"type":"object","properties":{"resume_id":{"type":"integer"},"approver":{"type":"string"}},"required":["resume_id","approver"]}},"failed_retries":{"type":"array","items":{"type":"string","format":"uuid"}},"skipped":{"type":"boolean"},"agent_actions":{"type":"array","items":{"type":"object","oneOf":[{"type":"object","properties":{"job_id":{"type":"string","format":"uuid"},"function_name":{"type":"string"},"type":{"type":"string","enum":["tool_call"]},"module_id":{"type":"string"}},"required":["job_id","function_name","type","module_id"]},{"type":"object","properties":{"call_id":{"type":"string","format":"uuid"},"function_name":{"type":"string"},"resource_path":{"type":"string"},"type":{"type":"string","enum":["mcp_tool_call"]},"arguments":{"type":"object"}},"required":["call_id","function_name","resource_path","type"]},{"type":"object","properties":{"type":{"type":"string","enum":["web_search"]}},"required":["type"]},{"type":"object","properties":{"type":{"type":"string","enum":["message"]}},"required":["content","type"]}]}},"agent_actions_success":{"type":"array","items":{"type":"boolean"}}},"required":["type"]}}
\ No newline at end of file
diff --git a/system_prompts/auto-generated/skills/write-script-bunnative/SKILL.md b/system_prompts/auto-generated/skills/write-script-bunnative/SKILL.md
index 89b1bc6f05..3b790959f2 100644
--- a/system_prompts/auto-generated/skills/write-script-bunnative/SKILL.md
+++ b/system_prompts/auto-generated/skills/write-script-bunnative/SKILL.md
@@ -1,6 +1,6 @@
 ---
 name: write-script-bunnative
-description: MUST use when writing Bun Native scripts.
+description: MUST use when writing Bun Native scripts. The script must start with //native to run on the native worker.
 ---
 
 ## CLI Commands
@@ -40,13 +40,14 @@ Use `wmill resource-type list --schema` to discover available resource types.
 
 # TypeScript (Bun Native)
 
-Native TypeScript execution with fetch only - no external imports allowed.
+Native TypeScript execution. Native scripts are Bun scripts that run on the native worker — a lightweight V8 isolate that exposes `fetch` and the JavaScript standard library — and can be heavily parallelized. Every script MUST start with `//native` on its first line so Windmill routes it to the native worker; without it the exact same script runs on the regular Bun worker. You may import npm packages and other Windmill scripts (e.g. `./helper.ts`) — imports are resolved and bundled just like a regular Bun script — as long as everything (your code and its dependencies) relies only on `fetch` and the standard library. Libraries that need Node/Bun runtime APIs (filesystem, `node:*` modules, child processes, native addons) will not work on the native worker; use the regular `bun` language for those.
 
 ## Structure
 
 Export a single **async** function called `main`:
 
 ```typescript
+//native
 export async function main(param1: string, param2: number) {
   // Your code here
   return { result: param1, count: param2 };
@@ -62,6 +63,7 @@ On Windmill, credentials and configuration are stored in resources and passed as
 Use the `RT` namespace for resource types:
 
 ```typescript
+//native
 export async function main(stripe: RT.Stripe) {
   // stripe contains API key and config from the resource
 }
@@ -73,9 +75,10 @@ Before using a resource type, check the `rt.d.ts` file in the project root to se
 
 ## Imports
 
-**No imports allowed.** Use the globally available `fetch` function:
+**The constraint is the runtime, not the import list.** You may import npm packages and relative Windmill scripts; they are resolved and bundled exactly like a regular Bun script. But the native worker only provides `fetch` and the JavaScript standard library, so any imported code must work using only those. Anything requiring Node/Bun built-ins (`node:fs`, `child_process`, the `Bun` API, native modules) belongs in a regular `bun` script instead. Use the globally available `fetch` for HTTP:
 
 ```typescript
+//native
 export async function main(url: string) {
   const response = await fetch(url);
   return await response.json();
@@ -84,13 +87,14 @@ export async function main(url: string) {
 
 ## Windmill Client
 
-The windmill client is not available in native TypeScript mode. Use fetch to call APIs directly.
+`windmill-client` is available for Windmill-specific primitives such as the S3 helpers below (`loadS3File`, `loadS3FileStream`, `writeS3File`, `S3Object`). Use `fetch` for plain HTTP.
 
 ## Preprocessor Scripts
 
 For preprocessor scripts, the function should be named `preprocessor` and receives an `event` parameter:
 
 ```typescript
+//native
 type Event = {
   kind:
     | "webhook"
@@ -123,6 +127,7 @@ Windmill provides built-in support for S3-compatible storage operations. The `wm
 ### Receiving an S3Object as a script parameter
 
 ```typescript
+//native
 import * as wmill from "windmill-client";
 
 export async function main(file: wmill.S3Object) {
@@ -134,6 +139,7 @@ export async function main(file: wmill.S3Object) {
 ### S3 operations
 
 ```typescript
+//native
 import * as wmill from "windmill-client";
 
 // Load file content from S3
diff --git a/system_prompts/auto-generated/skills/write-script-nativets/SKILL.md b/system_prompts/auto-generated/skills/write-script-nativets/SKILL.md
deleted file mode 100644
index 42ad9448a8..0000000000
--- a/system_prompts/auto-generated/skills/write-script-nativets/SKILL.md
+++ /dev/null
@@ -1,675 +0,0 @@
----
-name: write-script-nativets
-description: MUST use when writing Native TypeScript scripts.
----
-
-## CLI Commands
-
-Place scripts in a folder.
-
-After writing, tell the user which command fits what they want to do:
-
-- `wmill script preview <script_path>` — **default when iterating on a local script.** Runs the local file without deploying.
-- `wmill script run <path>` — runs the script **already deployed** in the workspace. Use only when the user explicitly wants to test the deployed version, not local edits.
-- `wmill generate-metadata` — generate `.script.yaml` and `.lock` files for the script you modified.
-- `wmill sync push` — deploy local changes to the workspace. Only suggest/run this when the user explicitly asks to deploy/publish/push — not when they say "run", "try", or "test".
-
-### Preview vs run — choose by intent, not habit
-
-If the user says "run the script", "try it", "test it", "does it work" while there are **local edits to the script file**, use `script preview`. Do NOT push the script to then `script run` it — pushing is a deploy, and deploying just to test overwrites the workspace version with untested changes.
-
-Only use `script run` when:
-- The user explicitly says "run the deployed version" / "run what's on the server".
-- There is no local script being edited (you're just invoking an existing script).
-
-Only use `sync push` when:
-- The user explicitly asks to deploy, publish, push, or ship.
-- The preview has already validated the change and the user wants it in the workspace.
-
-### After writing — offer to test, don't wait passively
-
-If the user hasn't already told you to run/test/preview the script, offer it as a one-sentence next step (e.g. "Want me to run `wmill script preview` with sample args?"). Do not present a multi-option menu.
-
-If the user already asked to test/run/try the script in their original request, skip the offer and just execute `wmill script preview <path> -d '<args>'` directly — pick plausible args from the script's declared parameters. The shape varies by language: `main(...)` for code languages, the SQL dialect's own placeholder syntax (`$1` for PostgreSQL, `?` for MySQL/Snowflake, `@P1` for MSSQL, `@name` for BigQuery, etc.), positional `$1`, `$2`, … for Bash, `param(...)` for PowerShell.
-
-`wmill script preview` does not deploy, but it still executes script code and may cause side effects; run it yourself when the user asked to test/preview (or after confirming that execution is intended). `wmill sync push` and `wmill generate-metadata` modify workspace state or local files — only run these when the user explicitly asks; otherwise tell them which to run.
-
-For a **visual** open-the-script-in-the-dev-page preview (rather than `script preview`'s run-and-print-result), use the `preview` skill.
-
-Use `wmill resource-type list --schema` to discover available resource types.
-
-# TypeScript (Native)
-
-Native TypeScript execution with fetch only - no external imports allowed.
-
-## Structure
-
-Export a single **async** function called `main`:
-
-```typescript
-export async function main(param1: string, param2: number) {
-  // Your code here
-  return { result: param1, count: param2 };
-}
-```
-
-Do not call the main function.
-
-## Resource Types
-
-On Windmill, credentials and configuration are stored in resources and passed as parameters to main.
-
-Use the `RT` namespace for resource types:
-
-```typescript
-export async function main(stripe: RT.Stripe) {
-  // stripe contains API key and config from the resource
-}
-```
-
-Only use resource types if you need them to satisfy the instructions. Always use the RT namespace.
-
-Before using a resource type, check the `rt.d.ts` file in the project root to see all available resource types and their fields. This file is generated by `wmill resource-type generate-namespace`.
-
-## Imports
-
-**No imports allowed.** Use the globally available `fetch` function:
-
-```typescript
-export async function main(url: string) {
-  const response = await fetch(url);
-  return await response.json();
-}
-```
-
-## Windmill Client
-
-The windmill client is not available in native TypeScript mode. Use fetch to call APIs directly.
-
-## Preprocessor Scripts
-
-For preprocessor scripts, the function should be named `preprocessor` and receives an `event` parameter:
-
-```typescript
-type Event = {
-  kind:
-    | "webhook"
-    | "http"
-    | "websocket"
-    | "kafka"
-    | "email"
-    | "nats"
-    | "postgres"
-    | "sqs"
-    | "mqtt"
-    | "gcp";
-  body: any;
-  headers: Record<string, string>;
-  query: Record<string, string>;
-};
-
-export async function preprocessor(event: Event) {
-  return {
-    param1: event.body.field1,
-    param2: event.query.id
-  };
-}
-```
-
-
-# TypeScript SDK (windmill-client)
-
-Import: import * as wmill from 'windmill-client'
-
-workerHasInternalServer(): boolean
-
-/**
- * Initialize the Windmill client with authentication token and base URL
- * @param token - Authentication token (defaults to WM_TOKEN env variable)
- * @param baseUrl - API base URL (defaults to BASE_INTERNAL_URL or BASE_URL env variable)
- */
-setClient(token?: string, baseUrl?: string): void
-
-/**
- * Create a client configuration from env variables
- * @returns client configuration
- */
-getWorkspace(): string
-
-/**
- * Get a resource value by path
- * @param path path of the resource,  default to internal state path
- * @param undefinedIfEmpty if the resource does not exist, return undefined instead of throwing an error
- * @returns resource value
- */
-async getResource(path?: string, undefinedIfEmpty?: boolean): Promise<any>
-
-/**
- * Get the true root job id
- * @param jobId job id to get the root job id from (default to current job)
- * @returns root job id
- */
-async getRootJobId(jobId?: string): Promise<string>
-
-/**
- * @deprecated Use runScriptByPath or runScriptByHash instead
- */
-async runScript(path: string | null = null, hash_: string | null = null, args: Record<string, any> | null = null, verbose: boolean = false): Promise<any>
-
-/**
- * Run a script synchronously by its path and wait for the result
- * @param path - Script path in Windmill
- * @param args - Arguments to pass to the script
- * @param verbose - Enable verbose logging
- * @returns Script execution result
- */
-async runScriptByPath(path: string, args: Record<string, any> | null = null, verbose: boolean = false): Promise<any>
-
-/**
- * Run a script synchronously by its hash and wait for the result
- * @param hash_ - Script hash in Windmill
- * @param args - Arguments to pass to the script
- * @param verbose - Enable verbose logging
- * @returns Script execution result
- */
-async runScriptByHash(hash_: string, args: Record<string, any> | null = null, verbose: boolean = false): Promise<any>
-
-/**
- * Append a text to the result stream
- * @param text text to append to the result stream
- */
-appendToResultStream(text: string): void
-
-/**
- * Stream to the result stream
- * @param stream stream to stream to the result stream
- */
-async streamResult(stream: AsyncIterable<string>): Promise<void>
-
-/**
- * Run a flow synchronously by its path and wait for the result
- * @param path - Flow path in Windmill
- * @param args - Arguments to pass to the flow
- * @param verbose - Enable verbose logging
- * @returns Flow execution result
- */
-async runFlow(path: string | null = null, args: Record<string, any> | null = null, verbose: boolean = false): Promise<any>
-
-/**
- * Wait for a job to complete and return its result
- * @param jobId - ID of the job to wait for
- * @param verbose - Enable verbose logging
- * @returns Job result when completed
- */
-async waitJob(jobId: string, verbose: boolean = false): Promise<any>
-
-/**
- * Get the result of a completed job
- * @param jobId - ID of the completed job
- * @returns Job result
- */
-async getResult(jobId: string): Promise<any>
-
-/**
- * Get the result of a job if completed, or its current status
- * @param jobId - ID of the job
- * @returns Object with started, completed, success, and result properties
- */
-async getResultMaybe(jobId: string): Promise<any>
-
-/**
- * @deprecated Use runScriptByPathAsync or runScriptByHashAsync instead
- */
-async runScriptAsync(path: string | null, hash_: string | null, args: Record<string, any> | null, scheduledInSeconds: number | null = null): Promise<string>
-
-/**
- * Run a script asynchronously by its path
- * @param path - Script path in Windmill
- * @param args - Arguments to pass to the script
- * @param scheduledInSeconds - Schedule execution for a future time (in seconds)
- * @returns Job ID of the created job
- */
-async runScriptByPathAsync(path: string, args: Record<string, any> | null = null, scheduledInSeconds: number | null = null): Promise<string>
-
-/**
- * Run a script asynchronously by its hash
- * @param hash_ - Script hash in Windmill
- * @param args - Arguments to pass to the script
- * @param scheduledInSeconds - Schedule execution for a future time (in seconds)
- * @returns Job ID of the created job
- */
-async runScriptByHashAsync(hash_: string, args: Record<string, any> | null = null, scheduledInSeconds: number | null = null): Promise<string>
-
-/**
- * Run a flow asynchronously by its path
- * @param path - Flow path in Windmill
- * @param args - Arguments to pass to the flow
- * @param scheduledInSeconds - Schedule execution for a future time (in seconds)
- * @param doNotTrackInParent - If false, tracks state in parent job (only use when fully awaiting the job)
- * @returns Job ID of the created job
- */
-async runFlowAsync(path: string | null, args: Record<string, any> | null, scheduledInSeconds: number | null = null, // can only be set to false if this the job will be fully await and not concurrent with any other job // as otherwise the child flow and its own child will store their state in the parent job which will // lead to incorrectness and failures doNotTrackInParent: boolean = true): Promise<string>
-
-/**
- * Resolve a resource value in case the default value was picked because the input payload was undefined
- * @param obj resource value or path of the resource under the format `$res:path`
- * @returns resource value
- */
-async resolveDefaultResource(obj: any): Promise<any>
-
-/**
- * Get the state file path from environment variables
- * @returns State path string
- */
-getStatePath(): string
-
-/**
- * Set a resource value by path
- * @param path path of the resource to set, default to state path
- * @param value new value of the resource to set
- * @param initializeToTypeIfNotExist if the resource does not exist, initialize it with this type
- */
-async setResource(value: any, path?: string, initializeToTypeIfNotExist?: string): Promise<void>
-
-/**
- * Set the state
- * @param state state to set
- * @deprecated use setState instead
- */
-async setInternalState(state: any): Promise<void>
-
-/**
- * Set the state
- * @param state state to set
- * @param path Optional state resource path override. Defaults to `getStatePath()`.
- */
-async setState(state: any, path?: string): Promise<void>
-
-/**
- * Set the progress
- * Progress cannot go back and limited to 0% to 99% range
- * @param percent Progress to set in %
- * @param jobId? Job to set progress for
- */
-async setProgress(percent: number, jobId?: any): Promise<void>
-
-/**
- * Get the progress
- * @param jobId? Job to get progress from
- * @returns Optional clamped between 0 and 100 progress value
- */
-async getProgress(jobId?: any): Promise<number | null>
-
-/**
- * Set a flow user state
- * @param key key of the state
- * @param value value of the state
- */
-async setFlowUserState(key: string, value: any, errorIfNotPossible?: boolean): Promise<void>
-
-/**
- * Get a flow user state
- * @param path path of the variable
- */
-async getFlowUserState(key: string, errorIfNotPossible?: boolean): Promise<any>
-
-/**
- * Get the internal state
- * @deprecated use getState instead
- */
-async getInternalState(): Promise<any>
-
-/**
- * Get the state shared across executions
- * @param path Optional state resource path override. Defaults to `getStatePath()`.
- */
-async getState(path?: string): Promise<any>
-
-/**
- * Get a variable by path
- * @param path path of the variable
- * @returns variable value
- */
-async getVariable(path: string): Promise<string>
-
-/**
- * Set a variable by path, create if not exist
- * @param path path of the variable
- * @param value value of the variable
- * @param isSecretIfNotExist if the variable does not exist, create it as secret or not (default: false)
- * @param descriptionIfNotExist if the variable does not exist, create it with this description (default: "")
- */
-async setVariable(path: string, value: string, isSecretIfNotExist?: boolean, descriptionIfNotExist?: string): Promise<void>
-
-/**
- * Build a PostgreSQL connection URL from a database resource
- * @param path - Path to the database resource
- * @returns PostgreSQL connection URL string
- */
-async databaseUrlFromResource(path: string): Promise<string>
-
-async polarsConnectionSettings(s3_resource_path: string | undefined): Promise<any>
-
-async duckdbConnectionSettings(s3_resource_path: string | undefined): Promise<any>
-
-/**
- * Get S3 client settings from a resource or workspace default
- * @param s3_resource_path - Path to S3 resource (uses workspace default if undefined)
- * @param workspace - Workspace to read from (defaults to the `WM_WORKSPACE` env var)
- * @returns S3 client configuration settings
- */
-async denoS3LightClientSettings(s3_resource_path: string | undefined, workspace: string | undefined = undefined): Promise<DenoS3LightClientSettings>
-
-/**
- * Load the content of a file stored in S3. If the s3ResourcePath is undefined, it will default to the workspace S3 resource.
- * 
- * ```typescript
- * let fileContent = await wmill.loadS3FileContent(inputFile)
- * // if the file is a raw text file, it can be decoded and printed directly:
- * const text = new TextDecoder().decode(fileContentStream)
- * console.log(text);
- * ```
- * 
- * @param workspace - Workspace to read from (defaults to the `WM_WORKSPACE` env var)
- */
-async loadS3File(s3object: S3Object, s3ResourcePath: string | undefined = undefined, workspace: string | undefined = undefined): Promise<Uint8Array | undefined>
-
-/**
- * Load the content of a file stored in S3 as a stream. If the s3ResourcePath is undefined, it will default to the workspace S3 resource.
- * 
- * ```typescript
- * let fileContentBlob = await wmill.loadS3FileStream(inputFile)
- * // if the content is plain text, the blob can be read directly:
- * console.log(await fileContentBlob.text());
- * ```
- * 
- * @param workspace - Workspace to read from (defaults to the `WM_WORKSPACE` env var)
- */
-async loadS3FileStream(s3object: S3Object, s3ResourcePath: string | undefined = undefined, workspace: string | undefined = undefined): Promise<Blob | undefined>
-
-/**
- * Persist a file to the S3 bucket. If the s3ResourcePath is undefined, it will default to the workspace S3 resource.
- * 
- * ```typescript
- * const s3object = await writeS3File(s3Object, "Hello Windmill!")
- * const fileContentAsUtf8Str = (await s3object.toArray()).toString('utf-8')
- * console.log(fileContentAsUtf8Str)
- * ```
- * 
- * @param workspace - Workspace to write to (defaults to the `WM_WORKSPACE` env var)
- */
-async writeS3File(s3object: S3Object | undefined, fileContent: string | Blob, s3ResourcePath: string | undefined = undefined, contentType: string | undefined = undefined, contentDisposition: string | undefined = undefined, workspace: string | undefined = undefined): Promise<S3Object>
-
-/**
- * Permanently delete a file from S3 by key.
- * 
- * ```typescript
- * await wmill.deleteS3File({ s3: "path/to/file.txt" })
- * ```
- * 
- * @param s3object - S3 object identifying the file to delete (must have `s3` set)
- * @param workspace - Workspace to delete from (defaults to the `WM_WORKSPACE` env var)
- */
-async deleteS3File(s3object: S3Object, workspace: string | undefined = undefined): Promise<void>
-
-/**
- * Sign S3 objects to be used by anonymous users in public apps
- * @param s3objects s3 objects to sign
- * @returns signed s3 objects
- */
-async signS3Objects(s3objects: S3Object[]): Promise<S3Object[]>
-
-/**
- * Sign S3 object to be used by anonymous users in public apps
- * @param s3object s3 object to sign
- * @returns signed s3 object
- */
-async signS3Object(s3object: S3Object): Promise<S3Object>
-
-/**
- * Generate a presigned public URL for an array of S3 objects.
- * If an S3 object is not signed yet, it will be signed first.
- * @param s3Objects s3 objects to sign
- * @returns list of signed public URLs
- */
-async getPresignedS3PublicUrls(s3Objects: S3Object[], { baseUrl }: { baseUrl?: string } = {}): Promise<string[]>
-
-/**
- * Generate a presigned public URL for an S3 object. If the S3 object is not signed yet, it will be signed first.
- * @param s3Object s3 object to sign
- * @returns signed public URL
- */
-async getPresignedS3PublicUrl(s3Objects: S3Object, { baseUrl }: { baseUrl?: string } = {}): Promise<string>
-
-/**
- * Get URLs needed for resuming a flow after this step
- * @param approver approver name
- * @param flowLevel if true, generate resume URLs for the parent flow instead of the specific step.
- *                  This allows pre-approvals that can be consumed by any later suspend step in the same flow.
- * @returns approval page UI URL, resume and cancel API URLs for resuming the flow
- */
-async getResumeUrls(approver?: string, flowLevel?: boolean): Promise<{
-  approvalPage: string;
-  resume: string;
-  cancel: string;
-}>
-
-/**
- * @deprecated use getResumeUrls instead
- */
-getResumeEndpoints(approver?: string): Promise<{
-  approvalPage: string;
-  resume: string;
-  cancel: string;
-}>
-
-/**
- * Get an OIDC jwt token for auth to external services (e.g: Vault, AWS) (ee only)
- * @param audience audience of the token
- * @param expiresIn Optional number of seconds until the token expires
- * @returns jwt token
- */
-async getIdToken(audience: string, expiresIn?: number): Promise<string>
-
-/**
- * Convert a base64-encoded string to Uint8Array
- * @param data - Base64-encoded string
- * @returns Decoded Uint8Array
- */
-base64ToUint8Array(data: string): Uint8Array
-
-/**
- * Convert a Uint8Array to base64-encoded string
- * @param arrayBuffer - Uint8Array to encode
- * @returns Base64-encoded string
- */
-uint8ArrayToBase64(arrayBuffer: Uint8Array): string
-
-/**
- * Get email from workspace username
- * This method is particularly useful for apps that require the email address of the viewer.
- * Indeed, in the viewer context, WM_USERNAME is set to the username of the viewer but WM_EMAIL is set to the email of the creator of the app.
- * @param username
- * @returns email address
- */
-async usernameToEmail(username: string): Promise<string>
-
-/**
- * Sends an interactive approval request via Slack, allowing optional customization of the message, approver, and form fields.
- * 
- * **[Enterprise Edition Only]** To include form fields in the Slack approval request, go to **Advanced -> Suspend -> Form**
- * and define a form. Learn more at [Windmill Documentation](https://www.windmill.dev/docs/flows/flow_approval#form).
- * 
- * @param {Object} options - The configuration options for the Slack approval request.
- * @param {string} options.slackResourcePath - The path to the Slack resource in Windmill.
- * @param {string} options.channelId - The Slack channel ID where the approval request will be sent.
- * @param {string} [options.message] - Optional custom message to include in the Slack approval request.
- * @param {string} [options.approver] - Optional user ID or name of the approver for the request.
- * @param {DefaultArgs} [options.defaultArgsJson] - Optional object defining or overriding the default arguments to a form field.
- * @param {Enums} [options.dynamicEnumsJson] - Optional object overriding the enum default values of an enum form field.
- * @param {string} [options.resumeButtonText] - Optional text for the resume button.
- * @param {string} [options.cancelButtonText] - Optional text for the cancel button.
- * 
- * @returns {Promise<void>} Resolves when the Slack approval request is successfully sent.
- * 
- * @throws {Error} If the function is not called within a flow or flow preview.
- * @throws {Error} If the `JobService.getSlackApprovalPayload` call fails.
- * 
- * **Usage Example:**
- * ```typescript
- * await requestInteractiveSlackApproval({
- *   slackResourcePath: "/u/alex/my_slack_resource",
- *   channelId: "admins-slack-channel",
- *   message: "Please approve this request",
- *   approver: "approver123",
- *   defaultArgsJson: { key1: "value1", key2: 42 },
- *   dynamicEnumsJson: { foo: ["choice1", "choice2"], bar: ["optionA", "optionB"] },
- *   resumeButtonText: "Resume",
- *   cancelButtonText: "Cancel",
- * });
- * ```
- * 
- * **Note:** This function requires execution within a Windmill flow or flow preview.
- */
-async requestInteractiveSlackApproval({ slackResourcePath, channelId, message, approver, defaultArgsJson, dynamicEnumsJson, resumeButtonText, cancelButtonText, }: SlackApprovalOptions): Promise<void>
-
-/**
- * Sends an interactive approval request via Teams, allowing optional customization of the message, approver, and form fields.
- * 
- * **[Enterprise Edition Only]** To include form fields in the Teams approval request, go to **Advanced -> Suspend -> Form**
- * and define a form. Learn more at [Windmill Documentation](https://www.windmill.dev/docs/flows/flow_approval#form).
- * 
- * @param {Object} options - The configuration options for the Teams approval request.
- * @param {string} options.teamName - The Teams team name where the approval request will be sent.
- * @param {string} options.channelName - The Teams channel name where the approval request will be sent.
- * @param {string} [options.message] - Optional custom message to include in the Teams approval request.
- * @param {string} [options.approver] - Optional user ID or name of the approver for the request.
- * @param {DefaultArgs} [options.defaultArgsJson] - Optional object defining or overriding the default arguments to a form field.
- * @param {Enums} [options.dynamicEnumsJson] - Optional object overriding the enum default values of an enum form field.
- * 
- * @returns {Promise<void>} Resolves when the Teams approval request is successfully sent.
- * 
- * @throws {Error} If the function is not called within a flow or flow preview.
- * @throws {Error} If the `JobService.getTeamsApprovalPayload` call fails.
- * 
- * **Usage Example:**
- * ```typescript
- * await requestInteractiveTeamsApproval({
- *   teamName: "admins-teams",
- *   channelName: "admins-teams-channel",
- *   message: "Please approve this request",
- *   approver: "approver123",
- *   defaultArgsJson: { key1: "value1", key2: 42 },
- *   dynamicEnumsJson: { foo: ["choice1", "choice2"], bar: ["optionA", "optionB"] },
- * });
- * ```
- * 
- * **Note:** This function requires execution within a Windmill flow or flow preview.
- */
-async requestInteractiveTeamsApproval({ teamName, channelName, message, approver, defaultArgsJson, dynamicEnumsJson, }: TeamsApprovalOptions): Promise<void>
-
-/**
- * Parse an S3 object from URI string or record format
- * @param s3Object - S3 object as URI string (s3://storage/key) or record
- * @returns S3 object record with storage and s3 key
- */
-parseS3Object(s3Object: S3Object): S3ObjectRecord
-
-setWorkflowCtx(ctx: WorkflowCtx | null): void
-
-async sleep(seconds: number): Promise<void>
-
-async step<T>(name: string, fn: () => T | Promise<T>): Promise<T>
-
-/**
- * Create a task that dispatches to a separate Windmill script.
- * 
- * @example
- * const extract = taskScript("f/data/extract");
- * // inside workflow: await extract({ url: "https://..." })
- */
-taskScript(path: string, options?: TaskOptions): (...args: any[]) => PromiseLike<any>
-
-/**
- * Create a task that dispatches to a separate Windmill flow.
- * 
- * @example
- * const pipeline = taskFlow("f/etl/pipeline");
- * // inside workflow: await pipeline({ input: data })
- */
-taskFlow(path: string, options?: TaskOptions): (...args: any[]) => PromiseLike<any>
-
-/**
- * Mark an async function as a workflow-as-code entry point.
- * 
- * The function must be **deterministic**: given the same inputs it must call
- * tasks in the same order on every replay. Branching on task results is fine
- * (results are replayed from checkpoint), but branching on external state
- * (current time, random values, external API calls) must use `step()` to
- * checkpoint the value so replays see the same result.
- */
-workflow<T>(fn: (...args: any[]) => Promise<T>): void
-
-/**
- * Suspend the workflow and wait for an external approval.
- * 
- * Use `getResumeUrls()` (wrapped in `step()`) to obtain resume/cancel/approvalPage
- * URLs before calling this function.
- * 
- * @example
- * const urls = await step("urls", () => getResumeUrls());
- * await step("notify", () => sendEmail(urls.approvalPage));
- * const { value, approver } = await waitForApproval({ timeout: 3600 });
- */
-waitForApproval(options?: { timeout?: number; form?: object; selfApproval?: boolean; }): PromiseLike<{ value: any; approver: string; approved: boolean }>
-
-/**
- * Process items in parallel with optional concurrency control.
- * 
- * Each item is processed by calling `fn(item)`, which should be a task().
- * Items are dispatched in batches of `concurrency` (default: all at once).
- * 
- * @example
- * const process = task(async (item: string) => { ... });
- * const results = await parallel(items, process, { concurrency: 5 });
- */
-async parallel<T, R>(items: T[], fn: (item: T) => PromiseLike<R> | R, options?: { concurrency?: number },): Promise<R[]>
-
-/**
- * Commit Kafka offsets for a trigger with auto_commit disabled.
- * @param triggerPath - Path to the Kafka trigger (from event.wm_trigger.trigger_path)
- * @param topic - Kafka topic name (from event.topic)
- * @param partition - Partition number (from event.partition)
- * @param offset - Message offset to commit (from event.offset)
- */
-async commitKafkaOffsets(triggerPath: string, topic: string, partition: number, offset: number,): Promise<void>
-
-/**
- * Create a SQL template function for PostgreSQL/datatable queries
- * @param name - Database/datatable name (default: "main")
- * @returns SQL template function for building parameterized queries
- * @example
- * let sql = wmill.datatable()
- * let name = 'Robin'
- * let age = 21
- * await sql`
- *   SELECT * FROM friends
- *     WHERE name = ${name} AND age = ${age}::int
- * `.fetch()
- */
-datatable(name: string = "main"): DatatableSqlTemplateFunction
-
-/**
- * Create a SQL template function for DuckDB/ducklake queries
- * @param name - DuckDB database name (default: "main")
- * @returns SQL template function for building parameterized queries
- * @example
- * let sql = wmill.ducklake()
- * let name = 'Robin'
- * let age = 21
- * await sql`
- *   SELECT * FROM friends
- *     WHERE name = ${name} AND age = ${age}
- * `.fetch()
- */
-ducklake(name: string = "main"): SqlTemplateFunction
diff --git a/system_prompts/generate.py b/system_prompts/generate.py
index 0c03e47fb5..783dcc1ce3 100644
--- a/system_prompts/generate.py
+++ b/system_prompts/generate.py
@@ -2463,8 +2463,22 @@ export function getRawAppPrompt(): string {
   return prompts.RAW_APP_BASE;
 }
 
-// Helper to get datatable SDK reference for app mode
-export function getDatatableSdkReference(): string {
+// Helper to get the datatable SQL SDK reference (wmill.datatable()).
+// Pass a language to get only that SDK; omit it to get both.
+export function getDatatableSdkReference(language?: string): string {
+  if (language == null) {
+    return [
+      prompts.DATATABLE_SDK_TYPESCRIPT,
+      prompts.DATATABLE_SDK_PYTHON
+    ].filter(Boolean).join('\\n\\n');
+  }
+  if (TS_SDK_LANGUAGES.includes(language)) {
+    return prompts.DATATABLE_SDK_TYPESCRIPT;
+  }
+  if (PY_SDK_LANGUAGES.includes(language)) {
+    return prompts.DATATABLE_SDK_PYTHON;
+  }
+  // Unknown language: return both rather than nothing.
   return [
     prompts.DATATABLE_SDK_TYPESCRIPT,
     prompts.DATATABLE_SDK_PYTHON
@@ -2501,7 +2515,7 @@ export declare function getScriptPrompt(language: string): string;
 export declare function getFlowPrompt(): string;
 export declare function getResourcePrompt(): string;
 export declare function getRawAppPrompt(): string;
-export declare function getDatatableSdkReference(): string;
+export declare function getDatatableSdkReference(language?: string): string;
 export declare function getWorkflowAsCodePrompt(language?: string): string;
 """
     (OUTPUT_GENERATED_DIR / "index.d.ts").write_text(index_dts_content)
diff --git a/system_prompts/languages/bunnative.md b/system_prompts/languages/bunnative.md
index 977c974737..9daa8a9a46 100644
--- a/system_prompts/languages/bunnative.md
+++ b/system_prompts/languages/bunnative.md
@@ -1,12 +1,13 @@
 # TypeScript (Bun Native)
 
-Native TypeScript execution with fetch only - no external imports allowed.
+Native TypeScript execution. Native scripts are Bun scripts that run on the native worker — a lightweight V8 isolate that exposes `fetch` and the JavaScript standard library — and can be heavily parallelized. Every script MUST start with `//native` on its first line so Windmill routes it to the native worker; without it the exact same script runs on the regular Bun worker. You may import npm packages and other Windmill scripts (e.g. `./helper.ts`) — imports are resolved and bundled just like a regular Bun script — as long as everything (your code and its dependencies) relies only on `fetch` and the standard library. Libraries that need Node/Bun runtime APIs (filesystem, `node:*` modules, child processes, native addons) will not work on the native worker; use the regular `bun` language for those.
 
 ## Structure
 
 Export a single **async** function called `main`:
 
 ```typescript
+//native
 export async function main(param1: string, param2: number) {
   // Your code here
   return { result: param1, count: param2 };
@@ -22,6 +23,7 @@ On Windmill, credentials and configuration are stored in resources and passed as
 Use the `RT` namespace for resource types:
 
 ```typescript
+//native
 export async function main(stripe: RT.Stripe) {
   // stripe contains API key and config from the resource
 }
@@ -33,9 +35,10 @@ Before using a resource type, check the `rt.d.ts` file in the project root to se
 
 ## Imports
 
-**No imports allowed.** Use the globally available `fetch` function:
+**The constraint is the runtime, not the import list.** You may import npm packages and relative Windmill scripts; they are resolved and bundled exactly like a regular Bun script. But the native worker only provides `fetch` and the JavaScript standard library, so any imported code must work using only those. Anything requiring Node/Bun built-ins (`node:fs`, `child_process`, the `Bun` API, native modules) belongs in a regular `bun` script instead. Use the globally available `fetch` for HTTP:
 
 ```typescript
+//native
 export async function main(url: string) {
   const response = await fetch(url);
   return await response.json();
@@ -44,13 +47,14 @@ export async function main(url: string) {
 
 ## Windmill Client
 
-The windmill client is not available in native TypeScript mode. Use fetch to call APIs directly.
+`windmill-client` is available for Windmill-specific primitives such as the S3 helpers below (`loadS3File`, `loadS3FileStream`, `writeS3File`, `S3Object`). Use `fetch` for plain HTTP.
 
 ## Preprocessor Scripts
 
 For preprocessor scripts, the function should be named `preprocessor` and receives an `event` parameter:
 
 ```typescript
+//native
 type Event = {
   kind:
     | "webhook"
@@ -83,6 +87,7 @@ Windmill provides built-in support for S3-compatible storage operations. The `wm
 ### Receiving an S3Object as a script parameter
 
 ```typescript
+//native
 import * as wmill from "windmill-client";
 
 export async function main(file: wmill.S3Object) {
@@ -94,6 +99,7 @@ export async function main(file: wmill.S3Object) {
 ### S3 operations
 
 ```typescript
+//native
 import * as wmill from "windmill-client";
 
 // Load file content from S3
diff --git a/system_prompts/languages/nativets.md b/system_prompts/languages/nativets.md
deleted file mode 100644
index 5df6ad2279..0000000000
--- a/system_prompts/languages/nativets.md
+++ /dev/null
@@ -1,77 +0,0 @@
-# TypeScript (Native)
-
-Native TypeScript execution with fetch only - no external imports allowed.
-
-## Structure
-
-Export a single **async** function called `main`:
-
-```typescript
-export async function main(param1: string, param2: number) {
-  // Your code here
-  return { result: param1, count: param2 };
-}
-```
-
-Do not call the main function.
-
-## Resource Types
-
-On Windmill, credentials and configuration are stored in resources and passed as parameters to main.
-
-Use the `RT` namespace for resource types:
-
-```typescript
-export async function main(stripe: RT.Stripe) {
-  // stripe contains API key and config from the resource
-}
-```
-
-Only use resource types if you need them to satisfy the instructions. Always use the RT namespace.
-
-Before using a resource type, check the `rt.d.ts` file in the project root to see all available resource types and their fields. This file is generated by `wmill resource-type generate-namespace`.
-
-## Imports
-
-**No imports allowed.** Use the globally available `fetch` function:
-
-```typescript
-export async function main(url: string) {
-  const response = await fetch(url);
-  return await response.json();
-}
-```
-
-## Windmill Client
-
-The windmill client is not available in native TypeScript mode. Use fetch to call APIs directly.
-
-## Preprocessor Scripts
-
-For preprocessor scripts, the function should be named `preprocessor` and receives an `event` parameter:
-
-```typescript
-type Event = {
-  kind:
-    | "webhook"
-    | "http"
-    | "websocket"
-    | "kafka"
-    | "email"
-    | "nats"
-    | "postgres"
-    | "sqs"
-    | "mqtt"
-    | "gcp";
-  body: any;
-  headers: Record<string, string>;
-  query: Record<string, string>;
-};
-
-export async function preprocessor(event: Event) {
-  return {
-    param1: event.body.field1,
-    param2: event.query.id
-  };
-}
-```
diff --git a/system_prompts/utils.py b/system_prompts/utils.py
index 152df2e1d9..45b7a365ba 100644
--- a/system_prompts/utils.py
+++ b/system_prompts/utils.py
@@ -94,14 +94,14 @@ LANGUAGE_METADATA = {
         'description': 'MUST use when writing Deno/TypeScript scripts.',
         'use_cases': 'TypeScript with Deno stdlib, secure sandboxed execution'
     },
-    'nativets': {
-        'name': 'Native TypeScript',
-        'description': 'MUST use when writing Native TypeScript scripts.',
-        'use_cases': 'simple API calls, lightweight TypeScript, no dependencies'
-    },
+    # 'nativets' is intentionally omitted: it is a legacy duplicate of
+    # 'bunnative' (a Bun script with a leading //native marker). No
+    # write-script-nativets skill is generated so agents always author native
+    # TypeScript as 'bunnative'. It remains in TS_SDK_LANGUAGES below so the
+    # TypeScript SDK still attaches when editing existing nativets scripts.
     'bunnative': {
         'name': 'Bun Native',
-        'description': 'MUST use when writing Bun Native scripts.',
+        'description': 'MUST use when writing Bun Native scripts. The script must start with //native to run on the native worker.',
         'use_cases': 'simple Bun scripts, lightweight, no dependencies'
     },
     'python3': {
@@ -186,7 +186,9 @@ LANGUAGE_METADATA = {
     },
 }
 
-# Languages that use TypeScript SDK
+# Languages that use TypeScript SDK. 'nativets' is kept here (despite having no
+# write-script skill — see LANGUAGE_METADATA) so the TS SDK still attaches when
+# editing pre-existing legacy nativets scripts.
 TS_SDK_LANGUAGES = ['bun', 'deno', 'nativets', 'bunnative']
 
 # Languages that use Python SDK
diff --git a/typescript-client/jsr.json b/typescript-client/jsr.json
index c68b80d575..7e0945ac7c 100644
--- a/typescript-client/jsr.json
+++ b/typescript-client/jsr.json
@@ -1,6 +1,6 @@
 {
   "name": "@windmill/windmill",
-  "version": "1.711.0",
+  "version": "1.714.0",
   "exports": "./src/index.ts",
   "publish": {
     "exclude": ["!src", "./s3Types.ts", "./sqlUtils.ts", "./client.ts"]
diff --git a/typescript-client/package.json b/typescript-client/package.json
index b4535d1f7b..6c3778ce59 100644
--- a/typescript-client/package.json
+++ b/typescript-client/package.json
@@ -1,7 +1,7 @@
 {
   "name": "windmill-client",
   "description": "Windmill SDK client for browsers and Node.js",
-  "version": "1.711.0",
+  "version": "1.714.0",
   "author": "Ruben Fiszel",
   "license": "Apache 2.0",
   "sideEffects": false,
diff --git a/version.txt b/version.txt
index 272c83ab90..1a0a78ba16 100644
--- a/version.txt
+++ b/version.txt
@@ -1 +1 @@
-1.711.0
+1.714.0