okf-kit 0.4.0 → 0.5.0

package/CHANGELOG.md

@@ -5,6 +5,39 @@ All notable changes to `okf-kit` are documented here.
 The format is based on [Keep a Changelog](https://keepachangelog.com/en/1.1.0/),
 and this project adheres to [Semantic Versioning](https://semver.org/spec/v2.0.0.html).
 
+## [0.5.0] - 2026-08-22
+
+### Added
+
+- New rule `citations-resolve`: for docs with a repo root, flags a
+  `` `path:N`/`path:N-M` `` citation (and its `` `:N` ``/`` -`M` ``/`` (`N`) ``
+  continuations) whose target file is missing, whose range is inverted or
+  exceeds the file, or whose start line is blank or (for a non-markdown
+  target) only a closing brace. Ported from agent-grounding's
+  `scripts/okf-citations-resolve.mjs` (agent-grounding PR #185), a
+  repo-local spike that closed a gap `sources-fresh` cannot: `sources-fresh`
+  only compares a doc's `sources` list against file mtimes, so it is
+  structurally blind to an edit that shifts line numbers inside a still-fresh
+  source file. `citations-resolve` gives every repo consuming okf-kit this
+  check without copying the script. See "Citation resolution
+  (citations-resolve)" in the README. Not ported: the original's
+  `docs/testing`-file expansion (an agent-grounding-specific convention, not
+  part of the OKF spec, and not exercised by the ported tests) -- this rule
+  only scans the docs already loaded for the bundle being checked.
+  `citations-resolve` findings are warn-level: an existing `okf-kit check
+  --strict` run that was previously green can now fail once this version is
+  picked up, purely from this rule's new warnings, with no other change to
+  the bundle. Two path-resolution refinements differ from the
+  agent-grounding original: (1) a bare filename with no `/` (e.g.
+  `README.md`) now tries the citing doc's own directory and each ancestor
+  directory up to the repo root, nearest first, before falling back to a
+  plain repo-root-relative lookup, so a package-level file is not shadowed
+  by a same-named file that happens to also sit at the repo root; (2) a
+  `` `path:N` `` match that starts at column 0 of its line, right after a
+  previous line ending in `-`/`–`, is treated as the phantom tail of a
+  filename hard-wrapped across the line break and skipped, instead of being
+  checked (and typically flagged `missing-file`) as its own citation.
+
 ## [0.4.0] - 2026-08-13
 
 ### Changed

package/README.md

@@ -69,6 +69,7 @@ Every template doc except `benchmark-template.md` ships with `sources: [path/to/
 | `no-absolute-links` | warning | Link targets should not start with `/`. GitHub resolves a leading slash against the repository root, not the bundle root, so an absolute link 404s once the bundle is viewed outside its own repository. Use a same-directory relative link instead. |
 | `sources-shape` | error | Frontmatter `sources`, when present, must be a non-empty array of non-empty strings. With a repo root (explicit or auto-detected), each listed path (file or directory) must also exist under it. |
 | `sources-fresh` | warning / notice | For docs with a `sources` list and a repo root, flags a source path whose last git commit is newer than both the doc's `timestamp` and the doc file's own last commit. See "Staleness (sources-fresh)" below. |
+| `citations-resolve` | warning / notice | For docs with a repo root, flags a `` `path:N`/`path:N-M` `` citation (and its `` `:N` ``/`` -`M` ``/`` (`N`) `` continuations) whose target file is missing, whose range is inverted or exceeds the file, or whose start line is blank or (for a non-markdown target) only a closing brace. See "Citation resolution (citations-resolve)" below. |
 
 ## repo-root auto-detection
 
@@ -99,6 +100,29 @@ Known limitation: the doc-commit comparison suppresses staleness for every sourc
 
 **Authoring guidance:** when you re-verify a doc against its sources, bump its frontmatter `timestamp` (and add a line to the bundle's `log.md`) so `sources-fresh` reflects that the doc is current again.
 
+## Citation resolution (citations-resolve)
+
+`sources-fresh` catches a source file changing after a doc's `timestamp`, but it is structurally blind to an edit that shifts *line numbers* inside a still-fresh file: a doc citing `path:42` keeps citing line 42 even after an edit moves the referenced content to line 50. `citations-resolve` finds every `` `path:N` ``/`` `path:N-M` `` citation in a doc, resolves `path` to a real file, and flags a citation that clearly cannot be pointing at real content any more. It is mechanical only (no symbol/AST resolution): it does not verify the cited line is *semantically* the right one, only that the target exists, the range is sound, and the start line is not blank or (for a non-markdown target) a lone closing brace/bracket.
+
+| Rule id | Meaning |
+|---------|---------|
+| `missing-file` | The cited path could not be resolved to a real file (see path resolution below). |
+| `path-traversal-rejected` | The cited path contains a `..` segment; rejected without ever being resolved. |
+| `inverted-range` | A range's end line is before its start line. |
+| `range-exceeds-file` | The cited line (or the end of a range) is past the end of the resolved file. |
+| `blank-start-line` | The start line resolves to a blank line. A citation whose start line is blank is flagged; cite the first content line instead. Consumers enabling this rule on an existing bundle should expect to fix citations like this once, the first time they turn it on. |
+| `closing-brace-start-line` | For a non-markdown target, the start line is only a closing brace/bracket/paren (`}`, `)`, `]`, optionally with a trailing `,`/`;`) -- a common signature of a cited block having moved. |
+| `unresolved-ambiguous` | More than one file in the repo matches the cited path; reported as a `notice` (never counted toward `--strict`), not guessed at. |
+| `unreadable-target` | The resolved target file exists but could not be read (e.g. permission denied); reported as a `notice` (never counted toward `--strict`) with the OS error code in `detail`, since an unreadable file is not evidence the citation itself is wrong. |
+
+**Continuation citations.** Once a sentence states a full `path:N` citation, prose commonly repeats just the line (or range) for a later reference in the same sentence: `` `:N` ``/`` `:N-M` `` (bare colon-prefixed), `` -`M` ``/`` –`M` `` (hyphen- or en-dash-led, the tail of a split range like `` `path:N`-`M` ``), or `` (`N`) `` (parenthesized). Each resolves against the nearest preceding citation in the same doc that resolved to a real file; a continuation right after an unresolved, ambiguous, or out-of-scope citation is silently skipped, not misattributed to an earlier, unrelated file.
+
+**Hard-wrapped prose.** A doc that hard-wraps prose at a fixed column can split a hyphenated filename across a line break right after its trailing `-` (e.g. `run-state-lifecycle-and-markers.md` wrapping to `run-state-lifecycle-and-\nmarkers.md`). A `` `path:N` `` match is skipped entirely (not checked, not counted as a citation) when it starts at column 0 of its line -- optionally after only whitespace or a list/quote marker (`-`, `*`, `>`, digits, `.`) -- and the previous line ends with `-`/`–`: the signature of a wrapped continuation rather than a genuine citation to a short bare filename.
+
+**Path resolution**, tried in order: (1) the doc's own frontmatter `sources` list, matched by exact suffix, only when exactly one source matches; (2) for a citedPath with no `/` only, doc-relative and then each ancestor directory of the doc up to the repo root, nearest first (so a bare filename like `README.md` prefers the README *for the package the doc lives in* over a same-named file that merely happens to also sit at the repo root); (3) repo-root-relative; (4) doc-relative; (5) the nearest earlier citation in the same doc whose path contains a `/` and ends with the same suffix (the "full path was mentioned earlier" convention); (6) a repo-wide search by basename. A cited path starting with `/` is treated as an absolute or placeholder path (e.g. inside a fabricated example stack trace) and skipped without a finding.
+
+Like `sources-fresh`, this rule requires a repo root (explicit `--repo-root` or auto-detected): without one, it emits a single bundle-level notice (`citation resolution skipped: not inside a git work tree`) rather than silently reporting nothing.
+
 ## Exit codes
 
 | Code | Meaning |
@@ -113,7 +137,7 @@ This is advisory: don't fail the build on warnings unless you pass `--strict`. U
 
 ```yaml
 - name: OKF bundle check
