amalgm 0.1.259 → 0.1.260

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "amalgm",
-  "version": "0.1.259",
+  "version": "0.1.260",
   "description": "Amalgm local computer runtime: login, MCP, chat, events, previews, and tunnels.",
   "license": "UNLICENSED",
   "private": false,

package/runtime/scripts/amalgm-mcp/observer/scan.js

@@ -14,15 +14,31 @@ const { lookFailed } = require('../adapters/truth');
 /**
  * Does a .git hold this ground? Three answers, like every look — and
  * only present or absent may conclude: territory is never born,
- * buried, or converted on a look that failed.
+ * buried, or converted on a look that failed. A directory is Git's own
+ * repository marker. A file is a linked-worktree/submodule pointer, so it
+ * claims territory only when the referenced gitdir still exists: a stale
+ * pointer is ordinary folder ground, never a broken repo boundary.
  */
 function gitDirTruth(absDir) {
+  let marker;
   try {
-    fs.lstatSync(path.join(absDir, '.git'));
-    return 'present';
+    marker = fs.lstatSync(path.join(absDir, '.git'));
   } catch (error) {
     return lookFailed(error).truth;
   }
+  if (marker.isDirectory()) return 'present';
+  if (!marker.isFile()) return 'absent';
+  try {
+    const source = fs.readFileSync(path.join(absDir, '.git'), 'utf8');
+    const match = /^gitdir:\s*(.+?)\s*$/im.exec(source);
+    if (!match) return 'absent';
+    const gitDir = path.resolve(absDir, match[1]);
+    if (!fs.lstatSync(gitDir).isDirectory()) return 'absent';
+    if (!fs.lstatSync(path.join(gitDir, 'HEAD')).isFile()) return 'absent';
+    return 'present';
+  } catch (error) {
+    return lookFailed(error).truth === 'unsettled' ? 'unsettled' : 'absent';
+  }
 }
 
 /**
@@ -72,9 +88,15 @@ function walkRoot(rootPath, shouldEnroll, { allowRootRepository = false } = {})
       vanished(error, relDir);
       continue;
     }
-    // A .git claims its subtree: an embedded repository is repo territory,
-    // never files territory. Its changes travel as one card, not as files.
-    if (entries.some((entry) => entry.name === '.git') && !(allowRootRepository && relDir === '')) {
+    // A valid .git claims its subtree: an embedded repository is repo
+    // territory, never files territory. Its changes travel as one card, not
+    // as files. A stale linked-worktree pointer is plain folder ground.
+    const territory = gitDirTruth(absDir);
+    if (territory === 'unsettled') {
+      unsettled.push(relDir);
+      continue;
+    }
+    if (territory === 'present' && !(allowRootRepository && relDir === '')) {
       repoDirs.push(relDir);
       if (!relDir) return { files: [], dirs: [], links: [], repoDirs, unsettled }; // the whole root is repo territory
       continue;
@@ -148,7 +170,12 @@ function listDir(rootPath, relDir, shouldEnroll) {
     else out.unsettled = true;
     return out;
   }
-  if (entries.some((entry) => entry.name === '.git')) {
+  const territory = gitDirTruth(absDir);
+  if (territory === 'unsettled') {
+    out.unsettled = true;
+    return out;
+  }
+  if (territory === 'present') {
     out.hasGit = true;
     return out;
   }
@@ -218,7 +245,12 @@ function censusBoundaries(rootPath, shouldEnroll = defaultShouldEnroll) {
       if (lookFailed(error).truth === 'unsettled') unsettled.push(relDir);
       continue;
     }
-    if (relDir && entries.some((entry) => entry.name === '.git')) {
+    const territory = gitDirTruth(absDir);
+    if (territory === 'unsettled') {
+      unsettled.push(relDir);
+      continue;
+    }
+    if (relDir && territory === 'present') {
       boundaries.push(relDir);
       continue;
     }
@@ -259,7 +291,12 @@ function censusLinks(rootPath, shouldEnroll = defaultShouldEnroll) {
       if (lookFailed(error).truth === 'unsettled') unsettled.push(relDir);
       continue;
     }
-    if (relDir && entries.some((entry) => entry.name === '.git')) continue;
+    const territory = gitDirTruth(absDir);
+    if (territory === 'unsettled') {
+      unsettled.push(relDir);
+      continue;
+    }
+    if (relDir && territory === 'present') continue;
     for (const entry of entries) {
       if (entry.name === '.git') continue;
       const rel = relDir ? `${relDir}/${entry.name}` : entry.name;

package/runtime/scripts/amalgm-mcp/registration/tree.js

@@ -29,6 +29,7 @@
 const fs = require('fs');
 const path = require('path');
 const crypto = require('crypto');
+const { gitDirTruth } = require('../observer/scan');
 
 function rootType(rootPath, kind) {
   if (kind === 'repo') return 'repo.git';
@@ -37,18 +38,10 @@ function rootType(rootPath, kind) {
 }
 
 function isRepository(dirPath) {
-  try {
-    fs.lstatSync(path.join(dirPath, '.git'));
-    return true;
-  } catch (error) {
-    // A failed look cannot prove a repo boundary. Register the readable
-    // shape below it; observer territory detection retries the boundary
-    // look and performs the UUID-preserving folder → repo.git transition
-    // once Git becomes knowable.
-    if (error.code === 'ENOENT' || error.code === 'ENOTDIR'
-      || error.code === 'EACCES' || error.code === 'EPERM') return false;
-    throw error;
-  }
+  // This is the observer's exact territory primitive. In particular, a
+  // stale linked-worktree pointer must be ordinary folder ground for both
+  // structural registration and later Watch/Detect reconciliation.
+  return gitDirTruth(dirPath) === 'present';
 }
 
 /**

package/runtime/scripts/amalgm-mcp/tests/observer.territory.test.js

@@ -63,6 +63,21 @@ test('a .git claims its subtree: embedded repos are never files territory', () =
   ));
 });
 
+test('a stale linked-worktree pointer is ordinary folder ground, not a broken repository', () => {
+  const dir = makeDir('stale-gitfile');
+  const child = path.join(dir, 'former-submodule');
+  fs.mkdirSync(child);
+  fs.writeFileSync(path.join(child, '.git'), 'gitdir: ../.git/modules/missing\n');
+  fs.writeFileSync(path.join(child, 'readme.md'), 'still ordinary files');
+
+  const { observer, events } = makeObserver();
+  observer.enrollRoot(dir);
+
+  assert.deepEqual(eventsOf(events, 'repo.discovered'), []);
+  assert.deepEqual(eventsOf(events, 'file.created').map((event) => event.path), ['former-submodule/readme.md']);
+  assert.equal(observer.listRoots().some((root) => root.path === child && root.kind === 'repo'), false);
+});
+
 test('a .git vanishing returns its territory to files: channels are reborn', () => {
   const dir = makeDir('territory-back');
   fs.mkdirSync(path.join(dir, 'vendor', '.git'), { recursive: true });