@plebeiantech/lat.md 0.12.3-fork.12 → 0.12.3-fork.14

package/dist/src/cli/expand.d.ts

@@ -1,8 +1,7 @@
-import { type Section } from '../lattice.js';
 import type { CmdContext, CmdResult } from '../context.js';
 /**
  * Resolve [[refs]] in text and return the expanded output.
  * Returns null if there are no wiki links, or if resolution fails.
  */
-export declare function expandPrompt(ctx: CmdContext, text: string, preloadedSections?: Section[]): Promise<string | null>;
+export declare function expandPrompt(ctx: CmdContext, text: string): Promise<string | null>;
 export declare function expandCommand(ctx: CmdContext, text: string): Promise<CmdResult>;

package/dist/src/cli/expand.js

@@ -1,6 +1,7 @@
 import { join, relative } from 'node:path';
-import { loadAllSections, findSections, } from '../lattice.js';
+import { findSections, } from '../lattice-model.js';
 import { UNTRUSTED_NOTICE, quoteUntrusted, cleanUntrustedId, } from '../untrusted.js';
+import { commandProjectAnalysis, commandProjectSession, } from '../project-analysis.js';
 const WIKI_LINK_RE = /\[\[([^\]]+)\]\]/g;
 function formatLocation(section, projectRoot) {
     const relPath = relative(process.cwd(), join(projectRoot, section.filePath));
@@ -10,17 +11,34 @@ function formatLocation(section, projectRoot) {
  * Resolve [[refs]] in text and return the expanded output.
  * Returns null if there are no wiki links, or if resolution fails.
  */
-export async function expandPrompt(ctx, text, preloadedSections) {
+export async function expandPrompt(ctx, text) {
     const refs = [...text.matchAll(WIKI_LINK_RE)];
     if (refs.length === 0)
         return null;
-    const allSections = preloadedSections ?? (await loadAllSections(ctx.latDir));
+    const { allSections } = await commandProjectAnalysis(ctx);
     const resolved = new Map();
+    const externalResolved = new Map();
+    const external = await commandProjectSession(ctx).external();
     const errors = [];
     for (const match of refs) {
         const target = match[1];
-        if (resolved.has(target))
+        if (resolved.has(target) || externalResolved.has(target))
             continue;
+        try {
+            if (external.parse(target)) {
+                externalResolved.set(target, await external.resolve(target));
+                continue;
+            }
+        }
+        catch (error) {
+            errors.push(error.message);
+            continue;
+        }
+        const unknownExternal = external.unknownTargetMessage(target);
+        if (unknownExternal) {
+            errors.push(unknownExternal);
+            continue;
+        }
         const matches = findSections(allSections, target);
         if (matches.length >= 1) {
             resolved.set(target, {
@@ -37,12 +55,21 @@ export async function expandPrompt(ctx, text, preloadedSections) {
         return null;
     // Replace [[refs]] inline
     let output = text.replace(WIKI_LINK_RE, (_match, target) => {
+        if (externalResolved.has(target))
+            return `[[${target}]]`;
         const ref = resolved.get(target);
         return `[[${cleanUntrustedId(ref.best.section.id)}]]`;
     });
     // Append context block as nested outliner
     output += '\n\n<lat-context>\n';
     output += UNTRUSTED_NOTICE + '\n';
+    for (const [target, value] of externalResolved) {
+        output += `* \`[[${target}]]\` is referring to:\n`;
+        output += `  * ${value.source.repo} @ ${value.source.commit} via ${value.provider}\n`;
+        output += `    * ${value.target.repositoryPath}:${value.startLine}-${value.endLine}\n`;
+        for (const line of value.content.split('\n'))
+            output += `    | ${line}\n`;
+    }
     for (const ref of resolved.values()) {
         const isExact = ref.best.reason === 'exact match' ||
             ref.best.reason.startsWith('file stem expanded');
@@ -73,9 +100,29 @@ export async function expandCommand(ctx, text) {
             return { output: text };
         }
         // Resolution failed — find which ref is broken
-        const allSections = await loadAllSections(ctx.latDir);
+        const { allSections } = await commandProjectAnalysis(ctx);
+        const external = await commandProjectSession(ctx).external();
         for (const match of refs) {
             const target = match[1];
+            try {
+                if (external.parse(target)) {
+                    await external.resolve(target);
+                    continue;
+                }
+            }
+            catch (error) {
+                return {
+                    output: ctx.styler.red(error.message),
+                    isError: true,
+                };
+            }
+            const unknownExternal = external.unknownTargetMessage(target);
+            if (unknownExternal) {
+                return {
+                    output: ctx.styler.red(unknownExternal),
+                    isError: true,
+                };
+            }
             const matches = findSections(allSections, target);
             if (matches.length === 0) {
                 const s = ctx.styler;

package/dist/src/cli/external.d.ts

@@ -0,0 +1,11 @@
+import type { CmdContext, CmdResult } from '../context.js';
+export type ExternalAddOptions = {
+    commit?: string;
+    prefix?: string;
+    defaultFileExtension?: string;
+    strategy?: string;
+    fetchUrl?: string;
+};
+export declare function externalListCommand(ctx: CmdContext, json?: boolean): Promise<CmdResult>;
+export declare function externalShowCommand(ctx: CmdContext, query: string, json?: boolean): Promise<CmdResult>;
+export declare function externalAddCommand(ctx: CmdContext, handleValue: string | undefined, repoValue: string | undefined, options: ExternalAddOptions): Promise<CmdResult>;

package/dist/src/cli/external.js

@@ -0,0 +1,185 @@
+import { createInterface } from 'node:readline/promises';
+import { addCanonicalExternalSource, describeExternalSources, inferExternalFetchUrl, loadExternalSources, normalizeExternalDefaultFileExtension, normalizeExternalRepoUrl, parseExternalTarget, resolveExternalCommit, } from '../external-sources.js';
+import { selectMenu } from './select-menu.js';
+function shellArg(value) {
+    return /^[a-zA-Z0-9_./:@=-]+$/.test(value)
+        ? value
+        : `'${value.replaceAll("'", "'\\''")}'`;
+}
+function formatDescription(value) {
+    const lines = [
+        `${value.handle}`,
+        `  Repository: ${value.repo}`,
+        `  Commit: ${value.effectiveCommit}${value.effectiveCommit !== value.canonicalCommit ? ` (canonical: ${value.canonicalCommit})` : ''}`,
+        `  Strategy: ${value.effectiveStrategy}${value.effectiveStrategy !== value.strategy ? ` (canonical: ${value.strategy})` : ''}`,
+        `  Prefix: ${value.prefix || '(none)'}`,
+        `  Default file extension: ${value.defaultFileExtension || '(none)'}`,
+        `  Cache: ${value.cache ? `${value.cache.strategy} @ ${value.cache.commit}` : '(empty)'}`,
+    ];
+    if (value.fetchUrl)
+        lines.push(`  Fetch URL: ${value.fetchUrl}`);
+    if (value.localPath)
+        lines.push(`  Local path: ${value.localPath}`);
+    if (value.localError)
+        lines.push(`  Local error: ${value.localError}`);
+    lines.push('  Suggested checkout:');
+    for (const command of value.checkout) {
+        lines.push(`    ${[command.command, ...command.args].map(shellArg).join(' ')}`);
+    }
+    return lines.join('\n');
+}
+export async function externalListCommand(ctx, json = false) {
+    const snapshot = await loadExternalSources(ctx.latDir, ctx.projectRoot);
+    if (!snapshot.validCanonical) {
+        return {
+            output: snapshot.errors
+                .map((error) => `${error.file}: ${error.message}`)
+                .join('\n'),
+            isError: true,
+        };
+    }
+    const descriptions = describeExternalSources(ctx.latDir, snapshot);
+    return {
+        output: json
+            ? JSON.stringify(descriptions, null, 2)
+            : descriptions.length
+                ? descriptions.map(formatDescription).join('\n\n')
+                : 'No external sources configured',
+    };
+}
+export async function externalShowCommand(ctx, query, json = false) {
+    const snapshot = await loadExternalSources(ctx.latDir, ctx.projectRoot);
+    const colon = query.indexOf(':');
+    const handle = colon === -1 ? query : query.slice(0, colon);
+    const source = describeExternalSources(ctx.latDir, snapshot).find((item) => item.handle === handle);
+    if (!source) {
+        return {
+            output: `External source "${handle}" is not configured`,
+            isError: true,
+        };
+    }
+    let target = null;
+    if (colon !== -1) {
+        try {
+            target = parseExternalTarget(query, snapshot);
+        }
+        catch (error) {
+            return { output: error.message, isError: true };
+        }
+    }
+    const value = target
+        ? {
+            ...source,
+            target: target.identity,
+            repositoryPath: target.repositoryPath,
+        }
+        : source;
+    return {
+        output: json
+            ? JSON.stringify(value, null, 2)
+            : formatDescription(source) +
+                (target
+                    ? `\n  Target: ${target.identity}\n  Repository path: ${target.repositoryPath}`
+                    : ''),
+    };
+}
+async function question(rl, label, current) {
+    if (current)
+        return current;
+    const answer = (await rl.question(`${label}: `)).trim();
+    if (!answer)
+        throw new Error(`${label} is required`);
+    return answer;
+}
+export async function externalAddCommand(ctx, handleValue, repoValue, options) {
+    const interactive = !!process.stdin.isTTY;
+    if (!interactive &&
+        (!handleValue || !repoValue || !options.commit || !options.strategy)) {
+        return {
+            output: 'Non-interactive use requires handle, repo, --commit, and --strategy',
+            isError: true,
+        };
+    }
+    let rl = null;
+    const getReadline = () => {
+        rl ??= createInterface({ input: process.stdin, output: process.stdout });
+        return rl;
+    };
+    const closeReadline = () => {
+        rl?.close();
+        rl = null;
+    };
+    try {
+        const handle = await question(getReadline(), 'Handle', handleValue);
+        const repo = normalizeExternalRepoUrl(await question(getReadline(), 'Repository', repoValue));
+        const ref = await question(getReadline(), 'Commit or ref', options.commit);
+        const prefix = options.prefix ??
+            (interactive
+                ? (await getReadline().question('Prefix (optional): ')).trim()
+                : '');
+        const defaultFileExtensionValue = options.defaultFileExtension ??
+            (interactive
+                ? (await getReadline().question('Default file extension (optional): ')).trim()
+                : '');
+        const defaultFileExtension = defaultFileExtensionValue
+            ? normalizeExternalDefaultFileExtension(defaultFileExtensionValue)
+            : '';
+        let strategy = options.strategy;
+        if (!strategy && interactive) {
+            const inferred = inferExternalFetchUrl(repo);
+            // selectMenu reads raw keypresses directly. Detach readline first so it
+            // cannot consume the selection's Enter key or remain paused afterward.
+            closeReadline();
+            strategy =
+                (await selectMenu(inferred
+                    ? [
+                        {
+                            label: 'Fetch individual files (recommended)',
+                            value: 'fetch',
+                        },
+                        { label: 'Use a Lat-managed checkout', value: 'checkout' },
+                    ]
+                    : [
+                        {
+                            label: 'Use a Lat-managed checkout (recommended)',
+                            value: 'checkout',
+                        },
+                        { label: 'Fetch individual files', value: 'fetch' },
+                    ], 'How should Lat read this source?')) ?? undefined;
+        }
+        if (strategy !== 'fetch' && strategy !== 'checkout') {
+            return { output: 'strategy must be fetch or checkout', isError: true };
+        }
+        let fetchUrl = options.fetchUrl;
+        if (strategy === 'fetch' &&
+            !fetchUrl &&
+            !inferExternalFetchUrl(repo) &&
+            interactive) {
+            fetchUrl = await question(getReadline(), 'Fetch URL template');
+        }
+        const commit = await resolveExternalCommit(repo, ref);
+        if (interactive) {
+            const confirmation = (await getReadline().question(`Add external source "${handle}" at commit "${commit}" using "${strategy}"? [Y/n] `))
+                .trim()
+                .toLowerCase();
+            if (confirmation === 'n' || confirmation === 'no')
+                return { output: 'Aborted' };
+        }
+        await addCanonicalExternalSource(ctx.latDir, {
+            handle,
+            repo,
+            commit,
+            ...(prefix ? { prefix } : {}),
+            ...(defaultFileExtension ? { defaultFileExtension } : {}),
+            strategy: strategy,
+            ...(fetchUrl ? { fetchUrl } : {}),
+        });
+        return { output: `Added external source ${handle} at ${commit}` };
+    }
+    catch (error) {
+        return { output: error.message, isError: true };
+    }
+    finally {
+        closeReadline();
+    }
+}

package/dist/src/cli/fork-instructions.d.ts

@@ -1,3 +1,4 @@
+export declare const SKILL_FRONTMATTER = "---\nname: lat-md-conventions\ndescription: >-\n  Rules lat check enforces in this project: Di\u00E1taxis mode placement for every\n  lat.md/ document, mandatory @lat: code refs starting at the application\n  entrypoint, and test specs wired to their tests. Load alongside lat-md\n  whenever creating or editing files under lat.md/.\n---\n\n";
 export declare function readForkConventions(): string;
 /**
  * Replace the fork block in `content`, or append one when absent.

package/dist/src/cli/fork-instructions.js

@@ -17,7 +17,7 @@ import { findTemplatesDir } from './templates.js';
  *
  * Two shapes, because the destinations behave differently:
  *
- * - Always-loaded instruction files (`CLAUDE.md`, `AGENTS.md`,
+ * - Always-loaded instruction files (`CLAUDE.md`, `AGENTS.md`, `GEMINI.md`,
  *   `.github/copilot-instructions.md`) already carry upstream's
  *   `%% lat:begin %%` block, so this appends a *second* block under its own
  *   `%% lat-fork:begin %%` markers. Upstream's `appendTemplateSection` slices
@@ -42,6 +42,7 @@ function forkHashKey(relPath) {
 const BLOCK_TARGETS = [
     'CLAUDE.md',
     'AGENTS.md',
+    'GEMINI.md',
     '.github/copilot-instructions.md',
 ];
 /**
@@ -56,7 +57,7 @@ const SKILL_ROOTS = [
     '.codex/skills',
 ];
 const SKILL_NAME = 'lat-md-conventions';
-const SKILL_FRONTMATTER = `---
+export const SKILL_FRONTMATTER = `---
 name: ${SKILL_NAME}
 description: >-
   Rules lat check enforces in this project: Diátaxis mode placement for every

package/dist/src/cli/hook.d.ts

@@ -1 +1,27 @@
+/**
+ * Measure code vs `lat.md/` churn since HEAD, in lines. Combines tracked
+ * changes (`git diff HEAD --numstat`) with untracked files
+ * (`git ls-files --others --exclude-standard -z`). Counting untracked files is
+ * what makes a freshly scaffolded, never-committed `lat.md/` register as
+ * updated — otherwise its edits are invisible to `git diff HEAD` and the sync
+ * reminder fires on every turn until `lat.md/` is committed (issue #61).
+ * Both scans are scoped and made relative to `projectRoot`, so a Lat project
+ * nested in a larger worktree neither misses its own `lat.md/` paths nor counts
+ * changes from sibling projects.
+ * Outside a Git worktree both scans contribute zero churn by design: Git is
+ * optional, so the hook still validates the project but skips the sync ratio.
+ */
+export declare function analyzeDiff(projectRoot: string): {
+    codeLines: number;
+    latMdLines: number;
+};
+export type StopStatus = {
+    checkFailed: boolean;
+    totalErrors: number;
+    needsSync: boolean;
+    codeLines: number;
+    latMdLines: number;
+};
+export declare function getStopStatus(latDir: string): Promise<StopStatus>;
+export declare function formatStopReason({ checkFailed, totalErrors, needsSync, codeLines, latMdLines, }: StopStatus): string | null;
 export declare function hookCmd(agent: string, event: string): Promise<void>;

package/dist/src/cli/hook.js

@@ -1,17 +1,23 @@
 import { execSync } from 'node:child_process';
-import { dirname, extname } from 'node:path';
-import { findLatticeDir, loadAllSections, findSections, } from '../lattice.js';
+import { lstatSync, readFileSync } from 'node:fs';
+import { dirname, extname, join } from 'node:path';
+import { findLatticeDir } from '../project-discovery.js';
+import { findSections } from '../lattice-model.js';
 import { plainStyler } from '../context.js';
 import { expandPrompt } from './expand.js';
 import { runSearch } from './search.js';
+import { DEFAULT_SEARCH_LIMIT } from '../search/search.js';
 import { getSection, formatSectionOutput } from './section.js';
 import { checkMd, checkCodeRefs, checkIndex, checkSections } from './check.js';
+import { CheckRunContext } from './check-context.js';
+import { isSourceFileExtension } from '../source-formats.js';
+import { commandProjectAnalysis } from '../project-analysis.js';
 import { checkMode } from './check-mode.js';
-import { SOURCE_EXTENSIONS } from '../source-parser.js';
 import { federateTags, taggedDocsForFiles } from '../knowledge/index.js';
 import { loadSessionMarkers, saveSessionMarkers, } from '../knowledge/session.js';
 import { computeCommentReminder, } from './comment-reminder.js';
 import { handlePreToolUse } from './comment-guard.js';
+import { handleAntigravityHook } from '../fork/antigravity-hook.js';
 function outputPromptSubmit(context) {
     process.stdout.write(JSON.stringify({
         hookSpecificOutput: {
@@ -64,15 +70,15 @@ function makeHookCtx(latDir) {
         mode: 'cli',
     };
 }
-async function searchAndExpand(ctx, userPrompt, preloadedSections) {
+async function searchAndExpand(ctx, userPrompt) {
     let result;
     try {
         // Read-only: search an existing index but never build/update it here. A fresh
         // repo's first prompt must not trigger a full local embed pass — that's what
         // `lat search` / `lat reindex` are for. Returns no matches until then.
-        result = await runSearch(ctx.latDir, userPrompt, 5, undefined, {
+        result = await runSearch(ctx.latDir, userPrompt, DEFAULT_SEARCH_LIMIT, undefined, {
             buildIndex: false,
-            preloadedSections,
+            project: await commandProjectAnalysis(ctx),
         });
     }
     catch {
@@ -113,13 +119,14 @@ async function handleUserPromptSubmit() {
     const latDir = findLatticeDir();
     if (latDir && userPrompt) {
         const ctx = makeHookCtx(latDir);
-        // Loaded once and threaded through expansion, search, and federation
-        // below — each of those otherwise walks and parses the whole tree itself.
-        const allSections = await loadAllSections(latDir);
+        // Parsed once for expansion, search, and federation below. The analysis is
+        // memoised on `ctx`, so passing that one object everywhere is what keeps
+        // the three of them from walking and parsing the tree three times.
+        const { allSections } = await commandProjectAnalysis(ctx);
         // If the user prompt contains [[refs]], resolve them inline
         if (hasWikiLinks(userPrompt)) {
             try {
-                const expanded = await expandPrompt(ctx, userPrompt, allSections);
+                const expanded = await expandPrompt(ctx, userPrompt);
                 if (expanded) {
                     parts.push('', 'Expanded user prompt with resolved [[refs]]:', expanded);
                 }
@@ -134,7 +141,7 @@ async function handleUserPromptSubmit() {
         // Search for relevant sections and include their full content
         let searchFilePaths = [];
         try {
-            const searchContext = await searchAndExpand(ctx, userPrompt, allSections);
+            const searchContext = await searchAndExpand(ctx, userPrompt);
             searchFilePaths = searchContext.filePaths;
             if (searchContext.text) {
                 parts.push('', searchContext.text);
@@ -252,55 +259,116 @@ const DIFF_THRESHOLD = 5;
 const LATMD_RATIO = 0.05;
 /** If lat.md/ changes exceed this many lines, skip the ratio check entirely. */
 const LATMD_UPPER_THRESHOLD = 50;
-/** Run `git diff --numstat` and return { codeLines, latMdLines }. */
-function analyzeDiff(projectRoot) {
-    let output;
+function diffFileKind(file) {
+    if (file.startsWith('lat.md/'))
+        return 'latMd';
+    if (isSourceFileExtension(extname(file)))
+        return 'code';
+    return null;
+}
+/** Count a regular text file's lines as additions, matching Git numstat. */
+function countUntrackedFileLines(projectRoot, file) {
     try {
-        output = execSync('git diff HEAD --numstat', {
-            cwd: projectRoot,
-            encoding: 'utf-8',
-            timeout: 2000,
-        });
+        const path = join(projectRoot, file);
+        if (!lstatSync(path).isFile())
+            return 0;
+        const text = readFileSync(path, 'utf-8');
+        if (text.length === 0)
+            return 0;
+        return text.split('\n').length - (text.endsWith('\n') ? 1 : 0);
     }
     catch {
-        return { codeLines: 0, latMdLines: 0 };
+        return 0;
     }
+}
+/**
+ * Measure code vs `lat.md/` churn since HEAD, in lines. Combines tracked
+ * changes (`git diff HEAD --numstat`) with untracked files
+ * (`git ls-files --others --exclude-standard -z`). Counting untracked files is
+ * what makes a freshly scaffolded, never-committed `lat.md/` register as
+ * updated — otherwise its edits are invisible to `git diff HEAD` and the sync
+ * reminder fires on every turn until `lat.md/` is committed (issue #61).
+ * Both scans are scoped and made relative to `projectRoot`, so a Lat project
+ * nested in a larger worktree neither misses its own `lat.md/` paths nor counts
+ * changes from sibling projects.
+ * Outside a Git worktree both scans contribute zero churn by design: Git is
+ * optional, so the hook still validates the project but skips the sync ratio.
+ */
+export function analyzeDiff(projectRoot) {
     let codeLines = 0;
     let latMdLines = 0;
-    // Each line: "added\tremoved\tfile" (e.g. "42\t11\tsrc/cli/hook.ts")
-    for (const line of output.split('\n')) {
-        const parts = line.split('\t');
-        if (parts.length < 3)
-            continue;
-        const added = parseInt(parts[0], 10) || 0;
-        const removed = parseInt(parts[1], 10) || 0;
-        const file = parts[2];
-        const changed = added + removed;
-        if (file.startsWith('lat.md/')) {
+    const tally = (kind, changed) => {
+        if (kind === 'latMd') {
             latMdLines += changed;
         }
-        else if (SOURCE_EXTENSIONS.has(extname(file))) {
+        else {
             codeLines += changed;
         }
+    };
+    // Tracked changes vs HEAD. Throws when there is no HEAD yet (a repo with no
+    // commits) or no repo at all; the untracked scan below still runs.
+    try {
+        const output = execSync('git diff HEAD --numstat --relative -- .', {
+            cwd: projectRoot,
+            encoding: 'utf-8',
+            stdio: ['ignore', 'pipe', 'ignore'],
+        });
+        // Each line: "added\tremoved\tfile" (e.g. "42\t11\tsrc/cli/hook.ts")
+        for (const line of output.split('\n')) {
+            const parts = line.split('\t');
+            if (parts.length < 3)
+                continue;
+            const added = parseInt(parts[0], 10) || 0;
+            const removed = parseInt(parts[1], 10) || 0;
+            const kind = diffFileKind(parts[2]);
+            if (kind)
+                tally(kind, added + removed);
+        }
+    }
+    catch {
+        // Not a git repo, or no HEAD — fall through to the untracked scan.
+    }
+    // NUL-delimited output preserves spaces, non-ASCII names, and newlines.
+    // Classify paths before reading so unrelated untracked files are never read.
+    try {
+        const output = execSync('git ls-files --others --exclude-standard -z -- .', {
+            cwd: projectRoot,
+            encoding: 'utf-8',
+            stdio: ['ignore', 'pipe', 'ignore'],
+        });
+        for (const file of output.split('\0')) {
+            if (!file)
+                continue;
+            const kind = diffFileKind(file);
+            if (!kind)
+                continue;
+            tally(kind, countUntrackedFileLines(projectRoot, file));
+        }
+    }
+    catch {
+        // Not a Git repo — diff-based sync analysis is intentionally disabled.
     }
     return { codeLines, latMdLines };
 }
-async function getStopStatus(latDir) {
-    const md = await checkMd(latDir);
-    const code = await checkCodeRefs(latDir);
-    const indexErrors = await checkIndex(latDir);
-    const sectionErrors = await checkSections(latDir);
+export async function getStopStatus(latDir) {
+    const projectRoot = dirname(latDir);
+    const run = new CheckRunContext(latDir, projectRoot);
     // Must stay in step with `checkAllCommand` in check.ts. A check counted
     // there but not here lets the Stop hook call a failing tree clean, which
     // silently disables the very enforcement the check was added for.
-    const modeErrors = await checkMode(latDir);
+    const [md, code, indexErrors, sectionErrors, modeErrors] = await Promise.all([
+        checkMd(latDir, projectRoot, run),
+        checkCodeRefs(latDir, projectRoot, run),
+        checkIndex(latDir, run),
+        checkSections(latDir, projectRoot, run),
+        checkMode(latDir, projectRoot),
+    ]);
     const totalErrors = md.errors.length +
         code.errors.length +
         indexErrors.length +
         sectionErrors.length +
         modeErrors.length;
     const checkFailed = totalErrors > 0;
-    const projectRoot = dirname(latDir);
     const { codeLines, latMdLines } = analyzeDiff(projectRoot);
     let needsSync = false;
     if (codeLines >= DIFF_THRESHOLD && latMdLines < LATMD_UPPER_THRESHOLD) {
@@ -315,7 +383,7 @@ async function getStopStatus(latDir) {
         latMdLines,
     };
 }
-function formatStopReason({ checkFailed, totalErrors, needsSync, codeLines, latMdLines, }) {
+export function formatStopReason({ checkFailed, totalErrors, needsSync, codeLines, latMdLines, }) {
     if (!checkFailed && !needsSync)
         return null;
     const parts = [];
@@ -425,8 +493,12 @@ export async function hookCmd(agent, event) {
                     console.error(`Unknown hook event for cursor: ${event}. Supported: stop, postToolUse`);
                     process.exit(1);
             }
+        case 'antigravity':
+        case 'gemini':
+            await handleAntigravityHook(event);
+            return;
         default:
-            console.error(`Unknown agent: ${agent}. Supported: claude, codex, cursor`);
+            console.error(`Unknown agent: ${agent}. Supported: claude, codex, cursor, antigravity, gemini`);
             process.exit(1);
     }
 }