-  run: npx okf-kit@0.4.0 check path/to/bundle
+  run: npx okf-kit@0.5.0 check path/to/bundle
 ```
 
 Pin the version: an unpinned `npx okf-kit` picks up new rules on their release day, which turns an unrelated PR red.

package/dist/rules/citations-resolve.d.ts

@@ -0,0 +1,2 @@
+import type { Rule } from "../types.js";
+export declare const citationsResolveRule: Rule;

package/dist/rules/citations-resolve.js

@@ -0,0 +1,629 @@
+import fs from "node:fs";
+import path from "node:path";
+import { getValidSources } from "../util.js";
+const RULE_ID = "citations-resolve";
+/**
+ * Warn-only checker for `path:N[-M]` citations inside a bundle's docs (and
+ * their continuation forms, see below).
+ *
+ * Ported from agent-grounding's `scripts/okf-citations-resolve.mjs`
+ * (PR #185), which was a repo-local, no-dependency spike at closing a gap
+ * `sources-fresh` cannot: `sources-fresh` only compares a doc's `sources`
+ * list against file mtimes, so it is structurally blind to an edit that
+ * shifts line numbers inside a still-fresh source file. This rule finds
+ * every `path:N` / `path:N-M` citation in a doc, resolves `path` to a real
+ * file, and warns when the citation clearly cannot be pointing at real
+ * content any more.
+ *
+ * What it checks (mechanical only, no symbol/AST resolution):
+ *   - the target file does not exist (after resolution, see below)
+ *   - a range's end line is before its start line (an inverted range)
+ *   - the cited line (or the end of a range) is past the end of the file
+ *   - the start line is blank
+ *   - for non-markdown targets only, the start line is only a closing
+ *     brace/bracket/paren (`}`, `)`, `]`, optionally with a trailing `,`/`;`)
+ *     -- a common signature of "the cited block moved and this now points at
+ *     the line right after it used to end"
+ *
+ * What it does NOT check: whether the cited line is semantically the right
+ * one (that needs the actual symbol; out of scope for a warn-only mechanical
+ * rule), nor citations without a file extension this rule recognises.
+ *
+ * Hard-wrapped prose. Some docs hard-wrap prose at a fixed column, which can
+ * split a hyphenated filename like `run-state-lifecycle-and-markers.md`
+ * across a line break right after the trailing `-`. `CITATION_RE` cannot
+ * (and should not) span the newline to reassemble the real citedPath, but
+ * without a guard it instead matches the phantom tail on its own
+ * (`markers.md:172`), which usually does not exist as a file and produces a
+ * false `missing-file`. A `CITATION_RE` match is skipped entirely (neither
+ * checked nor counted as a real citation) when it starts at column 0 of its
+ * line -- optionally after only whitespace or a list/quote marker
+ * (`-`, `*`, `>`, digits, `.`) -- and the previous line ends with `-` or
+ * `–`: the signature of a wrapped continuation, not a new citation.
+ *
+ * Unreadable targets. A resolved target file that exists but cannot be read
+ * (permission denied, and similar OS-level failures) is reported as a
+ * bundle-level `notice` tagged `unreadable-target` with the OS error code in
+ * `detail`, rather than throwing and aborting the whole check: a citation
+ * pointing at a file the checker itself cannot read is not evidence the
+ * citation is wrong.
+ *
+ * Porting decision (scope cut from the original): the original script also
+ * scanned any `docs/testing/*.md` file that an okf doc's frontmatter
+ * `sources` cited, an agent-grounding-specific convention (docs/testing is
+ * not part of the OKF spec) that is not exercised by any of the ported
+ * tests. This rule instead only scans the docs `loadBundle` already loaded
+ * for `ctx.bundleDir` -- a citing doc outside the bundle is out of scope.
+ *
+ * Path resolution. A bundle's prose citations are frequently written
+ * *relative to context* rather than as a full repo-root path, e.g. a doc's
+ * frontmatter `sources` list carries `packages/foo/src/cli.ts`, but the
+ * prose later just says `cli.ts:42` or `src/cli.ts:42` once the reader
+ * "knows" which package the section is about -- and source basenames can be
+ * reused across sibling packages, so a resolver that only tried
+ * repo-root-relative and doc-relative paths would either flag real,
+ * non-drifted citations as "missing file" or silently check the wrong
+ * same-named file. Resolution here instead tries, in order:
+ *   1. the citing doc's own frontmatter `sources` list, matched by exact
+ *      suffix (`source === citedPath || source.endsWith('/' + citedPath)`),
+ *      only when exactly one source matches -- the doc's author already
+ *      disambiguated which physical file this citation means
+ *   2. for a citedPath with no `/` only: doc-relative, then each ancestor
+ *      directory of the doc up to (and including) repoRoot, nearest first
+ *      -- a bare filename like `README.md` almost always means "the README
+ *      *for the package this doc lives in*", and a repo-root-relative
+ *      lookup done first would instead silently resolve to an unrelated,
+ *      differently-sized file of the same name that happens to sit at the
+ *      repo root ("shadowing"). A citedPath containing a `/` skips straight
+ *      to step 3: the caller already qualified enough of the path that
+ *      "closest ancestor" guessing isn't needed.
+ *   3. repo-root-relative (`<repoRoot>/<citedPath>`)
+ *   4. doc-relative (`<dirname(doc)>/<citedPath>`) -- redundant with step 2
+ *      for a no-`/` citedPath (already tried there), the effective first
+ *      resolution attempt for a `/`-containing one
+ *   5. the nearest earlier citation *in the same doc* whose path contains a
+ *      `/` and ends with the same suffix as citedPath (the "last full path
+ *      mentioned" convention)
+ *   6. a repo-wide search for a file whose path ends with citedPath (or,
+ *      for a bare filename, whose basename equals it)
+ * A citedPath starting with `/` is treated as out of scope (an absolute or
+ * placeholder path, e.g. inside a fabricated example stack trace) and
+ * skipped without a finding. When step 6 finds more than one candidate the
+ * citation is reported as a `notice`-severity "ambiguous target" finding
+ * rather than guessed at or false-flagged as missing (never counted toward
+ * `--strict`). A citation resolved by none of the above, with zero
+ * candidates at step 6, is reported as `missing-file`. A citedPath
+ * containing a `..` segment is rejected outright (`path-traversal-rejected`)
+ * without ever being resolved, so a malformed or hostile citation cannot
+ * walk resolution outside the repo.
+ *
+ * Continuation citations. Once a sentence has stated a full `path:N`
+ * citation, prose habitually repeats just the line (or range) for a later
+ * reference in the same sentence rather than retyping the path, in three
+ * forms:
+ *   - `` `:N` `` or `` `:N-M` `` -- a bare colon-prefixed line/range
+ *   - `` -`M` `` / `` –`M` `` -- a hyphen- or en-dash-led bare line, the
+ *     tail half of a `` `path:N`-`M` `` split range
+ *   - `` (`N`) `` -- a parenthesized bare line
+ * Each of these resolves against `governing`: the nearest *preceding*
+ * citation (full or itself a continuation) that resolved to a real file,
+ * scanned in document order. `governing` resets to none whenever the
+ * citation immediately before it failed to resolve, was ambiguous, or was
+ * out of scope (leading `/`) -- a continuation never silently inherits a
+ * stale or unrelated path from further up the doc. A continuation with no
+ * governing citation at all (e.g. very start of a doc) is skipped, not
+ * flagged: there is nothing to validate it against.
+ *
+ * A continuation is further split into two roles (see
+ * collectContinuationAtoms): "fresh" (a genuinely new start line, checked
+ * the same five ways as a full citation's start) versus "extension" (only
+ * ever the tail `M` of a split range whose start was already checked) --
+ * an extension gets *only* the range-bound checks (inverted-range,
+ * range-exceeds-file), never blank/closing-brace: that start line was
+ * already checked when it was first cited, so re-running it here would
+ * double-report the same drift, and a range legitimately ending on a
+ * closing brace is normal, not drift.
+ *
+ * Requires `ctx.repoRoot` (explicit `--repo-root` or auto-detected): target
+ * files usually live outside the bundle itself, so without a repo root
+ * there is no filesystem tree to resolve a citation against. Without one,
+ * this rule emits a single bundle-level notice, matching `sources-fresh`'s
+ * "not inside a git work tree" posture.
+ */
+const CITATION_RE = /([\w./-]+\.(?:ts|js|mjs|md|yml|yaml|json)):(\d+)(?:-(\d+))?/g;
+// Continuation citation forms (see the "Continuation citations" doc block
+// above). Each requires the backtick delimiter as part of the match so it
+// can never overlap a CITATION_RE match: a full citation's regex match
+// never includes the surrounding backticks, and none of these three
+// require a `path.ext` prefix before the digits.
+const CONT_COLON_RE = /`:(\d+)(?:-(\d+))?`/g;
+const CONT_DASH_RE = /[-–]`(\d+)`/g;
+const CONT_PAREN_RE = /\(`(\d+)`\)/g;
+const CLOSING_ONLY_EXTS = new Set(["ts", "js", "mjs", "yml", "yaml", "json"]);
+const CLOSING_BRACE_RE = /^[)\]}][;,]?$/;
+const EXCLUDED_DIRS = new Set([
+    "node_modules",
+    ".git",
+    "dist",
+    "build",
+    "coverage",
+    ".next",
+    ".turbo",
+    // Ported 1:1 from the original script's own disposable test-fixtures
+    // exclusion, kept so the ported EXCLUDED_DIRS regression test carries
+    // over verbatim; harmless for any consuming repo that has no directory
+    // with this name.
+    "okf-citations-resolve-fixtures",
+]);
+function isFile(p) {
+    try {
+        return fs.statSync(p).isFile();
+    }
+    catch {
+        return false;
+    }
+}
+/** True when citedPath has a literal `..` path segment. */
+function hasParentSegment(citedPath) {
+    return citedPath.split("/").includes("..");
+}
+/**
+ * Repo-wide search for files with an exact basename, memoized per root
+ * within `cache`. `cache` is built lazily and scoped to a single
+ * `citationsResolveRule.run(ctx)` invocation (see the rule's `run`), not
+ * held at module scope, so an in-process caller running the check
+ * repeatedly (e.g. in a long-lived process, or a test suite that edits
+ * fixtures between runs) never sees a stale index from an earlier run.
+ */
+function findByBasename(cache, root, basename) {
+    let index = cache.get(root);
+    if (!index) {
+        index = new Map();
+        const found = index;
+        const walk = (dir) => {
+            let entries;
+            try {
+                entries = fs.readdirSync(dir, { withFileTypes: true });
+            }
+            catch {
+                return;
+            }
+            for (const entry of entries) {
+                if (entry.name.startsWith(".") && entry.name !== ".github")
+                    continue;
+                if (EXCLUDED_DIRS.has(entry.name))
+                    continue;
+                const full = path.join(dir, entry.name);
+                if (entry.isDirectory()) {
+                    walk(full);
+                }
+                else if (entry.isFile()) {
+                    const list = found.get(entry.name) ?? [];
+                    list.push(full);
+                    found.set(entry.name, list);
+                }
+            }
+        };
+        walk(root);
+        cache.set(root, index);
+    }
+    return index.get(basename) ?? [];
+}
+/**
+ * Finds the nearest citation earlier in the same doc whose cited path
+ * contains a `/` and ends with the same suffix as `citedPath`, the "full
+ * path was mentioned earlier in this section/doc" convention.
+ */
+function findPriorQualifiedCitation(content, beforeIndex, citedPath) {
+    const suffix = "/" + citedPath;
+    let best = null;
+    let bestIndex = -1;
+    const re = new RegExp(CITATION_RE.source, "g");
+    let m;
+    while ((m = re.exec(content)) !== null) {
+        if (m.index >= beforeIndex)
+            break;
+        const candidate = m[1];
+        if (candidate === citedPath)
+            continue; // not more qualified than itself
+        if (candidate.includes("/") &&
+            (candidate === citedPath || candidate.endsWith(suffix))) {
+            if (m.index > bestIndex) {
+                bestIndex = m.index;
+                best = candidate;
+            }
+        }
+    }
+    return best;
+}
+/**
+ * For a bare (no `/`) citedPath, tries doc-relative first, then each
+ * ancestor directory of the doc, nearest first, up to and including `root`.
+ * Returns the first real file found, or `null`. See the "Path resolution"
+ * doc block above (step 2) for why this runs before the plain
+ * repo-root-relative lookup: a same-named file closer to the citing doc
+ * (e.g. a package's own `README.md`) should win over one that merely
+ * happens to also exist at the repo root.
+ */
+function resolveViaAncestorClimb(root, docAbsPath, citedPath) {
+    const resolvedRoot = path.resolve(root);
+    let dir = path.dirname(docAbsPath);
+    for (;;) {
+        const candidate = path.resolve(dir, citedPath);
+        if (isFile(candidate))
+            return candidate;
+        if (path.resolve(dir) === resolvedRoot)
+            return null;
+        const parent = path.dirname(dir);
+        if (parent === dir)
+            return null; // reached the filesystem root
+        dir = parent;
+    }
+}
+/**
+ * Resolves a citation's path to a single real file. Returns `{ skip: true }`
+ * for a citedPath out of scope (leading `/`), `{ path }` on a definitive
+ * single resolution, `{ ambiguous: true, candidates }` when more than one
+ * plausible target exists, or `null` when nothing matches. Callers must
+ * reject a citedPath with a `..` segment (see hasParentSegment) before
+ * calling this; it is not re-checked here.
+ */
+function resolveCitation(cache, root, docAbsPath, docContent, docSources, citedPath, matchIndex) {
+    if (citedPath.startsWith("/")) {
+        return { skip: true };
+    }
+    const sourceMatches = docSources.filter((s) => s === citedPath || s.endsWith("/" + citedPath));
+    if (sourceMatches.length === 1) {
+        const candidate = path.resolve(root, sourceMatches[0]);
+        if (isFile(candidate))
+            return { path: candidate };
+    }
+    if (!citedPath.includes("/")) {
+        const viaAncestor = resolveViaAncestorClimb(root, docAbsPath, citedPath);
+        if (viaAncestor)
+            return { path: viaAncestor };
+    }
+    const rootRelative = path.resolve(root, citedPath);
+    if (isFile(rootRelative))
+        return { path: rootRelative };
+    const docRelative = path.resolve(path.dirname(docAbsPath), citedPath);
+    if (isFile(docRelative))
+        return { path: docRelative };
+    const prior = findPriorQualifiedCitation(docContent, matchIndex, citedPath);
+    if (prior) {
+        const candidate = path.resolve(root, prior);
+        if (isFile(candidate))
+            return { path: candidate };
+    }
+    const base = citedPath.includes("/")
+        ? citedPath.split("/").pop()
+        : citedPath;
+    const bySuffix = findByBasename(cache, root, base).filter((m) => {
+        const normalized = m.split(path.sep).join("/");
+        return (normalized === citedPath ||
+            normalized.endsWith("/" + citedPath) ||
+            !citedPath.includes("/"));
+    });
+    if (bySuffix.length === 1)
+        return { path: bySuffix[0] };
+    if (bySuffix.length > 1) {
+        return {
+            ambiguous: true,
+            candidates: bySuffix.map((m) => path.relative(root, m)),
+        };
+    }
+    return null;
+}
+function splitLines(content) {
+    const lines = content.split("\n");
+    if (lines.length > 0 &&
+        lines[lines.length - 1] === "" &&
+        content.endsWith("\n")) {
+        lines.pop();
+    }
+    return lines;
+}
+// Range-bound checks shared by a full citation's own range (via
+// checkTarget below) and a cont-ext atom's extension (via
+// checkRangeBoundOnly): a citation's end before its start, or either bound
+// past the end of the file. Both are pure "does this range make sense"
+// checks, independent of what the start line's content actually is.
+function checkRangeBound(startLine, endLine, lineCount) {
+    if (endLine !== null && endLine < startLine) {
+        return {
+            rule: "inverted-range",
+            message: `range end (${endLine}) is before its start (${startLine})`,
+        };
+    }
+    const last = endLine ?? startLine;
+    if (startLine > lineCount || last > lineCount) {
+        return {
+            rule: "range-exceeds-file",
+            message: `citation exceeds file length (${lineCount} line(s))`,
+        };
+    }
+    return null;
+}
+/**
+ * Reads a resolved target's content, or reports why it couldn't be read
+ * (permission denied, and similar OS-level failures short of the file not
+ * existing at all -- `resolveCitation` already confirmed the target exists
+ * via `isFile`/`fs.statSync`, which does not require read permission).
+ * Returned as a `Problem` with `rule: "unreadable-target"` and `code` set to
+ * the OS error code, so callers can route it to a `notice`-severity finding
+ * (see pushUnreadable) instead of the usual `warning`-severity drift finding
+ * -- an unreadable file is not evidence the citation itself is wrong.
+ */
+function readTarget(resolvedPath) {
+    try {
+        return { content: fs.readFileSync(resolvedPath, "utf8") };
+    }
+    catch (err) {
+        const code = err.code ?? "UNKNOWN";
+        return {
+            rule: "unreadable-target",
+            message: "target file exists but could not be read",
+            code,
+        };
+    }
+}
+function checkTarget(citedPath, startLine, endLine, resolvedPath) {
+    const read = readTarget(resolvedPath);
+    if ("rule" in read)
+        return read;
+    const content = read.content;
+    const lines = splitLines(content);
+    const lineCount = lines.length;
+    const bound = checkRangeBound(startLine, endLine, lineCount);
+    if (bound)
+        return bound;
+    const startText = lines[startLine - 1] ?? "";
+    const trimmed = startText.trim();
+    if (trimmed === "") {
+        return { rule: "blank-start-line", message: "start line is blank" };
+    }
+    const ext = (citedPath.split(".").pop() ?? "").toLowerCase();
+    if (CLOSING_ONLY_EXTS.has(ext) && CLOSING_BRACE_RE.test(trimmed)) {
+        return {
+            rule: "closing-brace-start-line",
+            message: `start line is only a closing brace/bracket ("${trimmed}")`,
+        };
+    }
+    return null;
+}
+// A cont-ext atom only ever extends the *end* of a range whose start line
+// was already fully checked (blank / closing-brace) when it was cited as
+// its own full citation or cont-fresh atom -- re-running checkTarget here
+// would re-derive that same start-line check against the identical line
+// and, on a real drift, double-report it as a second finding. This checks
+// only whether the (possibly inverted, possibly out-of-file) range itself
+// is sound.
+function checkRangeBoundOnly(startLine, endLine, resolvedPath) {
+    const read = readTarget(resolvedPath);
+    if ("rule" in read)
+        return read;
+    const lineCount = splitLines(read.content).length;
+    return checkRangeBound(startLine, endLine, lineCount);
+}
+/**
+ * Collects every continuation-citation atom (see the "Continuation
+ * citations" doc block above) in `content`, sorted by document position.
+ *
+ * Each atom is tagged with a role:
+ *   - "cont-fresh": establishes a new start line (optionally with its own
+ *     embedded end, e.g. `` `:75-78` ``), checked the same way as a full
+ *     citation's start (blank / closing-brace / range-exceeds).
+ *   - "cont-ext": purely extends the *end* of whatever start line came
+ *     immediately before it (a `` -`M` `` / `` –`M` `` tail, or a
+ *     `` `:M` `` directly preceded by a `-`/`–`). Ending a range on a
+ *     closing brace is completely normal, so an extension is checked ONLY
+ *     for the range-bound checks (inverted-range, range-exceeds-file),
+ *     never blank/closing-brace.
+ * A colon-form match (`` `:N` ``) is "cont-ext" exactly when the nearest
+ * non-whitespace character before its opening backtick is `-` or `–`;
+ * otherwise it is "cont-fresh". Dash-form (`` -`M` ``/`` –`M` ``) is
+ * always "cont-ext" by construction. Paren-form (`` (`N`) ``) is always
+ * "cont-fresh".
+ */
+function collectContinuationAtoms(content) {
+    const atoms = [];
+    const colonRe = new RegExp(CONT_COLON_RE.source, "g");
+    let m;
+    while ((m = colonRe.exec(content)) !== null) {
+        const before = content.slice(0, m.index).trimEnd();
+        if (/[-–]$/.test(before)) {
+            atoms.push({
+                kind: "cont-ext",
+                index: m.index,
+                value: m[2] ? Number(m[2]) : Number(m[1]),
+            });
+        }
+        else {
+            atoms.push({
+                kind: "cont-fresh",
+                index: m.index,
+                startLine: Number(m[1]),
+                endLine: m[2] ? Number(m[2]) : null,
+            });
+        }
+    }
+    const dashRe = new RegExp(CONT_DASH_RE.source, "g");
+    while ((m = dashRe.exec(content)) !== null) {
+        atoms.push({ kind: "cont-ext", index: m.index, value: Number(m[1]) });
+    }
+    const parenRe = new RegExp(CONT_PAREN_RE.source, "g");
+    while ((m = parenRe.exec(content)) !== null) {
+        atoms.push({
+            kind: "cont-fresh",
+            index: m.index,
+            startLine: Number(m[1]),
+            endLine: null,
+        });
+    }
+    return atoms;
+}
+function pushDrift(findings, file, citation, rule, message, resolvedTo) {
+    findings.push({
+        ruleId: RULE_ID,
+        severity: "warning",
+        file,
+        message: `\`${citation}\`: ${message} [${rule}]`,
+        ...(resolvedTo ? { detail: `resolvedTo: ${resolvedTo}` } : {}),
+    });
+}
+function pushAmbiguous(findings, file, citation, candidates) {
+    findings.push({
+        ruleId: RULE_ID,
+        severity: "notice",
+        file,
+        message: `\`${citation}\`: ambiguous target, not evaluated [unresolved-ambiguous]`,
+        detail: `candidates: ${candidates.join(", ")}`,
+    });
+}
+function pushUnreadable(findings, file, citation, resolvedTo, code) {
+    findings.push({
+        ruleId: RULE_ID,
+        severity: "notice",
+        file,
+        message: `\`${citation}\`: target file exists but could not be read [unreadable-target]`,
+        detail: `resolvedTo: ${resolvedTo}, errorCode: ${code}`,
+    });
+}
+/**
+ * True when a `CITATION_RE` match at `matchIndex` is the phantom tail of a
+ * filename hard-wrapped across a line break (see the "Hard-wrapped prose"
+ * doc block above): the match starts at column 0 of its line, optionally
+ * after only whitespace or a list/quote marker, and the previous line ends
+ * with `-` or `–`.
+ */
+function isWrappedPathContinuation(content, matchIndex) {
+    const lineStart = content.lastIndexOf("\n", matchIndex - 1) + 1;
+    if (lineStart === 0)
+        return false; // no previous line to have wrapped from
+    const prefix = content.slice(lineStart, matchIndex);
+    if (!/^[\s>*.\d-]*$/.test(prefix))
+        return false;
+    const prevLineEnd = lineStart - 1; // index of the newline just before lineStart
+    const prevLineStart = content.lastIndexOf("\n", prevLineEnd - 1) + 1;
+    const prevLine = content.slice(prevLineStart, prevLineEnd);
+    return /[-–]$/.test(prevLine);
+}
+function scanDoc(cache, root, bundleDir, doc) {
+    const findings = [];
+    const content = doc.raw;
+    const sources = getValidSources(doc.frontmatter.parsed) ?? [];
+    const docAbsPath = path.join(bundleDir, doc.relPath);
+    const fullAtoms = [];
+    const re = new RegExp(CITATION_RE.source, "g");
+    let m;
+    while ((m = re.exec(content)) !== null) {
+        if (isWrappedPathContinuation(content, m.index))
+            continue;
+        fullAtoms.push({
+            kind: "full",
+            index: m.index,
+            citedPath: m[1],
+            startLine: Number(m[2]),
+            endLine: m[3] ? Number(m[3]) : null,
+        });
+    }
+    const atoms = [...fullAtoms, ...collectContinuationAtoms(content)].sort((a, b) => a.index - b.index);
+    // `governing`: nearest preceding citation (full or continuation) that
+    // resolved to a real file; see the "Continuation citations" doc block
+    // above for the reset rules. `lastStartLine`: the start line a "cont-ext"
+    // atom extends into a range; tracks the most recent full or cont-fresh
+    // atom's own startLine, scoped together with `governing`.
+    let governing = null;
+    let lastStartLine = null;
+    for (const atom of atoms) {
+        if (atom.kind === "cont-ext") {
+            if (!governing || lastStartLine === null)
+                continue; // nothing to extend
+            const citation = `${governing.citedPath}:${lastStartLine}-${atom.value} (continuation)`;
+            const problem = checkRangeBoundOnly(lastStartLine, atom.value, governing.resolvedPath);
+            if (problem?.rule === "unreadable-target") {
+                pushUnreadable(findings, doc.relPath, citation, path.relative(root, governing.resolvedPath), problem.code ?? "UNKNOWN");
+            }
+            else if (problem) {
+                pushDrift(findings, doc.relPath, citation, problem.rule, problem.message, path.relative(root, governing.resolvedPath));
+            }
+            continue; // governing and lastStartLine both carry over unchanged
+        }
+        if (atom.kind === "cont-fresh") {
+            if (!governing)
+                continue; // nothing to validate a bare continuation against
+            const { startLine, endLine } = atom;
+            const citation = `${governing.citedPath}:${startLine}${endLine ? "-" + endLine : ""} (continuation)`;
+            const problem = checkTarget(governing.citedPath, startLine, endLine, governing.resolvedPath);
+            if (problem?.rule === "unreadable-target") {
+                pushUnreadable(findings, doc.relPath, citation, path.relative(root, governing.resolvedPath), problem.code ?? "UNKNOWN");
+            }
+            else if (problem) {
+                pushDrift(findings, doc.relPath, citation, problem.rule, problem.message, path.relative(root, governing.resolvedPath));
+            }
+            lastStartLine = startLine;
+            continue; // governing (same file) carries over unchanged
+        }
+        const { citedPath, startLine, endLine } = atom;
+        const citation = `${citedPath}:${startLine}${endLine ? "-" + endLine : ""}`;
+        if (hasParentSegment(citedPath)) {
+            pushDrift(findings, doc.relPath, citation, "path-traversal-rejected", `citedPath contains a ".." segment and was rejected without resolving: ${citedPath}`);
+            governing = null;
+            lastStartLine = null;
+            continue;
+        }
+        const resolution = resolveCitation(cache, root, docAbsPath, content, sources, citedPath, atom.index);
+        if (!resolution) {
+            pushDrift(findings, doc.relPath, citation, "missing-file", `could not resolve ${citedPath}: tried doc sources, ancestor climb (bare filenames only), repo-root, doc-relative, nearest prior qualified mention, repo-wide search; no candidate file exists`);
+            governing = null;
+            lastStartLine = null;
+            continue;
+        }
+        if ("skip" in resolution) {
+            governing = null;
+            lastStartLine = null;
+            continue;
+        }
+        if ("ambiguous" in resolution) {
+            pushAmbiguous(findings, doc.relPath, citation, resolution.candidates);
+            governing = null;
+            lastStartLine = null;
+            continue;
+        }
+        const problem = checkTarget(citedPath, startLine, endLine, resolution.path);
+        if (problem?.rule === "unreadable-target") {
+            pushUnreadable(findings, doc.relPath, citation, path.relative(root, resolution.path), problem.code ?? "UNKNOWN");
+        }
+        else if (problem) {
+            pushDrift(findings, doc.relPath, citation, problem.rule, problem.message, path.relative(root, resolution.path));
+        }
+        governing = { citedPath, resolvedPath: resolution.path };
+        lastStartLine = startLine;
+    }
+    return findings;
+}
+export const citationsResolveRule = {
+    id: RULE_ID,
+    description: "`path:N`/`path:N-M` citations (and their `:N`, -`M`/–`M`, (`N`) continuations) must resolve to a real target file and land on real, non-blank content. Mechanical only: does not verify the cited line is semantically correct.",
+    run(ctx) {
+        if (!ctx.repoRoot) {
+            // Never silently skip: mirrors sources-fresh's posture so a "clean"
+            // run is never a fake pass when there is no filesystem tree to
+            // resolve citation targets against.
+            return [
+                {
+                    ruleId: RULE_ID,
+                    severity: "notice",
+                    file: "",
+                    message: "citation resolution skipped: not inside a git work tree",
+                },
+            ];
+        }
+        const root = ctx.repoRoot;
+        // Fresh per invocation: see findByBasename's doc comment for why this
+        // is not held at module scope.
+        const cache = new Map();
+        return ctx.docs.flatMap((doc) => scanDoc(cache, root, ctx.bundleDir, doc));
+    },
+};
+//# sourceMappingURL=citations-resolve.js.map

