@amalgm/shell 0.1.79 → 0.1.80

package/dist/user-ground-host.js

@@ -2007,6 +2007,34 @@ function readGroundRowsForRoots(file, table, rootUUIDs) {
         database.close();
     }
 }
+/** Type and UUID settle locally even when immutable repository capture must
+ * retry. Those rows are identity evidence for the next observation, while
+ * their absence from the notebook still means no verified logical result has
+ * been recorded. Normally this query is empty. */
+function readMaterializedRowsWithoutNotebook(file, rootUUIDs) {
+    if (!existsSync(file) || rootUUIDs?.size === 0)
+        return [];
+    const database = initializeDatabase(file);
+    try {
+        const roots = rootUUIDs ? [...rootUUIDs] : [];
+        const rootFilter = roots.length > 0
+            ? `AND entities.root_uuid IN (${roots.map(() => "?").join(", ")})`
+            : "";
+        return database.prepare(`
+      SELECT ${GROUND_ROW_PROJECTION}
+        FROM entities
+       WHERE NOT EXISTS (
+         SELECT 1 FROM detection_notebook
+          WHERE detection_notebook.uuid = entities.uuid
+       )
+       ${rootFilter}
+       ORDER BY uuid
+    `).all(...roots);
+    }
+    finally {
+        database.close();
+    }
+}
 function readGroundRootAtPath(file, table, absolutePath) {
     if (!existsSync(file))
         return null;
@@ -2820,10 +2848,13 @@ async function reconcileGround(input) {
     const notebook = selectedRoots
         ? readGroundRowsForRoots(database, "detection_notebook", selectedRoots)
         : readDetectionNotebook(database);
-    const existing = suspicions ? notebook : materialized;
+    const unverifiedIdentity = suspicions
+        ? readMaterializedRowsWithoutNotebook(database, selectedRoots ?? undefined)
+        : [];
+    const existing = suspicions ? [...notebook, ...unverifiedIdentity] : materialized;
     const notebookByUuid = new Map(notebook.map((row) => [row.uuid, row]));
     const materializedBaseline = suspicions
-        ? notebook.filter((row) => materializedUUIDs.has(row.uuid))
+        ? existing.filter((row) => materializedUUIDs.has(row.uuid))
         : materialized;
     const materializedByUuid = new Map(materializedBaseline.map((row) => [row.uuid, row]));
     const materializedByRoot = new Map();
@@ -3031,8 +3062,9 @@ async function reconcileRoot(input) {
         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.
+            // ring. Git already knows every dirty tracked and untracked path, so
+            // those paths join this observation and Card + Checkpoint cannot carry
+            // stale identity.
             rootRepositoryEvidence = inspectGitRegistration(rootPath);
         }
         catch {
@@ -3059,6 +3091,7 @@ async function reconcileRoot(input) {
             : [...new Set([
                     ...normalizedSuspects,
                     ...rootRepositoryEvidence.dirtyPaths,
+                    ...rootRepositoryEvidence.untrackedPaths,
                     ...changedTrackedPaths,
                 ])].sort()
         : suspects;
@@ -3181,7 +3214,8 @@ async function reconcileRoot(input) {
                 : null;
             const observe = forceObserve || existing === undefined
                 || (repositoryPath !== null
-                    && activeRepository?.evidence?.dirtyPaths.has(repositoryPath) === true)
+                    && (activeRepository?.evidence?.dirtyPaths.has(repositoryPath) === true
+                        || activeRepository?.evidence?.untrackedPaths.has(repositoryPath) === true))
                 || (scanSuspects === null ? !stableDuringCompleteCatchUp : touchesSuspicion(relativePath));
             if (!observe && scanSuspects === null)
                 evidence && (evidence.metadataReused += 1);
@@ -3195,7 +3229,10 @@ async function reconcileRoot(input) {
                     // provide clean-index evidence, read current worktree bytes; Card +
                     // Checkpoint capture below remains the transfer retry boundary.
                     activeRepository.evidence = {
-                        trackedPaths: new Set(), cleanLeaves: new Map(), dirtyPaths: new Set(),
+                        trackedPaths: new Set(),
+                        cleanLeaves: new Map(),
+                        dirtyPaths: new Set(),
+                        untrackedPaths: new Set(),
                     };
                 }
             }
@@ -3484,6 +3521,7 @@ async function reconcileRoot(input) {
                 captured = captureRepository(repository.absolutePath, repoIdentity, prior, previousIdentity);
                 const after = await refreshRepositoryIdentity();
                 if (sameGitIdentity(after, repoIdentity)) {
+                    repoIdentity = [...captured.identity];
                     coherent = true;
                     break;
                 }