@quolu/lattice 0.69.5 → 0.71.0

package/sensor/dist/directory.d.ts

@@ -1,17 +1,65 @@
 /** Lattice sensor project-state directory management. */
+/**
+ * The per-project data directory, as upstream's name for it. Lattice has one
+ * fixed path (no `LATTICE_SENSOR_DIR` override, no per-host variant), so this is
+ * {@link latticeSensorRelativeDir} under the name upstream code imports.
+ */
+export declare const DEFAULT_LATTICE_SENSOR_DIR: string;
+/**
+ * Upstream's WSL-on-a-Windows-drive data directory (#995). Lattice does not
+ * place an index here — see {@link latticeSensorRelativeDirFor} — and the name is
+ * kept only so upstream's WSL diagnostics compile unchanged.
+ */
+export declare const WSL_LATTICE_SENSOR_DIR: string;
 /** Stable repository-relative owner path. It deliberately has no legacy override. */
 export declare function latticeSensorRelativeDir(): string;
 /** Repository-relative sensor state path. */
 export declare const LATTICE_SENSOR_DIR: string;
 /** Lattice owns `.lattice`; source extraction and watching never descend into it. */
 export declare function isLatticeStateDir(name: string): boolean;
+/**
+ * The data directory for one project. Upstream picks a WSL-only sibling for a
+ * project on a Windows drive (#995); Lattice keeps the single fixed owner path
+ * on every host, because `.lattice/` is Lattice's state root and other Lattice
+ * components address the sensor index by that path. The WSL factory lane is
+ * retired, and a WSL user sharing a tree with Windows-native Lattice must run
+ * only one of them against it.
+ */
+export declare function latticeSensorRelativeDirFor(_projectRoot: string): string;
 /** Absolute sensor state directory for a project. */
 export declare function getLatticeSensorDir(projectRoot: string): string;
 /**
- * Check if a project has been initialized with LatticeSensor
- * Requires both .lattice/sensor/ directory AND sensor.db to exist
+ * Check if a project has been initialized with LatticeSensor.
+ *
+ * Requires `.lattice/sensor/sensor.db` to exist AND to carry the lattice sensor
+ * schema. A file that merely exists — empty, or a SQLite database with no
+ * tables, as an interrupted `init` or a stray `touch` leaves behind — used to
+ * count as initialized, so one such file in an ANCESTOR directory (worst
+ * case: `$HOME`) captured the upward resolution of every project beneath it
+ * and made their real indexes unreachable (#1895).
+ *
+ * The probe is cheap and gated so hot callers (the prompt hook, MCP root
+ * resolution on every call) pay one `stat`: file size, then a read-only
+ * SQLite open with a single `sqlite_master` lookup — memoized per path +
+ * mtime + size so an unchanged db is never reopened. A database that cannot
+ * be inspected counts as initialized (see probeSchema) — only a proven-absent
+ * schema, or a file SQLite refuses as not a database, says no.
  */
 export declare function isInitialized(projectRoot: string): boolean;
+/**
+ * `sensor.db` exists at `projectRoot` but does not carry the schema, and
+ * `init` can add it in place: an empty file, or a SQLite database without the
+ * lattice sensor tables (#1895). A file that is not SQLite at all is NOT this case —
+ * see {@link hasForeignDbFile}.
+ */
+export declare function hasSchemalessDb(projectRoot: string): boolean;
+/**
+ * `sensor.db` exists at `projectRoot` and is not a SQLite database (no
+ * header magic): SQLite refuses to open it, so `init` cannot rebuild it in
+ * place. The caller must say so rather than promise a repair; nothing here
+ * deletes the file.
+ */
+export declare function hasForeignDbFile(projectRoot: string): boolean;
 /**
  * Find the nearest parent directory containing .lattice/sensor/
  *
@@ -36,6 +84,25 @@ export declare function isInitialized(projectRoot: string): boolean;
  * The returned string is a human phrase that slots into "… looks like {reason}".
  */
 export declare function unsafeIndexRootReason(projectRoot: string): string | null;