package/dist/rules/citations-resolve.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"citations-resolve.js","sourceRoot":"","sources":["../../src/rules/citations-resolve.ts"],"names":[],"mappings":"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"}

package/dist/rules/index.d.ts

@@ -5,5 +5,6 @@ import { linksResolveRule } from "./links-resolve.js";
 import { noAbsoluteLinksRule } from "./no-absolute-links.js";
 import { sourcesShapeRule } from "./sources-shape.js";
 import { sourcesFreshRule } from "./sources-fresh.js";
+import { citationsResolveRule } from "./citations-resolve.js";
 export declare const allRules: Rule[];
-export { frontmatterRequiredRule, reservedFilesBareRule, linksResolveRule, noAbsoluteLinksRule, sourcesShapeRule, sourcesFreshRule, };
+export { frontmatterRequiredRule, reservedFilesBareRule, linksResolveRule, noAbsoluteLinksRule, sourcesShapeRule, sourcesFreshRule, citationsResolveRule, };

package/dist/rules/index.js

@@ -4,6 +4,7 @@ import { linksResolveRule } from "./links-resolve.js";
 import { noAbsoluteLinksRule } from "./no-absolute-links.js";
 import { sourcesShapeRule } from "./sources-shape.js";
 import { sourcesFreshRule } from "./sources-fresh.js";
