@plebeiantech/lat.md 0.12.3-fork.8 → 0.13.4-fork.1

package/README.md

@@ -77,9 +77,33 @@ The hooks are also packaged as a plugin, installable straight from this reposito
 
 The plugin ships hooks only and finds `lat` on your `PATH`, accepting a build only if its version carries a `-fork` suffix.
 
+### As an Antigravity / Gemini CLI plugin
+
+The hooks, rules, and skills are packaged as an Antigravity plugin under `plugins/lat-md/`.
+
+You can install it directly without cloning the repository:
+
+**Global installation (all local projects):**
+```bash
+mkdir -p ~/.gemini/config/plugins/lat-md && \
+curl -sL https://github.com/PlebeianTech/lat.md/archive/refs/heads/main.tar.gz | \
+  tar -xz -C ~/.gemini/config/plugins/lat-md --strip-components=2 lat.md-main/plugins/lat-md
+```
+
+**Workspace installation (single repository):**
+```bash
+mkdir -p .agents/plugins/lat-md && \
+curl -sL https://github.com/PlebeianTech/lat.md/archive/refs/heads/main.tar.gz | \
+  tar -xz -C .agents/plugins/lat-md --strip-components=2 lat.md-main/plugins/lat-md
+```
+
+Alternatively, install `@plebeiantech/lat.md` via npm/mise, run `lat init` in your project, and select **Antigravity / Gemini** from the agent checklist.
+
+
+
 ## How it works
 
-Run `lat init` to scaffold a `lat.md/` directory, then write markdown files describing your architecture, business logic, test specs — whatever matters. Link between sections using `[[file#Section#Subsection]]` syntax. Link to source code symbols with `[[src/auth.ts#validateToken]]`. Annotate source code with `// @lat: [[section-id]]` (or `# @lat: [[section-id]]` in Python) comments to tie implementation back to concepts.
+Run `lat init` to scaffold a `lat.md/` directory, then write markdown files describing your architecture, business logic, test specs — whatever matters. Link between sections using `[[file#Section#Subsection]]` syntax. Link to source code symbols with `[[src/auth.ts#validateToken]]`. Annotate source code with `// @lat: [[section-id]]` (or `# @lat: [[section-id]]` in Python and PHP) comments to tie implementation back to concepts.
 
 ```
 my-project/
@@ -115,7 +139,7 @@ To use higher-quality hosted embeddings instead, provide an OpenAI (`sk-...`) or
 1. `LAT_LLM_KEY` env var — direct value
 2. `LAT_LLM_KEY_FILE` env var — path to a file containing the key
 3. `LAT_LLM_KEY_HELPER` env var — shell command that prints the key (10s timeout)
-4. Config file — power users can set `llm_key` manually. Run `lat config` to print its location.
+4. Config file — power users can set `llm_key` manually. Run `lat paths --config` to print its location. Run `lat paths` to see cache and other storage paths with their purposes.
 
 Switch backends any time with `lat reindex` (`--local` to force the offline model, `--remote` to use your key).
 
@@ -123,7 +147,7 @@ Switch backends any time with `lat reindex` (`--local` to force the offline mode
 
 Development requires Node.js 22, pnpm, and Rust installed through rustup. The
 pnpm setup installs the matching WASM target and build tools project-locally.
-See the [development process](lat.md/dev-process.md) for complete setup and
+See the [development process](lat.md/knowledge/dev-process.md) for complete setup and
 contribution guidance.
 
 ```bash

package/dist/src/cli/agent-invocation.d.ts

@@ -0,0 +1,6 @@
+export interface AgentInvocation {
+    command: string;
+    args: string[];
+}
+/** Generated tools pass user input as argv, never as shell program text. */
+export declare function agentInvocation(style: 'local' | 'global' | 'npx', local: AgentInvocation, platform?: NodeJS.Platform): AgentInvocation;

package/dist/src/cli/agent-invocation.js