+/**
+ * `dev:ino` for a path, or null if it can't be stat'd or the platform doesn't
+ * report a usable inode. Read as bigints: WSL DrvFs (`/mnt/c`) reports inodes
+ * above 2^53, where a plain number rounds nearby inodes onto one value. Windows
+ * st_ino is unreliable across handle reopens, so we deliberately return null
+ * there — the deleted-but-open-inode hazard this guards (#925) is a POSIX
+ * file-semantics issue that doesn't arise on Windows (an open file can't be
+ * unlinked).
+ */
+export declare function statInode(p: string): string | null;
+/**
+ * Whether two resolved index roots are one index spelled two ways — a symlinked
+ * checkout, or a case-variant on a case-insensitive mount (macOS, NTFS, WSL
+ * DrvFs `/mnt/c`), where `realpathSync` keeps the caller's casing (#1057).
+ * Compares the identity of both data directories as they are NOW, so an inode
+ * reused after a delete can't match: the deleted root no longer stats. Windows
+ * has no usable inode, so it compares the on-disk-cased native realpaths.
+ */
+export declare function isSameIndexRoot(a: string, b: string): boolean;
 export declare function findNearestLatticeSensorRoot(startPath: string): string | null;
 /**
  * Indexed sub-project roots beneath `root` (bounded breadth-first scan). For
@@ -49,6 +116,35 @@ export declare function findIndexedSubprojectRoots(root: string, opts?: {
     maxDepth?: number;
     max?: number;
 }): string[];
+/** Result of {@link resolveServerRoot}. */
+export interface ServerRootResolution {
+    /** The project root to serve as the default, or null when none resolved. */
+    root: string | null;
+    /** True when `root` was adopted from the down-scan rather than the up-walk. */
+    viaSubScan: boolean;
+    /**
+     * Indexed sub-projects the down-scan saw when it ran but could NOT adopt
+     * (zero or several candidates). Empty when the up-walk resolved or the scan
+     * was skipped. Callers surface these so "no default project" errors can say
+     * what IS reachable (#1607).
+     */
+    candidates: string[];
+}
+/**
+ * Resolve the project root an MCP server should serve as its DEFAULT project
+ * (#1606). Up-walk first (`findNearestLatticeSensorRoot` — the common case, and
+ * cheap). When nothing is indexed at or above `searchFrom`, run the bounded
+ * sub-project down-scan `planFrontload` already uses, behind the workspace
+ * gate above: EXACTLY ONE indexed sub-project is unambiguous and is adopted
+ * as the root; zero or several yield no root, with the candidates carried so
+ * the caller can name them instead of failing silently (#1607).
+ *
+ * `opts.subprojectScan: false` skips the down-scan entirely (the per-tool-call
+ * retry path throttles it; the up-walk always runs).
+ */
+export declare function resolveServerRoot(searchFrom: string, opts?: {
+    subprojectScan?: boolean;
+}): ServerRootResolution;
 /**
  * Does `prompt` contain an explicit structural keyword? A keyword is a strong,
  * self-contained signal, so the front-load hook fires on it directly — no graph
@@ -85,6 +181,26 @@ export declare function extractCodeTokens(prompt: string): string[];
  * non-candidate prompt ("fix this typo", in any language) stays a zero-cost no-op.
  */
 export declare function isStructuralPrompt(prompt: string): boolean;
+/**
+ * Claude Code persists `UserPromptSubmit` hook stdout above this many
+ * characters to a file and shows the model a ~2 KB preview instead (#1694).
+ * Measured on Claude Code 2.1.261; documented in the hooks reference as a
+ * 10,000-character cap on hook output strings.
+ */
+export declare const CLAUDE_CODE_INLINE_HOOK_OUTPUT_LIMIT = 10000;
+/**
+ * Max characters of explore text injected by `lattice sensor prompt-hook` before
+ * truncation. Must stay under {@link CLAUDE_CODE_INLINE_HOOK_OUTPUT_LIMIT} so
+ * the host delivers the payload inline. 9,000 leaves ~1k for the
+ * `<lattice_sensor_context>` wrapper and the `projectPath` nudge lines appended
+ * after the cap is applied.
+ */
+export declare const PROMPT_HOOK_INJECTION_MAX = 9000;
+/**
+ * Cap explore text for the prompt-hook injection, preserving the existing
+ * "call lattice_sensor_explore for the rest" notice when truncated.
+ */
+export declare function capPromptHookInjection(text: string, max?: number): string;
 /**
  * What the front-load hook should do for a prompt issued from a directory.
  */
@@ -144,4 +260,12 @@ export declare function validateDirectory(projectRoot: string): {
     valid: boolean;
     errors: string[];
 };
