@alisio/alisio-code 0.5.2 → 0.7.0

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,79 @@ 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 evalCommand = program
+    .command("eval")
+    .description("Reliability lab: run a task suite k times, report pass rates with Wilson intervals, compare reports or config variants, record cassettes and replay them without a model");
+/** `alisio eval` entry points: lazy, and exit codes are returned, not thrown (0 ok, 1 error, 2 replay diverged, 3 incompatible). */
+async function runEval(cmd, action) {
+    const api = await import("./eval.js");
+    const env = await api.realEvalEnv(async () => options(cmd), async () => cliDefaults());
+    process.exitCode = await action(api, env, cmd.optsWithGlobals());
+}
+const evalRunOptions = (command) => command
+    .option("--tasks <ids>", "Comma-separated task ids (default: every task of the suite)")
+    .option("--k <n>", "Repetitions per task (default 5; below 5 the report warns of low power)")
+    .option("--seed <n>", "Seed of the run order; each run gets seed + repetition")
+    .option("--mode <mode>", "live (default) or replay (serve the recorded cassettes: no provider, no network; measures the harness, not the model)")
+    .option("--cassette-dir <dir>", "Cassette directory (default: <suite>/cassettes; used by --mode replay and by record)")
+    .option("--keep", "Keep each run's temporary directory (it prints the paths)")
+    .option("--out <dir>", "Write the report files here (default: <state>/eval/<runId>/)")
+    .option("--suite-dir <dir>", "A suite, or a directory of suites; third-party code: needs --yes")
+    .option("--allow-suite-full", "Let a suite run tasks that ask for the full permission mode")
+    .option("--yes", "Confirm running a --suite-dir suite without asking (required if not interactive)")
+    .option("--input-rate <usd>", "USD per million input tokens, to estimate cost (needs --output-rate)")
+    .option("--output-rate <usd>", "USD per million output tokens (needs --input-rate)");
+evalCommand
+    .command("list")
+    .description("List the available suites (bundled ones plus --suite-dir)")
+    .option("--suite-dir <dir>", "A suite, or a directory of suites")
+    .action((_flags, cmd) => runEval(cmd, (api, env, flags) => api.evalList(env, flags)));
+evalRunOptions(evalCommand
+    .command("run")
+    .description("Run a suite k times (live, or --mode replay from cassettes) and write report.json, report.md and runs.jsonl; --json prints the run records as JSONL and the report last. Exit 0 when it completed (whatever passed), 1 on a usage or infrastructure error, 2 when a replay diverged from its cassette")
+    .argument("<suite>")).action((suite, _flags, cmd) => runEval(cmd, (api, env, flags) => api.evalRun(env, flags, suite)));
+evalCommand
+    .command("record")
+    .description("Run each task of a suite ONCE live and write <suite>/cassettes/<taskId>.cassette.jsonl for `eval run --mode replay`. Refuses (exit 1) a cassette that holds a secret or is over 256 KB (2 MB per directory)")
+    .argument("<suite>")
+    .option("--tasks <ids>", "Comma-separated task ids (default: every task of the suite)")
+    .option("--seed <n>", "Seed of the run order")
+    .option("--keep", "Keep each run's temporary directory (it prints the paths)")
+    .option("--cassette-dir <dir>", "Write the cassettes here (default: <suite>/cassettes)")
+    .option("--suite-dir <dir>", "A suite, or a directory of suites; third-party code: needs --yes")
+    .option("--allow-suite-full", "Let a suite run tasks that ask for the full permission mode")
+    .option("--yes", "Confirm running a --suite-dir suite without asking (required if not interactive)")
+    .action((suite, _flags, cmd) => runEval(cmd, (api, env, flags) => api.evalRecord(env, flags, suite)));
+evalCommand
+    .command("compare")
+    .description("Compare two reports of the same suite and version; exit 3 when the suites are incompatible")
+    .argument("<reportA>", "Baseline report.json (or the directory that holds it)")
+    .argument("<reportB>", "Candidate report.json (or the directory that holds it)")
+    .option("--md", "Print Markdown (the default; --json prints JSON instead)")
+    .action((a, b, _flags, cmd) => runEval(cmd, (api, env, flags) => api.evalCompare(env, flags, a, b)));
+evalRunOptions(evalCommand
+    .command("variants")
+    .description('Run two or more config variants over the same tasks and seeds and compare them with the first. compare.json: {"suite":"id","variants":[{"id":"baseline","overrides":{}},{"id":"early","overrides":{"compaction.threshold":0.6}}]}')
+    .argument("<suite>")
+    .requiredOption("--variants <file>", "The compare.json file")).action((suite, _flags, cmd) => runEval(cmd, (api, env, flags) => api.evalVariants(env, flags, suite)));
+evalCommand
+    .command("export")
+    .description("Write ONE shareable JSON bundle ({schemaVersion, report, runs, markdown}) of a stored run (<state>/eval/<runId>/) with absolute paths replaced by placeholders and endpoint hosts removed from provider ids. Refuses (exit 1) when a secret is found, naming the field; refuses to overwrite FILE without --force. Local only: nothing is uploaded. Scrubbing is pattern-based, not a guarantee")
+    .argument("<runId>", "Directory name of the run under <state>/eval/")
+    .requiredOption("--out <file>", "The bundle to write")
+    .option("--force", "Overwrite FILE if it exists")
+    .action((runId, _flags, cmd) => runEval(cmd, (api, env, flags) => api.evalExport(env, flags, runId)));
 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 +748,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.2",
+  "version": "0.7.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.2",
-    "@alisio/plugin-memory": "0.5.2",
-    "@alisio/plugin-openai-compatible": "0.5.2",
-    "@alisio/plugin-subagents": "0.5.2",
-    "@alisio/sdk": "0.5.2",
-    "@alisio/server": "0.5.2",
+    "@alisio/core": "0.7.0",
+    "@alisio/plugin-memory": "0.7.0",
+    "@alisio/plugin-openai-compatible": "0.7.0",
+    "@alisio/plugin-subagents": "0.7.0",
+    "@alisio/sdk": "0.7.0",
+    "@alisio/server": "0.7.0",
     "@earendil-works/pi-tui": "0.87.1",
     "commander": "15.0.0"
   },