@alisio/core 0.5.2 → 0.7.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). */

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) };
@@ -1492,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,48 @@
 export const CHANGELOG_DATA = {
     schema: 1,
     entries: [
+        {
+            version: "0.7.0",
+            date: "2026-10-14",
+            sections: [
+                {
+                    title: "Added",
+                    items: [
+                        "`alisio eval list|run|record|compare|variants|export`: run evaluation suites against any configured provider, compare variants and export the results.",
+                        "Reliability Lab suites with deterministic verifiers (files, commands, tool sequences), so a pass or fail never depends on a model judging itself.",
+                        "`pass@k` and `pass^k` metrics with Wilson confidence intervals, so a comparison tells you whether a difference is real or noise.",
+                        "Cassettes: `alisio eval record` captures provider responses and later runs replay them offline, without network or cost.",
+                        "Bundled suites `smoke-coding`, `tool-sequences` and `long-context`, available from a source checkout.",
+                    ],
+                },
+            ],
+        },
+        {
+            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",

package/dist/config.d.ts

@@ -196,9 +196,22 @@ export declare const configSchema: z.ZodPipe<z.ZodObject<{
         enabled: z.ZodDefault<z.ZodBoolean>;
         smartDashboard: z.ZodDefault<z.ZodBoolean>;
         runtime: z.ZodDefault<z.ZodEnum<{
+            auto: "auto";
             managed: "managed";
             oci: "oci";
+            wasm: "wasm";
         }>>;
+        isolation: z.ZodDefault<z.ZodEnum<{
+            preferred: "preferred";
+            required: "required";
+            strict: "strict";
+        }>>;
+        wasm: z.ZodDefault<z.ZodObject<{
+            memoryMb: z.ZodDefault<z.ZodNumber>;
+            startupMs: z.ZodDefault<z.ZodNumber>;
+            maxInputBytes: z.ZodDefault<z.ZodNumber>;
+            nodePath: z.ZodDefault<z.ZodNullable<z.ZodString>>;
+        }, z.core.$strict>>;
         oci: z.ZodDefault<z.ZodObject<{
             engine: z.ZodDefault<z.ZodEnum<{
                 docker: "docker";
@@ -255,6 +268,35 @@ export declare const configSchema: z.ZodPipe<z.ZodObject<{
         active: z.ZodDefault<z.ZodString>;
         effort: z.ZodOptional<z.ZodString>;
     }, z.core.$strict>>;
+    forge: z.ZodDefault<z.ZodObject<{
+        javascript: z.ZodDefault<z.ZodObject<{
+            enabled: z.ZodDefault<z.ZodBoolean>;
+            host: z.ZodDefault<z.ZodEnum<{
+                auto: "auto";
+                process: "process";
+                worker: "worker";
+            }>>;
+            timeoutMs: z.ZodDefault<z.ZodNumber>;
+            memoryBytes: z.ZodDefault<z.ZodNumber>;
+            stackBytes: z.ZodDefault<z.ZodNumber>;
+            maxToolCalls: z.ZodDefault<z.ZodNumber>;
+            maxConcurrency: z.ZodDefault<z.ZodNumber>;
+            maxOutputChars: z.ZodDefault<z.ZodNumber>;
+        }, z.core.$strict>>;
+        state: z.ZodDefault<z.ZodObject<{
+            enabled: z.ZodDefault<z.ZodBoolean>;
+            maxTotalBytes: z.ZodDefault<z.ZodNumber>;
+        }, z.core.$strict>>;
+        scratch: z.ZodDefault<z.ZodObject<{
+            enabled: z.ZodDefault<z.ZodBoolean>;
+            root: z.ZodDefault<z.ZodNullable<z.ZodString>>;
+            retentionDays: z.ZodDefault<z.ZodNumber>;
+            maxBytes: z.ZodDefault<z.ZodNumber>;
+        }, z.core.$strict>>;
+        guides: z.ZodDefault<z.ZodObject<{
+            enabled: z.ZodDefault<z.ZodBoolean>;
+        }, z.core.$strict>>;
+    }, z.core.$strict>>;
     web: z.ZodDefault<z.ZodObject<{
         iconTheme: z.ZodDefault<z.ZodString>;
     }, z.core.$strict>>;
@@ -325,7 +367,14 @@ export declare const configSchema: z.ZodPipe<z.ZodObject<{
     analysis: {
         enabled: boolean;
         smartDashboard: boolean;
-        runtime: "managed" | "oci";
+        runtime: "auto" | "managed" | "oci" | "wasm";
+        isolation: "preferred" | "required" | "strict";
+        wasm: {
+            memoryMb: number;
+            startupMs: number;
+            maxInputBytes: number;
+            nodePath: string | null;
+        };
         oci: {
             engine: "docker" | "podman";
             image?: string | undefined;
@@ -379,6 +428,31 @@ export declare const configSchema: z.ZodPipe<z.ZodObject<{
         active: string;
         effort?: string | undefined;
     };
+    forge: {
+        javascript: {
+            enabled: boolean;
+            host: "auto" | "process" | "worker";
+            timeoutMs: number;
+            memoryBytes: number;
+            stackBytes: number;
+            maxToolCalls: number;
+            maxConcurrency: number;
+            maxOutputChars: number;
+        };
+        state: {
+            enabled: boolean;
+            maxTotalBytes: number;
+        };
+        scratch: {
+            enabled: boolean;
+            root: string | null;
+            retentionDays: number;
+            maxBytes: number;
+        };
+        guides: {
+            enabled: boolean;
+        };
+    };
     web: {
         iconTheme: string;
     };
@@ -532,7 +606,14 @@ export declare const configSchema: z.ZodPipe<z.ZodObject<{
     analysis: {
         enabled: boolean;
         smartDashboard: boolean;
-        runtime: "managed" | "oci";
+        runtime: "auto" | "managed" | "oci" | "wasm";
+        isolation: "preferred" | "required" | "strict";
+        wasm: {
+            memoryMb: number;
+            startupMs: number;
+            maxInputBytes: number;
+            nodePath: string | null;
+        };
         oci: {
             engine: "docker" | "podman";
             image?: string | undefined;
@@ -586,6 +667,31 @@ export declare const configSchema: z.ZodPipe<z.ZodObject<{
         active: string;
         effort?: string | undefined;
     };
+    forge: {
+        javascript: {
+            enabled: boolean;
+            host: "auto" | "process" | "worker";
+            timeoutMs: number;
+            memoryBytes: number;
+            stackBytes: number;
+            maxToolCalls: number;
+            maxConcurrency: number;
+            maxOutputChars: number;
+        };
+        state: {
+            enabled: boolean;
+            maxTotalBytes: number;
+        };
+        scratch: {
+            enabled: boolean;
+            root: string | null;
+            retentionDays: number;
+            maxBytes: number;
+        };
+        guides: {
+            enabled: boolean;
+        };
+    };
     web: {
         iconTheme: string;
     };
@@ -705,6 +811,8 @@ declare const SETTABLE_KEYS: {
     readonly "plan.diagrams": z.ZodDefault<z.ZodBoolean>;
     readonly "plan.maxDiagrams": z.ZodDefault<z.ZodNumber>;
     readonly "web.iconTheme": z.ZodDefault<z.ZodString>;
+    readonly "forge.javascript.enabled": z.ZodDefault<z.ZodBoolean>;
+    readonly "forge.guides.enabled": z.ZodDefault<z.ZodBoolean>;
 };
 export type SettableSettingKey = keyof typeof SETTABLE_KEYS;
 export declare function isSettableSettingKey(key: string): key is SettableSettingKey;