+/**
+ * Claude Code injects `<task-notification>…</task-notification>` blocks as
+ * `user` messages when a background agent finishes, and UserPromptSubmit
+ * hooks receive them exactly like typed prompts (#1832). The whole prompt
+ * must be that single envelope; a user question that merely mentions the
+ * marker is still a prompt.
+ */
+export declare function isTaskNotification(prompt: string): boolean;
 //# sourceMappingURL=directory.d.ts.map

package/sensor/dist/directory.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"directory.d.ts","sourceRoot":"","sources":["../src/directory.ts"],"names":[],"mappings":"AAAA,yDAAyD;AASzD,qFAAqF;AACrF,wBAAgB,wBAAwB,IAAI,MAAM,CAEjD;AAED,6CAA6C;AAC7C,eAAO,MAAM,kBAAkB,QAA6B,CAAC;AAE7D,qFAAqF;AACrF,wBAAgB,iBAAiB,CAAC,IAAI,EAAE,MAAM,GAAG,OAAO,CAEvD;AAED,qDAAqD;AACrD,wBAAgB,mBAAmB,CAAC,WAAW,EAAE,MAAM,GAAG,MAAM,CAE/D;AAED;;;GAGG;AACH,wBAAgB,aAAa,CAAC,WAAW,EAAE,MAAM,GAAG,OAAO,CAQ1D;AAED;;;;;;;;GAQG;AACH;;;;;;;;;;;;;GAaG;AACH,wBAAgB,qBAAqB,CAAC,WAAW,EAAE,MAAM,GAAG,MAAM,GAAG,IAAI,CA8BxE;AAED,wBAAgB,4BAA4B,CAAC,SAAS,EAAE,MAAM,GAAG,MAAM,GAAG,IAAI,CAmB7E;AA2BD;;;;;;;GAOG;AACH,wBAAgB,0BAA0B,CACxC,IAAI,EAAE,MAAM,EACZ,IAAI,GAAE;IAAE,QAAQ,CAAC,EAAE,MAAM,CAAC;IAAC,GAAG,CAAC,EAAE,MAAM,CAAA;CAAO,GAC7C,MAAM,EAAE,CAmBV;AAsND;;;;;;;;;GASG;AACH,wBAAgB,oBAAoB,CAAC,MAAM,EAAE,MAAM,GAAG,OAAO,CAK5D;AAED;;;;;;;;;;;;;GAaG;AACH,wBAAgB,iBAAiB,CAAC,MAAM,EAAE,MAAM,GAAG,MAAM,EAAE,CAkB1D;AAED;;;;;;;;GAQG;AACH,wBAAgB,kBAAkB,CAAC,MAAM,EAAE,MAAM,GAAG,OAAO,CAE1D;AAED;;GAEG;AACH,MAAM,WAAW,aAAa;IAC5B;;yEAEqE;IACrE,WAAW,EAAE,MAAM,GAAG,IAAI,CAAC;IAC3B;;6EAEyE;IACzE,aAAa,EAAE,MAAM,EAAE,CAAC;IACxB;;oEAEgE;IAChE,UAAU,EAAE,OAAO,CAAC;CACrB;AAED;;;;;;;;;;;;GAYG;AACH,wBAAgB,aAAa,CAAC,GAAG,EAAE,MAAM,EAAE,MAAM,EAAE,MAAM,GAAG,aAAa,CAwCxE;AAyDD;;;GAGG;AACH,wBAAgB,eAAe,CAAC,WAAW,EAAE,MAAM,GAAG,IAAI,CAgBzD;AAED;;GAEG;AACH,wBAAgB,eAAe,CAAC,WAAW,EAAE,MAAM,GAAG,IAAI,CAuBzD;AAED;;GAEG;AACH,wBAAgB,qBAAqB,CAAC,WAAW,EAAE,MAAM,GAAG,MAAM,EAAE,CA8BnE;AAED;;GAEG;AACH,wBAAgB,gBAAgB,CAAC,WAAW,EAAE,MAAM,GAAG,MAAM,CA+B5D;AAED;;GAEG;AACH,wBAAgB,kBAAkB,CAAC,WAAW,EAAE,MAAM,EAAE,UAAU,EAAE,MAAM,GAAG,MAAM,CAYlF;AAED;;GAEG;AACH,wBAAgB,iBAAiB,CAAC,WAAW,EAAE,MAAM,GAAG;IACtD,KAAK,EAAE,OAAO,CAAC;IACf,MAAM,EAAE,MAAM,EAAE,CAAC;CAClB,CA6BA"}
+{"version":3,"file":"directory.d.ts","sourceRoot":"","sources":["../src/directory.ts"],"names":[],"mappings":"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"}

