@akanjs/devkit 3.1.1-rc.8 → 3.1.1

package/codeAgent/skills/akan-page/SKILL.md

@@ -0,0 +1,44 @@
+---
+name: akan-page
+description: "Add or change a route under page/: the one page()/layout() chain, typed params and search, guards, heads, loading and errors, overrides, and lib pages."
+---
+
+# Akan pages
+
+A route file exports one chain and nothing else. Every setting is a stage of it.
+
+```tsx
+export default page()
+  .param("orgId", ID)
+  .guard(() => signedIn())
+  .render(({ orgId }) => {
+    const { l } = usePage();
+    const { taskInitInOrg } = fetch.initTaskInOrg(orgId);
+    return <Task.Zone.Card init={taskInitInOrg} prefix={`/org/${orgId}`} />;
+  });
+```
+
+## Steps
+
+1. Place the file: `<route>.tsx` or `<dir>/_index.tsx` serves the path, `_layout.tsx` nests a layout (`layout()`;
+   the root one is `rootLayout()`), `[id]` is a dynamic segment, `(group)` groups without a segment. `page/` holds
+   route modules only — no helpers, no `.ts` files.
+2. Name every `[x]` segment with `.param("x", Type)` and read a query key only with `.search("k", Type)`. Values
+   arrive typed; `lang` reaches every stage and is never declared.
+3. Gate with `.guard(() => signedIn())` on the `_layout.tsx` (a real redirect before anything renders), and repeat
+   a stricter guard on a page that needs more. The endpoint guards are still the real gate.
+4. In `.render()`: `usePage()`, then fetch, then return. Hand `fetch.init*` / `view*` / `edit*` fields to sections
+   unawaited; await only what the shell reads, in one `Promise.all`.
+5. `.head()` takes JSX (or a function returning it), never a metadata object. A canonical link comes only from the
+   page's own head.
+6. Re-skin an `akanjs/ui` component for a subtree with `_overrides.tsx`:
+   `export default override({ Slot: AppComponent })`, no logic.
+
+## Never
+
+- A `fetch.<mutation>()` while rendering — it throws `base.error.mutationInRender`, because opening a link would
+  perform it. Send writes from a user action.
+- `useState`, `useEffect`, comments, a named export beside the chain, or the legacy `export default async function`.
+- Editing a lib page through its link in `page/(libs)/` — edit the lib's own `page/` source.
+
+Full detail: `get_guideline` with `pageRule`, or `ssrRule` for what may render on the server.

package/codeAgent/skills/akan-query/SKILL.md

@@ -0,0 +1,38 @@
+---
+name: akan-query
+description: "Write filters, slices and list loading: query descriptors, init paging and loadMoreOf, soft removal and hookless writes, q.search text search, and the cascade direction."
+---
+
+# Akan queries and slices
+
+## Filters and slices
+
+- A filter in `<model>.document.ts` declares its args; a slice in `<model>.signal.ts` serves it to stores. A slice
+  `exec` returns a `query<Filter>(…)` descriptor — never a `list<Filter>` array — and you cannot chain sort or
+  limit on it.
+- Page through the store: `initX(…, { sort, page, limit })`, then `st.do.loadMoreOf<Model>()` while
+  `hasMoreOf<Model>`. Never compare `count > page * limit`.
+- Never ask for more than 500 rows: the server serves at most 500 per request and drops the rest silently.
+  A figure over the whole set belongs in an insight or an endpoint.
+- The root slice takes a filter name and its args, never a raw query, and its `root:` guard is always `Admin`.
+- No value is `q.empty`, never `q.missing`.
+- A projection is bare on the facade (`pickById(id, { secret: true })`) and under `select` on a filter accessor —
+  the only way to read a `field.secret` value.
+
+## Writes and removal
+
+- Removal is soft: reads see live rows unless `{ withRemoved: true }`. The one hard delete is `purge<Filter>` /
+  `purgeMany`, for data past retention.
+- A filter's `remove*` / `update*`, `updateById` and `removeById` run no hooks and no cascade. A model with a
+  cascade or `_postRemove` removes through `remove<Model>(id)`.
+- Load a set once (`load<Model>Many`, one filter query) instead of one call per item in a loop — lint fails a
+  per-item service call an endpoint reaches.
+
+## Search and cascade
+
+- `q.search(text, { prefix: true })` sits in a filter at an AND position, over fields with the `text` role. Blank
+  input matches nothing — never a passthrough. A search slice only over data safe to enumerate.
+- `cascade` names a direction, and the wrong one loses data: `removeRef` on the owner's relation, `removeWith` on
+  the child's reference to its owner.
+
+Full detail: `get_guideline` with `queryRule`, and `workspaceRecipes` for a worked slice.

