@animalabs/agent-framework 0.22.2 → 0.23.0

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

@@ -12,15 +12,29 @@ export type { WorkspaceConfig, MountConfig, MountState, WorkspaceModuleState, Re
 /**
  * Why a workspace-owned filesystem read was refused. Distinguishes the cases a
  * peer needs to react to differently: a path that never resolved inside the
- * mount (`unknown_mount`, `traversal`), a mount whose root is gone
- * (`mount_unavailable`), an ordinary missing file (`not_found`), a directory
- * (`directory`), a symlink refused by the mount's `followSymlinks` policy
- * (`symlink`), a symlink whose canonical target lands outside the canonical
- * mount root (`escape`), and a file swapped underneath the read (`changed`).
+ * mount (`unknown_mount`, `traversal`), a mount whose root is gone, isn't a
+ * directory, or isn't the directory the workspace was using
+ * (`mount_unavailable`: with errno ENOENT or ENOTDIR when no directory is
+ * there at all, with none for another directory), an ordinary missing file
+ * or one that isn't a regular file, such as a FIFO (`not_found`), a directory
+ * (`directory`), a file that is itself a symlink, refused by the mount's
+ * `followSymlinks` policy (`symlink`), a symlink among the path's directories
+ * on a mount that doesn't follow symlinks, leading to a directory or a file
+ * inside the mount, or nowhere (`parent_symlink`), whose message names the
+ * link and, where it leads somewhere, its target, a symlink whose canonical
+ * target lands outside the canonical mount root, or one among the path's
+ * directories leading out of it (`escape`), a file swapped underneath the read
+ * (`changed`), and a path in another mount's directory nested in the one
+ * named, or reached through a symlink among the path's directories leading
+ * there (`other_mount`), whose message names the mount that holds it and the
+ * path to use there. A `mount_unavailable` for a root whose realpath or stat
+ * fails otherwise carries that errno, such as EACCES.
  */
-export type WorkspaceReadErrorCode = 'unknown_mount' | 'traversal' | 'mount_unavailable' | 'not_found' | 'directory' | 'symlink' | 'escape' | 'changed';
+export type WorkspaceReadErrorCode = 'unknown_mount' | 'traversal' | 'other_mount' | 'mount_unavailable' | 'not_found' | 'directory' | 'symlink' | 'parent_symlink' | 'escape' | 'changed';
 /** Where in the open sequence a `WorkspaceReadError` originated (diagnostics). */
-export type WorkspaceReadStage = 'parse' | 'lstat' | 'realpath_root' | 'open' | 'fstat' | 'post_lstat' | 'realpath' | 'stat' | 'read';
+export type WorkspaceReadStage = 'parse'
+/** The mount root's check: a directory, the one the workspace was using. */
+ | 'root' | 'readlink' | 'lstat' | 'realpath_root' | 'open' | 'fstat' | 'post_lstat' | 'realpath' | 'stat' | 'read';
 /**
  * Thrown by `WorkspaceModule.readFileFromDisk()`. Messages carry the
  * mount-prefixed path only — never absolute filesystem paths — so they can be
@@ -37,13 +51,23 @@ export declare class WorkspaceReadError extends Error {
 }
 /** Successful `readFileFromDisk()` result. */
 export interface WorkspaceDiskReadResult {
-    /** File bytes — the whole file, or its first `maxBytes` when `truncated`. */
+    /**
+     * File bytes: the whole file, or its first `maxBytes` when `truncated`.
+     * Without `maxBytes` the file is read with `readFile`, with no limit. In
+     * Node, that reads up to the size its own fstat finds, or to the file's end
+     * if that size is 0.
+     */
     bytes: Buffer;
-    /** Full on-disk size in bytes, regardless of truncation. */
+    /**
+     * The file's size, agreeing with `bytes` and `truncated`: `bytes.length`,
+     * unless `truncated`. Then it's the file's size by an fstat after the read,
+     * or `maxBytes + 1` if that's less, since the read found at least that many
+     * bytes.
+     */
     size: number;
-    /** True when `maxBytes` was set and the file was larger; `bytes` is a prefix. */
+    /** True when `maxBytes` was set and the read found the file going on past it; `bytes` is a prefix. */
     truncated: boolean;
-    /** mtime of the file actually read (for change-detection caches). */
+    /** mtime of the file actually read, from its fstat at the open (for change-detection caches). */
     mtimeMs: number;
     /** Canonical (realpath) location of the file read — inside the canonical mount root by construction. */
     realPath: string;
@@ -51,7 +75,12 @@ export interface WorkspaceDiskReadResult {
     mount: string;
 }
 export interface ReadFileFromDiskOptions {
-    /** Read at most this many bytes (a bounded prefix read — the rest of the file is never loaded). */
+    /**
+     * Keep at most this many bytes (a bounded prefix read): the read loads them
+     * and one byte past them, which isn't kept and tells whether the file goes
+     * on, and never the rest of the file. It bounds the read itself, so it
+     * holds for a file that grows while it's read.
+     */
     maxBytes?: number;
 }
 export declare class WorkspaceModule implements Module {
@@ -60,6 +89,8 @@ export declare class WorkspaceModule implements Module {
     private store;
     /** Set once stop has drained and saved, cleared by start (running()). */
     private stopped;
+    /** Stops begun, so a start that read disk meanwhile can tell that one came. */
+    private stopsBegun;
     private config;
     private mounts;
     private watchers;
@@ -74,6 +105,26 @@ export declare class WorkspaceModule implements Module {
     /** Whether a mount root's filesystem maintains ctime, by canonical root. */
     /** Per canonical root: the device of its filesystem when that maintains ctime, else null. */
     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).
+     */
+    private otherMounts;
+    /** Whether each mount's root folds case (foldsCase), where disk has it, as the last start read it. */
+    private rootFoldsCase;
+    /**
+     * Whether a file's mode is observed, taken in and applied (MountRuntime's
+     * `modesObserved`): not on Windows, which reports no POSIX modes. A test
+     * sets it false to run that case anywhere.
+     */
+    private modesObserved;
     /** Persisted state decoded in start(), held until mounts exist to apply it
      *  to — in the Host ordering start() runs before initStore() creates the
      *  mounts, so restoration must be second-callback-safe like watcher
@@ -99,8 +150,28 @@ export declare class WorkspaceModule implements Module {
      */
     private withMount;
     private agreementOrThrow;
+    /**
+     * A mount as observation reads it, with the root identity the workspace
+     * recorded for it, if any: what a pass reads beneath (runtime), with
+     * rootIdentity's, and what a disk read checks its root against (readRoot),
+     * with rootIdentityForRead's.
+     */
+    private viewOf;
     /** The view reconciliation needs of a mount, refreshed per pass. */
     private runtime;
+    /**
+     * Where a search's walk starts: `base`, its path as parsePath spells it,
+     * then each segment of `beneath` while disk lists it, in the directory
+     * reached so far, as a directory with exactly that spelling. The walk names
+     * what it finds from its start's spelling, and a case-insensitive disk
+     * would let it go on under a spelling disk doesn't list, taking files in
+     * under that spelling beside their own. So the start stops before a segment
+     * spelled any other way, not there, or not a directory, and before a link,
+     * which a walk of the whole mount doesn't go through either. It lists only
+     * directories it has checked lie inside the mount, and none the mount
+     * passes over by design, which the walk then answers for.
+     */
+    private walkStart;
     /** One disk→store pass; the caller holds the mount's turn. Emits its events. */
     private passUnlocked;
     /** One store→disk push; the caller holds the mount's turn. */
@@ -165,6 +236,15 @@ export declare class WorkspaceModule implements Module {
     /** Generated files bypass stored blobs so every read reflects current definitions. */
     registerGeneratedTextFile(path: string, read: () => string, agentName: string): void;
     handleToolCall(call: ToolCall): Promise<ToolResult>;
+    /**
+     * Tool calls, and the public reads and writes that take a mount's turn,
+     * under way. Each can await disk (parsePath) before it takes its turn, so
+     * stop waits for these as well as for the turns.
+     */
+    private callsUnderWay;
+    /** `work`, recorded as under way until it settles (callsUnderWay). */
+    private underWay;
+    private runToolCall;
     onProcess(event: ProcessEvent, _state: ProcessState): Promise<EventResponse>;
     /**
      * Resolve a mount-prefixed path (e.g. "tickets/2026-04-22-foo.md") to its
@@ -206,6 +286,7 @@ export declare class WorkspaceModule implements Module {
     writeBinary(mountPrefixedPath: string, data: Buffer, mimeType: string, options?: {
         branch?: string;
     }): Promise<ToolResult>;
+    private writeBinaryUnderWay;
     /**
      * Read a file's raw bytes from a mount (through the Chronicle tree, synced
      * first like the `read` tool). Public API for the framework's synthesized
@@ -216,6 +297,7 @@ export declare class WorkspaceModule implements Module {
     } | {
         error: string;
     }>;
+    private readBinaryUnderWay;
     /**
      * Read a file's raw bytes straight from the mount's filesystem, bypassing
      * the Chronicle tree.
@@ -228,8 +310,16 @@ export declare class WorkspaceModule implements Module {
      * permanent cost to send something once is the wrong trade.
      *
      * Same mount boundary and traversal guard as every other path here: only
-     * declared mounts, nothing above their root. Deliberately does NOT sync,
-     * register, or hash anything — it reads and returns.
+     * declared mounts, nothing above their root, and the file reached as
+     * readFileFromDisk reaches it (openContainedFile), so the mount's
+     * `followSymlinks` holds for the file and the directories on its way, and
+     * what it reaches stays canonically inside the mount. Deliberately does NOT
+     * sync, register, or hash anything — it reads and returns.
+     *
+     * `maxBytes` refuses a larger file as "File too large", having loaded at
+     * most `maxBytes` bytes and one more: the reads decide where the file ends,
+     * not the size fstat gave at the open, so the bound holds for a file that
+     * grows while it's read.
      */
     readBinaryFromDisk(mountPrefixedPath: string, opts?: {
         maxBytes?: number;
@@ -239,10 +329,98 @@ export declare class WorkspaceModule implements Module {
     } | {
         error: string;
     }>;
+    /** The directories of the mounts nested inside a mount, mount-relative, in each spelling. */
+    private othersOf;
     /**
-     * Parse a mount-prefixed path into (mountName, relativePath).
+     * Which mounts are nested in which, read afresh at each start. A mount is
+     * nested in another where its configured path lies beneath the other's
+     * root, as configured or as it lies on disk, whatever links the path
+     * reaches that root through, or where its real root lies beneath the
+     * other's. Each root, and each directory above a configured path, is
+     * placed by realBeneath, awaited, so a root on a share that stops
+     * answering holds this start and not the process, and a root moved while
+     * the module was stopped is placed where it is now. A mount whose real
+     * root is the other's own, or holds it, is nested by its configured path
+     * 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
+     * start reads there.
+     */
+    private readNesting;
+    /** The mounts nested in `mountName`, by directory, name and real root where it has one (MountView's `nested`), in each spelling known. */
+    private nestedOf;
+    /**
+     * The innermost mount nested in `mountName` whose directory holds a path
+     * 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.
+     */
+    private holderOf;
+    /**
+     * Why a mount leaves a path in a nested mount's directory, naming that
+     * mount and the path to use: for a sync or a push, which of them leaves
+     * it; for a listing, whose the path is.
+     */
+    private otherMountNote;
+    /**
+     * parsePath for the file operations (read, write, edit, delete, and the
+     * module's binary and disk reads and writes). A path in another mount's
+     * directory nested in this one is that mount's: this mount's passes don't
+     * observe it and its pushes don't write it, so its file operations refuse
+     * it, naming the innermost mount that holds it and the path to use there.
+     */
+    private parseFilePath;
+    /**
+     * The refusal for a path of `mount` that reaches a nested mount's directory
+     * through a symlink on its way (nestedAtReal), or null where it doesn't. On
+     * a mount that doesn't follow the link, the refusal is the link's own
+     * (linkWords), as the readers and pushes give it. A mount with nothing
+     * nested has nothing to find, so it pays nothing.
+     */
+    private leadsIntoNested;
+    /** A parsed path, refused if it lies in a nested mount's directory (parseFilePath). */
+    private refuseNested;
+    /**
+     * Parse a mount-prefixed path into its mount and mount-relative path, as
+     * disk spells it (diskSpelling), with `path` the mount-prefixed path so
+     * spelled. On a disk that folds names, a path spelled otherwise reaches
+     * disk's file, so every tool takes it by disk's name: one name per file,
+     * and the names its answers give are disk's, except that a path that names
+     * a workspace entry exactly, or does once its directories take disk's
+     * spelling, keeps the entry's spelling. A path the workspace records an
+     * intent at, such as a deletion disk hasn't been given yet, counts as an
+     * entry here, so the calls that settle it reach it. The workspace's
+     * entries (entriesOf) stand in for disk where it has nothing yet, so a
+     * draft has one name too. Neither applies to a path that disk's spelling
+     * puts in a nested mount's directory.
+     * A handler that must read something at the moment it's asked, as
+     * handleSync reads the branch a path sync adopts on, reads it before
+     * calling this, since this awaits disk. The entries are read when the
+     * step needs them, some after those awaits, from the branch current then.
      */
     private parsePath;
+    /**
+     * A mount's entries on the current branch, and the paths it records an
+     * intent at there, as diskSpelling reads them when it does, whether its
+     * root folds case as the last start read it (false before the first), and
+     * which nested mount's directory holds a path, by holderOf, as the
+     * nested-mount checks read it. diskSpelling keeps disk's spelling of a
+     * path that lies in a nested mount's directory as disk spells it, so the
+     * checks refuse at least what they would refuse without the entries.
+     */
+    private entriesOf;
+    /**
+     * Parse a mount-prefixed path into (mountName, relativePath), as spelled.
+     */
+    private parsePathAsGiven;
     /**
      * Whether the module takes work: stop hasn't finished. Work admitted while
      * stop drains still runs; once stop has saved the pins and watermarks,
@@ -255,26 +433,72 @@ export declare class WorkspaceModule implements Module {
     private getStore;
     private validateImageBytes;
     private tryReadImageFromTree;
+    /**
+     * The mount root a disk read reads beneath: resolved, then checked as
+     * observation checks it (checkRoot), so the read and the evidence agree on
+     * which directory the mount is. Once the workspace has recorded the root's
+     * identity, a root that resolves to any other directory is refused, in
+     * ROOT_REPLACED's words; with none recorded yet, it need only be a
+     * directory there. A refusal where no directory is at the root's path
+     * carries the errno that gives (rootAbsence: ENOENT when nothing is there
+     * and ENOTDIR when something else is, which a caller can read as no file,
+     * or the errno the root's stat failed with otherwise, such as EACCES). A
+     * root whose realpath fails carries realpath's errno, and one that is
+     * 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.
+     */
+    private readRoot;
+    /**
+     * The refusal for a root that stopped being the directory a read checked,
+     * with the code and errno readRoot gives what is at its path now (its stage
+     * and words are this check's): gone, or not a directory, with ENOENT or
+     * ENOTDIR, so a caller reads a root gone mid-read as one gone before it; or
+     * another directory, with none.
+     */
+    private rootMoved;
     /**
      * Open a mount-relative file for reading with the mount boundary enforced on
      * the *filesystem*, not just the path string:
      *
-     * 1. `lstat` the lexical path — refuse directories; refuse a final-component
-     *    symlink when the mount does not `followSymlinks`.
-     * 2. Open with `O_NOFOLLOW` where the platform has it (POSIX) so the refusal
+     * 0. Check the root (readRoot) before anything beneath it: under a root
+     *    that isn't the mount's directory, no path says anything about the
+     *    mount's files, an absence included.
+     * 1. On a mount that does not `followSymlinks`, refuse a path with a symlink
+     *    among the directories on its way beneath the mount's root, wherever it
+     *    leads (linkOnTheWay), before anything resolves it: as `escape` for a
+     *    link leading outside the mount, as `other_mount` for one into a nested
+     *    mount's directory, and as `parent_symlink` for any other.
+     * 2. `lstat` the lexical path — refuse directories; refuse a final-component
+     *    symlink when the mount does not `followSymlinks`; refuse anything else
+     *    that isn't a regular file, such as a FIFO, without opening it.
+     * 3. Open with `O_NOFOLLOW` where the platform has it (POSIX) so the refusal
      *    holds against a symlink swapped in between lstat and open; where it
-     *    doesn't (Windows), re-`lstat` after opening instead.
-     * 3. `realpath` both the mount root and the opened path and require canonical
-     *    containment — this is what catches an *intermediate* symlinked
-     *    directory escaping the mount, and a followed symlink whose target lands
-     *    outside, on every platform (junctions included).
-     * 4. Confirm the descriptor and the canonical path are the same inode.
+     *    doesn't (Windows), re-`lstat` after opening instead. `O_NONBLOCK`, so a
+     *    FIFO swapped in meanwhile doesn't wait for a writer.
+     * 4. `realpath` the opened path. On a mount that does not `followSymlinks`,
+     *    refuse it again for a symlinked directory on its way, which catches one
+     *    swapped in since step 1 (linkRefusal). Then require canonical
+     *    containment in the root step 0 resolved — this is what catches an
+     *    *intermediate* symlinked directory escaping the mount, and a followed
+     *    symlink whose target lands outside, on every platform (junctions
+     *    included).
+     * 5. Confirm the descriptor and the canonical path are the same inode, and
+     *    the root still the directory step 0 checked.
      *
-     * `inspect` runs right after the descriptor is stat'd and before the
-     * containment work, so callers can impose size policy in the same order the
-     * image reader always has. The returned handle is the caller's to close.
+     * Whatever steps 1 to 5 refuse, a missing file included, is said of the
+     * mount's files only while the root is still that directory. If it isn't,
+     * the read is refused with the code and errno step 0 gives what is at the
+     * root's path then (rootMoved), as step 5's own check of the root does.
+     *
+     * `inspect` runs last, after the boundary's checks, so a caller's own check
+     * of the file, such as a size limit, never answers for a file the boundary
+     * refuses. The returned handle is the caller's to close.
      */
     private openContainedFile;
+    /** Steps 1 to 5 of openContainedFile, beneath the root that step 0 checked. */
+    private openBeneathRoot;
     /**
      * Read a workspace file from disk with the mount boundary enforced on the
      * filesystem (see {@link openContainedFile}). Public API for peer modules
@@ -287,29 +511,55 @@ export declare class WorkspaceModule implements Module {
      * - With symlinks allowed, the canonical target must stay beneath the
      *   canonical mount root; a sibling-prefix root (`/mount-other`) does not count.
      * - `maxBytes` performs a bounded prefix read: at most `maxBytes` bytes are
-     *   ever loaded, and `truncated` reports that the file was larger.
+     *   kept, and one byte past them is read to tell whether the file goes on
+     *   (`truncated`). The reads decide where the file ends, not the size fstat
+     *   gave at the open, so the bound holds for a file that grows while it's
+     *   read.
+     * - Once the workspace has recorded the mount root's identity, with the
+     *   first evidence it gathers there, a root that is another directory is
+     *   an unavailable mount: a replaced directory, a link swapped in for it,
+     *   or an unmounted drive's mountpoint. In any mount, recorded or not, a
+     *   root that stops being the directory the read checked until the file
+     *   has been opened and checked is unavailable too: with ENOENT or
+     *   ENOTDIR where no directory is there, as before the read, and with no
+     *   errno for another directory. The file's bytes are then read through
+     *   the descriptor that was checked.
      *
      * Throws {@link WorkspaceReadError} with a `code` distinguishing unknown
-     * mount, lexical traversal, unavailable mount, missing file, directory,
-     * policy-denied symlink, outside-mount target, and file-changed-during-read.
+     * mount, lexical traversal, 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.
      */
     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
+     * push commitToolChange makes, and what an edit's answer says of it.
+     */
+    private pushesOnCommit;
     /**
      * Commit a tool's write or delete to the workspace tree, with the branch
-     * intent it implies (store origin for a path disk never agreed with; a
-     * tombstone for a deletion), and push it to disk when the mount opts in via
+     * intent it implies: store origin for a path disk never agreed with; for a
+     * deletion, a tombstone, unless the evidence holds no agreed disk copy (P
+     * absent, or no P and store origin), when it clears the path's intent and
+     * pushes nothing. It pushes the change to disk when the mount opts in via
      * `autoMaterialize` — required for cross-agent pipelines, since another
      * agent's watcher on the same directory only sees real filesystem events.
      * The push follows materialize's rule: a disk copy that changed since it
      * last agreed is not overwritten or unlinked, and the refusal says why.
      *
-     * Returns the reason when the change reached the workspace but not disk, so
-     * callers surface it in the tool result: the autoMaterialize contract is
-     * that disk is the source of truth for downstream agents. The caller holds
-     * the mount's turn and has settled the path first (settleBeforeMutation).
+     * Answers, so callers surface them in the tool result, the reason when the
+     * change reached the workspace but not disk (`refused`): the
+     * autoMaterialize contract is that disk is the source of truth for
+     * 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).
      */
     private commitToolChange;
     /**
@@ -318,15 +568,20 @@ export declare class WorkspaceModule implements Module {
      * disk now holds (an edit sees a disk change the settled adoption took in).
      * The pass may not settle it (a branch that keeps changing, an unreadable
      * disk copy); the precondition that matters is enforced again,
-     * synchronously, where the change commits (commitToolChange). The caller
-     * holds the mount's turn.
+     * synchronously, where the change commits (commitToolChange). The pass
+     * names the path, as a file tool names the one it acts on, so a path the
+     * mount passes over by design is observed there, as a sync naming it would
+     * observe it (#276). The caller holds the mount's turn.
      */
     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 caller holds
-     * the mount's turn.
+     * 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. The caller holds the mount's turn.
      */
     private ensureSynced;
     /** Why the workspace holds no entry at a path, when disk explains it. */
@@ -352,10 +607,21 @@ export declare class WorkspaceModule implements Module {
      * does). `inPlace` says whether any tree entry was left out for that reason.
      */
     private materializeSelection;
+    /**
+     * Whether a path of the mount is its own to push and to count as owed:
+     * not in another mount's directory nested in it. Copies the mount's tree
+     * holds there (stored before the nesting) stay in its history and its
+     * listings (and in status's fileCount, which counts the tree), passed over
+     * by its syncs, and left out of what it pushes and of status's pending
+     * changes, conflicts and workspace deletions.
+     */
+    private ownPaths;
     /**
      * The workspace entries by what the evidence says of disk. `owed`: P
-     * differs from the entry (a draft, or a push still pending), or there is no
-     * P and the entry came from the workspace (a draft disk never had).
+     * differs from the entry (a draft, or a push still pending), the entry
+     * records a mode other than the one P agreed (a mode owed to disk), or
+     * there is no P and the entry came from the workspace (a draft disk never
+     * had).
      * `unchecked`: no P and no workspace origin, an entry from before the
      * evidence; a push agrees it, writes it where disk lacks it, or refuses it
      * as a conflict. `agreed`: how many have P = S, so disk holds them. Status
@@ -421,9 +687,11 @@ export declare class WorkspaceModule implements Module {
     /** The scan deadline, kept below the framework's hook bound (warned once). */
     private agentActionScanDeadlineMs;
     /**
-     * Push one ProcessEvent per op for a pass's tree changes and new conflicts.
-     * A conflict rides the event for the disk change behind it (modified, or
-     * deleted for a disk deletion of a file with newer workspace changes).
+     * Push one ProcessEvent per op for a pass's tree changes and new conflicts,
+     * apart from an op that changes only a file's mode, which brings nothing
+     * new to read and makes none. A conflict rides the event for the disk
+     * change behind it (modified, or deleted for a disk deletion of a file with
+     * newer workspace changes).
      */
     private emitFsEvents;
 }

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":"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"}