package/sensor/dist/directory.js

@@ -34,17 +34,24 @@ var __importStar = (this && this.__importStar) || (function () {
     };
 })();
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.LATTICE_SENSOR_DIR = void 0;
+exports.PROMPT_HOOK_INJECTION_MAX = exports.CLAUDE_CODE_INLINE_HOOK_OUTPUT_LIMIT = exports.LATTICE_SENSOR_DIR = exports.WSL_LATTICE_SENSOR_DIR = exports.DEFAULT_LATTICE_SENSOR_DIR = void 0;
 exports.latticeSensorRelativeDir = latticeSensorRelativeDir;
 exports.isLatticeStateDir = isLatticeStateDir;
+exports.latticeSensorRelativeDirFor = latticeSensorRelativeDirFor;
 exports.getLatticeSensorDir = getLatticeSensorDir;
 exports.isInitialized = isInitialized;
+exports.hasSchemalessDb = hasSchemalessDb;
+exports.hasForeignDbFile = hasForeignDbFile;
 exports.unsafeIndexRootReason = unsafeIndexRootReason;
+exports.statInode = statInode;
+exports.isSameIndexRoot = isSameIndexRoot;
 exports.findNearestLatticeSensorRoot = findNearestLatticeSensorRoot;
 exports.findIndexedSubprojectRoots = findIndexedSubprojectRoots;
+exports.resolveServerRoot = resolveServerRoot;
 exports.hasStructuralKeyword = hasStructuralKeyword;
 exports.extractCodeTokens = extractCodeTokens;
 exports.isStructuralPrompt = isStructuralPrompt;
+exports.capPromptHookInjection = capPromptHookInjection;
 exports.planFrontload = planFrontload;
 exports.createDirectory = createDirectory;
 exports.removeDirectory = removeDirectory;
@@ -52,11 +59,24 @@ exports.listDirectoryContents = listDirectoryContents;
 exports.getDirectorySize = getDirectorySize;
 exports.ensureSubdirectory = ensureSubdirectory;
 exports.validateDirectory = validateDirectory;
+exports.isTaskNotification = isTaskNotification;
 const fs = __importStar(require("fs"));
 const os = __importStar(require("os"));
 const path = __importStar(require("path"));
 const LATTICE_STATE_DIR = '.lattice';
 const SENSOR_STATE_DIR = 'sensor';