package/codeAgent/skills/akan-runtime/SKILL.md

@@ -0,0 +1,40 @@
+---
+name: akan-runtime
+description: "Configure how an app runs: web surfaces, route prefixes, gateway vs solo, akan start and logs, the Docker image, native and desktop apps, database modes, ops, assets and the build pipeline."
+---
+
+# Akan runtime
+
+Runtime and build settings are declared in `akan.config.ts` and narrowed — never widened — by an env at boot.
+Domain code reaches none of them.
+
+## Where each setting lives
+
+| Want | Setting |
+| --- | --- |
+| API only, or no CSR bundle for native apps | `web: false`, `web: { csr: false }` |
+| Move the API or websocket mount | `new AkanApp({ prefix, websocketPrefix })` in `main.ts`, mirrored in `api: { … }`; read with `getApiPrefix()` / `getWsPrefix()` |
+| The production image | `docker: string \| { image, preRuns, postRuns, command }` |
+| iOS, Android, desktop | the `native` section; `desktop: { server: true }` carries the server |
+| SQLite, several databases, a cluster | `database: { modes: [...] }`, picked by `AKAN_DATABASE_MODE` |
+
+- `main.ts` imports `AkanApp` from `akanjs/server/akanApp`, never the barrel.
+- Never write `/api` or `/ws` literally, and never pass a prefix as a prop.
+- The generated image installs only `ca-certificates` and `tzdata`; add the rest in `preRuns`.
+- An app running in two database modes avoids `q.raw`.
+
+## Running and logs
+
+- `akan start <app>` (`a,b` or `all` for several) runs the dev server; `akan build <app>` checks the production
+  build. A supervised session writes `local/apps/<app>/runtime/dev.log` — hand over that path, not a paste of the
+  live view. Tail with `akan logs <app>`.
+- Give every log sink a floor (`Logger.addSink(sink, { minLevel })`) and never log once per delivered record.
+
+## Native and desktop
+
+- `akan start-desktop <app>`, `akan start-ios <app>`, `akan start-android <app>` load pages from a running
+  `akan start`; a desktop app carrying its server starts it itself.
+- A desktop app's carried server listens on a loopback port any local program can call — guard it like a network
+  server. Read runtime files from `AKAN_APP_DIR`, and keep a user's secret with `NativeSecret`, never in a file.
+
+Full detail: `get_guideline` with `runtimeRule`.

package/codeAgent/skills/akan-scaffold/SKILL.md

@@ -43,8 +43,8 @@ Each result names the next call in `next.tool`. Follow it; do not improvise.
    and each workflow's inputs.)
 2. `apply_workflow({ planPath })` — writes the scaffold and syncs the generated barrels. Returns
    `validationTarget`.
-3. `run_validation({ runIdOrPlan: <validationTarget> })`, or just call `akan_verify`, which runs the whole
-   chain over everything the working tree changed.
+3. `run_validation({ runIdOrPlan: <validationTarget> })`, or run `akan verify` (`akan_verify` in akan code);
+   both are the whole chain in one process.
 4. **Read each scaffolded file before editing it.** They are a few lines each and they extend base classes
    that already generated the CRUD surface. Read the `akan-store` skill before touching a store or adding
    signal endpoints, or you will redeclare `create<Model>` and hit an "already exists" typecheck error.
@@ -60,9 +60,19 @@ Each result names the next call in `next.tool`. Follow it; do not improvise.
 - Hand-writing files is the fallback, used only when no workflow matches, or when apply reports
   unsupported / no-op / failed diagnostics telling you to act manually. Say which case applied.
 - Never hand-edit a generated file to "finish" a scaffold — use `repair_generated` or `akan sync <app>`.
