@mnemonik/shared 7.140.2 → 7.140.3

package/src/codeScanner.ts

@@ -714,9 +714,12 @@ export const SCANNER_MAX_DEPTH = 10;
  *    project, never also into this one. A file naming the enclosing project
  *    (`enclosingProjectId`, a copy) is the same project, and a
  *    configuration-only file (no `projectId`) names none: neither is a
- *    boundary. A file that cannot be read as an identity still is;
- *  - a linked worktree (a `.git` FILE whose git directory has a `commondir`)
- *    is another checkout of a project, indexed from its main checkout.
+ *    boundary. A file that cannot be read as an identity still is, and so is
+ *    a copy in a full clone (its own `.git` DIRECTORY): a second checkout of
+ *    the project, whose files would otherwise be indexed twice;
+ *  - a linked worktree (a `.git` FILE whose git directory has a `commondir`,
+ *    or is missing) is another checkout of a project, indexed from its main
+ *    checkout.
  * A nested clone or a submodule without its own `.mnemonik.json` belongs to
  * this project and is indexed with it (its `.git` directory is ignored by the
  * built-in rules). The scan ROOT is exempt by construction (callers only test
@@ -735,6 +738,7 @@ export async function isProjectBoundary(
     if (!identity) return true;
     if (identity.kind === 'ok') {
       if (identity.identity.projectId !== enclosingProjectId) return true;
+      if ((await lstatWithin(join(dirPath, '.git')))?.isDirectory()) return true;
     } else if (identity.kind !== 'absent') return true;
   }
   return isLinkedWorktreeCheckout(dirPath);
@@ -758,8 +762,10 @@ const lstatWithin = (path: string) =>
 
 /**
  * True when `dirPath` is the top of a linked git worktree: its `.git` is a
- * FILE pointing at a git directory that has a `commondir`. A submodule's
- * `.git` file points at `.git/modules/<name>`, which has none.
+ * FILE pointing at a git directory that has a `commondir`, or at one that no
+ * longer exists (a pruned or moved worktree, or one made on another machine):
+ * nothing shows it is this project's own. A submodule's `.git` file points at
+ * `.git/modules/<name>`, which exists and has no `commondir`.
  */
 export async function isLinkedWorktreeCheckout(dirPath: string): Promise<boolean> {
   const marker = await lstatWithin(join(dirPath, '.git'));
@@ -773,7 +779,9 @@ export async function isLinkedWorktreeCheckout(dirPath: string): Promise<boolean
       )
     )?.[1];
     if (!pointer) return false;
-    return !!(await lstatWithin(join(resolve(dirPath, pointer), 'commondir')));
+    const gitDirectory = resolve(dirPath, pointer);
+    if (!(await lstatWithin(gitDirectory))) return true;
+    return !!(await lstatWithin(join(gitDirectory, 'commondir')));
   } catch {
     return false;
   }

package/src/contextBudget.ts