+import { citationsResolveRule } from "./citations-resolve.js";
 export const allRules = [
     frontmatterRequiredRule,
     reservedFilesBareRule,
@@ -11,6 +12,7 @@ export const allRules = [
     noAbsoluteLinksRule,
     sourcesShapeRule,
     sourcesFreshRule,
+    citationsResolveRule,
 ];
-export { frontmatterRequiredRule, reservedFilesBareRule, linksResolveRule, noAbsoluteLinksRule, sourcesShapeRule, sourcesFreshRule, };
+export { frontmatterRequiredRule, reservedFilesBareRule, linksResolveRule, noAbsoluteLinksRule, sourcesShapeRule, sourcesFreshRule, citationsResolveRule, };
 //# sourceMappingURL=index.js.map

package/dist/rules/index.js.map

@@ -1 +1 @@
-{"version":3,"file":"index.js","sourceRoot":"","sources":["../../src/rules/index.ts"],"names":[],"mappings":"AACA,OAAO,EAAE,uBAAuB,EAAE,MAAM,2BAA2B,CAAC;AACpE,OAAO,EAAE,qBAAqB,EAAE,MAAM,0BAA0B,CAAC;AACjE,OAAO,EAAE,gBAAgB,EAAE,MAAM,oBAAoB,CAAC;AACtD,OAAO,EAAE,mBAAmB,EAAE,MAAM,wBAAwB,CAAC;AAC7D,OAAO,EAAE,gBAAgB,EAAE,MAAM,oBAAoB,CAAC;AACtD,OAAO,EAAE,gBAAgB,EAAE,MAAM,oBAAoB,CAAC;AAEtD,MAAM,CAAC,MAAM,QAAQ,GAAW;IAC9B,uBAAuB;IACvB,qBAAqB;IACrB,gBAAgB;IAChB,mBAAmB;IACnB,gBAAgB;IAChB,gBAAgB;CACjB,CAAC;AAEF,OAAO,EACL,uBAAuB,EACvB,qBAAqB,EACrB,gBAAgB,EAChB,mBAAmB,EACnB,gBAAgB,EAChB,gBAAgB,GACjB,CAAC"}
+{"version":3,"file":"index.js","sourceRoot":"","sources":["../../src/rules/index.ts"],"names":[],"mappings":"AACA,OAAO,EAAE,uBAAuB,EAAE,MAAM,2BAA2B,CAAC;AACpE,OAAO,EAAE,qBAAqB,EAAE,MAAM,0BAA0B,CAAC;AACjE,OAAO,EAAE,gBAAgB,EAAE,MAAM,oBAAoB,CAAC;AACtD,OAAO,EAAE,mBAAmB,EAAE,MAAM,wBAAwB,CAAC;AAC7D,OAAO,EAAE,gBAAgB,EAAE,MAAM,oBAAoB,CAAC;AACtD,OAAO,EAAE,gBAAgB,EAAE,MAAM,oBAAoB,CAAC;AACtD,OAAO,EAAE,oBAAoB,EAAE,MAAM,wBAAwB,CAAC;AAE9D,MAAM,CAAC,MAAM,QAAQ,GAAW;IAC9B,uBAAuB;IACvB,qBAAqB;IACrB,gBAAgB;IAChB,mBAAmB;IACnB,gBAAgB;IAChB,gBAAgB;IAChB,oBAAoB;CACrB,CAAC;AAEF,OAAO,EACL,uBAAuB,EACvB,qBAAqB,EACrB,gBAAgB,EAChB,mBAAmB,EACnB,gBAAgB,EAChB,gBAAgB,EAChB,oBAAoB,GACrB,CAAC"}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "okf-kit",
-  "version": "0.4.0",
+  "version": "0.5.0",
   "description": "CLI that validates OKF v0.1 knowledge bundles for structural correctness",
   "type": "module",
   "bin": {