@4fu/arbor-prompt 2026.1106.0 → 2026.1107.0

package/README.md

@@ -27,9 +27,11 @@ everything that takes judgment, such as git, merges and conflicts, to the agent.
   guarantees what an agent cannot guarantee for itself - the record, isolation,
   exactly-once effects, the checks, dispatch. Everything that takes judgment,
   such as git, merges and conflicts, is the agent's.
-- **A directory per window.** Each window gets its own directory, and a
-  continuation keeps working in its predecessor's directory in place. It is not
-  bound to a repository; the agent clones and pushes what it needs.
+- **A shared workspace with per-window checkouts.** The default workspace is
+  ovnfs: one shared folder every window reads, and a window opens its own
+  copy-on-write checkout of the project it needs, works there and merges back
+  with `apply`. It falls back to a plain directory per window when ovnfs is not
+  installed. It is not a sandbox: ovnfs isolates files, not processes.
 - **A self-changing environment.** The model adds and changes skills, MCP
   servers and resident services itself; a `reload` validates the change and
   broadcasts it to every live window as a delta of names and descriptions.
@@ -54,7 +56,9 @@ npm install @4fu/arbor-core @4fu/arbor-journal-sqlite @4fu/arbor-notes-sqlite \
 ```
 
 `@4fu/arbor-plugin-http` is optional; it is the example plugin below.
-`@4fu/arbor-segmenter-jieba` is an optional peer of the journal.
+`@4fu/arbor-segmenter-jieba` is an optional peer of the lexical package, and
+`@4fu/arbor-search-zvec` an optional peer of the journal: absent either one, the
+journal searches lexically and nothing else changes.
 
 ## A minimal host
 
@@ -118,7 +122,10 @@ window gets, and how a continuation keeps working in it, are in
 | [`@4fu/arbor-journal-sqlite`](packages/journal-sqlite) | the default `Journal` and `BlobStore` on SQLite |
 | [`@4fu/arbor-notes-sqlite`](packages/notes-sqlite) | the default `NoteStore` on SQLite, beside the journal |
 | [`@4fu/arbor-segmenter-jieba`](packages/segmenter-jieba) | the default `Segmenter`: jieba's dictionary segmentation for the word index, optional |
-| [`@4fu/arbor-workspace-dir`](packages/workspace-dir) | the default `Workspace`: one directory per window, with a continuation working in its predecessor's directory in place |
+| [`@4fu/arbor-lexical`](packages/lexical) | the lexical search the journal and notes share: word segmentation, the FTS5 helpers and the merge order |
+| [`@4fu/arbor-search-zvec`](packages/search-zvec) | the optional semantic channel: event text embedded and searched by meaning with zvec |
+| [`@4fu/arbor-workspace-dir`](packages/workspace-dir) | the fallback `Workspace`: one directory per window, with a continuation working in its predecessor's directory in place |
+| [`@4fu/arbor-workspace-ovnfs`](packages/workspace-ovnfs) | the default `Workspace` when ovnfs is installed: one shared folder, per-window copy-on-write checkouts the model opens and applies back |
 | [`@4fu/arbor-environment-dir`](packages/environment-dir) | the default `Environment`: one `/env` directory, a revision per item, validation and deltas |
 | [`@4fu/arbor-supervisor-process`](packages/supervisor-process) | the default `Supervisor`: one host process per service, restart with backoff, logs |
 | [`@4fu/arbor-judge-jev`](packages/judge-jev) | the default `Judge`: Jev, TypeSafe AI's System One classifier, answering the dispatch decisions |
@@ -151,7 +158,7 @@ deployment can see what it would be taking on before it adopts one.
 | [docs/coordination.md](docs/coordination.md) | the board, expectations, deliveries and broadcasts, staying current, effects |
 | [docs/environment.md](docs/environment.md) | skills, MCP servers and services: using, changing, reload, built-in skills, deltas |
 | [docs/memory.md](docs/memory.md) | notes, the active set, anchors, links |
-| [docs/workspaces.md](docs/workspaces.md) | per-window directories: isolation, continuity, what the agent does |
+| [docs/workspaces.md](docs/workspaces.md) | the shared folder and per-window checkouts: isolation, continuity, what the agent does |
 | [docs/tools.md](docs/tools.md) | direct tools and code mode modules |
 | [docs/prompting.md](docs/prompting.md) | how every model-facing text is written: layers, notes, deliveries, errors, judge questions, terms |
 | [docs/release.md](docs/release.md) | calendar versioning, the manual release steps, how a package is published |
@@ -168,6 +175,7 @@ tarball would contain ([docs/release.md](docs/release.md)).
 | `packages/errors` | the error shape every refusal uses: the rule and the next action |
 | `packages/journal-sqlite` | the default `Journal` and `BlobStore` on SQLite |
 | `packages/segmenter-jieba` | the default `Segmenter`: jieba's dictionary segmentation for the word index, optional |
+| `packages/lexical` | the lexical search the journal and notes share: word segmentation, the FTS5 helpers and the merge order |
 | `packages/notes-sqlite` | the default `NoteStore` on SQLite, beside the journal |
 | `packages/judge-jev` | the default `Judge`: Jev, TypeSafe AI's System One classifier, answering the dispatch decisions |
 | `packages/workspace-dir` | the default `Workspace`: one directory per window, with a continuation working in its predecessor's directory in place, and the lookup of another window's directory it contributes to the catalog |

package/blocks.js

@@ -29,12 +29,13 @@ export const BUILTIN_BLOCK_KINDS = [
     {
         kind: "board_line",
         tag: "board_line",
-        lines: ["board.line", "board.targets", "board.usage", "board.expects"],
+        lines: ["board.line", "board.targets", "board.open", "board.usage", "board.expects"],
         fields: [
             { name: "window", type: "ref" },
             { name: "state", type: "string" },
             { name: "doing", type: "string" },
             { name: "targets", type: "strings" },
+            { name: "openWork", type: "strings" },
             { name: "used", type: "number" },
             { name: "limit", type: "number" },
             { name: "expects", type: "strings" },
@@ -81,7 +82,7 @@ export const BUILTIN_BLOCK_KINDS = [
     {
         kind: "reminder",
         tag: "reminder",
-        lines: ["reminder.numbers", "reminder.series", "reminder.tier.{tier}", "reminder.cost", "delivery.time"],
+        lines: ["reminder.head", "reminder.numbers", "reminder.series", "reminder.tier.{tier}", "reminder.open", "reminder.cost.{tier}", "delivery.time"],
         fields: [
             { name: "tier", type: "string" },
             { name: "index", type: "number" },
@@ -89,6 +90,7 @@ export const BUILTIN_BLOCK_KINDS = [
             { name: "used", type: "number" },
             { name: "limit", type: "number" },
             { name: "percent", type: "number" },
+            { name: "openWork", type: "strings" },
             { name: "time", type: "string" },
         ],
     },
@@ -96,10 +98,11 @@ export const BUILTIN_BLOCK_KINDS = [
         kind: "tool_result",
         tag: "tool_result",
         data: true,
-        lines: ["tool_result.call"],
+        lines: ["tool_result.call", "tool_result.{status}"],
         fields: [
             { name: "callId", type: "string" },
             { name: "name", type: "string" },
+            { name: "status", type: "string" },
             { name: "content", type: "string" },
         ],
     },
@@ -203,6 +206,57 @@ export const BUILTIN_BLOCK_KINDS = [
             { name: "description", type: "string" },
         ],
     },
+    {
+        kind: "plugin_section",
+        data: true,
+        lines: ["system.plugin.outside"],
+        fields: [{ name: "content", type: "blocks" }],
+    },
+    {
+        kind: "prompt_delta",
+        tag: "prompt_delta",
+        lines: ["delivery.prompt_delta", "delivery.time"],
+        fields: [
+            { name: "time", type: "string" },
+            { name: "items", type: "blocks" },
+        ],
+    },
+    {
+        kind: "tools_delta",
+        tag: "tools_delta",
+        lines: ["delivery.tools_delta", "delivery.time"],
+        fields: [
+            { name: "time", type: "string" },
+            { name: "items", type: "blocks" },
+        ],
+    },
+    {
+        kind: "tool_change",
+        lines: ["delivery.tool_change"],
+        fields: [
+            { name: "change", type: "string" },
+            { name: "name", type: "string" },
+            { name: "source", type: "string" },
+        ],
+    },
+    {
+        kind: "prompt_section",
+        // The tag is the plugin's own choice, so it rides on the block
+        // (docs/prompting.md#plugin-sections-that-change).
+        tagField: "tag",
+        fields: [
+            { name: "tag", type: "string", tag: true },
+            { name: "items", type: "blocks" },
+        ],
+    },
+    {
+        kind: "prompt_line",
+        lines: ["delivery.prompt_line"],
+        fields: [
+            { name: "change", type: "string" },
+            { name: "line", type: "string" },
+        ],
+    },
     {
         kind: "continuation_note",
         tag: "continuation_note",
@@ -232,4 +286,10 @@ export const BUILTIN_BLOCK_KINDS = [
         lines: ["continuation.handoff.none"],
         fields: [{ name: "previous", type: "ref" }],
     },
+    {
+        kind: "continuation_interrupted",
+        tag: "continuation_interrupted",
+        lines: ["continuation.interrupted"],
+        fields: [{ name: "previous", type: "ref" }],
+    },
 ];

package/build.d.ts

@@ -6,7 +6,7 @@
  * builders are the shapes the core, the tools and the plugins use, so a block
  * of one kind is always built the same way.
  */
-import type { Block, Delivery, EnvDelta, EnvItem, Handoff, Note, NoteSummary, Ref, TaskRef, WindowRef } from "@4fu/arbor-interfaces";
+import type { Block, Delivery, DirectToolSpec, EnvDelta, EnvItem, ExternalToolChange, Handoff, Note, NoteSummary, Ref, TaskRef, TextTable, WindowRef } from "@4fu/arbor-interfaces";
 import type { Renderer } from "./render.ts";
 /** One task, as it would open a window (docs/prompting.md#deliveries). */
 export declare function taskBlock(task: {
@@ -27,6 +27,8 @@ export declare function boardLineBlock(line: {
     used: number;
     limit: number;
     expects?: readonly string[];
+    /** The window's open work in its workspace, each item as the model reads it. */
+    openWork?: readonly string[];
 }): Block;
 /** The cost of ending a window with unfinished work. */
 export declare function handoffBlock(handoff: Handoff): Block;
@@ -43,12 +45,14 @@ export declare function reminderBlock(reminder: {
     limit: number;
     percent: number;
     time: number;
+    /** The window's open work in its workspace, each item as the model reads it. */
+    openWork?: readonly string[];
 }): Block;
 /** A tool's result, as data (docs/prompting.md#layers). */
 export declare function toolResultBlock(call: {
     callId: string;
     name: string;
-}, content: string): Block;
+}, content: string, status?: "ok" | "failed"): Block;
 /** A refusal: the rule that refused the call and the next action. */
 export declare function errorBlock(error: {
     tool: string;
@@ -100,6 +104,13 @@ export declare function conversationUpdateBlock(update: {
 }): Block;
 /** One environment delta: one line per item, `+`, `~` or `-`. */
 export declare function environmentDeltaBlock(delta: EnvDelta, time: number): Block;
+/**
+ * One tools delta: the direct tools declared from outside the core that
+ * appeared, and the ones that were removed, one line each
+ * (docs/tools.md#external-tools-that-change). The window's own prefix is not
+ * rebuilt: it reads the change and calls what is new from its next tool call.
+ */
+export declare function toolDeltaBlock(changes: readonly ExternalToolChange[], time: number): Block;
 /** The fixed notes of a continuation (docs/prompting.md#fixed-notes). */
 export declare function continuationBlocks(continuation: {
     previous: WindowRef;
@@ -113,7 +124,41 @@ export declare function midTaskResetBlock(previous: WindowRef): Block;
 export declare function continuationHandoffBlock(previous: WindowRef, handoff: Handoff): Block;
 /** No handoff: the order to recover from. */
 export declare function continuationRecoveryBlock(previous: WindowRef): Block;
+/** The previous window's run was cut short by a model failure. */
+export declare function continuationInterruptedBlock(previous: WindowRef): Block;
+/**
+ * One plugin prompt section's change, for a window that opened before it
+ * (docs/prompting.md#plugin-sections-that-change).
+ *
+ * Only the lines that changed are carried: a line both texts hold is left out,
+ * so the delta never repeats unchanged text and never rebuilds the prompt.
+ * `undefined` when nothing moved, so a section whose content did not change
+ * emits no delta at all.
+ */
+export declare function promptSectionDeltaBlock(section: {
+    /** The tag the section renders in, which is the plugin's own choice. */
+    tag: string;
+    /** What the window's prefix holds of the section. */
+    from: string;
+    /** What the section says now. */
+    to: string;
+    /** True when the section is material from outside the framework. */
+    outside?: boolean;
+}, time: number): Block | undefined;
 /** One environment item's line, for `<env>` and `tool_search`. */
 export declare function envItemLine(item: EnvItem, renderer: Renderer): string;
+/**
+ * One direct tool's line, the same one the `<tools>` section writes and the one
+ * `tool_search` answers with (docs/tools.md#external-tools).
+ *
+ * A tool declared from outside the core says where it comes from, so the model
+ * knows whose it is wherever it meets the name. A tool that carries the JSON
+ * Schema its own harness declared shows it on the line too, so the model reads
+ * the parameters it will actually call with - `enum`, `items`, a nested
+ * object's own properties - and not a summary that dropped them. The schema is
+ * escaped like every other string from outside the framework: it cannot close
+ * the section it renders in.
+ */
+export declare function toolLine(table: TextTable, tool: DirectToolSpec): string;
 /** The text one delivery is steered in as. */
 export declare function renderDelivery(delivery: Delivery, renderer: Renderer): string;

package/build.js

@@ -6,6 +6,8 @@
  * builders are the shapes the core, the tools and the plugins use, so a block
  * of one kind is always built the same way.
  */
+import { changedLines } from "./diff.js";
+import { escapeText } from "./render.js";
 import { textOf } from "./text.js";
 import { formatTime } from "./time.js";
 /** One task, as it would open a window (docs/prompting.md#deliveries). */
@@ -35,6 +37,7 @@ export function boardLineBlock(line) {
             used: line.used,
             limit: line.limit,
             ...(line.expects === undefined || line.expects.length === 0 ? {} : { expects: [...line.expects] }),
+            ...(line.openWork === undefined || line.openWork.length === 0 ? {} : { openWork: [...line.openWork] }),
         },
     };
 }
@@ -90,14 +93,17 @@ export function reminderBlock(reminder) {
             limit: reminder.limit,
             percent: reminder.percent,
             time: formatTime(reminder.time),
+            ...(reminder.openWork === undefined || reminder.openWork.length === 0
+                ? {}
+                : { openWork: [...reminder.openWork] }),
         },
     };
 }
 /** A tool's result, as data (docs/prompting.md#layers). */
-export function toolResultBlock(call, content) {
+export function toolResultBlock(call, content, status = "ok") {
     return {
         kind: "tool_result",
-        fields: { callId: call.callId, name: call.name, content },
+        fields: { callId: call.callId, name: call.name, status, content },
     };
 }
 /** A refusal: the rule that refused the call and the next action. */
@@ -196,6 +202,22 @@ export function environmentDeltaBlock(delta, time) {
         fields: { revision: delta.revision, time: formatTime(time), items },
     };
 }
+/**
+ * One tools delta: the direct tools declared from outside the core that
+ * appeared, and the ones that were removed, one line each
+ * (docs/tools.md#external-tools-that-change). The window's own prefix is not
+ * rebuilt: it reads the change and calls what is new from its next tool call.
+ */
+export function toolDeltaBlock(changes, time) {
+    const items = changes.map((change) => ({
+        kind: "tool_change",
+        fields: { change: DELTA_MARK[change.change], name: change.name, source: change.source },
+    }));
+    return {
+        kind: "tools_delta",
+        fields: { time: formatTime(time), items },
+    };
+}
 /** The fixed notes of a continuation (docs/prompting.md#fixed-notes). */
 export function continuationBlocks(continuation) {
     return [
@@ -231,6 +253,36 @@ export function continuationHandoffBlock(previous, handoff) {
 export function continuationRecoveryBlock(previous) {
     return { kind: "continuation_recovery", fields: { previous } };
 }
+/** The previous window's run was cut short by a model failure. */
+export function continuationInterruptedBlock(previous) {
+    return { kind: "continuation_interrupted", fields: { previous } };
+}
+/**
+ * One plugin prompt section's change, for a window that opened before it
+ * (docs/prompting.md#plugin-sections-that-change).
+ *
+ * Only the lines that changed are carried: a line both texts hold is left out,
+ * so the delta never repeats unchanged text and never rebuilds the prompt.
+ * `undefined` when nothing moved, so a section whose content did not change
+ * emits no delta at all.
+ */
+export function promptSectionDeltaBlock(section, time) {
+    const changes = changedLines(section.from, section.to);
+    if (changes.length === 0)
+        return undefined;
+    const lines = changes.map((change) => ({
+        kind: "prompt_line",
+        fields: { change: change.change, line: change.line },
+    }));
+    const tagged = { kind: "prompt_section", fields: { tag: section.tag, items: lines } };
+    return {
+        kind: "prompt_delta",
+        fields: {
+            time: formatTime(time),
+            items: [section.outside === true ? { kind: "plugin_section", fields: { content: [tagged] } } : tagged],
+        },
+    };
+}
 /** One environment item's line, for `<env>` and `tool_search`. */
 export function envItemLine(item, renderer) {
     return item.path === undefined
@@ -241,6 +293,35 @@ export function envItemLine(item, renderer) {
             path: item.path,
         });
 }
+/**
+ * One direct tool's line, the same one the `<tools>` section writes and the one
+ * `tool_search` answers with (docs/tools.md#external-tools).
+ *
+ * A tool declared from outside the core says where it comes from, so the model
+ * knows whose it is wherever it meets the name. A tool that carries the JSON
+ * Schema its own harness declared shows it on the line too, so the model reads
+ * the parameters it will actually call with - `enum`, `items`, a nested
+ * object's own properties - and not a summary that dropped them. The schema is
+ * escaped like every other string from outside the framework: it cannot close
+ * the section it renders in.
+ */
+export function toolLine(table, tool) {
+    const schema = tool.schema === undefined ? undefined : escapeText(JSON.stringify(tool.schema));
+    const withSource = tool.source !== undefined;
+    const key = withSource
+        ? schema === undefined
+            ? "system.tool.source"
+            : "system.tool.source.schema"
+        : schema === undefined
+            ? "system.tool"
+            : "system.tool.schema";
+    return textOf(table, key, {
+        name: tool.name,
+        description: tool.description,
+        ...(tool.source === undefined ? {} : { source: tool.source }),
+        ...(schema === undefined ? {} : { schema }),
+    });
+}
 /** The text one delivery is steered in as. */
 export function renderDelivery(delivery, renderer) {
     return renderer.render([...delivery.content]);

package/diff.d.ts

@@ -0,0 +1,23 @@
+/**
+ * The line diff a prompt-section delta is built from
+ * (docs/prompting.md#plugin-sections-that-change).
+ *
+ * A plugin's prompt section can change while a window runs. The window learns
+ * the change the way it learns an environment change - as a delta at the next
+ * tool-call boundary - and the delta carries only the lines that changed, so
+ * unchanged text is never repeated and the whole system prompt is never
+ * rebuilt. The diff is by longest common subsequence: a line both texts hold is
+ * left out, and a line that moved is reported where it now stands.
+ */
+/** One line that changed between two texts. */
+export interface LineChange {
+    /** `+` for a line the new text has and the old one did not, `-` for one it lost. */
+    change: "+" | "-";
+    line: string;
+}
+/**
+ * The lines that changed between two texts, in the order the new text stands
+ * in. Two texts with the same lines give nothing, so a section whose content
+ * did not move emits no delta at all.
+ */
+export declare function changedLines(from: string, to: string): readonly LineChange[];

package/diff.js

@@ -0,0 +1,93 @@
+/**
+ * The line diff a prompt-section delta is built from
+ * (docs/prompting.md#plugin-sections-that-change).
+ *
+ * A plugin's prompt section can change while a window runs. The window learns
+ * the change the way it learns an environment change - as a delta at the next
+ * tool-call boundary - and the delta carries only the lines that changed, so
+ * unchanged text is never repeated and the whole system prompt is never
+ * rebuilt. The diff is by longest common subsequence: a line both texts hold is
+ * left out, and a line that moved is reported where it now stands.
+ */
+/** The lines one text carries. A blank line carries nothing a diff can say. */
+function linesOf(text) {
+    return text.split("\n").filter((line) => line !== "");
+}
+/**
+ * The index pairs the two texts share, longest first: the lines that are in
+ * both, in order. The table is filled from the end, so one pass walks it from
+ * the start and prefers the side that keeps more lines in common.
+ */
+function commonLines(before, after) {
+    const rows = before.length;
+    const columns = after.length;
+    const table = Array.from({ length: rows + 1 }, () => new Array(columns + 1).fill(0));
+    for (let row = rows - 1; row >= 0; row -= 1) {
+        const current = table[row];
+        if (current === undefined)
+            continue;
+        for (let column = columns - 1; column >= 0; column -= 1) {
+            const down = table[row + 1]?.[column] ?? 0;
+            const right = current[column + 1] ?? 0;
+            const diagonal = table[row + 1]?.[column + 1] ?? 0;
+            current[column] = before[row] === after[column] ? diagonal + 1 : Math.max(down, right);
+        }
+    }
+    const pairs = [];
+    let row = 0;
+    let column = 0;
+    while (row < rows && column < columns) {
+        if (before[row] === after[column]) {
+            pairs.push([row, column]);
+            row += 1;
+            column += 1;
+            continue;
+        }
+        if ((table[row + 1]?.[column] ?? 0) >= (table[row]?.[column + 1] ?? 0))
+            row += 1;
+        else
+            column += 1;
+    }
+    return pairs;
+}
+/**
+ * The lines that changed between two texts, in the order the new text stands
+ * in. Two texts with the same lines give nothing, so a section whose content
+ * did not move emits no delta at all.
+ */
+export function changedLines(from, to) {
+    const before = linesOf(from);
+    const after = linesOf(to);
+    const changes = [];
+    let row = 0;
+    let column = 0;
+    for (const [sameRow, sameColumn] of commonLines(before, after)) {
+        while (row < sameRow) {
+            const line = before[row];
+            if (line !== undefined)
+                changes.push({ change: "-", line });
+            row += 1;
+        }
+        while (column < sameColumn) {
+            const line = after[column];
+            if (line !== undefined)
+                changes.push({ change: "+", line });
+            column += 1;
+        }
+        row = sameRow + 1;
+        column = sameColumn + 1;
+    }
+    while (row < before.length) {
+        const line = before[row];
+        if (line !== undefined)
+            changes.push({ change: "-", line });
+        row += 1;
+    }
+    while (column < after.length) {
+        const line = after[column];
+        if (line !== undefined)
+            changes.push({ change: "+", line });
+        column += 1;
+    }
+    return changes;
+}

package/first-input.d.ts

@@ -26,6 +26,11 @@ export interface FirstInputInput {
         handoff?: Handoff;
         /** Set after the hard limit: the window was reset mid-task. */
         midTaskReset?: boolean;
+        /**
+         * Set when the previous window's run was cut short by a model failure:
+         * the steps it had taken stand, and the ones it had sent are not repeated.
+         */
+        interrupted?: boolean;
         /** The tasks the previous window still had open. */
         openTasks?: readonly Ref[];
         /** The effects the previous window already made. */

package/first-input.js

@@ -6,7 +6,7 @@
  * It is this window's own layer, so it carries the per-input facts a frozen
  * prefix must not: the time, the targets, the numbers.
  */
-import { boardLineBlock, continuationBlocks, continuationHandoffBlock, continuationRecoveryBlock, handoffBlock, midTaskResetBlock, taskBlock, } from "./build.js";
+import { boardLineBlock, continuationBlocks, continuationHandoffBlock, continuationInterruptedBlock, continuationRecoveryBlock, handoffBlock, midTaskResetBlock, taskBlock, } from "./build.js";
 /** The blocks of one window's first input, in the layout's order. */
 export function firstInputBlocks(input) {
     const blocks = [taskBlock(input.task)];
@@ -19,6 +19,7 @@ export function firstInputBlocks(input) {
             used: line.usage.used,
             limit: line.usage.limit,
             expects: line.expects.map((expectation) => expectation.description ?? expectation.ref),
+            ...(line.openWork === undefined ? {} : { openWork: line.openWork }),
         }));
     }
     const continuation = input.continuation;
@@ -31,6 +32,8 @@ export function firstInputBlocks(input) {
         }));
         if (continuation.midTaskReset === true)
             blocks.push(midTaskResetBlock(continuation.previous));
+        if (continuation.interrupted === true)
+            blocks.push(continuationInterruptedBlock(continuation.previous));
         if (continuation.handoff === undefined) {
             blocks.push(continuationRecoveryBlock(continuation.previous));
         }

package/index.d.ts

@@ -9,10 +9,11 @@
  * finished text.
  */
 export { BUILTIN_BLOCK_KINDS } from "./blocks.ts";
+export { changedLines, type LineChange } from "./diff.ts";
 export { Renderer, escapeText, type RendererOptions } from "./render.ts";
-export { DEFAULT_GENERAL_RULES, renderSystemPrompt, type SystemPromptInput, } from "./system.ts";
+export { DEFAULT_GENERAL_RULES, renderPluginSection, renderPluginSections, renderSystemPrompt, sectionRevision, type RenderedPluginSection, type RenderedSystemPrompt, type SystemPromptInput, } from "./system.ts";
 export { memoryBlocks, noteSortKey, renderMemorySnapshot, } from "./memory.ts";
-export { boardLineBlock, broadcastBlock, continuationBlocks, continuationHandoffBlock, continuationRecoveryBlock, conversationUpdateBlock, dataBlock, envItemLine, environmentDeltaBlock, errorBlock, handoffBlock, midTaskResetBlock, noteBlock, noteSummaryBlock, noticeBlock, outsideMessageBlock, reminderBlock, renderDelivery, taskBlock, toolResultBlock, windowMessageBlock, } from "./build.ts";
+export { boardLineBlock, broadcastBlock, continuationBlocks, continuationHandoffBlock, continuationInterruptedBlock, continuationRecoveryBlock, conversationUpdateBlock, dataBlock, envItemLine, environmentDeltaBlock, errorBlock, handoffBlock, midTaskResetBlock, noteBlock, noteSummaryBlock, noticeBlock, outsideMessageBlock, promptSectionDeltaBlock, reminderBlock, renderDelivery, taskBlock, toolDeltaBlock, toolLine, toolResultBlock, windowMessageBlock, } from "./build.ts";
 export { firstInputBlocks, type FirstInputInput } from "./first-input.ts";
 export { REMINDER_SERIES, REMINDER_TIERS, atHardLimit, hardLimitAt, hardLimitReserve, nextReminderTier, usedPercent, type ReminderTier, } from "./reminder.ts";
 export { formatText, textOf, zhTextTable, type TextArgs } from "./text.ts";

package/index.js

@@ -9,10 +9,11 @@
  * finished text.
  */
 export { BUILTIN_BLOCK_KINDS } from "./blocks.js";
+export { changedLines } from "./diff.js";
 export { Renderer, escapeText } from "./render.js";
-export { DEFAULT_GENERAL_RULES, renderSystemPrompt, } from "./system.js";
+export { DEFAULT_GENERAL_RULES, renderPluginSection, renderPluginSections, renderSystemPrompt, sectionRevision, } from "./system.js";
 export { memoryBlocks, noteSortKey, renderMemorySnapshot, } from "./memory.js";
-export { boardLineBlock, broadcastBlock, continuationBlocks, continuationHandoffBlock, continuationRecoveryBlock, conversationUpdateBlock, dataBlock, envItemLine, environmentDeltaBlock, errorBlock, handoffBlock, midTaskResetBlock, noteBlock, noteSummaryBlock, noticeBlock, outsideMessageBlock, reminderBlock, renderDelivery, taskBlock, toolResultBlock, windowMessageBlock, } from "./build.js";
+export { boardLineBlock, broadcastBlock, continuationBlocks, continuationHandoffBlock, continuationInterruptedBlock, continuationRecoveryBlock, conversationUpdateBlock, dataBlock, envItemLine, environmentDeltaBlock, errorBlock, handoffBlock, midTaskResetBlock, noteBlock, noteSummaryBlock, noticeBlock, outsideMessageBlock, promptSectionDeltaBlock, reminderBlock, renderDelivery, taskBlock, toolDeltaBlock, toolLine, toolResultBlock, windowMessageBlock, } from "./build.js";
 export { firstInputBlocks } from "./first-input.js";
 export { REMINDER_SERIES, REMINDER_TIERS, atHardLimit, hardLimitAt, hardLimitReserve, nextReminderTier, usedPercent, } from "./reminder.js";
 export { formatText, textOf, zhTextTable } from "./text.js";

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@4fu/arbor-prompt",
-  "version": "2026.1106.0",
+  "version": "2026.1107.0",
   "type": "module",
   "description": "Typed prompt blocks, the one deterministic renderer, the replaceable Chinese text table and the system prompt sections.",
   "exports": {
@@ -16,6 +16,8 @@
     "blocks.js",
     "build.d.ts",
     "build.js",
+    "diff.d.ts",
+    "diff.js",
     "first-input.d.ts",
     "first-input.js",
     "index.d.ts",
@@ -46,7 +48,7 @@
     "access": "public"
   },
   "dependencies": {
-    "@4fu/arbor-errors": "2026.1106.0",
-    "@4fu/arbor-interfaces": "2026.1106.0"
+    "@4fu/arbor-errors": "2026.1107.0",
+    "@4fu/arbor-interfaces": "2026.1107.0"
   }
 }

package/reminder.d.ts

@@ -1,20 +1,22 @@
 /**
  * Usage reminders (docs/windows.md#usage-reminders).
  *
- * Host reminders are appended to an input, never to the prefix: at 15, 30 and
- * 50 % of the window, write down what a later window would need; at 60, 70 and
- * 80 %, also end the window with a handoff; a final one at
- * `window - 2 x reserve`. Each carries the real numbers, its place in the
- * series and the cost of ignoring it. Only the highest crossed tier is sent;
- * the lower ones it jumped over are recorded as sent with it.
+ * Host reminders are appended to an input, never to the prefix. The series has
+ * seven tiers, each with its own instruction: at 15, 30 and 50 % write down
+ * what a later window would need; at 60 % say what the boundary is; at 70 %
+ * open no new large task; at 80 % rotate before new work; a final one at
+ * `window - 2 x reserve` rotates now. Each carries the real numbers, its place
+ * in the series and, from 80 % on, the cost of ignoring it. Only the highest
+ * crossed tier is sent; the lower ones it jumped over are recorded as sent
+ * with it.
  */
 import type { TokenUsage } from "@4fu/arbor-interfaces";
 /** One tier of the series. `tier` names the instruction in the text table. */
 export interface ReminderTier {
     /** The share of the window, in percent. */
     percent: number;
-    /** `note`, `handoff` or `final`. */
-    tier: "note" | "handoff" | "final";
+    /** The tier's key in the text table: `p15` … `p80`, or `final`. */
+    tier: "p15" | "p30" | "p50" | "p60" | "p70" | "p80" | "final";
     /** The share of the window's tokens at which this tier fires. */
     at: (usage: TokenUsage) => number;
 }