@animalabs/agent-framework 0.26.2 → 0.28.0

package/dist/src/modules/workspace/index.d.ts

@@ -26,10 +26,12 @@ export type { WorkspaceConfig, MountConfig, MountState, WorkspaceModuleState, Re
  * directories leading out of it (`escape`), a file swapped underneath the read
  * (`changed`), a path the mount's `include` doesn't cover (`outside_include`),
  * and a path in another mount's directory nested in the one named
- * (`other_mount`), whose message names the mount that holds it and the path
- * to use there. A symlink leading into such a directory is `other_mount`
- * only where its refusal names that mount: a directory, or a file that
- * mount's include covers. Anywhere else, on a mount that doesn't follow
+ * (`other_mount`), whose message names the mount that holds it, or may hold
+ * it, and the path to use there. A symlink leading into such a directory is
+ * `other_mount` only where its refusal names that mount: a directory, or a
+ * file that mount's include covers, and so does the include of each other
+ * nested mount whose directory may hold it, out to the first that surely
+ * does. Anywhere else, on a mount that doesn't follow
  * symlinks, it gets the code of a link where it stands, `symlink` at the
  * path itself and `parent_symlink` on its way, and on one that does,
  * `escape`, as a path that leaves the mount. On a mount with an include, a
@@ -119,14 +121,11 @@ export declare class WorkspaceModule implements Module {
     private ctimeTrust;
     /**
      * Each mount's directories that are other mounts nested inside it, with
-     * each mount's name and real root, in each spelling that names the
-     * directory: as configured; as the real roots place it, where that differs
-     * (`fromRoots`); and as disk spells each of those where that differs.
-     * Each spelling is mount-relative and `/`-separated, with its root beneath
-     * the mount's resolved root. The constructor nests by configured path,
-     * with each root as resolved standing for its real one, and each start
-     * reads it all again with the roots placed where disk has them
-     * (readNesting).
+     * each mount's name and real root: as configured, and as the real roots
+     * place it, where that differs (`fromRoots`). Each is mount-relative and
+     * `/`-separated. The constructor nests by configured path, with each root
+     * as resolved standing for its real one, and each start reads it all again
+     * with the roots placed where disk has them (readNesting).
      */
     private otherMounts;
     /** Whether each mount's root folds case (foldsCase), where disk has it, as the last start read it. */
@@ -152,6 +151,23 @@ export declare class WorkspaceModule implements Module {
      * ensureRunning to say once both halves of the lifecycle have run.
      */
     private notDirect;
+    /**
+     * Each agent's latest direct write on each mount it wrote direct, P, with
+     * the notice of its departure from it, N (DirectHead), by mount, then by
+     * agent. Saved at stop() in a global record (headsJournal), not the
+     * module's branch state: they describe disk, which doesn't rewind with a
+     * branch, so a restart on another branch, such as one an offline rollback
+     * made, still finds them.
+     */
+    private directHeads;
+    /** Where directHeads is saved and loaded (DIRECT_HEADS_RECORD_TYPE), once initStore() has read it. */
+    private headsJournal;
+    /** The record initStore() read, as saved text, so a stop that would save the same adds none; null where there's one to replace. */
+    private loadedHeads;
+    /** Saved entries this session doesn't take up (another root, a mount not configured direct, or none), kept for the next save. */
+    private carriedHeads;
+    /** Whether an agent's history holds a message, as the framework hands it over (useHistory). */
+    private historyLookup;
     constructor(config: WorkspaceConfig);
     /**
      * Inject the Chronicle store. Must be called after framework creation.
@@ -163,6 +179,22 @@ export declare class WorkspaceModule implements Module {
      * second. `ensureRunning()` gates on `ctx && mounts-populated`.
      */
     initStore(store: JsStore): void;
+    /**
+     * The positions stop() last saved (directHeads), before any call can
+     * write: each saved entry is a mount's positions at one root, and a mount
+     * this session configures direct gets the entry at its own root. Every
+     * other entry, a mount configured at another root, not direct, or not at
+     * all, is kept for the next save (carriedHeads), since its writes are
+     * still on disk beneath that root; a mount removed for good, and each
+     * root a mount has moved from, leave that small entry behind. A record
+     * the store can't read is logged, and this session starts with none and
+     * saves none, so the record stands for a session that can read it. One
+     * read but not of the shape saved is logged too, and this session starts
+     * with none and its stop replaces it, so a damaged record doesn't keep
+     * every later session from saving. Either way, a move away from the
+     * writes before it goes untold, as after a crash.
+     */
+    private loadDirectHeads;
     /**
      * Whether each mount configured direct runs direct: not while the store
      * holds changes there that disk lacks, on the branch selected then, so
@@ -289,15 +321,40 @@ export declare class WorkspaceModule implements Module {
     private sayNotDirect;
     private initialScan;
     stop(): Promise<void>;
-    /** Mount names + modes, and each mount's include where it sets one, for
-     *  peer callers (framework spill/journal paths) that need a mount for files
-     *  of their own, the first writable one without an include
-     *  (firstWritableMountName), without reaching into private state. */
+    /**
+     * Save directHeads as one global record, the latest of which the next
+     * start loads (loadDirectHeads): each mount's positions with the root
+     * they were made under, and the entries this session didn't take up
+     * (carriedHeads), unchanged. Only when that differs from what the
+     * start loaded, so a session that changed nothing, or a store no direct
+     * write reached, adds no record, and always where the record read wasn't
+     * of the shape saved, which this replaces. Nothing where the store couldn't
+     * read the record, so it stands. A save that fails is logged, and the next
+     * start finds the positions of the last save that landed, as after a
+     * crash.
+     */
+    private saveDirectHeads;
+    /** Mount names + modes, each mount's include where it sets one, and
+     *  `backend: 'direct'` for one configured direct, whether it runs direct
+     *  this session or, while the store holds work there disk lacks, as
+     *  'chronicle': either way it's a directory agents write directly when it
+     *  runs direct, whose files an undo leaves. For the
+     *  framework's tool-result spills, saved payloads and fetched references,
+     *  which need a mount for files of their own: the first writable one
+     *  without an include that isn't direct (firstWritableMountName), without
+     *  reaching into private state. */
     getMounts(): Array<{
         name: string;
         mode: 'read-write' | 'read-only';
         include?: readonly string[];
+        backend?: 'direct';
     }>;
+    /**
+     * Whether any of this host's mounts runs direct. The tools' descriptions
+     * and grep's notes mention direct mounts only on such a host, so both ask
+     * this one question.
+     */
+    private anyRunsDirect;
     getTools(): ToolDefinition[];
     private generatedTextFiles;
     /** Compare the same normalized physical path for registration and tool access. */
@@ -315,6 +372,8 @@ export declare class WorkspaceModule implements Module {
     /** `work`, recorded as under way until it settles (callsUnderWay). */
     private underWay;
     private runToolCall;
+    private answerToolCall;
+    private failureAnswer;
     onProcess(event: ProcessEvent, _state: ProcessState): Promise<EventResponse>;
     /**
      * Resolve a mount-prefixed path (e.g. "tickets/2026-04-22-foo.md") to its
@@ -354,6 +413,15 @@ export declare class WorkspaceModule implements Module {
      * withheld original this way, for the branch its stub is on
      * (agent-framework #277).
      *
+     * On a mount running direct, the bytes go to disk as a direct `write`'s
+     * do, whole or not at all, and nothing goes into the store: `branch` is
+     * checked before the write starts and again just before its rename, and
+     * `agentName` names the agent whose write it is for the head-move notice
+     * (a write naming none tells no agent).
+     *
+     * A success's `disk` says where the file stands on disk as the workspace
+     * last saw it, as the write tool's answer does.
+     *
      * A write whose tree entry is set but that then fails returns success
      * false with `data: { inChronicle: true }`: its copy on disk was refused,
      * the store failed after recording the entry, which skips the push where
@@ -365,14 +433,19 @@ export declare class WorkspaceModule implements Module {
      */
     writeBinary(mountPrefixedPath: string, data: Buffer, mimeType: string, options?: {
         branch?: string;
+        agentName?: string;
     }): Promise<ToolResult>;
     private writeBinaryUnderWay;
     /**
-     * Read a file's raw bytes from a mount (through the Chronicle tree, synced
-     * first like the `read` tool; on a direct mount, from disk as
-     * readBinaryFromDisk reads it, at most the mount's `maxFileSize`). Public
-     * API for the framework's synthesized `read_image` tool and other peer
-     * callers that need binary content.
+     * Read a file's raw bytes from a mount: through the Chronicle tree, a path
+     * the workspace doesn't hold observed first (ensureSynced); or, on a direct
+     * mount, from disk as readBinaryFromDisk reads it, at most the mount's
+     * `maxFileSize`. A path the workspace holds is read as the workspace holds
+     * it, not settled as the `read` tool settles it: the tree takes in no
+     * binary disk copy, so a pass over a held binary file that disk changed
+     * would drop the workspace's copy. Public API for the framework's
+     * synthesized `read_image` tool, where the workspace module doesn't serve
+     * read_image itself, and other peer callers that need binary content.
      */
     readBinary(mountPrefixedPath: string): Promise<{
         data: Buffer;
@@ -413,7 +486,7 @@ export declare class WorkspaceModule implements Module {
     }>;
     /** A file's bytes as readBinaryFromDisk reads them, once its path is parsed. */
     private bytesFromDisk;
-    /** The directories of the mounts nested inside a mount, mount-relative, in each spelling. */
+    /** The directories of the mounts nested inside a mount, mount-relative. */
     private othersOf;
     /**
      * Which mounts are nested in which, read afresh at each start. A mount is
@@ -428,13 +501,8 @@ export declare class WorkspaceModule implements Module {
      * alone, with no real root, since through it it would claim the other's
      * every path.
      *
-     * Each way it lies there is a spelling of its directory (`fromRoots`), and
-     * so is the spelling disk lists each of those by, where that differs. On a
-     * disk that folds names, the outer mount's walks name the directory as
-     * disk does, and so does a path parsePath has respelled, while a path given
-     * as configured still names it as configured (resolveAbsolutePath). A
-     * directory not on disk keeps the spellings the roots give alone. Each
-     * mount's real root comes back beside the nesting (`reals`), for what
+     * Each way it lies there is a spelling of its directory (`fromRoots`).
+     * Each mount's real root comes back beside the nesting (`reals`), for what
      * start reads there, and each directory above each configured path with
      * where it lies on disk (`above`), for a direct mount whose root moves
      * (movedNesting).
@@ -442,7 +510,7 @@ export declare class WorkspaceModule implements Module {
     private readNesting;
     /**
      * The mounts nested in `mountName`, by directory, name, real root where it
-     * has one, and include (MountView's `nested`), in each spelling known.
+     * has one, and include (MountView's `nested`).
      */
     private nestedOf;
     /**
@@ -475,8 +543,10 @@ export declare class WorkspaceModule implements Module {
      * mount nested by its directories alone, since its real root holds this
      * one, is judged by the parse's nesting, so a root repointed between a
      * read's parse and its open can have it serve a path in that mount's
-     * directory. Each mount is placed as a start places it (placementOf), from
-     * where its real root and the directories above its configured path lie on
+     * directory, and one repointed between a direct write's parse and its
+     * staging can have the write land there. Each mount is placed as a start
+     * places it (placementOf), from where its real root and the directories
+     * above its configured path lie on
      * disk. For a mount configured at this mount's own path or beneath it,
      * that's where they lie now: beneath `rootReal` where they lie beneath this
      * mount's path, and the directories above this mount's path as resolving
@@ -499,13 +569,7 @@ export declare class WorkspaceModule implements Module {
      * of that mount, judged lexically where the path lands (`.`, `..` and
      * repeated separators resolved, as for the traversal guard; a link of the
      * outer mount isn't followed), with the path to use there; undefined when
-     * no nested mount's directory holds it. A path parsePath has respelled is
-     * compared with the directory's spellings exactly. One judged as given
-     * (`asGiven`, resolveAbsolutePath's) is compared loosely, as a disk that
-     * folds names may compare it (beginsWithDir), so it can't reach that
-     * mount's directory by spelling a segment otherwise. On a disk that tells
-     * names apart, that takes a directory of this mount's own spelled like the
-     * nested one in another way as that mount's too.
+     * no nested mount's directory holds it.
      */
     private holderOf;
     /**
@@ -550,8 +614,7 @@ export declare class WorkspaceModule implements Module {
      * mount's directory first, naming the mount that holds it, then outside
      * the mount's include. Each is judged on the path as the caller parsed it:
      * as disk spells it for parseFilePath, as given for resolveAbsolutePath,
-     * which is synchronous and says so (`asGiven`, so the nested-mount check
-     * folds where disk does). The include's refusal shows the path as given
+     * which is synchronous. The include's refusal shows the path as given
      * (`given`), since it answers the path the caller asked about.
      */
     private refuseNotHeld;
@@ -624,8 +687,8 @@ export declare class WorkspaceModule implements Module {
     private parsePath;
     /**
      * How many segments the innermost nested mount's directory that holds
-     * `relativePath` has, in a spelling it's known by (othersOf), or, for a
-     * direct mount whose root has moved, in the nesting there (`moved`);
+     * `relativePath` has, or, for a direct mount whose root has moved, in the
+     * nesting there (`moved`);
      * undefined when no nested mount's directory holds it.
      */
     private nestedDepth;
@@ -655,6 +718,10 @@ export declare class WorkspaceModule implements Module {
      * path refuses it here, a disk reader included.
      */
     private parsePathAsGiven;
+    private writableNames;
+    private mountList;
+    private noSuchMountField;
+    private noSuchMount;
     /**
      * Whether the module takes work: stop hasn't finished. Work admitted while
      * stop drains still runs; once stop has saved the pins and watermarks,
@@ -666,7 +733,7 @@ export declare class WorkspaceModule implements Module {
     private running;
     private getStore;
     private validateImageBytes;
-    private tryReadImageFromTree;
+    private readImageFromTree;
     /**
      * The mount root a disk read reads beneath: resolved, then checked as
      * observation checks it (checkRoot), so the read and the evidence agree on
@@ -681,7 +748,8 @@ export declare class WorkspaceModule implements Module {
      * another directory carries none. The identity is rootIdentityForRead's,
      * which answers while the evidence awaits reopening; where even it can't
      * be read, as when the evidence was never read back whole, the read is
-     * refused too, with an errno only where no directory is at the root's path.
+     * refused before its root is resolved, with an errno only where no
+     * directory is at the root's path.
      * A direct mount's root is checked against no identity, and its read reads
      * no evidence: it promises what's at its root now (diskView).
      */
@@ -771,11 +839,11 @@ export declare class WorkspaceModule implements Module {
      * (`outside_include`), a path in another mount's directory nested in the one named
      * (`other_mount`), unavailable mount, missing or non-regular file,
      * directory, policy-denied symlink, outside-mount target, and
-     * file-changed-during-read.
+     * file-changed-during-read. An error met while parsing the path that is
+     * none of these refusals, such as the store's, is thrown as it is, and a
+     * `maxBytes` that isn't a non-negative integer throws a `RangeError`.
      */
     readFileFromDisk(mountPrefixedPath: string, options?: ReadFileFromDiskOptions): Promise<WorkspaceDiskReadResult>;
-    /** Map a core read refusal onto the image reader's historical error vocabulary and wording. */
-    private imageErrorFromRead;
     private readImageFromFilesystem;
     /**
      * Whether a tool's change on this mount goes to disk as it commits: the
@@ -801,9 +869,10 @@ export declare class WorkspaceModule implements Module {
      * downstream agents. And, apart from it, why a write whose bytes reached
      * disk left the file's mode as disk had it (`modeKept`), and, for a
      * deletion that cleared a conflict naming a disk file the workspace never
-     * took in, that nothing was unlinked (`note`). The caller holds the mount's
-     * turn and has settled the path first (settleBeforeMutation, or a pass over
-     * the path, as an edit makes).
+     * took in, that nothing was unlinked (`note`). And the answer's `disk` for
+     * the path, unless it was refused. The caller holds the mount's turn and has
+     * settled the path first (settleBeforeMutation, or a pass over the path, as
+     * an edit makes).
      */
     private commitToolChange;
     /**
@@ -819,9 +888,10 @@ export declare class WorkspaceModule implements Module {
      * (changesLanded).
      * Answers, by path, the reason for each that reached the workspace but not
      * disk (`refused`), and, apart from it, why one whose bytes reached disk
-     * left the file's mode as disk had it (`modeKept`), and that a deletion
-     * clearing a conflict that named a disk file unlinked nothing (`notes`), as
-     * commitToolChange answers them for one path.
+     * left the file's mode as disk had it (`modeKept`), that a deletion
+     * clearing a conflict that named a disk file unlinked nothing (`notes`),
+     * and the answer's `disk` for each path not refused, as commitToolChange
+     * answers them for one path.
      */
     private commitToolChanges;
     /**
@@ -837,15 +907,19 @@ export declare class WorkspaceModule implements Module {
      */
     private settleBeforeMutation;
     /**
-     * Before a read: a path the workspace doesn't hold is observed under the
-     * three-way rule, which ingests a new disk file but never brings back a
-     * workspace deletion or a file absent from this branch. The pass names the
-     * path, as a file tool names the one it acts on: a path the mount passes
-     * over by design is observed, as a sync naming it would observe it (#276),
-     * while a path in another mount's directory is refused before this, and
-     * passed over by any pass. Answers the pass's report on the path, and why
-     * the pass decided nothing where it did (undecidedOf), which leaves disk
-     * unchecked. The caller holds the mount's turn.
+     * Before a deletion, and for readBinary: a path the workspace doesn't hold
+     * is observed under the three-way rule, which ingests a new disk file but
+     * never brings back a workspace deletion or a file absent from this branch.
+     * A path it holds is left alone. For a deletion, as for a write, taking
+     * disk's change in first would let the push remove that change unseen; for
+     * readBinary, a pass would drop a held binary file that disk changed, since
+     * the tree takes in no binary disk copy. The pass names the path, as a file
+     * tool names the one it acts on: a path the mount passes over by design is
+     * observed, as a sync naming it would observe it (#276), while a path in
+     * another mount's directory is refused before this, and passed over by any
+     * pass. Answers the pass's report on the path, and why the pass decided
+     * nothing where it did (undecidedOf), which leaves disk unchecked. The
+     * caller holds the mount's turn.
      */
     private ensureSynced;
     /**
@@ -857,10 +931,11 @@ export declare class WorkspaceModule implements Module {
     /** Why the workspace holds no entry at a path, when disk explains it. */
     private notInWorkspace;
     /**
-     * A file's bytes for read, from where the mount keeps what it reads: the
-     * workspace's copy, taken in from disk first where it holds none
-     * (ensureSynced); or, on a direct mount, disk's file as it is now
-     * (bytesOnDisk). An error says why there are none to read.
+     * A file's bytes for read, and the notes that say which copy they are. On a
+     * 'chronicle' mount it's the workspace's copy, after a pass over the path
+     * takes disk's change to it in first. On a direct mount it's disk's file as
+     * it is now (bytesOnDisk), with no notes, since nothing else is kept. An
+     * error says why there are none to read.
      */
     private bytesOf;
     /**
@@ -872,6 +947,16 @@ export declare class WorkspaceModule implements Module {
      * read_image reads where it's an image.
      */
     private bytesOnDisk;
+    private contentsOf;
+    private tellLost;
+    private diskLacks;
+    private restoreEach;
+    /**
+     * A read's page, held to `maxChars`, the most of this call's result that
+     * can reach its caller whole. A call that carries none, made in process,
+     * takes the data itself: its page holds to its line limit alone, with every
+     * line whole, as it did before pages had a budget.
+     */
     private handleRead;
     private handleReadImage;
     private handleWrite;
@@ -896,12 +981,14 @@ export declare class WorkspaceModule implements Module {
      * stored where its record landed, and that it can't tell where they
      * couldn't be read back.
      * Under the mount's turn, one pass settles every path with disk, by the
-     * rule a listing uses, so the edits apply to what disk now holds. That pass
-     * is the only step that awaits before the commit: every file is then read,
-     * every edit planned, and every entry set (commitToolChanges) with no turn
-     * of the event loop between, so no pass, branch change or other call moves
-     * the tree between a file's read and its set. Disk then takes what it can
-     * of the stored change.
+     * rule a listing uses, so the edits apply to what disk now holds. Each
+     * file's stored contents are then read; where the store has lost some,
+     * they're restored from disk's matching copy (contentsOf) and the pass runs
+     * again, so the plan reads a pass taken after every await. From there
+     * nothing awaits before the commit: every edit is planned and every entry
+     * set (commitToolChanges) with no turn of the event loop between, so no
+     * pass, branch change or other call moves the tree between a file's read
+     * and its set. Disk then takes what it can of the stored change.
      *
      * The answer is held to `maxChars`, the length the call's result may have
      * (ToolCall.resultMaxChars), as edit-text.ts describes.
@@ -938,8 +1025,132 @@ export declare class WorkspaceModule implements Module {
      * would (`conflicts`, found only where the mount doesn't push).
      */
     private editsStoredButUnfinished;
+    /**
+     * A direct mount's write of a whole file: its bytes staged beside it and
+     * renamed over it (direct-write.ts), under the mount's turn, so the
+     * module's own calls take turns. Answers a note when the file had other
+     * hard links, which keep its old text, or why nothing was written. One
+     * that lands is the caller's latest write on the mount (recordDirectWrite).
+     * With `branch`, nothing is written once the store's branch is another,
+     * checked with no turn of the event loop before the rename (writeBinary's).
+     */
+    private writeDirect;
+    /**
+     * applyEdits on a direct mount, under the mount's turn, whose edits land
+     * on disk or don't happen. Each attempt reads every file from disk as it
+     * is now (directEditText), plans every edit against those bytes as on any
+     * mount (planTargetEdits), stages every file beside itself, checks every
+     * one unchanged since its read, and then renames each over its file in
+     * turn (direct-write.ts). A file another writer changed between its read
+     * and its check has the call read and planned again against its new
+     * text, three attempts in all (DIRECT_EDIT_ATTEMPTS), so edits that no
+     * longer apply to it, a file that changed at every attempt, or a file the
+     * next read refuses as any read would (now past the size limit, say) are
+     * refused, with nothing written. A rename that fails after others leaves
+     * those written and the rest as they were, and the answer names each
+     * file's outcome; nothing puts the written ones back.
+     */
+    private applyDirectEdits;
+    /**
+     * One attempt of applyDirectEdits: its answer, or 'changed' when another
+     * writer changed a file since its read, with nothing written. `early` are
+     * the problems found before any file was read, which a refusal names with
+     * the rest. The caller holds the mount's turn.
+     */
+    private attemptDirectEdits;
+    /**
+     * The answer to an edit_many call on a direct mount whose rename of its
+     * `failed`th file failed after the ones before it were written: what was
+     * written, the failure, and that nothing puts them back, then each file's
+     * outcome, within `maxChars`, with the hard links a written one split
+     * from, as a full answer names them (linksNote).
+     */
+    private directEditsPartway;
+    /**
+     * A direct mount's file as an edit reads it: its bytes on disk as they are
+     * now, through the mount's boundary as read reaches them
+     * (openContainedFile), with the file's identity when the read began, which
+     * the write checks it against just before its rename. A file changed while
+     * it was read is `changed`, so the call reads it again. What the
+     * workspace doesn't show as text, it doesn't edit either: a file over the
+     * mount's size limit, and a binary one.
+     */
+    private directEditText;
+    /**
+     * A direct mount's deletion: the file the read tools reach, by their
+     * refusals (openContainedFile), unlinked through the mount's boundary as
+     * a push's deletion unlinks one (unlinkContained). A followed link is the
+     * entry removed, as there. One that lands is the caller's latest write on
+     * the mount (recordDirectWrite).
+     */
+    private deleteDirect;
+    /**
+     * After a direct write lands: the agent's latest write on the mount, P,
+     * moves to it, where the agent's history holds P or the notice of its
+     * departure from P, N (historyHoldsWrites), and N clears. Otherwise P
+     * stays where it is: the head moved away from it under the call's turn,
+     * and the next start's notice covers what it left (headMoveNotice). P is
+     * the branch and the store's head as it is now, read with no turn of the
+     * event loop since the write, so no record that lands after the write is
+     * taken for one before it. A deletion, whose unlink is awaited, passes
+     * where the head was just before its unlink (`since`): where the branch
+     * changed meanwhile, the head moved under the call, and P is set there,
+     * so the next start judges the deletion by the branch its turn was on,
+     * unless the history doesn't hold P already, whose notice is owed. A write no agent
+     * made tells no one. The store's reads here come after the write landed,
+     * so one that throws is logged and P stays, as for a history that can't
+     * be read, and the write still answers that it landed.
+     */
+    private recordDirectWrite;
+    /** The store's branch and head now, or null where the store can't say. */
+    private positionNow;
+    /**
+     * Whether an agent's history holds its latest direct write on a mount
+     * (holdsPosition), or the notice of its departure from it, judged by the
+     * notice's own presence there, through the lookup the framework hands the
+     * module (useHistory); null where that lookup threw, which is logged. A
+     * history that can't be read decides nothing: a write takes it as not
+     * held, so its position stays and the notice stays owed, and a start
+     * gives no notice, which may not be true of a history it can't read, and
+     * leaves the next start to decide (headMoveNotice).
+     */
+    private historyHoldsWrites;
+    /**
+     * Whether the store's current branch holds what came before a direct
+     * write: it's the write's branch, or continues it with every fork point on
+     * the way after `after`, the store's head when the write landed. A fork at
+     * exactly `after` doesn't: an undo forks at its turn's sequenceBefore,
+     * which is the head at the write when nothing was recorded in the turn
+     * before it. A missing branch or one without fork metadata holds nothing,
+     * as for the materialize guard (isLinearContinuation).
+     */
+    private holdsPosition;
+    /**
+     * The framework's check at every start of an agent's turn, opening,
+     * continuing or resuming: the notice due for each mount the agent wrote
+     * direct where its history holds neither its latest write there nor the
+     * notice of its departure from it (historyHoldsWrites), with those
+     * mounts' names; or null, as on a head that hasn't moved. The framework
+     * stores the text in the agent's history before the turn's compile and
+     * hands its message id back (headMoveNoticeStored).
+     */
+    headMoveNotice(agentName: string): {
+        text: string;
+        mounts: string[];
+    } | null;
+    /** The id of the message headMoveNotice's text was stored as, N, for each mount it named. */
+    headMoveNoticeStored(agentName: string, mounts: readonly string[], messageId: string): void;
+    /**
+     * How the module asks whether an agent's history holds a message, as the
+     * framework judges its own notices (`cm.getMessage(id) !== null`): handed
+     * over once, when the module is added. Without it, no notice is held.
+     */
+    useHistory(lookup: (agentName: string, messageId: string) => boolean): void;
     private handleDelete;
     private handleLs;
+    private emptyScopeNote;
+    private absentOnDisk;
+    private holdsAnythingAt;
     /**
      * What a listing shows of a directory scope, from where the mount keeps
      * what it reads: the store-backed kind's pass (listingFromStore), or, on a
@@ -973,11 +1184,28 @@ export declare class WorkspaceModule implements Module {
     private diskWalk;
     private handleGlob;
     private handleGrep;
+    /**
+     * Why a grep or a glob whose `path` (`given`, in the mount at
+     * `relativePath`) and filter or pattern can't overlap did nothing. grep's
+     * filter is matched from the mount's root, and in the mount its first
+     * segment names, either tool's is read mount-prefixed (`prefixed`), from
+     * that mount's root; either way no file at or beneath the path can pass
+     * it. Where the path isn't a file, it names the one that reaches beneath
+     * it, the one meant if it was written relative to the path, mount-prefixed
+     * as the tools write paths: the path's own `{`, `}`, `*` and `?` stand as
+     * `?`, which matches each of them, and since the search stays beneath the
+     * path, a `?` that would match a sibling's name too takes nothing in from
+     * outside it. One with an empty, `.` or `..` segment gets no suggestion,
+     * since no path holds such a segment. Segments are read as written, so one
+     * a brace group splits around isn't told apart.
+     */
+    private disjointRefusal;
     /**
      * The texts a 'chronicle' mount's grep searches beneath `start`, or in the
      * single file `relativePath` names, those `keep` lets through, each handed
-     * to `each` in path order: a pass over the scope, then each path's
-     * workspace copy, labelled with its state, and a conflict's disk side.
+     * to `search`, whose answers are recorded in path order: a pass over the
+     * scope, then each path's workspace copy, labelled with its state, and a
+     * conflict's disk side.
      * What it doesn't search is in `skipped`, and what it couldn't see in
      * `incomplete`, each mount-prefixed.
      */
@@ -1048,6 +1276,8 @@ export declare class WorkspaceModule implements Module {
      * owed and the unchecked.
      */
     private entriesByEvidence;
+    private evidenceOf;
+    private diskOf;
     private handleMaterialize;
     /**
      * Programmatically materialize a mount's files from Chronicle tree to filesystem.
@@ -1079,9 +1309,9 @@ export declare class WorkspaceModule implements Module {
      * on disk (a shell command's files, a deletion) is in the workspace when the
      * agent next looks. On a mount over its walkCap, that holds for the first
      * walkCap entries in the walk's order, which every batch's scan takes; files
-     * past them come in through syncs and the listings that reach them, while a
-     * read takes in only a file the workspace doesn't hold yet. A scan that
-     * outlasts the deadline stops holding the round: the miss is recorded on
+     * past them come in through syncs, the listings that reach them, and a read
+     * of the path, which takes disk's change in first as a listing does. A scan
+     * that outlasts the deadline stops holding the round: the miss is recorded on
      * the mount's status and pushed as a `workspace:agent-action-scan-incomplete`
      * event, and the scan continues, deciding on the branch selected when it
      * applies.

package/dist/src/modules/workspace/index.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../../src/modules/workspace/index.ts"],"names":[],"mappings":"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"}
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../../src/modules/workspace/index.ts"],"names":[],"mappings":"AAAA;;;;;GAKG;AAMH,OAAO,KAAK,EAAE,OAAO,EAAe,MAAM,sBAAsB,CAAC;AACjE,OAAO,KAAK,EAAE,MAAM,EAAE,aAAa,EAAE,YAAY,EAAE,aAAa,EAAE,MAAM,uBAAuB,CAAC;AAChG,OAAO,KAAK,EAAE,YAAY,EAAE,cAAc,EAAE,QAAQ,EAAE,UAAU,EAAE,MAAM,uBAAuB,CAAC;AAChG,OAAO,KAAK,EAEV,eAAe,EAoBhB,MAAM,YAAY,CAAC;AAqFpB,YAAY,EACV,eAAe,EACf,WAAW,EACX,UAAU,EACV,oBAAoB,EACpB,SAAS,EACT,cAAc,EACd,UAAU,EACV,SAAS,EACT,aAAa,EACb,WAAW,EACX,OAAO,EACP,SAAS,EACT,SAAS,EACT,WAAW,EACX,gBAAgB,EAChB,SAAS,GACV,MAAM,YAAY,CAAC;AAqBpB;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAkCG;AACH,MAAM,MAAM,sBAAsB,GAC9B,eAAe,GACf,WAAW,GACX,iBAAiB,GACjB,aAAa,GACb,mBAAmB,GACnB,WAAW,GACX,WAAW,GACX,SAAS,GACT,gBAAgB,GAChB,QAAQ,GACR,SAAS,CAAC;AAEd,kFAAkF;AAClF,MAAM,MAAM,kBAAkB,GAC1B,OAAO;AACT,4EAA4E;GAC1E,MAAM,GACN,UAAU,GACV,OAAO,GACP,eAAe,GACf,MAAM,GACN,OAAO,GACP,YAAY,GACZ,UAAU,GACV,MAAM,GACN,MAAM,CAAC;AA4BX;;;;GAIG;AACH,qBAAa,kBAAmB,SAAQ,KAAK;IAEzC,QAAQ,CAAC,IAAI,EAAE,sBAAsB;IAErC,QAAQ,CAAC,KAAK,EAAE,kBAAkB;IAClC,4EAA4E;IAC5E,QAAQ,CAAC,KAAK,CAAC,EAAE,MAAM;IALzB,YACW,IAAI,EAAE,sBAAsB,EACrC,OAAO,EAAE,MAAM,EACN,KAAK,EAAE,kBAAkB;IAClC,4EAA4E;IACnE,KAAK,CAAC,EAAE,MAAM,YAAA,EAIxB;CACF;AAcD,8CAA8C;AAC9C,MAAM,WAAW,uBAAuB;IACtC;;;;;OAKG;IACH,KAAK,EAAE,MAAM,CAAC;IACd;;;;;OAKG;IACH,IAAI,EAAE,MAAM,CAAC;IACb,sGAAsG;IACtG,SAAS,EAAE,OAAO,CAAC;IACnB,iGAAiG;IACjG,OAAO,EAAE,MAAM,CAAC;IAChB,wGAAwG;IACxG,QAAQ,EAAE,MAAM,CAAC;IACjB,oCAAoC;IACpC,KAAK,EAAE,MAAM,CAAC;CACf;AAED,MAAM,WAAW,uBAAuB;IACtC;;;;;OAKG;IACH,QAAQ,CAAC,EAAE,MAAM,CAAC;CACnB;AA6nBD,qBAAa,eAAgB,YAAW,MAAM;IAC5C,QAAQ,CAAC,IAAI,eAAe;IAE5B,OAAO,CAAC,GAAG,CAA8B;IACzC,OAAO,CAAC,KAAK,CAAwB;IACrC,yEAAyE;IACzE,OAAO,CAAC,OAAO,CAAS;IACxB,+EAA+E;IAC/E,OAAO,CAAC,UAAU,CAAK;IACvB,OAAO,CAAC,MAAM,CAAkB;IAChC,OAAO,CAAC,MAAM,CAAiC;IAC/C,OAAO,CAAC,QAAQ,CAAmC;IACnD,2EAA2E;IAC3E,OAAO,CAAC,SAAS,CAA8B;IAC/C,qCAAqC;IACrC,OAAO,CAAC,OAAO,CAAoC;IACnD,uEAAuE;IACvE,OAAO,CAAC,UAAU,CAAoC;IACtD,6EAA6E;IAC7E,OAAO,CAAC,kBAAkB,CAAS;IACnC,4EAA4E;IAC5E,6FAA6F;IAC7F,OAAO,CAAC,UAAU,CAAoC;IACtD;;;;;;;OAOG;IACH,OAAO,CAAC,WAAW,CAAyC;IAC5D,sGAAsG;IACtG,OAAO,CAAC,aAAa,CAA8B;IACnD,6EAA6E;IAC7E,OAAO,CAAC,WAAW,CAA6B;IAChD,6HAA6H;IAC7H,OAAO,CAAC,WAAW,CAA2D;IAC9E;;;;OAIG;IACH,OAAO,CAAC,aAAa,CAAgC;IACrD;;;qEAGiE;IACjE,OAAO,CAAC,UAAU,CAAqC;IACvD;;;;OAIG;IACH,OAAO,CAAC,SAAS,CAA4D;IAE7E;;;;;;;OAOG;IACH,OAAO,CAAC,WAAW,CAA8C;IAEjE,sGAAsG;IACtG,OAAO,CAAC,YAAY,CAA0D;IAE9E,mIAAmI;IACnI,OAAO,CAAC,WAAW,CAAuB;IAE1C,iIAAiI;IACjI,OAAO,CAAC,YAAY,CAA0B;IAE9C,+FAA+F;IAC/F,OAAO,CAAC,aAAa,CAAoE;IAEzF,YAAY,MAAM,EAAE,eAAe,EAuDlC;IAED;;;;;;;;OAQG;IACH,SAAS,CAAC,KAAK,EAAE,OAAO,GAAG,IAAI,CAgE9B;IAED;;;;;;;;;;;;;;OAcG;IACH,OAAO,CAAC,eAAe;IAsCvB;;;;;;;;OAQG;IACH,OAAO,CAAC,WAAW;IA8BnB;;;;;;OAMG;IACH,OAAO,CAAC,SAAS;IAQjB,OAAO,CAAC,gBAAgB;IAKxB;;;;;OAKG;IACH,OAAO,CAAC,MAAM;IAcd;;;;;OAKG;IACH,OAAO,CAAC,QAAQ;IAIhB;;;;;;;;;;OAUG;YACW,QAAQ;IAQtB,oEAAoE;YACtD,OAAO;IAuBrB;;;;;;;;;;;;;;OAcG;YACW,SAAS;IAevB,gFAAgF;YAClE,YAAY;IAkB1B,8DAA8D;YAChD,YAAY;IAqBpB,KAAK,CAAC,GAAG,EAAE,aAAa,GAAG,OAAO,CAAC,IAAI,CAAC,CA2B7C;IAED;;;;;;;OAOG;IACH,OAAO,CAAC,eAAe;IAgCvB;;;;;;;;;;;OAWG;IACH,OAAO,CAAC,oBAAoB;IAoB5B;;;;;;OAMG;IACH,OAAO,CAAC,2BAA2B;IAkBnC;;;;;OAKG;IACH,OAAO,CAAC,cAAc;IAoBtB;;;;;;OAMG;IACH,OAAO,CAAC,aAAa;IA4FrB;;;;;;;;;OASG;IACH,OAAO,CAAC,YAAY;YAmCN,WAAW;IAmBnB,IAAI,IAAI,OAAO,CAAC,IAAI,CAAC,CA+C1B;IAED;;;;;;;;;;;OAWG;IACH,OAAO,CAAC,eAAe;IAoBvB;;;;;;;;uCAQmC;IACnC,SAAS,IAAI,KAAK,CAAC;QAAE,IAAI,EAAE,MAAM,CAAC;QAAC,IAAI,EAAE,YAAY,GAAG,WAAW,CAAC;QAAC,OAAO,CAAC,EAAE,SAAS,MAAM,EAAE,CAAC;QAAC,OAAO,CAAC,EAAE,QAAQ,CAAA;KAAE,CAAC,CAQtH;IAMD;;;;OAIG;IACH,OAAO,CAAC,aAAa;IAIrB,QAAQ,IAAI,cAAc,EAAE,CAiR3B;IAMD,OAAO,CAAC,kBAAkB,CAA8D;IAExF,kFAAkF;IAClF,OAAO,CAAC,gBAAgB;IAYxB,OAAO,CAAC,qBAAqB;IAU7B,sFAAsF;IACtF,yBAAyB,CAAC,IAAI,EAAE,MAAM,EAAE,IAAI,EAAE,MAAM,MAAM,EAAE,SAAS,EAAE,MAAM,GAAG,IAAI,CAMnF;IAEK,cAAc,CAAC,IAAI,EAAE,QAAQ,GAAG,OAAO,CAAC,UAAU,CAAC,CAGxD;IAED;;;;OAIG;IACH,OAAO,CAAC,aAAa,CAA+B;IAEpD,sEAAsE;IACtE,OAAO,CAAC,QAAQ;IAOhB,OAAO,CAAC,WAAW;YAKL,cAAc;IA6C5B,OAAO,CAAC,aAAa;IA4Bf,SAAS,CAAC,KAAK,EAAE,YAAY,EAAE,MAAM,EAAE,YAAY,GAAG,OAAO,CAAC,aAAa,CAAC,CAgEjF;IAMD;;;;;;;;;;;;;;;;;;;;;OAqBG;IACH,mBAAmB,CAAC,iBAAiB,EAAE,MAAM,GAAG,MAAM,GAAG,IAAI,CAgB5D;IAED;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;OAgCG;IACG,WAAW,CACf,iBAAiB,EAAE,MAAM,EACzB,IAAI,EAAE,MAAM,EACZ,QAAQ,EAAE,MAAM,EAChB,OAAO,GAAE;QAAE,MAAM,CAAC,EAAE,MAAM,CAAC;QAAC,SAAS,CAAC,EAAE,MAAM,CAAA;KAAO,GACpD,OAAO,CAAC,UAAU,CAAC,CAGrB;YAEa,mBAAmB;IAmFjC;;;;;;;;;;OAUG;IACG,UAAU,CACd,iBAAiB,EAAE,MAAM,GACxB,OAAO,CAAC;QAAE,IAAI,EAAE,MAAM,CAAA;KAAE,GAAG;QAAE,KAAK,EAAE,MAAM,CAAA;KAAE,CAAC,CAG/C;YAEa,kBAAkB;IAyBhC;;;;;;;;;;;;;;;;;;;;;;OAsBG;IACG,kBAAkB,CACtB,iBAAiB,EAAE,MAAM,EACzB,IAAI,GAAE;QAAE,QAAQ,CAAC,EAAE,MAAM,CAAA;KAAO,GAC/B,OAAO,CAAC;QAAE,IAAI,EAAE,MAAM,CAAC;QAAC,YAAY,EAAE,MAAM,CAAA;KAAE,GAAG;QAAE,KAAK,EAAE,MAAM,CAAA;KAAE,CAAC,CAUrE;IAED,gFAAgF;YAClE,aAAa;IAwC3B,2EAA2E;IAC3E,OAAO,CAAC,QAAQ;IAIhB;;;;;;;;;;;;;;;;;;OAkBG;YACW,WAAW;IAmCzB;;;OAGG;IACH,OAAO,CAAC,QAAQ;IAKhB;;;;OAIG;YACW,SAAS;IAIvB;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;OA2CG;YACW,YAAY;IAqD1B;;;;;;OAMG;IACH,OAAO,CAAC,QAAQ;IAgBhB;;;;OAIG;IACH,OAAO,CAAC,cAAc;IAQtB;;;;;;;;;;OAUG;YACW,aAAa;IAgB3B;;;;;;;;;;;;;;;;;OAiBG;YACW,cAAc;IAmC5B;;;;;;;OAOG;IACH,OAAO,CAAC,aAAa;IASrB;;;;;;;;;;;;OAYG;YACW,SAAS;IAOvB;;;;;;;;;;;;;;;;;;;;;OAqBG;YACW,gBAAgB;IAgB9B;;;;;;;;;;;;;;;;;;;;;;;;;;;;OA4BG;YACW,SAAS;IA2BvB;;;;;OAKG;IACH,OAAO,CAAC,WAAW;IAInB;;;;;;;;OAQG;IACH,OAAO,CAAC,SAAS;IAkBjB;;;;;;;;;;;;;;OAcG;IACH,OAAO,CAAC,gBAAgB;IAyCxB,OAAO,CAAC,aAAa;IAIrB,OAAO,CAAC,SAAS;IAKjB,OAAO,CAAC,gBAAgB;IAOxB,OAAO,CAAC,WAAW;IAcnB;;;;;;;OAOG;IACH,OAAO,CAAC,OAAO;IAIf,OAAO,CAAC,QAAQ;IAKhB,OAAO,CAAC,kBAAkB;YAeZ,iBAAiB;IAa/B;;;;;;;;;;;;;;;;;;OAkBG;YACW,QAAQ;IA4BtB;;;;;;;;OAQG;YACW,SAAS;IAMvB;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;OAsCG;YACW,iBAAiB;IAiB/B,+EAA+E;YACjE,eAAe;IA8J7B;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;OAoCG;IACG,gBAAgB,CACpB,iBAAiB,EAAE,MAAM,EACzB,OAAO,GAAE,uBAA4B,GACpC,OAAO,CAAC,uBAAuB,CAAC,CAyClC;YAEa,uBAAuB;IAwBrC;;;OAGG;IACH,OAAO,CAAC,cAAc;IAItB;;;;;;;;;;;;;;;;;;;;;;;OAuBG;YACW,gBAAgB;IAU9B;;;;;;;;;;;;;;;;;OAiBG;YACW,iBAAiB;IA4L/B;;;;;;;;;;OAUG;YACW,oBAAoB;IAKlC;;;;;;;;;;;;;;OAcG;YACW,YAAY;IAO1B;;;;OAIG;IACH,OAAO,CAAC,aAAa;IAIrB,yEAAyE;IACzE,OAAO,CAAC,cAAc;IAuBtB;;;;;;OAMG;YACW,OAAO;IA2CrB;;;;;;;OAOG;YACW,WAAW;YA4BX,UAAU;IA6DxB,OAAO,CAAC,QAAQ;YAOF,SAAS;YAWT,WAAW;IAqCzB;;;;;OAKG;YACW,UAAU;YA6BV,eAAe;YA4Cf,WAAW;YAiDX,UAAU;YASV,cAAc;IAgB5B;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;OA8BG;YACW,UAAU;IA4QxB;;;;;;;;OAQG;YACW,YAAY;IA2B1B;;;;OAIG;IACH,OAAO,CAAC,oBAAoB;IAM5B;;;;;;;;;;;;;OAaG;IACH,OAAO,CAAC,wBAAwB;IAwDhC;;;;;;;;OAQG;YACW,WAAW;IAmCzB;;;;;;;;;;;;;;OAcG;YACW,gBAAgB;IA+B9B;;;;;OAKG;YACW,kBAAkB;IAwJhC;;;;;;OAMG;IACH,OAAO,CAAC,kBAAkB;IAW1B;;;;;;;;OAQG;YACW,cAAc;IAkC5B;;;;;;OAMG;YACW,YAAY;IAmD1B;;;;;;;;;;;;;;;;OAgBG;IACH,OAAO,CAAC,iBAAiB;IAmBzB,0EAA0E;IAC1E,OAAO,CAAC,WAAW;IASnB;;;;;;;;;OASG;IACH,OAAO,CAAC,kBAAkB;IAW1B;;;;;;;;OAQG;IACH,OAAO,CAAC,aAAa;IAgBrB;;;;;;;;OAQG;IACH,cAAc,CAAC,SAAS,EAAE,MAAM,GAAG;QAAE,IAAI,EAAE,MAAM,CAAC;QAAC,MAAM,EAAE,MAAM,EAAE,CAAA;KAAE,GAAG,IAAI,CAc3E;IAED,6FAA6F;IAC7F,oBAAoB,CAAC,SAAS,EAAE,MAAM,EAAE,MAAM,EAAE,SAAS,MAAM,EAAE,EAAE,SAAS,EAAE,MAAM,GAAG,IAAI,CAK1F;IAED;;;;OAIG;IACH,UAAU,CAAC,MAAM,EAAE,CAAC,SAAS,EAAE,MAAM,EAAE,SAAS,EAAE,MAAM,KAAK,OAAO,GAAG,IAAI,CAE1E;YAEa,YAAY;YA6CZ,QAAQ;YAkER,cAAc;YAWd,YAAY;IAK1B,OAAO,CAAC,eAAe;IAOvB;;;;OAIG;IACH,OAAO,CAAC,SAAS;IAIjB;;;;OAIG;IACH,OAAO,CAAC,gBAAgB;IA0BxB;;;;;;OAMG;YACW,eAAe;IAU7B;;;;;;;;;OASG;YACW,QAAQ;YAqBR,UAAU;YAmEV,UAAU;IA6IxB;;;;;;;;;;;;;;OAcG;YACW,eAAe;IAY7B;;;;;;;;OAQG;YACW,cAAc;IAoI5B;;;;;;;;;OASG;YACW,aAAa;YA+Bb,YAAY;IAkD1B;;;;;;;;;;;;;;;;;OAiBG;IACH,OAAO,CAAC,WAAW;IAanB;;;;;;;;;;OAUG;IACH,OAAO,CAAC,oBAAoB;IA2B5B;;;;;;;;OAQG;IACH,OAAO,CAAC,QAAQ;IAKhB;;;;;;;;;;;OAWG;IACH,OAAO,CAAC,iBAAiB;IAkBzB,OAAO,CAAC,UAAU;IAUlB,OAAO,CAAC,MAAM;YAQA,iBAAiB;IAuK/B;;;;OAIG;IACG,gBAAgB,CAAC,SAAS,EAAE,MAAM,GAAG,OAAO,CAAC,MAAM,EAAE,CAAC,CA2B3D;YAEa,UAAU;IA4KxB;;;;OAIG;YACW,kBAAkB;IAiBhC;;;;;;;;;OASG;YACW,eAAe;IAQ7B;;;;;;;;;;;;OAYG;IACG,mBAAmB,CAAC,UAAU,CAAC,EAAE,MAAM,GAAG,OAAO,CAAC,IAAI,CAAC,CA6B5D;IAED;;;;;OAKG;IACH,OAAO,CAAC,wBAAwB;IAOhC,qFAAqF;IACrF,OAAO,CAAC,qBAAqB;IAK7B;;;;;;;;OAQG;IACH,OAAO,CAAC,eAAe;IAsCvB,8EAA8E;IAC9E,OAAO,CAAC,yBAAyB;IAajC;;;;;;OAMG;IACH,OAAO,CAAC,YAAY;CAgCrB;AA2BD;;;;;;;GAOG;AACH,wBAAsB,OAAO,CAAC,CAAC,EAAE,CAAC,EAAE,KAAK,EAAE,SAAS,CAAC,EAAE,EAAE,KAAK,EAAE,MAAM,EAAE,IAAI,EAAE,CAAC,IAAI,EAAE,CAAC,KAAK,OAAO,CAAC,CAAC,CAAC,EAAE,IAAI,EAAE,CAAC,MAAM,EAAE,CAAC,EAAE,IAAI,EAAE,CAAC,KAAK,IAAI,GAAG,OAAO,CAAC,IAAI,CAAC,CAcxJ"}