@4fu/arbor-notes-sqlite 2026.1106.0 → 2026.1106.1

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.
@@ -118,7 +120,8 @@ 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-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 +154,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 |

package/notes.d.ts

@@ -46,6 +46,12 @@ export interface SqliteNoteStoreOptions {
     now?: () => number;
     /** Usage loses half of its weight this often. 24 hours. */
     usageHalfLifeMs?: number;
+    /**
+     * One fixed string from the deployment's text table, so this implementation
+     * writes none of its own (docs/prompting.md#language-and-the-text-table).
+     * Defaults to the framework's own Chinese table.
+     */
+    text?: (key: string, args?: Record<string, string | number>) => string;
 }
 /** The opening of a body, when a write carries no summary of its own. */
 export declare function deriveSummary(body: string): string;
@@ -55,6 +61,8 @@ export declare class SqliteNoteStore implements NoteStore {
     private readonly journal;
     private readonly clock;
     private readonly halfLifeMs;
+    /** The table every refusal this store raises is written from. */
+    private readonly text;
     /** One write at a time: a write spans the notes database and the journal. */
     private writeQueue;
     private closed;
@@ -121,6 +129,8 @@ export declare class SqliteNoteStore implements NoteStore {
      * the changes since reach it as a delta.
      */
     private epochAt;
+    /** What the active notes of one epoch cost, as the epoch froze them. */
+    private epochTokens;
     /** The active notes one epoch froze, by summary, sorted by id. */
     private epochSummaries;
 }

package/notes.js

@@ -31,6 +31,7 @@ import { noteIdOf, noteRefOf, noteRefForms, parseNoteId, parseNoteRef, storedEve
 import { FTS_TABLE, createSchema } from "./schema.js";
 import { USE_WEIGHTS, applyJudgeShare, pickByBudget, scoreNotes } from "./score.js";
 import { holdingIds, substringClause } from "./search.js";
+import { textOf, zhTextTable } from "@4fu/arbor-prompt";
 /** A summary is at most this many characters (docs/memory.md). */
 export const SUMMARY_LIMIT = 200;
 /** How many characters of a body one read returns. */
@@ -87,19 +88,19 @@ export function deriveSummary(body) {
     const characters = Array.from(flat);
     return characters.length <= SUMMARY_LIMIT ? flat : `${characters.slice(0, SUMMARY_LIMIT).join("")}…`;
 }
-function invalidNoteRef(call, ref) {
+function invalidNoteRef(text, call, ref) {
     return arborError({
         code: "invalid_input",
         rule: `note.${call}.ref`,
-        message: `note.${call}: ${ref} is not a note ref`,
-        nextAction: "pass a note ref such as n012, or one of its revisions such as n012@3",
+        message: text("refused.note.ref", { ref }),
+        nextAction: text("next.note.ref"),
         details: { ref },
     });
 }
-function parseOrThrow(ref, call) {
+function parseOrThrow(text, ref, call) {
     const parsed = parseNoteRef(ref);
     if (parsed === null)
-        throw invalidNoteRef(call, ref);
+        throw invalidNoteRef(text, call, ref);
     return parsed;
 }
 function toSummary(row) {
@@ -164,6 +165,8 @@ export class SqliteNoteStore {
     journal;
     clock;
     halfLifeMs;
+    /** The table every refusal this store raises is written from. */
+    text;
     /** One write at a time: a write spans the notes database and the journal. */
     writeQueue = Promise.resolve();
     closed = false;
@@ -174,6 +177,7 @@ export class SqliteNoteStore {
         this.journal = options.journal;
         this.clock = options.now ?? (() => Date.now());
         this.halfLifeMs = options.usageHalfLifeMs ?? DEFAULT_HALF_LIFE_MS;
+        this.text = options.text ?? ((key, args) => textOf(zhTextTable, key, args));
     }
     // --- writes -------------------------------------------------------------
     async write(input) {
@@ -217,8 +221,8 @@ export class SqliteNoteStore {
             throw arborError({
                 code: isArborError(error) ? error.code : "internal",
                 rule: "note.write.journal",
-                message: `note.write: ${noteRef} was not written because the journal refused the event (${detail})`,
-                nextAction: "fix what the journal refused, then write the note again",
+                message: this.text("refused.note.write.journal", { ref: noteRef, detail }),
+                nextAction: this.text("next.note.write.journal"),
                 details: { upstream: detail },
                 cause: error,
             });
@@ -233,36 +237,44 @@ export class SqliteNoteStore {
     }
     /** The rules a write has to meet before it touches the one copy. */
     checkWrite(input) {
+        if (input.id !== undefined && input.id.trim() === "") {
+            throw arborError({
+                code: "invalid_input",
+                rule: "note.write.id",
+                message: this.text("refused.note.write.id"),
+                nextAction: this.text("next.note.write.id"),
+            });
+        }
         if (input.title.trim() === "") {
             throw arborError({
                 code: "invalid_input",
                 rule: "note.write.title",
-                message: "note.write: a note needs a title",
-                nextAction: "give the note a short title",
+                message: this.text("refused.note.write.title"),
+                nextAction: this.text("next.note.write.title"),
             });
         }
         if (input.delete !== true && input.body.trim() === "") {
             throw arborError({
                 code: "invalid_input",
                 rule: "note.write.body",
-                message: "note.write: a note needs a body",
-                nextAction: "write what the note holds in body; a delete needs no body",
+                message: this.text("refused.note.write.body"),
+                nextAction: this.text("next.note.write.body"),
             });
         }
         if (input.summary !== undefined && Array.from(input.summary).length > SUMMARY_LIMIT) {
             throw arborError({
                 code: "invalid_input",
                 rule: "note.write.summary",
-                message: `note.write: a summary is at most ${SUMMARY_LIMIT} characters`,
-                nextAction: `shorten the summary to at most ${SUMMARY_LIMIT} characters, or omit it`,
+                message: this.text("refused.note.write.summary", { limit: SUMMARY_LIMIT }),
+                nextAction: this.text("next.note.write.summary", { limit: SUMMARY_LIMIT }),
             });
         }
         if (input.id === undefined && input.expectedRevision !== undefined) {
             throw arborError({
                 code: "invalid_input",
                 rule: "note.write.expected_revision",
-                message: "note.write: a new note has no revision to name",
-                nextAction: "omit expectedRevision to write a new note, or pass the note's id to replace it",
+                message: this.text("refused.note.write.expected_revision"),
+                nextAction: this.text("next.note.write.expected_revision"),
             });
         }
     }
@@ -280,22 +292,22 @@ export class SqliteNoteStore {
         else {
             const parsed = parseNoteId(input.id);
             if (parsed === null)
-                throw invalidNoteRef("write", input.id);
+                throw invalidNoteRef(this.text, "write", input.id);
             previous = this.noteRow(parsed);
             if (previous === null) {
                 throw arborError({
                     code: "not_found",
                     rule: "note.write.note",
-                    message: `note.write: ${input.id} is not in the notes`,
-                    nextAction: "omit id to write a new note, or look the note up with notes.search",
+                    message: this.text("refused.note.write.note", { id: input.id }),
+                    nextAction: this.text("next.note.write.note"),
                 });
             }
             if (previous.status === "deleted") {
                 throw arborError({
                     code: "not_found",
                     rule: "note.write.deleted",
-                    message: `note.write: ${input.id} is deleted`,
-                    nextAction: "its revisions still resolve by ref, but it cannot be written; write a new note instead",
+                    message: this.text("refused.note.write.deleted", { id: input.id }),
+                    nextAction: this.text("next.note.write.deleted"),
                 });
             }
             const expected = input.expectedRevision;
@@ -303,16 +315,20 @@ export class SqliteNoteStore {
                 throw arborError({
                     code: "invalid_input",
                     rule: "note.write.revision",
-                    message: `note.write: ${input.id} is at revision ${previous.revision}; a write names the revision it read`,
-                    nextAction: `read the note and write again against revision ${previous.revision}`,
+                    message: this.text("refused.note.write.revision", { id: input.id, revision: previous.revision }),
+                    nextAction: this.text("next.note.write.revision", { revision: previous.revision }),
                 });
             }
             if (expected > previous.revision) {
                 throw arborError({
                     code: "invalid_input",
-                    rule: "note.write.revision",
-                    message: `note.write: ${input.id}@${expected} does not exist; the note is at revision ${previous.revision}`,
-                    nextAction: `read the note and write again against revision ${previous.revision}`,
+                    rule: "note.write.revision.absent",
+                    message: this.text("refused.note.write.revision.absent", {
+                        id: input.id,
+                        expected,
+                        revision: previous.revision,
+                    }),
+                    nextAction: this.text("next.note.write.revision.absent", { revision: previous.revision }),
                 });
             }
             if (expected < previous.revision)
@@ -326,9 +342,9 @@ export class SqliteNoteStore {
                 input.body !== previous.body) {
                 throw arborError({
                     code: "invalid_input",
-                    rule: "note.write.summary",
-                    message: `note.write: a replace that changes the body of ${input.id} names a summary`,
-                    nextAction: `write a summary of at most ${SUMMARY_LIMIT} characters for the new body`,
+                    rule: "note.write.replace_summary",
+                    message: this.text("refused.note.write.replace_summary", { id: input.id }),
+                    nextAction: this.text("next.note.write.replace_summary", { limit: SUMMARY_LIMIT }),
                 });
             }
         }
@@ -435,8 +451,16 @@ export class SqliteNoteStore {
         return arborError({
             code: "conflict",
             rule: "note.write.stale_revision",
-            message: `note.write: ${noteIdOf(note.id)} is at revision ${current}, not the revision ${read} you read; merge what changed and write again`,
-            nextAction: `read ${noteIdOf(note.id)}@${current} and the revisions since ${read}, merge them with this write, then write again against revision ${current}`,
+            message: this.text("refused.note.write.stale_revision", {
+                ref: noteRefOf(note.id, current),
+                current,
+                read,
+            }),
+            nextAction: this.text("next.note.write.stale_revision", {
+                ref: noteRefOf(note.id, current),
+                current,
+                read,
+            }),
             refs: [noteRefOf(note.id, current), ...revisions.map((revision) => revision.ref)],
             details: {
                 conflict: { read, current, revisions },
@@ -447,7 +471,7 @@ export class SqliteNoteStore {
     // --- reads --------------------------------------------------------------
     async read(ref, options) {
         this.ensureOpen();
-        const parsed = parseOrThrow(ref, "read");
+        const parsed = parseOrThrow(this.text, ref, "read");
         const row = parsed.revision === null ? this.latestRevisionRow(parsed.id) : this.revisionRow(parsed.id, parsed.revision);
         if (row === null)
             return null;
@@ -469,7 +493,7 @@ export class SqliteNoteStore {
     }
     async revisions(ref) {
         this.ensureOpen();
-        const parsed = parseOrThrow(ref, "revisions");
+        const parsed = parseOrThrow(this.text, ref, "revisions");
         const limit = DEFAULT_PAGE_LIMIT;
         const nextCall = `notes.revisions(${noteIdOf(parsed.id)}, offset=${limit})`;
         const note = this.noteRow(parsed.id);
@@ -510,7 +534,7 @@ export class SqliteNoteStore {
     }
     async context(ref) {
         this.ensureOpen();
-        const parsed = parseOrThrow(ref, "context");
+        const parsed = parseOrThrow(this.text, ref, "context");
         const note = this.noteRow(parsed.id);
         if (note === null)
             return null;
@@ -552,6 +576,7 @@ export class SqliteNoteStore {
                 limit: items.length,
                 nextCall: `notes.delta(${epoch.epoch})`,
                 budget,
+                tokens: this.epochTokens(epoch.epoch),
             };
         });
     }
@@ -564,8 +589,8 @@ export class SqliteNoteStore {
             throw arborError({
                 code: "invalid_input",
                 rule: "note.delta.epoch",
-                message: `note.delta: epoch ${since} is not in the notes`,
-                nextAction: "pass the epoch the window froze, or 0 for every note",
+                message: this.text("refused.note.delta.epoch", { since }),
+                nextAction: this.text("next.note.delta.epoch"),
                 details: { since },
             });
         }
@@ -631,7 +656,7 @@ export class SqliteNoteStore {
     }
     async recordUse(input) {
         this.ensureOpen();
-        const parsed = parseOrThrow(input.ref, "recordUse");
+        const parsed = parseOrThrow(this.text, input.ref, "recordUse");
         // A use of a note that is not there names a ref that does not resolve; the
         // host's own append must not fail for it.
         if (this.noteRow(parsed.id) === null)
@@ -668,8 +693,8 @@ export class SqliteNoteStore {
             throw arborError({
                 code: "unavailable",
                 rule: "note.closed",
-                message: "notes: the note store is closed",
-                nextAction: "open a note store before reading or writing",
+                message: this.text("refused.note.closed"),
+                nextAction: this.text("next.note.closed"),
             });
         }
     }
@@ -841,6 +866,13 @@ export class SqliteNoteStore {
             activate.run(item.note);
         return this.epochRow(epoch);
     }
+    /** What the active notes of one epoch cost, as the epoch froze them. */
+    epochTokens(epoch) {
+        const row = this.db
+            .prepare("SELECT COALESCE(SUM(tokens), 0) AS total FROM note_epoch_items WHERE epoch = ?")
+            .get(epoch);
+        return row === undefined ? 0 : toNumber(row.total);
+    }
     /** The active notes one epoch froze, by summary, sorted by id. */
     epochSummaries(epoch) {
         const rows = this.db

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@4fu/arbor-notes-sqlite",
-  "version": "2026.1106.0",
+  "version": "2026.1106.1",
   "type": "module",
   "description": "The default NoteStore: one copy of every note, checked writes, revisions, anchors and the active set on SQLite beside the journal.",
   "exports": {
@@ -40,7 +40,8 @@
     "access": "public"
   },
   "dependencies": {
-    "@4fu/arbor-errors": "2026.1106.0",
-    "@4fu/arbor-interfaces": "2026.1106.0"
+    "@4fu/arbor-errors": "2026.1106.1",
+    "@4fu/arbor-interfaces": "2026.1106.1",
+    "@4fu/arbor-prompt": "2026.1106.1"
   }
 }