@animalabs/agent-framework 0.29.0 → 0.31.0

package/dist/src/modules/workspace/index.js

@@ -5,15 +5,16 @@
  * auto-sync between real filesystem and Chronicle, and manual materialization.
  */
 import { NOTICE_TAG } from '../../notice-tags.js';
+import { nameToTypeBack } from '../../supplied-text.js';
 import { constants as fsConstants } from 'node:fs';
 import { open, readdir, readlink, stat, lstat, realpath } from 'node:fs/promises';
 import { basename, dirname, isAbsolute, join, parse, resolve, relative, sep } from 'node:path';
 import { WORKSPACE_FS_EVENT_TYPES, opToEventType } from './types.js';
 import { MountWatcher } from './watcher.js';
 import { hashContent, storedBytes, DEFAULT_MAX_FILE_SIZE } from './sync.js';
-import { DiskAgreement, EvidenceUnavailable, callGate, sameRootIdentity } from './disk-agreement.js';
+import { DiskAgreement, EvidenceUnavailable, callGate, rootUnreadable, sameRootIdentity } from './disk-agreement.js';
 import { BranchIntents } from './branch-intent.js';
-import { CHANGED, DIRECTORY, IGNORED, NONBLOCK, OTHER_MOUNT, OUTSIDE_INCLUDE, ROOT_REPLACED, ROOT_UNAVAILABLE, beneathRoot, checkDir, checkRoot, confirmAbsent, coversLanding, directoryAt, diskSpelling, filesystemTrustsCtime, foldsCase, inOtherMount, insideMount, leadsInto, linkOnTheWay, linkRefusal, linkWords, locateRoot, looksBinary, namesHolder, nestedAtReal, nestedGuess, nestedHolder, nestedStep, observePath, parsedSpelling, passedOverAt, pathSegments, patternRefusal, readBytes, readPrefix, restBeneath, rootAbsence, sameRoot, shownLeads, sniffImageMime, surelyAtRoot, walkScope, withinIncludes } from './observe.js';
+import { CHANGED, DIRECTORY, IGNORED, NONBLOCK, OTHER_MOUNT, OUTSIDE_INCLUDE, ROOT_ON_ANOTHER_DEVICE, ROOT_REPLACED, ROOT_UNAVAILABLE, beneathRoot, checkDir, checkRoot, confirmAbsent, coversLanding, directoryAt, diskSpelling, filesystemTrustsCtime, foldsCase, inOtherMount, insideMount, leadsInto, linkOnTheWay, linkRefusal, linkWords, locateRoot, looksBinary, namesHolder, nestedAtReal, nestedGuess, nestedHolder, nestedStep, observePath, parsedSpelling, passedOverAt, pathSegments, patternRefusal, readBytes, readPrefix, restBeneath, rootAbsence, sameRoot, shownLeads, sniffImageMime, surelyAtRoot, walkScope, withinIncludes } from './observe.js';
 import { TOOL_BATCH_HOOK_TIMEOUT_MS, ensureStateRegistered } from '../../module-registry.js';
 import { DEFAULT_TOOL_RESULT_INLINE_MAX_CHARS } from '../../tool-result-history.js';
 import { countBudget, decodeForEdit, hintBudget, planFile } from './edit-plan.js';
@@ -21,7 +22,7 @@ import { cutLine, editList, editReceipt, fitted, refusalText } from './edit-text
 import { fileText } from './text.js';
 import { DEFAULT_READ_LINE_LIMIT, characterPage, linePage } from './read-page.js';
 import { grepText, textAnswer } from './result-text.js';
-import { NOT_PUSHED_IN_OTHER_MOUNT, WALK_CAP, entryMode, explained, pushPaths, reconcilePass, settleAdoptionBeforeMutation, wayOn, } from './reconcile.js';
+import { NOT_PUSHED_IN_OTHER_MOUNT, WALK_CAP, entryMode, explained, passRoot, pushPaths, reconcilePass, settleAdoptionBeforeMutation, wayOn, } from './reconcile.js';
 import { EffectFailed, unlinkContained } from './effects.js';
 import { AWAITS_REOPEN, MOUNT_IT, ROOT_RECHECK, Refusal, UNFOLLOWED_STEP, changesFiles, didNothing, errnoCode, errnoWayOn, errnoWords, hostFix, onlyTheHost, systemWords, unexpectedAnswer } from './answers.js';
 import { unknownToolMessage } from '../unknown-tool.js';
@@ -61,6 +62,17 @@ const DIRECT_READS_AT_ONCE = 16;
 const DIRECT_SYNC_SKIPPED = "a direct mount: its tools read disk as it is, so there's nothing to take in";
 /** Why materialize passes over a writable direct mount, as its result's `skipped` says. */
 const DIRECT_MATERIALIZE_SKIPPED = "a direct mount: its writes are on disk as they're made, so there's nothing to write";
