@alisio/core 0.5.1 → 0.6.0

package/dist/analysis/rerun.d.ts

@@ -16,7 +16,7 @@ export interface RerunPlan {
     manifest: unknown[];
     extras: Array<"analysis" | "science">;
     /** The runtime of the original execution (a rerun uses the configured runtime now). */
-    runtime: "managed" | "oci";
+    runtime: "managed" | "oci" | "wasm";
 }
 export type RerunPreparation = {
     ok: true;

package/dist/analysis/status.d.ts

@@ -3,7 +3,7 @@
  * Settings page: mode, interpreter and extras, container engine (probed only when it matters),
  * limits and retention. One shape (`AnalysisStatus` of the SDK) for every surface.
  */
-import type { AnalysisStatus } from "@alisio/sdk";
+import type { AnalysisStatus, EngineDescriptor } from "@alisio/sdk";
 import type { Config } from "../config.ts";
 import type { AnalysisJanitor } from "./janitor.ts";
 import type { OciRuntime } from "./oci.ts";
@@ -14,6 +14,8 @@ export declare function analysisStatus(input: {
     /** Builds the container runtime of the current settings (probed on demand). */
     oci?: () => OciRuntime;
     janitor?: Pick<AnalysisJanitor, "lastSweep">;
+    /** The live state of the Python backends (isolation, readiness, profiles); omitted = no table. */
+    backends?: (signal?: AbortSignal) => Promise<EngineDescriptor[]>;
     /** python_run is registered (analysis enabled and not `--read-only`). */
     enabled: boolean;
     readOnly: boolean;

package/dist/analysis/status.js

@@ -40,10 +40,13 @@ export async function analysisStatus(input) {
             oci.reason = status.reason;
     }
     const lastSweep = await input.janitor?.lastSweep();
+    const backends = input.backends ? await input.backends(input.signal) : undefined;
     return {
         enabled: input.enabled,
         readOnly: input.readOnly,
         mode: config.runtime,
+        isolation: config.isolation,
+        ...(backends ? { backends } : {}),
         python,
         oci,
         limits: { timeoutMs: config.limits.timeoutMs },

package/dist/application.d.ts

@@ -2,7 +2,7 @@ import type { AvailableProviderModel, ModelInfo, ModelProvider, Plugin, PluginCa
 import { AgentDefinitionService } from "./agents/service.ts";
 import { CapabilityGrants } from "./analysis/capabilities.ts";
 import { DatasetService } from "./analysis/data/datasets.ts";
-import { AnalysisJanitor } from "./analysis/janitor.ts";
+import { AnalysisJanitor, ScratchJanitor } from "./analysis/janitor.ts";
 import { AnalysisJobs } from "./analysis/jobs.ts";
 import { OciRuntime } from "./analysis/oci.ts";
 import { AnalysisRerun } from "./analysis/rerun.ts";
@@ -15,6 +15,8 @@ import type { ApprovalHandler } from "./core/contracts.ts";
 import { ToolRegistry } from "./core/registry.ts";
 import { AgentRunner } from "./core/runner.ts";
 import { DecisionMetrics, DecisionRegistry, DecisionService } from "./decisions/index.ts";
+import { SqliteExecutionJournal } from "./forge/journal.ts";
+import { SqliteStateStore } from "./forge/state-store.ts";
 import { GoalService } from "./goal/service.ts";
 import { HerdrBridge } from "./integrations/herdr.ts";
 import { McpConnector } from "./mcp/connector.ts";
@@ -188,12 +190,36 @@ export declare function createApplication(options?: AppOptions): Promise<{
         jobs: AnalysisJobs;
         /** Container runtime of the current configuration (status, pull); mode `managed` ignores it. */
         oci: {
-            mode: () => "managed" | "oci";
+            mode: () => "auto" | "managed" | "oci" | "wasm";
             runtime: () => OciRuntime;
         };
+        /** The live state of every Python backend (isolation, ready, profiles, reason). */
+        backends: (signal?: AbortSignal) => Promise<import("@alisio/sdk").EngineDescriptor[]>;
         rerun: AnalysisRerun;
         janitor: AnalysisJanitor;
     };
+    /**
+     * Forja services for the engines (Phase 3b): the execution journal, the cross-execution
+     * state, the scratchpad of a session (undefined while the JavaScript engine is off) and the
+     * retention sweep of the volatile session folders.
+     */
+    forge: {
+        journal: SqliteExecutionJournal;
+        state: SqliteStateStore;
+        /** The scratchpad, created on first use; under the same gate as the write root. */
+        scratchpad: ((session: string) => Promise<string | undefined>) | undefined;
+        /**
+         * What the HTTP surface sees (L2): `available` follows the gate of the write root (engine
+         * verified, not `--read-only`); the folder is only looked up, never created.
+         */
+        scratchpadView: ((session: string) => Promise<{
+            available: boolean;
+            path?: string;
+        }>) | undefined;
+        scratchJanitor: ScratchJanitor;
+        /** The JavaScript engine: descriptor and effective limits (`alisio forge status`), probe. */
+        runtime: import("./forge/runtime.ts").ForgeRuntime;
+    };
     /** Keys a project layer set that only the user layer decides (ignored on load). */
     configDiagnostics: string[];
     /** Tabular datasets of every session (ingestion, read-only queries, pages). */
@@ -320,6 +346,16 @@ export declare function createApplication(options?: AppOptions): Promise<{
     resolveModel: (reference: string, signal?: AbortSignal) => Promise<ResolvedProviderModel>;
     /** Creates and binds a fresh session to an optional configured model selector. */
     createSession(reference?: string): Promise<import("./index.ts").Session>;
+    /**
+     * Re-binds an existing session to the provider that owns `model` (a configured profile), else
+     * to the active provider. The session keeps a single provider+model binding, so choosing a
+     * model of the now-active provider makes it usable even when the session's original provider
+     * is gone. The persisted transcript is provider-neutral: no new session is needed.
+     */
+    rebindSession(sessionId: string, model?: string): Promise<{
+        provider: string;
+        model: string;
+    }>;
     /** Persists and activates only after construction succeeds; programmatic overrides stay fixed. */
     activateProvider(id: string, profile: Record<string, import("@alisio/sdk").ProviderConfigurationValue>, credentials: Record<string, string>, model: string, profileName?: string): Promise<void>;
     /** Activates a stored profile without exposing its credentials. Returns false for a no-op. */

package/dist/application.js

@@ -4,7 +4,7 @@ import { dirname, join, resolve } from "node:path";
 import { AgentDefinitionService } from "./agents/service.js";
 import { CapabilityGrants } from "./analysis/capabilities.js";
 import { DatasetService } from "./analysis/data/datasets.js";
-import { AnalysisJanitor } from "./analysis/janitor.js";
+import { AnalysisJanitor, ScratchJanitor } from "./analysis/janitor.js";
 import { AnalysisJobs } from "./analysis/jobs.js";
 import { OciRuntime } from "./analysis/oci.js";
 import { AnalysisRerun } from "./analysis/rerun.js";
@@ -21,6 +21,12 @@ import { DEFAULT_MAX_OUTPUT_TOKENS } from "./core/output-limit.js";
 import { ToolRegistry } from "./core/registry.js";
 import { AgentRunner } from "./core/runner.js";
 import { bindDecisions, DecisionMetrics, DecisionRegistry, DecisionService, } from "./decisions/index.js";
+import { reconcileInterruptedExecutions, SqliteExecutionJournal } from "./forge/journal.js";
+import { describePythonBackends } from "./forge/python/status.js";
+import { createPythonBackends } from "./forge/python/wiring.js";
+import { createForgeRuntime } from "./forge/runtime.js";
+import { createScratchpadLookup, createScratchpadProvider, scratchSweepRoots, } from "./forge/scratch-provider.js";
+import { SqliteStateStore } from "./forge/state-store.js";
 import { GoalService } from "./goal/service.js";
 import { GoalStore } from "./goal/store.js";
 import { HerdrBridge } from "./integrations/herdr.js";
@@ -35,7 +41,7 @@ import { Skills, skillRoots } from "./resources/skills.js";
 import { PathAccess } from "./runtime/access.js";
 import { BlobStore } from "./runtime/blobs.js";
 import { isPathSpec } from "./runtime/modules.js";
-import { findWorkspace } from "./runtime/paths.js";
+import { findWorkspace, workspaceKey } from "./runtime/paths.js";
 import { SQLiteStore } from "./runtime/store.js";
 import { ChildSessions } from "./sessions/children.js";
 import { SideQuestions } from "./sessions/side-questions.js";
@@ -100,6 +106,24 @@ export async function createApplication(options = {}) {
         }
     });
     const askExternalDirectory = options.approveExternalDirectory;
+    const customStore = !!options.db;
+    const scratchStateRoot = options.db && options.db !== ":memory:" ? dirname(options.db) : stateHome();
+    // Forja's scratchpad (spec §9.4): an authorized write root only while the JavaScript engine is
+    // enabled, so a build with Forja off behaves exactly as before. `store` is read lazily, on the
+    // first path outside the workspace.
+    const scratchOptions = {
+        rootOf: (session) => store.rootOf(session),
+        workspaceOf: (rootSessionId) => store.get(rootSessionId).workspace,
+        workspaceKey,
+        stateHome: scratchStateRoot,
+        configRoot: () => config.forge.scratch.root,
+    };
+    const scratchEnabled = config.forge.javascript.enabled && config.forge.scratch.enabled;
+    const scratchpad = scratchEnabled ? createScratchpadProvider(scratchOptions) : undefined;
+    const scratchpadLookup = scratchEnabled ? createScratchpadLookup(scratchOptions) : undefined;
+    // The scratchpad is a free write root only once the engine verified itself (`jsReady`, known after
+    // `createForgeRuntime` below): a failed self-check leaves it an ordinary directory (L9).
+    let scratchReady = false;
     const pathAccess = new PathAccess({
         workspace,
         extraRoots: [...config.additionalDirectories, ...addDirs],
@@ -109,8 +133,20 @@ export async function createApplication(options = {}) {
             }
             : {}),
         readOnly: !!options.readOnly,
+        ...(scratchpad
+            ? {
+                scratchpad: (session) => scratchReady ? scratchpad(session) : Promise.resolve(undefined),
+                scratchMaxBytes: () => config.forge.scratch.maxBytes,
+            }
+            : {}),
     });
     const store = new SQLiteStore(options.db ?? join(stateHome(), "sessions.sqlite"));
+    // Executions of a process that is gone cannot be running: close them (nothing is relaunched).
+    reconcileInterruptedExecutions(store.db);
+    const forgeJournal = new SqliteExecutionJournal(store.db);
+    const forgeState = new SqliteStateStore(store.db, {
+        maxTotalBytes: () => config.forge.state.maxTotalBytes,
+    });
     // Content-addressed attachment bytes next to the session database (no I/O until `put`).
     const blobs = new BlobStore({
         root: options.db && options.db !== ":memory:"
@@ -352,6 +388,14 @@ export async function createApplication(options = {}) {
         }));
         context.extras.push(async () => skills.catalog(), ...plugins.contexts);
         const { registerStandard } = await import("./tools/standard.js");
+        // Forja's JavaScript engine verifies itself here (the WASM against its pinned hash). Enabled
+        // means `js_run` replaces `execute` for good: a failed check leaves neither (no fallback).
+        const forgeRuntime = await createForgeRuntime({
+            forge: () => config.forge,
+            journal: forgeJournal,
+            state: forgeState,
+        });
+        scratchReady = forgeRuntime.jsReady;
         // `runner` is referenced lazily (constructed just below): safe because these accessors only
         // run once the tool is actually called, well after the runner exists.
         registerStandard(registry, workspace, skills, context, plugins.ui, {
@@ -359,7 +403,27 @@ export async function createApplication(options = {}) {
         }, {
             config: config.websearch,
             resolveExtension: () => plugins.extensions.resolve("websearch"),
-        }, pathAccess);
+        }, pathAccess, { execute: !config.forge.javascript.enabled });
+        // `--read-only` has no scratchpad root, so `codePath` is unavailable there.
+        const sessionScratchpad = options.readOnly ? async () => undefined : scratchpad;
+        if (forgeRuntime.jsReady) {
+            const { registerJsRun } = await import("./tools/js-run.js");
+            const { buildRoutingRule } = await import("./forge/routing-rule.js");
+            registerJsRun(registry, {
+                kernel: forgeRuntime.kernel,
+                rootOf: (session) => store.rootOf(session),
+                scratchpad: async (session) => sessionScratchpad?.(session),
+                policy: () => runner.policy,
+            });
+            // Layer 0 of the context (spec §8.1): present only because `js_run` is, per session.
+            context.extras.push(async (sessionId) => buildRoutingRule({
+                javascript: true,
+                python: registry.list().some((tool) => tool.name === "python_run"),
+                // Registered later (after `python_run`), so it is looked up when the prompt is built.
+                guide: registry.list().some((tool) => tool.name === "forge_guide"),
+                scratchpad: sessionId ? await sessionScratchpad?.(sessionId) : undefined,
+            }));
+        }
         // Python analysis and artifacts live next to the session database (like attachment blobs).
         const artifacts = new ArtifactStore({
             root: stateRoot,
@@ -395,6 +459,13 @@ export async function createApplication(options = {}) {
                 return ociRuntime.runtime;
             },
         };
+        // The Python backends as surfaces report them (`GET /api/analysis`, `GET /api/forge`); the tool
+        // builds its own for running. Read live: the settings can change between calls.
+        const pythonBackends = createPythonBackends({
+            runtime: analysisRuntime,
+            oci,
+            wasm: { stateRoot, settings: () => config.analysis.wasm },
+        });
         // Tabular datasets (one SQLite file each); XLSX needs the discovered Python.
         const datasets = new DatasetService({
             root: stateRoot,
@@ -416,6 +487,28 @@ export async function createApplication(options = {}) {
                 ? { initialDelayMs: options.analysisSweepDelayMs }
                 : {}),
         });
+        // Volatile Forja session folders: same schedule as the analysis sweep, gone with their session.
+        const scratchJanitor = new ScratchJanitor({
+            stateRoot,
+            roots: () => scratchSweepRoots({
+                customStore,
+                stateHome: scratchStateRoot,
+                configRoot: config.forge.scratch.root,
+            }),
+            sessionExists: (rootSessionId) => {
+                try {
+                    store.get(rootSessionId);
+                    return true;
+                }
+                catch {
+                    return false;
+                }
+            },
+            retentionDays: () => config.forge.scratch.retentionDays,
+            ...(options.analysisSweepDelayMs !== undefined
+                ? { initialDelayMs: options.analysisSweepDelayMs }
+                : {}),
+        });
         // Background tasks: a service over the shared database (state change = compare-and-set), logs
         // under `<state>/tasks/`. Tasks of a dead owner process (a previous run) become `lost` now.
         const tasks = new BackgroundTasks({
@@ -473,6 +566,15 @@ export async function createApplication(options = {}) {
                 runtime: analysisRuntime,
                 datasets,
                 oci,
+                // Read live: the policy and the Pyodide settings are global-only and may change.
+                isolation: () => config.analysis.isolation,
+                wasm: { stateRoot, settings: () => config.analysis.wasm },
+                // Python runs through the same kernel as `js_run`: one journal, one state store.
+                forge: { kernel: forgeRuntime.kernel, engines: forgeRuntime.engines },
+                // `codePath` and the read-only exposure exist only where `js_run` has its scratchpad too.
+                ...(scratchReady && sessionScratchpad
+                    ? { scratchpad: async (session) => sessionScratchpad(session) }
+                    : {}),
                 rerun: analysisRerun,
                 rootOf: (id) => store.rootOf(id),
                 // Read live: a changed `analysis.limits.*` setting applies to the next call.
@@ -485,6 +587,8 @@ export async function createApplication(options = {}) {
                     },
                 },
                 startup: { candidates: candidates.length > 0, extras: active?.extras ?? [] },
+                // Error results point at `forge_guide` only while that tool exists (spec §8.4).
+                guideHints: () => registry.list().some((tool) => tool.name === "forge_guide"),
             });
             const { registerArtifactTools } = await import("./tools/artifacts.js");
             registerArtifactTools(registry, { store: artifacts, rootOf: (id) => store.rootOf(id) });
@@ -496,6 +600,42 @@ export async function createApplication(options = {}) {
                 context.extras.push(async () => DASHBOARD_PROMPT_RULE);
             }
         }
+        // Layer 2 of the context (spec §8.3): `forge_guide`. Registered only with Forja on and a ready
+        // engine for at least one language; the `python.*` topics need `python_run`.
+        if (config.forge.guides.enabled && config.forge.javascript.enabled) {
+            const [{ GuideProvider }, { registerForgeGuide }, { probePythonEnvironment }] = await Promise.all([
+                import("./forge/guides/provider.js"),
+                import("./tools/forge-guide.js"),
+                import("./forge/guides/python-environment.js"),
+            ]);
+            const hasPython = registry.list().some((tool) => tool.name === "python_run");
+            registerForgeGuide(registry, new GuideProvider({
+                ...(forgeRuntime.jsReady
+                    ? {
+                        javascript: async () => {
+                            const status = await forgeRuntime.status();
+                            return {
+                                version: status.javascript.version,
+                                isolation: status.engines[0]?.isolation ?? "wasm-isolate",
+                                host: status.javascript.host,
+                                limits: status.javascript.limits,
+                            };
+                        },
+                    }
+                    : {}),
+                ...(hasPython
+                    ? {
+                        python: () => probePythonEnvironment({
+                            backends: pythonBackends,
+                            runtime: () => config.analysis.runtime,
+                            isolation: () => config.analysis.isolation,
+                            managedExtras: async () => (await analysisRuntime.activeRuntime())?.extras ?? [],
+                            smartDashboard: () => config.analysis.smartDashboard,
+                        }),
+                    }
+                    : {}),
+            }));
+        }
         // `exit_plan` (opt-in: only the plan agent's run sees it): the plan review hand-over.
         const { registerExitPlan } = await import("./plan/exit-plan.js");
         registerExitPlan(registry, {
@@ -957,8 +1097,10 @@ export async function createApplication(options = {}) {
         if (analysisEnabled && options.db !== ":memory:")
             janitor.start();
         // Retention is maintenance that deletes files: never under --read-only, never for `:memory:`.
-        if (options.db !== ":memory:" && !options.readOnly)
+        if (options.db !== ":memory:" && !options.readOnly) {
             taskJanitor.start();
+            scratchJanitor.start();
+        }
         return {
             workspace,
             pathAccess,
@@ -983,9 +1125,39 @@ export async function createApplication(options = {}) {
                 jobs: analysisJobs,
                 /** Container runtime of the current configuration (status, pull); mode `managed` ignores it. */
                 oci,
+                /** The live state of every Python backend (isolation, ready, profiles, reason). */
+                backends: (signal) => describePythonBackends(pythonBackends, signal),
                 rerun: analysisRerun,
                 janitor,
             },
+            /**
+             * Forja services for the engines (Phase 3b): the execution journal, the cross-execution
+             * state, the scratchpad of a session (undefined while the JavaScript engine is off) and the
+             * retention sweep of the volatile session folders.
+             */
+            forge: {
+                journal: forgeJournal,
+                state: forgeState,
+                /** The scratchpad, created on first use; under the same gate as the write root. */
+                scratchpad: scratchpad
+                    ? (session) => scratchReady && !options.readOnly ? scratchpad(session) : Promise.resolve(undefined)
+                    : undefined,
+                /**
+                 * What the HTTP surface sees (L2): `available` follows the gate of the write root (engine
+                 * verified, not `--read-only`); the folder is only looked up, never created.
+                 */
+                scratchpadView: scratchpadLookup
+                    ? async (session) => {
+                        if (!scratchReady || options.readOnly)
+                            return { available: false };
+                        const path = await scratchpadLookup(session);
+                        return path ? { available: true, path } : { available: true };
+                    }
+                    : undefined,
+                scratchJanitor,
+                /** The JavaScript engine: descriptor and effective limits (`alisio forge status`), probe. */
+                runtime: forgeRuntime,
+            },
             /** Keys a project layer set that only the user layer decides (ignored on load). */
             configDiagnostics: configProvenance.ignored ?? [],
             /** Tabular datasets of every session (ingestion, read-only queries, pages). */
@@ -1306,6 +1478,18 @@ export async function createApplication(options = {}) {
                         config.tasks = { ...config.tasks, [leaf]: Number(value) };
                         break;
                     }
+                    case "forge.javascript.enabled":
+                        // The tool set (`js_run` or `execute`) is chosen when the application starts: the
+                        // change applies to the next application (the web recycles the workspace application).
+                        config.forge = {
+                            ...config.forge,
+                            javascript: { ...config.forge.javascript, enabled: value === true },
+                        };
+                        break;
+                    case "forge.guides.enabled":
+                        // Like `forge.javascript.enabled`: `forge_guide` is registered at start.
+                        config.forge = { ...config.forge, guides: { enabled: value === true } };
+                        break;
                     case "web.iconTheme":
                         // Read live by the icon-theme routes on the next request; `"none"` clears the theme.
                         config.web = { ...config.web, iconTheme: String(value) };
@@ -1400,6 +1584,30 @@ export async function createApplication(options = {}) {
                 sessionProviders.set(session.id, runtime);
                 return session;
             },
+            /**
+             * Re-binds an existing session to the provider that owns `model` (a configured profile), else
+             * to the active provider. The session keeps a single provider+model binding, so choosing a
+             * model of the now-active provider makes it usable even when the session's original provider
+             * is gone. The persisted transcript is provider-neutral: no new session is needed.
+             */
+            async rebindSession(sessionId, model) {
+                const requested = model?.trim();
+                if (requested) {
+                    const target = await resolveModel(requested).catch(() => undefined);
+                    if (target) {
+                        const runtime = await runtimeFor(target);
+                        store.updateBinding(sessionId, runtime.id, target.model.id);
+                        sessionProviders.set(sessionId, runtime);
+                        return { provider: runtime.id, model: target.model.id };
+                    }
+                }
+                // No configured profile owns it (or none requested): keep the active provider.
+                const next = requested || provider.model;
+                store.updateBinding(sessionId, provider.id, next);
+                sessionProviders.set(sessionId, provider.currentProvider);
+                retainedProviders.add(provider.currentProvider);
+                return { provider: provider.id, model: next };
+            },
             /** Persists and activates only after construction succeeds; programmatic overrides stay fixed. */
             async activateProvider(id, profile, credentials, model, profileName = id) {
                 if (options.provider)
@@ -1468,6 +1676,7 @@ export async function createApplication(options = {}) {
                 try {
                     janitor.stop();
                     taskJanitor.stop();
+                    scratchJanitor.stop();
                     datasets?.close();
                     // Tasks first in the same stage: they end with Alisio (process groups killed).
                     await capped(Promise.allSettled([herdr.close(), mcp.close(), tasks.close()]));

package/dist/changelog/data.js

@@ -2,6 +2,70 @@
 export const CHANGELOG_DATA = {
     schema: 1,
     entries: [
+        {
+            version: "0.6.0",
+            date: "2026-10-12",
+            sections: [
+                {
+                    title: "Added",
+                    items: [
+                        "`js_run`: the model writes a short JavaScript script that composes tools, runs them in parallel and returns a small result. It runs in an isolated QuickJS-WebAssembly VM with limits for time, memory, calls and output; every nested call passes your permissions and a script cannot ask for approval.",
+                        "`forge_guide`: a short guide for `js_run` and `python_run`, generated from the live limits, tools and Python backend, so the model learns the real environment on demand (`forge.guides.enabled`).",
+                        "`python_run` backends `auto`, `managed`, `oci` and `wasm`, with an isolation policy (`analysis.isolation`: `preferred`, `required` or `strict`). The new `wasm` backend runs Pyodide in a restricted Node process with no Docker (`alisio analysis setup --wasm`); the result names the engine and why it was chosen. `alisio forge status` shows every engine and why one is not ready.",
+                        "A per-session scratchpad where the model keeps scripts and intermediate files and runs them with `codePath` (`forge.scratch.*`: 7 days of retention and a 256 MiB quota by default). Python sees it read only through `ALISIO_SCRATCH_DIR`.",
+                        "Web UI: a Forja settings page, a `js_run` card with the code, the nested calls and a progress bar, an isolation badge and the reason on every `python_run`, and a Scratch tab to preview, download and empty the scratchpad. The terminal shows nested-call counts and the Python backend.",
+                        "Database migrations v9 and v10 (the execution journal and the shared script state) and `alisio_runtime` 4 with `alisio_runtime.forge`; they apply automatically.",
+                    ],
+                },
+                {
+                    title: "Changed",
+                    items: [
+                        "`analysis.runtime` defaults to `auto` (before: `managed`): Alisio uses the most isolated backend that is ready (container, then WebAssembly, then your Python). Set `managed` to keep the old behavior; an explicit value is honored or fails, never replaced.",
+                        "While `forge.javascript.enabled` is on (the default), `execute` is not registered: `js_run` takes its place. Set it to `false` to get `execute` and the previous prompt back; saved sessions with `execute` calls still open.",
+                        "The script's own progress now reaches the web UI next to the nested-call events instead of being replaced by them.",
+                        "Isolation has limits you should know: the `wasm` backend does not block the network on Node 22 and 24, its memory limit is soft and a hostile script can reach the runner's JavaScript; `managed` is not a sandbox. The Forja documentation page lists them.",
+                    ],
+                },
+            ],
+        },
+        {
+            version: "0.5.2",
+            date: "2026-10-08",
+            sections: [
+                {
+                    title: "Fixed",
+                    items: [
+                        "Changing the model in a chat re-binds the session to the model's provider, so you can pick any model of the current provider and keep using the same conversation even when the session's original provider is gone, without starting a new chat.",
+                    ],
+                },
+            ],
+        },
+        {
+            version: "0.5.1",
+            date: "2026-10-08",
+            sections: [
+                {
+                    title: "Fixed",
+                    items: [
+                        'The file panel previews PDFs again: the server no longer blocks the same-origin frame, which showed "refused to connect" instead of the document.',
+                    ],
+                },
+            ],
+        },
+        {
+            version: "0.5.0",
+            date: "2026-10-07",
+            sections: [
+                {
+                    title: "Added",
+                    items: [
+                        "The Trajectory tab offers a Table/Timeline switch: the timeline is an execution trace with lanes for the model, the tools and the user waits, plus tokens per turn and time per tool.",
+                        "The file panel adds a right-click menu to copy a file's absolute path, relative path or name, and previews PDFs and HTML (with a source toggle for HTML).",
+                        "Icon-theme plugins: choose one in Settings, Appearance (for example the Material Icon Theme plugin).",
+                    ],
+                },
+            ],
+        },
         {
             version: "0.4.5",
             date: "2026-10-07",