acrylblends 0.11.0 → 1.0.0

package/lib/{snapshot-text-yaWlezbd.js → snapshot-text-DmE0YfeZ.js}

@@ -5,11 +5,11 @@ import { r as streamSSE } from "./streaming-DHST3Scg.js";
 import { loopbackAuthority, loopbackOnly } from "./loopback-only.js";
 import "./helpers-CvTauQT5.js";
 import { UiControlError, WINDOW_ID, parseChannelToHost } from "./door/protocol.js";
-import "./src-DNzw0Qsb.js";
+import "./src-2Z4mJg0x.js";
 import "./middleware-CPQ8himN.js";
 import { dirname, join } from "node:path";
-import { timingSafeEqual } from "node:crypto";
 import { closeSync, mkdirSync, openSync, readFileSync, renameSync, statSync, writeSync } from "node:fs";
+import { timingSafeEqual } from "node:crypto";
 //#region ../../plugins/acryl-door/src/host/channel.ts
 /**
 * The Host's side of the page channel: the connected pages of the app, and calls that go to the current one (moved from

package/lib/{src-DNzw0Qsb.js → src-2Z4mJg0x.js}

@@ -4,7 +4,6 @@ import { COMPOSED_HANDLER } from "./utils/constants.js";
 import { t as TrieRouter } from "./trie-router-CfFbapzL.js";
 import { t as Acryl } from "./app-BM0rTCp7.js";
 import "./core-CaY8XDZ6.js";
-import "./deprecated-BP4fPt38.js";
 import "./connection-C7xgP1hP.js";
 import { Service } from "@deepseek-ai/cordis";
 import z from "@deepseek-ai/schemastery";

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "acrylblends",
-  "version": "0.11.0",
+  "version": "1.0.0",
   "description": "The Acryl web framework (import { Acryl } from \"acrylblends\") and the acrylblends command that scaffolds Cordis apps.",
   "license": "MIT",
   "type": "module",
@@ -22,10 +22,6 @@
       "types": "./lib/types.d.ts",
       "default": "./lib/types.js"
     },
-    "./acryl-base": {
-      "types": "./lib/acryl-base.d.ts",
-      "default": "./lib/acryl-base.js"
-    },
     "./http-exception": {
       "types": "./lib/http-exception.d.ts",
       "default": "./lib/http-exception.js"
@@ -190,38 +186,10 @@
       "types": "./lib/testing.d.ts",
       "default": "./lib/testing.js"
     },
-    "./aws-lambda": {
-      "types": "./lib/aws-lambda.d.ts",
-      "default": "./lib/aws-lambda.js"
-    },
     "./bun": {
       "types": "./lib/bun.d.ts",
       "default": "./lib/bun.js"
     },
-    "./cloudflare-pages": {
-      "types": "./lib/cloudflare-pages.d.ts",
-      "default": "./lib/cloudflare-pages.js"
-    },
-    "./cloudflare-workers": {
-      "types": "./lib/cloudflare-workers.d.ts",
-      "default": "./lib/cloudflare-workers.js"
-    },
-    "./lambda-edge": {
-      "types": "./lib/lambda-edge.d.ts",
-      "default": "./lib/lambda-edge.js"
-    },
-    "./netlify": {
-      "types": "./lib/netlify.d.ts",
-      "default": "./lib/netlify.js"
-    },
-    "./service-worker": {
-      "types": "./lib/service-worker.d.ts",
-      "default": "./lib/service-worker.js"
-    },
-    "./vercel": {
-      "types": "./lib/vercel.d.ts",
-      "default": "./lib/vercel.js"
-    },
     "./ws": {
       "types": "./lib/ws.d.ts",
       "default": "./lib/ws.js"
@@ -306,94 +274,6 @@
       "types": "./lib/router/linear-router.d.ts",
       "default": "./lib/router/linear-router.js"
     },
-    "./utils/jwt": {
-      "types": "./lib/utils/jwt.d.ts",
-      "default": "./lib/utils/jwt.js"
-    },
-    "./utils/accept": {
-      "types": "./lib/utils/accept.d.ts",
-      "default": "./lib/utils/accept.js"
-    },
-    "./utils/basic-auth": {
-      "types": "./lib/utils/basic-auth.d.ts",
-      "default": "./lib/utils/basic-auth.js"
-    },
-    "./utils/body": {
-      "types": "./lib/utils/body.d.ts",
-      "default": "./lib/utils/body.js"
-    },
-    "./utils/buffer": {
-      "types": "./lib/utils/buffer.d.ts",
-      "default": "./lib/utils/buffer.js"
-    },
-    "./utils/color": {
-      "types": "./lib/utils/color.d.ts",
-      "default": "./lib/utils/color.js"
-    },
-    "./utils/compress": {
-      "types": "./lib/utils/compress.d.ts",
-      "default": "./lib/utils/compress.js"
-    },
-    "./utils/concurrent": {
-      "types": "./lib/utils/concurrent.d.ts",
-      "default": "./lib/utils/concurrent.js"
-    },
-    "./utils/constants": {
-      "types": "./lib/utils/constants.d.ts",
-      "default": "./lib/utils/constants.js"
-    },
-    "./utils/cookie": {
-      "types": "./lib/utils/cookie.d.ts",
-      "default": "./lib/utils/cookie.js"
-    },
-    "./utils/crypto": {
-      "types": "./lib/utils/crypto.d.ts",
-      "default": "./lib/utils/crypto.js"
-    },
-    "./utils/encode": {
-      "types": "./lib/utils/encode.d.ts",
-      "default": "./lib/utils/encode.js"
-    },
-    "./utils/filepath": {
-      "types": "./lib/utils/filepath.d.ts",
-      "default": "./lib/utils/filepath.js"
-    },
-    "./utils/handler": {
-      "types": "./lib/utils/handler.d.ts",
-      "default": "./lib/utils/handler.js"
-    },
-    "./utils/headers": {
-      "types": "./lib/utils/headers.d.ts",
-      "default": "./lib/utils/headers.js"
-    },
-    "./utils/html": {
-      "types": "./lib/utils/html.d.ts",
-      "default": "./lib/utils/html.js"
-    },
-    "./utils/http-status": {
-      "types": "./lib/utils/http-status.d.ts",
-      "default": "./lib/utils/http-status.js"
-    },
-    "./utils/ipaddr": {
-      "types": "./lib/utils/ipaddr.d.ts",
-      "default": "./lib/utils/ipaddr.js"
-    },
-    "./utils/mime": {
-      "types": "./lib/utils/mime.d.ts",
-      "default": "./lib/utils/mime.js"
-    },
-    "./utils/stream": {
-      "types": "./lib/utils/stream.d.ts",
-      "default": "./lib/utils/stream.js"
-    },
-    "./utils/types": {
-      "types": "./lib/utils/types.d.ts",
-      "default": "./lib/utils/types.js"
-    },
-    "./utils/url": {
-      "types": "./lib/utils/url.d.ts",
-      "default": "./lib/utils/url.js"
-    },
     "./loopback-only": {
       "types": "./lib/loopback-only.d.ts",
       "default": "./lib/loopback-only.js"
@@ -450,6 +330,10 @@
       "types": "./lib/kv/conformance.d.ts",
       "default": "./lib/kv/conformance.js"
     },
+    "./drivers": {
+      "types": "./lib/drivers.d.ts",
+      "default": "./lib/drivers.js"
+    },
     "./door/host": {
       "types": "./lib/door/host.d.ts",
       "default": "./lib/door/host.js"

package/plugins/acryl-door/src/index.ts

@@ -49,9 +49,15 @@ export const inject = ['router', 'appInstance', 'nodeServer']
 
 export interface Config {
   tools?: { expose?: string[] }
+  /**
+   * The door is a development tool: with `NODE_ENV=production` the plugin starts nothing (no route, no `.acryl/` file, no service), and with `ACRYL_DOOR=off` it never does. A host that means to
+   * run it in production (a packaged desktop app whose user drives it with an agent) says so here; `ACRYL_DOOR=off` still wins.
+   */
+  allowInProduction?: boolean
 }
 
 export const Config: z<Config> = z.object({
+  allowInProduction: z.boolean().default(false).description('Run in production too (NODE_ENV=production); ACRYL_DOOR=off still turns it off.'),
   tools: z.object({
     // Not a `door_` name: those are the door's own verbs in the registry, never offered back as app tools.
     expose: z.array(z.string().pattern(/^(?!door_)[A-Za-z][A-Za-z0-9_-]{0,63}$/u)).description('App tools (from the tools registry) the door offers; none by default.'),
@@ -84,6 +90,8 @@ function loopbackUrl(url: string): string {
 
 export function apply(ctx: Context, rawConfig: Config = {}): void {
   const config = Config(rawConfig)
+  // Development only: nothing is started, mounted or written in production, or when switched off.
+  if (process.env.ACRYL_DOOR === 'off' || (process.env.NODE_ENV === 'production' && config.allowInProduction !== true)) return
   const app = ctx.get('appInstance') as unknown as AppFolder
   const server = ctx.get('nodeServer') as unknown as Listening
   if (typeof app?.root !== 'string') throw new Error('acryl-door: the appInstance service has no app folder (root)')

package/plugins/acryl-router/src/index.ts

@@ -1,7 +1,6 @@
 export { Router, Config, apply, name, type MountableApp, type RouterHttpService, type TrailingSlash } from './service.ts'
 export { connectionOf, getConnInfo, type ConnectionInfo, type RouterBindings, type RouterEnv } from './connection.ts'
 export { Acryl, Context } from './core/index.ts'
-export { App, type AppRequest } from './deprecated.ts'
 export type { AcrylRequest, ContextRenderer, ContextVariableMap, Env, ErrorHandler, ExecutionContext, Handler, Input, MiddlewareHandler, Next, NotFoundHandler, NotFoundResponse, Schema, ToSchema, TypedResponse, ValidationTargets } from './core/index.ts'
 export { HTTPException } from './core/http-exception.ts'
 export type { ContentfulStatusCode, StatusCode } from './core/utils/http-status.ts'

package/plugins/agent-panel/drivers.ts

@@ -4,11 +4,9 @@
  * - `chat`: a message in, the panel's own events out (`text`, `tool`, `error`). The app's agent, the headless coding agents and a harness chat are chat drivers.
  * - `terminal`: bytes in, bytes out, a real pseudo-terminal (the `driver-pty` plugin). Nothing is forced to speak bytes.
  *
- * The panel lists every registered driver and picks the view by `kind`. A plugin that provides drivers injects `drivers`: with no panel mounted it is pending,
+ * This module is `acrylblends/drivers`: the contract a driver plugin writes against, with no dependency on Cordis. The panel lists every registered driver and picks the view by `kind`. A plugin that provides drivers injects `drivers`: with no panel mounted it is pending,
  * and a panel without such a plugin simply lists none of its drivers.
  */
-import type { Context } from '@deepseek-ai/cordis'
-
 /** One event of a chat run. The panel adds `change` (a plugin was installed or removed) and `done` itself. */
 export type ChatEvent =
   | { readonly event: 'text'; readonly data: { readonly text: string } }
@@ -55,12 +53,6 @@ export interface Drivers {
   authorized(headers: Headers): boolean
 }
 
-declare module '@deepseek-ai/cordis' {
-  interface Context {
-    drivers: Drivers
-  }
-}
-
 export function createDrivers(authorized: (headers: Headers) => boolean = () => true): Drivers {
   const table = new Map<string, Driver>()
   return {
@@ -74,10 +66,3 @@ export function createDrivers(authorized: (headers: Headers) => boolean = () =>
     authorized,
   }
 }
-
-/** Provide the registry on `ctx` (the panel does). */
-export function provideDrivers(ctx: Context, authorized: (headers: Headers) => boolean): Drivers {
-  const registry = createDrivers(authorized)
-  ;(ctx as Context).provide('drivers', registry)
-  return registry
-}

package/plugins/agent-panel/index.ts

@@ -18,8 +18,8 @@ import { streamSSE } from '../acryl-router/src/helpers/index.ts'
 import { Acryl } from '../acryl-router/src/index.ts'
 import type {} from '../agent/index.ts'
 import type {} from '../extensions/index.ts'
-import { provideDrivers } from './drivers.ts'
 import { agentDriver, availableHeadless, type HeadlessName, headlessDriver } from './headless.ts'
+import { provideDrivers } from './registry.ts'
 
 export type {
   ChatDriver,

package/plugins/agent-panel/registry.ts

@@ -0,0 +1,16 @@
+/** The `drivers` service of the agent panel: the registry (`drivers.ts`, published as `acrylblends/drivers`) provided on a Cordis context, and the `ctx.drivers` type. */
+import type { Context } from '@deepseek-ai/cordis'
+import { createDrivers, type Drivers } from './drivers.ts'
+
+declare module '@deepseek-ai/cordis' {
+  interface Context {
+    drivers: Drivers
+  }
+}
+
+/** Provide the registry on `ctx` (the panel does). */
+export function provideDrivers(ctx: Context, authorized: (headers: Headers) => boolean): Drivers {
+  const registry = createDrivers(authorized)
+  ;(ctx as Context).provide('drivers', registry)
+  return registry
+}

package/plugins/driver-acp/README.md

@@ -0,0 +1,53 @@
+# driver-acp
+
+Any agent that speaks the [Agent Client Protocol](https://agentclientprotocol.com) (ACP) as a chat in the agent panel (M8, spec 046 T028).
+The agent runs in the app folder and acts through the door, as the panel's other agents do. An agent needs no code here: it is a preset,
+the command line that starts its ACP server. DeepSeek Harness is the first one, and other ACP agents are added by config.
+
+```yaml
+- id: agent-panel
+  name: agent-panel
+- id: driver-acp
+  name: driver-acp
+  config:
+    agents:                      # replaces the presets; default: the presets whose command is on the PATH
+      dsh: { command: dsh, args: [--profile, acp] }
+    permissions: reject          # or allow: the answer to the agent's permission requests
+```
+
+The row goes after the panel's, injects `drivers` and `appInstance`, and stays PENDING without the panel. Each agent becomes the
+panel driver `acp:<name>`. An agent whose command is not on the PATH gets no driver, and the plugin logs one line saying why. With
+`NODE_ENV=production` or `ACRYL_DOOR=off` the plugin starts nothing.
+
+## How it talks
+
+ACP v1 over the agent's stdin and stdout, as newline-delimited JSON-RPC 2.0 (`connection.ts`). At the first message the driver starts the
+agent, sends `initialize` and `session/new` with the app folder as `cwd`, and keeps that session, so later messages continue the
+conversation. Each message is one `session/prompt`. Stop sends `session/cancel`. The client offers no file system or terminal
+capabilities, so the agent uses its own tools. A `session/request_permission` gets the agent's own "reject once" option, or "allow once"
+with `permissions: allow`.
+
+What the panel shows (`chat.ts`):
+
+- each `agent_message_chunk` as text;
+- each tool call once, when it completes or fails: its title, its input, and its result or error;
+- an error when a turn stops short (`refusal`, `max_tokens`, `max_turn_requests`) or the agent ends.
+
+Thoughts and plans stay out of the chat.
+
+## Processes
+
+Every agent process is started inside one `ctx.effect`. Its disposer closes the agent's stdin, then sends SIGTERM, then kills it (the
+whole process tree on Windows), and waits until it is gone. Unloading or reloading the plugin leaves no agent running. An agent that ended
+on its own is started again, with a new session, at the next message.
+
+## Provenance
+
+The client is written from the ACP v1 specification, not ported from an SDK: the official SDK (`@agentclientprotocol/sdk`) is 8 MB with
+two required peers, too much for a plugin copied into every app. To keep it honest, `test/conformance.test.ts` checks every message of a
+session, sent and received, against the official ACP v1 JSON schema. The schema is vendored unmodified in `test/acp-v1/` with its Apache-2.0
+license. It comes from `@agentclientprotocol/sdk@2.0.2` (`schema/v1/schema.json`); the version, source and checksum are in
+`provenance.json`. To follow a newer schema, replace the file, update `provenance.json`, and run the test.
+
+Checked live: `node scripts/verify-agent-panel.mjs --driver acp:dsh` (dsh on the PATH, a DeepSeek key) builds `/hello` from the panel
+through `dsh --profile acp`.

package/plugins/driver-acp/chat.ts

@@ -0,0 +1,258 @@
+/**
+ * An ACP agent as a chat driver of the panel. The agent process starts at the first message and keeps one ACP session, so later messages continue the same conversation;
+ * an agent that ended is started again, with a new session, at the next message. One message runs at a time; a second one waits for the first.
+ *
+ * What the panel gets from the ACP updates: the agent's message chunks as `text`, each finished tool call as one `tool` (its title, input, and result or error), and an
+ * `error` for a turn that stopped short (a refusal, a token or request limit, an agent that ended). Thoughts, plans and the rest stay out of the chat.
+ */
+import type { ChatDriver, ChatEvent } from '../agent-panel/drivers.ts'
+import { type AcpAgent, type AcpConnection, AcpError } from './connection.ts'
+
+/** Which answer a permission request gets: the agent's own "allow once" or "reject once" option. */
+export type AcpPermissions = 'allow' | 'reject'
+
+/** The ACP version this client speaks. */
+const PROTOCOL_VERSION = 1
+
+/** An agent connection with its session. */
+interface Session {
+  readonly connection: AcpConnection
+  readonly id: string
+}
+
+/**
+ * Opens a connection to the agent and returns it with the function that closes it. The plugin acquires it inside one `ctx.effect`, so unloading the plugin ends the process.
+ */
+export type OpenAgent = (
+  agent: AcpAgent,
+  handle: (method: string, params: unknown) => unknown,
+) => {
+  connection: AcpConnection
+  close(): Promise<void>
+}
+
+interface ToolUpdate {
+  toolCallId: string
+  title?: string | null
+  status?: string | null
+  rawInput?: unknown
+  rawOutput?: unknown
+  content?: Array<{ type?: string; content?: { type?: string; text?: string } }> | null
+}
+
+/** Why a turn stopped short, in the panel's words; `undefined` for a turn that ended normally or was cancelled. */
+function stopMessage(name: string, stopReason: unknown): string | undefined {
+  switch (stopReason) {
+    case 'end_turn':
+    case 'cancelled':
+      return undefined
+    case 'refusal':
+      return `${name} refused to continue`
+    case 'max_tokens':
+      return `${name} stopped at its token limit`
+    case 'max_turn_requests':
+      return `${name} stopped at its limit of model requests for one message`
+    default:
+      return `${name} stopped (${String(stopReason)})`
+  }
+}
+
+/** The text an ACP tool call produced, when it reports text content and no raw output. */
+function toolText(update: ToolUpdate): string | undefined {
+  const text = (update.content ?? [])
+    .map((item) =>
+      item.type === 'content' && item.content?.type === 'text' ? item.content.text : undefined,
+    )
+    .filter((part): part is string => typeof part === 'string')
+    .join('\n')
+  return text || undefined
+}
+
+/** The answer to `session/request_permission`: the agent's option of the wanted kind, or `cancelled` when it offers none or the turn was cancelled. */
+function permissionAnswer(
+  params: unknown,
+  permissions: AcpPermissions,
+  cancelled: boolean,
+): unknown {
+  const options = ((params as { options?: Array<{ optionId: string; kind: string }> }).options ??
+    []) as Array<{ optionId: string; kind: string }>
+  const wanted =
+    permissions === 'allow' ? ['allow_once', 'allow_always'] : ['reject_once', 'reject_always']
+  const option = cancelled
+    ? undefined
+    : wanted.map((kind) => options.find((o) => o.kind === kind)).find(Boolean)
+  return {
+    outcome: option ? { outcome: 'selected', optionId: option.optionId } : { outcome: 'cancelled' },
+  }
+}
+
+export function acpDriver(options: {
+  /** The driver's name in the panel (`acp:dsh`). */
+  name: string
+  agent: AcpAgent
+  /** The app folder: the agent's working directory and its session's `cwd`. */
+  cwd: string
+  permissions: AcpPermissions
+  open: OpenAgent
+}): ChatDriver {
+  const { name, agent, cwd, permissions, open } = options
+  let session: Promise<Session> | undefined
+  /** The connection `session` belongs to, so only its own end clears it. */
+  let live: AcpConnection | undefined
+  let turnCancelled = false
+  let queue: Promise<void> = Promise.resolve()
+
+  const startSession = async (): Promise<Session> => {
+    const { connection, close } = open(agent, (method, params) => {
+      if (method === 'session/request_permission')
+        return permissionAnswer(params, permissions, turnCancelled)
+      throw new AcpError(`${method} is not offered by this client`, -32601)
+    })
+    // An agent that ends is started again at the next message.
+    live = connection
+    void connection.ended.then(() => {
+      if (live !== connection) return
+      live = undefined
+      session = undefined
+    })
+    try {
+      await connection.request('initialize', {
+        protocolVersion: PROTOCOL_VERSION,
+        clientCapabilities: { fs: { readTextFile: false, writeTextFile: false }, terminal: false },
+        clientInfo: { name: 'acrylblends-driver-acp', version: '1' },
+      })
+      const created = await connection.request<{ sessionId: string }>('session/new', {
+        cwd,
+        mcpServers: [],
+      })
+      return { connection, id: created.sessionId }
+    } catch (error) {
+      await close()
+      throw error
+    }
+  }
+
+  return {
+    kind: 'chat',
+    name,
+    async *start({ message, signal }) {
+      // One message at a time: this one waits for the one before it.
+      const previous = queue
+      let finished!: () => void
+      queue = new Promise((resolve) => (finished = resolve))
+      try {
+        await previous
+        if (signal.aborted) return
+        let current: Session
+        try {
+          session ??= startSession()
+          current = await session
+        } catch (error) {
+          session = undefined
+          yield {
+            event: 'error',
+            data: { message: error instanceof Error ? error.message : String(error) },
+          }
+          return
+        }
+        yield* turn(current, message, signal)
+      } finally {
+        finished()
+      }
+    },
+  }
+
+  async function* turn(
+    current: Session,
+    message: string,
+    signal: AbortSignal,
+  ): AsyncGenerator<ChatEvent> {
+    const events: ChatEvent[] = []
+    let wake: (() => void) | undefined
+    let settled = false
+    const push = (event: ChatEvent): void => {
+      events.push(event)
+      wake?.()
+    }
+    /** What earlier updates said about each tool call: its title and its input arrive before its result. */
+    const calls = new Map<string, { title?: string; input?: unknown }>()
+    const off = current.connection.onNotification((method, params) => {
+      const { sessionId, update } = params as {
+        sessionId?: string
+        update?: { sessionUpdate?: string } & ToolUpdate & { content?: unknown }
+      }
+      if (method !== 'session/update' || sessionId !== current.id || !update) return
+      if (update.sessionUpdate === 'agent_message_chunk') {
+        const content = update.content as { type?: string; text?: string } | undefined
+        if (content?.type === 'text' && content.text)
+          push({ event: 'text', data: { text: content.text } })
+        return
+      }
+      if (update.sessionUpdate !== 'tool_call' && update.sessionUpdate !== 'tool_call_update')
+        return
+      const call = calls.get(update.toolCallId) ?? {}
+      if (update.title) call.title = update.title
+      if (update.rawInput !== undefined) call.input = update.rawInput
+      calls.set(update.toolCallId, call)
+      if (update.status !== 'completed' && update.status !== 'failed') return
+      const tool = call.title ?? update.toolCallId
+      const output = update.rawOutput ?? toolText(update)
+      push({
+        event: 'tool',
+        data: {
+          tool,
+          ...(call.input === undefined ? {} : { input: call.input }),
+          ...(update.status === 'failed'
+            ? {
+                error:
+                  output === undefined
+                    ? 'failed'
+                    : String(typeof output === 'string' ? output : JSON.stringify(output)),
+              }
+            : { result: output }),
+        },
+      })
+    })
+    turnCancelled = false
+    const cancel = (): void => {
+      turnCancelled = true
+      current.connection.notify('session/cancel', { sessionId: current.id })
+    }
+    signal.addEventListener('abort', cancel, { once: true })
+    current.connection
+      .request<{ stopReason?: unknown }>('session/prompt', {
+        sessionId: current.id,
+        prompt: [{ type: 'text', text: message }],
+      })
+      .then(
+        (result) => {
+          const stopped = signal.aborted ? undefined : stopMessage(name, result.stopReason)
+          if (stopped) push({ event: 'error', data: { message: stopped } })
+        },
+        (error: unknown) => {
+          if (!signal.aborted)
+            push({
+              event: 'error',
+              data: { message: error instanceof Error ? error.message : String(error) },
+            })
+        },
+      )
+      .finally(() => {
+        settled = true
+        wake?.()
+      })
+    try {
+      for (;;) {
+        const next = events.shift()
+        if (next) yield next
+        else if (settled) return
+        else await new Promise<void>((resolve) => (wake = resolve))
+      }
+    } finally {
+      off()
+      signal.removeEventListener('abort', cancel)
+      // The panel stopped reading before the turn ended: the agent is told to stop it.
+      if (!settled) cancel()
+    }
+  }
+}