wizards 0.6.2 → 0.7.1

package/apps/runtime/dist/cli/uninstall.js

@@ -0,0 +1,231 @@
+import { spawnSync } from "node:child_process";
+import { existsSync, lstatSync, readdirSync, readlinkSync, rmdirSync, rmSync } from "node:fs";
+import { homedir } from "node:os";
+import { dirname, join, resolve, sep } from "node:path";
+import * as p from "@clack/prompts";
+import { LOGIN_LABEL, present, removeUnit, UNIT, unloadLoginItem } from "./autostart.js";
+import { apps as allApps } from "./connect.js";
+import { findWizardsProcesses, stopProcesses } from "./processes.js";
+import { settings } from "./start.js";
+import { bad, cyan, dim, no, ok } from "./ui.js";
+export const realSystem = () => ({
+    userHome: homedir(),
+    platform: process.platform,
+    env: process.env,
+    interactive: Boolean(process.stdin.isTTY && process.stdout.isTTY),
+    apps: allApps,
+    processes: findWizardsProcesses,
+    stop: (pids) => stopProcesses(pids),
+    unloadLoginItem,
+    removeUnit,
+});
+/** Parts of the install folder that are the person's: kept or deleted with the data. */
+const WITH_DATA = [".env", ".env.local", "plugins"];
+function loginItemPath(system) {
+    if (system.platform === "darwin") {
+        return join(system.userHome, "Library", "LaunchAgents", `${LOGIN_LABEL}.plist`);
+    }
+    if (system.platform === "linux") {
+        const config = system.env.XDG_CONFIG_HOME || join(system.userHome, ".config");
+        return join(config, "systemd", "user", UNIT);
+    }
+    return null;
+}
+/** The links install.sh put into ~/.local/bin that point into the install. */
+function ourLinks(home, system) {
+    return ["wizards", "engenty-wizards"]
+        .map((name) => join(system.userHome, ".local", "bin", name))
+        .filter((link) => {
+        try {
+            return (lstatSync(link).isSymbolicLink() &&
+                resolve(dirname(link), readlinkSync(link)).startsWith(home + sep));
+        }
+        catch {
+            return false;
+        }
+    });
+}
+/** Works out what an uninstall takes away, without changing anything. */
+export async function makePlan(paths, system) {
+    const apps = [];
+    for (const app of system.apps(paths)) {
+        if (await app.connected().catch(() => false)) {
+            apps.push(app);
+        }
+    }
+    const item = loginItemPath(system);
+    let loginItem = null;
+    try {
+        loginItem = item && present(item) ? item : null;
+    }
+    catch {
+        // Can't look: count it as there, so the uninstall tries and says so.
+        loginItem = item;
+    }
+    const { dataDir } = settings(paths, system.env);
+    const program = [];
+    const data = existsSync(dataDir) ? [dataDir] : [];
+    for (const name of existsSync(paths.home) ? readdirSync(paths.home) : []) {
+        const path = join(paths.home, name);
+        if (path === dataDir) {
+            continue;
+        }
+        const empty = name === "plugins" && readdirSync(path).length === 0;
+        (WITH_DATA.includes(name) && !empty ? data : program).push(path);
+    }
+    return {
+        home: paths.home,
+        apps,
+        loginItem,
+        processes: system.processes(paths.home),
+        program,
+        links: ourLinks(paths.home, system),
+        data,
+    };
+}
+/** Size of a folder as `du` counts it, e.g. " (805 MB)"; "" where it can't tell. */
+function size(path) {
+    const kb = Number(spawnSync("du", ["-sk", path], { encoding: "utf8" }).stdout?.split(/\s/)[0]);
+    return kb > 0 ? ` (${kb < 1024 ? `${kb} KB` : `${Math.round(kb / 1024)} MB`})` : "";
+}
+const processes = (n) => `${n} running process${n === 1 ? "" : "es"}`;
+/** `wizards uninstall [--dry-run] [--yes] [--delete-data]`. */
+export async function uninstall(paths, options, system = realSystem()) {
+    const t = (path) => path.startsWith(system.userHome + sep) ? `~${path.slice(system.userHome.length)}` : path;
+    if (!options.dryRun && !options.yes && !system.interactive) {
+        console.error("The uninstall asks before it deletes anything, and there is no terminal to ask in.\n" +
+            "Run it with --yes (your data is kept), --yes --delete-data, or --dry-run to only look.");
+        return 2;
+    }
+    const plan = await makePlan(paths, system);
+    const steps = [
+        ...plan.apps.map((app) => `Disconnect ${app.name}`),
+        ...(plan.loginItem ? [`Remove the login item ${t(plan.loginItem)}`] : []),
+        ...(plan.processes.length ? [`Stop ${processes(plan.processes.length)}`] : []),
+        ...(plan.program.length ? [`Delete the program in ${t(plan.home)}${size(plan.home)}`] : []),
+        ...plan.links.map((link) => `Delete the command ${t(link)}`),
+    ];
+    if (!steps.length && !plan.data.length) {
+        console.log(`${ok} engenty wizards isn’t installed here.`);
+        return 0;
+    }
+    if (steps.length) {
+        console.log("\nThis removes engenty wizards:");
+    }
+    for (const step of steps) {
+        console.log(`  ${no} ${step}`);
+    }
+    if (plan.data.length) {
+        console.log(`\nYour data: ${plan.data.map((path) => t(path) + size(path)).join(", ")}`);
+        console.log(dim("  Kept unless you choose to delete it. A reinstall picks it up again."));
+    }
+    console.log("");
+    if (options.dryRun) {
+        console.log(dim("Nothing was changed (--dry-run)."));
+        return 0;
+    }
+    let deleteData = options.yes && options.deleteData;
+    if (!options.yes) {
+        if (plan.data.length) {
+            const answer = await p.confirm({
+                message: "Delete your data too? Your wizards, runs and results are gone for good.",
+                initialValue: false,
+            });
+            if (p.isCancel(answer)) {
+                return 130;
+            }
+            deleteData = answer;
+        }
+        const go = await p.confirm({
+            message: deleteData ? "Uninstall and delete your data now?" : "Uninstall now?",
+        });
+        if (p.isCancel(go) || !go) {
+            p.cancel("Nothing was changed.");
+            return 130;
+        }
+    }
+    const failed = (what, error) => console.log(`${bad} ${what}: ${error.message.split("\n")[0]}`);
+    for (const app of plan.apps) {
+        const result = await app
+            .disconnect()
+            .catch((error) => ({ ok: false, message: error.message }));
+        console.log(result.ok ? `${ok} Disconnected ${app.name}` : `${bad} ${app.name}: ${result.message}`);
+    }
+    if (plan.loginItem) {
+        try {
+            if (system.platform === "darwin") {
+                await system.unloadLoginItem();
+                rmSync(plan.loginItem, { force: true });
+            }
+            else {
+                await system.removeUnit(plan.loginItem);
+            }
+            console.log(`${ok} Removed the login item`);
+        }
+        catch (error) {
+            failed("The login item", error);
+        }
+    }
+    // Twice: an AI app's `wizards mcp` may start the studio again meanwhile.
+    for (let round = 0; round < 2; round++) {
+        const running = system.processes(paths.home);
+        if (running.length && !(await system.stop(running.map((proc) => proc.pid))).length) {
+            console.log(`${ok} Stopped ${processes(running.length)}`);
+        }
+    }
+    for (const path of [...plan.program, ...plan.links, ...(deleteData ? plan.data : [])]) {
+        try {
+            rmSync(path, { recursive: true, force: true });
+        }
+        catch (error) {
+            failed(`Couldn’t delete ${t(path)}`, error);
+        }
+    }
+    for (const dir of [plan.home, join(system.userHome, ".engenty")]) {
+        try {
+            rmdirSync(dir);
+        }
+        catch {
+            // not empty, or not there
+        }
+    }
+    // A second look: what is still there.
+    const after = await makePlan(paths, system);
+    const left = [
+        ...after.apps.map((app) => `${app.name} still lists the wizards: ${cyan(`npx wizards disconnect ${app.id}`)}`),
+        ...(after.loginItem ? [t(after.loginItem)] : []),
+        ...after.processes.map((proc) => `process ${proc.pid}: ${cyan(`kill -9 ${proc.pid}`)}`),
+        ...[...after.program, ...after.links, ...(deleteData ? after.data : [])].map(t),
+    ];
+    if (!deleteData && after.data.length) {
+        console.log(`${ok} Kept your data: ${after.data.map(t).join(", ")}`);
+    }
+    if (left.length) {
+        console.log(`\n${bad} Still there:`);
+        for (const line of left) {
+            console.log(`  ${line}`);
+        }
+        return 1;
+    }
+    console.log(`\n${ok} engenty wizards is uninstalled.\n`);
+    return 0;
+}
+/** The options of `uninstall` from its command line; a message when something is off. */
+export function parseUninstall(argv) {
+    const options = { dryRun: false, yes: false, deleteData: false };
+    for (const arg of argv) {
+        if (arg === "--dry-run") {
+            options.dryRun = true;
+        }
+        else if (arg === "--yes" || arg === "-y") {
+            options.yes = true;
+        }
+        else if (arg === "--delete-data") {
+            options.deleteData = true;
+        }
+        else if (arg !== "uninstall") {
+            return `Unknown option ${arg}. The uninstall takes --dry-run, --yes and --delete-data.`;
+        }
+    }
+    return options;
+}