+const NOTHING_RECORDED_YET = 'nothing is recorded of this root yet, so any directory at its path is taken as it';
+const NOTHING_RECORDED = `${NOTHING_RECORDED_YET}; the first sync that takes in a file, or materialize that writes one, records it`;
+const NOTHING_RECORDED_READ_ONLY = `${NOTHING_RECORDED_YET}; the first sync that takes in a file records it`;
+const BORN_UNRECORDED = 'no birth time is recorded of this root yet, so a directory made again in its place with the same inode can\'t be told from it; the next sync or ls of this mount records it';
+function asShown(identity) {
+    if (identity?.born === undefined)
+        return identity;
+    const ns = BigInt(identity.born);
+    const second = new Date(Number(ns / 1000000000n) * 1000).toISOString().replace(/\.000Z$/, '');
+    return { ...identity, born: `${second}.${String(ns % 1000000000n).padStart(9, '0')}Z` };
+}
 class WorkspaceImageReadError extends Refusal {
     reason;
     constructor(reason, wayOn) {
@@ -1106,6 +1118,8 @@ export class WorkspaceModule {
     /** One disk→store pass; the caller holds the mount's turn. Emits its events. */
     async passUnlocked(mount, scope, opts = {}) {
         const result = await reconcilePass(this.getStore(), this.agreementOrThrow(), await this.runtime(mount), scope, opts);
+        if (result.rootListed !== undefined)
+            mount.lastPassRoot = { at: new Date().toISOString(), listed: result.rootListed };
         if (scope.kind === 'dir' && scope.dir === '' && scope.recursive)
             mount.initialSyncDone = true;
         // What a pass says is another mount's directory names that mount and
@@ -2005,14 +2019,14 @@ export class WorkspaceModule {
             return { requestInference: true };
         let text;
         if (paths.length === 1) {
-            text = `[${NOTICE_TAG.workspaceEvent} · ${op} · ${paths[0]}]`;
+            text = `[${NOTICE_TAG.workspaceEvent} · ${op} · ${nameToTypeBack(paths[0])}]`;
         }
         else {
-            const list = paths.map(p => `- ${p}`).join('\n');
+            const list = paths.map(p => `- ${nameToTypeBack(p)}`).join('\n');
             text = `[${NOTICE_TAG.workspaceEvent} · ${op} · ${paths.length} files in ${mountName}/]\n${list}`;
         }
         if (conflicts && conflicts.length > 0) {
-            text += `\n[${NOTICE_TAG.conflictsWithDisk}: ${conflicts.join(', ')}; reading each shows how to settle it]`;
+            text += `\n[${NOTICE_TAG.conflictsWithDisk}: ${conflicts.map(nameToTypeBack).join(', ')}; reading each shows how to settle it]`;
         }
         return {
             requestInference: true,
@@ -2078,7 +2092,7 @@ export class WorkspaceModule {
     /**
      * Write binary content (e.g. an image pulled from the agent's context) to a
      * mount, through the same Chronicle-tree + auto-materialize path as the
-     * `write` tool. Public API for the framework's synthesized `save_image`
+     * `write` tool. Public API for the framework's synthesized `save_recent_image`
      * tool and other peer callers that hold bytes rather than text.
      *
      * `branch`, when given, ties the write to that branch: the store's current
@@ -2910,8 +2924,9 @@ export class WorkspaceModule {
      * 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
+     * ROOT_REPLACED's words, or ROOT_ON_ANOTHER_DEVICE's where only its device
+     * differs and birth times can't tell; 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
@@ -3751,9 +3766,7 @@ export class WorkspaceModule {
         const absent = err instanceof WorkspaceReadError && err.code !== 'mount_unavailable' && (err.errno === 'ENOENT' || err.errno === 'ENOTDIR');
         if (!absent)
             return { unreadable: containedRefusal(err, path) };
-        const root = resolve(mount.config.path);
-        const rootReal = await realpath(root).catch(() => root);
-        const view = this.viewOf(mount, this.agreementOrThrow().rootIdentityForRead(mount.config.name));
+        const { view, rootReal } = await this.readView(mount);
         const proof = await confirmAbsent(view, rootReal, relativePath);
         if (!('reason' in proof))
             return 'none';
@@ -5502,6 +5515,8 @@ export class WorkspaceModule {
         if (input.mount !== undefined && !this.mounts.has(input.mount)) {
             return { success: false, error: didNothing('status', this.noSuchMountField(input.mount, 'covers every mount')), isError: true };
         }
+        const asked = input.mount === undefined ? [] : [...this.mounts].filter(([name, mount]) => !mount.direct && name === input.mount);
+        const roots = new Map(await Promise.all(asked.map(async ([name, mount]) => [name, await this.rootState(mount)])));
         for (const [name, mount] of this.mounts) {
             if (input.mount !== undefined && name !== input.mount)
                 continue;
@@ -5520,6 +5535,8 @@ export class WorkspaceModule {
             const { conflicts: conflictPaths, deletions: deletionPaths, owed } = this.heldChanges(mount);
             const pending = new Set([...conflictPaths, ...deletionPaths, ...owed]);
             const currentBranch = store.currentBranch();
+            const root = input.mount !== undefined ? roots.get(name)
+                : mount.lastPassRoot?.listed ? { unavailable: mount.lastPassRoot.listed, lastPassAt: mount.lastPassRoot.at } : undefined;
             status[name] = {
                 path: mount.config.path,
                 mode: mount.config.backend === 'direct' ? mount.config.mode ?? 'read-write' : mount.config.mode,
@@ -5537,12 +5554,41 @@ export class WorkspaceModule {
                 initialSyncDone: mount.initialSyncDone,
                 currentBranch: currentBranch.name,
                 lastMaterializedBranch: mount.lastMaterializedBranchId,
-                canMaterialize: this.mountMaterializeBlockReason(store, mount) === null,
+                canMaterialize: this.mountMaterializeBlockReason(store, mount) === null && root?.unavailable === undefined,
                 ...(mount.lastAgentActionScan ? { lastAgentActionScan: mount.lastAgentActionScan } : {}),
+                ...(root !== undefined ? { root } : {}),
             };
         }
         return { success: true, data: status };
     }
+    async readView(mount) {
+        const root = resolve(mount.config.path);
+        const rootReal = await realpath(root).catch(() => root);
+        return { view: this.viewOf(mount, this.agreementOrThrow().rootIdentityForRead(mount.config.name)), rootReal };
+    }
+    async rootState(mount) {
+        const read = await this.readView(mount).catch((err) => {
+            if (err instanceof EvidenceUnavailable)
+                return err;
+            throw err;
+        });
+        if (read instanceof EvidenceUnavailable) {
+            const root = resolve(mount.config.path);
+            const there = await locateRoot(this.viewOf(mount, undefined), await realpath(root).catch(() => root));
+            return { now: asShown('identity' in there ? there.identity : null), unavailable: rootUnreadable(read) };
+        }
+        const { view, rootReal } = read;
+        const recorded = view.rootIdentity ?? null;
+        const found = await passRoot({ view, rootReal });
+        if ('unavailable' in found) {
+            const there = await locateRoot({ ...view, rootIdentity: undefined }, rootReal);
+            return { recorded: asShown(recorded), now: asShown('identity' in there ? there.identity : null), unavailable: found.listed };
+        }
+        const note = this.agreementOrThrow().awaitsReopen ? undefined
+            : recorded === null ? mount.config.mode === 'read-only' ? NOTHING_RECORDED_READ_ONLY : NOTHING_RECORDED
+                : recorded.born === undefined && found.identity.born !== undefined && found.bornFixed ? BORN_UNRECORDED : undefined;
+        return { recorded: asShown(recorded), now: asShown(found.identity), ...(note !== undefined ? { note } : {}) };
+    }
     /**
      * What the store holds of a mount that disk lacks, on the selected branch,
      * among the mount's own paths. Status counts the first three as pending:
@@ -6069,7 +6115,7 @@ export class WorkspaceModule {
             return false; // still missing: the pass says so
         const agreement = this.agreementOrThrow();
         const recorded = agreement.rootIdentity(mount.config.name);
-        if (recorded && sameRootIdentity(recorded, found.identity))
+        if (recorded && sameRootIdentity(recorded, found.identity, found.bornFixed))
             return false;
         if (recorded)
             agreement.acceptRoot(mount.config.name, found.identity);
@@ -6477,7 +6523,7 @@ function deletedOnDisk(path) {
 function uncheckedFile(shown, note, cause) {
     if (note === DIRECTORY)
         return `${shown} is a directory, not a file; ls ${shown} lists what's in it.`;
-    const on = note === ROOT_REPLACED || cause.ownStep === true ? null
+    const on = note === ROOT_REPLACED || note === ROOT_ON_ANOTHER_DEVICE || cause.ownStep === true ? null
         : (note === undefined ? null : wayOn(note, cause, 'read')) ?? 'calling again checks disk again; if the same reason comes back, whoever runs this host can fix it on disk';
     return `${shown} isn't in the workspace, and disk couldn't be checked: ${sentence(note ?? 'not observed')}${on !== null ? ` ${on[0].toUpperCase()}${sentence(on.slice(1))}` : ''}`;
 }