@@ -0,0 +1,23 @@
+import { existsSync } from 'node:fs';
+import { delimiter, dirname, join } from 'node:path';
+/** Generated tools pass user input as argv, never as shell program text. */
+export function agentInvocation(style, local, platform = process.platform) {
+    if (style === 'local')
+        return local;
+    // Windows npm command shims require cmd.exe. Use the installed entry point
+    // directly instead, retaining the Node launcher and its loader arguments.
+    if (style === 'global')
+        return platform === 'win32' ? local : { command: 'lat', args: [] };
+    if (platform !== 'win32')
+        return { command: 'npx', args: ['lat.md@latest'] };
+    const directories = [
+        dirname(process.execPath),
+        ...(process.env.PATH ?? '').split(delimiter),
+    ];
+    for (const directory of directories) {
+        const cli = join(directory, 'node_modules', 'npm', 'bin', 'npx-cli.js');
+        if (existsSync(cli))
+            return { command: process.execPath, args: [cli, 'lat.md@latest'] };
+    }
+    throw new Error('Cannot find the npm npx entry point. Choose the local command style or install npm.');
+}

package/dist/src/cli/checklist-menu.d.ts

@@ -5,8 +5,9 @@ export interface ChecklistOption {
 /**
  * Display an interactive multi-select checklist with arrow-key navigation.
  * Returns an array of checked values.
+ * Known initial values start checked; unknown values are ignored.
  *
  * Keys: Up/Down (j/k) to move, Space to toggle, Enter to confirm, Ctrl+C to exit.
  * Non-TTY fallback: returns [].
  */
-export declare function checklistMenu(options: ChecklistOption[], prompt?: string): Promise<string[]>;
+export declare function checklistMenu(options: ChecklistOption[], prompt?: string, initialValues?: readonly string[]): Promise<string[]>;

package/dist/src/cli/checklist-menu.js

@@ -2,18 +2,19 @@ import { styleText } from 'node:util';
 /**
  * Display an interactive multi-select checklist with arrow-key navigation.
  * Returns an array of checked values.
+ * Known initial values start checked; unknown values are ignored.
  *
  * Keys: Up/Down (j/k) to move, Space to toggle, Enter to confirm, Ctrl+C to exit.
  * Non-TTY fallback: returns [].
  */
-export async function checklistMenu(options, prompt) {
+export async function checklistMenu(options, prompt, initialValues = []) {
     if (options.length === 0)
         return [];
     if (!process.stdin.isTTY)
         return [];
     return new Promise((resolve) => {
         let cursor = 0;
-        const checked = new Set();
+        const checked = new Set(options.flatMap((option, index) => initialValues.includes(option.value) ? [index] : []));
         const stdin = process.stdin;
         const wasRaw = stdin.isRaw;
         stdin.setRawMode(true);

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

@@ -1,3 +1,4 @@
+export declare const SKILL_FRONTMATTER = "---\nname: lat-md-conventions\ndescription: >-\n  Rules and writing conventions for this project: Di\u00E1taxis mode placement for\n  every lat.md/ document, Strunk & White prose style, mandatory @lat: code refs\n  starting at the application entrypoint, and test specs wired to their tests.\n  Load alongside lat-md 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

@@ -1,33 +1,9 @@
 import { existsSync, mkdirSync, readFileSync, writeFileSync } from 'node:fs';
 import { join } from 'node:path';
 import { styleText } from 'node:util';
-import { contentHash, readFileHash } from '../init-version.js';
+import { contentHash, readFileHash, } from '@plebeiantech/lat.md-core/init-version';
 import { findTemplatesDir } from './templates.js';
-/**
- * The fork's own instruction channel into a consumer project.
- *
- * Upstream teaches a consumer's agent through `templates/AGENTS.md` and
- * `templates/skill/SKILL.md`. Both are upstream files, and both are the ones
- * upstream is most likely to rewrite, so every sentence this fork adds to them
- * is a merge conflict bought on credit. The fork's Diátaxis block cost 13
- * lines in one and 14 in the other before this module existed.
- *
- * Everything here writes into fork-owned paths instead. The entire upstream
- * footprint is one import and one call in `initCmd`.
- *
- * Two shapes, because the destinations behave differently:
- *
- * - Always-loaded instruction files (`CLAUDE.md`, `AGENTS.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
- *   between its own markers and leaves anything after them intact, so the two
- *   blocks do not fight on re-run.
- * - Skill directories get a separate `lat-md-conventions/SKILL.md`. Upstream
- *   writes its `lat-md` skill with a whole-file hash comparison, so appending
- *   to that file would make every later `lat init` report it as
- *   user-modified and prompt.
- */
+// @lat: [[fork#Fork#The instruction channel]]
 const FORK_BEGIN = '%% lat-fork:begin %%';
 const FORK_END = '%% lat-fork:end %%';
 /**
@@ -40,8 +16,8 @@ function forkHashKey(relPath) {
 }
 /** Instruction files that use upstream's marker-append shape. */
 const BLOCK_TARGETS = [
-    'CLAUDE.md',
     'AGENTS.md',
+    'GEMINI.md',
     '.github/copilot-instructions.md',
 ];
 /**
@@ -56,13 +32,13 @@ 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
-  lat.md/ document, mandatory @lat: code refs starting at the application
-  entrypoint, and test specs wired to their tests. Load alongside lat-md
-  whenever creating or editing files under lat.md/.
+  Rules and writing conventions for this project: Diátaxis mode placement for
+  every lat.md/ document, Strunk & White prose style, mandatory @lat: code refs
+  starting at the application entrypoint, and test specs wired to their tests.
+  Load alongside lat-md whenever creating or editing files under lat.md/.
 ---
 
 `;

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

@@ -2,8 +2,8 @@ import { existsSync, mkdirSync, readFileSync, writeFileSync } from 'node:fs';
 import { basename, dirname, join } from 'node:path';
 import { styleText } from 'node:util';
 import { isMap, isScalar, isSeq, parseDocument } from 'yaml';
-import { parseFrontmatter } from '../lattice.js';
-import { DIATAXIS_MODES, MODE_DIRS, checkMode, indexNameFor, } from './check-mode.js';
+import { parseFrontmatter } from '@plebeiantech/lat.md-core/lattice';
+import { DIATAXIS_MODES, MODE_DIRS, checkMode, indexNameFor, } from '@plebeiantech/lat.md-core/cli/check-mode';
 /**
  * Give a freshly created `lat.md/` the Diátaxis shape, and turn the gate on.
  *

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

@@ -1,4 +1,4 @@
-import type { CmdContext, CmdResult } from '../context.js';
+import type { CmdContext, CmdResult } from '@plebeiantech/lat.md-core/context';
 export type GraphOptions = {
     format?: string;
     at?: string;

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,22 @@
 import { execSync } from 'node:child_process';
-import { dirname, extname } from 'node:path';
-import { findLatticeDir, loadAllSections, findSections, } from '../lattice.js';
-import { plainStyler } from '../context.js';
-import { expandPrompt } from './expand.js';
+import { lstatSync, readFileSync } from 'node:fs';
+import { dirname, extname, join } from 'node:path';
+import { findLatticeDir } from '@plebeiantech/lat.md-core/project-discovery';
+import { findSections } from '@plebeiantech/lat.md-core/lattice-model';
+import { plainStyler, } from '@plebeiantech/lat.md-core/context';
 import { runSearch } from './search.js';
-import { getSection, formatSectionOutput } from './section.js';
-import { checkMd, checkCodeRefs, checkIndex, checkSections } from './check.js';
-import { checkMode } from './check-mode.js';
-import { SOURCE_EXTENSIONS } from '../source-parser.js';
+import { DEFAULT_SEARCH_LIMIT } from '../search/search.js';
+import { getSection, formatSectionOutput, } from '@plebeiantech/lat.md-core/cli/section';
+import { checkMd, checkCodeRefs, checkIndex, checkSections, } from '@plebeiantech/lat.md-core/cli/check';
+import { CheckRunContext } from '@plebeiantech/lat.md-core/cli/check-context';
+import { isSourceFileExtension } from '@plebeiantech/lat.md-core/source-formats';
+import { commandProjectAnalysis } from '@plebeiantech/lat.md-core/project-analysis';
+import { checkMode } from '@plebeiantech/lat.md-core/cli/check-mode';
 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: {
@@ -53,9 +58,6 @@ async function readStdin() {
     }
     return Buffer.concat(chunks).toString('utf-8');
 }
-function hasWikiLinks(text) {
-    return /\[\[[^\]]+\]\]/.test(text);
-}
 function makeHookCtx(latDir) {
     return {
         latDir,
@@ -64,15 +66,15 @@ function makeHookCtx(latDir) {
         mode: 'cli',
     };
 }
-async function searchAndExpand(ctx, userPrompt, preloadedSections) {
+async function searchContextForPrompt(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 {
@@ -109,32 +111,16 @@ async function handleUserPromptSubmit() {
         // If we can't parse stdin, still emit the reminder
     }
     const parts = [];
-    parts.push("Before starting work, run `lat search` with one or more queries describing the user's intent.", 'ALWAYS do this, even when the task seems straightforward — search results may reveal critical design details, protocols, or constraints.', 'Use `lat section` to read the full content of relevant matches.', 'Do not read files, write code, or run commands until you have searched.', '', 'Remember: `lat.md/` must stay in sync with meaningful codebase state. If you change behavior, architecture, tests, or planned work, update the relevant current-state sections and run `lat check` before finishing. Do not use `lat.md/` as a journal/changelog or add notes for insignificant details.');
+    parts.push("Before starting work, run `lat search` with one or more queries describing the user's intent.", 'ALWAYS do this, even when the task seems straightforward — search results may reveal critical design details, protocols, or constraints.', 'Use `lat section` to read the full content of relevant matches.', 'Do not read files, write code, or run commands until you have searched.', '', 'Remember: `lat.md/` must stay in sync with meaningful codebase state. If you change implemented behavior, architecture, or tests, update the relevant current-state sections and run `lat check` before finishing. Plans may be drafted in `lat.md/` alongside implementation, with the intent that by commit time they describe what was implemented. Otherwise, keep proposals, hypothetical designs, and future work outside `lat.md/` unless the user explicitly requests them there. Do not use `lat.md/` as a journal/changelog or add notes for insignificant details.');
     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);
-        // If the user prompt contains [[refs]], resolve them inline
-        if (hasWikiLinks(userPrompt)) {
-            try {
-                const expanded = await expandPrompt(ctx, userPrompt, allSections);
-                if (expanded) {
-                    parts.push('', 'Expanded user prompt with resolved [[refs]]:', expanded);
-                }
-                else {
-                    parts.push('', 'NOTE: The user prompt contains [[refs]] but they could not be resolved. Ask the user to correct them.');
-                }
-            }
-            catch {
-                parts.push('', 'NOTE: The user prompt contains [[refs]] but resolution failed. Run `lat expand` on the prompt text manually.');
-            }
-        }
+        // Search and federation share the analysis memoised on `ctx`.
+        const { allSections } = await commandProjectAnalysis(ctx);
         // Search for relevant sections and include their full content
         let searchFilePaths = [];
         try {
-            const searchContext = await searchAndExpand(ctx, userPrompt, allSections);
+            const searchContext = await searchContextForPrompt(ctx, userPrompt);
             searchFilePaths = searchContext.filePaths;
             if (searchContext.text) {
                 parts.push('', searchContext.text);
@@ -161,7 +147,7 @@ async function handleUserPromptSubmit() {
                     }
                 }
             }
-            // Reuses what searchAndExpand already matched. Searching again here
+            // Reuses what searchContextForPrompt already matched. Searching again here
             // would double the cost of every prompt, and an unusable index makes
             // runSearch throw — which abandoned the [[ref]] paths collected above,
             // even though resolving those never touches the index at all.
@@ -252,55 +238,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 +362,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 +472,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);
     }
 }