acrylblends 1.1.0 → 1.2.0

package/docs/framework/workshop/facilitator.md

@@ -1,131 +1,99 @@
-# Facilitator notes: an app that builds and drives itself
+# Facilitator notes: building inside the ACRYL frame
 
-Read the handout first (`docs/framework/workshop/README.md`); this page is the room around it. The workshop changed shape on 2026-10-29: the agent living in
-the app both builds its interface and drives it (clicks, sidebars, dialogs, settings), on the web and in a desktop window. The data layer and the template
-tour are asides now, and `/hello` is only the introduction to the framework core. The handout is written for **acrylblends 1.0.10 or newer**.
+Read the handout first (`docs/framework/workshop/README.md`); this page is the room around it. The workshop changed shape again for the frame: the
+app is created, then **opened inside ACRYL's IDE** (projects on the left, the app's page in the canvas, files/changes/terminals on the right), a
+chat model works on the app from inside the frame, and coding agents run in terminal tabs in the same folder. The data layer, the desktop window and
+the panel-first flow of the previous handout are gone.
+
+The handout is written for **acrylblends 1.2.0 or newer** (the release that carries the frame). A room on an older release is on the previous handout;
+check with `npx acrylblends@latest --version` before the day.
 
 ## Before the room: put this on every machine
 
 | What | Why | How |
 | --- | --- | --- |
 | The preflight passing | it checks Node, npm, git, an agent with its login or key, a free port, and on Windows PowerShell and long paths | `npx acrylblends@latest preflight` ends with `Ready for the workshop.` |
-| Node.js 22.19 or newer (24 and 26 tested) | the app runs TypeScript directly | `node -v`; the app's own `scripts/check-node.cjs` refuses an older Node with a clear line |
-| git, and a GitHub account with `gh auth login` | the last block forks the workshop registry and opens a pull request | `git --version`, `gh auth status` |
-| One coding agent, logged in | the panel drives it; `codex`, `claude` and `pi` all worked | `codex login` once (and a model the account supports), or run `claude` once, or pi with `DEEPSEEK_API_KEY` set in the terminal that starts the app |
-| A prepared app with Electron already downloaded | the desktop block is 15 minutes and the download is the slowest part | run the handout's blocks 1 and 4 once per machine, then keep the folder as `~/acryl-workshop/prepared/` |
-| A warm npm cache | the first `npm create` and the Electron download dominate the first ten minutes | the prepared app does it |
+| Node.js 22.19 or newer (24 and 26 tested) | the app runs TypeScript directly | `node -v`; the app's `scripts/check-node.cjs` refuses an older Node with a clear line |
+| git, and a GitHub account with `gh auth login` | the first `npm run dev` makes the folder a git repository (Files and Changes need one); the last block forks the registry | `git --version`, `gh auth status` |
+| One coding agent, logged in | block 5 starts it in a terminal tab; `claude`, `codex` and `pi` all worked | `codex login` once, or run `claude` once, or pi with `DEEPSEEK_API_KEY` in the terminal that starts `npm run dev` |
+| One model key | block 3 adds it in Settings > Models; without it the chat shows a connect card | a DeepSeek key from <https://platform.deepseek.com>, or a Claude/ChatGPT subscription through Sign in with an account |
+| A prepared app with `npm install` done | the first install brings the frame and the chat engine (about 500 MB together); a room on one Wi-Fi should not do it 20 times | run the handout's block 1 once per machine and keep the folder as `~/acryl-workshop/prepared/` |
+| A warm npm cache | the first install dominates block 1 | the prepared app does it |
 
-**The agent config that decides the day.** The panel's agent is configured to act rather than describe. Check on every machine that a plain request
-produces files, not a plan: ask the prepared app's panel "say hello in a card on the page" and watch the panel's `Working...` line and the first file
-appear. If it only describes, the model is waiting for permission; the handout's sentence is "do it now".
+**The agent setting that decides the day.** The agents are configured to act rather than describe. Check on every machine that a plain request
+produces files, not a plan: ask the prepared app's chat "add a line to the app's page" and watch the Changes panel. If it only describes, the model
+is waiting for permission; the handout's sentence is "do it now".
 
