acrylblends 1.0.10 → 1.2.0

package/dist/index.js

@@ -1,13 +1,1270 @@
 import { createRequire } from "node:module";
-import { cpSync, existsSync, mkdirSync, readFileSync, readdirSync, rmSync, statSync, writeFileSync } from "node:fs";
+import { chmodSync, cpSync, existsSync, mkdirSync, readFileSync, readdirSync, renameSync, rmSync, statSync, writeFileSync } from "node:fs";
 import { basename, dirname, join, posix, relative, resolve, sep } from "node:path";
 import { parseArgs } from "node:util";
+import { spawn, spawnSync } from "node:child_process";
 import { fileURLToPath } from "node:url";
 import { createHash } from "node:crypto";
-import { spawn, spawnSync } from "node:child_process";
+import { connect, createServer } from "node:net";
 import { createInterface } from "node:readline/promises";
-import { createServer } from "node:net";
 import { homedir } from "node:os";
+//#region ../../frame/packages.json
+var scope = "@acrylblends";
+var dshVersion = "0.2.0-rc.2";
+var packages = {
+	"acryl-ui": {
+		"name": "ui",
+		"version": "0.3.0"
+	},
+	"dsh-client-ui-brand-acryl": {
+		"name": "brand-client",
+		"version": "0.1.0"
+	},
+	"acryl-app-shell": {
+		"name": "app-shell",
+		"version": "0.1.0"
+	},
+	"acryl-workspace": {
+		"name": "workspace",
+		"version": "0.1.0"
+	},
+	"acryl-settings": {
+		"name": "settings",
+		"version": "0.1.0"
+	},
+	"acryl-sign-in": {
+		"name": "sign-in",
+		"version": "0.1.0"
+	},
+	"acryl-control": {
+		"name": "control",
+		"version": "0.2.5"
+	},
+	"acryl-diagnostics": {
+		"name": "diagnostics",
+		"version": "0.1.0"
+	},
+	"acryl-plugin-admin": {
+		"name": "plugin-admin",
+		"version": "0.1.0"
+	},
+	"acryl-support": {
+		"name": "support",
+		"version": "0.1.0"
+	},
+	"acryl-loopback-http": {
+		"name": "loopback-http",
+		"version": "0.1.0"
+	},
+	"acryl-web": {
+		"name": "web",
+		"version": "0.1.0"
+	},
+	"acryl-system-prompt": {
+		"name": "system-prompt",
+		"version": "0.1.0"
+	},
+	"acryl-app-context": {
+		"name": "app-context",
+		"version": "0.1.0"
+	},
+	"acryl-versions": {
+		"name": "versions",
+		"version": "0.1.0"
+	},
+	"acryl-blends-frame": {
+		"name": "blends-frame",
+		"version": "0.1.0"
+	}
+};
+//#endregion
+//#region src/ide-profile.ts
+/**
+* The host an app runs on inside the ACRYL frame: the app's own node server and loader composition, with DSH riding as the chat/session driver
+* (`docs/plans/ide-host-inversion.md`). The overlay (`cordis.patch.yml`) is the app's own layer: the frame's rows, the app's rows and the switches.
+* `scripts/ide-host.mjs` is the launcher: it composes the driver rows from DSH's base and web bundles with this app's layer and boots them on the
+* framework's node server. No DSH profile, no `dsh` launcher, no `dsh plugin add`. Generation is deterministic and idempotent: asking twice writes
+* the same bytes and the second call reports nothing changed, so a template or an upgrade can call it freely.
+*/
+/** Where an app keeps its data, for the plugins that inject `appInstance` (the framework's settings service does): the slice 0 row, kept in the app. */
+const APP_INSTANCE_ROW = `// Generated by acrylblends: the app's own folder family, for the plugins that inject appInstance.
+import { join } from 'node:path'
+
+export const name = 'app-instance'
+
+export function apply(ctx) {
+  ctx.effect(() => {
+    const home = process.env.ACRYLBLENDS_HOME ?? join(process.cwd(), '.acrylblends')
+    const instance = ctx.reflect.provide('appInstance', {
+      root: process.cwd(),
+      home,
+      // The engine home ACRYL's plugins read (support serves \`dshHome/logs\`); in this host the engine and the app share one home.
+      dshHome: home,
+    })
+    return () => {
+      void instance()
+    }
+  }, 'app-instance')
+}
+`;
+/** The packages the frame mounts, in row order: the router pair, the host services, the frame's client plugins. */
+const FRAME_PACKAGES = [
+	{
+		name: "acrylblends/cordis/router",
+		spec: "",
+		row: "acryl-router",
+		installed: true
+	},
+	{
+		name: "acrylblends/cordis/router-http",
+		spec: "",
+		row: "acryl-router-http",
+		installed: true
+	},
+	{
+		name: "acryl-web",
+		spec: ""
+	},
+	{
+		name: "acryl-settings",
+		spec: ""
+	},
+	{
+		name: "acryl-app-shell",
+		spec: ""
+	},
+	{
+		name: "acryl-versions",
+		spec: ""
+	},
+	{
+		name: "acryl-blends-frame",
+		spec: ""
+	},
+	{
+		name: "acryl-plugin-admin",
+		spec: ""
+	},
+	{
+		name: "acryl-system-prompt",
+		spec: ""
+	},
+	{
+		name: "acryl-app-context",
+		spec: ""
+	},
+	{
+		name: "acryl-support",
+		spec: ""
+	},
+	{
+		name: "acryl-sign-in",
+		spec: ""
+	},
+	{
+		name: "dsh-client-ui-brand-acryl",
+		spec: "",
+		row: "ui-brand-acryl",
+		disables: ["ui-brand-official"]
+	}
+];
+/**
+* Where every template's frame row mounts the app (`FRAME_MOUNT_PREFIX` in the template's own source, `/app`). The overlay tells the frame's row, so
+* the frame shows the app's page in its centre; `init-frame` asserts the templates still agree with this constant.
+*/
+const FRAME_PAGE_PREFIX = "/app";
+/**
+* The driver rows the chat and session need, with what they hard-inject, and nothing else of DSH's base or web bundles
+* (`docs/plans/ide-host-inversion.md`, section 4). The composition check proves each one activates; a missing one is a loud failure, never a silent skip.
+*/
+const DRIVER_ROWS = [
+	"connection",
+	"typert",
+	"typert-loader",
+	"typert-gateway",
+	"session",
+	"session-persistence-jsonl",
+	"session-query-sqlite",
+	"session-projection",
+	"session-title",
+	"storage",
+	"storage-json",
+	"storage-domain",
+	"agent",
+	"agent-loop",
+	"agent-default-model",
+	"llm",
+	"llm-retry",
+	"llm-deepseek",
+	"llm-deepseek-account",
+	"llm-pi-ai",
+	"deepseek-account",
+	"credentials",
+	"authorization",
+	"settings",
+	"config-editor",
+	"attachment-local",
+	"file-reference-local",
+	"session-controller",
+	"settings-controller",
+	"api-remotes",
+	"workspace",
+	"workspace-controller",
+	"tools",
+	"system-prompt",
+	"skill",
+	"file-upload",
+	"fs-sandbox",
+	"sandbox-policy",
+	"commands",
+	"fs-observation-policy",
+	"sandbox",
+	"bash-sandbox",
+	"pwsh-sandbox",
+	"approval",
+	"permission",
+	"shell-env",
+	"jobs",
+	"subprocess",
+	"workspace-changes",
+	"message-feedback",
+	"session-stats",
+	"session-turn-outline",
+	"job-controller",
+	"workspace-files",
+	"open-in-app",
+	"session-log-download",
+	"session-reference",
+	"token-meter",
+	"user-questions"
+];
+/**
+* The chat's agent preset. DSH's web bundle gives every session a preset (`standard`: every tool DSH has, subagents, workflows, skills and plan mode, each
+* needing host rows of its own), and a session without a loadable preset cannot start. The frame offers the agent what builds an app, and nothing more:
+* the shell, the file tools (read, write, edit, search) and background jobs, with the persona and the app folder's instructions. It is the registry's
+* default, so every chat in the frame uses it. A tool added here needs the host rows it stands on in `DRIVER_ROWS`.
+*/
+const AGENT_PRESET_ID = "acryl-blends";
+/**
+* The plugins the frame's preset takes from DSH's own `standard` preset, as DSH declares them (config and prompt included), so they follow every DSH
+* bump instead of being restated here: the app's skills (`skill-filesystem` finds `.agents/skills/` in the app folder, the skills `acrylblends` writes
+* there with every app, and `tool-skill` lets the agent load one), plan mode and its `/plan` (`planning`, which ui-plan's plan card and Plan tab show),
+* the To-dos list the composer's dock shows (`tool-todo`), the questions the agent can ask (`tool-ask-user`), and context compaction (`compaction`),
+* whose meter is the footer's context %.
+*/
+const DSH_STANDARD_PLUGINS = [
+	"skill-filesystem",
+	"tool-skill",
+	"planning",
+	"compaction",
+	"tool-ask-user",
+	"tool-todo"
+];
+const AGENT_PRESET_ROWS = [{
+	id: "agent-preset-registry",
+	name: "@deepseek-ai/dsh-agent-preset-registry",
+	config: { default: AGENT_PRESET_ID }
+}, {
+	id: `preset-${AGENT_PRESET_ID}`,
+	name: "@deepseek-ai/dsh-agent-preset",
+	config: {
+		id: AGENT_PRESET_ID,
+		order: 1,
+		plugins: [
+			{
+				id: "persona",
+				name: "@deepseek-ai/dsh-persona",
+				config: {
+					prefix: "You are a coding agent powered by the {{model}} model.",
+					suffix: "Your working directory is {{cwd}}."
+				}
+			},
+			{
+				id: "agent-instructions",
+				name: "@deepseek-ai/dsh-agent-instructions",
+				config: { maxBytes: 65536 }
+			},
+			{
+				id: "tool-bash",
+				name: "@deepseek-ai/dsh-tool-bash",
+				disabled: { __jsExpr: "process.platform === 'win32'" }
+			},
+			{
+				id: "tool-pwsh",
+				name: "@deepseek-ai/dsh-tool-pwsh",
+				disabled: { __jsExpr: "process.platform !== 'win32'" }
+			},
+			{
+				id: "tool-fs",
+				name: "@deepseek-ai/dsh-tool-fs"
+			},
+			{
+				id: "tool-fs-search",
+				name: "@deepseek-ai/dsh-tool-fs-search",
+				config: { sampleOverCapGlobResults: false }
+			},
+			{
+				id: "tool-jobs",
+				name: "@deepseek-ai/dsh-tool-jobs"
+			}
+		]
+	}
+}];
+const CLIENT_ROWS = [
+	{
+		id: "client-modules",
+		name: "@deepseek-ai/dsh-client-modules"
+	},
+	{
+		id: "client-locale",
+		name: "@deepseek-ai/dsh-client-locale"
+	},
+	{
+		id: "client-shortcuts",
+		name: "@deepseek-ai/dsh-client-shortcuts"
+	},
+	{
+		id: "ui-renderer",
+		name: "@deepseek-ai/dsh-client-ui-renderer"
+	},
+	{
+		id: "ui-theme",
+		name: "@deepseek-ai/dsh-client-ui-theme",
+		config: { preference: "dark" }
+	},
+	{
+		id: "ui-settings",
+		name: "@deepseek-ai/dsh-client-ui-settings"
+	},
+	{
+		id: "ui-settings-general",
+		name: "@deepseek-ai/dsh-client-ui-settings-general"
+	},
+	{
+		id: "ui-settings-models",
+		name: "@deepseek-ai/dsh-client-ui-settings-models"
+	},
+	{
+		id: "ui-session",
+		name: "@deepseek-ai/dsh-client-ui-session"
+	},
+	{
+		id: "ui-sidebar-right",
+		name: "@deepseek-ai/dsh-client-ui-sidebar-right"
+	},
+	{
+		id: "ui-sidebar-documentpreview",
+		name: "@deepseek-ai/dsh-client-ui-sidebar-documentpreview"
+	},
+	{
+		id: "ui-commands",
+		name: "@deepseek-ai/dsh-client-ui-commands"
+	},
+	{
+		id: "ui-workspace",
+		name: "@deepseek-ai/dsh-client-ui-workspace"
+	},
+	{
+		id: "ui-conversation",
+		name: "@deepseek-ai/dsh-client-ui-conversation"
+	},
+	{
+		id: "ui-chat",
+		name: "@deepseek-ai/dsh-client-ui-chat"
+	},
+	{
+		id: "ui-tool",
+		name: "@deepseek-ai/dsh-client-ui-tool"
+	},
+	{
+		id: "ui-approval",
+		name: "@deepseek-ai/dsh-client-ui-approval"
+	},
+	{
+		id: "ui-attachment",
+		name: "@deepseek-ai/dsh-client-ui-attachment"
+	},
+	{
+		id: "ui-shortcuts",
+		name: "@deepseek-ai/dsh-client-ui-shortcuts"
+	},
+	{
+		id: "ui-workflow-run",
+		name: "@deepseek-ai/dsh-client-ui-workflow-run"
+	},
+	{
+		id: "ui-skill",
+		name: "@deepseek-ai/dsh-client-ui-skill"
+	},
+	{
+		id: "ui-subagent",
+		name: "@deepseek-ai/dsh-client-ui-subagent"
+	},
+	{
+		id: "ui-reference",
+		name: "@deepseek-ai/dsh-client-ui-reference"
+	},
+	{
+		id: "ui-jobs",
+		name: "@deepseek-ai/dsh-client-ui-jobs"
+	},
+	{
+		id: "ui-goal",
+		name: "@deepseek-ai/dsh-client-ui-goal"
+	},
+	{
+		id: "ui-message-feedback",
+		name: "@deepseek-ai/dsh-client-ui-message-feedback"
+	},
+	{
+		id: "ui-model-selection",
+		name: "@deepseek-ai/dsh-client-ui-model-selection"
+	},
+	{
+		id: "ui-permission",
+		name: "@deepseek-ai/dsh-client-ui-permission-presets"
+	},
+	{
+		id: "ui-agent-preset",
+		name: "@deepseek-ai/dsh-client-ui-agent-preset"
+	},
+	{
+		id: "ui-settings-session-log",
+		name: "@deepseek-ai/dsh-client-ui-settings-session-log"
+	},
+	{
+		id: "ui-user-questions",
+		name: "@deepseek-ai/dsh-client-ui-user-questions"
+	},
+	{
+		id: "ui-trajectory",
+		name: "@deepseek-ai/dsh-client-ui-trajectory"
+	},
+	{
+		id: "ui-deliverables",
+		name: "@deepseek-ai/dsh-client-ui-deliverables"
+	},
+	{
+		id: "ui-plan",
+		name: "@deepseek-ai/dsh-client-ui-plan"
+	},
+	{
+		id: "ui-open-in-app",
+		name: "@deepseek-ai/dsh-client-ui-open-in-app"
+	},
+	{
+		id: "client-resources",
+		name: "@deepseek-ai/dsh-client-resources"
+	},
+	{
+		id: "ui-input-trigger",
+		name: "@deepseek-ai/dsh-client-ui-input-trigger"
+	}
+];
+/** The array literal a host script writes for its rows (`const clientRows = [...];`, JSON at two spaces). */
+const CLIENT_ROWS_BLOCK = /const clientRows = (\[[\s\S]*?\n\])/u;
+/** The client rows a host script names, or undefined when its array cannot be read. */
+function parseHostClientRows(hostText) {
+	const match = CLIENT_ROWS_BLOCK.exec(hostText);
+	if (match?.[1] === void 0) return void 0;
+	try {
+		const parsed = JSON.parse(match[1]);
+		if (!Array.isArray(parsed)) return void 0;
+		return parsed.filter((row) => row !== null && typeof row === "object" && typeof row.id === "string" && typeof row.name === "string");
+	} catch {
+		return;
+	}
+}
+/**
+* Add the client rows the current host script names and the app's host script does not, keeping every row the app has exactly as it is: a person's
+* own row, or one whose config they changed. The app's rows keep their order; the missing current rows follow; the rest of the host script is the
+* current one. An app without a host script (a new app) or with an unreadable array gets the current script as it is.
+* @param currentHost - the host script the CLI generates now.
+* @param appHost - the app's existing host script, when it has one.
+* @returns the text to write and the row names it added.
+*/
+function mergeHostClientRows(currentHost, appHost) {
+	if (appHost === void 0) return {
+		text: currentHost,
+		added: []
+	};
+	const current = parseHostClientRows(currentHost);
+	const app = parseHostClientRows(appHost);
+	if (current === void 0 || app === void 0) return {
+		text: currentHost,
+		added: []
+	};
+	const names = new Set(app.map((row) => row.name));
+	const missing = current.filter((row) => !names.has(row.name));
+	const block = CLIENT_ROWS_BLOCK.exec(currentHost);
+	if (block === null) return {
+		text: currentHost,
+		added: []
+	};
+	const merged = [...app, ...missing];
+	return {
+		text: currentHost.replace(block[0], `const clientRows = ${JSON.stringify(merged, null, 2)}`),
+		added: missing.map((row) => row.name)
+	};
+}
+/**
+* `scripts/ide-host.mjs`: the app's launcher. It boots the framework's node server and the webServer port the driver rows register on, then the frame
+* layer, and mounts DSH's driver rows from the base and web bundles (only the ids in `DRIVER_ROWS`) as ordinary rows of this composition. `--check`
+* audits the composition (every row active) and disposes it, for the gate.
+*/
+function hostScriptOf(profile, frameModule) {
+	return [
+		"// Generated by acrylblends: boots this app inside the ACRYL frame on the app's own node server. Regenerate instead of editing.",
+		"import { existsSync, mkdirSync, readFileSync, renameSync, writeFileSync } from 'node:fs'",
+		"import { chmodSync } from 'node:fs'",
+		"import { spawnSync } from 'node:child_process'",
+		"import { randomBytes, timingSafeEqual } from 'node:crypto'",
+		"import { createRequire } from 'node:module'",
+		"import { dirname, isAbsolute, join, resolve } from 'node:path'",
+		"import { fileURLToPath, pathToFileURL } from 'node:url'",
+		"import { DEFAULT_SCHEMA, dump as dumpYaml, Type, load as parseYaml } from 'js-yaml'",
+		"import { Acryl } from 'acrylblends'",
+		"",
+		"const appRoot = join(dirname(fileURLToPath(import.meta.url)), '..')",
+		`const profileName = '${profile}'`,
+		"const home = process.env.ACRYLBLENDS_HOME ?? join(appRoot, '.acrylblends')",
+		"// DSH's rows keep their files in this app's own home: set before any driver row is imported.",
+		"process.env.DSH_HOME = home",
+		"// Development only: the app's code can be loaded again in this host (a version gone back to, a file written by the chat, an agent or an editor). Every file",
+		"// of the app's src/ then resolves under a generation the frame's Host raises, so nothing but the app's own rows restarts. Before anything of the app loads;",
+		"// a frame package that predates the hook leaves the code as it started.",
+		"try {",
+		`  const { installAppGeneration } = await import('${frameModule}/app-generation')`,
+		"  installAppGeneration({ appRoot })",
+		"} catch (error) {",
+		"  if (error?.code !== 'ERR_PACKAGE_PATH_NOT_EXPORTED' && error?.code !== 'ERR_MODULE_NOT_FOUND') throw error",
+		"}",
+		"// Before any DSH module is imported: its home resolution reads the environment at import time.",
+		"const { boot } = await import('@deepseek-ai/dsh-app-boot')",
+		"// The frame listens where the app's own server would: the folder's stable port (or the home's, when ACRYLBLENDS_HOME pins one). A restart then",
+		"// keeps the page's origin, its auth cookie and its tabs; ACRYLBLENDS_PORT still decides, and the gates pass 0 for any free port.",
+		"const { selectInstance } = await import(new URL('../plugins/instance/index.ts', import.meta.url).href)",
+		"const port = String(selectInstance({ projectRoot: appRoot, env: process.env }).port.start)",
+		"const check = process.argv.includes('--check')",
+		"const require = createRequire(import.meta.url)",
+		"/** The `!!js` tag the loader evaluates: js-yaml needs the same type the Cordis include plugin declares. */",
+		"const JsExpr = new Type('tag:yaml.org,2002:js', {",
+		"  kind: 'scalar',",
+		"  construct: (data) => ({ __jsExpr: data }),",
+		"  represent: (data) => data.__jsExpr,",
+		"})",
+		"const load = (text) => parseYaml(text, { schema: DEFAULT_SCHEMA.extend([JsExpr]) })",
+		"",
+		"/** An insert names its module beside the patch file that named it (the loader rule, and the rule DSH applies when it reads a profile again). The",
+		" * composition is read as the profile bundle, from its own directory, so a row written relative would turn into a bundle-relative path the first time",
+		" * DSH reconciles the profile (any Settings write) and the app rows would stop loading. Anchoring each layer at the directory it was written for",
+		" * keeps one row meaning one file: boot, a Settings write and the frame reload then import the same absolute URL. */",
+		"function anchorRows(patches, baseDir) {",
+		"  const visit = (row) => {",
+		"    if (typeof row.name === 'string' && (isAbsolute(row.name) || row.name.startsWith('./') || row.name.startsWith('../')))",
+		"      row.name = pathToFileURL(resolve(baseDir, row.name)).href",
+		"    if (row.group && Array.isArray(row.config)) row.config.forEach(visit)",
+		"  }",
+		"  for (const patch of patches) patch.insert?.forEach(visit)",
+		"  return patches",
+		"}",
+		"",
+		"/** The driver rows above are selected from the bundles by id; nothing else of DSH is mounted. */",
+		`const DRIVER_ROWS = ${JSON.stringify(DRIVER_ROWS, null, 2).replaceAll("\n", "\n")}`,
+		"",
+		"/** A bundle's patch files, in application order, as the package declares them, anchored beside that package (a relative name in a bundle is its own file). */",
+		"function bundlePatches(packageName) {",
+		"  const dir = dirname(require.resolve(packageName + '/package.json'))",
+		"  const manifest = JSON.parse(readFileSync(join(dir, 'package.json'), 'utf8'))",
+		"  const files = manifest.dsh?.bundle?.patch",
+		"  const list = typeof files === 'string' ? [files] : Array.isArray(files) ? files : []",
+		"  return anchorRows(list.flatMap((file) => load(readFileSync(join(dir, file), 'utf8')) ?? []), dir)",
+		"}",
+		"",
+		"/** Keep only the driver rows: insert lists filtered entry by entry, id-targeted patches only when they hit a driver row. */",
+		"function onlyDriverRows(patches) {",
+		"  const kept = []",
+		"  for (const patch of patches) {",
+		"    if (Array.isArray(patch.insert)) {",
+		"      const insert = patch.insert.filter((entry) => DRIVER_ROWS.includes(entry.id))",
+		"      if (insert.length > 0) kept.push({ ...patch, insert })",
+		"    } else if (typeof patch.id === 'string' && DRIVER_ROWS.includes(patch.id)) kept.push(patch)",
+		"  }",
+		"  return kept",
+		"}",
+		"",
+		"const frameLayer = anchorRows(load(readFileSync(join(appRoot, 'cordis.patch.yml'), 'utf8')) ?? [], appRoot)",
+		"/** Our host rows first: the framework's node server, then the webServer port the driver rows register on (they are the app's, not DSH's). */",
+		`const clientRows = ${JSON.stringify(CLIENT_ROWS, null, 2).replaceAll("\\n", "\\n")}`,
+		`const agentRows = ${JSON.stringify(AGENT_PRESET_ROWS, null, 2)}`,
+		`const DSH_STANDARD_PLUGINS = ${JSON.stringify(DSH_STANDARD_PLUGINS)}`,
+		"/** One plugin row of DSH's `standard` preset, exactly as DSH's web bundle declares it; a missing one fails the boot loudly. */",
+		"function dshStandardPlugin(id) {",
+		"  for (const patch of bundlePatches('@deepseek-ai/dsh-web-app'))",
+		"    for (const entry of patch.insert ?? [])",
+		"      if (entry.config?.id === 'standard') {",
+		"        const found = entry.config.plugins?.find((plugin) => plugin.id === id)",
+		"        if (found !== undefined) return found",
+		"      }",
+		"  throw new Error(`DSH's standard preset has no ${id} row`)",
+		"}",
+		`agentRows.find((row) => row.id === 'preset-${AGENT_PRESET_ID}').config.plugins.push(...DSH_STANDARD_PLUGINS.map(dshStandardPlugin))`,
+		"const hostLayer = anchorRows([{",
+		"  insert: [",
+		"    { id: 'node-server', name: './plugins/acryl-node-server/src/index.ts', config: { hostname: '127.0.0.1', port: Number(port), scan: Number(port) === 0 ? 0 : 20 } },",
+		"    { id: 'web-server', name: './plugins/acryl-web-server/src/index.ts' },",
+		"    { id: 'page', name: './plugins/acryl-page/src/index.ts' },",
+		"    ...clientRows,",
+		"    ...agentRows,",
+		"  ],",
+		"}], appRoot)",
+		"// The composition: the driver rows selected from the bundles, the host rows and the app's frame layer, in the order they mount.",
+		"const composition = [",
+		"  ...onlyDriverRows(bundlePatches('@deepseek-ai/dsh-base')),",
+		"  ...onlyDriverRows(bundlePatches('@deepseek-ai/dsh-web-app')),",
+		"  ...hostLayer,",
+		"  ...frameLayer,",
+		"]",
+		"",
+		"// The app's DSH profile, which DSH's Settings, config editor and plugin manager read and write (docs/plans/ide-host-inversion.md, section 20):",
+		"// - package.json: the profile manifest (no DSH bundles; the composition is ours), created once when the app has none.",
+		"// - cordis.patch.yml: the composition, regenerated on every boot from the layers above, so an upgrade or a framework bump never leaves a stale copy.",
+		"// - settings.patch.yml: the profile patch document ProfileContext.patchPath points at. Only the config editor writes it; the host creates it empty",
+		"//   when missing and never rewrites it, so the Settings edits of the app survive a boot, an upgrade and a framework bump.",
+		"mkdirSync(home, { recursive: true })",
+		"const manifestPath = join(home, 'package.json')",
+		"// The composition is a profile bundle: bundle layers are applied before the profile patch document, so a Settings edit always wins over a row the",
+		"// composition also configures. DSH resolves it from the profile directory like any installed bundle, and the launcher rewrites it on every boot.",
+		"const bundleDir = join(home, 'node_modules', 'acrylblends-frame')",
+		"mkdirSync(bundleDir, { recursive: true })",
+		"writeFileSync(join(bundleDir, 'package.json'), `${JSON.stringify({ name: 'acrylblends-frame', version: '0.0.0', private: true, dsh: { bundle: { patch: 'cordis.patch.yml' } } }, null, 2)}\\n`)",
+		"const compositionHeader =",
+		"  \"# Generated by acrylblends: the host composition of this app, a profile bundle. Rewritten on every boot from the launcher layers; do not edit. Settings live in settings.patch.yml.\\n\"",
+		"writeFileSync(join(bundleDir, 'cordis.patch.yml'), compositionHeader + dumpYaml(composition, { schema: DEFAULT_SCHEMA.extend([JsExpr]), noRefs: true }))",
+		"writeFileSync(manifestPath, `${JSON.stringify({ name: profileName, private: true, dependencies: { 'acrylblends-frame': '0.0.0' }, dsh: { profile: { bundles: ['acrylblends-frame'] } } }, null, 2)}\\n`)",
+		"const settingsPath = join(home, 'settings.patch.yml')",
+		"if (!existsSync(settingsPath)) writeFileSync(settingsPath, '[]\\n')",
+		"",
+		"// Boot reads the same list readProfilePatches will: the composition bundle first, then the settings document, which is also the order DSH uses for",
+		"// bundles and the profile patch, so the first reconcile is a no-op recomposition and every later one differs only by the edited patch.",
+		"const compositionLayer = load(readFileSync(join(bundleDir, 'cordis.patch.yml'), 'utf8')) ?? []",
+		"const settingsLayer = anchorRows(load(readFileSync(settingsPath, 'utf8')) ?? [], home)",
+		"/** The profile context DSH's settings row, config editor and plugin manager read. */",
+		"const profileContext = {",
+		"  name: 'web',",
+		"  dir: home,",
+		"  patchPath: settingsPath,",
+		"  installAnchor: join(appRoot, 'package.json'),",
+		"  cwd: appRoot,",
+		"  home,",
+		"  startedBundles: [],",
+		"  overlays: [],",
+		"  telemetryDisabledEnv: process.env.DSH_TELEMETRY_DISABLED,",
+		"}",
+		"const layers = [compositionLayer, settingsLayer]",
+		"let ctx",
+		"try {",
+		"  ctx = await boot('" + profile + "', join(appRoot, 'cordis.yml'), layers.flat(), (hostContext) => {",
+		"    hostContext.provide('profileContext', profileContext)",
+		"  }, pathToFileURL(join(appRoot, 'package.json')).href)",
+		"} catch (error) {",
+		"  // A row that fails before it has a plugin (a module that is not one, an import that throws) is reported as 'failed to import' with no cause; the boot's",
+		"  // StartupError carries the original failures. Print each one, by row id and module, then fail: a silent half-composed host is never an option.",
+		"  const entries = Array.isArray(error?.entries) ? error.entries : []",
+		"  const failures = entries.filter(({ outcome }) => outcome?.kind === \"failed\")",
+		"  console.error(`acrylblends host: startup failed (${String(failures.length)} row(s))`)",
+		"  for (const { entry, outcome } of failures) {",
+		"    const cause = outcome.error",
+		"    const detail = cause instanceof Error ? cause.stack ?? cause.message : String(cause)",
+		"    console.error(`- ${entry.id} (${entry.options?.name ?? \"?\"}): ${detail}`)",
+		"  }",
+		"  const cause = error?.cause",
+		"  if (failures.length === 0 && cause !== undefined) console.error(cause instanceof Error ? cause.stack ?? cause.message : String(cause))",
+		"  process.exit(1)",
+		"}",
+		"const server = ctx.get('nodeServer')",
+		"const connection = ctx.get('connection')",
+		"// The frame listens on a stable port; its launch token is made stable the same way: the address of the previous run is read back and the connection",
+		"// is given that token, so a restart keeps the same URL and an open page - even one whose cookie was lost - comes back by reloading it. The record is",
+		"// the launcher own bookkeeping (the installed framework may predate `acrylblends open`), so it is read and written here: owner-only (0600, and a",
+		"// restricted ACL on Windows), a temp file renamed over the old one. The token lives in the connection instance field DSH reads on every check;",
+		"// nothing in the pinned package is edited, and a connection without that field keeps the token the process minted.",
+		"const frameRecordPath = join(home, 'frame-url.json')",
+		"function readFrameRecord() {",
+		"  try {",
+		"    return JSON.parse(readFileSync(frameRecordPath, \"utf8\"))",
+		"  } catch {",
+		"    return undefined",
+		"  }",
+		"}",
+		"function restrictFrameRecord(path) {",
+		"  chmodSync(path, 0o600)",
+		"  if (process.platform !== \"win32\" || !process.env.USERNAME) return",
+		"  spawnSync(\"icacls\", [path, \"/inheritance:r\", \"/grant:r\", `${process.env.USERNAME}:F`], { stdio: \"ignore\", windowsHide: true })",
+		"}",
+		"function writeFrameRecord(url) {",
+		"  let token = \"\"",
+		"  try {",
+		"    token = new URL(url).searchParams.get(\"token\") ?? \"\"",
+		"  } catch {}",
+		"  mkdirSync(home, { recursive: true })",
+		"  const temporary = `${frameRecordPath}.${String(process.pid)}.tmp`",
+		"  writeFileSync(temporary, JSON.stringify({ version: 1, url, token, pid: process.pid, writtenAt: new Date().toISOString() }, null, 2) + \"\\n\", { mode: 0o600 })",
+		"  restrictFrameRecord(temporary)",
+		"  renameSync(temporary, frameRecordPath)",
+		"  restrictFrameRecord(frameRecordPath)",
+		"}",
+		"const connectionAuth = connection !== undefined && typeof connection === \"object\" ? connection.browserAuth : undefined",
+		"const previousAddress = readFrameRecord()",
+		"const reusedToken = connectionAuth !== undefined && typeof connectionAuth.launchToken === \"string\" && previousAddress !== undefined && typeof previousAddress.token === \"string\" && previousAddress.token !== \"\"",
+		"if (reusedToken) connectionAuth.launchToken = previousAddress.token",
+		"// The chat's remote RPC is token-authenticated: the printed URL carries the launch token, and the page exchange turns it into a cookie.",
+		"const url = server === undefined ? undefined : connection === undefined ? server.url : connection.authenticatedUrl(server.url)",
+		"console.log(`acrylblends host: ${url ?? 'no node server'}`)",
+		"// `acrylblends open` prints the record back; a stopped host leaves it behind on purpose, so the command can say the frame is not running instead of",
+		"// pretending the app never ran one.",
+		"if (url !== undefined) {",
+		"  try {",
+		"    writeFrameRecord(url)",
+		"  } catch (error) {",
+		"    console.error(`acrylblends host: could not write the frame address: ${String(error)}`)",
+		"  }",
+		"  // `acrylblends open --new` rotates the token in the running host: the stored token presents itself, the connection gets a new one, the new address is",
+		"  // written and answered; every other request is refused.",
+		"  const frameRouter = ctx.get(\"router\")",
+		"  const frameRouterHttp = ctx.get(\"routerHttp\")",
+		"  if (frameRouter !== undefined && frameRouterHttp !== undefined && connectionAuth !== undefined && typeof connectionAuth.launchToken === \"string\") {",
+		"    const sameToken = (actual, expected) => {",
+		"      const a = Buffer.from(String(actual), \"utf8\")",
+		"      const b = Buffer.from(String(expected), \"utf8\")",
+		"      return a.byteLength === b.byteLength && timingSafeEqual(a, b)",
+		"    }",
+		"    const rotate = () => {",
+		"      connectionAuth.launchToken = randomBytes(32).toString(\"base64url\")",
+		"      const next = connection.authenticatedUrl(server.url)",
+		"      writeFrameRecord(next)",
+		"      return next",
+		"    }",
+		"    frameRouter.route(\"/api/acryl-frame\", new Acryl().post(\"/token/new\", (c) => {",
+		"      const presented = c.req.header(\"x-frame-token\") ?? \"\"",
+		"      if (!sameToken(presented, connectionAuth.launchToken)) return c.text(\"forbidden\", 403)",
+		"      return c.json({ url: rotate() })",
+		"    }))",
+		"    frameRouterHttp.mount(\"/api/acryl-frame\")",
+		"  }",
+		"}",
+		"if (previousAddress !== undefined && !reusedToken && url !== undefined) {",
+		"  console.warn(\"acrylblends host: the stored frame address could not be reused on this boot; a new one was minted\")",
+		"}",
+		"if (check) {",
+		"  const loader = ctx.get('loader')",
+		"  const rows = [...loader.entries()]",
+		"  const stalled = []",
+		"  for (const row of rows) {",
+		"    const state = row.fiber?.state",
+		"    if (row.disabled) continue",
+		"    if (state !== 2 && state !== 4) stalled.push(`${row.id} (${row.options.name}): ${state === undefined ? 'no fiber' : String(state)}`)",
+		"  }",
+		"  const webRows = rows.filter((row) => /(^|\\/)(host-webserver|web-app|web-frontend)$/u.test(row.options.name))",
+		"  if (stalled.length > 0 || webRows.length > 0) {",
+		"    console.error('acrylblends host: composition check failed')",
+		"    for (const line of stalled) console.error(`- not active: ${line}`)",
+		"    for (const row of webRows) console.error(`- a DSH web row is mounted: ${row.id} (${row.options.name})`)",
+		"    process.exitCode = 1",
+		"  } else {",
+		"    console.log(`acrylblends host: every row active (${String(rows.length)} rows), no DSH web row mounted`)",
+		"  }",
+		"  // The Cordis way: a provider removed puts its consumer PENDING, restoring it activates it again; a reload adds nothing twice.",
+		"  // The rows live under the include entry (the launcher mounts one config file), so an id is found by its last segment.",
+		"  const findRow = (id) => rows.find((row) => row.id === id || row.id.endsWith(`:${id}`))",
+		"  const stateOf = (id) => findRow(id)?.fiber?.state",
+		"  await loader.update(findRow('credentials').id, { disabled: true })",
+		"  await loader.await()",
+		"  const pendingAfterRemoval = stateOf('connection') === 0",
+		"  await loader.update(findRow('credentials').id, { disabled: false })",
+		"  await loader.await()",
+		"  const activeAfterRestore = stateOf('connection') === 2",
+		"  for (let round = 0; round < 2; round += 1) {",
+		"    await loader.update(findRow('session-title').id, { disabled: true })",
+		"    await loader.update(findRow('session-title').id, { disabled: false })",
+		"    await loader.await()",
+		"  }",
+		"  const reloaded = stateOf('session-title') === 2",
+		"  if (!pendingAfterRemoval || !activeAfterRestore || !reloaded) {",
+		"    console.error(`acrylblends host: lifecycle check failed (pending ${String(pendingAfterRemoval)}, restored ${String(activeAfterRestore)}, reloaded ${String(reloaded)})`)",
+		"    process.exitCode = 1",
+		"  } else {",
+		"    console.log('acrylblends host: PENDING on provider removal, active on restore, two reloads clean')",
+		"  }",
+		"  await ctx.fiber.dispose()",
+		"} else {",
+		"  for (const signal of ['SIGINT', 'SIGTERM']) process.once(signal, () => { void ctx.fiber.dispose() })",
+		"}",
+		""
+	].join("\n");
+}
+function frameModuleOf(packages) {
+	return packages.find((entry) => (entry.row ?? entry.name) === "acryl-blends-frame")?.name ?? "acryl-blends-frame";
+}
+/** `acrylblends-<app>`, safe for a DSH profile name: lowercase, dashes, nothing else. */
+function profileNameFor(appName) {
+	const slug = appName.toLowerCase().replaceAll(/[^a-z0-9]+/gu, "-").replaceAll(/^-+|-+$/gu, "");
+	return `acrylblends-${slug === "" ? "app" : slug}`;
+}
+/** A package name as a YAML scalar: a scoped name starts with `@`, which YAML reserves at the start of a scalar, so it is quoted. */
+const yamlName = (name) => name.startsWith("@") ? `'${name}'` : name;
+function overlayOf(packages, door = false, appRows = []) {
+	const rows = packages;
+	const disabled = new Set(packages.flatMap((entry) => entry.disables ?? []));
+	const lines = [
+		"# Generated by acrylblends: the DSH overlay that mounts the ACRYL frame. Regenerate instead of editing.",
+		"- insert:",
+		"    - id: app-instance",
+		"      name: ./app/runtime.mjs",
+		...door ? [
+			"    - id: acryl-door",
+			"      name: ./plugins/acryl-door/src/index.ts",
+			"      config:",
+			"        hostIndex: false",
+			`        appBase: ${FRAME_PAGE_PREFIX}`
+		] : [],
+		...appRows.flatMap((row) => [
+			`    - id: ${row.id}`,
+			`      name: ${row.name}`,
+			...row.isolate === void 0 ? [] : [`      isolate: ${JSON.stringify(row.isolate)}`]
+		])
+	];
+	for (const entry of rows) {
+		lines.push(`    - id: ${entry.row ?? entry.name}`, `      name: ${yamlName(entry.name)}`);
+		if ((entry.row ?? entry.name) === "acryl-blends-frame") lines.push("      config:", `        appPage: ${FRAME_PAGE_PREFIX}`);
+	}
+	lines.push("- id: connection", "  inject: []", "  config:", "    trustedHosts: ['127.0.0.1']");
+	lines.push("- id: workspace-controller", "  config:", "    documentsDirectory: !!js process.env.ACRYLBLENDS_HOME ?? process.cwd() + '/.acrylblends'");
+	for (const id of [...disabled].sort()) lines.push(`- id: ${id}`, "  disabled: true");
+	return `${lines.join("\n")}\n`;
+}
+/**
+* The files a fresh app's profile needs, without touching the disk: the overlay text and the app's `package.json` with the DSH pin, the framework, the
+* frame packages and a `dev` script on the app's own profile. An existing `package.json` keeps its keys; only the generated fields are set.
+*/
+function ideProfilePlan(input, existing) {
+	const profile = profileNameFor(input.appName);
+	const packages = (input.packages ?? FRAME_PACKAGES).map((entry) => ({
+		...entry,
+		spec: entry.spec === "" ? input.spec?.(entry.row ?? entry.name) ?? "" : entry.spec
+	}));
+	const dependencies = {
+		"@deepseek-ai/cordis": "4.0.5",
+		"@deepseek-ai/cordis-plugin-loader": "~1.0.6",
+		"@deepseek-ai/dsh-app-boot": input.dshVersion,
+		"@deepseek-ai/dsh-base": input.dshVersion,
+		"@deepseek-ai/dsh-web-app": input.dshVersion,
+		acrylblends: input.frameworkVersion,
+		"js-yaml": "^4.2.0",
+		...input.dependencies
+	};
+	for (const entry of packages) if (entry.installed !== true && entry.spec !== "") dependencies[entry.name] = entry.spec;
+	const manifest = existing === void 0 ? {
+		name: input.appName,
+		private: true,
+		type: "module"
+	} : JSON.parse(existing);
+	return {
+		profile,
+		overlay: overlayOf(packages, input.door === true, input.rows ?? []),
+		packageJson: `${JSON.stringify(mergeManifest(manifest, dependencies), null, 2)}\n`,
+		rootConfig: "[]\n",
+		hostScript: hostScriptOf(profile, frameModuleOf(packages))
+	};
+}
+/** The app's manifest with the generated fields set: dependencies merged (generated wins), the dev script on its own profile, keys in a stable order. */
+function mergeManifest(manifest, dependencies) {
+	const sorted = Object.fromEntries(Object.entries(dependencies).sort(([a], [b]) => a.localeCompare(b)));
+	const scripts = {
+		...manifest.scripts,
+		dev: "node --import ./plugins/acryl-node-server/src/register.ts scripts/ide-host.mjs"
+	};
+	return {
+		...manifest,
+		dependencies: {
+			...manifest.dependencies,
+			...sorted
+		},
+		scripts
+	};
+}
+/**
+* The first line of every file this module generates. `acrylblends upgrade` uses it to tell a file it may rewrite from one the app wrote (a hand-made
+* `cordis.patch.yml` for DSH, say): a file without the marker is refused, never overwritten.
+*/
+const GENERATED_MARKER = /^(?:#|\/\/) Generated by acrylblends:/u;
+/** The generated files, in the order this module writes them, with the plan field each one's text comes from. */
+const GENERATED_FILES = [
+	{
+		file: "cordis.patch.yml",
+		of: (plan) => plan.overlay
+	},
+	{
+		file: "cordis.yml",
+		of: (plan) => plan.rootConfig
+	},
+	{
+		file: "scripts/ide-host.mjs",
+		of: (plan) => plan.hostScript
+	},
+	{
+		file: "app/runtime.mjs",
+		of: () => APP_INSTANCE_ROW
+	}
+];
+/** The door is app source, not a registry package: the row exists when the app carries it, and nothing fails when it does not. */
+function withDoor(root, input) {
+	return {
+		...input,
+		door: existsSync(join(root, "plugins", "acryl-door", "src", "index.ts"))
+	};
+}
+/**
+* Plan writing the profile into `root`, which may already hold an app: a file this module generated (its first line carries the marker) is an `update`, a
+* file the app wrote is a `conflict` and must be refused by the caller, a missing file is an `add`. The bytes are exactly what `applyIdeProfile` writes.
+*/
+function planIdeProfileWrite(root, input) {
+	const manifestFile = join(root, "package.json");
+	const existing = existsSync(manifestFile) ? readFileSync(manifestFile, "utf8") : void 0;
+	const plan = ideProfilePlan(withDoor(root, input), existing);
+	const hostPath = join(root, "scripts/ide-host.mjs");
+	const appHost = existsSync(hostPath) ? readFileSync(hostPath, "utf8") : void 0;
+	let clientRowsAdded = [];
+	return {
+		plan,
+		files: GENERATED_FILES.map(({ file, of }) => {
+			let text = of(plan);
+			if (file === "scripts/ide-host.mjs") {
+				const merged = mergeHostClientRows(text, appHost);
+				text = merged.text;
+				clientRowsAdded = merged.added;
+			}
+			const path = join(root, file);
+			if (!existsSync(path)) return {
+				file,
+				text,
+				state: "add"
+			};
+			const before = readFileSync(path, "utf8");
+			if (before === text) return {
+				file,
+				text,
+				state: "same"
+			};
+			const firstLine = before.split("\n", 1)[0] ?? "";
+			return {
+				file,
+				text,
+				state: GENERATED_MARKER.test(firstLine) ? "update" : "conflict"
+			};
+		}),
+		manifestChanged: existing !== plan.packageJson,
+		clientRowsAdded
+	};
+}
+/** Write a plan made by {@link planIdeProfileWrite}: only the files whose bytes differ, and `package.json` only when the merge changes it. */
+function writeIdeProfilePlan(root, planned) {
+	const written = [];
+	const unchanged = [];
+	for (const file of planned.files) {
+		if (file.state === "same") {
+			unchanged.push(file.file);
+			continue;
+		}
+		const path = join(root, file.file);
+		mkdirSync(dirname(path), { recursive: true });
+		writeFileSync(path, file.text);
+		written.push(file.file);
+	}
+	if (planned.manifestChanged) {
+		writeFileSync(join(root, "package.json"), planned.plan.packageJson);
+		written.push("package.json");
+	} else unchanged.push("package.json");
+	return {
+		written,
+		unchanged
+	};
+}
+/**
+* Write the profile into `root`: `cordis.patch.yml` and the app's `package.json`. Idempotent: a file whose bytes are already the generated ones is not
+* touched, so a second run reports it under `unchanged` and the git working tree stays clean.
+*/
+function applyIdeProfile(root, input) {
+	mkdirSync(root, { recursive: true });
+	return writeIdeProfilePlan(root, planIdeProfileWrite(root, input));
+}
+//#endregion
+//#region src/version.ts
+/** The version of this package. */
+const VERSION = createRequire(import.meta.url)("../package.json").version;
+/** The DSH release the frame's packages pin as peers, so an app's DSH pin is the same one. */
+const FRAME_DSH_VERSION = dshVersion;
+/** Every package the frame publishes, in the file's order. */
+const FRAME_RELEASE = Object.entries(packages).map(([source, entry]) => ({
+	source,
+	name: `${scope}/${entry.name}`,
+	version: entry.version
+}));
+/** `ACRYLBLENDS_FRAME_PACKAGES=none`: the app runs on the framework alone, whatever the default would be. */
+const FRAMEWORK_ONLY = "framework-only";
+/**
+* The frame's specs from npm: every row package by its published name at a caret over its released version, the DSH pin the packages are built against,
+* and this CLI's own release as the framework. A row package the file does not name is an error (the CLI tests catch it), never a silent skip.
+*/
+function publishedFrameProfile() {
+	const bySource = new Map(FRAME_RELEASE.map((entry) => [entry.source, entry]));
+	const packages = {};
+	const names = {};
+	for (const entry of FRAME_PACKAGES) {
+		if (entry.installed === true) continue;
+		const published = bySource.get(entry.name);
+		if (published === void 0) throw new Error(`frame/packages.json does not name the frame row ${entry.name}`);
+		packages[entry.name] = `^${published.version}`;
+		names[entry.name] = published.name;
+	}
+	return {
+		dshVersion: FRAME_DSH_VERSION,
+		frameworkVersion: `^${VERSION}`,
+		packages,
+		names
+	};
+}
+/** `ACRYLBLENDS_FRAME_PACKAGES`: specs (a checkout's build), {@link FRAMEWORK_ONLY} for `none`, undefined when unset or malformed. */
+function frameProfileFromEnv() {
+	const raw = process.env.ACRYLBLENDS_FRAME_PACKAGES;
+	if (raw === void 0 || raw.trim() === "") return void 0;
+	if (raw.trim() === "none") return FRAMEWORK_ONLY;
+	try {
+		const parsed = JSON.parse(raw);
+		if (typeof parsed.dshVersion !== "string" || typeof parsed.frameworkVersion !== "string") return void 0;
+		const packages = {};
+		for (const [key, value] of Object.entries(parsed.packages ?? {})) if (typeof value === "string") packages[key] = value;
+		return {
+			dshVersion: parsed.dshVersion,
+			frameworkVersion: parsed.frameworkVersion,
+			packages
+		};
+	} catch {
+		return;
+	}
+}
+/** The specs a new app's frame installs: the environment's, else npm's for a desktop app; undefined leaves the app on the framework alone. */
+function frameProfileForInit(desktop) {
+	const fromEnv = frameProfileFromEnv();
+	if (fromEnv === "framework-only") return void 0;
+	return fromEnv ?? (desktop ? publishedFrameProfile() : void 0);
+}
+/**
+* The specs for an app that may or may not be framed already: the environment first, then the app's own `package.json` (a framed app carries the DSH
+* pin, the framework and the frame packages, by their source or published names), then npm's for a desktop app (one with `plugins/desktop`).
+* Undefined when none applies: the caller then leaves the app on the framework alone and says why.
+*/
+function frameProfileForApp(root) {
+	const fromEnv = frameProfileFromEnv();
+	if (fromEnv === "framework-only") return void 0;
+	if (fromEnv !== void 0) return fromEnv;
+	const fromApp = frameProfileOfManifest(root);
+	if (fromApp !== void 0) return fromApp;
+	return existsSync(join(root, "plugins", "desktop")) ? publishedFrameProfile() : void 0;
+}
+function frameProfileOfManifest(root) {
+	const manifestFile = join(root, "package.json");
+	if (!existsSync(manifestFile)) return void 0;
+	let manifest;
+	try {
+		manifest = JSON.parse(readFileSync(manifestFile, "utf8"));
+	} catch {
+		return;
+	}
+	const dependencies = manifest.dependencies ?? {};
+	const dshVersion = dependencies["@deepseek-ai/dsh-base"];
+	const frameworkVersion = dependencies.acrylblends;
+	if (typeof dshVersion !== "string" || typeof frameworkVersion !== "string") return void 0;
+	const publishedOf = new Map(FRAME_RELEASE.map((entry) => [entry.source, entry.name]));
+	const packages = {};
+	const names = {};
+	for (const entry of FRAME_PACKAGES) {
+		const source = dependencies[entry.name];
+		const publishedName = publishedOf.get(entry.name);
+		const published = publishedName === void 0 ? void 0 : dependencies[publishedName];
+		if (typeof source === "string") packages[entry.name] = source;
+		else if (typeof published === "string" && publishedName !== void 0) {
+			packages[entry.name] = published;
+			names[entry.name] = publishedName;
+		}
+	}
+	if (Object.keys(packages).length === 0) return void 0;
+	return {
+		dshVersion,
+		frameworkVersion,
+		packages,
+		names
+	};
+}
+/**
+* The profile input for an app from its specs: every frame row named by the module it installs as, its Loader row id kept as the source name (so a checkout
+* app and a published one have the same rows, and an upgrade between them renames nothing), and the specs as dependencies under the same module names.
+*/
+function frameProfileInput(specs, appName, rows) {
+	const moduleOf = (source) => specs.names?.[source] ?? source;
+	const packages = FRAME_PACKAGES.map((entry) => entry.installed === true ? entry : {
+		...entry,
+		name: moduleOf(entry.name),
+		row: entry.row ?? entry.name,
+		spec: specs.packages[entry.name] ?? ""
+	});
+	return {
+		appName,
+		dshVersion: specs.dshVersion,
+		frameworkVersion: specs.frameworkVersion,
+		packages,
+		dependencies: Object.fromEntries(Object.entries(specs.packages).map(([source, spec]) => [moduleOf(source), spec])),
+		...rows === void 0 ? {} : { rows }
+	};
+}
+//#endregion
+//#region src/frame-rows.ts
+/**
+* The rows the frame's layer needs for an app's own code, and the generated composition row that runs the app's plugins beside the host.
+*
+* A template with `src/frame.ts` gets the app's routes row. A template whose `src/app.ts` exports `composeInto` also gets `frame/app-plugins.mjs`, one row
+* that composes the app exactly as its own server does (same rows, order and config; `host: true` leaves the host's infrastructure rows out). The services
+* the app's own rows provide are read from their sources, never a hand list, and isolated through the Loader's own entry option, so the host's DSH rows keep
+* their copies of the same names.
+*
+* `init` writes these for a fresh app and `upgrade` writes them for an app made before the frame: one home for the row ids, the isolate rule and the
+* generated file.
+*/
+/** Rows the host mounts itself: an app's manifest may name them, but the generated layer does not. */
+const HOST_PROVIDED_IDS = /* @__PURE__ */ new Set([
+	"instance",
+	"acryl-router",
+	"acryl-node-server",
+	"acryl-web-server",
+	"acryl-page",
+	"manifest",
+	"save",
+	"acryl-door"
+]);
+/** The generated `frame/app-plugins.mjs`, by the row that mounts it. */
+const APP_PLUGINS_FILE = "frame/app-plugins.mjs";
+/**
+* The generated row source: the app's plugins composed beside the host, with the services they provide isolated (the Loader entry option). Every
+* route they mount lands under the frame's app prefix (`prefix`): a plugin's `ctx.router.route('/board')` answers `/app/board` in the canvas and
+* `/board` on the app's own server, so a plugin never writes the prefix. `@param prefix` is the canvas prefix, {@link FRAME_PAGE_PREFIX}.
+*/
+function appPluginsRow(prefix) {
+	return [
+		"// Generated by acrylblends: the app's own plugins, composed as the app's server composes them (src/app.ts composeInto). The layer row isolates the",
+		"// services this app provides (the Loader entry option), so the host's driver rows keep their own. Every route these rows mount lands under the",
+		`// frame's app prefix (${prefix}): a plugin's ctx.router.route('/board') answers /${prefix.replace(/^\/+/u, "")}/board in the canvas and /board on the app's own server.`,
+		"import { composeInto } from '../src/app.ts'",
+		"",
+		"export const name = 'app-plugins'",
+		"export const inject = ['appInstance', 'router']",
+		"",
+		"/** The path a route lands at under the prefix: \"/\" is the prefix itself, a path already under it stays as it is. */",
+		"function prefixedAppRoute(prefix, path) {",
+		"  const base = prefix.replace(/\\/+$/, '')",
+		"  if (base === '') return path",
+		"  if (path === '' || path === '/') return base",
+		"  return path === base || path.startsWith(base + '/') ? path : base + (path.startsWith('/') ? '' : '/') + path",
+		"}",
+		"",
+		"/** The router as the app's rows see it: mounts land under the prefix, every other member is the host router's. */",
+		"function appRouter(router, prefix) {",
+		"  const route = (path, app) => router.route(prefixedAppRoute(prefix, path), app)",
+		"  return new Proxy(router, {",
+		"    get(target, property) {",
+		"      if (property === 'route') return route",
+		"      const value = Reflect.get(target, property, target)",
+		"      return typeof value === 'function' ? value.bind(target) : value",
+		"    },",
+		"  })",
+		"}",
+		"",
+		"export async function apply(ctx, config) {",
+		`  const prefix = typeof config?.appPrefix === 'string' ? config.appPrefix : ${JSON.stringify(prefix)}`,
+		"  // The rows read ctx.router as the app's own router: the same paths as on their own server, under the frame's prefix.",
+		"  const appScope = ctx.extend({ router: appRouter(ctx.router, prefix) })",
+		"  const fibers = await composeInto(appScope, ctx.appInstance, { host: true })",
+		"  ctx.effect(() => () => { for (const fiber of [...fibers].reverse()) void fiber.dispose() }, 'app-plugins: dispose')",
+		"}",
+		""
+	].join("\n");
+}
+/** Whether an app's composition root is the one `composeInto` makes: the row can call it only then. */
+function carriesComposeInto(appTs) {
+	return appTs.includes("export async function composeInto");
+}
+/** The ids of the app's own rows (blend.yaml), without the ones the host provides. */
+function ownRowIds(appDir) {
+	const blend = join(appDir, "blend.yaml");
+	if (!existsSync(blend)) return [];
+	const ids = [];
+	for (const match of readFileSync(blend, "utf8").matchAll(/^\s*- id:\s*(\S+)\s*$/gmu)) if (!HOST_PROVIDED_IDS.has(match[1])) ids.push(match[1]);
+	return ids;
+}
+/** The service names the app's own plugins provide, read from their sources. */
+function providedServices(appDir) {
+	const provided = /* @__PURE__ */ new Set();
+	const walk = (folder) => {
+		if (!existsSync(folder)) return;
+		for (const entry of readdirSync(folder, { withFileTypes: true })) {
+			const path = join(folder, entry.name);
+			if (entry.isDirectory()) {
+				walk(path);
+				continue;
+			}
+			if (!/\.(ts|tsx|mjs)$/u.test(entry.name)) continue;
+			const text = readFileSync(path, "utf8");
+			for (const match of text.matchAll(/super\(\s*ctx\s*,\s*['"]([\w.-]+)['"]/gu)) provided.add(match[1]);
+			for (const match of text.matchAll(/reflect\.provide\(\s*['"]([\w.-]+)['"]/gu)) provided.add(match[1]);
+			for (const match of text.matchAll(/ctx\.provide\(\s*['"]([\w.-]+)['"]/gu)) provided.add(match[1]);
+		}
+	};
+	for (const row of ownRowIds(appDir)) walk(join(appDir, "plugins", row));
+	return Object.fromEntries([...provided].sort().map((name) => [name, true]));
+}
+/**
+* The frame rows for an app: its routes row when it carries `src/frame.ts`, and the composition row when its `src/app.ts` exports `composeInto`.
+* `appTs` and `hasFrame` let a caller plan against the files it is about to write (an upgrade replacing the scaffold) rather than the ones on disk.
+*/
+function appFrameRows(appDir, options = {}) {
+	if (options.hasFrame !== true && !existsSync(join(appDir, "src", "frame.ts"))) return {
+		rows: [],
+		appPlugins: void 0
+	};
+	const appTs = options.appTs ?? readAppTs(appDir);
+	const composes = appTs !== void 0 && carriesComposeInto(appTs);
+	const rows = [];
+	if (composes) {
+		const isolate = providedServices(appDir);
+		rows.push({
+			id: "app-plugins",
+			name: `./${APP_PLUGINS_FILE}`,
+			...Object.keys(isolate).length === 0 ? {} : { isolate }
+		});
+	}
+	rows.push({
+		id: "app-routes",
+		name: "./src/frame.ts"
+	});
+	return {
+		rows,
+		appPlugins: composes ? appPluginsRow(FRAME_PAGE_PREFIX) : void 0
+	};
+}
+function readAppTs(appDir) {
+	const file = join(appDir, "src", "app.ts");
+	return existsSync(file) ? readFileSync(file, "utf8") : void 0;
+}
+//#endregion
 //#region src/templates.ts
 /** The templates, all Cordis apps: a web app with a page and a client component (nodejs), a notes app and a chat app on the db port (notes, chat), a blank app on the router, a todo list on the router and state, and the blank app with the offline agent. */
 const TEMPLATES = [
@@ -73,10 +1330,6 @@ function frameworkDocsRoot() {
 	}
 }
 //#endregion
-//#region src/version.ts
-/** The version of this package. */
-const VERSION = createRequire(import.meta.url)("../package.json").version;
-//#endregion
 //#region src/lock.ts
 /**
 * What an app knows about the library plugins it carries: `plugins/library.lock.json` records, for every library plugin copied into the app, the version it came from and a hash of each file
@@ -409,7 +1662,10 @@ function readTemplatePlugins(templateDir) {
 	const { plugins } = JSON.parse(readFileSync(file, "utf8"));
 	return plugins ?? [];
 }
-/** Add run-time dependencies to an app's package.json, keeping what is there and sorting the keys. Returns the names added. */
+/**
+* Add run-time dependencies to an app's package.json, keeping what is there and sorting the keys. Returns the names added. A package the app lists as a development
+* dependency too is taken out of that list: npm lets the development entry win, so `npm install --omit=dev` would leave a run-time dependency out.
+*/
 function mergeDependencies(appDir, dependencies) {
 	const file = join(appDir, "package.json");
 	const manifest = JSON.parse(readFileSync(file, "utf8"));
@@ -420,6 +1676,7 @@ function mergeDependencies(appDir, dependencies) {
 		...current
 	};
 	manifest.dependencies = Object.fromEntries(Object.entries(merged).sort(([a], [b]) => a.localeCompare(b)));
+	if (manifest.devDependencies !== void 0) manifest.devDependencies = Object.fromEntries(Object.entries(manifest.devDependencies).filter(([name]) => !(name in merged)));
 	writeFileSync(file, `${JSON.stringify(manifest, null, 2)}\n`);
 	return added;
 }
@@ -450,20 +1707,22 @@ function mergeOpener(appDir, opener) {
 	writeFileSync(file, `${JSON.stringify(manifest, null, 2)}\n`);
 }
 /**
-* Add a plugin's development dependencies and scripts to an app's package.json: nothing the app already has is replaced. Returns the names of the development dependencies
-* and scripts added.
+* Add a plugin's development dependencies and scripts to an app's package.json: nothing the app already has is replaced, and a package the app already needs at run time
+* (`dependencies`) is not listed again as a development one. Returns the names of the development dependencies and scripts added.
 */
 function mergeTooling(appDir, tooling) {
 	const file = join(appDir, "package.json");
 	const manifest = JSON.parse(readFileSync(file, "utf8"));
 	const dev = manifest.devDependencies ?? {};
+	const runtime = manifest.dependencies ?? {};
 	const scripts = manifest.scripts ?? {};
-	const addedDev = Object.keys(tooling.devDependencies ?? {}).filter((name) => !(name in dev));
+	const wanted = Object.entries(tooling.devDependencies ?? {}).filter(([name]) => !(name in runtime));
+	const addedDev = wanted.map(([name]) => name).filter((name) => !(name in dev));
 	const addedScripts = Object.keys(tooling.scripts ?? {}).filter((name) => !(name in scripts));
 	manifest.devDependencies = Object.fromEntries(Object.entries({
-		...tooling.devDependencies,
+		...Object.fromEntries(wanted),
 		...dev
-	}).sort(([a], [b]) => a.localeCompare(b)));
+	}).filter(([name]) => !(name in runtime)).sort(([a], [b]) => a.localeCompare(b)));
 	manifest.scripts = {
 		...tooling.scripts,
 		...scripts
@@ -510,22 +1769,34 @@ function appendGitignore(appDir, lines) {
 	if (missing.length > 0) writeFileSync(file, `${current}${current.endsWith("\n") || current === "" ? "" : "\n"}${missing.join("\n")}\n`);
 	return missing;
 }
-/** The generated app's guide for a coding agent: the shared core, then the template's own part. `CLAUDE.md` is only an import of it. */
+/**
+* The generated app's guide for a coding agent: the shared core, then the template's own part. `CLAUDE.md` is only an import of it. The skills
+* every app ships (`shared/skills/<name>/SKILL.md`) go to `.claude/skills/` (Claude Code) and `.agents/skills/` (the other agents), the same text in both.
+*/
 function writeAgentFiles(sharedDir, templateDir, target, name) {
 	const core = readFileSync(join(sharedDir, "AGENTS.core.md"), "utf8");
 	const own = existsSync(join(templateDir, "AGENTS.md")) ? readFileSync(join(templateDir, "AGENTS.md"), "utf8") : "";
 	const text = `${core}${readFileSync(join(sharedDir, "DEFAULTS.md"), "utf8")}${own}`.replaceAll("__APP_NAME__", name);
 	writeFileSync(join(target, "AGENTS.md"), text);
 	writeFileSync(join(target, "CLAUDE.md"), text);
-	const skill = readFileSync(join(sharedDir, "SKILL.md"), "utf8").replaceAll("__APP_NAME__", name);
 	const written = ["AGENTS.md", "CLAUDE.md"];
-	for (const folder of [".claude/skills/app-guide", ".agents/skills/app-guide"]) {
-		mkdirSync(join(target, folder), { recursive: true });
-		writeFileSync(join(target, folder, "SKILL.md"), skill);
-		written.push(`${folder}/SKILL.md`);
+	for (const skill of sharedSkills(sharedDir)) {
+		const skillText = readFileSync(join(sharedDir, "skills", skill, "SKILL.md"), "utf8").replaceAll("__APP_NAME__", name);
+		for (const scope of [".claude/skills", ".agents/skills"]) {
+			const folder = `${scope}/${skill}`;
+			mkdirSync(join(target, folder), { recursive: true });
+			writeFileSync(join(target, folder, "SKILL.md"), skillText);
+			written.push(`${folder}/SKILL.md`);
+		}
 	}
 	return written;
 }
+/** The skills every generated app carries: the folder name of each under `shared/skills/`. */
+function sharedSkills(sharedDir) {
+	const root = join(sharedDir, "skills");
+	if (!existsSync(root)) return [];
+	return readdirSync(root, { withFileTypes: true }).filter((entry) => entry.isDirectory() && existsSync(join(root, entry.name, "SKILL.md"))).map((entry) => entry.name).sort((a, b) => a.localeCompare(b));
+}
 /**
 * Copy the framework's docs (a generated copy of ACRYL's `docs/framework`, already checked against its digest) into `<app>/docs/framework/`,
 * so a coding agent working in the app reads the API from the folder it is in. The generated-copy notes and the digest record stay behind.
@@ -558,6 +1829,33 @@ function copyFrameworkDocs(source, target) {
 var UsageError = class extends Error {
 	name = "UsageError";
 };
+/**
+* A new app is a git repository from the start: its `.gitignore` is written with the scaffold, `npm run save` commits it, and the frame's Files and
+* Changes views work on a git worktree (the app's own folder; without one they answer "file request failed"). A folder that already is a repository, or
+* a machine without git, is left alone.
+*/
+function startRepository(directory) {
+	if (existsSync(join(directory, ".git"))) return;
+	const run = (args) => spawnSync("git", args, {
+		cwd: directory,
+		stdio: "ignore",
+		windowsHide: true
+	}).status === 0;
+	if (!run(["init", "-q"])) return;
+	if (!run(["add", "-A"])) return;
+	run([
+		...run(["config", "user.email"]) ? [] : [
+			"-c",
+			"user.name=acrylblends",
+			"-c",
+			"user.email=scaffold@acrylblends.invalid"
+		],
+		"commit",
+		"-q",
+		"-m",
+		"Initial commit from acrylblends"
+	]);
+}
 /** Parse `init [dir] [--template t] [--agent|--no-agent] [--name n] [--install] [-y]`. `--agent` means `--template agent`, `--no-agent` means `--template blank`. */
 function parseInitOptions(argv) {
 	let parsed;
@@ -639,9 +1937,26 @@ async function init(options, io) {
 		mergeTooling(directory, plugin);
 	}
 	addNodePreflight(directory);
+	const frame = appFrameRows(directory);
+	if (frame.appPlugins !== void 0) {
+		mkdirSync(join(directory, "frame"), { recursive: true });
+		writeFileSync(join(directory, APP_PLUGINS_FILE), frame.appPlugins);
+	}
+	const frameRow = frame.rows;
+	if (frameRow.length > 0) {
+		const specs = frameProfileForInit(options.desktop);
+		if (specs === void 0) {
+			const why = options.desktop ? "ACRYLBLENDS_FRAME_PACKAGES is none" : "init --desktop puts it inside the ACRYL frame";
+			io.stdout.write(`note: this app runs on the framework alone; ${why}\n`);
+		} else {
+			const wrote = applyIdeProfile(directory, frameProfileInput(specs, name, frameRow));
+			io.stdout.write(`frame: wrote ${wrote.written.join(", ") || "nothing (already right)"}\n`);
+		}
+	}
 	const desktopPath = options.desktop ? readTemplateDesktopPath(templateDir(template)) : void 0;
 	if (desktopPath !== void 0) writeDesktopPath(directory, desktopPath);
 	io.stdout.write(`created ${name} (${template}) in ${directory}: ${files.length} files, plugins ${own.map((plugin) => plugin.name).join(", ")}${forDesktop.length > 0 ? `; the desktop shell adds ${forDesktop.map((plugin) => plugin.name).join(", ")}, which it needs` : ""}\n`);
+	startRepository(directory);
 	if (install && await io.install(directory) !== 0) {
 		io.stderr.write("error: npm install failed; run it yourself in the new directory\n");
 		return 1;
@@ -673,9 +1988,17 @@ const MOUNTED = [
 		local: "driverAcp",
 		needs: ["agent-panel"],
 		after: "agent-panel"
+	},
+	{
+		name: "feedback",
+		local: "feedback",
+		needs: ["acryl-router"]
 	}
 ];
-const ROW = /^( *)- id: ?(\S+)\n\1 {2}name: ?(\S+)\n/gmu;
+/** A row, in either line ending: a file edited on Windows (or checked out with core.autocrlf) is still a Blend. */
+const ROW = /^( *)- id: ?(\S+)\r?\n\1 {2}name: ?(\S+)\r?\n/gmu;
+/** The line ending the text already uses, so an edit keeps the file's own style. */
+const eolOf$1 = (text) => text.includes("\r\n") ? "\r\n" : "\n";
 /** The `name:` of every row of the app's `blend.yaml`, or `undefined` when it has none. */
 function rowNames(appDir) {
 	const file = join(appDir, "blend.yaml");
@@ -696,10 +2019,11 @@ function mount(appDir, plugin) {
 		let text = readFileSync(manifestFile, "utf8");
 		if ([...text.matchAll(ROW)].some((match) => match[3] === plugin.name)) done.push("blend.yaml (already has the row)");
 		else {
-			const found = (plugin.after ? new RegExp(`^( *)- id: ?\\S+\\n\\1 {2}name: ?${plugin.after}\\n(?:\\1 {2}config:\\n(?:\\1 {4}.*\\n|\\1 {2}\\s*\\n)*)?`, "mu") : /^( *)- id: ?routes\n/mu).exec(text);
+			const eol = eolOf$1(text);
+			const found = (plugin.after ? new RegExp(`^( *)- id: ?\\S+\\r?\\n\\1 {2}name: ?${plugin.after}\\r?\\n(?:\\1 {2}config:\\r?\\n(?:\\1 {4}.*\\r?\\n|\\1 {2}\\s*\\r?\\n)*)?`, "mu") : /^( *)- id: ?routes\r?\n/mu).exec(text);
 			if (found) {
 				const indent = found[1];
-				const row = `${indent}- id: ${plugin.row ?? plugin.name}\n${indent}  name: ${plugin.name}\n`;
+				const row = `${indent}- id: ${plugin.row ?? plugin.name}${eol}${indent}  name: ${plugin.name}${eol}`;
 				const at = plugin.after ? found.index + found[0].length : found.index;
 				text = text.slice(0, at) + row + text.slice(at);
 				writeFileSync(manifestFile, text);
@@ -713,13 +2037,14 @@ function mount(appDir, plugin) {
 		const entry = `'${plugin.name}': ${plugin.local}`;
 		if (text.includes(entry)) done.push("src/app.ts (already registered)");
 		else {
-			const last = [...text.matchAll(/^import .* from '\.\.\/plugins\/[^']+'\n/gmu)].at(-1);
-			const table = /^export const registry = \{(\s)/mu.exec(text);
+			const eol = eolOf$1(text);
+			const last = [...text.matchAll(/^import .* from '\.\.\/plugins\/[^']+'\r?\n/gmu)].at(-1);
+			const table = /^export const registry = \{(\r?\n)/mu.exec(text);
 			if (last && table) {
 				const file = plugin.entry ?? "index.ts";
-				const line = `import * as ${plugin.local} from '../plugins/${plugin.name}/${file}'\n`;
+				const line = `import * as ${plugin.local} from '../plugins/${plugin.name}/${file}'${eol}`;
 				const at = table.index + table[0].length;
-				text = text.slice(0, at) + (table[1] === "\n" ? `  ${entry},\n` : `${entry}, `) + text.slice(at);
+				text = text.slice(0, at) + (table[1] === "\n" || table[1] === "\r\n" ? `  ${entry},${eol}` : `${entry}, `) + text.slice(at);
 				const lastEnd = last.index + last[0].length;
 				text = text.slice(0, lastEnd) + line + text.slice(lastEnd);
 				writeFileSync(appFile, text);
@@ -1127,6 +2452,216 @@ function checkDeps(options, io) {
 	return 1;
 }
 //#endregion
+//#region src/frame-url.ts
+/**
+* The running frame's address, kept where the app's own data lives.
+*
+* The generated launcher prints the frame's URL with the launch token in it, and that token is the only way into a frame whose browser session ended.
+* So the address is written where the app keeps its data - `.acrylblends/`, which every scaffold's `.gitignore` already covers - at mint time,
+* owner-only (0600 here; a restricted ACL on Windows), and atomically (a temp file in the same folder renamed over it, so a reader never sees half a
+* record). On every later boot the launcher reuses the stored token instead of minting a new one, so the address - and an open page - survives a
+* restart; `acrylblends open` prints it, and `acrylblends open --new` rotates it (the running host replaces the token in place through
+* `/api/acryl-frame/token/new`), invalidating the old one immediately.
+*
+* DSH's connection package mints its launch token as a random value with no configuration seam (BrowserAuth's constructor calls
+* `processLaunchToken`, cached per process owner). The one seam it offers is the instance field the class keeps: `browserAuth.launchToken`, which
+* `authorizeIndex` and `authenticatedUrl` read on every use. The launcher sets that field from the stored record (guarded: a DSH package whose shape
+* lacks it simply keeps its fresh token), and sets it again on a rotation. Nothing inside the pinned package is edited.
+*/
+/** The record's file name inside the app home. */
+const FRAME_URL_FILE = "frame-url.json";
+/** Where a running frame rotates its token: a route the launcher mounts on the frame's own router. */
+const FRAME_TOKEN_PATH = "/api/acryl-frame/token/new";
+/** The app home the frame uses: `ACRYLBLENDS_HOME` when set, else `<app>/.acrylblends` (the launcher's own rule). */
+function frameHome(appRoot, env = process.env) {
+	const pinned = env.ACRYLBLENDS_HOME?.trim();
+	return pinned === void 0 || pinned === "" ? join(resolve(appRoot), ".acrylblends") : resolve(pinned);
+}
+function frameUrlPath(home) {
+	return join(home, FRAME_URL_FILE);
+}
+/** Windows has no mode bits; the equivalent is an ACL with inheritance removed and only this account allowed. Best effort: a failure leaves the
+* inherited ACL, which is still the user's folder on a normal install. */
+function restrictToOwner(path) {
+	chmodSync(path, 384);
+	if (process.platform !== "win32") return;
+	const user = process.env.USERNAME;
+	if (user === void 0 || user === "") return;
+	spawnSync("icacls", [
+		path,
+		"/inheritance:r",
+		"/grant:r",
+		`${user}:F`
+	], {
+		stdio: "ignore",
+		windowsHide: true
+	});
+}
+/** The token a frame address carries, if it carries one. */
+function tokenOfFrameUrl(url) {
+	try {
+		const token = new URL(url).searchParams.get("token");
+		return token === null || token === "" ? void 0 : token;
+	} catch {
+		return;
+	}
+}
+/** Write the frame's address for `home`, owner-only and atomically. Throws when the folder or file cannot be written; the caller decides whether
+* that is fatal (the launcher prints why and keeps serving the app). */
+function writeFrameUrl(home, url, pid = process.pid) {
+	mkdirSync(home, { recursive: true });
+	const record = {
+		version: 1,
+		url,
+		token: tokenOfFrameUrl(url) ?? "",
+		pid,
+		writtenAt: (/* @__PURE__ */ new Date()).toISOString()
+	};
+	const target = frameUrlPath(home);
+	const temporary = join(home, `${FRAME_URL_FILE}.${String(pid)}.tmp`);
+	writeFileSync(temporary, `${JSON.stringify(record, null, 2)}\n`, { mode: 384 });
+	restrictToOwner(temporary);
+	renameSync(temporary, target);
+	restrictToOwner(target);
+}
+/** Remove the record, but only the one `pid` wrote: a host that is stopping must not erase the address of a newer one that already started. */
+function removeFrameUrl(home, pid = process.pid) {
+	const record = readFrameUrl(home);
+	if (record === void 0 || record.pid !== pid) return;
+	rmSync(frameUrlPath(home), { force: true });
+}
+/** The record, or undefined when there is none, it is not ours, or it is malformed. */
+function readFrameUrl(home) {
+	const path = frameUrlPath(home);
+	if (!existsSync(path)) return void 0;
+	let parsed;
+	try {
+		parsed = JSON.parse(readFileSync(path, "utf8"));
+	} catch {
+		return;
+	}
+	if (typeof parsed !== "object" || parsed === null) return void 0;
+	const record = parsed;
+	if (record.version !== 1) return void 0;
+	if (typeof record.url !== "string" || record.url === "") return void 0;
+	if (typeof record.pid !== "number" || !Number.isInteger(record.pid)) return void 0;
+	if (typeof record.writtenAt !== "string") return void 0;
+	const token = typeof record.token === "string" ? record.token : tokenOfFrameUrl(record.url) ?? "";
+	return {
+		version: 1,
+		url: record.url,
+		token,
+		pid: record.pid,
+		writtenAt: record.writtenAt
+	};
+}
+/** Whether something accepts a TCP connection at the record's address (the host process is alive and listening). */
+function frameIsListening(url, timeoutMs = 500) {
+	let target;
+	try {
+		target = new URL(url);
+	} catch {
+		return Promise.resolve(false);
+	}
+	const port = Number(target.port === "" ? target.protocol === "https:" ? 443 : 80 : target.port);
+	return new Promise((done) => {
+		const socket = connect({
+			host: target.hostname,
+			port
+		});
+		const finish = (listening) => {
+			socket.destroy();
+			done(listening);
+		};
+		socket.setTimeout(timeoutMs);
+		socket.once("connect", () => finish(true));
+		socket.once("timeout", () => finish(false));
+		socket.once("error", () => finish(false));
+	});
+}
+/** Read the record and say whether the frame it names is still listening. */
+async function lookUpFrameUrl(appRoot, env = process.env) {
+	const home = frameHome(appRoot, env);
+	const record = readFrameUrl(home);
+	if (record === void 0) return {
+		kind: "none",
+		home
+	};
+	return await frameIsListening(record.url) ? {
+		kind: "running",
+		record
+	} : {
+		kind: "stopped",
+		record
+	};
+}
+/** Ask the running host to rotate its token, presenting the current one. Returns the new address, or a reason it failed. */
+async function rotateFrameToken(record) {
+	let origin;
+	try {
+		origin = new URL(record.url).origin;
+	} catch {
+		return { reason: "the stored address is not a URL" };
+	}
+	let response;
+	try {
+		response = await fetch(`${origin}${FRAME_TOKEN_PATH}`, {
+			method: "POST",
+			headers: {
+				"x-frame-token": record.token,
+				accept: "application/json"
+			}
+		});
+	} catch (cause) {
+		return { reason: cause instanceof Error ? cause.message : String(cause) };
+	}
+	if (!response.ok) return { reason: `the host answered ${String(response.status)}` };
+	const body = await response.json().catch(() => void 0);
+	if (typeof body?.url !== "string" || body.url === "") return { reason: "the host answered without an address" };
+	return { url: body.url };
+}
+/**
+* `acrylblends open [dir] [--new]`: print the address of the frame running the app in this folder, so a page whose session ended (or the person, after
+* a restart) can open it again without restarting the host. Only a listening host's address is printed, and only the address goes to stdout, for copy
+* and paste. `--new` rotates the token in the running host first: the old address stops working at once and the new one is printed; with no host
+* running, the stored address is simply forgotten and the next start mints a fresh one.
+*/
+async function openFrame(args, io) {
+	const fresh = args.includes("--new");
+	const rest = args.filter((arg) => arg !== "--new");
+	if (rest.length > 1) {
+		io.stderr.write("usage: acrylblends open [dir] [--new]\n");
+		return 2;
+	}
+	const directory = resolve(io.cwd, rest[0] ?? ".");
+	const found = await lookUpFrameUrl(directory);
+	if (found.kind === "none") {
+		io.stderr.write(`no frame has run in ${directory} yet; start it with npm run dev\n`);
+		return 1;
+	}
+	if (!fresh) {
+		if (found.kind === "running") {
+			io.stdout.write(`${found.record.url}\n`);
+			return 0;
+		}
+		io.stderr.write(`the frame of ${directory} is not running (its last address was minted ${found.record.writtenAt}); run npm run dev, then this command again\n`);
+		return 1;
+	}
+	if (found.kind === "stopped") {
+		rmSync(frameUrlPath(frameHome(directory)), { force: true });
+		io.stderr.write(`no frame is running in ${directory}; its stored address was forgotten and the next npm run dev mints a new one\n`);
+		return 0;
+	}
+	const rotated = await rotateFrameToken(found.record);
+	if ("reason" in rotated) {
+		io.stderr.write(`the running frame did not rotate its address (${rotated.reason}); run npm run dev to start it with a fresh one\n`);
+		return 1;
+	}
+	writeFrameUrl(frameHome(directory), rotated.url);
+	io.stdout.write(`${rotated.url}\n`);
+	return 0;
+}
+//#endregion
 //#region src/spawn.ts
 /**
 * How to start a package manager without the shell option (Node warns about passing args to a shell, DEP0190, and a `.cmd` shim cannot be spawned directly).
@@ -1530,6 +3065,115 @@ async function runPreflight(io, probes = machineProbes()) {
 	return checks.some((check) => check.status === "FIX") ? 1 : 0;
 }
 //#endregion
+//#region src/app-registration.ts
+/**
+* The two `src/app.ts` edits `acrylblends add` makes for a plugin it mounts (`mount.ts`): an import line after the last plugin import, and a
+* registry entry after `export const registry = {`. An app's own copy of these lines is not the owner's change; the upgrade recognises them,
+* keeps them on the new file it writes, and reports only the owner's other lines.
+*/
+const eolOf = (text) => text.includes("\r\n") ? "\r\n" : "\n";
+/** Every registration line at the start of `text`, the line ending kept; a line is one registration. */
+function registrations(text, mounted) {
+	const found = [];
+	for (const raw of text.split("\n")) {
+		const line = raw.endsWith("\r") ? raw.slice(0, -1) : raw;
+		const importMatch = /^import \* as (\w+) from '\.\.\/plugins\/([^/]+)\/([^']+)'$/u.exec(line);
+		if (importMatch !== null) {
+			const plugin = mounted.find((candidate) => candidate.name === importMatch[2] && candidate.local === importMatch[1]);
+			if (plugin !== void 0) found.push({
+				plugin,
+				kind: "import",
+				line
+			});
+			continue;
+		}
+		const entryMatch = /^ {2}'([^']+)': (\w+),$/u.exec(line);
+		if (entryMatch !== null) {
+			const plugin = mounted.find((candidate) => candidate.name === entryMatch[1] && candidate.local === entryMatch[2]);
+			if (plugin !== void 0) found.push({
+				plugin,
+				kind: "registry",
+				line
+			});
+		}
+	}
+	return found;
+}
+/** The text without the framework's registration lines, and those lines in file order. A line the released template already has is the
+* template's own (agent-panel's import ships with the agent template), never the add command's edit. */
+function stripRegistrations(text, mounted = MOUNTED, template) {
+	const inTemplate = new Set((template ?? "").split("\n").map((raw) => raw.endsWith("\r") ? raw.slice(0, -1) : raw));
+	const edits = registrations(text, mounted).filter((edit) => !inTemplate.has(edit.line));
+	if (edits.length === 0) return {
+		text,
+		edits
+	};
+	const wanted = new Set(edits.map((edit) => edit.line));
+	return {
+		text: text.split("\n").filter((raw) => {
+			const line = raw.endsWith("\r") ? raw.slice(0, -1) : raw;
+			return !wanted.has(line);
+		}).join("\n"),
+		edits
+	};
+}
+/**
+* Put the framework's registration lines back into a template, at the same places `mount` inserts them: every import after the last
+* `../plugins/` import, every registry entry after the `export const registry = {` line. Lines already present are left alone.
+*/
+function withRegistrations(text, edits) {
+	const eol = eolOf(text);
+	let next = text;
+	const imports = edits.filter((edit) => edit.kind === "import" && !next.split("\n").some((raw) => (raw.endsWith("\r") ? raw.slice(0, -1) : raw) === edit.line));
+	if (imports.length > 0) {
+		const last = [...next.matchAll(/^import .* from '\.\.\/plugins\/[^']+'\r?\n/gmu)].at(-1);
+		if (last !== void 0) {
+			const at = last.index + last[0].length;
+			next = next.slice(0, at) + imports.map((edit) => `${edit.line}${eol}`).join("") + next.slice(at);
+		}
+	}
+	const entries = edits.filter((edit) => edit.kind === "registry" && !next.split("\n").some((raw) => (raw.endsWith("\r") ? raw.slice(0, -1) : raw) === edit.line));
+	if (entries.length > 0) {
+		const table = /^export const registry = \{(\r?\n)/mu.exec(next);
+		if (table !== null) {
+			const at = table.index + table[0].length;
+			next = next.slice(0, at) + entries.map((edit) => `${edit.line}${eol}`).join("") + next.slice(at);
+		}
+	}
+	return next;
+}
+/**
+* The app's lines that the expected file does not have, in order: the owner's real changes. A line-level longest common subsequence, cut to
+* `limit` lines, so a change reads as the lines it is, not as a whole file.
+*/
+function ownerChangeLines(actual, expected, limit = 5) {
+	const lineOf = (raw) => raw === void 0 ? "" : raw.endsWith("\r") ? raw.slice(0, -1) : raw;
+	const left = actual.split("\n");
+	const right = expected.split("\n");
+	const lengths = Array.from({ length: left.length + 1 }, () => new Array(right.length + 1).fill(0));
+	for (let i = left.length - 1; i >= 0; i -= 1) for (let j = right.length - 1; j >= 0; j -= 1) lengths[i][j] = lineOf(left[i]) === lineOf(right[j]) ? (lengths[i + 1][j + 1] ?? 0) + 1 : Math.max(lengths[i + 1][j] ?? 0, lengths[i][j + 1] ?? 0);
+	const changed = [];
+	let i = 0;
+	let j = 0;
+	while (i < left.length && changed.length < limit) {
+		if (j < right.length && lineOf(left[i]) === lineOf(right[j])) {
+			i += 1;
+			j += 1;
+			continue;
+		}
+		if (j < right.length && (lengths[i + 1][j] ?? 0) < (lengths[i][j + 1] ?? 0)) {
+			j += 1;
+			continue;
+		}
+		changed.push({
+			line: i + 1,
+			text: lineOf(left[i])
+		});
+		i += 1;
+	}
+	return changed;
+}
+//#endregion
 //#region src/diff.ts
 function ops(a, b) {
 	if (a.length * b.length > 6e6) return void 0;
@@ -1619,6 +3263,159 @@ function unifiedDiff(name, from, to, context = 3) {
 	return `${out.join("\n")}\n`;
 }
 //#endregion
+//#region src/legacy.ts
+/**
+* The scaffolds published acrylblends releases shipped, as `acrylblends upgrade` needs them: the template's route module and, where the composition root
+* exports `composeInto` today, `src/app.ts`. Fixtures are verbatim from each release (deduplicated by content hash under `legacy/<template>/<hash>/`, built by
+* `scripts/build-legacy-layouts.mjs` from the release tags). An app's file matches when it equals the released bytes with the app name substituted, or the
+* current template's file (already upgraded); anything else is the app's own and is never replaced.
+*/
+/** The app name init substituted for `__APP_NAME__` in the template's files. */
+const PLACEHOLDER = "__APP_NAME__";
+/** The frame row module's path inside an app: a template with it is framed by the host. */
+const FRAME_FILE = "src/frame.ts";
+/** The `legacy/` fixtures: beside `dist/` in the build and `src/` in a checkout, found by walking up like the templates. */
+function legacyRoot() {
+	let dir = dirname(fileURLToPath(import.meta.url));
+	for (;;) {
+		const candidate = join(dir, "legacy");
+		if (existsSync(join(candidate, "layouts.json"))) return candidate;
+		const parent = dirname(dir);
+		if (parent === dir) throw new Error("acrylblends cannot find its legacy layout fixtures");
+		dir = parent;
+	}
+}
+/** Whether a template carries the frame row (only the framed templates can be upgraded onto it). `dir` overrides the template folder for tests. */
+function carriesFrame(template, dir = templateDir(template)) {
+	return existsSync(join(dir, FRAME_FILE));
+}
+/** A template's file as a scaffolded app of `name` has it, or undefined when the current template has no such file. */
+function templateText(template, file, name) {
+	const path = join(templateDir(template), file);
+	return existsSync(path) ? readFileSync(path, "utf8").replaceAll(PLACEHOLDER, name) : void 0;
+}
+function read(path) {
+	return existsSync(path) ? readFileSync(path, "utf8") : void 0;
+}
+function walk(dir, base, into) {
+	for (const entry of readdirSync(dir)) {
+		const path = join(dir, entry);
+		if (statSync(path).isDirectory()) walk(path, `${base}${entry}/`, into);
+		else into.set(`${base}${entry}`, readFileSync(path, "utf8"));
+	}
+}
+/** Every distinct scaffold the releases shipped for a template, sorted by hash. Empty when no release shipped this template. */
+function legacyVariants(template) {
+	const dir = join(legacyRoot(), template);
+	if (!existsSync(dir)) return [];
+	return readdirSync(dir).filter((entry) => statSync(join(dir, entry)).isDirectory()).sort().map((id) => {
+		const files = /* @__PURE__ */ new Map();
+		walk(join(dir, id), "", files);
+		return {
+			id,
+			files
+		};
+	});
+}
+/** The app's name as `init` wrote it into the scaffold (package.json, then the folder). */
+function appNameOf(appDir) {
+	try {
+		const manifest = JSON.parse(readFileSync(join(appDir, "package.json"), "utf8"));
+		if (typeof manifest.name === "string" && manifest.name !== "") return manifest.name;
+	} catch {}
+	return basename(appDir);
+}
+/** The scaffold files the releases recorded for a template (the union across variants): what a fixture app starts from. */
+function legacyScaffold(template) {
+	const paths = /* @__PURE__ */ new Set();
+	for (const variant of legacyVariants(template)) for (const file of variant.files.keys()) paths.add(file);
+	return [...paths].sort();
+}
+/**
+* The app's entry module when a release before 0.7.8 wrote it: those releases shipped `src/main.ts` importing `./plugins/...` where the app keeps its
+* plugins one folder up (`../plugins/...` since 0.7.8), so the app cannot start as scaffolded and the frame layout cannot be applied on top of it.
+*/
+function brokenEntry(appDir) {
+	const text = read(join(appDir, "src", "main.ts"));
+	return text !== void 0 && /from '\.\/plugins\//u.test(text) ? "src/main.ts" : void 0;
+}
+/** The releases the fixtures cover, oldest first, from the index the build script wrote (for the CLI's message). */
+function releasedVersions() {
+	try {
+		return (JSON.parse(readFileSync(join(legacyRoot(), "layouts.json"), "utf8")).releases ?? []).map((release) => release.version).filter((version) => typeof version === "string");
+	} catch {
+		return [];
+	}
+}
+/** The release range the fixtures cover, for a sentence: `0.3.0 through 1.1.0`, or `the published releases` when the index cannot be read. */
+function releasedRange() {
+	const versions = releasedVersions();
+	const first = versions[0];
+	const last = versions.at(-1);
+	if (first === void 0 || last === void 0) return "the published releases";
+	return first === last ? first : `${first} through ${last}`;
+}
+/**
+* Which template made this app: the template whose released (or current) scaffold files the app matches most. Undefined when none matches: the app's
+* scaffold was edited, or a release that shipped no template made it, and the upgrade leaves it alone.
+*/
+function identifyTemplate(appDir, name) {
+	let best;
+	for (const template of TEMPLATES) {
+		const variants = legacyVariants(template);
+		if (variants.length === 0) continue;
+		let score = 0;
+		for (const variant of variants) {
+			let matches = 0;
+			for (const [file, text] of variant.files) if (read(join(appDir, file)) === text.replaceAll(PLACEHOLDER, name)) matches += 1;
+			score = Math.max(score, matches);
+		}
+		let current = 0;
+		for (const file of legacyScaffold(template)) {
+			const text = templateText(template, file, name);
+			if (text !== void 0 && read(join(appDir, file)) === text) current += 1;
+		}
+		score = Math.max(score, current);
+		if (score > 0 && (best === void 0 || score > best.score)) best = {
+			template,
+			score
+		};
+	}
+	return best?.template;
+}
+/**
+* What the frame layout would do to the app's scaffold of `template`: `same` when the app already has the current template's file, `update` when it has a
+* released one, `add` when it is missing, `conflict` when the app edited it (the caller refuses without `--force`).
+*/
+function readLegacy(appDir, template, name) {
+	const variants = legacyVariants(template);
+	const files = [];
+	const frame = read(join(appDir, FRAME_FILE));
+	if (carriesFrame(template)) {
+		const text = templateText(template, FRAME_FILE, name);
+		if (text !== void 0) files.push({
+			file: FRAME_FILE,
+			text,
+			state: frame === void 0 ? "add" : frame === text ? "same" : "conflict"
+		});
+	}
+	for (const file of legacyScaffold(template)) {
+		const text = templateText(template, file, name);
+		if (text === void 0) continue;
+		const app = read(join(appDir, file));
+		const released = variants.map((variant) => variant.files.get(file)).filter((value) => value !== void 0).map((value) => value.replaceAll(PLACEHOLDER, name));
+		files.push({
+			file,
+			text,
+			state: app === void 0 ? "add" : app === text ? "same" : released.includes(app) ? "update" : "conflict"
+		});
+	}
+	return {
+		template,
+		files
+	};
+}
+//#endregion
 //#region src/upgrade.ts
 /** Parse `upgrade [plugin...] [--dir <app>] [--dry-run] [--force] [--diff]`. */
 function parseUpgradeOptions(argv) {
@@ -1656,6 +3453,128 @@ function carriedCopies(dir) {
 	const listFile = join(dir, LIBRARY_LIST);
 	return (existsSync(listFile) ? JSON.parse(readFileSync(listFile, "utf8")).plugins ?? [] : readdirSync(dir).filter((name) => statSync(join(dir, name)).isDirectory())).filter((name) => existsSync(join(dir, name)));
 }
+/** The plugins the frame's host layer mounts by path: any framed app carries them, and an app made before the frame gets them here. */
+const HOST_PLUGINS = ["acryl-web-server", "acryl-page"];
+/** The profile script the DSH-profile layout used; the host launcher replaced it, so an app upgraded from that layout drops it. */
+const OLD_PROFILE_SCRIPT = "scripts/ide-profile.mjs";
+/**
+* Scaffold files the app owns from its first edit: the release's copy is only the starting point, so an edited (or removed) one is never written, refused
+* over or backed up. A copy the app never edited is still the release's and is updated like any other scaffold file.
+*/
+const KEPT_BY_THE_APP = /* @__PURE__ */ new Set(["src/routes.ts"]);
+/** What the frame row of every template imports from `src/routes.ts`: an app-owned copy without it cannot be shown in the frame. */
+const FRAME_PREFIX_EXPORT = /\bexport const FRAME_MOUNT_PREFIX\b/u;
+/** The state of one generated file that already exists: our marker makes it ours to update, anything else is the app's. */
+function generatedState(existing, text) {
+	if (existing === void 0) return "add";
+	if (existing === text) return "same";
+	return GENERATED_MARKER.test(existing.split("\n", 1)[0] ?? "") ? "update" : "conflict";
+}
+/**
+* Plan the frame half of an upgrade: an app made by the previous published release gets the frame-hosted layout (`scripts/ide-host.mjs`, the overlay with
+* the app's rows, `frame/app-plugins.mjs` with its entry isolate, the mount config in its composition root, the host plugins), and the template's own files
+* are replaced only where the app still has the released ones. An app whose scaffold was edited is refused by the caller unless it passes --force; an app
+* of a template without a frame row yet, or one whose scaffold is not this release's, stays standalone and is told so.
+*/
+function planFrameStep(appDir, library, templateDirFor = templateDir) {
+	const name = appNameOf(appDir);
+	const broken = brokenEntry(appDir);
+	if (broken !== void 0) return {
+		kind: "broken-scaffold",
+		file: broken
+	};
+	const template = identifyTemplate(appDir, name);
+	if (template === void 0) return { kind: "unidentified" };
+	if (!carriesFrame(template, templateDirFor(template))) return {
+		kind: "no-frame-template",
+		template
+	};
+	const specs = frameProfileForApp(appDir);
+	if (specs === void 0) return {
+		kind: "unavailable",
+		template
+	};
+	const released = readLegacy(appDir, template, name);
+	const ownedByTheApp = (file) => KEPT_BY_THE_APP.has(file.file) && (file.state === "conflict" || file.state === "add");
+	const kept = released.files.filter(ownedByTheApp).map((file) => {
+		const path = join(appDir, file.file);
+		return {
+			file: file.file,
+			mountable: existsSync(path) && FRAME_PREFIX_EXPORT.test(readText(path))
+		};
+	});
+	const files = released.files.filter((file) => !ownedByTheApp(file)).map((file) => ({
+		file: file.file,
+		text: file.text,
+		state: file.state
+	}));
+	const appIndex = files.findIndex((file) => file.file === "src/app.ts");
+	const appFile = appIndex < 0 ? void 0 : files[appIndex];
+	let conflictLines;
+	if (appFile !== void 0 && appFile.state === "conflict") {
+		const appTsPath = join(appDir, "src", "app.ts");
+		const current = existsSync(appTsPath) ? readText(appTsPath) : void 0;
+		if (current !== void 0) {
+			const stripped = stripRegistrations(current, void 0, appFile.text);
+			const target = withRegistrations(appFile.text, stripped.edits);
+			if (stripped.text === appFile.text) files[appIndex] = {
+				file: "src/app.ts",
+				text: target,
+				state: target === current ? "same" : "update"
+			};
+			else conflictLines = { "src/app.ts": ownerChangeLines(current, target) };
+		}
+	}
+	const appTs = files.find((file) => file.file === "src/app.ts")?.text ?? (existsSync(join(appDir, "src", "app.ts")) ? readText(join(appDir, "src", "app.ts")) : void 0);
+	const rows = appFrameRows(appDir, {
+		...appTs === void 0 ? {} : { appTs },
+		hasFrame: true
+	});
+	if (rows.appPlugins !== void 0) {
+		const path = join(appDir, APP_PLUGINS_FILE);
+		files.push({
+			file: APP_PLUGINS_FILE,
+			text: rows.appPlugins,
+			state: generatedState(existsSync(path) ? readText(path) : void 0, rows.appPlugins)
+		});
+	}
+	const hostPlugins = HOST_PLUGINS.filter((plugin) => library.has(plugin) && !existsSync(join(appDir, "plugins", plugin)));
+	const oldScript = join(appDir, OLD_PROFILE_SCRIPT);
+	const removeProfileScript = existsSync(oldScript) && GENERATED_MARKER.test(readText(oldScript).split("\n", 1)[0] ?? "");
+	const input = frameProfileInput(specs, name, rows.rows);
+	const profile = planIdeProfileWrite(appDir, input);
+	const conflicts = [...files.filter((file) => file.state === "conflict").map((file) => file.file), ...profile.files.filter((file) => file.state === "conflict").map((file) => file.file)];
+	const changed = files.some((file) => file.state !== "same") || profile.manifestChanged || profile.files.some((file) => file.state !== "same") || hostPlugins.length > 0 || removeProfileScript;
+	return {
+		kind: "planned",
+		template,
+		input,
+		profile,
+		files,
+		kept,
+		hostPlugins,
+		removeProfileScript,
+		conflicts,
+		...conflictLines === void 0 ? {} : { conflictLines },
+		changed
+	};
+}
+/** The `frame` line `upgrade` prints: every file it changes, or why it leaves the app alone. */
+function frameReport(frame) {
+	if (frame.kind === "broken-scaffold") return `${frame.file} imports './plugins/...', as acrylblends 0.3.0 through 0.7.7 wrote it (the plugins are one folder up; 0.7.8 fixed the paths), so the app cannot start: change those imports to '../plugins/...' and run again`;
+	if (frame.kind === "unidentified") return `not the scaffold of any published acrylblends release (${releasedRange()}), so it was edited or another version made it: left on the framework alone`;
+	if (frame.kind === "no-frame-template") return `the ${frame.template} template has no src/frame.ts yet: left standalone`;
+	if (frame.kind === "unavailable") return "left on the framework alone: not a desktop app (`acrylblends add desktop` makes it one), or ACRYLBLENDS_FRAME_PACKAGES is none";
+	const parts = [];
+	for (const file of frame.files) if (file.state !== "same") parts.push(`${file.file} ${file.state === "update" ? "updated" : "added"}`);
+	for (const file of frame.profile.files) if (file.state !== "same") parts.push(`${file.file} ${file.state === "update" ? "updated" : "added"}`);
+	if (frame.profile.clientRowsAdded.length > 0) parts.push(`scripts/ide-host.mjs client rows added (${frame.profile.clientRowsAdded.join(", ")})`);
+	for (const plugin of frame.hostPlugins) parts.push(`plugins/${plugin} added`);
+	if (frame.removeProfileScript) parts.push(`${OLD_PROFILE_SCRIPT} removed`);
+	if (frame.profile.manifestChanged) parts.push("package.json merged (dev runs scripts/ide-host.mjs)");
+	for (const { file, mountable } of frame.kept) if (!mountable) parts.push(`${file} kept as the app's (edited): it does not export FRAME_MOUNT_PREFIX, so the frame cannot show the app until it does (a fresh app's ${file} shows how)`);
+	return parts.length === 0 ? "up to date" : parts.join(", ");
+}
 /**
 * `acrylblends upgrade`: bring the library plugins an app carries (the router, the server, the door, `extensions`, ...) up to the version of this package. Each file is compared with what
 * the app was given: an untouched file is replaced, a file the app edited stops the upgrade (it is shown as a diff and nothing changes) unless `--force`, which saves the edited version
@@ -1680,8 +3599,16 @@ async function upgrade(options, io) {
 		return 1;
 	}
 	const selected = (options.names.length > 0 ? [...options.names] : carried).filter((name) => library.has(name));
-	if (selected.length === 0) {
-		io.stdout.write("nothing to upgrade: the app carries no library plugins\n");
+	const frame = planFrameStep(appDir, library);
+	if (frame.kind === "planned" && frame.conflicts.length > 0 && !options.force) {
+		const own = frame.conflictLines?.["src/app.ts"] ?? [];
+		const detail = own.length === 0 ? "" : `\n  src/app.ts keeps the framework's plugin registrations; the app's own lines are ${own.map((line) => `line ${String(line.line)} (${JSON.stringify(line.text)})`).join(", ")}`;
+		io.stderr.write(`error: ${frame.conflicts.join(", ")} in ${appDir} ${frame.conflicts.length === 1 ? "is" : "are"} not the previous release's scaffold and acrylblends did not write ${frame.conflicts.length === 1 ? "it" : "them"}; nothing was changed.${detail} Move the app's version aside (or merge it into the template's) and run again, or run again with --force (the app's versions are saved under .acrylblends/upgrade-backup/ first)\n`);
+		return 1;
+	}
+	const frameChanged = frame.kind === "planned" && frame.changed;
+	if (selected.length === 0 && !frameChanged) {
+		io.stdout.write(frame.kind === "planned" ? "nothing to upgrade: the library plugins and the frame are up to date\n" : `nothing to upgrade: the app carries no library plugins\n  ${"frame".padEnd(22)} ${frameReport(frame)}\n`);
 		return 0;
 	}
 	const scratch = join(appDir, ".acrylblends", `upgrade-${process.pid}-${Date.now()}`);
@@ -1753,6 +3680,7 @@ async function upgrade(options, io) {
 			io.stdout.write(`  ${label} ${parts.join(", ")}\n`);
 		}
 		for (const name of unknown) io.stdout.write(`  ${name.padEnd(22)} not in this library: left alone\n`);
+		io.stdout.write(`  ${"frame".padEnd(22)} ${frameReport(frame)}\n`);
 		for (const plan of plans) for (const [file, state] of plan.files) {
 			if (!(state === "conflict" || options.diff && (state === "update" || state === "add" || state === "remove"))) continue;
 			const name = `plugins/${plan.plugin.name}/${file}`;
@@ -1765,10 +3693,10 @@ async function upgrade(options, io) {
 			return 1;
 		}
 		if (options.dryRun) {
-			io.stdout.write(`\n${changes === 0 ? "everything is up to date" : "dry run: nothing was changed"}\n`);
+			io.stdout.write(`\n${changes === 0 && !frameChanged ? "everything is up to date" : "dry run: nothing was changed"}\n`);
 			return 0;
 		}
-		if (changes === 0) {
+		if (changes === 0 && !frameChanged) {
 			io.stdout.write("\neverything is up to date\n");
 			return 0;
 		}
@@ -1807,8 +3735,36 @@ async function upgrade(options, io) {
 			manifest.dependencies.acrylblends = `^${VERSION}`;
 			writeFileSync(manifestFile, `${JSON.stringify(manifest, null, 2)}\n`);
 		}
-		io.stdout.write(`\nupgraded ${plans.filter((p) => [...p.files.values()].some((s) => s !== "same" && s !== "extra") || p.isNew).map((p) => p.plugin.name).join(", ")}\n`);
-		if (conflicts > 0) io.stdout.write(`the ${conflicts} edited file(s) replaced by --force are saved in ${posix$1(relative(appDir, backup))}/\n`);
+		let frameBackups = 0;
+		if (frame.kind === "planned" && frameChanged) {
+			for (const file of [...frame.files, ...frame.profile.files]) {
+				if (file.state !== "conflict") continue;
+				mkdirSync(dirname(join(backup, file.file)), { recursive: true });
+				cpSync(join(appDir, file.file), join(backup, file.file));
+				frameBackups += 1;
+			}
+			for (const plugin of frame.hostPlugins) {
+				const known = library.get(plugin);
+				if (known === void 0) continue;
+				copyPlugin(known, appDir);
+				if (known.imports) mergeImports(appDir, known.imports, "plugins");
+				addedDependencies.push(...mergeDependencies(appDir, known.dependencies));
+				addedDependencies.push(...mergeTooling(appDir, known).devDependencies);
+				appendGitignore(appDir, known.gitignore);
+				recordLibraryCopy(folder.dir, plugin);
+			}
+			for (const file of frame.files) {
+				if (file.state === "same") continue;
+				const target = join(appDir, file.file);
+				mkdirSync(dirname(target), { recursive: true });
+				writeFileSync(target, file.text);
+			}
+			writeIdeProfilePlan(appDir, planIdeProfileWrite(appDir, frame.input));
+			if (frame.removeProfileScript) rmSync(join(appDir, OLD_PROFILE_SCRIPT), { force: true });
+		}
+		const upgradedPlugins = plans.filter((p) => [...p.files.values()].some((s) => s !== "same" && s !== "extra") || p.isNew).map((p) => p.plugin.name);
+		io.stdout.write(`\nupgraded ${[...upgradedPlugins, ...frameChanged ? ["the frame"] : []].join(", ")}\n`);
+		if (conflicts + frameBackups > 0) io.stdout.write(`the ${conflicts + frameBackups} edited file(s) replaced by --force are saved in ${posix$1(relative(appDir, backup))}/\n`);
 		io.stdout.write(`acrylblends is now ^${VERSION} in package.json${addedDependencies.length > 0 ? `; new dependencies: ${[...new Set(addedDependencies)].join(", ")}` : ""}: run npm install, then npm run check and npm test\n`);
 		return 0;
 	} finally {
@@ -1831,6 +3787,8 @@ Usage:
                                       Bring the library plugins an app carries (the router, the server, the door, ...) up to this
                                       version: untouched files are replaced, an edited file stops it (diff shown) unless --force
   acrylblends plugins                    List the plugin library
+  acrylblends open [dir]           Print the address of the frame running this app (the URL npm run dev printed),
+                                      for a page that has to be opened again after its session ended
   acrylblends preflight                  Check this machine for the workshop: Node, npm, git, a coding agent, a free port
                                       (and on Windows PowerShell and long paths); one line per check, PASS or the fix
   acrylblends build-client [root] [out]  Compile the client modules once for production (src/client to dist/client)
@@ -1873,6 +3831,7 @@ async function runCli(argv, io = processIo()) {
 		if (command === "kv") return await kvImport(parseKv(args), io);
 		if (command === "check-deps") return checkDeps(parseCheckDeps(args), io);
 		if (command === "plugins") return listPlugins(io);
+		if (command === "open") return await openFrame(args, io);
 		if (command === "preflight") return await runPreflight(io);
 		throw new UsageError(`unknown command "${command}"`);
 	} catch (error) {
@@ -1895,6 +3854,6 @@ function parseKv(args) {
 	return parseKvOptions(args);
 }
 //#endregion
-export { HELP, TEMPLATES, TEMPLATE_ALIASES, TEMPLATE_SUMMARY, TargetNotEmptyError, UsageError, VERSION, add, assertTargetFree, closure, copyPlugin, copyTemplate, init, isOmitted, isTemplate, isValidName, libraryRoot, listPlugins, mergeDependencies, nameFrom, parseAddOptions, parseInitOptions, parseUpgradeOptions, readLibrary, readTemplatePlugins, resolveTemplate, runCli, templateDir, templatesRoot, upgrade };
+export { FRAME_URL_FILE, HELP, TEMPLATES, TEMPLATE_ALIASES, TEMPLATE_SUMMARY, TargetNotEmptyError, UsageError, VERSION, add, assertTargetFree, closure, copyPlugin, copyTemplate, frameHome, frameUrlPath, init, isOmitted, isTemplate, isValidName, libraryRoot, listPlugins, lookUpFrameUrl, mergeDependencies, mergeTooling, nameFrom, openFrame, parseAddOptions, parseInitOptions, parseUpgradeOptions, readFrameUrl, readLibrary, readTemplatePlugins, removeFrameUrl, resolveTemplate, runCli, templateDir, templatesRoot, tokenOfFrameUrl, upgrade, writeFrameUrl };
 
 //# sourceMappingURL=index.js.map