package/apps/runtime/dist/cli/update.js

@@ -1,10 +1,12 @@
 import { spawn } from "node:child_process";
 import { mkdtempSync, rmSync, writeFileSync } from "node:fs";
 import { join } from "node:path";
-import { installedByScript, isCheckout } from "./home.js";
+import { autoUpdatePolicy, noteUpdated } from "./autoupdate.js";
+import { installedByScript, isCheckout, readInstallNote, writeInstallNote, } from "./home.js";
 import { runningRuntime, settings } from "./start.js";
 import { restart } from "./status.js";
-import { cmd, cyan } from "./ui.js";
+import { cmd, cyan, no, ok } from "./ui.js";
+import { currentVersion } from "./versions.js";
 /** The installer this install was made with; it also updates one. */
 const INSTALLER = "https://engenty.ai/install.sh";
 async function installer(into) {
@@ -34,6 +36,7 @@ export async function update(paths, options = {}) {
             : `This copy runs from npm. To update: ${cyan("npx wizards@latest")}`);
         return 0;
     }
+    const before = currentVersion(paths);
     const tmp = mkdtempSync(join(paths.home, "update-"));
     try {
         const script = await installer(tmp);
@@ -53,6 +56,10 @@ export async function update(paths, options = {}) {
     finally {
         rmSync(tmp, { recursive: true, force: true });
     }
+    const after = currentVersion(paths);
+    if (before && after) {
+        noteUpdated(paths, before, after);
+    }
     if (await runningRuntime(settings(paths).dataDir)) {
         if (options.restart) {
             return restart(paths);
@@ -61,3 +68,19 @@ export async function update(paths, options = {}) {
     }
     return 0;
 }
+/** `wizards autoupdate [on|off]`: whether updates come by themselves (autoupdate.ts). */
+export function autoUpdateCommand(paths, value) {
+    if (value && value !== "on" && value !== "off") {
+        console.error(`Use ${cmd("autoupdate on")} or ${cmd("autoupdate off")}.`);
+        return 2;
+    }
+    const installed = installedByScript(paths);
+    if (value && installed) {
+        writeInstallNote({ ...readInstallNote(paths), autoUpdate: value === "on" }, paths);
+    }
+    const policy = autoUpdatePolicy(paths, { installed });
+    console.log(policy.on
+        ? `${ok} Updates come by themselves: downloaded in the background, used from the next start.`
+        : `${no} Updates don’t come by themselves: ${policy.reason}. To update now: ${cmd("update")}`);
+    return value && !installed ? 1 : 0;
+}

package/apps/runtime/dist/cli/versions.js

@@ -0,0 +1,106 @@
+import { existsSync, lstatSync, mkdirSync, readdirSync, readFileSync, readlinkSync, renameSync, rmSync, symlinkSync, } from "node:fs";
+import { join } from "node:path";
+/**
+ * The runtimes of an install made by install.sh, one folder per version, side by side:
+ *
+ *   runtime/<version>/     an npm prefix: node_modules/wizards, package.json, package-lock.json
+ *   runtime/current        → <version>, the one `bin/wizards` starts
+ *   runtime/node_modules   → current/node_modules, for commands written before the versions
+ *
+ * Up to 0.6.2 `runtime/` itself was the prefix; `switchTo` moves such an install into its
+ * version folder first. A process keeps the files of the version it started with.
+ */
+const VERSION = /^\d+\.\d+\.\d+$/;
+export const runtimeDir = (paths, version) => join(paths.runtime, version);
+const currentLink = (paths) => join(paths.runtime, "current");
+const modules = (paths) => join(paths.runtime, "node_modules");
+/** The version of the package `wizards` in an npm prefix; null when there is none. */
+export function versionIn(prefix) {
+    try {
+        const file = join(prefix, "node_modules", "wizards", "package.json");
+        const { version } = JSON.parse(readFileSync(file, "utf8"));
+        return typeof version === "string" ? version : null;
+    }
+    catch {
+        return null;
+    }
+}
+const isLink = (path) => {
+    try {
+        return lstatSync(path).isSymbolicLink();
+    }
+    catch {
+        return false;
+    }
+};
+/** The version `bin/wizards` starts; null without a runtime. */
+export function currentVersion(paths) {
+    if (isLink(currentLink(paths))) {
+        return versionIn(join(paths.runtime, readlinkSync(currentLink(paths))));
+    }
+    return versionIn(paths.runtime);
+}
+/** The version folders there are, each with a complete package in it. */
+export function installedVersions(paths) {
+    try {
+        return readdirSync(paths.runtime)
+            .filter((name) => VERSION.test(name) && versionIn(join(paths.runtime, name)) === name)
+            .sort();
+    }
+    catch {
+        return [];
+    }
+}
+/** Points `link` at `target` in one step: a new link renamed over the old one. */
+function link(target, path) {
+    const tmp = `${path}.${process.pid}.tmp`;
+    rmSync(tmp, { force: true });
+    symlinkSync(target, tmp);
+    renameSync(tmp, path);
+}
+/** Moves a runtime from before the version folders into `runtime/<version>/`. */
+function adoptLegacy(paths) {
+    const version = versionIn(paths.runtime);
+    if (isLink(modules(paths)) || !version) {
+        return;
+    }
+    const into = runtimeDir(paths, version);
+    rmSync(into, { recursive: true, force: true });
+    mkdirSync(into, { recursive: true });
+    for (const name of ["node_modules", "package.json", "package-lock.json"]) {
+        if (existsSync(join(paths.runtime, name))) {
+            renameSync(join(paths.runtime, name), join(into, name));
+        }
+    }
+    link(version, currentLink(paths));
+}
+/** Makes `version` the one `bin/wizards` starts from now on. */
+export function switchTo(paths, version) {
+    if (versionIn(runtimeDir(paths, version)) !== version) {
+        throw new Error(`${runtimeDir(paths, version)} holds no complete runtime ${version}.`);
+    }
+    adoptLegacy(paths);
+    link(version, currentLink(paths));
+    link(join("current", "node_modules"), modules(paths));
+}
+/** Deletes the version folders other than `keep` and the current one; returns what went. */
+export function prune(paths, keep) {
+    const current = currentVersion(paths);
+    const stale = installedVersions(paths).filter((v) => v !== current && !keep.includes(v));
+    for (const version of stale) {
+        rmSync(runtimeDir(paths, version), { recursive: true, force: true });
+    }
+    return stale;
+}
+/** Puts an npm prefix installed elsewhere into its version folder (never the current one). */
+export function promote(paths, staged, version) {
+    if (versionIn(staged) !== version) {
+        throw new Error(`The download holds version ${versionIn(staged) ?? "none"}, not ${version}.`);
+    }
+    if (currentVersion(paths) === version) {
+        rmSync(staged, { recursive: true, force: true });
+        return;
+    }
+    rmSync(runtimeDir(paths, version), { recursive: true, force: true });
+    renameSync(staged, runtimeDir(paths, version));
+}

package/apps/runtime/dist/docs/user/command-line.md

@@ -8,7 +8,7 @@ version: 0.5.0
 
 | Command | What it does |
 |---|---|
-| `wizards` | Shows what is running, and a menu. While it runs, you can open the studio, restart or stop it; while it doesn’t, “Start in the background” or “Start here” (in this terminal). Then “Update”, which restarts it into the new version, “Start at login”, “Connect AI apps”, “Account”, “Status”, “Setup” and “Help”. The first time, the setup runs first. It needs a terminal |
+| `wizards` | Shows what is running, and a menu. While it runs, you can open the studio, restart or stop it; while it doesn’t, “Start in the background” or “Start in this terminal”. Then “Update”, which restarts it into the new version, “Start at login”, “Connect AI apps”, “Account”, “Status”, “Setup”, “Uninstall” and “Help”. The first time, the setup runs first. It needs a terminal |
 | `wizards start` | Starts it and opens the studio. It runs in that terminal, and Ctrl-C stops it. The first time, the setup runs first |
 | `wizards studio` | Opens the studio in your browser. If it isn’t running, it starts in the background first |
 | `wizards setup` | Runs the guided setup again: your account, an AI client, the browser and ffmpeg, start at login, your AI apps. `--local` leaves the account out ([Local only](./local-only.md)) |
@@ -18,13 +18,14 @@ version: 0.5.0
 | `wizards doctor` | Shows the status and checks for problems |
 | `wizards logs [n]` | Prints the last lines engenty wizards printed while running (100, or `n` up to 2000). Keys and tokens are taken out |
 | `wizards report` | Sends the status, the model settings (never a key) and the last 500 log lines to your [account](./models.md#account), so support can see what went wrong. Nothing is sent unless you run it. The command names the report’s ID. If this computer isn’t signed in, it tells you to sign in under Settings → Account or with `wizards account sign-in` |
-| `wizards stop` | Stops it. Your data is kept |
+| `wizards stop` | Stops it, with any other copy of it still running in the background. Your data is kept. AI apps that use your wizards start it again when you use one there |
 | `wizards restart` | Stops it and starts it again; after an update, that is the new version. If it isn’t running, it starts in the background |
 | `wizards update` | Installs the latest version |
 | `wizards autostart on` / `off` | Starts it when you log in, or stops doing so. It is a LaunchAgent on macOS and a systemd user service on Linux |
 | `wizards connect [app …]` | Adds your wizards to your [AI apps](./ai-apps.md): every app found, or the ones you name |
 | `wizards disconnect [app …]` | Takes them out again |
 | `wizards mcp` | Runs the MCP server over stdio. AI apps start it; you don’t |
+| `wizards uninstall` | Takes engenty wizards off this computer. It shows what it will remove first and asks about your data on its own; your data is kept unless you choose to delete it. `--dry-run` only shows the plan, `--yes` asks nothing and keeps your data, `--yes --delete-data` deletes it too. See [Remove](./install.md#remove) |
 | `wizards validate <path …>` | Checks wizards without the studio: `.wizard` files, unpacked wizard files, or a wizard’s JSON. `--json` prints the problems as JSON. A space’s connectors and plugins are checked when you import it |
 
 | Option | What it does |

package/apps/runtime/dist/docs/user/data.md

@@ -27,7 +27,7 @@ Keychain (as `engenty-wizards`). On other systems they are stored encrypted in t
 |---|---|
 | Back up | Stop engenty wizards (`wizards stop`) and copy the folder |
 | Move to another computer | Install engenty wizards there, stop it and put the folder in place. On a Mac, enter your API keys and sign in to your account again: the Keychain doesn’t move |
-| Start over | Delete the folder. On a Mac, the keys in the Keychain stay and are used again. To remove them, delete the `engenty-wizards` entries in Keychain Access |
+| Start over | Run `wizards uninstall`, choose to delete your data, then install again. On a Mac, the keys in the Keychain stay and are used again. To remove them, delete the `engenty-wizards` entries in Keychain Access |
 | Keep it elsewhere | Set `ENGENTY_HOME` to another folder. engenty wizards then keeps everything in its `wizards` folder there |
 
 After an update, engenty wizards brings your data up to date the next time it starts.

package/apps/runtime/dist/docs/user/install.md

@@ -71,6 +71,19 @@ the right of the address bar.
 
 ## Update
 
+engenty wizards updates itself: it looks for a new version when it starts and once a day,
+downloads it in the background and checks it, and switches to it at the next start (a restart or
+the next login), never while a wizard runs. The version before stays beside it. `wizards status`
+and the studio then say “Updated to …” with what changed. To turn it off:
+
+```bash
+wizards autoupdate off
+```
+
+or set `WIZARDS_DISABLE_AUTOUPDATE=1` (in the terminal or in `~/.engenty/wizards/.env`). In CI,
+and for an install set up without a terminal, it is off unless you turn it on with `wizards
+autoupdate on`. `npx wizards` never updates itself. To update now:
+
 ```bash
 wizards update
 ```
@@ -88,11 +101,21 @@ brought up to date at the next start.
 ## Remove
 
 ```bash
-wizards stop
-wizards autostart off
-wizards disconnect
+wizards uninstall
 ```
 
-`wizards disconnect` takes your wizards out of your AI apps again. Then delete `~/.engenty/wizards`
-and `~/.local/bin/wizards`. Your wizards and results are in `~/.engenty/wizards/data`:
-[back that folder up](./data.md) first if you want to keep them.
+First it shows what it will remove: your wizards in your AI apps, starting at login, everything of
+engenty wizards that is running, the program in `~/.engenty/wizards` and the command
+`~/.local/bin/wizards`. Your data in `~/.engenty/wizards/data` is kept unless you say to delete
+it, and installing again picks it up. [Back it up](./data.md) first if you delete it. At the end
+it lists anything it couldn’t remove.
+
+If the `wizards` command no longer runs, `npx wizards uninstall` does the same.
+
+| Option | What it does |
+|---|---|
+| `--dry-run` | Only shows what it would remove |
+| `--yes` | Removes everything without asking and keeps your data |
+| `--yes --delete-data` | Deletes your data as well |
+
+Without a terminal, it asks for `--yes`.

package/apps/runtime/dist/engine/input.js

@@ -1,4 +1,5 @@
 import { isDecidedField, isLang, isLocationValue, MAX_FILES, offeredSlot, shownFields, } from "@engenty-wizards/shared/definition";
+import { readNumber } from "@engenty-wizards/shared/numbers";
 import { note, saidText } from "@engenty-wizards/shared/run";
 /** The field errors in a language, for whoever reads them. */
 export function fieldErrorsIn(errors, lang) {
@@ -13,11 +14,10 @@ function coerce(field, raw) {
     }
     switch (field.kind) {
         case "number": {
-            if (raw === "") {
+            if (String(raw).trim() === "") {
                 return undefined;
             }
-            const n = Number(String(raw).replace(",", "."));
-            return Number.isFinite(n) ? n : Number.NaN;
+            return readNumber(raw) ?? Number.NaN;
         }
         case "toggle":
             return raw === true || raw === "true" || raw === "on";
@@ -62,8 +62,7 @@ function coerce(field, raw) {
                 if (c.kind === "text") {
                     return [c.id, String(v ?? "").slice(0, 2000)];
                 }
-                const n = Number(String(v ?? "").replace(",", "."));
-                return [c.id, Number.isFinite(n) ? n : 0];
+                return [c.id, readNumber(v) ?? 0];
             })))
                 .filter((r) => Object.values(r).some((v) => v !== "" && v !== 0))
                 .slice(0, 200);

package/apps/runtime/dist/engine/steps.js

@@ -11,7 +11,7 @@ import { snapshotHtmlImages } from "../files/web-images.js";
 import { runFilmStep } from "../film/step.js";
 import { generateImageMedia, generateSpeechMedia, generateVideoMedia, } from "../media/generate.js";
 import { markMedia } from "../media/marking.js";
-import { attachTools, costOf, isHarnessVendor, textModel } from "../models.js";
+import { agentModel, attachTools, costOf, isHarnessVendor, textModel, totalUsage, } from "../models.js";
 import { knowledgeBlock } from "../services/knowledge.js";
 import { buildStepTools } from "../tools/index.js";
 import { callPluginTool, spaceContextOf } from "../tools/plugin.js";
@@ -536,7 +536,7 @@ export async function runAgentStep(step, ctx) {
             id: `step-${step.id}`,
             name: step.title,
             instructions: system,
-            model: resolved.model,
+            model: agentModel(resolved),
             tools,
         });
         // Working through a mailbox or a row of portals takes many small tool calls.
@@ -564,7 +564,7 @@ export async function runAgentStep(step, ctx) {
         const result = step.output.format === "json"
             ? await streamWithProgress(agent, message, { maxSteps, abortSignal: ctx.signal }, step, ctx)
             : await agent.generate(message, { maxSteps, abortSignal: ctx.signal });
-        await ctx.chargeUsd(costOf(resolved, result.totalUsage ?? result.usage));
+        await ctx.chargeUsd(costOf(resolved, await totalUsage(result)));
         // `result.text` strings together what the model said between tool calls ("I open the page …").
         // A written result is its last message; structuring keeps everything, numbers may sit anywhere.
         const closing = String(result.steps?.at?.(-1)?.text ?? "").trim();

package/apps/runtime/dist/engine/template.js

@@ -1,15 +1,8 @@
 import { allFields, isAudioValue, isLocationValue, itemsTotals, localeOf, locationText, wizardLang, } from "@engenty-wizards/shared/definition";
+import { formatMoney } from "@engenty-wizards/shared/numbers";
 import { fontLicenseWords, gradientCss, textStyleLine, } from "@engenty-wizards/shared/projects";
 import { listAsMarkdown } from "@engenty-wizards/shared/store";
 const TEMPLATE_RE = /\{\{\s*([^}]+?)\s*\}\}/g;
-function money(n, currency, locale) {
-    try {
-        return new Intl.NumberFormat(locale, { style: "currency", currency }).format(n);
-    }
-    catch {
-        return `${n.toFixed(2)} ${currency}`;
-    }
-}
 /** Line items as a Markdown table with their totals — what a model needs to write a document. */
 export function itemsAsMarkdown(field, value, values, lang = "en") {
     const locale = localeOf(lang);
@@ -21,13 +14,15 @@ export function itemsAsMarkdown(field, value, values, lang = "en") {
     const head = `| ${cols.map((c) => c.label).join(" | ")} | Amount |\n|${cols.map(() => " --- ").join("|")}| ---: |`;
     const body = totals.rows.map((r) => `| ${cols
         .map((c) => c.kind === "money"
-        ? money(Number(r[c.id]) || 0, totals.currency, locale)
+        ? formatMoney(Number(r[c.id]) || 0, totals.currency, locale)
         : String(r[c.id] ?? ""))
-        .join(" | ")} | ${money(r.amount, totals.currency, locale)} |`);
+        .join(" | ")} | ${formatMoney(r.amount, totals.currency, locale)} |`);
     const sums = [
-        `Net: ${money(totals.net, totals.currency, locale)}`,
-        totals.vatRate ? `VAT ${totals.vatRate}%: ${money(totals.vat, totals.currency, locale)}` : null,
-        `Total: ${money(totals.gross, totals.currency, locale)}`,
+        `Net: ${formatMoney(totals.net, totals.currency, locale)}`,
+        totals.vatRate
+            ? `VAT ${totals.vatRate}%: ${formatMoney(totals.vat, totals.currency, locale)}`
+            : null,
+        `Total: ${formatMoney(totals.gross, totals.currency, locale)}`,
     ].filter(Boolean);
     return [head, ...body, "", ...sums].join("\n");
 }

package/apps/runtime/dist/env.js

@@ -23,8 +23,7 @@ function loadEnvFiles() {
 loadEnvFiles();
 const str = (key, fallback = "") => process.env[key]?.trim() || fallback;
 /**
- * Without `SANDBOX`: Docker when the sandbox image is on this machine, else agentOS when its
- * packages are installed (a checkout has them, the image and the desktop app do not), else none.
+ * Without `SANDBOX`: Docker when the sandbox image is on this machine, else none.
  * The image is not published, so a fresh install would otherwise offer a tool that cannot start.
  */
 function sandboxEngine(image) {
@@ -33,12 +32,9 @@ function sandboxEngine(image) {
         return "off";
     }
     if (engine) {
-        return engine === "agentos" ? "agentos" : "docker";
-    }
-    if (dockerHasImage(image)) {
         return "docker";
     }
-    return agentOsInstalled() ? "agentos" : "off";
+    return dockerHasImage(image) ? "docker" : "off";
 }
 function dockerHasImage(image) {
     try {
@@ -49,19 +45,6 @@ function dockerHasImage(image) {
         return false;
     }
 }
-/** agentOS ships its sidecar for macOS and Linux on arm64 and x64 only. */
-function agentOsInstalled() {
-    if (!["darwin", "linux"].includes(process.platform) || !["arm64", "x64"].includes(process.arch)) {
-        return false;
-    }
-    try {
-        import.meta.resolve("@rivet-dev/agentos-core");
-        return true;
-    }
-    catch {
-        return false;
-    }
-}
 /** A comma-separated list. */
 const list = (key) => str(key)
     .split(",")
@@ -234,7 +217,7 @@ export const env = {
             : "/usr/bin/chromium")),
     /** Encodes widget animations to MP4; without it widgets offer no video. */
     ffmpegPath: str("FFMPEG_PATH", "ffmpeg"),
-    /** What runs an agent's shell and code: a Docker container, an agentOS VM, or nothing. */
+    /** What runs an agent's shell and code: a Docker container or nothing. */
     sandbox: sandboxEngine(sandboxImage),
     sandboxImage,
     /** Assets and workspace files in an S3-compatible bucket (R2); empty = the data folder. */

package/apps/runtime/dist/features.js

@@ -1,6 +1,6 @@
 import { mkdirSync, readFileSync, statSync, writeFileSync } from "node:fs";
 import { dirname, join } from "node:path";
-import { declaredByPlugin, defaultFeatures, FEATURES, parseFeatures, resolveFeatures, } from "@engenty-wizards/shared/features";
+import { declaredByPlugin, defaultFeatures, FEATURES, featureOn, parseFeatures, resolveFeatures, } from "@engenty-wizards/shared/features";
 import { accountOverview } from "./auth/account.js";
 import { isCheckout, layout, packageRoot } from "./cli/home.js";
 import { env } from "./env.js";
@@ -61,7 +61,7 @@ export function features(remote) {
     return resolveFeatures(defaultFeatures(declaredFeatures()), envFeatures(), remote, fileFeatures());
 }
 export function feature(name, remote) {
-    return features(remote)[name] === true;
+    return featureOn(features(remote), name);
 }
 let accountCache = null;
 /**

package/apps/runtime/dist/index.js

@@ -17,7 +17,7 @@ import { purgeExpiredRuns } from "./services/shares.js";
 import { purgeUnusedStores } from "./store/index.js";
 import { forgetRunner, registerRunner } from "./tenants/control.js";
 import { LOCAL_TENANT } from "./tenants/tenant.js";
-import { onRestart, RESTART_EXIT } from "./update.js";
+import { onRestart, RESTART_EXIT, startUpdateChecks } from "./update.js";
 // Before anything prints: the last lines stay in memory for a look from afar (debug.ts).
 hookConsole();
 await migrateControlDb();
@@ -39,6 +39,8 @@ else {
     void loadCatalog();
     void checkModelsAtStart().catch(() => undefined);
     startProChecks();
+    // A newer release is downloaded beside this one and used from the next start.
+    startUpdateChecks();
 }
 // The marketplace's starters and the starred entries, kept for offline use; checked hourly.
 void syncMarketplace();