-- No workflow tools this turn? The same order through bash:
-  `akan workflow list` → `akan workflow plan create-module --app <app> --module comment --format json --out <path>`
-  → `akan workflow apply <path> --format json`.
+
+## No workflow tools? The CLI is the same chain
+
+The tools come from `akan mcp` (`--mode plan` reads, `--mode apply` writes). When they are not connected, each
+has a command that prints the same report:
+
+| tool | command |
+| --- | --- |
+| `list_workflows` / `explain_workflow` | `akan workflow list` / `akan workflow explain <name>` |
+| `plan_workflow` | `akan workflow plan create-module --app <app> --module comment --format json --out <path>` |
+| `apply_workflow` | `akan workflow apply <path> --format json` (`--dry-run` previews) |
+| `run_validation` | `akan verify <app>` |
+| `repair_generated` / `repair_imports` / `repair_module_shape` | `akan repair generated\|imports\|module-shape --app <app>` |
 
 ## Worked example — "an intro page, two detail pages, and a comment zone with a database"
 
@@ -73,4 +83,4 @@ Each result names the next call in `next.tool`. Follow it; do not improvise.
    leave the store body empty unless you need extra state.
 4. Write the pages and the comment UI against the generated actions — `st.do.createComment`,
    `st.do.initCommentInPublic`, `st.use.commentListInPublic`.
-5. `akan_verify` until clean.
+5. `akan verify` until it prints `verify ok`.

package/codeAgent/skills/akan-transport/SKILL.md

@@ -0,0 +1,40 @@
+---
+name: akan-transport
+description: "Guard and tune endpoints on the wire: writing a Can<Verb><Model> guard, deadlines, cache, idempotency, rate limits, server-to-server calls, body types, bytes and HTTP verbs."
+---
+
+# Akan transport
+
+## Guards
+
+- Every custom `query` / `mutation` / `pubsub` / `message` names its own `guards: [...]`; every `slice()` takes an
+  explicit guard map with `root: Admin`. `Public` belongs on a slice `get:`, and on a mutation only for an act that
+  must work signed out (sign-up, sign-in, token refresh, an OAuth route), which also declares a `rateLimit`.
+- A resource guard is a `Can<Verb><Model>` class in the model library's `srvkit/guards.ts` that fails closed:
+  no resource named, or a load that throws, is `false` (after a `logger.warn`). Admin bypass goes first.
+- Every guard declares `static scope`: `"account"` reads only the caller (`SignedIn`, `Admin`, roles), and
+  `"resource"` needs the call's arguments (every `Can<Verb><Model>`). Keep `static name = "User";` with a comment.
+- Guards read `context.get<T>("account")`, serve HTTP and websocket alike, and stay side-effect free. The acting
+  user comes from `.with(Self)` / `.with(CurrentUserId)` / `.with(Me)`, the address from `.with(Ip)` — never a
+  client-supplied id. The service re-checks ownership: two independent gates.
+
+## Endpoint options
+
+- `{ timeout: <ms> }` is the deadline on both ends; undeclared, the client quits at 30 s and the handler is not
+  cancelled.
+- `{ cache }` only on a `query` with no internal argument, capped at one day; `invalidate(endpoint, args?)` drops
+  it early through a plugged `EndpointCacheControl`.
+- `{ rateLimit: { calls, windowMs?, by? } }` per endpoint, `option.setRateLimit` per app, `plug(RateLimit)` for a
+  business key.
+- A mutation repeated under one `Idempotency-Key` header runs once and replays its first answer.
+- `{ method: "PATCH" | "PUT" | "DELETE" }` moves a mutation off `POST` — only when a foreign protocol forces it.
+- `errors: { 409: ["ticket.error.locked"] }` names the errors an endpoint throws on purpose.
+
+## Bodies and other servers
+
+- `.body()` / `.param()` take scalars, model refs or `enumOf(...)`; `Int` / `Float`, never `Number`; bytes are
+  `Binary`, never `Any`; `Upload` only in a `fileUpload: true` mutation.
+- Server to server, `fetch.clone({ origin })` opens no socket without `connect: true`, retries through `retry`,
+  and rethrows a remote `Err` as it is — never wrap or re-key it.
+
+Full detail: `get_guideline` with `transportRule`, or `mcpRule` for what a guard's scope does to an MCP listing.

package/codeAgent/skills/akan-validate/SKILL.md

@@ -7,17 +7,19 @@ description: "Run the akan check loop after editing and fix each failure class t
 
 ## One call does the whole chain
 
