@amalgm/shell 0.1.71 → 0.1.72

package/dist/user-ground-host.js

@@ -16,7 +16,7 @@ import { AcceptedInboxResultIndex } from "./detection/accepted-result.js";
 import { NamedDetectRuntime } from "./detection/runtime.js";
 import { WORKSPACE_UUID as UUID, createFilesRegisterPorts, ensureWorkspaceBinding, ensureWorkspaceReference, pathExists, pathWithin, referenceWorkspaceId, selectKnownRegistrationId, workspaceBindingDir, } from "./files-register-host.js";
 import { applyRepositoryFiles, captureRepository, inspectRepositoryTransportFile, hasGitMarker, readCachedRepositoryIdentity, } from "./git-repository-host.js";
-import { canonicalizeGitIdentity, inspectGitRegistration, sameGitIdentity, } from "./git-registration-host.js";
+import { inspectGitRegistration, sameGitIdentity, } from "./git-registration-host.js";
 import { projectMaterializedGraph } from "./materialized-graph.js";
 import { NodeWatchHost, } from "./watching/index.js";
 import { WireClient, WireRequestError } from "./wire-client.js";
@@ -2407,13 +2407,6 @@ async function reconcileGround(input) {
 }
 async function reconcileRoot(input) {
     const { identity, resourceId, rootUUID, rootName, rootPath, rootType, database, cacheDir, policy, bindingDir, suspects = null, evidence, } = input;
-    const scanSuspects = suspects !== null && rootType === "repo.git"
-        ? [...new Set(suspects.map((path) => {
-                const segments = path.split("/");
-                const marker = segments.indexOf(".git");
-                return marker < 0 ? path : segments.slice(0, marker).join("/");
-            }))].sort()
-        : suspects;
     const existingRows = input.existingRows
         ?? readRows(database).filter((row) => row.resourceId === resourceId && row.rootUUID === rootUUID);
     const existingByPath = new Map(existingRows.flatMap((row) => {
@@ -2453,6 +2446,43 @@ async function reconcileRoot(input) {
             }) : null,
         };
     }
+    let rootRepositoryEvidence = null;
+    let rootRepositoryInspectionFailed = false;
+    if (rootType === "repo.git") {
+        evidence && (evidence.gitInspections += 1);
+        try {
+            // A Git metadata ring can arrive before the corresponding worktree
+            // ring. Git already knows every dirty tracked path, so those paths join
+            // this observation and Card + Checkpoint cannot carry stale identity.
+            rootRepositoryEvidence = inspectGitRegistration(rootPath);
+        }
+        catch {
+            rootRepositoryInspectionFailed = true;
+        }
+    }
+    const normalizedSuspects = suspects === null ? null : suspects.map((path) => {
+        const segments = path.split("/");
+        const marker = segments.indexOf(".git");
+        return marker < 0 ? path : segments.slice(0, marker).join("/");
+    });
+    const changedTrackedPaths = rootRepositoryEvidence === null ? [] : [
+        ...[...rootRepositoryEvidence.trackedPaths]
+            .filter((path) => !existingByPath.has(path)),
+        ...existingRows
+            .filter((row) => row.relativePath !== ""
+            && row.payloadVersion?.startsWith("git:")
+            && !rootRepositoryEvidence.trackedPaths.has(row.relativePath))
+            .map((row) => row.relativePath),
+    ];
+    const scanSuspects = suspects !== null && rootType === "repo.git"
+        ? rootRepositoryInspectionFailed
+            ? null
+            : [...new Set([
+                    ...normalizedSuspects,
+                    ...rootRepositoryEvidence.dirtyPaths,
+                    ...changedTrackedPaths,
+                ])].sort()
+        : suspects;
     const entries = [];
     const referenceWorkspaceIds = new Set();
     const rootStats = lstatSync(rootPath);
@@ -2525,7 +2555,11 @@ async function reconcileRoot(input) {
         return [...new Set(paths)].sort();
     };
     const visit = async (directory, parentUUID, parentType, base = "", activeRepository = parentType === "repo.git"
-        ? { root: directory, evidencePaths: repositoryEvidencePaths(directory), evidence: null }
+        ? {
+            root: directory,
+            evidencePaths: repositoryEvidencePaths(directory),
+            evidence: directory === rootPath ? rootRepositoryEvidence : null,
+        }
         : null, forceObserve = rootRailChanged) => {
         const children = readdirSync(directory, { withFileTypes: true })
             .sort((left, right) => left.name < right.name ? -1 : left.name > right.name ? 1 : 0);
@@ -2557,13 +2591,15 @@ async function reconcileRoot(input) {
             const stableDuringCompleteCatchUp = scanSuspects === null
                 && existing !== undefined
                 && reusableDuringCompleteCatchUp(existing, stats);
+            const repositoryPath = activeRepository
+                ? slashPath(relative(activeRepository.root, absolutePath))
+                : null;
             const observe = forceObserve || existing === undefined
+                || (repositoryPath !== null
+                    && activeRepository?.evidence?.dirtyPaths.has(repositoryPath) === true)
                 || (scanSuspects === null ? !stableDuringCompleteCatchUp : touchesSuspicion(relativePath));
             if (!observe && scanSuspects === null)
                 evidence && (evidence.metadataReused += 1);
-            const repositoryPath = activeRepository
-                ? slashPath(relative(activeRepository.root, absolutePath))
-                : null;
             if (observe && repositoryPath && activeRepository && !activeRepository.evidence) {
                 evidence && (evidence.gitInspections += 1);
                 try {
@@ -2573,7 +2609,9 @@ async function reconcileRoot(input) {
                     // Classification already settled from the marker. If Git cannot
                     // provide clean-index evidence, read current worktree bytes; Card +
                     // Checkpoint capture below remains the transfer retry boundary.
-                    activeRepository.evidence = { cleanLeaves: new Map() };
+                    activeRepository.evidence = {
+                        trackedPaths: new Set(), cleanLeaves: new Map(), dirtyPaths: new Set(),
+                    };
                 }
             }
             const indexed = observe && repositoryPath
@@ -2751,14 +2789,73 @@ async function reconcileRoot(input) {
                 ? entry.relativePath.slice(repository.relativePath.length + 1)
                 : entry.relativePath;
             const ownedByPath = new Map(ownedEntries.map((entry) => [repositoryPath(entry), entry]));
-            let repoIdentity = ownedEntries
-                .map((entry) => ({
-                path: repositoryPath(entry),
-                uuid: entry.uuid,
-                type: entry.type,
-                payloadVersion: entry.payloadVersion,
-            }))
-                .sort((left, right) => left.path < right.path ? -1 : left.path > right.path ? 1 : 0);
+            const refreshRepositoryIdentity = async () => {
+                const registration = inspectGitRegistration(repository.absolutePath);
+                const removed = new Set();
+                for (const [path, clean] of registration.cleanLeaves) {
+                    const entry = ownedByPath.get(path);
+                    if (!entry) {
+                        throw new Error(`repository indexed path ${path} has no registered identity`);
+                    }
+                    entry.type = clean.type;
+                    entry.payloadVersion = clean.payloadVersion;
+                    entry.linkTarget = undefined;
+                }
+                for (const path of registration.dirtyPaths) {
+                    const entry = ownedByPath.get(path);
+                    const absolutePath = join(repository.absolutePath, ...path.split("/"));
+                    if (!existsSync(absolutePath)) {
+                        if (entry)
+                            removed.add(path);
+                        continue;
+                    }
+                    if (!entry) {
+                        throw new Error(`repository dirty path ${path} has no registered identity`);
+                    }
+                    const stats = lstatSync(absolutePath);
+                    if (stats.isSymbolicLink()) {
+                        const target = readlinkSync(absolutePath);
+                        entry.type = "link";
+                        entry.payloadVersion = sha256Hex(Buffer.from(target, "utf8"));
+                        entry.linkTarget = target;
+                    }
+                    else if (stats.isFile()) {
+                        const current = await captureContentFile(absolutePath, stats, null);
+                        entry.type = classifyFile({ binary: current.binary });
+                        entry.payloadVersion = current.contentHash;
+                        entry.linkTarget = undefined;
+                    }
+                    else {
+                        throw new Error(`repository dirty path ${path} is not a file or link`);
+                    }
+                    entry.contentVerifiedAtMs = Date.now();
+                    Object.assign(entry, statFingerprint(stats));
+                    evidence && (evidence.contentReads += 1);
+                }
+                if (removed.size > 0) {
+                    for (const path of removed) {
+                        const entry = ownedByPath.get(path);
+                        if (!entry)
+                            continue;
+                        const index = entries.indexOf(entry);
+                        if (index >= 0)
+                            entries.splice(index, 1);
+                        ownedByPath.delete(path);
+                    }
+                }
+                return [...ownedByPath.entries()]
+                    .map(([path, entry]) => ({
+                    path,
+                    uuid: entry.uuid,
+                    type: entry.type,
+                    payloadVersion: entry.payloadVersion,
+                }))
+                    .sort((left, right) => left.path < right.path ? -1 : left.path > right.path ? 1 : 0);
+            };
+            let repoIdentity = await refreshRepositoryIdentity();
+            /* The rows and the transport identity are derived from the same fresh
+             * worktree evidence. A later Watch ring for one of these dirty paths is
+             * therefore ordinary equality, not a transport-only echo. */
             const priorRow = existingByPath.get(repository.relativePath);
             if (priorRow?.type === "repo.git") {
                 repository.payloadVersion = priorRow.payloadVersion;
@@ -2799,7 +2896,7 @@ async function reconcileRoot(input) {
             let coherent = false;
             for (let attempt = 0; attempt < 3; attempt += 1) {
                 captured = captureRepository(repository.absolutePath, repoIdentity, prior, previousIdentity);
-                const after = canonicalizeGitIdentity(repoIdentity, inspectGitRegistration(repository.absolutePath));
+                const after = await refreshRepositoryIdentity();
                 if (sameGitIdentity(after, repoIdentity)) {
                     coherent = true;
                     break;