-**Agent-specific checks.** Codex answering `model_not_found` means the account does not have the default model: pick one it supports (`/model` in codex,
-or `model = "..."` in `~/.codex/config.toml`). pi with DeepSeek needs `DEEPSEEK_API_KEY` in the environment of the terminal that runs `npm run dev`
-(the panel starts pi from the app); the preflight reports `PASS agent pi (DeepSeek key found)` when it is there. The package is
-`@earendil-works/pi-coding-agent` (1.4.0 on npm on 2026-10-30), installed with `npm i -g @earendil-works/pi-coding-agent`.
+**Agent-specific checks.** Codex answering `model_not_found` means the account does not have the default model: pick one it supports (`/model` in
+codex, or `model = "..."` in `~/.codex/config.toml`). pi with DeepSeek needs `DEEPSEEK_API_KEY` in the environment of the terminal that runs `npm
+run dev` (the terminal tabs inherit it); the preflight reports `PASS agent pi (DeepSeek key found)`. The package is
+`@earendil-works/pi-coding-agent`.
 
-## Timings, from the 1.0.10 walks (macOS and Windows, pi on DeepSeek)
+## Timings, from the rehearsal (this Mac, packed CLI, isolated HOME)
 
 | Minutes | Block | Measured | If late |
 | --- | --- | --- | --- |
-| 0-10 | preflight, setup and `/hello` | preflight 12 s; create, install, dev, the route edit, `npm test` (14 tests) and `npm run check` 14 s of commands | never cut |
-| 10-40 | the agent builds the interface | 5:51 for pi to build, install and check the board (an earlier codex run: about 2.5 minutes) | if late, keep the board minimal (one column) |
-| 40-60 | the agent drives the app | 1:41 for the tick-and-filter prompt (six door calls, most of the time the model thinking), 2:07 for the New-card prompt | the drive is the point; cut the second "check its own work" prompt |
-| 60-75 | the same app in a window | add + install 5 s; first `npm run desktop` 10 s including the Electron download on a fast line; the drive in the window 22 s; the windows, menu and settings prompt 1:11 | pre-warm Electron or demo it |
-| 75-90 | deploy and publish | production start in seconds; the registry check merges in about 2 minutes | keep the publish; the deploy talk can be 3 minutes |
+| 0-10 | preflight and setup | preflight ~15 s; the prepared app skips create and install | never cut |
+| 10-20 | create and open the frame | the first `npm install` dominates (the frame and the chat engine); the frame's first page is up in a few seconds after that | use the prepared app and open its frame |
+| 20-25 | the first change at /app | the Files view opens `src/routes.ts`; stop and `npm run dev` reconnects the frame in a few seconds; the page shows the edit | cut `npm test` to the take-home |
+| 25-30 | Settings > Models | the key saves with Apply (`Saved DeepSeek (deepseek-official).`); the page uses it after a reload | paste the key in the first-run card instead, Save and continue |
+| 30-50 | chat builds the board | the chat writes into the app folder and Changes fills; the restart loop shows it at /app/board | if the model is slow, cut the board to one column |
+| 50-65 | a coding agent in a terminal | the agent tab starts in the app folder (its prompt is `my-app`); `.acryl/bin/acryl look` prints the page in the frame's tile | demo one agent and let the room follow |
+| 65-80 | upgrade an older app | `npx acrylblends@latest upgrade` reports every file it changed (the `frame` line is the new layout), then `npm install` and `npm run dev` | keep the report, skip the second app |
+| 80-90 | publish (take-home) | the registry check merges in about two minutes | leave it as the take-home |
+
+What the rehearsal verified end to end on this Mac: a packed CLI in an isolated HOME, the app opened by the frame with the app's page in a tab
+(the first-run tile), the Preview Notice dismissed once, Settings > Models saving a key and the chat sending with it (against a local mock), a
+terminal tab running commands in the app folder, the app's page edited and shown after a restart, the door seeing the page (`acryl look`), and an
+app made by the previous release upgraded and opened by the frame.
 
-The Windows walk on 1.0.10 (2026-10-30, Windows 10, Node 22, pi on DeepSeek) matched: preflight 13 s; `npm create` 8 s and install 4 s; pi built the
-board from the panel in 5:56; the agent opened Settings through `File > Settings...`, set the appearance and saw `Saved: Dark`, and window 1 showed it
-after a reload; with two windows open during a live run, `look` answered in 317-353 ms in each and the panel's Stop ended the run in 3 s; production served
-the board read-only with the agent routes gone.
+## What to say in the room
 