+/**
+ * The per-project data directory, as upstream's name for it. Lattice has one
+ * fixed path (no `LATTICE_SENSOR_DIR` override, no per-host variant), so this is
+ * {@link latticeSensorRelativeDir} under the name upstream code imports.
+ */
+exports.DEFAULT_LATTICE_SENSOR_DIR = path.join(LATTICE_STATE_DIR, SENSOR_STATE_DIR);
+/**
+ * Upstream's WSL-on-a-Windows-drive data directory (#995). Lattice does not
+ * place an index here — see {@link latticeSensorRelativeDirFor} — and the name is
+ * kept only so upstream's WSL diagnostics compile unchanged.
+ */
+exports.WSL_LATTICE_SENSOR_DIR = `${exports.DEFAULT_LATTICE_SENSOR_DIR}-wsl`;
 /** Stable repository-relative owner path. It deliberately has no legacy override. */
 function latticeSensorRelativeDir() {
     return path.join(LATTICE_STATE_DIR, SENSOR_STATE_DIR);
@@ -67,13 +87,37 @@ exports.LATTICE_SENSOR_DIR = latticeSensorRelativeDir();
 function isLatticeStateDir(name) {
     return name === LATTICE_STATE_DIR;
 }
+/**
+ * The data directory for one project. Upstream picks a WSL-only sibling for a
+ * project on a Windows drive (#995); Lattice keeps the single fixed owner path
+ * on every host, because `.lattice/` is Lattice's state root and other Lattice
+ * components address the sensor index by that path. The WSL factory lane is
+ * retired, and a WSL user sharing a tree with Windows-native Lattice must run
+ * only one of them against it.
+ */
+function latticeSensorRelativeDirFor(_projectRoot) {
+    return latticeSensorRelativeDir();
+}
 /** Absolute sensor state directory for a project. */
 function getLatticeSensorDir(projectRoot) {
     return path.join(projectRoot, LATTICE_STATE_DIR, SENSOR_STATE_DIR);
 }
 /**
- * Check if a project has been initialized with LatticeSensor
- * Requires both .lattice/sensor/ directory AND sensor.db to exist
+ * Check if a project has been initialized with LatticeSensor.
+ *
+ * Requires `.lattice/sensor/sensor.db` to exist AND to carry the lattice sensor
+ * schema. A file that merely exists — empty, or a SQLite database with no
+ * tables, as an interrupted `init` or a stray `touch` leaves behind — used to
+ * count as initialized, so one such file in an ANCESTOR directory (worst
+ * case: `$HOME`) captured the upward resolution of every project beneath it
+ * and made their real indexes unreachable (#1895).
+ *
+ * The probe is cheap and gated so hot callers (the prompt hook, MCP root
+ * resolution on every call) pay one `stat`: file size, then a read-only
+ * SQLite open with a single `sqlite_master` lookup — memoized per path +
+ * mtime + size so an unchanged db is never reopened. A database that cannot
+ * be inspected counts as initialized (see probeSchema) — only a proven-absent
+ * schema, or a file SQLite refuses as not a database, says no.
  */
 function isInitialized(projectRoot) {
     const sensorDir = getLatticeSensorDir(projectRoot);
@@ -82,7 +126,102 @@ function isInitialized(projectRoot) {
     }
     // Must have sensor.db, not just .lattice/sensor folder
     const dbPath = path.join(sensorDir, 'sensor.db');
-    return fs.existsSync(dbPath);
+    let st;
+    try {
+        st = fs.statSync(dbPath);
+    }
+    catch {
+        return false;
+    }
+    return hasLatticeSensorSchema(dbPath, st);
+}
+/**
+ * `sensor.db` exists at `projectRoot` but does not carry the schema, and
+ * `init` can add it in place: an empty file, or a SQLite database without the
+ * lattice sensor tables (#1895). A file that is not SQLite at all is NOT this case —
+ * see {@link hasForeignDbFile}.
+ */
+function hasSchemalessDb(projectRoot) {
+    const dbPath = path.join(getLatticeSensorDir(projectRoot), 'sensor.db');
+    let st;
+    try {
+        st = fs.statSync(dbPath);
+    }
+    catch {
+        return false;
+    }
+    if (!st.isFile() || isInitialized(projectRoot))
+        return false;
+    return st.size === 0 || probeSchema(dbPath) === 'no-schema';
+}
+/**
+ * `sensor.db` exists at `projectRoot` and is not a SQLite database (no
+ * header magic): SQLite refuses to open it, so `init` cannot rebuild it in
+ * place. The caller must say so rather than promise a repair; nothing here
+ * deletes the file.
+ */
+function hasForeignDbFile(projectRoot) {
+    const dbPath = path.join(getLatticeSensorDir(projectRoot), 'sensor.db');
+    let st;
+    try {
+        st = fs.statSync(dbPath);
+    }
+    catch {
+        return false;
+    }
+    return st.isFile() && st.size > 0 && probeSchema(dbPath) === 'not-sqlite';
+}
+/** A SQLite file header is 100 bytes; anything shorter cannot hold a schema. */
+const SQLITE_HEADER_SIZE = 100;
+/** SQLITE_NOTADB: SQLite read the file and it is not a database. */
+const SQLITE_NOTADB = 26;
+const schemaProbeCache = new Map();
+function hasLatticeSensorSchema(dbPath, st) {
+    if (!st.isFile() || st.size < SQLITE_HEADER_SIZE)
+        return false;
+    const cached = schemaProbeCache.get(dbPath);
+    if (cached && cached.mtimeMs === st.mtimeMs && cached.size === st.size)
+        return cached.ok;
+    const probe = probeSchema(dbPath);
+    const ok = probe === 'schema' || probe === 'unknown';
+    schemaProbeCache.set(dbPath, { mtimeMs: st.mtimeMs, size: st.size, ok });
+    return ok;
+}
+/**
+ * What `sensor.db` holds, asked of SQLite itself through a read-only
+ * connection: the lattice sensor schema, a database without it, not a database at
+ * all (SQLITE_NOTADB), or `unknown` — locked, busy, a WAL db in a directory we
+ * cannot create `-shm` in (read-only checkout, mount, another user's tree),
+ * disk I/O. Callers treat `unknown` as initialized: the pre-existing behaviour
+ * for a database we cannot inspect.
+ *
+ * The file is never read through a descriptor of our own, not even for its
+ * 16-byte header. Closing ANY descriptor on a database file drops every POSIX
+ * lock this process holds on it, including those of a connection it already
+ * has open (sqlite.org/howtocorrupt.html §2.2.1) — and the MCP server resolves
+ * projects through isInitialized on every call while it holds the index as
+ * its writer. SQLite's own connections share one lock table per file, so a
+ * second connection opened and closed here leaves the first one's locks alone.
+ */
+function probeSchema(dbPath) {
+    // eslint-disable-next-line @typescript-eslint/no-require-imports
+    const { DatabaseSync } = require('node:sqlite');
+    let db = null;
+    try {
+        db = new DatabaseSync(dbPath, { readOnly: true });
+        const row = db.prepare("SELECT 1 AS ok FROM sqlite_master WHERE type = 'table' AND name = 'nodes'").get();
+        return row !== undefined ? 'schema' : 'no-schema';
+    }
+    catch (error) {
+        return error?.errcode === SQLITE_NOTADB ? 'not-sqlite' : 'unknown';
+    }
+    finally {
+        // Never hold the handle: Windows file locking would block the owner.
+        try {
+            db?.close();
+        }
+        catch { /* already closed */ }
+    }
 }
 /**
  * Find the nearest parent directory containing .lattice/sensor/
@@ -135,6 +274,48 @@ function unsafeIndexRootReason(projectRoot) {
     }
     return null;
 }
+/**
+ * `dev:ino` for a path, or null if it can't be stat'd or the platform doesn't
+ * report a usable inode. Read as bigints: WSL DrvFs (`/mnt/c`) reports inodes
+ * above 2^53, where a plain number rounds nearby inodes onto one value. Windows
+ * st_ino is unreliable across handle reopens, so we deliberately return null
+ * there — the deleted-but-open-inode hazard this guards (#925) is a POSIX
+ * file-semantics issue that doesn't arise on Windows (an open file can't be
+ * unlinked).
+ */
+function statInode(p) {
+    if (process.platform === 'win32')
+        return null;
+    try {
+        const s = fs.statSync(p, { bigint: true });
+        return `${s.dev}:${s.ino}`;
+    }
+    catch {
+        return null;
+    }
+}
+/**
+ * Whether two resolved index roots are one index spelled two ways — a symlinked
+ * checkout, or a case-variant on a case-insensitive mount (macOS, NTFS, WSL
+ * DrvFs `/mnt/c`), where `realpathSync` keeps the caller's casing (#1057).
+ * Compares the identity of both data directories as they are NOW, so an inode
+ * reused after a delete can't match: the deleted root no longer stats. Windows
+ * has no usable inode, so it compares the on-disk-cased native realpaths.
+ */
+function isSameIndexRoot(a, b) {
+    if (a === b)
+        return true;
+    if (process.platform === 'win32') {
+        try {
+            return fs.realpathSync.native(getLatticeSensorDir(a)) === fs.realpathSync.native(getLatticeSensorDir(b));
+        }
+        catch {
+            return false;
+        }
+    }
+    const id = statInode(getLatticeSensorDir(a));
+    return id !== null && id === statInode(getLatticeSensorDir(b));
+}
 function findNearestLatticeSensorRoot(startPath) {
     let current = path.resolve(startPath);
     const root = path.parse(current).root;
@@ -183,6 +364,9 @@ function escapeRegExp(s) {
  * never turns into a full-tree crawl on a large repo.
  */
 function findIndexedSubprojectRoots(root, opts = {}) {
+    // A stray workspace manifest must not enable scanning home or broader roots (#1454).
+    if (unsafeIndexRootReason(root) !== null)
+        return [];
     const maxDepth = opts.maxDepth ?? 4;
     const max = opts.max ?? 64;
     const out = [];
@@ -214,6 +398,57 @@ function findIndexedSubprojectRoots(root, opts = {}) {
     walk(root, 1);
     return out;
 }
+/**
+ * Whether `base` is a plausible workspace root for the sub-project down-scan.
+ * Mirrors `planFrontload`'s manifest gate, widened to accept a bare `.git`
+ * entry — the #1606 shape is a workspace container holding only agent config
+ * and a `.git`, with every build manifest living in the indexed children. The
+ * user's home directory and the filesystem root are never eligible: a stray
+ * manifest there must not turn server startup into a scan that could adopt an
+ * unrelated project (#1454 documents that failure mode for the prompt-hook).
+ */
+function eligibleForSubprojectScan(base) {
+    if (base === path.parse(base).root)
+        return false;
+    let home = null;
+    try {
+        home = os.homedir();
+    }
+    catch {
+        home = null;
+    }
+    if (home && (base === home || base === path.resolve(home)))
+        return false;
+    if (looksLikeProjectRoot(base))
+        return true;
+    return fs.existsSync(path.join(base, '.git'));
+}
+/**
+ * Resolve the project root an MCP server should serve as its DEFAULT project
+ * (#1606). Up-walk first (`findNearestLatticeSensorRoot` — the common case, and
+ * cheap). When nothing is indexed at or above `searchFrom`, run the bounded
+ * sub-project down-scan `planFrontload` already uses, behind the workspace
+ * gate above: EXACTLY ONE indexed sub-project is unambiguous and is adopted
+ * as the root; zero or several yield no root, with the candidates carried so
+ * the caller can name them instead of failing silently (#1607).
+ *
+ * `opts.subprojectScan: false` skips the down-scan entirely (the per-tool-call
+ * retry path throttles it; the up-walk always runs).
+ */
+function resolveServerRoot(searchFrom, opts = {}) {
+    const up = findNearestLatticeSensorRoot(searchFrom);
+    if (up)
+        return { root: up, viaSubScan: false, candidates: [] };
+    if (opts.subprojectScan === false)
+        return { root: null, viaSubScan: false, candidates: [] };
+    const base = path.resolve(searchFrom);
+    if (!eligibleForSubprojectScan(base))
+        return { root: null, viaSubScan: false, candidates: [] };
+    const subs = findIndexedSubprojectRoots(base);
+    if (subs.length === 1)
+        return { root: subs[0], viaSubScan: true, candidates: subs };
+    return { root: null, viaSubScan: false, candidates: subs };
+}
 /**
  * Unicode-aware word-boundary emulation for the keyword lists below. JS's `\b`
  * is ASCII-only — it fires only at `[A-Za-z0-9_]` edges — so it can never bound
@@ -229,8 +464,9 @@ const NOT_WORD_AFTER = /(?![\p{L}\p{N}_])/u.source;
  * Structural keywords matched as EXACT words (boundary on both sides): short
  * or ambiguous tokens where prefix matching would false-positive ("flow" in
  * "flower", "path" in "pathological"). Grouped by language; a term appears once
- * even when several languages share it ("como" is Portuguese for how AND
- * unaccented-typed Spanish "cómo").
+ * even when several languages share it. Ambiguous everyday words like PT/ES
+ * "como" and DE "wie" are excluded: the hook instead requires another strong
+ * keyword, a verified code token, or indexed prose segments (#1654).
  */
 const STRUCTURAL_WORDS = [
     // English — the pre-#1126 list minus what moved to STRUCTURAL_STEMS: the
@@ -239,17 +475,16 @@ const STRUCTURAL_WORDS = [
     'how', 'where', 'tracing', 'flows?', 'paths?', 'reach(?:es|ed)?', 'wired?', 'breaks?', 'why does',
     // French (où=where, flux=flow, chemin=path, casse=breaks)
     'comment', 'où', 'flux', 'chemins?', 'casse',
-    // Spanish (cómo/como=how, dónde/donde=where, flujo=flow, ruta/camino=path,
+    // Spanish (cómo=how, dónde/donde=where, flujo=flow, ruta/camino=path,
     // rompe=breaks, llaman / quién llama = call(s) — bare "llama" is excluded:
     // it's also the animal/model name in English prompts)
     'cómo', 'dónde', 'donde', 'flujos?', 'rutas?', 'caminos?', 'rompe', 'llaman', 'quién llama', 'quien llama',
-    // Portuguese (como=how — also covers unaccented Spanish; onde=where,
-    // fluxo=flow, caminho=path)
-    'como', 'onde', 'fluxos?', 'caminhos?',
-    // German (wie=how, wo/woher/wohin=where, Pfad=path, Fluss/Ablauf=flow,
+    // Portuguese (onde=where, fluxo=flow, caminho=path)
+    'onde', 'fluxos?', 'caminhos?',
+    // German (wo/woher/wohin=where, Pfad=path, Fluss/Ablauf=flow,
     // bricht/kaputt=breaks, ruft=calls, hängt=depends — "hängt … von X ab"
     // splits the separable verb "abhängen", so the "abhäng" stem can't catch it)
-    'wie', 'wo', 'woher', 'wohin', 'pfade?', 'fluss', 'ablauf', 'bricht', 'kaputt', 'ruft', 'hängt',
+    'wo', 'woher', 'wohin', 'pfade?', 'fluss', 'ablauf', 'bricht', 'kaputt', 'ruft', 'hängt',
     // Italian (dove=where, flusso=flow, percorso/i=path)
     'dove', 'flusso', 'percors[oi]',
     // Russian (как=how, где=where, путь/пути=path, работает=works)
@@ -485,6 +720,30 @@ function extractCodeTokens(prompt) {
 function isStructuralPrompt(prompt) {
     return hasStructuralKeyword(prompt) || extractCodeTokens(prompt).length > 0;
 }
+/**
+ * Claude Code persists `UserPromptSubmit` hook stdout above this many
+ * characters to a file and shows the model a ~2 KB preview instead (#1694).
+ * Measured on Claude Code 2.1.261; documented in the hooks reference as a
+ * 10,000-character cap on hook output strings.
+ */
+exports.CLAUDE_CODE_INLINE_HOOK_OUTPUT_LIMIT = 10_000;
+/**
+ * Max characters of explore text injected by `lattice sensor prompt-hook` before
+ * truncation. Must stay under {@link CLAUDE_CODE_INLINE_HOOK_OUTPUT_LIMIT} so
+ * the host delivers the payload inline. 9,000 leaves ~1k for the
+ * `<lattice_sensor_context>` wrapper and the `projectPath` nudge lines appended
+ * after the cap is applied.
+ */
+exports.PROMPT_HOOK_INJECTION_MAX = 9_000;
+/**
+ * Cap explore text for the prompt-hook injection, preserving the existing
+ * "call lattice_sensor_explore for the rest" notice when truncated.
+ */
+function capPromptHookInjection(text, max = exports.PROMPT_HOOK_INJECTION_MAX) {
+    return text.length > max
+        ? `${text.slice(0, max)}\n…(truncated; call lattice_sensor_explore for the rest)`
+        : text;
+}
 /**
  * Decide what the front-load hook injects for a `prompt` issued from `cwd`,
  * shaped by where the `.lattice/sensor/` index(es) actually are:
@@ -604,10 +863,10 @@ function ensureGitignore(gitignorePath) {
  */
 function createDirectory(projectRoot) {
     const sensorDir = getLatticeSensorDir(projectRoot);
-    const dbPath = path.join(sensorDir, 'sensor.db');
-    // Only throw if LatticeSensor is actually initialized (db exists)
-    // .lattice/sensor/ folder alone is fine
-    if (fs.existsSync(dbPath)) {
+    // Only throw if LatticeSensor is actually initialized (db with a schema).
+    // .lattice/sensor/ folder alone — or a schema-less sensor.db left by an
+    // interrupted init (#1895) — is fine: initialize() adds the schema to it.
+    if (isInitialized(projectRoot)) {
         throw new Error(`LatticeSensor already initialized in ${projectRoot}`);
     }
     // Create main directory (if it doesn't exist)
@@ -738,4 +997,14 @@ function validateDirectory(projectRoot) {
         errors,
     };
 }
+/**
+ * Claude Code injects `<task-notification>…</task-notification>` blocks as
+ * `user` messages when a background agent finishes, and UserPromptSubmit
+ * hooks receive them exactly like typed prompts (#1832). The whole prompt
+ * must be that single envelope; a user question that merely mentions the
+ * marker is still a prompt.
+ */
+function isTaskNotification(prompt) {
+    return /^\s*<task-notification>[\s\S]*<\/task-notification>\s*$/.test(prompt);
+}
 //# sourceMappingURL=directory.js.map