@@ -255,13 +255,12 @@ export function isBootstrapDigestPayload(text: string): boolean {
  * The explicit call that re-fetches a bootstrap digest, for the item that
  * carries one. A shed emission without a route leaves no stub, so a digest
  * shed for budget once vanished without a trace (2026-10-10); with this route
- * the not-reached marker names the call that brings it back. The digest's own
- * `cwd=` line supplies the scope.
+ * the not-reached marker names the call that brings it back. The call carries
+ * no scope: the hook adds the project.
  */
 export function projectContextRetrievalRoute(text: string): string | undefined {
   if (!isBootstrapDigestPayload(text)) return undefined;
-  const cwd = /^cwd=(.+)$/m.exec(text)?.[1]?.trim();
-  return cwd ? `session_bootstrap({ cwd: ${JSON.stringify(cwd)} })` : 'session_bootstrap';
+  return 'session_bootstrap({})';
 }
 
 /** Fit one rendered envelope while preserving its exact under-budget bytes. */

package/src/gitEditDetector.ts

@@ -62,7 +62,7 @@
  *
  * Each report also carries where the edit happened (`editScope`): the git
  * worktree and repository of the file, or a mark that the file lies outside
- * the project's repository (/tmp, another repository, a `.git` directory). The
+ * the project (/tmp, another project, a `.git` directory). The
  * server counts only project edits, and gates a push on the uncheckpointed
  * files it carries (`describeHandoffs`).
  */
@@ -70,6 +70,7 @@
 import { execFileSync } from 'node:child_process';
 import { createHash, randomUUID } from 'node:crypto';
 import {
+  lstatSync,
   mkdirSync,
   readFileSync,
   realpathSync,
@@ -78,6 +79,7 @@ import {
   unlinkSync,
   writeFileSync,
 } from 'node:fs';
+import { homedir } from 'node:os';
 import { dirname, isAbsolute, join, resolve } from 'node:path';
 import { performance } from 'node:perf_hooks';
 
@@ -462,6 +464,97 @@ function isWithin(path: string, dir: string): boolean {
   return path === dir || path.startsWith(base);
 }
 
+const CANONICAL_UUID = /^[0-9a-f]{8}-[0-9a-f]{4}-[1-8][0-9a-f]{3}-[89ab][0-9a-f]{3}-[0-9a-f]{12}$/;
+
+/**
+ * The `projectId` a folder's own `.mnemonik.json` names: 'absent' when there is
+ * no file or it holds configuration only (no `projectId`, schema 1 or none),
+ * null when it cannot be read or is not a valid schema 1 identity.
+ */
+function identityFileAt(dir: string): string | 'absent' | null {
+  const path = join(dir, '.mnemonik.json');
+  let text: string;
+  try {
+    if (!lstatSync(path).isFile()) return null;
+    text = readFileSync(path, 'utf8');
+  } catch (error) {
+    const code = (error as NodeJS.ErrnoException).code;
+    return code === 'ENOENT' || code === 'ENOTDIR' ? 'absent' : null;
+  }
+  try {
+    const value: unknown = JSON.parse(text);
+    if (!value || typeof value !== 'object' || Array.isArray(value)) return null;
+    const record = value as Record<string, unknown>;
+    if (!('projectId' in record)) {
+      return !('schemaVersion' in record) || record.schemaVersion === 1 ? 'absent' : null;
+    }
+    return record.schemaVersion === 1 &&
+      typeof record.projectId === 'string' &&
+      CANONICAL_UUID.test(record.projectId)
+      ? record.projectId
+      : null;
+  } catch {
+    return null;
+  }
+}
+
+/** The main checkout of a linked worktree whose top is `dir`, or null when `dir` is no such top. */
+function linkedWorktreeMainCheckout(dir: string): string | null {
+  const dotGit = join(dir, '.git');
+  try {
+    if (!lstatSync(dotGit).isFile()) return null;
+    const gitDir = gitDirFromFile(dotGit, dir);
+    if (!gitDir) return null;
+    const common = readFileSync(join(gitDir, 'commondir'), 'utf8').trim();
+    return common ? dirname(canonicalPath(resolve(gitDir, common))) : null;
+  } catch {
+    return null;
+  }
+}
+
+const projectIdCache = new Map<string, string | 'none' | null>();
+
+/**
+ * The Mnemonik project a directory belongs to: the `projectId` of the nearest
+ * `.mnemonik.json` at or above it, as the hooks resolve a session's project
+ * (repositoryRoot.ts `resolveNearestProjectIdentity`). A git repository is not
+ * a project's edge: a nested clone or submodule belongs to the project around
+ * it unless it has an identity file of its own. A configuration-only file is
+ * passed, the walk stops at the home folder (whose own file counts), and the
+ * top of a linked worktree stands for its main checkout (the worktree's own
+ * copy of the file does not count). 'none' outside any project; null when the
+ * identity cannot be read, which callers treat as unknown. Read from the file
+ * system without git, as `gitLocation` is, and with the Node standard library
+ * only (this file is copied into grok-hooks).
+ */
+function projectIdAt(dir: string): string | 'none' | null {
+  const cached = projectIdCache.get(dir);
+  if (cached !== undefined) return cached;
+  const home = canonicalPath(homedir());
+  let result: string | 'none' | null = 'none';
+  let current = canonicalPath(dir);
+  let inMainCheckout = false;
+  for (;;) {
+    const main = inMainCheckout ? null : linkedWorktreeMainCheckout(current);
+    if (main) {
+      current = main;
+      inMainCheckout = true;
+      continue;
+    }
+    const identity = identityFileAt(current);
+    if (identity !== 'absent') {
+      result = identity;
+      break;
+    }
+    if (current === home) break;
+    const parent = dirname(current);
+    if (parent === current) break;
+    current = parent;
+  }
+  projectIdCache.set(dir, result);
+  return result;
+}
+
 /** Where a reported edit happened, as sent to track-ide-edit. */
 export interface EditScope {
   /** The git worktree root that holds the file. Absent when unknown or not in git. */
@@ -480,19 +573,31 @@ export interface EditScope {
  * Where `filePath` lies relative to the project the agent works in.
  *
  * `anchorDir` is the project directory: the host's project root when it has
- * one (Claude Code's CLAUDE_PROJECT_DIR), else the event's cwd. A file is
- * project work when it is in the same git repository as the anchor (any of
- * its worktrees), or, when the anchor is not in git, inside the anchor.
- * Anything that cannot be determined is reported as unknown (no claim), so an
- * unreadable directory never hides an edit.
+ * one (Claude Code's CLAUDE_PROJECT_DIR), else the event's cwd. When the
+ * anchor is in a Mnemonik project, a file is project work when the nearest
+ * `.mnemonik.json` above it names the same project (`projectIdAt`): a nested
+ * clone or submodule is in, and a subproject with its own identity file is
+ * out even when it shares the anchor's repository. Otherwise a file is project
+ * work when it is in the same git repository as the anchor (any of its
+ * worktrees), or, when the anchor is not in git, inside the anchor. A path
+ * inside `.git` is never project work. Anything that cannot be determined is
+ * reported as unknown (no claim), so an unreadable directory never hides an
+ * edit.
  */
 export function editScope(filePath: string, cwd: string, anchorDir: string = cwd): EditScope {
   if (!filePath) return {};
   const absolute = isAbsolute(filePath) ? filePath : join(cwd, filePath);
   if (/(?:^|\/)\.git(?:\/|$)/.test(absolute)) return { outsideProject: true };
-  const file = gitLocation(nearestExistingDirectory(dirname(absolute)));
-  const anchor = anchorDir ? gitLocation(anchorDir) : null;
+  const fileDir = nearestExistingDirectory(dirname(absolute));
+  const file = gitLocation(fileDir);
   const editRoot = file && file !== 'none' ? { editRoot: file.root, editRepo: file.commonDir } : {};
+  const anchorProject = anchorDir ? projectIdAt(anchorDir) : null;
+  if (anchorProject !== null && anchorProject !== 'none') {
+    const fileProject = projectIdAt(fileDir);
+    if (fileProject === null || fileProject === anchorProject) return editRoot;
+    return { outsideProject: true };
+  }
+  const anchor = gitLocation(anchorDir);
   if (file === null || anchor === null) return editRoot;
   if (anchor === 'none') {
     return isWithin(absolute, anchorDir) ? editRoot : { outsideProject: true };

package/src/hookRuntime.ts

@@ -63,6 +63,18 @@ export async function findProjectIdentity(startCwd: string): Promise<ProjectIden
   return pending;
 }
 
+/**
+ * What a hook tells the server about its working folder: the project's id
+ * (the only project identity) and the project's root folder (the root for
+ * repo-relative paths). Both are absent outside a project.
+ */
+export async function projectScope(
+  startCwd: string
+): Promise<{ projectId?: string; projectRoot?: string }> {
+  const identity = await findProjectIdentity(startCwd);
+  return identity ? { projectId: identity.projectId, projectRoot: identity.projectRoot } : {};
+}
+
 /** The project a hook's working folder belongs to: the nearest `.mnemonik.json` above it. */
 export async function findProjectIdentityDetailed(
   startCwd: string
@@ -128,20 +140,8 @@ export function readHookStdin(
   });
 }
 
-let mismatchEmitted = false;
-
 export async function parseHookResponse<T>(response: Response): Promise<T> {
-  const body = (await response.json()) as T;
-  const result = body as { ok?: boolean; reason?: string };
-  if (!mismatchEmitted && result?.ok === false && result.reason === 'identity_mismatch') {
-    stderr.write(
-      'mnemonik-hook: project identity mismatch - .mnemonik.json points to one project, ' +
-        'but this directory is registered to a different one on the server. ' +
-        'Fix .mnemonik.json (delete it and let session_bootstrap rewrite it) or cd to the correct project root.\n'
-    );
-    mismatchEmitted = true;
-  }
-  return body;
+  return (await response.json()) as T;
 }
 
 /** Native host correlation only; never accept checkpoint/model fields here. */

package/src/instructions.ts

@@ -156,7 +156,7 @@
 
 // Dynamic response orchestration remains authoritative. This universal floor stays
 // self-scoping when project context was already loaded through another channel.
-const INSTRUCTIONS_CONTENT = `Mnemonik provides persistent project memory: decisions, rationale, tasks, and policies across sessions. If no block begins "PROJECT_CONTEXT schemaVersion=", session_bootstrap({ cwd }) loads project context when cwd is the real absolute path of the project root; a placeholder or relative path fails. With that block, context is loaded and no session_bootstrap call is needed. Code and docs show current artifacts, git shows changes, and memory carries the why; memory_search recalls rationale or intent, then Grep or Read verifies current source.
+const INSTRUCTIONS_CONTENT = `Mnemonik provides persistent project memory: decisions, rationale, tasks, and policies across sessions. If no block begins "PROJECT_CONTEXT schemaVersion=", session_bootstrap({}) loads project context; installed hooks supply the project. With that block, context is loaded and no session_bootstrap call is needed. Code and docs show current artifacts, git shows changes, and memory carries the why; memory_search recalls rationale or intent, then Grep or Read verifies current source.
 
 What I learn about you belongs in Companion; what I learn about this project belongs here.
 

package/src/runtimeReader.ts

@@ -21,7 +21,12 @@ export type Reason =
   | 'unsigned'
   | 'permission'
   | 'acl_unavailable'
-  | 'lock_held';
+  | 'lock_held'
+  // The registry answered without the package (404, 429 or 5xx): a fresh release
+  // still reaching its CDN, a busy registry, or a pin it does not have.
+  | 'registry_unavailable'
+  // The registry could not be reached at all: offline, DNS, refused, timed out.
+  | 'registry_unreachable';
 export class RuntimeError extends Error {
   constructor(public readonly reason: Reason) {
     super(reason);