@plebeiantech/lat.md 0.12.3-fork.2 → 0.12.3-fork.20

package/README.md

@@ -42,9 +42,12 @@ This is a fork. It publishes as [`@plebeiantech/lat.md`](https://www.npmjs.com/p
 With [mise](https://mise.jdx.dev/):
 
 ```bash
+mise settings add minimum_release_age_excludes npm:@plebeiantech/lat.md
 mise use -g npm:@plebeiantech/lat.md@latest
 ```
 
+The first line is needed once per machine. mise quarantines any npm version published in the last day or so, and a fresh release is invisible until that window passes — the exclude waives it for this package alone and leaves the guard in force for every other tool.
+
 With npm:
 
 ```bash
@@ -59,6 +62,8 @@ npm i -g --prefix ~/.local/lat https://github.com/PlebeianTech/lat.md/releases/l
 
 That last one wants `~/.local/lat/bin` on your `PATH`. A fixed prefix keeps the install independent of whichever Node version is active.
 
+Pick one route and stay on it. A Release-route install left on `PATH` shadows a mise-managed one — `mise upgrade` then reports a new version while the shell keeps running the old binary.
+
 Then run `lat init` in the repo you want to use lat in.
 
 ### As a Claude Code plugin
@@ -72,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/
@@ -110,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).
 

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/comment-guard.d.ts

@@ -1,4 +1,18 @@
 import { type ToolInput } from './comment-reminder.js';
+/**
+ * The blocking half of the comment convention. `computeCommentReminder` runs
+ * at PostToolUse and only advises: by then the prose is already on disk, and
+ * it is deduped to once per file per session, so the second rationale block
+ * in a file draws no signal at all.
+ *
+ * This runs at PreToolUse instead, where `tool_input` is visible before the
+ * edit is applied and the hook can answer `deny`. A multi-line comment is
+ * refused outright and the agent is told to put the reasoning in `lat.md/`
+ * and leave a `@lat:` pointer behind.
+ *
+ * There is deliberately no per-session dedup here. A gate that fires once is
+ * not a gate.
+ */
 export type PreToolUseInput = {
     hook_event_name?: string;
     session_id?: string;

package/dist/src/cli/comment-guard.js

@@ -1,28 +1,4 @@
-import { candidateCommentLines, extractWrittenText, hasLatTree, matchFamily, resolveProjectRoot, } from './comment-reminder.js';
-/**
- * The blocking half of the comment convention. `computeCommentReminder` runs
- * at PostToolUse and only advises: by then the prose is already on disk, and
- * it is deduped to once per file per session, so the second rationale block
- * in a file draws no signal at all.
- *
- * This runs at PreToolUse instead, where `tool_input` is visible before the
- * edit is applied and the hook can answer `deny`. A multi-line comment is
- * refused outright and the agent is told to put the reasoning in `lat.md/`
- * and leave a `@lat:` pointer behind.
- *
- * There is deliberately no per-session dedup here. A gate that fires once is
- * not a gate.
- */
-/** Minimum candidate comment lines in one write before the edit is refused.
- *  A single line ("// bytes, not chars") is the bare-fact case the convention
- *  explicitly allows; two or more is a block of prose. */
-const BLOCK_THRESHOLD = 2;
-/** Explicit, reviewable opt-out. Spelled the same as the `lat:ignore` token
- *  [[src/code-refs.ts]] already honours, so a project has one escape hatch to
- *  learn rather than two. It suppresses only the line it appears on, which
- *  keeps a deliberate exception visible in the diff instead of silently
- *  disarming the gate for a whole file. */
-const LAT_IGNORE_RE = /(?<![\w])lat:ignore(?![-\w])/;
+import { hasLatTree, judgeWrittenComments, matchFamily, resolveProjectRoot, } from './comment-reminder.js';
 function buildReason(opts) {
     const where = opts.hasTree
         ? '  1. Put the reasoning in a lat.md/ section. Verbatim is fine — it does\n' +
@@ -43,8 +19,12 @@ function buildReason(opts) {
         '  3. Re-apply the edit with the prose replaced by that one pointer line.\n\n' +
         'If a comment only narrates what the code does, delete it rather than ' +
         'moving it — a reader could reconstruct it from the code.\n\n' +
-        `To keep a specific line anyway, put \`lat:ignore\` on it. That is an ` +
-        'explicit, reviewable exception, not a way to silence the gate.');
+        'Two exits, if neither applies:\n' +
+        '  - Put `lat:ignore` on a specific line to keep it. An explicit, ' +
+        'reviewable exception, not a way to silence the gate.\n' +
+        '  - Use `Edit` rather than a whole-file `Write`. Re-emitting a comment ' +
+        'the file already holds is free in either shape, but an `Edit` puts far ' +
+        'less text in front of the count.');
 }
 /**
  * Returns the denial reason for a single Edit/Write/MultiEdit call, or `null`
@@ -93,18 +73,15 @@ export function computeCommentBlock(input) {
     const family = matchFamily(filePath);
     if (!family)
         return null;
-    const written = extractWrittenText(toolInput);
-    if (!written)
-        return null;
-    const candidates = candidateCommentLines(written, family).filter((line) => !LAT_IGNORE_RE.test(line));
-    if (candidates.length < BLOCK_THRESHOLD)
+    const verdict = judgeWrittenComments(toolInput, family, 'before-write');
+    if (!verdict.flagged)
         return null;
     const projectRoot = resolveProjectRoot(filePath, input.cwd);
     if (!projectRoot)
         return null;
     return buildReason({
         base: filePath.split('/').pop() ?? filePath,
-        count: candidates.length,
+        count: verdict.count,
         marker: family.marker,
         hasTree: hasLatTree(projectRoot),
     });

package/dist/src/cli/comment-reminder.d.ts

@@ -27,20 +27,79 @@ export declare function matchFamily(filePath: string): CommentFamily | null;
 export type ToolInput = {
     file_path?: string;
     content?: string;
+    old_string?: string;
     new_string?: string;
     edits?: {
+        old_string?: string;
         new_string?: string;
     }[];
 };
-/** Only the NEW text — reading the file would fire on every pre-existing
- * comment in it, nagging about prose the agent did not write. */
-export declare function extractWrittenText(toolInput: ToolInput): string;
-/** Comment lines worth reminding about. Dropped before counting:
+/**
+ * Which side of the tool call the caller is on.
+ *
+ * `'before-write'` — PreToolUse. The file on disk is still the pre-edit state,
+ * so it is usable as a baseline for a whole-file `Write`, which carries no
+ * other record of what it replaced.
+ *
+ * `'after-write'` — PostToolUse. The write has landed, so the file contains
+ * every line of `content` by construction. Diffing against it there cancels
+ * the whole payload and the caller sees nothing at all.
+ *
+ * An `Edit` carries its own `old_string` and needs neither reading: its
+ * baseline is phase-independent, which is the shape to prefer.
+ *
+ * The parameter is required so a third call site has to answer the question
+ * rather than inherit whichever default happened to suit the first two.
+ */
+export type WritePhase = 'before-write' | 'after-write';
+/** Explicit, reviewable per-line opt-out, spelled the same as the token
+ * [[src/code-refs.ts]] already honours so a project has one escape hatch to
+ * learn rather than two. It lives here, not in the guard, because the
+ * advisory and blocking halves have to agree on it: an exemption that the
+ * gate honours but the reminder does not just relocates the nag.
+ * It suppresses only the line it appears on, keeping a deliberate exception
+ * visible in the diff instead of silently disarming the convention for a
+ * whole file. */
+export declare const LAT_IGNORE_RE: RegExp;
+/** Whether one line is a comment worth counting. Not counted:
  *   - a line that already carries a `@lat:` pointer (the compliant state)
+ *   - a line carrying the explicit opt-out token
  *   - machine directives: shebangs, magic comments, linter/type pragmas
  *   - decoration with no alphanumeric character (`# ----`, `//////`, a bare
- *     `*​/` closing a block) */
-export declare function candidateCommentLines(written: string, family: CommentFamily): string[];
+ *     `*​/` closing a block)
+ *
+ * Both halves of the convention call this and nothing else, so the gate and
+ * the reminder cannot drift apart on what counts as prose. */
+export declare function isCandidateCommentLine(line: string, family: CommentFamily): boolean;
+export type CommentVerdict = {
+    /** Candidate comment lines this call is answerable for. Names the number
+     * printed in the denial or the reminder. */
+    count: number;
+    /** Whether the call warrants a denial from the gate or a reminder from its
+     * advisory half. */
+    flagged: boolean;
+};
+/**
+ * What one Edit/Write/MultiEdit call did to the comments in a file.
+ *
+ * Two rules, because neither alone survives contact with an agent:
+ *
+ * A run of `PROSE_THRESHOLD` or more *adjacent* comment lines is flagged as
+ * soon as any one of them is new. Counting only the new lines lets a block be
+ * grown one line per `Edit` and never reach the threshold — and the denial
+ * text itself recommends `Edit` over `Write`, so the technique is advertised.
+ * What matters is the block the edit leaves behind, not the increment.
+ *
+ * Isolated new comment lines are flagged once `PROSE_THRESHOLD` of them
+ * accumulate anywhere in the call. Two one-line comments in different places
+ * are still two lines of prose; without this a scattered write walks past the
+ * adjacency rule.
+ *
+ * Neither rule counts a line that was already there, so re-emitting a
+ * comment — the whole of a `Write`'s payload, or the lines bracketing an
+ * `Edit` — stays free.
+ */
+export declare function judgeWrittenComments(toolInput: ToolInput, family: CommentFamily, phase: WritePhase): CommentVerdict;
 /** Resolvable project root, required so a scratch file in /tmp is not treated
  * as a project. `cwd` is preferred (matches CLAUDE_PROJECT_DIR / payload cwd
  * conventions); falls back to `git rev-parse --show-toplevel`. */