-`akan_verify` runs sync → lint → typecheck → `quality ssr` over everything the working tree has changed, in
-the right order, and reports only what failed. **Call it after editing, before you say you are done.** It
-also runs itself at the end of a turn that changed source, so a failure comes back to you either way.
-
-The same chain by hand, for the app you are editing:
-
-- `akan sync <app>` — after adding, renaming, or deleting any file. Regenerates the barrels.
-- `akan lint <app>` — fast; run after every edit. Prints up to 200 diagnostics.
-- `akan typecheck <app>` — the client/server boundary violations land here, not in lint.
-- `akan quality ssr` — only when you wrote or changed a `.tsx`. Did the server share hold?
-- `akan build <app>` — the full production build; slower, and only when the build itself is in question.
+`akan verify` (the `akan_verify` tool in akan code) syncs, lints with fixes, typechecks, fast-builds each
+changed app, and runs the SSR check for a `.tsx` change — over everything the working tree has changed, in one
+process. It prints one line when it passes and one line per problem when it fails. **Run it after editing,
+before you say you are done.** In akan code it also runs itself at the end of a turn that changed source.
+
+Never run `akan lint`, `akan typecheck` and `akan build` in turn: that is the same work three times over, at
+three times the output. Narrow the one command instead:
+
+- `akan verify <app-or-lib-or-pkg>` — that target whole, changed or not.
+- `akan verify --lint-only` — the quick pass between edits.
+- `akan verify --no-build` — leave the app build out.
+- `akan verify --max 0` — every line, when the report ends in `+N more`.
+- `fixed N files` in the header means lint rewrote them on disk: re-read before editing them again.
 
 Raw `tsc` misses the generated barrels and reports false errors. Do not reach for it.
 

package/codeAgent/tools/AkanCli.ts