-Checkpoints in the handout: 10 minutes a route answers; 40 minutes the agent's board is on screen; 60 minutes the agent has clicked through it; 75 minutes
-the window is open. Walk the room at those minutes and help the machine that is behind, rather than the one that is ahead.
+- **The frame is the product.** The point is not "an app with a chat sidebar"; it is that ACRYL's IDE hosts the app you are building: the app is
+  the page in the middle, its folder is the workspace, and the agents work in that folder.
+- **Settings > Models is the key's home.** The key goes to the frame's own credentials store, never the app folder or `.acrylblends` files. The
+  first-run card writes the same store; either path is fine.
+- **The loop is stop, start, look.** A source change needs `npm run dev` again; the port is stable per app, so the frame reconnects on the same
+  address and the app's tab is still there. If a chat tab comes to the front after the restart, press the `my-app` tab.
+- **Two kinds of agent.** The chat (DSH's own, in the frame) and the coding agents in terminal tabs are different hands on the same folder; show
+  both and let people pick.
+- **The door.** `.acryl/bin/acryl look` prints the page with refs, `act` clicks and types. In the frame the page is the tile, and the door sees
+  it. This is how an agent checks its own work.
+- **Production is unchanged.** The frame, the chat and the agents are development tools; `NODE_ENV=production npm start` serves the app alone.
 
-## What to say in the room
+## Windows
 
-- **Close the browser tab before block 4.** While a browser tab of the app is open, a door action without `--window` can go to that tab: in the 1.0.10
-  walk the agent, asked from the window's panel, moved the hidden browser tab and reported success while the window stayed on `/`. With the tab closed
-  the same prompt drove the window in 22 s. The handout says so at the top of block 4; it stays until the door aims at the window the agent was asked
-  from (reported to Blends).
-- **The Settings item.** It is in the application menu on macOS (`my-app > Settings...`, `Cmd+,`) and the first item of the File menu on Windows and Linux
-  (`Ctrl+,`). An app gets it because it serves `/settings`; the template does. In the walk, pi found it in the app menu by itself.
-- **Appearance.** The template's `/settings` saves light, dark or "match the system" for the app's own pages. A window that is already open shows the
-  change after a reload, and a page the agent built follows the system theme unless asked otherwise. On a dark-mode machine, demo with Light.
-- **The driving bar.** `Agent is driving: clicking` with a Stop button shows at the bottom of the page only while each action runs, a moment each; the
-  panel's `Working... m:ss` line and its Stop button are what people see during a run.
-- **Every agent builds a different board.** pi's board needed a title typed before "New card" added a card, and kept its sidebar always open when the
-  prompt did not ask for a toggle. The handout's block 2 prompt now asks for a button that opens and closes the sidebar, so block 3 has something to open.
-- **Production listens where it is told.** The app reads `ACRYLBLENDS_HOST` and `ACRYLBLENDS_PORT`, not `PORT`; without them it listens on `127.0.0.1` at a
-  port chosen from its folder. A server needs `ACRYLBLENDS_HOST=0.0.0.0 ACRYLBLENDS_PORT=8080 NODE_ENV=production npm start` (verified: it answered on the
-  LAN). If Blends ships `PORT`, the handout switches to it.
-- **Windows.** Windows PowerShell 5.1 has no `&&` (two lines, or `;`); PowerShell sets variables with `$env:NAME="value"`; cmd.exe's `Ctrl-C` asks
-  `Terminate batch job (Y/N)?` (answer `Y`); cmd.exe does not expand `~` (use `%USERPROFILE%`). Node 22 prints only `Restarting 'src/main.ts'` on a save;
-  Node 24 and 26 print `Change detected …` before it.
-- **F (the door through a DeepSeek model with no login).** pi with a DeepSeek key works today; do not promise more than that.
-
-## What the 1.0.10 walk found, block by block
-
-The final macOS walk on 1.0.10 (2026-10-30), verbatim from the handout as it stood before this revision, with pi on DeepSeek. Every block passed; these
-are the places where the handout text differed from what the walk saw, and each one is now handled in the handout.
-
-1. Block 1: npm test now has 14 tests (the guide gives no number). "Change detected … Restarting" matches on Node 24; on Node 22 only "Restarting"
-   prints (seen on z370n).
-2. Block 2: "keep the app's own page (/) open in a second tab, because the panel lives there" is outdated: the panel is on every page now and followed the
-   agent to /board. The page is dark on a dark-mode Mac (screenshots s1-first-page/s3-board look different); the panel stays light on the dark page.
-3. Block 3: the guide's block 2 prompt asks for no sidebar toggle, so "open the sidebar" has nothing to open (pi says so and goes on). "an indicator in
-   the corner says the agent is driving, with a stop button": it shows only while each single door call runs (a fraction of a second), so an attendee
-   will hardly see it; it never showed in 33 frames taken every 3 s. "Click New card twice" added no cards: pi's board needs a title first; the prompt
-   only asks whether the counts agree. "seven door calls in about twenty seconds" was 6 calls in 1:41 with pi.
-4. Block 4: the guide says "use the File menu". On macOS Settings is in the app menu (my-app>Settings..., Cmd+,); pi found it there itself. Elsewhere it
-   is the first File item. "switch the appearance to dark" shows no change on a dark-mode Mac, and the agent-built /board ignores the app theme (its CSS
-   follows the system); the change shows on the template's / and /settings, and in other open windows only after a reload (switching to Light in window
-   3, window 1 on / changed only after act reload). The TODO(1.0.4-C) paragraph is outdated: the window, menu and settings control has shipped.
-   Important: if the browser tab from blocks 2-3 is still open, the agent's door calls from the window's panel go to that browser tab, not the window. My
-   first in-window drive moved the hidden tab and the window stayed on /. With the tab closed it worked.
-5. Block 5: "That is the same app on any Node host … one port" names no port: the app binds 127.0.0.1 on a port derived from its folder path, ignores PORT
-   (PORT=3299 still gave 3991), and needs ACRYLBLENDS_PORT and ACRYLBLENDS_HOST (only the app's README names them; production.md does not).
+Windows PowerShell 5.1 has no `&&` (two lines, or `;`); PowerShell sets variables with `$env:NAME="value"`; cmd.exe's `Ctrl-C` asks `Terminate
+batch job (Y/N)?` (answer `Y`); cmd.exe does not expand `~` (use `%USERPROFILE%`). `npm install` needs the "Desktop development with C++" workload
+of Visual Studio Build Tools for the terminal package; the preflight notes it.
 
 ## The no-network fallback
 
-1. Prepared apps on every machine cover blocks 1-3; the agent's model still needs the network, so block 2 and 3 need a connection or a demo.
-2. Block 5's registry needs GitHub; if the venue is offline, publish from your machine on a hotspot at the end, or show the recording.
+1. Prepared apps with `npm install` done cover blocks 1, 2 and the frame; the models (chat and agents) still need a connection or a demo.
+2. Block 7's registry needs GitHub; if the venue is offline, publish from your machine on a hotspot at the end, or show the recording.
 3. Keep one phone hotspot for the room.
 
 ## Demo script (five minutes, if the room is behind)
 
-1. Prepared app, panel open: ask for a card with a count. Narrate the panel's `Working...` line and the page as it reloads.
-2. Ask: "open the sidebar, tick one card, change the filter to done, tell me the counts." Point at the page changing and at the driving bar as each action
-   runs.
-3. Show `.acryl/audit/` afterwards: every action is a line.
-4. Close the browser tab, switch to the desktop window and repeat one click there; then open Settings from the menu.
-5. Show the registry listing with an app already published, and the four commands that put it there.
-
-## Screenshots
-
-Taken on 1.0.10 on macOS in dark mode (the pages follow the system theme), 1280 wide, no personal data, tokens or real home paths:
-
-| File | Shows |
-| --- | --- |
-| `s1-first-page.webp` | the first page with the panel open (block 1) |
-| `s2-panel-building.webp` | the panel with the build request and `Working... 0:04` (block 2) |
-| `s3-board.webp` | a board an agent built (block 2; from an earlier run, kept because it shows the result best) |
-| `s4-agent-drives-window.webp` | the agent driving the board in the desktop window: the Done filter it just set (block 4) |
-| `s5-two-windows.webp` | two desktop windows: the app's page in the dark appearance, and the Settings window showing `Saved: Dark` (block 4) |
-| `s6-registry.webp` | the registry listing (block 5) |
-
-S4 and S5 are page captures of the desktop windows (through the window's DevTools), without the window frame; a capture with the frame needs the
-screen-recording permission on the machine that takes it.
+1. Prepared app, frame open on the app's page: press `+`, open **AcrylDSH Chat**, ask for a sentence on the page. Narrate the Changes panel and
+   the restart loop.
+2. Open a **files** tab in the right panel and show the edit the model made.
+3. `+` → **Pi** (or Claude): the agent starts in the app folder; ask it for a route; run `.acryl/bin/acryl look` in that terminal and show the
+   page's snapshot.
+4. Settings > Models: show where the key lives and that it is not in the app folder.
+5. Show the registry listing with an app already published.
 
 ## Resetting between sessions
 
-Everything a person makes lives inside their app folder and `~/acryl-workshop`. To reset a machine, delete the app folders and copy the prepared one back;
-nothing is installed globally except the agent, `gh` and Node.
+Everything a person makes lives inside their app folder and `~/acryl-workshop`. To reset a machine, delete the app folders and copy the prepared one
+back; nothing is installed globally except the agent, `gh` and Node. An app's data lives in its `.acrylblends/` (gitignored); the model key lives in
+that home's credentials store, so a fresh copy starts without it.
 
 ## What is still open
 
-- Close-the-tab advice in block 4 until the door aims at the window the agent was asked from.
-- The appearance reaching open windows live, and an agent-built page following the app's appearance: reported to Blends; the handout says "reload".
-- `PORT` for production: if Blends ships it, the handout's server line switches from `ACRYLBLENDS_PORT` to `PORT`.
-- The handout's hosted-workspace section (browser-only attendees) stays TODO(M9) until that workspace is live; the one-click WebBoxes.ai deploy lives
-  there too.
+- The frame's chat tab takes the focus when it binds its session after a restart; the app's tab is one click away and the guide says so.
+- The frame's address is stable across restarts: the launcher keeps the token in the app home (owner-only, atomic) and reuses it, so an open page
+  comes back by reloading its URL even if the browser lost its cookie. `npx acrylblends open` prints the address of the running frame;
+  `npx acrylblends open --new` rotates it (the old address stops working at once and the new one is printed). The frame-side banner that names the
+  command is still to come (after the 120 gate work).
+- The one-click WebBoxes.ai deploy and the browser-only section stay TODO(M9) until that workspace is live.

package/legacy/README.md

@@ -0,0 +1,9 @@
+# The scaffolds published acrylblends releases shipped
+
+Generated by `scripts/build-legacy-layouts.mjs`; do not edit by hand. Each folder is a template, each hash under it one distinct scaffold (deduplicated by
+content hash across releases), and `layouts.json` maps every published release that shipped templates (0.3.0 through 1.1.0, 40 releases)
+to the layouts it shipped.
+
+`acrylblends upgrade` compares an app's scaffold files with these bytes: a file the app has not edited is brought up to date, an edited one is refused (or
+replaced with --force after a backup). Releases before 0.7.8 wrote src/main.ts importing './plugins/...', which cannot start; their layouts are kept so the
+upgrade can say so precisely instead of writing a frame such a release's app cannot run.

package/legacy/agent/157ce3db1112/src/app.ts

@@ -0,0 +1,98 @@
+import { join } from 'node:path'
+import { fileURLToPath } from 'node:url'
+import { Context, type Fiber } from '@deepseek-ai/cordis'
+import * as nodeServer from './plugins/acryl-node-server/src/index.ts'
+import * as router from './plugins/acryl-router/src/index.ts'
+import * as state from './plugins/acryl-state/src/index.ts'
+import { agent, memory, model, tools } from './plugins/agent/index.ts'
+import { builder } from './plugins/builder/index.ts'
+import { extensions } from './plugins/extensions/index.ts'
+import { type AppInstance, instance } from './plugins/instance/index.ts'
+import {
+  blueprintsIn,
+  compose,
+  loadManifest,
+  type ParameterValue,
+} from './plugins/manifest/index.ts'
+import { type OpenAIConfig, openai } from './plugins/openai/index.ts'
+import { sandboxPlugin } from './plugins/sandbox/index.ts'
+import { save } from './plugins/save/index.ts'
+import { tasks } from './plugins/tasks/index.ts'
+import { routes } from './routes.ts'
+
+/** The plugins this app's code provides. `blend.yaml` chooses, orders and configures them. */
+export const registry = {
+  tasks,
+  model,
+  tools,
+  memory,
+  agent,
+  'acryl-router': router,
+  'acryl-state': state,
+  extensions,
+  builder,
+  save,
+  sandbox: sandboxPlugin,
+  routes,
+  'acryl-node-server': nodeServer,
+}
+
+/** The manifest next to this app's source. */
+export const MANIFEST = join(fileURLToPath(new URL('..', import.meta.url)), 'blend.yaml')
+
+/**
+ * The app's manifest, resolved. A Blend finds its Blueprint in `blueprints/<id>.yaml`; an app that is itself a Blueprint never looks.
+ * `createApp` and the tests read it the same way.
+ */
+export function readManifest(values?: Readonly<Record<string, ParameterValue>>) {
+  return loadManifest(MANIFEST, {
+    known: Object.keys(registry),
+    getBlueprint: blueprintsIn(join(fileURLToPath(new URL('..', import.meta.url)), 'blueprints')),
+    ...(values ? { values } : {}),
+  })
+}
+
+export interface App {
+  readonly root: Context
+  readonly url: string
+  stop(): Promise<void>
+}
+
+/**
+ * The app: `instance` first (where it lives, chosen at run time), then the manifest's rows in order. The app's own `extensions/`
+ * folder is trusted to install at start, and is where the builder writes.
+ */
+export async function createApp(
+  chosen: AppInstance,
+  options: {
+    values?: Readonly<Record<string, ParameterValue>>
+    /** A real model (any OpenAI-compatible API) in place of the offline scripted one. */
+    model?: OpenAIConfig
+  } = {},
+): Promise<App> {
+  const manifest = readManifest(options.values)
+  const extensionsDir = join(chosen.root, 'extensions')
+  const root = new Context()
+  const first = root.plugin(instance, chosen)
+  await first.await()
+  const fibers: Fiber[] = [
+    first,
+    // The `model` row mounts the scripted model, or the real one when a model is configured.
+    ...(await compose(root, manifest, options.model ? { ...registry, model: openai } : registry, {
+      ...(options.model ? { model: { ...options.model } } : {}),
+      // Runtime values the manifest cannot hold: the manifest's own digest (every task records it), and who may install.
+      tasks: { manifest: `sha256:${manifest.digest}` },
+      // The `approval` parameter in blend.yaml (the extensions row) turns this source into one that asks.
+      extensions: { sources: [{ dir: extensionsDir, trust: 'install' }] },
+      builder: { dir: extensionsDir },
+      server: { port: chosen.port.start, scan: chosen.port.scan ? 20 : 0, hostname: chosen.host },
+    })),
+  ]
+  return {
+    root,
+    url: root.nodeServer.url,
+    async stop() {
+      for (const fiber of [...fibers].reverse()) await fiber.dispose()
+    },
+  }
+}

package/legacy/agent/157ce3db1112/src/routes.ts

@@ -0,0 +1,63 @@
+import type { Context } from '@deepseek-ai/cordis'
+import { Acryl } from './plugins/acryl-router/src/index.ts'
+import { bodyLimit } from './plugins/acryl-router/src/middleware/index.ts'
+import type {} from './plugins/agent/index.ts'
+import type {} from './plugins/extensions/index.ts'
+import type {} from './plugins/tasks/index.ts'
+
+export const APP_NAME = '__APP_NAME__'
+
+/**
+ * The app's own routes on the router: `POST /ask` for the agent; `GET /extensions` and `GET /tasks` to observe what it did (every run is a
+ * durable task owning one task per tool call); `POST /tasks/cancel`. What changes is also streamed: `GET /api/state/tasks/events` and
+ * `GET /api/state/extensions/events`. The mount is removed when the plugin is disposed.
+ */
+export const routes = {
+  name: 'routes',
+  inject: ['router', 'agent', 'extensions', 'tasks'],
+  apply(ctx: Context) {
+    // A body here is a name, an id or a question; anything bigger is refused before it is read.
+    const json = async (c: {
+      req: { json(): Promise<unknown> }
+    }): Promise<Record<string, unknown>> => {
+      const body = await c.req.json().catch(() => undefined)
+      return typeof body === 'object' && body !== null ? (body as Record<string, unknown>) : {}
+    }
+    const app = new Acryl()
+      .use(bodyLimit({ maxSize: 64 * 1024 }))
+      .get('/', (c) => c.json({ app: APP_NAME, ok: true }))
+      .get('/health', (c) => c.json({ ok: true }))
+      .get('/extensions', (c) =>
+        c.json({
+          installed: ctx.extensions.list(),
+          notInstalled: ctx.extensions.pending(),
+          waitingForApproval: ctx.extensions.approvals(),
+        }),
+      )
+    // The owner's decision on an install that is waiting (the `approval` parameter in blend.yaml).
+    for (const [path, decide] of [
+      ['/extensions/approve', (name: string) => ctx.extensions.approve(name)],
+      ['/extensions/deny', (name: string) => ctx.extensions.deny(name)],
+    ] as const) {
+      app.post(path, async (c) => {
+        const { name } = await json(c)
+        if (typeof name !== 'string') return c.json({ error: 'name must be a string' }, 400)
+        return c.json(await decide(name))
+      })
+    }
+    app
+      .get('/tasks', (c) => c.json(ctx.tasks.list().slice(0, 100)))
+      .post('/tasks/cancel', async (c) => {
+        const { id } = await json(c)
+        if (typeof id !== 'string' || !ctx.tasks.get(id))
+          return c.json({ error: 'no such task' }, 404)
+        return c.json({ cancelled: ctx.tasks.cancel(id) })
+      })
+      .post('/ask', async (c) => {
+        const { question } = await json(c)
+        if (typeof question !== 'string') return c.json({ error: 'question must be a string' }, 400)
+        return c.json(await ctx.agent.run(question))
+      })
+    ctx.router.route('/', app)
+  },
+}

package/legacy/agent/24c681a00fca/src/app.ts

@@ -0,0 +1,160 @@
+import { existsSync } from 'node:fs'
+import { join } from 'node:path'
+import { fileURLToPath } from 'node:url'
+import { Context, type Fiber } from '@deepseek-ai/cordis'
+import * as door from '../plugins/acryl-door/src/index.ts'
+import * as nodeServer from '../plugins/acryl-node-server/src/index.ts'
+import * as router from '../plugins/acryl-router/src/index.ts'
+import * as state from '../plugins/acryl-state/src/index.ts'
+import { agent, memory, model, tools } from '../plugins/agent/index.ts'
+import * as panel from '../plugins/agent-panel/index.ts'
+import { builder } from '../plugins/builder/index.ts'
+import { extensions } from '../plugins/extensions/index.ts'
+import { type AppInstance, instance } from '../plugins/instance/index.ts'
+import {
+  blueprintsIn,
+  compose,
+  loadManifest,
+  type ParameterValue,
+} from '../plugins/manifest/index.ts'
+import { type OpenAIConfig, openai } from '../plugins/openai/index.ts'
+import { sandboxPlugin } from '../plugins/sandbox/index.ts'
+import { save } from '../plugins/save/index.ts'
+import { tasks } from '../plugins/tasks/index.ts'
+import { routes } from './routes.ts'
+
+/** The plugins this app's code provides. `blend.yaml` chooses, orders and configures them. */
+export const registry = {
+  tasks,
+  model,
+  tools,
+  memory,
+  agent,
+  'acryl-router': router,
+  'acryl-state': state,
+  extensions,
+  builder,
+  save,
+  sandbox: sandboxPlugin,
+  routes,
+  'acryl-node-server': nodeServer,
+  'agent-panel': panel,
+  'acryl-door': door,
+}
+
+/** The manifest next to this app's source. */
+export const MANIFEST = join(fileURLToPath(new URL('..', import.meta.url)), 'blend.yaml')
+
+/**
+ * The app's manifest, resolved. A Blend finds its Blueprint in `blueprints/<id>.yaml`; an app that is itself a Blueprint never looks.
+ * `createApp` and the tests read it the same way.
+ */
+export function readManifest(values?: Readonly<Record<string, ParameterValue>>) {
+  return loadManifest(MANIFEST, {
+    known: Object.keys(registry),
+    getBlueprint: blueprintsIn(join(fileURLToPath(new URL('..', import.meta.url)), 'blueprints')),
+    ...(values ? { values } : {}),
+  })
+}
+
+export interface App {
+  readonly root: Context
+  /** The address the server listens on; empty when the app was made with `listen: false`. */
+  readonly url: string
+  stop(): Promise<void>
+}
+
+/** The development rows production leaves out, and what each one gives a visitor. */
+const DEVELOPMENT_ROWS: Record<string, string> = {
+  agent: 'POST /ask runs the agent, which spends the model key and calls its tools',
+  builder: 'the agent can write plugin source into plugins/',
+  extensions:
+    'a plugin installed live runs in this process, and POST /extensions/approve decides installs',
+}
+
+/**
+ * The app: `instance` first (where it lives, chosen at run time), then the manifest's rows in order. The app's `plugins/`
+ * folder is trusted to install at start, and is where the builder writes.
+ */
+export async function createApp(
+  chosen: AppInstance,
+  options: {
+    values?: Readonly<Record<string, ParameterValue>>
+    /** A real model (any OpenAI-compatible API) in place of the offline scripted one. */
+    model?: OpenAIConfig
+    /** Start the HTTP server (default). Tests pass `false` and call `app.root.router.request(path)`: it needs no port, so it also runs where a sandbox forbids listening. */
+    listen?: boolean
+  } = {},
+): Promise<App> {
+  const read = readManifest(options.values)
+  // Rows left out: the server (and so the door, which needs it) when the app is reached in process; the door in production and with ACRYL_DOOR=off (one process at a time
+  // serves a folder's door, so the tests that start several apps set it).
+  const listen = options.listen !== false
+  const leaveOut = new Set<string>()
+  if (!listen) leaveOut.add('acryl-node-server').add('acryl-door')
+  if (process.env.NODE_ENV === 'production' || process.env.ACRYL_DOOR === 'off')
+    leaveOut.add('acryl-door')
+  // Production: the rows that give a visitor power over the running app or the owner's model key are left out too. The agent (`POST /ask` spends the model key and runs tools),
+  // the builder and the extensions (live plugin install runs code in this process, and `POST /extensions/approve` decides it) are development tools. `ACRYL_PRODUCTION_KEEP`
+  // names the ones to keep (`agent,builder,extensions`); each one kept is announced at start, because none of them is behind a login.
+  if (process.env.NODE_ENV === 'production') {
+    const keep = new Set(
+      (process.env.ACRYL_PRODUCTION_KEEP ?? '')
+        .split(',')
+        .map((name) => name.trim())
+        .filter((name) => name !== ''),
+    )
+    for (const name of keep)
+      if (!(name in DEVELOPMENT_ROWS))
+        console.warn(
+          `WARNING: ACRYL_PRODUCTION_KEEP names "${name}", which is not one of ${Object.keys(DEVELOPMENT_ROWS).join(', ')}`,
+        )
+    for (const [row, danger] of Object.entries(DEVELOPMENT_ROWS)) {
+      if (keep.has(row))
+        console.warn(
+          `WARNING: the "${row}" row runs in production because ACRYL_PRODUCTION_KEEP names it: ${danger}. Nothing here is behind a login; put the app behind your own.`,
+        )
+      else leaveOut.add(row)
+    }
+  }
+  const manifest = {
+    ...read,
+    plugins: read.plugins.map((row) => (leaveOut.has(row.use) ? { ...row, disabled: true } : row)),
+  }
+  const extensionsDir = join(chosen.root, 'plugins')
+  // One release of grace: an app made before 0.7.8 kept what the agent wrote in `extensions/`. It is still installed, with a warning.
+  const legacyDir = join(chosen.root, 'extensions')
+  const legacy = existsSync(legacyDir)
+  if (legacy)
+    console.warn(
+      'warning: extensions/ is the old folder for plugins the agent writes; move them to plugins/ ("git mv extensions/<name> plugins/<name>"). extensions/ is read for this release only.',
+    )
+  const root = new Context()
+  const first = root.plugin(instance, chosen)
+  await first.await()
+  const fibers: Fiber[] = [
+    first,
+    // The `model` row mounts the scripted model, or the real one when a model is configured.
+    ...(await compose(root, manifest, options.model ? { ...registry, model: openai } : registry, {
+      ...(options.model ? { model: { ...options.model } } : {}),
+      // Runtime values the manifest cannot hold: the manifest's own digest (every task records it), and who may install.
+      tasks: { manifest: `sha256:${manifest.digest}` },
+      // The `approval` parameter in blend.yaml (the extensions row) turns this source into one that asks.
+      extensions: {
+        sources: [
+          { dir: extensionsDir, trust: 'install' },
+          ...(legacy ? [{ dir: legacyDir, trust: 'install' as const }] : []),
+        ],
+      },
+      builder: { dir: extensionsDir },
+      server: { port: chosen.port.start, scan: chosen.port.scan ? 20 : 0, hostname: chosen.host },
+    })),
+  ]
+  return {
+    root,
+    url: listen ? root.nodeServer.url : '',
+    async stop() {
+      for (const fiber of [...fibers].reverse()) await fiber.dispose()
+    },
+  }
+}