@engenty/wizards-runtime 0.7.6 → 0.7.8

package/apps/runtime/dist/film/project.js

@@ -1,6 +1,6 @@
 import { createHash } from "node:crypto";
 import { existsSync } from "node:fs";
-import { cp, mkdir, readFile, rm, writeFile } from "node:fs/promises";
+import { cp, mkdir, readdir, readFile, rm, writeFile } from "node:fs/promises";
 import { dirname, join, normalize } from "node:path";
 import { dataRef, FILM_SIZES } from "@engenty-wizards/shared/definition";
 import { gradientCss, ruleLines, textStyleLine } from "@engenty-wizards/shared/projects";
@@ -52,21 +52,43 @@ async function put(root, rel, data) {
     await writeFile(path, data);
 }
 const safeName = (name) => name.replace(/[^A-Za-z0-9._-]+/g, "-").replace(/^-+|-+$/g, "") || "file";
-function rules(step, skills) {
+/** Where the client starts, by how film/ began. */
+function startRules(start) {
+    if (start === "base") {
+        return `- **What to make:** BRIEF.md. **Start here:** film/ is already the wizard's base project in this
+  format — read film/PARTS.md first: its scene templates carry the look. Compose the film from them in
+  the one file PARTS.md names, timed to the voice; write a new scene only where no template fits, then
+  in the style of showcase/ (SHOWCASE.md says how each technique is made).
+- **The brand:** film/brand/ holds brand.json and the logos. If film/brand/theme.json is missing, make
+  it first as film/BRAND.md says — it is kept for the next films of this space, so get it right.
+  Colours, logo and fonts come from there only.
+`;
+    }
+    if (start === "from") {
+        return `- **What to make:** BRIEF.md. **Start here:** film/ holds a finished film of this run in another
+  format. Lay it out for this one: scenes, timing, words and sound stay; only the layout changes
+  (film/PARTS.md says how when it exists). The look is showcase/'s.
+- **The brand:** film/brand/ when it is there, else brand/brand.json and brand/logos/ — colours, logo
+  and fonts come from there only.
+`;
+    }
+    return `- **What to make:** BRIEF.md. **The bar:** showcase/ (read showcase/SHOWCASE.md and showcase/frame.md
+  first when it exists, look at its stills, reuse its helpers from showcase/assets/). **The brand:**
+  brand/brand.json and brand/logos/ — colours, logo and fonts come from there only.
+`;
+}
+function rules(step, skills, start) {
     const size = FILM_SIZES[step.format];
     return `# The film folder
 
 You make one film here, autonomously, to the end. Nobody answers questions: where a skill asks the
 person, decide yourself and note it in PROGRESS.md.
 
-- **What to make:** BRIEF.md. **The bar:** showcase/ (read showcase/SHOWCASE.md and showcase/frame.md
-  first when it exists, look at its stills, reuse its helpers from showcase/assets/). **The brand:**
-  brand/brand.json and brand/logos/ — colours, logo and fonts come from there only.
-- **Material:** input/ (see input/README.md). Use nothing from the web; you have no network.
+${startRules(start)}- **Material:** input/ (see input/README.md). Use nothing from the web; you have no network.
 - **Skills:** ${skills.join(", ")} in .claude/skills/<name>/SKILL.md. Start with \`hyperframes\` and
   read the skill files directly; do not update or install skills.
-- **The HyperFrames project is film/** (${size.width}×${size.height}, already set up). Keep every file
-  of the film inside film/.
+- **The HyperFrames project is film/** (${size.width}×${size.height}). Keep every file of the film
+  inside film/.
 - **Running HyperFrames:** only through the \`hyperframes\` tool (MCP server \`film\`), e.g.
   \`["lint","film"]\`, \`["check","film"]\`, \`["snapshot","film","--at","1,4,8"]\`,
   \`["render","film","-q","draft"]\`, \`["transcribe","input/voice/l01.wav","--json","-d","input/voice"]\`.
@@ -86,57 +108,25 @@ person, decide yourself and note it in PROGRESS.md.
 - Install nothing (no pip, brew, npm).
 `;
 }
-/** Sets up the folder for a first attempt; a later attempt finds it as it was left. */
-export async function prepareFilmFolder(step, ctx) {
-    const root = filmRoot(ctx.runId, step.id);
-    const brief = renderTemplate(step.brief, ctx.scope).trim();
-    // The same brief and material as last time: the film is there to go on with or to change.
-    const stamp = createHash("sha256")
-        .update(JSON.stringify([
-        brief,
-        Object.values(step.inputs).map((raw) => {
-            const ref = dataRef(raw);
-            const [head, id] = ref.split(".");
-            return head === "steps" ? ctx.state.outputs[id]?.at : ctx.state.values[ref];
-        }),
-    ]))
-        .digest("hex");
-    const stampFile = join(root, ".engenty", "inputs");
-    const same = existsSync(stampFile) && (await readFile(stampFile, "utf8")) === stamp;
-    if (same && existsSync(join(root, "film", "index.html")) && (await savedSession(root))) {
-        return { root, brief };
-    }
-    await rm(root, { recursive: true, force: true });
-    await mkdir(root, { recursive: true });
-    const skills = await placeSkills(step.skills, ctx.files, join(root, ".claude", "skills"));
-    const size = FILM_SIZES[step.format];
-    await put(root, "BRIEF.md", `# Brief\n\nFormat ${step.format}, ${size.width}×${size.height}${step.seconds ? `, about ${step.seconds} s` : ""}. Language of all text on screen: the brief's language.\n\n${brief}\n`);
-    const text = rules(step, skills);
-    await put(root, "CLAUDE.md", text);
-    await put(root, "AGENTS.md", text);
-    // The style kit.
-    if (step.kit) {
-        const file = ctx.files.find((f) => f.path === step.kit);
-        if (file) {
-            const entries = unzipSync(new Uint8Array(await getBlob(file.hash)));
-            for (const [name, data] of Object.entries(entries)) {
-                if (!name.endsWith("/")) {
-                    await put(join(root, "showcase"), name.replace(/^showcase\//, ""), data);
-                }
-            }
-        }
-    }
-    // The space's brand.
+const BRAND_STAMP = join(".engenty", "brand");
+/**
+ * Writes the space's brand into brand/ as it is now (brand.json, logos). True when it differs
+ * from what the folder had before — the film's code then still carries the old one.
+ */
+async function writeBrand(root, ctx) {
     const b = ctx.scope.brand;
-    const logos = [];
+    const hash = createHash("sha256");
+    const files = [];
+    const fileName = (dir, f) => `${dir}/${safeName(f.name.replace(/\.[^.]+$/, ""))}.${extFor(f.mime) === "bin" ? (f.name.split(".").pop() ?? "bin") : extFor(f.mime)}`;
     const patterns = [];
     for (const p of b.patterns ?? []) {
         const f = ctx.projectFiles.find((x) => x.id === p.file);
         try {
             if (f) {
                 const { data } = await projectFileContent(f.projectId, f.id);
-                const name = `patterns/${safeName(f.name.replace(/\.[^.]+$/, ""))}.${extFor(f.mime) === "bin" ? (f.name.split(".").pop() ?? "bin") : extFor(f.mime)}`;
-                await put(join(root, "brand"), name, data);
+                const name = fileName("patterns", f);
+                files.push({ name, data });
+                hash.update(name).update(data);
                 patterns.push({
                     file: name,
                     name: p.name,
@@ -149,11 +139,13 @@ export async function prepareFilmFolder(step, ctx) {
             // a pattern less
         }
     }
+    const logos = [];
     for (const f of ctx.projectFiles.filter((p) => p.kind === "logo")) {
         try {
             const { data } = await projectFileContent(f.projectId, f.id);
-            const name = `logos/${safeName(f.name.replace(/\.[^.]+$/, ""))}.${extFor(f.mime) === "bin" ? (f.name.split(".").pop() ?? "bin") : extFor(f.mime)}`;
-            await put(join(root, "brand"), name, data);
+            const name = fileName("logos", f);
+            files.push({ name, data });
+            hash.update(name).update(data);
             const section = logoSectionLine(b.logoSections, f.id);
             logos.push({
                 file: name,
@@ -165,7 +157,7 @@ export async function prepareFilmFolder(step, ctx) {
             // a logo less
         }
     }
-    await put(join(root, "brand"), "brand.json", JSON.stringify({
+    const json = JSON.stringify({
         note: "The space's brand. Colours are named by what they are for; the first is the accent. A logo's section, a gradient's or a pattern's description says when to use it; colorRules, logoRules and typeRules, where there are any, say how colours, logos and type may be used; text is set in the fonts — a font with `uses` that leave out video is not used in a film: its text gets a system font.",
         name: b.name ?? "",
         about: b.about ?? "",
@@ -199,16 +191,149 @@ export async function prepareFilmFolder(step, ctx) {
             : {}),
         ...(b.textStyles?.length
             ? {
-                textStyles: b.textStyles.map((s) => ({
-                    name: s.name,
-                    style: textStyleLine(s, b.fonts ?? []),
+                textStyles: b.textStyles.map((t) => ({
+                    name: t.name,
+                    style: textStyleLine(t, b.fonts ?? []),
                 })),
             }
             : {}),
         ...(b.typeRules?.length ? { typeRules: ruleLines(b.typeRules).split("\n") } : {}),
         ...(b.logoRules?.length ? { logoRules: ruleLines(b.logoRules).split("\n") } : {}),
         facts: (b.facts ?? []).map((f) => `${f.label}: ${f.value}`),
-    }, null, 1));
+    }, null, 1);
+    const stamp = hash.update(json).digest("hex");
+    let changed = false;
+    try {
+        changed = (await readFile(join(root, BRAND_STAMP), "utf8")) !== stamp;
+    }
+    catch {
+        // A folder from before the stamp: its brand.json tells; a new folder has none.
+        const old = await readFile(join(root, "brand", "brand.json"), "utf8").catch(() => null);
+        changed = old !== null && old !== json;
+    }
+    await rm(join(root, "brand"), { recursive: true, force: true });
+    for (const f of files) {
+        await put(join(root, "brand"), f.name, f.data);
+    }
+    await put(join(root, "brand"), "brand.json", json);
+    await put(root, BRAND_STAMP, stamp);
+    return { changed, stamp };
+}
+const START = join(".engenty", "start");
+const BASE = join(".engenty", "base");
+/**
+ * The brand base: what a film made once from the space's brand for the kit's base (the base's
+ * BRAND.md says what — theme.json at least), kept per space for the kit and the brand as they are.
+ * A changed brand or kit is another key, so it is made again.
+ */
+function brandBaseDir(ctx, kitHash, brandStamp) {
+    const key = createHash("sha256").update(`${kitHash}:${brandStamp}`).digest("hex").slice(0, 24);
+    return join(env.dataDir, "brand-bases", ctx.project.id, key);
+}
+/** What in film/brand/ is the brand base: everything but the brand itself. */
+const isBrandItself = (name) => name === "brand.json" || name === "logos" || name === "patterns";
+/**
+ * Brings the brand into a project that started from a base: brand.json and the logos as they are
+ * now, and the brand base kept for them when there is one. A base that no longer fits the brand
+ * is removed — the film makes it again, as BRAND.md says.
+ */
+async function brandIntoFilm(root, brandChanged) {
+    const base = await readFile(join(root, BASE), "utf8").catch(() => "");
+    if (!base) {
+        return;
+    }
+    const target = join(root, "film", "brand");
+    await mkdir(target, { recursive: true });
+    for (const name of await readdir(target)) {
+        if (isBrandItself(name) || (brandChanged && !existsSync(base))) {
+            await rm(join(target, name), { recursive: true, force: true });
+        }
+    }
+    await cp(join(root, "brand"), target, { recursive: true });
+    if (existsSync(base) && (brandChanged || !existsSync(join(target, "theme.json")))) {
+        await cp(base, target, { recursive: true });
+    }
+}
+/** A new brand is another brand base: the marker points at the one for the brand as it is now. */
+async function refreshBrandBase(root, ctx, step) {
+    if (!existsSync(join(root, BASE))) {
+        return;
+    }
+    const kitHash = ctx.files.find((f) => f.path === step.kit)?.hash ?? "";
+    const stamp = await readFile(join(root, BRAND_STAMP), "utf8");
+    await put(root, BASE, brandBaseDir(ctx, kitHash, stamp));
+}
+/** After a film: keeps what it made from the brand for the next films in this space. */
+export async function keepBrandBase(root) {
+    const base = await readFile(join(root, BASE), "utf8").catch(() => "");
+    const source = join(root, "film", "brand");
+    if (!base || !existsSync(join(source, "theme.json"))) {
+        return;
+    }
+    await rm(base, { recursive: true, force: true });
+    await mkdir(base, { recursive: true });
+    for (const name of await readdir(source)) {
+        if (!isBrandItself(name)) {
+            await cp(join(source, name), join(base, name), { recursive: true });
+        }
+    }
+}
+/** Sets up the folder for a first attempt; a later attempt finds it as it was left. */
+export async function prepareFilmFolder(step, ctx) {
+    const root = filmRoot(ctx.runId, step.id);
+    const brief = renderTemplate(step.brief, ctx.scope).trim();
+    // An earlier film to start from, when it ran.
+    const fromId = step.from ? dataRef(step.from).replace(/^steps\./, "") : null;
+    const fromDir = fromId ? join(filmRoot(ctx.runId, fromId), "film") : null;
+    const from = fromId && fromDir && existsSync(join(fromDir, "index.html")) ? fromId : null;
+    // The same brief and material as last time: the film is there to go on with or to change.
+    const stamp = createHash("sha256")
+        .update(JSON.stringify([
+        brief,
+        Object.values(step.inputs).map((raw) => {
+            const ref = dataRef(raw);
+            const [head, id] = ref.split(".");
+            return head === "steps" ? ctx.state.outputs[id]?.at : ctx.state.values[ref];
+        }),
+        from ? ctx.state.outputs[from]?.at : null,
+    ]))
+        .digest("hex");
+    const stampFile = join(root, ".engenty", "inputs");
+    const same = existsSync(stampFile) && (await readFile(stampFile, "utf8")) === stamp;
+    if (same && existsSync(join(root, "film", "index.html")) && (await savedSession(root))) {
+        // The brand is the space's as it is now, also for a change: colours or a logo may be new.
+        const { changed } = await writeBrand(root, ctx);
+        const start = ((await readFile(join(root, START), "utf8").catch(() => "")) ||
+            "init");
+        if (changed) {
+            await refreshBrandBase(root, ctx, step);
+        }
+        await brandIntoFilm(root, changed);
+        return { root, brief, brandChanged: changed, start };
+    }
+    await rm(root, { recursive: true, force: true });
+    await mkdir(root, { recursive: true });
+    const skills = await placeSkills(step.skills, ctx.files, join(root, ".claude", "skills"));
+    const size = FILM_SIZES[step.format];
+    await put(root, "BRIEF.md", `# Brief\n\nFormat ${step.format}, ${size.width}×${size.height}${step.seconds ? `, about ${step.seconds} s` : ""}. Language of all text on screen: the brief's language.\n\n${brief}\n`);
+    // The style kit: the showcase to look at, and the base a film starts from when it has one.
+    const kitFile = step.kit ? ctx.files.find((f) => f.path === step.kit) : undefined;
+    const base = {};
+    if (kitFile) {
+        const entries = unzipSync(new Uint8Array(await getBlob(kitFile.hash)));
+        for (const [name, data] of Object.entries(entries)) {
+            if (name.endsWith("/")) {
+                continue;
+            }
+            if (name.startsWith("base/")) {
+                base[name.slice("base/".length)] = data;
+            }
+            else {
+                await put(join(root, "showcase"), name.replace(/^showcase\//, ""), data);
+            }
+        }
+    }
+    const { stamp: brandStamp } = await writeBrand(root, ctx);
     // What the run made before.
     const listed = [];
     for (const [name, raw] of Object.entries(step.inputs)) {
@@ -246,12 +371,43 @@ export async function prepareFilmFolder(step, ctx) {
     }
     await put(join(root, "input"), "README.md", `# Material for this film\n\n${listed.join("\n") || "(none)"}\n\nVoice lines play one after another in their order; their lengths decide the timing.\n`);
     await cp(await soundCatalog(), join(root, "audio-catalog"), { recursive: true });
-    // The HyperFrames project, set up for the format.
-    const preset = { "16:9": "landscape", "9:16": "portrait", "1:1": "square" }[step.format];
-    const init = await runHyperframes(["init", "film", "--non-interactive", "--skip-transcribe", `--resolution=${preset}`], { cwd: root, signal: ctx.signal, timeoutMs: 5 * 60_000 });
-    if (init.code !== 0 || !existsSync(join(root, "film"))) {
-        throw new Error(`The film project could not be set up: ${init.out.slice(-300)}`);
+    // The HyperFrames project: the earlier film, the kit's base in this format, or a new one.
+    const index = `index.${step.format.replace(":", "x")}.html`;
+    let start;
+    if (from && fromDir) {
+        start = "from";
+        await cp(fromDir, join(root, "film"), {
+            recursive: true,
+            filter: (path) => !/\/(renders|snapshots)(\/|$)/.test(path.slice(fromDir.length)),
+        });
+        const fromBase = await readFile(join(filmRoot(ctx.runId, from), BASE), "utf8").catch(() => "");
+        if (fromBase) {
+            await put(root, BASE, fromBase);
+        }
     }
+    else if (base[index]) {
+        start = "base";
+        for (const [name, data] of Object.entries(base)) {
+            if (!/^index\.\d+x\d+\.html$/.test(name)) {
+                await put(join(root, "film"), name, data);
+            }
+        }
+        await put(join(root, "film"), "index.html", base[index]);
+        await put(root, BASE, brandBaseDir(ctx, kitFile?.hash ?? "", brandStamp));
+    }
+    else {
+        start = "init";
+        const preset = { "16:9": "landscape", "9:16": "portrait", "1:1": "square" }[step.format];
+        const init = await runHyperframes(["init", "film", "--non-interactive", "--skip-transcribe", `--resolution=${preset}`], { cwd: root, signal: ctx.signal, timeoutMs: 5 * 60_000 });
+        if (init.code !== 0 || !existsSync(join(root, "film"))) {
+            throw new Error(`The film project could not be set up: ${init.out.slice(-300)}`);
+        }
+    }
+    await brandIntoFilm(root, false);
+    const text = rules(step, skills, start);
+    await put(root, "CLAUDE.md", text);
+    await put(root, "AGENTS.md", text);
+    await put(root, START, start);
     await put(root, ".engenty/inputs", stamp);
-    return { root, brief };
+    return { root, brief, brandChanged: false, start };
 }

package/apps/runtime/dist/film/step.js

@@ -2,6 +2,7 @@ import { spawn } from "node:child_process";
 import { existsSync } from "node:fs";
 import { readFile, rm, stat } from "node:fs/promises";
 import { isAbsolute, join, normalize } from "node:path";
+import { FILM_SIZES } from "@engenty-wizards/shared/definition";
 import { note as runNote } from "@engenty-wizards/shared/run";
 import { StepError } from "../engine/types.js";
 import { CLAUDE_BIN, claudeEnv } from "../harness/claude.js";
@@ -9,7 +10,7 @@ import { failureOf } from "../harness/model.js";
 import { openBridge } from "../mcp/bridge.js";
 import { saidOf } from "../model-errors.js";
 import { filmClient } from "../models.js";
-import { prepareFilmFolder, savedSession, saveSession } from "./project.js";
+import { keepBrandBase, prepareFilmFolder, savedSession, saveSession } from "./project.js";
 import { runHyperframes } from "./tools.js";
 /**
  * A film step: the installed client (Claude Code) works in the film's folder with the skills,
@@ -99,7 +100,7 @@ export async function runFilmStep(step, ctx) {
     }
     const { client, alias } = found;
     await ctx.emit("info", { code: "filmSetup" });
-    const { root, brief } = await prepareFilmFolder(step, ctx);
+    const { root, brief, brandChanged, start } = await prepareFilmFolder(step, ctx);
     const resume = await savedSession(root);
     await ctx.emit("info", resume ? { code: "filmResume" } : { code: "filmClient", params: { client: client.name } });
     const limit = AbortSignal.any([ctx.signal, AbortSignal.timeout(LIMIT_MS)]);
@@ -244,11 +245,20 @@ export async function runFilmStep(step, ctx) {
     try {
         // A review's note asks for a change: the film's code is there, so it is edited, not redone.
         const note = ctx.state.notes[step.id]?.trim();
+        // A brand changed in the space since the film was made: the film's code carries the old one.
+        const brandNote = !brandChanged
+            ? ""
+            : start === "init"
+                ? "\n\nThe space's brand has changed since the film was made: brand/brand.json and brand/logos/ are new. Carry them into the film wherever it uses the brand (its own copies included), so every colour, logo and name is the new one, and check the frames for contrast."
+                : "\n\nThe space's brand has changed since the film was made: film/brand/brand.json and the logos are new. If film/brand/theme.json is missing, make it again as film/BRAND.md says. Make sure every colour, logo and name in the film is the new one, and check the frames for contrast.";
+        const size = FILM_SIZES[step.format];
         const prompt = resume && note
-            ? `The person watched the film and asks for this change:\n\n${note}\n\nChange the film in film/ accordingly — keep what they did not mention — check the frames again, and end with a short summary of what you changed.`
+            ? `The person watched the film and asks for this change:\n\n${note}${brandNote}\n\nChange the film in film/ accordingly — keep what they did not mention — check the frames again, and end with a short summary of what you changed.`
             : resume
-                ? "Carry on with the film where you stopped. Read PROGRESS.md and the folder to see where that was, then finish it."
-                : `Make the film BRIEF.md asks for, following CLAUDE.md.\n\n${brief}`;
+                ? `Carry on with the film where you stopped. Read PROGRESS.md and the folder to see where that was, then finish it.${brandNote}`
+                : start === "from"
+                    ? `film/ holds this run's film in another format. Lay it out for ${step.format} (${size.width}×${size.height}), following CLAUDE.md: set the size of film/index.html, then make every scene fit — scenes, timing, words and sound stay. Check the frames, render a draft, and end with a short summary of what you changed.\n\nThe brief, for reference:\n\n${brief}`
+                    : `Make the film BRIEF.md asks for, following CLAUDE.md.\n\n${brief}`;
         const first = await turn(prompt, resume);
         summary = typeof first.result === "string" ? first.result.trim() : "";
         // The final render is ours: it does not depend on the client still running. What fails
@@ -277,6 +287,7 @@ export async function runFilmStep(step, ctx) {
     finally {
         bridge.close();
     }
+    await keepBrandBase(root).catch(() => { });
     const ref = await ctx.saveAsset({
         stepId: step.id,
         kind: "video",

package/apps/runtime/dist/models.js

@@ -11,6 +11,7 @@ import { CAPABILITY_CLASSES, creditsModelOf, isCreditsRef, PROVIDER_IDS, provide
 import { note, saidText } from "@engenty-wizards/shared/run";
 import { generateSpeech, generateText, } from "ai";
 import { accountToken, linkedAccount } from "./auth/account.js";
+import { ollamaDecisionModel, ollamaRoot } from "./decision-model.js";
 import { DeviceModel, deviceThinks } from "./engine/device.js";
 import { env } from "./env.js";
 import { appleModel, appleStatus, appleTranscriptionModel, appleUnavailableNote, } from "./harness/apple.js";
@@ -652,10 +653,37 @@ export async function embeddingModel() {
         ? { model: gatewayClient(access, {}).embeddingModel("wizards/embedding"), ref: bound.model }
         : null;
 }
+/** What the local Ollama held at the last look, so a decision does not ask it every time. */
+let localDecision = null;
+/** The decision model in the local Ollama (Clef-flash, pulled by the setup), looked up once a minute. */
+async function localDecisionModel(url) {
+    if (localDecision?.url === url && Date.now() < localDecision.at) {
+        return localDecision.model;
+    }
+    const model = await ollamaDecisionModel(url);
+    localDecision = { url, model, at: Date.now() + 60_000 };
+    return model;
+}
+/**
+ * Ollama refused the model itself, not the question: a newer Ollama that wants it downloaded
+ * again, a model that was removed, one that does not fit into memory. Decisions take the next
+ * way for ten minutes, and the log says what Ollama says fixes it.
+ */
+function localModelRefused(url, status, body) {
+    const cannotRun = status === 404 ||
+        status >= 500 ||
+        /no longer supported|re-?download|ollama pull|not found/i.test(body);
+    if (!cannotRun) {
+        return;
+    }
+    console.warn(`[decide] the local decision model cannot run, left out for 10 minutes: ${body}`);
+    localDecision = { url, model: null, at: Date.now() + 10 * 60_000 };
+}
 /**
- * The way to TypeSafe's Jev, a classifier that answers typed questions with probabilities and
- * writes no text: the credits on a Manage-App's runtime; alone, an AI Gateway key, a TypeSafe
- * key, or the linked account's credits. Null when there is none.
+ * The way to a decision model, one that answers typed questions with probabilities and writes
+ * no text: the credits on a Manage-App's runtime; alone, TypeSafe's Jev through an AI Gateway
+ * key or a TypeSafe key, then Clef-flash in Ollama on this machine, then Jev on the linked
+ * account's credits. Null when there is none.
  */
 export async function systemOneAccess() {
     const cfg = await config();
@@ -687,6 +715,18 @@ export async function systemOneAccess() {
             model: "jev-latest",
         };
     }
+    // Free, and nothing leaves the machine: before the credits.
+    const ollama = cfg.settings.ollamaUrl ?? env.ollamaUrl;
+    const local = await localDecisionModel(ollama);
+    if (local) {
+        return {
+            url: `${ollamaRoot(ollama)}/v1/systemone`,
+            headers: {},
+            model: local,
+            local: true,
+            refused: (status, body) => localModelRefused(ollama, status, body),
+        };
+    }
     const access = await creditAccess(cfg, false).catch(() => null);
     return access ? viaCredits(access) : null;
 }

package/apps/runtime/dist/routes/runs.js

@@ -1,6 +1,6 @@
 import { FORMATS, isLang, LANG_CODE, LANGS, LIST_FORMATS, TEXT_CLASSES, wizardLang, } from "@engenty-wizards/shared/definition";
 import { TableColumnValueError } from "@engenty-wizards/shared/engenty/data-tables";
-import { noteText } from "@engenty-wizards/shared/run";
+import { noteText, } from "@engenty-wizards/shared/run";
 import { machineTranslated, translateDefinition, } from "@engenty-wizards/shared/translation";
 import { getConnInfo } from "@hono/node-server/conninfo";
 import { and, eq } from "drizzle-orm";
@@ -220,6 +220,18 @@ async function publishedWizard(token) {
 function wantsTranslation(w, def, lang) {
     return w.translate && lang !== wizardLang(def);
 }
+/** What the wizard's pages ask, in order (`PublicWizard.fields`). */
+export function pageFields(def) {
+    return def.steps.flatMap((step) => step.type === "page"
+        ? step.fields.map((f) => ({
+            id: f.id,
+            label: f.label,
+            kind: f.kind,
+            ...(f.options?.length ? { options: f.options } : {}),
+            ...(f.required ? { required: true } : {}),
+        }))
+        : []);
+}
 /** What a wizard's page shows before a run: in the viewer's language where `as` is given. */
 async function publicBody(c, w, original, as) {
     const translated = as ? translateDefinition(original, as.memory) : null;
@@ -245,6 +257,7 @@ async function publicBody(c, w, original, as) {
                 machine: machineTranslated(as.memory, original),
             }
             : null,
+        fields: pageFields(def),
     };
 }
 export const publicRoutes = new Hono()