package/dist/src/cli/comment-reminder.js

@@ -1,6 +1,6 @@
 import { execSync } from 'node:child_process';
 import { createHash } from 'node:crypto';
-import { existsSync, mkdirSync, writeFileSync, statSync, lstatSync, } from 'node:fs';
+import { existsSync, mkdirSync, readFileSync, writeFileSync, statSync, lstatSync, } from 'node:fs';
 import { tmpdir } from 'node:os';
 import { basename, dirname, join } from 'node:path';
 const FAMILIES = [
@@ -41,35 +41,174 @@ export function matchFamily(filePath) {
     }
     return null;
 }
-/** Only the NEW text — reading the file would fire on every pre-existing
- * comment in it, nagging about prose the agent did not write. */
-export function extractWrittenText(toolInput) {
-    const parts = [];
+/** Line multiset of `text`, used as the baseline a written fragment is new
+ * against. */
+function lineCounts(text) {
+    const counts = new Map();
+    for (const line of text.split('\n')) {
+        counts.set(line, (counts.get(line) ?? 0) + 1);
+    }
+    return counts;
+}
+/** Baseline taken from the file itself, or `null` when there is no readable
+ * file — a brand-new path, a directory, a permission error, a payload naming
+ * no file. `null` means every line counts as new, which is what makes an
+ * unreadable file fail closed: the gate denies rather than waving the write
+ * through on evidence it could not gather. */
+function fileBaseline(filePath) {
+    if (!filePath)
+        return null;
+    try {
+        return lineCounts(readFileSync(filePath, 'utf-8'));
+    }
+    catch {
+        return null;
+    }
+}
+/**
+ * The fragments one tool call writes, each against the narrowest baseline
+ * available for it.
+ *
+ * `old_string` is preferred over the file wherever the payload carries one,
+ * because the file is the wrong scope: matching a written line against
+ * *anywhere* in the file forgives a genuinely new block whenever one of its
+ * lines happens to duplicate an unrelated line elsewhere. `old_string` is the
+ * exact text being replaced, so the difference is the real delta.
+ *
+ * Baselines are per fragment rather than shared across a `MultiEdit`: two
+ * hunks that each re-emit the same surrounding comment are both re-emitting
+ * it, and charging the second one for it would deny exactly the edit this is
+ * here to allow.
+ */
+function writtenFragments(toolInput, phase) {
+    let diskRead = false;
+    let disk = null;
+    const fromFile = () => {
+        if (phase !== 'before-write')
+            return null;
+        if (!diskRead) {
+            disk = fileBaseline(toolInput.file_path);
+            diskRead = true;
+        }
+        return disk;
+    };
+    const baselineFor = (oldString) => typeof oldString === 'string' ? lineCounts(oldString) : fromFile();
+    const fragments = [];
     if (typeof toolInput.content === 'string')
-        parts.push(toolInput.content);
+        fragments.push({ text: toolInput.content, baseline: fromFile() });
     if (typeof toolInput.new_string === 'string')
-        parts.push(toolInput.new_string);
+        fragments.push({
+            text: toolInput.new_string,
+            baseline: baselineFor(toolInput.old_string),
+        });
     if (Array.isArray(toolInput.edits)) {
         for (const edit of toolInput.edits) {
             if (typeof edit?.new_string === 'string')
-                parts.push(edit.new_string);
+                fragments.push({
+                    text: edit.new_string,
+                    baseline: baselineFor(edit.old_string),
+                });
         }
     }
-    return parts.join('\n');
+    return fragments;
 }
-/** Comment lines worth reminding about. Dropped before counting:
+/** Explicit, reviewable per-line opt-out, spelled the same as the token
+ * [[src/code-refs.ts]] already honours so a project has one escape hatch to
+ * learn rather than two. It lives here, not in the guard, because the
+ * advisory and blocking halves have to agree on it: an exemption that the
+ * gate honours but the reminder does not just relocates the nag.
+ * It suppresses only the line it appears on, keeping a deliberate exception
+ * visible in the diff instead of silently disarming the convention for a
+ * whole file. */
+export const LAT_IGNORE_RE = /(?<![\w])lat:ignore(?![-\w])/;
+/** Whether one line is a comment worth counting. Not counted:
  *   - a line that already carries a `@lat:` pointer (the compliant state)
+ *   - a line carrying the explicit opt-out token
  *   - machine directives: shebangs, magic comments, linter/type pragmas
  *   - decoration with no alphanumeric character (`# ----`, `//////`, a bare
- *     `*​/` closing a block) */
-export function candidateCommentLines(written, family) {
-    return written
-        .split('\n')
-        .filter((line) => family.commentRe.test(line))
-        .filter((line) => !line.includes('@lat:'))
-        .filter((line) => !/^\s*#!/.test(line))
-        .filter((line) => !family.pragmaRe.test(line))
-        .filter((line) => /[a-zA-Z0-9]/.test(line));
+ *     `*​/` closing a block)
+ *
+ * Both halves of the convention call this and nothing else, so the gate and
+ * the reminder cannot drift apart on what counts as prose. */
+export function isCandidateCommentLine(line, family) {
+    return (family.commentRe.test(line) &&
+        !line.includes('@lat:') &&
+        !LAT_IGNORE_RE.test(line) &&
+        !/^\s*#!/.test(line) &&
+        !family.pragmaRe.test(line) &&
+        /[a-zA-Z0-9]/.test(line));
+}
+/** Candidate comment lines in one write before either half reacts. A single
+ * line ("// bytes, not chars") is the bare-fact case the convention allows;
+ * two is a block of prose. */
+const PROSE_THRESHOLD = 2;
+/**
+ * What one Edit/Write/MultiEdit call did to the comments in a file.
+ *
+ * Two rules, because neither alone survives contact with an agent:
+ *
+ * A run of `PROSE_THRESHOLD` or more *adjacent* comment lines is flagged as
+ * soon as any one of them is new. Counting only the new lines lets a block be
+ * grown one line per `Edit` and never reach the threshold — and the denial
+ * text itself recommends `Edit` over `Write`, so the technique is advertised.
+ * What matters is the block the edit leaves behind, not the increment.
+ *
+ * Isolated new comment lines are flagged once `PROSE_THRESHOLD` of them
+ * accumulate anywhere in the call. Two one-line comments in different places
+ * are still two lines of prose; without this a scattered write walks past the
+ * adjacency rule.
+ *
+ * Neither rule counts a line that was already there, so re-emitting a
+ * comment — the whole of a `Write`'s payload, or the lines bracketing an
+ * `Edit` — stays free.
+ */
+export function judgeWrittenComments(toolInput, family, phase) {
+    const fragments = writtenFragments(toolInput, phase);
+    if (!fragments.some((fragment) => fragment.text !== ''))
+        return { count: 0, flagged: false };
+    let inFlaggedRuns = 0;
+    let isolatedNew = 0;
+    for (const fragment of fragments) {
+        const lines = fragment.text.split('\n');
+        const unclaimed = fragment.baseline ? new Map(fragment.baseline) : null;
+        const isNew = [];
+        const isComment = [];
+        for (const line of lines) {
+            let fresh = true;
+            if (unclaimed) {
+                const left = unclaimed.get(line) ?? 0;
+                if (left > 0) {
+                    unclaimed.set(line, left - 1);
+                    fresh = false;
+                }
+            }
+            isNew.push(fresh);
+            isComment.push(isCandidateCommentLine(line, family));
+        }
+        let i = 0;
+        while (i < lines.length) {
+            if (!isComment[i]) {
+                i += 1;
+                continue;
+            }
+            let end = i;
+            while (end < lines.length && isComment[end])
+                end += 1;
+            let fresh = 0;
+            for (let k = i; k < end; k += 1)
+                if (isNew[k])
+                    fresh += 1;
+            if (end - i >= PROSE_THRESHOLD && fresh > 0)
+                inFlaggedRuns += end - i;
+            else
+                isolatedNew += fresh;
+            i = end;
+        }
+    }
+    return {
+        count: inFlaggedRuns + isolatedNew,
+        flagged: inFlaggedRuns > 0 || isolatedNew >= PROSE_THRESHOLD,
+    };
 }
 /** Resolvable project root, required so a scratch file in /tmp is not treated
  * as a project. `cwd` is preferred (matches CLAUDE_PROJECT_DIR / payload cwd
@@ -176,16 +315,13 @@ export function computeCommentReminder(input) {
     const family = matchFamily(filePath);
     if (!family)
         return null;
-    const written = extractWrittenText(toolInput);
-    if (!written)
-        return null;
     // A single-line comment ("// increment the counter") almost always states
     // a bare fact, not a rationale — the acceptance case for this hook. Only a
-    // multi-line block is treated as prose worth a reminder; the model still
-    // makes the real judgment call, this just filters the overwhelmingly
-    // common one-liner before it ever reaches that question.
-    const candidates = candidateCommentLines(written, family);
-    if (candidates.length < 2)
+    // block is treated as prose worth a reminder; the model still makes the
+    // real judgment call, this just filters the overwhelmingly common one-liner
+    // before it ever reaches that question.
+    const verdict = judgeWrittenComments(toolInput, family, 'after-write');
+    if (!verdict.flagged)
         return null;
     const sessionId = input.session_id;
     let dedup = null;
@@ -201,7 +337,7 @@ export function computeCommentReminder(input) {
     const base = basename(filePath);
     const message = buildMessage({
         base,
-        count: candidates.length,
+        count: verdict.count,
         marker: family.marker,
         hasTree,
     });

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

@@ -0,0 +1,20 @@
+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.
+ *
+ * Returns null when the block is already byte-identical, so the caller can
+ * stay quiet rather than announce a write that did not happen.
+ */
+export declare function spliceForkBlock(content: string, body: string): string | null;
+/** Read the body currently fenced by the fork markers, or null if absent. */
+export declare function extractForkBlock(content: string): string | null;
+/**
+ * Write the fork's conventions into every instruction file and skill directory
+ * the selected agents produced.
+ *
+ * `fileHashes` is upstream's record, threaded through so `writeInitMeta`
+ * persists these entries alongside its own; a stored hash is what lets a later
+ * run tell "the user edited our block" from "the template moved on".
+ */
+export declare function writeForkInstructions(root: string, latDir: string, fileHashes: Record<string, string>, ask: (message: string) => Promise<boolean>): Promise<void>;