@alisio/alisio-code 0.5.1 → 0.6.0

package/dist/analysis.d.ts

@@ -1,4 +1,4 @@
-import type { AnalysisStatus } from "@alisio/sdk";
+import type { AnalysisStatus, EngineDescriptor } from "@alisio/sdk";
 type Common = {
     db?: string;
     python?: string;
@@ -6,6 +6,10 @@ type Common = {
     config?: string;
     trustProject?: boolean;
 };
+/** `alisio forge status` reuses this for its Python lines. */
+export declare function pythonBackendDescriptors(o: Common): Promise<EngineDescriptor[]>;
+/** A fixed-width table of the backends: readiness, isolation, profiles and why not. */
+export declare function backendsTable(backends: readonly EngineDescriptor[]): string;
 /** The unified runtime state and, when Python is missing, the install guidance for this system. */
 export declare function analysisState(o: Common): Promise<{
     status: AnalysisStatus;
@@ -24,4 +28,23 @@ export declare function setupExtras(o: Common, extras: string | undefined): Prom
 export declare function setupOci(o: Common, image: string | undefined): Promise<void>;
 /** `alisio analysis sweep [--force]`: the retention sweep now (it also runs by itself, daily). */
 export declare function sweep(o: Common, force: boolean): Promise<void>;
+export interface WasmSetupDeps {
+    /** Replaceable in tests; the global `fetch` otherwise. */
+    fetch?: typeof fetch;
+    manifest?: import("@alisio/core").PyodideManifest;
+    /** Whether someone can answer a question (a terminal). */
+    interactive?: boolean;
+    ask?: (question: string) => Promise<boolean>;
+    write?: (text: string) => void;
+}
+/**
+ * `alisio analysis setup --wasm [--profile analysis|science] [--yes]`: the only place the wasm
+ * backend uses the network. Downloads the pinned Pyodide distribution into
+ * `<analysis dir>/pyodide/<version>/`, verifies every hash and size, and on any mismatch deletes
+ * what it fetched and leaves the backend not ready. It never touches the venv or the OCI image.
+ */
+export declare function setupWasm(o: Common, flags: {
+    profile?: string;
+    yes?: boolean;
+}, deps?: WasmSetupDeps): Promise<void>;
 export {};

package/dist/analysis.js

@@ -5,6 +5,7 @@
  * `python_run`: the base runtime is the discovered Python with only the standard library.
  */
 import { dirname, join } from "node:path";
+import { createInterface } from "node:readline/promises";
 async function context(o) {
     const core = await import("@alisio/core");
     const workspace = await core.findWorkspace(o.cwd ?? process.cwd());
@@ -20,9 +21,41 @@ async function context(o) {
     const oci = () => new core.OciRuntime({ ...config.analysis.oci });
     return { core, config, provenance, stateDir, manager, oci };
 }
+/** The Python backends of this configuration, described with their live readiness. */
+function describeBackends(c) {
+    const backends = c.core.createPythonBackends({
+        runtime: c.manager,
+        oci: { runtime: c.oci, mode: () => c.config.analysis.runtime },
+        wasm: { stateRoot: c.stateDir, settings: () => c.config.analysis.wasm },
+    });
+    return (signal) => c.core.describePythonBackends(backends, signal);
+}
+/** `alisio forge status` reuses this for its Python lines. */
+export async function pythonBackendDescriptors(o) {
+    return describeBackends(await context(o))();
+}
+/** A fixed-width table of the backends: readiness, isolation, profiles and why not. */
+export function backendsTable(backends) {
+    const rows = backends.map((b) => [
+        b.id.replace(/^python-/, ""),
+        b.isolation,
+        b.ready ? "ready" : "not ready",
+        b.profiles?.length ? b.profiles.join(",") : "-",
+        b.capabilities.networkDeniedByOS ? "denied" : "open",
+        b.reason ?? (b.isolation === "none" ? "host (not sandboxed)" : ""),
+    ]);
+    const head = ["BACKEND", "ISOLATION", "STATE", "PROFILES", "NETWORK", "NOTE"];
+    const widths = head.map((h, i) => Math.max(h.length, ...rows.map((r) => (r[i] ?? "").length)));
+    const line = (cells) => cells
+        .map((c, i) => c.padEnd(widths[i] ?? 0))
+        .join("  ")
+        .trimEnd();
+    return [line(head), ...rows.map(line)].join("\n");
+}
 /** The unified runtime state and, when Python is missing, the install guidance for this system. */
 export async function analysisState(o) {
-    const { core, config, provenance, stateDir, manager, oci } = await context(o);
+    const ctx = await context(o);
+    const { core, config, provenance, stateDir, manager, oci } = ctx;
     const janitor = {
         lastSweep: () => import("node:fs/promises")
             .then((fs) => fs.readFile(join(stateDir, "analysis", ".last-sweep"), "utf8"))
@@ -37,6 +70,7 @@ export async function analysisState(o) {
         runtime: manager,
         oci,
         janitor,
+        backends: describeBackends(ctx),
         enabled: config.analysis.enabled,
         readOnly: false,
     });
@@ -58,6 +92,8 @@ export async function analysisState(o) {
 export async function printAnalysisStatus(o) {
     const { status, guidance, ignored } = await analysisState(o);
     console.log(JSON.stringify(status, null, 2));
+    if (status.backends?.length)
+        process.stderr.write(`\nPython backends (analysis.runtime=${status.mode}, analysis.isolation=${status.isolation ?? "preferred"}):\n${backendsTable(status.backends)}\n`);
     if (guidance)
         process.stderr.write(`\n${guidance}\n`);
     if (status.mode === "oci" && status.oci.available === false)
@@ -143,3 +179,66 @@ export async function sweep(o, force) {
         store.close();
     }
 }
+const megabytes = (bytes) => `${Math.max(1, Math.round(bytes / (1024 * 1024)))} MB`;
+async function confirm(question) {
+    const rl = createInterface({ input: process.stdin, output: process.stderr });
+    try {
+        return /^y(es)?$/i.test((await rl.question(question)).trim());
+    }
+    finally {
+        rl.close();
+    }
+}
+/**
+ * `alisio analysis setup --wasm [--profile analysis|science] [--yes]`: the only place the wasm
+ * backend uses the network. Downloads the pinned Pyodide distribution into
+ * `<analysis dir>/pyodide/<version>/`, verifies every hash and size, and on any mismatch deletes
+ * what it fetched and leaves the backend not ready. It never touches the venv or the OCI image.
+ */
+export async function setupWasm(o, flags, deps = {}) {
+    const profile = flags.profile ?? "analysis";
+    if (profile !== "analysis" && profile !== "science")
+        throw new Error("Choose the profile: --profile analysis (default) or --profile science");
+    const { core, stateDir } = await context(o);
+    const manifest = deps.manifest ?? core.PYODIDE_MANIFEST;
+    const write = deps.write ?? ((text) => void process.stderr.write(text));
+    const dir = core.pyodideDir(stateDir, manifest);
+    const bytes = core.pyodideDownloadSize(manifest, profile);
+    const hosts = [
+        ...new Set([...manifest.core, ...Object.values(manifest.packages)].map((f) => new URL(f.url).host)),
+    ];
+    write(`Pyodide ${manifest.version} (Python ${manifest.python}), profile ${profile}: about ${megabytes(bytes)} from ${hosts.join(", ")}.\n` +
+        `It goes to ${dir}. Every file is checked against a pinned SHA-256; this command is the only time the wasm backend uses the network.\n`);
+    if (!flags.yes) {
+        const interactive = deps.interactive ?? (!!process.stdin.isTTY && !!process.stderr.isTTY);
+        if (!interactive)
+            throw new Error("This download needs your confirmation: pass --yes in a non-interactive run.");
+        const ok = await (deps.ask ?? confirm)("Download now? [y/N] ");
+        if (!ok) {
+            write("Cancelled; nothing was downloaded.\n");
+            return;
+        }
+    }
+    const controller = new AbortController();
+    process.on("SIGINT", () => controller.abort(new Error("Interrupted")));
+    try {
+        const result = await core.installPyodide({
+            dir,
+            profile,
+            manifest,
+            signal: controller.signal,
+            ...(deps.fetch ? { fetch: deps.fetch } : {}),
+            onProgress: (e) => write(`  [${e.index}/${e.total}] ${e.file}\n`),
+        });
+        write(`Pyodide ${manifest.version} is ready (profile ${result.ok ? result.profile : profile}). ` +
+            'With analysis.runtime "auto" it is used when no container is ready; set analysis.runtime to "wasm" to require it.\n');
+    }
+    catch (error) {
+        const integrity = error instanceof core.PyodideIntegrityError;
+        write(`${error instanceof Error ? error.message : String(error)}\n` +
+            (integrity
+                ? "Nothing from this download was kept. The wasm backend is not ready.\n"
+                : "Nothing from this download was kept.\n"));
+        process.exitCode = 1;
+    }
+}

package/dist/forge.d.ts

@@ -0,0 +1,13 @@
+/**
+ * `alisio forge status`: what `GET /api/forge` will report, for the terminal. It builds the engine
+ * from the configuration alone (no application, no database): the WASM is checked against its
+ * pinned hash, the host files are looked for, and `--probe` runs a real isolate end to end.
+ */
+type Common = {
+    cwd?: string;
+    config?: string;
+    trustProject?: boolean;
+    json?: boolean;
+};
+export declare function printForgeStatus(o: Common, probe: boolean): Promise<void>;
+export {};

package/dist/forge.js

@@ -0,0 +1,46 @@
+const mib = (bytes) => `${Math.round(bytes / (1024 * 1024))} MiB`;
+export async function printForgeStatus(o, probe) {
+    const core = await import("@alisio/core");
+    const workspace = await core.findWorkspace(o.cwd ?? process.cwd());
+    const { config } = await core.loadConfigWithProvenance(workspace, {
+        file: o.config,
+        trustProject: o.trustProject,
+    });
+    const engine = core.forgeEngineFor(config.forge);
+    const { pythonBackendDescriptors } = await import("./analysis.js");
+    const python = await pythonBackendDescriptors(o);
+    const base = await core.describeForge(config.forge, engine);
+    const status = {
+        ...base,
+        engines: [...base.engines, ...python],
+        python: { runtime: config.analysis.runtime, isolation: config.analysis.isolation },
+    };
+    const probed = probe ? await engine.probe() : undefined;
+    if (o.json) {
+        process.stdout.write(`${JSON.stringify({ ...status, ...(probed ? { probe: probed } : {}) })}\n`);
+        return;
+    }
+    const js = status.javascript;
+    const descriptor = status.engines[0];
+    const lines = [
+        `JavaScript   ${js.enabled ? "enabled" : "disabled"}   ${descriptor?.ready ? "ready" : "not ready"}`,
+        `  engine     ${descriptor?.id ?? "javascript-quickjs"}  ${js.version}`,
+        `  isolation  ${descriptor?.isolation ?? "none"}  (${js.host} host${js.hostSetting === "auto" ? "" : `, forced by forge.javascript.host=${js.hostSetting}`})`,
+        `  wasm       sha256 ${js.wasmSha256}${js.verified ? "  verified" : ""}`,
+    ];
+    if (!descriptor?.ready && descriptor?.reason)
+        lines.push(`  reason     ${descriptor.reason}`);
+    if (js.verification)
+        lines.push(`  problem    ${js.verification}`);
+    lines.push(`  limits     timeout ${js.limits.timeoutMs} ms, heap ${mib(js.limits.memoryBytes)}, stack ${Math.round(js.limits.stackBytes / 1024)} KiB, ${js.limits.maxToolCalls} calls (${js.limits.maxConcurrency} at once), ${js.limits.maxOutputChars} output chars`, `  state      ${status.state.enabled ? "on" : "off"}    scratchpad ${status.scratch.enabled ? "on" : "off"}`);
+    lines.push("", `Python       analysis.runtime=${config.analysis.runtime}  isolation=${config.analysis.isolation}`);
+    for (const backend of python)
+        lines.push(`  ${backend.id.replace(/^python-/, "").padEnd(10)} ${backend.isolation.padEnd(13)} ${backend.ready ? "ready    " : "not ready"}  network ${backend.capabilities.networkDeniedByOS ? "denied by the OS" : "not blocked"}${backend.profiles?.length ? `  profiles ${backend.profiles.join(",")}` : ""}${backend.reason ? `  (${backend.reason})` : ""}`);
+    if (probed)
+        lines.push(probed.ok
+            ? `  probe      ok, a ${probed.host} isolate ran a script in ${probed.bootMs} ms`
+            : `  probe      FAILED (${probed.host} host): ${probed.reason}`);
+    process.stdout.write(`${lines.join("\n")}\n`);
+    if (probed && !probed.ok)
+        process.exitCode = 1;
+}

package/dist/main.js

@@ -419,6 +419,8 @@ program.command("doctor").action(async (_opts, cmd) => {
         python: { mode: analysisInfo.status.mode, ...pythonInfo },
         analysis: {
             mode: analysisInfo.status.mode,
+            ...(analysisInfo.status.isolation ? { isolation: analysisInfo.status.isolation } : {}),
+            ...(analysisInfo.status.backends ? { backends: analysisInfo.status.backends } : {}),
             oci: analysisInfo.status.oci,
             limits: analysisInfo.status.limits,
             retention: analysisInfo.status.retention,
@@ -447,13 +449,21 @@ analysis
 });
 analysis
     .command("setup")
-    .description("Optional: install hash-locked Python extras (--extras) or pull the container image (--oci). " +
-    "python_run never needs this for the standard library.")
+    .description("Optional: install hash-locked Python extras (--extras), pull the container image (--oci) or " +
+    "download the WebAssembly runtime (--wasm). python_run never needs this for the standard library.")
     .option("--extras <set>", "analysis (pandas, numpy, matplotlib…) or science (adds scipy…)")
     .option("--oci", "Pull the container image once and verify its digest (Docker or Podman)")
     .option("--image <name>", "With --oci: the image to pull (default: analysis.oci.image)")
+    .option("--wasm", "Download the pinned Pyodide runtime for the wasm backend (needs network)")
+    .option("--profile <name>", "With --wasm: analysis (default) or science (adds scipy, scikit-learn…)")
+    .option("--yes", "With --wasm: do not ask for confirmation (required when not interactive)")
     .action(async (flags, cmd) => {
-    const { setupExtras, setupOci } = await import("./analysis.js");
+    const { setupExtras, setupOci, setupWasm } = await import("./analysis.js");
+    if (flags.wasm)
+        return setupWasm(options(cmd), {
+            ...(flags.profile ? { profile: flags.profile } : {}),
+            yes: !!flags.yes,
+        });
     if (flags.oci)
         return setupOci(options(cmd), flags.image);
     return setupExtras(options(cmd), flags.extras);
@@ -466,6 +476,17 @@ analysis
     const { sweep } = await import("./analysis.js");
     await sweep(options(cmd), !!flags.force);
 });
+const forge = program
+    .command("forge")
+    .description("Forja: isolated code execution (js_run). Shows the engine and why it is or is not ready");
+forge
+    .command("status")
+    .description("Show the engines: JavaScript (version, WASM hash, isolation, host, limits) and the Python backends")
+    .option("--probe", "Also start a real isolate and run a trivial script through the protocol")
+    .action(async (flags, cmd) => {
+    const { printForgeStatus } = await import("./forge.js");
+    await printForgeStatus(options(cmd), !!flags.probe);
+});
 const trust = program.command("trust").description("Inspect or revoke per-directory project trust");
 trust.command("list").action(async () => {
     const { listTrust } = await import("@alisio/core");
@@ -665,7 +686,14 @@ program
     await cliUpdateAll(common);
 });
 try {
-    await program.parseAsync();
+    // The compiled binary starts its own Forja process isolates with this hidden command (spec D-21).
+    // It is dispatched before any configuration or database is loaded and is not part of the CLI.
+    if (process.argv.slice(2)[0] === "__forge-isolate") {
+        const { runProcessIsolate } = await import("@alisio/core/forge-isolate");
+        await runProcessIsolate();
+    }
+    else
+        await program.parseAsync();
 }
 catch (error) {
     console.error(error instanceof Error ? error.message : String(error));

package/dist/tui/artifacts.d.ts

@@ -51,4 +51,4 @@ export declare const installApprovalTitle: (install: InstallPreview) => string;
 /** Body of the `analysis.install` approval: the packages, the download estimate and the network. */
 export declare function installApprovalDetail(install: InstallPreview): string;
 /** Title of a capability approval in the TUI picker. */
-export declare const capabilityApprovalTitle: (runtime: "managed" | "oci" | undefined) => string;
+export declare const capabilityApprovalTitle: (runtime: "auto" | "managed" | "oci" | "wasm" | undefined) => string;

package/dist/tui/artifacts.js

@@ -204,4 +204,8 @@ export function installApprovalDetail(install) {
 /** Title of a capability approval in the TUI picker. */
 export const capabilityApprovalTitle = (runtime) => runtime === "oci"
     ? "Run Python analysis (container · no network)?"
-    : "Run Python analysis (managed · not sandboxed)?";
+    : runtime === "wasm"
+        ? "Run Python analysis (wasm · restricted process, network not blocked)?"
+        : runtime === "auto"
+            ? "Run Python analysis (most isolated backend ready; the host only if none · see the engine line)?"
+            : "Run Python analysis (managed · not sandboxed)?";

package/dist/tui/components.js

@@ -8,7 +8,7 @@ import { branchDisplay } from "./git-branch.js";
 import { initialPlanReviewState, reducePlanReview, } from "./plan-review.js";
 import { initialQuestionState, reduceQuestions, } from "./questions.js";
 import { scrollWindow } from "./scroll.js";
-import { contextLevel, contextPercent, editSummary, entryKeyOf, fitIdentityParts, fitSegments, foldCandidateOf, formatContext, formatDuration, formatTokens, groupIdentity, groupToolEntries, humanizeToolName, isUiBlock, previewLinesFor, previewRows, quietFor, REASONING_EXPAND_MAX_LINES, reasoningDurationMs, runPhase, STALLED_MS, } from "./state.js";
+import { contextLevel, contextPercent, editSummary, entryKeyOf, fitIdentityParts, fitSegments, foldCandidateOf, forgeLabel, formatContext, formatDuration, formatTokens, groupIdentity, groupToolEntries, humanizeToolName, isUiBlock, previewLinesFor, previewRows, quietFor, REASONING_EXPAND_MAX_LINES, reasoningDurationMs, runPhase, STALLED_MS, } from "./state.js";
 import { highlightCode, imageTheme, levelColor, markdownDefaultTextStyle, markdownTheme, markdownTransform, sanitizeCode, style, } from "./theme.js";
 export const SPINNER = ["⠋", "⠙", "⠹", "⠸", "⠼", "⠴", "⠦", "⠧", "⠇", "⠏"];
 /** Shared animation clock advanced by the app while work is running. */
@@ -643,7 +643,9 @@ export class ToolBlock {
                 ? style.gray(formatDuration(i.durationMs))
                 : "";
         const progress = i.status === "running" && i.progress ? ` ${style.dim(`· ${i.progress}`)}` : "";
-        const head = `${marker}${icon} ${style.bold(humanizeToolName(i.name))} ${style.gray(i.summary)}${progress}`;
+        const forge = forgeLabel(i.forge);
+        const forgePart = forge ? ` ${style.dim(`· ${forge}`)}` : "";
+        const head = `${marker}${icon} ${style.bold(humanizeToolName(i.name))} ${style.gray(i.summary)}${forgePart}${progress}`;
         const gap = width - visibleWidth(head) - visibleWidth(right) - 1;
         const lines = [
             gap > 0 ? `${head}${" ".repeat(gap + 1)}${right}` : truncateToWidth(head, width),
@@ -728,7 +730,7 @@ export class ToolGroupBlock {
                     : `${style.bold(member.humanName)} ${style.dim(`(${member.name})`)}`;
                 lines.push(`  ${micon} ${name}${member.durationMs !== undefined
                     ? ` ${style.gray(`· ${formatDuration(member.durationMs)}`)}`
-                    : ""}${member.summary ? ` ${style.gray(member.summary)}` : ""}`);
+                    : ""}${member.summary ? ` ${style.gray(member.summary)}` : ""}${member.forge ? ` ${style.dim(`· ${member.forge}`)}` : ""}`);
                 const rich = richBodyLines(member, width);
                 if (rich.lines.length) {
                     lines.push(...rich.lines.map((line) => `    ${line}`));

package/dist/tui/state.d.ts

@@ -1,4 +1,4 @@
-import type { Message, ModelInfo, RunEvent, ToolResult, TreeNode, UiBlock } from "@alisio/sdk";
+import type { EngineId, Message, ModelInfo, RunEvent, ToolResult, TreeNode, UiBlock } from "@alisio/sdk";
 export type Level = "ok" | "warn" | "danger";
 export declare function formatTokens(n: number): string;
 /** Prefixes every model with its owning provider so identical model ids are never ambiguous. */
@@ -317,6 +317,8 @@ export type TranscriptItem = {
     toolKind?: ToolKind;
     /** Last non-empty `tool_progress` line while the tool runs (cleared on completion). */
     progress?: string;
+    /** What a Forja execution (`js_run`, `python_run`) reported; kept after completion. */
+    forge?: ForgeLine;
     /** Exit code derived safely from the JSON preview when the tool reports one (run_process/shell/search_text). */
     exitCode?: number;
 } | {
@@ -377,6 +379,18 @@ export declare function reasoningDurationMs(item: {
     reasoningStartedAt?: number;
     reasoningDoneAt?: number;
 }): number | undefined;
+/** What the row of a Forja execution shows: nested calls, the script's own note and the engine. */
+export interface ForgeLine {
+    engine: EngineId;
+    /** Highest nested call number seen. */
+    started: number;
+    /** Nested calls that ended (succeeded, failed or denied). */
+    finished: number;
+    /** The script's own `progress({ message, completed, total })`, bounded. */
+    note?: string;
+}
+/** `page 2 (2/9) · 2/3 calls · wasm`; empty when there is nothing to say yet. */
+export declare function forgeLabel(forge: ForgeLine | undefined): string;
 export declare function reduceEvent(state: ViewState, event: RunEvent): ViewState;
 /** No event for this long: the footer says how long the run has been quiet. */
 export declare const QUIET_MS = 15000;
@@ -460,6 +474,8 @@ export interface ToolItemView {
     summary: string;
     /** Last progress line while running. */
     progress?: string;
+    /** `2/3 calls · wasm` of a Forja execution (running or finished). */
+    forge?: string;
     status: ToolStatus;
     durationMs?: number;
     preview?: string;

package/dist/tui/state.js

@@ -580,6 +580,54 @@ function updateTool(state, id, update) {
     items[index] = { ...item, ...update };
     return { ...state, items };
 }
+const FORGE_NOTE_MAX = 40;
+const isForgeProgress = (value) => !!value &&
+    typeof value === "object" &&
+    value.kind === "forge" &&
+    typeof value.engine === "string";
+/** Folds one `ForgeProgress` into the line (terminal call events are never coalesced away). */
+function foldForgeProgress(current, progress) {
+    const next = current
+        ? { ...current, engine: progress.engine }
+        : { engine: progress.engine, started: 0, finished: 0 };
+    if (progress.call) {
+        next.started = Math.max(next.started, progress.call.callId);
+        if (progress.call.status !== "started")
+            next.finished += 1;
+    }
+    else if (progress.message || progress.total !== undefined) {
+        const fraction = progress.completed !== undefined && progress.total !== undefined
+            ? ` (${progress.completed}/${progress.total})`
+            : "";
+        const message = (progress.message ?? "").slice(0, FORGE_NOTE_MAX);
+        next.note = `${message}${fraction}`.trim();
+    }
+    return next;
+}
+/** The isolation tag of a Python engine; nothing for JavaScript (it is always isolated). */
+const FORGE_ENGINE_TAG = {
+    "python-oci": "oci",
+    "python-wasm": "wasm",
+    "python-managed": "host!",
+};
+/** `page 2 (2/9) · 2/3 calls · wasm`; empty when there is nothing to say yet. */
+export function forgeLabel(forge) {
+    if (!forge)
+        return "";
+    return [
+        forge.note,
+        forge.started > 0 ? `${forge.finished}/${forge.started} calls` : undefined,
+        FORGE_ENGINE_TAG[forge.engine],
+    ]
+        .filter(Boolean)
+        .join(" · ");
+}
+const ENGINE_LINE = /^engine: (python-oci|python-wasm|python-managed) \(/m;
+/** The Python engine a result text names on its last line (PD11), for rows without progress. */
+const engineOfResult = (text) => {
+    const engine = typeof text === "string" ? ENGINE_LINE.exec(text)?.[1] : undefined;
+    return engine ? { engine: engine, started: 0, finished: 0 } : undefined;
+};
 /** Longest progress line kept on a running tool row. */
 const PROGRESS_LINE_MAX = 80;
 /** The last non-empty line of a `tool_progress` payload, bounded; empty when it has none. */
@@ -733,6 +781,11 @@ function reduceEventItems(state, event) {
             });
         }
         case "tool_progress": {
+            if (isForgeProgress(d.data)) {
+                const row = state.items.findLast((i) => i.kind === "tool" && i.id === d.id);
+                const before = row?.kind === "tool" ? row.forge : undefined;
+                return updateTool(state, d.id, { forge: foldForgeProgress(before, d.data) });
+            }
             const line = lastProgressLine(d.data);
             return line ? updateTool(state, d.id, { progress: line }) : state;
         }
@@ -757,6 +810,9 @@ function reduceEventItems(state, event) {
                 status: d.isError ? "error" : "ok",
                 ...(typeof d.durationMs === "number" ? { durationMs: d.durationMs } : {}),
                 ...(typeof d.preview === "string" ? { preview: d.preview } : {}),
+                ...(running?.kind === "tool" && !running.forge && engineOfResult(d.preview)
+                    ? { forge: engineOfResult(d.preview) }
+                    : {}),
                 ...exitCodePart(d.preview),
                 ...(isUiBlock(d.ui) ? { ui: d.ui } : {}),
                 ...(isImagePart(d.image) ? { image: d.image } : {}),
@@ -1186,6 +1242,7 @@ export function toolItemView(item) {
         kind: item.toolKind ?? toolKindOf(item.name),
         summary: item.summary,
         ...(item.progress ? { progress: item.progress } : {}),
+        ...(forgeLabel(item.forge) ? { forge: forgeLabel(item.forge) } : {}),
         status: item.status,
         ...(item.durationMs !== undefined ? { durationMs: item.durationMs } : {}),
         ...(item.preview !== undefined ? { preview: item.preview } : {}),
@@ -1351,11 +1408,13 @@ export function itemsFromHistory(messages) {
                 items.push({ kind: "assistant", text: m.text, reasoning: "", done: true });
             for (const c of m.calls) {
                 const r = results.get(c.id);
-                const preview = r?.result.content
+                const text = r?.result.content
                     .filter((p) => p.type === "text")
                     .map((x) => x.text)
-                    .join("\n")
-                    .slice(0, 2_000);
+                    .join("\n");
+                const preview = text?.slice(0, 2_000);
+                // The engine line closes a python_run result (PD11); read it before the preview clips it.
+                const forge = c.name === "python_run" ? engineOfResult(text) : undefined;
                 items.push({
                     kind: "tool",
                     id: c.id,
@@ -1365,6 +1424,7 @@ export function itemsFromHistory(messages) {
                     status: r?.result.isError ? "error" : "ok",
                     preview,
                     toolKind: toolKindOf(c.name),
+                    ...(forge ? { forge } : {}),
                     ...exitCodePart(preview),
                     ...richPartsOf(r?.result, c.name),
                 });

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@alisio/alisio-code",
-  "version": "0.5.1",
+  "version": "0.6.0",
   "description": "Alisio: an extensible, provider-agnostic coding-agent harness for your terminal. TUI, OpenAI-compatible providers, permissioned local tools, context compaction, persistent memory and a typed plugin SDK.",
   "author": "Gustavo Gutiérrez",
   "license": "MIT",
@@ -45,12 +45,12 @@
     "alisio": "./dist/main.js"
   },
   "dependencies": {
-    "@alisio/core": "0.5.1",
-    "@alisio/plugin-memory": "0.5.1",
-    "@alisio/plugin-openai-compatible": "0.5.1",
-    "@alisio/plugin-subagents": "0.5.1",
-    "@alisio/sdk": "0.5.1",
-    "@alisio/server": "0.5.1",
+    "@alisio/core": "0.6.0",
+    "@alisio/plugin-memory": "0.6.0",
+    "@alisio/plugin-openai-compatible": "0.6.0",
+    "@alisio/plugin-subagents": "0.6.0",
+    "@alisio/sdk": "0.6.0",
+    "@alisio/server": "0.6.0",
     "@earendil-works/pi-tui": "0.87.1",
     "commander": "15.0.0"
   },