@@ -24,7 +24,8 @@ export class AkanCli {
       cwd: this.#cwd,
       stdout: "pipe",
       stderr: "pipe",
-      env: { ...process.env, FORCE_COLOR: "0", NO_COLOR: "1" },
+      //? A workspace .env's AKAN_PUBLIC_LOG_LEVEL=verbose reaches the child too, and buried its error under 90 lines.
+      env: { ...process.env, FORCE_COLOR: "0", NO_COLOR: "1", AKAN_LOG_STDOUT_LEVEL: "warn" },
     });
     const timer = setTimeout(() => proc.kill(), timeoutMs);
     const [stdout, stderr, exitCode] = await Promise.all([

package/codeAgent/tools/AkanCodePlugins.ts

@@ -1,11 +1,12 @@
 import type { InlineExtension } from "@earendil-works/pi-coding-agent";
 import type { CodeAgentMcpStatus, CodeAgentProfile, CodeAgentQuestion, CodeAgentSubagent } from "akanjs/common";
 import type { Workspace } from "../../commandDecorators";
+import { PreviewView } from "../../preview/PreviewView";
+import type { CodeAgentModelRef } from "../agent/akanCodeModel";
 import type { CodeMailbox } from "../agent/CodeMailbox";
 import { SubagentPool, type SubagentSpend } from "../agent/SubagentPool";
 import { DevLogFeedback } from "../feedback/DevLogFeedback";
 import { PreviewFeedback } from "../feedback/PreviewFeedback";
-import { PreviewView } from "../feedback/PreviewView";
 import { TurnFeedback, type TurnFeedbackSource } from "../feedback/TurnFeedback";
 import { VerifyFeedback } from "../feedback/VerifyFeedback";
 import { AkanToolPack } from "./AkanToolPack";
@@ -23,6 +24,8 @@ export interface AkanCodePluginsOptions {
   /** Apps whose dev server should be watched, and whose page should be probed. */
   apps: string[];
   canSeeImages: boolean;
+  /** The owning agent's model as it is now; a `task` child runs on it. */
+  model?: () => CodeAgentModelRef | undefined;
   deepseek?: DeepSeekWeb | undefined;
   /** How many `task` levels deep the owning agent is. */
   depth: number;
@@ -92,6 +95,7 @@ export class AkanCodePlugins {
       workspace: options.workspace,
       cwd: options.cwd,
       parent: options.profile,
+      ...(options.model ? { model: options.model } : {}),
       depth: options.depth,
       ...(options.subagentSpend ? { spend: options.subagentSpend } : {}),
       ...(options.onNotice ? { onNotice: options.onNotice } : {}),

package/codeAgent/tools/AkanEditScope.ts

@@ -2,12 +2,13 @@ export interface AkanEditScopeResult {
   paths: string[];
   apps: string[];
   libs: string[];
+  pkgs: string[];
   /** A created, deleted or renamed file under `apps/**` or `libs/**` — the only kind a barrel has to catch up with. */
   needsSync: boolean;
   touchesTsx: boolean;
 }
 
-const empty: AkanEditScopeResult = { paths: [], apps: [], libs: [], needsSync: false, touchesTsx: false };
+const empty: AkanEditScopeResult = { paths: [], apps: [], libs: [], pkgs: [], needsSync: false, touchesTsx: false };
 
 // Read from git, not tool events: an edit made through `bash` (a heredoc, sed, a codemod) produces no write tool call.
 export class AkanEditScope {
@@ -21,6 +22,7 @@ export class AkanEditScope {
       paths,
       apps: AkanEditScope.#targets(paths, "apps"),
       libs: AkanEditScope.#targets(paths, "libs"),
+      pkgs: AkanEditScope.#targets(paths, "pkgs"),
       needsSync: entries.some((entry) => /[ARD?]/.test(entry.code) && /^(apps|libs)\//.test(entry.file)),
       touchesTsx: paths.some((file) => file.endsWith(".tsx")),
     };
@@ -38,10 +40,13 @@ export class AkanEditScope {
     return new Set(text.split("\n").filter((line) => line.trim().length > 3));
   }
 
-  static #targets(paths: string[], root: "apps" | "libs") {
+  static #targets(paths: string[], root: "apps" | "libs" | "pkgs") {
     const names = paths
       .filter((file) => file.startsWith(`${root}/`))
-      .map((file) => file.split("/")[1] ?? "")
+      .map((file) => {
+        const [, first = "", second = ""] = file.split("/");
+        return first.startsWith("@") && second ? `${first}/${second}` : first;
+      })
       .filter(Boolean);
     return [...new Set(names)];
   }

package/codeAgent/tools/AkanToolPack.ts

@@ -1,7 +1,6 @@
 import type { ExtensionAPI, InlineExtension } from "@earendil-works/pi-coding-agent";
 import { Type } from "typebox";
 import type { Workspace } from "../../commandDecorators";
-import { AkanEditScope } from "./AkanEditScope";
 import { AkanVerifier } from "./AkanVerifier";
 
 export interface AkanToolPackOptions {
@@ -66,17 +65,12 @@ export class AkanToolPack {
       name: AkanToolPack.verifyToolName,
       label: "akan verify",
       description:
-        "Run the akan validation chain (sync, lint, typecheck, and quality ssr for .tsx changes) over everything the working tree has changed, and report what failed. Call this after editing before you finish.",
-      promptSnippet: "akan_verify: run sync/lint/typecheck/quality over the working tree's changes",
+        "Run `akan verify` over everything the working tree has changed: sync, lint (with fixes), typecheck, a fast build of each changed app, and the SSR check for .tsx changes, in one call. It prints one line when it passes and one line per problem when it fails. Call this after editing, before you finish; never run lint, typecheck or build separately.",
+      promptSnippet: "akan_verify: sync, lint, typecheck and build what the working tree changed, in one call",
       parameters: Type.Object({}),
       execute: async () => {
-        const scope = await AkanEditScope.since(this.#options.cwd, new Set());
-        const report = await verifier.verify(scope);
-        return {
-          content: [{ type: "text", text: AkanVerifier.summarize(report) }],
-          details: undefined,
-          isError: !report.ok,
-        };
+        const report = await verifier.verify();
+        return { content: [{ type: "text", text: report.text }], details: undefined, isError: !report.ok };
       },
     });
   }

package/codeAgent/tools/AkanVerifier.ts

@@ -1,48 +1,30 @@
 import { AkanCli, type AkanCliResult } from "./AkanCli";
-import type { AkanEditScopeResult } from "./AkanEditScope";
 
 export interface AkanVerifyReport {
   ok: boolean;
-  steps: AkanCliResult[];
-  scope: AkanEditScopeResult;
+  text: string;
 }
 
 export class AkanVerifier {
+  static readonly tailLines = 20;
   readonly #cli: AkanCli;
 
   constructor(cwd: string) {
     this.#cli = new AkanCli(cwd);
   }
 
-  async verify(scope: AkanEditScopeResult): Promise<AkanVerifyReport> {
-    const steps: AkanCliResult[] = [];
-    const targets = [...scope.apps, ...scope.libs];
-    // Order matters: a stale barrel reads to typecheck as a missing symbol, and lint moves the positions it reports.
-    if (scope.needsSync) for (const target of targets) steps.push(await this.#cli.run(["sync", target]));
-    for (const target of targets) steps.push(await this.#cli.run(["lint", target]));
-    for (const app of scope.apps) steps.push(await this.#cli.run(["typecheck", app]));
-    if (scope.touchesTsx) steps.push(await this.#cli.run(["quality", "ssr"]));
-    return { ok: steps.every((step) => step.ok), steps, scope };
+  async verify(paths: string[] = []): Promise<AkanVerifyReport> {
+    const args = ["verify", ...(paths.length ? ["--files", paths.join(",")] : [])];
+    const result = await this.#cli.run(args, { timeoutMs: 600_000 });
+    return { ok: result.ok, text: AkanVerifier.summarize(result) };
   }
 
-  /** What a model needs to act: which step failed and its tail — never the whole output, which rides every later turn. */
-  static summarize(report: AkanVerifyReport, { tailLines = 40 }: { tailLines?: number } = {}) {
-    if (!report.steps.length) return "No akan target was touched, so there was nothing to verify.";
-    if (report.ok) return `Verification passed: ${report.steps.map((step) => step.command).join(", ")}.`;
-    const failed = report.steps.filter((step) => !step.ok);
-    const passed = report.steps.filter((step) => step.ok).map((step) => step.command);
-    const blocks = failed.map((step) => `### ${step.command} (exit ${step.exitCode})\n${tail(step.output, tailLines)}`);
-    return [
-      `Verification failed: ${failed.map((step) => step.command).join(", ")}.`,
-      passed.length ? `Passed: ${passed.join(", ")}.` : "",
-      ...blocks,
-    ]
-      .filter(Boolean)
-      .join("\n\n");
+  //* `akan verify` already prints the agent-sized report; only a crash before it prints needs trimming.
+  static summarize(result: AkanCliResult) {
+    if (result.output.startsWith("verify ")) return result.output;
+    const lines = result.output.split("\n");
+    const tail =
+      lines.length <= AkanVerifier.tailLines ? result.output : `…\n${lines.slice(-AkanVerifier.tailLines).join("\n")}`;
+    return `${result.command} exited ${result.exitCode} before reporting:\n${tail}`;
   }
 }
-
-const tail = (text: string, lines: number) => {
-  const all = text.split("\n");
-  return all.length <= lines ? text : `…\n${all.slice(-lines).join("\n")}`;
-};

package/codeAgent/tools/akanCodePlugins.test.ts

@@ -5,7 +5,6 @@ import { makeCliTempWorkspace, tempRoots, writeText } from "../../testHelpers";
 import { CodeAgent, type CodeAgentOptions } from "../agent/CodeAgent";
 import { SubagentPool } from "../agent/SubagentPool";
 import { DevLogFeedback } from "../feedback/DevLogFeedback";
-import { PreviewView } from "../feedback/PreviewView";
 import { TurnFeedback, type TurnFeedbackSource } from "../feedback/TurnFeedback";
 import { AkanCodePlugins } from "./AkanCodePlugins";
 import { AkanEditScope } from "./AkanEditScope";
@@ -111,38 +110,18 @@ describe("TurnFeedback", () => {
 });
 
 describe("AkanVerifier.summarize", () => {
-  const scope = { paths: ["apps/a/x.ts"], apps: ["a"], libs: [], needsSync: false, touchesTsx: false };
+  test("passes the verify report through untouched", () => {
+    const output =
+      "verify fail · a · lint ok · typecheck 1 error · 4.1s\napps/a/x.ts:1:7 TS2322 Type 'string' is not assignable to type 'number'.";
+    expect(AkanVerifier.summarize({ command: "akan verify", ok: false, exitCode: 1, output })).toBe(output);
+  });
 
-  test("names the failing step and keeps only its tail", () => {
+  test("keeps only the tail of a crash that never reached the report", () => {
     const output = [...Array(100).keys()].map((n) => `line ${n}`).join("\n");
-    const text = AkanVerifier.summarize(
-      {
-        ok: false,
-        scope,
-        steps: [
-          { command: "akan lint a", ok: true, exitCode: 0, output: "" },
-          { command: "akan typecheck a", ok: false, exitCode: 1, output },
-        ],
-      },
-      { tailLines: 5 },
-    );
-    expect(text).toContain("Verification failed: akan typecheck a");
-    expect(text).toContain("Passed: akan lint a");
+    const text = AkanVerifier.summarize({ command: "akan verify", ok: false, exitCode: 1, output });
+    expect(text).toStartWith("akan verify exited 1 before reporting:");
     expect(text).toContain("line 99");
-    expect(text).not.toContain("line 10\n");
-  });
-
-  test("says so plainly when everything passed", () => {
-    const text = AkanVerifier.summarize({
-      ok: true,
-      scope,
-      steps: [{ command: "akan lint a", ok: true, exitCode: 0, output: "" }],
-    });
-    expect(text).toContain("Verification passed");
-  });
-
-  test("an untouched workspace is not a failure", () => {
-    expect(AkanVerifier.summarize({ ok: true, scope, steps: [] })).toContain("nothing to verify");
+    expect(text).not.toContain("line 79\n");
   });
 });
 
@@ -153,9 +132,11 @@ describe("AkanEditScope", () => {
     const baseline = await AkanEditScope.baseline(root);
     await writeText(path.join(root, "apps", "demo", "lib", "post", "post.service.ts"), "export {};\n");
     await writeText(path.join(root, "libs", "shared", "ui", "Card.tsx"), "export const Card = () => null;\n");
+    await writeText(path.join(root, "pkgs", "@akanjs", "cli", "index.ts"), "export {};\n");
     const scope = await AkanEditScope.since(root, baseline);
     expect(scope.apps).toEqual(["demo"]);
     expect(scope.libs).toEqual(["shared"]);
+    expect(scope.pkgs).toEqual(["@akanjs/cli"]);
     expect(scope.needsSync).toBe(true);
     expect(scope.touchesTsx).toBe(true);
   });
@@ -165,7 +146,7 @@ describe("AkanEditScope", () => {
     await Bun.spawn(["git", "init", "-q"], { cwd: root, stdout: "ignore", stderr: "ignore" }).exited;
     const baseline = await AkanEditScope.baseline(root);
     const scope = await AkanEditScope.since(root, baseline);
-    expect(scope).toEqual({ paths: [], apps: [], libs: [], needsSync: false, touchesTsx: false });
+    expect(scope).toEqual({ paths: [], apps: [], libs: [], pkgs: [], needsSync: false, touchesTsx: false });
   });
 });
 
@@ -243,33 +224,6 @@ describe("AkanEnvKeys", () => {
   });
 });
 
-describe("PreviewView", () => {
-  test("reports whether this Bun build can drive a headless page at all", () => {
-    expect(typeof PreviewView.available).toBe("boolean");
-  });
-
-  test.skipIf(!PreviewView.available)(
-    "finds an empty body and a console error on a real page",
-    async () => {
-      const server = Bun.serve({
-        port: 0,
-        fetch: () =>
-          new Response('<!doctype html><html><body></body><script>console.error("boom")</script></html>', {
-            headers: { "content-type": "text/html" },
-          }),
-      });
-      try {
-        const probe = await PreviewView.probe(`http://localhost:${server.port}/`);
-        expect(probe.pageErrors.join(" ")).toContain("rendered empty");
-        expect(probe.consoleErrors.join(" ")).toContain("boom");
-      } finally {
-        server.stop(true);
-      }
-    },
-    30_000,
-  );
-});
-
 describe("SubagentPool", () => {
   const workspace = { workspaceRoot: "/tmp/akan" } as never;
 
@@ -519,6 +473,54 @@ describe("SubagentPool", () => {
     }
   });
 
+  test("a child runs on the model its parent runs on when the task starts", async () => {
+    const { opened, spy } = openFakeAgents([]);
+    let current = { provider: "deepseek", id: "deepseek-v4-pro" };
+    try {
+      const root = SubagentPool.extensionFor({
+        workspace,
+        cwd: "/tmp/akan",
+        parent: budgeted(1_000),
+        model: () => current,
+        depth: 0,
+      });
+      await runTask(root, "c1");
+      current = { provider: "openai", id: "gpt-5.5" };
+      await runTask(root, "c2");
+      expect(opened.map((options) => options.model)).toEqual([
+        { provider: "deepseek", id: "deepseek-v4-pro" },
+        { provider: "openai", id: "gpt-5.5" },
+      ]);
+    } finally {
+      spy.mockRestore();
+    }
+  });
+
+  test("the plugins hand their pool the owning agent's model", async () => {
+    const { opened, spy } = openFakeAgents([]);
+    try {
+      const plugins = await AkanCodePlugins.build({
+        workspace,
+        cwd: "/tmp/akan",
+        profile: budgeted(1_000),
+        apps: [],
+        canSeeImages: false,
+        model: () => ({ provider: "deepseek", id: "deepseek-v4-pro" }),
+        depth: 0,
+        currentSessionId: () => "",
+        mailbox: () => undefined,
+      });
+      await runTask(
+        plugins.extensions.find((extension) => extension.name === "akan-subagent"),
+        "c1",
+      );
+      expect(opened[0]?.model).toEqual({ provider: "deepseek", id: "deepseek-v4-pro" });
+      plugins.dispose();
+    } finally {
+      spy.mockRestore();
+    }
+  });
+
   test("a child keeps no session and cannot ask a human", () => {
     const child = SubagentPool.childOf(codeAgentPresets.local("/tmp/akan"), "explore");
     expect(child.session).toEqual({ store: "memory", crossSession: false });

package/commandDecorators/workspaceVersionCheck.test.ts

@@ -23,14 +23,24 @@ describe("WorkspaceVersionCheck", () => {
     expect(WorkspaceVersionCheck.warning("3.1.1-rc.5", argv("sync", "demo"), await makeWorkspace({}))).toBeNull();
   });
 
-  test("names both versions and the matching CLI with the same arguments", async () => {
+  test("names both versions and the matching CLI with the same arguments, quoted for the shell it runs in", async () => {
     const root = await makeWorkspace({ akanjs: "3.1.0-rc.6" });
-
-    const warning = WorkspaceVersionCheck.warning("3.1.0", argv("sync", "demo", "--title", "it's"), root);
-
-    expect(warning).toContain("@akanjs/cli 3.1.0, but this workspace has akanjs 3.1.0-rc.6");
-    expect(warning).toContain(`Run the matching CLI: bunx -p @akanjs/cli@3.1.0-rc.6 akan sync demo --title 'it'\\''s'`);
-    expect(warning).toEndWith("together: akan update");
+    const platform = Object.getOwnPropertyDescriptor(process, "platform");
+    const warningOn = (os: NodeJS.Platform) => {
+      Object.defineProperty(process, "platform", { value: os });
+      return WorkspaceVersionCheck.warning("3.1.0", argv("sync", "demo", "--title", "it's"), root);
+    };
+    try {
+      const posix = warningOn("linux");
+      expect(posix).toContain("@akanjs/cli 3.1.0, but this workspace has akanjs 3.1.0-rc.6");
+      expect(posix).toContain(`Run the matching CLI: bunx -p @akanjs/cli@3.1.0-rc.6 akan sync demo --title 'it'\\''s'`);
+      expect(posix).toEndWith("together: akan update");
+      expect(warningOn("win32")).toContain(
+        `Run the matching CLI: bunx -p @akanjs/cli@3.1.0-rc.6 akan sync demo --title "it's"`,
+      );
+    } finally {
+      if (platform) Object.defineProperty(process, "platform", platform);
+    }
   });
 
   test("offers akan update with the CLI's prerelease tag only when the CLI is the newer one", async () => {

package/commandDecorators/workspaceVersionCheck.ts

@@ -45,6 +45,9 @@ export class WorkspaceVersionCheck {
   }
 
   static #quote(arg: string) {
-    return /^[\w@%+=:,./-]+$/.test(arg) ? arg : `'${arg.replaceAll("'", `'\\''`)}'`;
+    if (/^[\w@%+=:,./-]+$/.test(arg)) return arg;
+    //? cmd and PowerShell take neither single quotes nor '\'' as POSIX shells do.
+    if (process.platform === "win32") return `"${arg.replaceAll('"', '\\"')}"`;
+    return `'${arg.replaceAll("'", `'\\''`)}'`;
   }
 }