etymd 0.17.0 → 0.19.1

package/dist/{chunk-PIJZUDDQ.js → chunk-PQISPOB2.js}

@@ -1,8 +1,5 @@
 #!/usr/bin/env node
-import { DEFAULT_CONFIG } from './chunk-P6ATKV2R.js';
-import { PACK_VERSION } from './chunk-YQZDYDAK.js';
-import { readText, pathExists } from './chunk-4VPBP6K6.js';
-import path from 'path';
+import { PACK_VERSION } from './chunk-2DRA7S67.js';
 import { createHash } from 'crypto';
 
 var GENERATION_MARKER_RE = /^(?:# |<!-- )etymd:generated pack-v\S+ ([0-9a-f]{16})(?: -->)?$/;
@@ -128,6 +125,19 @@ ${[
     ].filter(Boolean).join("\n") || "# add the project's key commands"}
 \`\`\`
 
+`,
+    "md"
+  );
+}
+function generateClaudePointerMd() {
+  return stampGenerated(
+    `# CLAUDE.md
+
+Single source of truth for agent instructions lives in \`AGENTS.md\`. This pointer keeps Claude
+Code aligned with every other agent \u2014 edit \`AGENTS.md\`, not this file.
+
+@AGENTS.md
+
 `,
     "md"
   );
@@ -151,15 +161,21 @@ function contentScreenCall(opts) {
     `${indent}fi`
   ].join("\n");
 }
-function localHookCall(hook) {
+function localHookCall(hook, feedRefs = false) {
+  const refsCapture = feedRefs ? `# git hands the pushed refs to pre-push ONCE, on stdin \u2014 one line per ref:
+# "<local ref> <local sha> <remote ref> <remote sha>". The shell gate below reads them too, so
+# they are captured here and fed to each.
+refs=$(cat)
+` : "";
+  const call = feedRefs ? `printf '%s\\n' "$refs" | "$LOCAL" "$@" || exit 1` : `"$LOCAL" "$@" || exit 1`;
   return `# Repo-owned checks. This file is generated and will be overwritten; \`.githooks/${hook}.local\`
 # is yours \u2014 etymd never reads, writes, or regenerates it. Put project-specific guards there.
 # A guard running tests that build fixture repositories should scrub git's exported GIT_* names
 # first \u2014 a child git inherits them and ignores its cwd, so the suite would hit the real repo:
 #   env $(env | grep -o '^GIT_[A-Za-z0-9_]*' | sed 's/^/-u /') <your command>
 LOCAL="$(dirname "$0")/${hook}.local"
-if [ -x "$LOCAL" ]; then
-  "$LOCAL" "$@" || exit 1
+${refsCapture}if [ -x "$LOCAL" ]; then
+  ${call}
 fi`;
 }
 function generatePreCommitHook(selfBuild = false) {
@@ -168,10 +184,10 @@ function generatePreCommitHook(selfBuild = false) {
 
 ${localHookCall("pre-commit")}
 
-# Content screen \u2014 staged file bytes. Refuses to commit environment, guarded-side or identity
-# detail into a repo whose history is (or could become) public. The checker and its patterns
-# are machine-local by design, so this is a NO-OP wherever no checker is installed: safe to
-# commit anywhere, active only where you opted in.
+# Content screen \u2014 staged file bytes. Refuses to commit detail about your environment, work
+# or identity into a repo whose history is (or could become) public. The checker and its
+# patterns are machine-local by design, so this is a NO-OP wherever no checker is installed:
+# safe to commit anywhere, active only where you opted in.
 #
 # Bypass, with a reason: git commit --no-verify
 ${contentGateResolution(selfBuild)}
@@ -239,42 +255,181 @@ ${localHookCall("commit-msg")}
 exit 0
 `);
 }
+function generateShellDiscoveryScript() {
+  return stampGenerated(`#!/usr/bin/env sh
+# etymd: shell script discovery for the pre-push shellcheck step. Arguments: the scratch
+# directory the hook created, then the tracked paths to classify (NUL-delimited on the hook's
+# side, positional here). Verdicts land in the scratch: scripts (NUL-delimited matches) and one
+# dot per decision into count / zsh-count / skip-count, tallied by the hook after the pipeline.
+#
+# The hook runs it from inside a commit materialised from git's object store, so paths resolve
+# against that tree, never the working tree. A path with nothing readable behind it \u2014 a
+# submodule entry, a dangling symlink \u2014 cannot lie about its contents, so it is a disclosed
+# skip, never a block. A regular file
+# that EXISTS but cannot be read is the other branch \u2014 coverage would silently shrink, so it
+# fails, naming the path.
+#
+# The two \`[ "$?" -eq 1 ]\` guards are the match/error protocol: grep reports "no match" as 1
+# and a failure as 2 or more, and only the first is a verdict. Dropping the guard would let a
+# failing matcher pass as "not a shell script" \u2014 the exact silent coverage-shrink the
+# fail-closed rules exist to prevent. The checker does not associate \`$?\` with the enclosing
+# if-condition, which is why this shape survives the pass it serves; keep it that way.
+work=$1
+shift
+for file do
+  if [ ! -f "./$file" ]; then
+    printf . >> "$work/skip-count" || exit 1
+    continue
+  fi
+  # 4096 bytes bound the read \u2014 a binary with no newline would otherwise be copied whole
+  # into the scratch on every push. The second head restores line-1-only semantics, so a
+  # shebang embedded on a LATER line of a document cannot match the patterns below.
+  head -c 4096 "./$file" > "$work/head-bytes" || {
+    echo "etymd: cannot read tracked file for shellcheck: $file" >&2
+    exit 1
+  }
+  head -n 1 "$work/head-bytes" > "$work/first-line" || exit 1
+  if grep -qE "^#!.*[/ ](ba|da)?sh( |$)" "$work/first-line"; then
+    printf "./%s\\0" "$file" >> "$work/scripts" || exit 1
+    printf . >> "$work/count" || exit 1
+  else
+    [ "$?" -eq 1 ] || exit 1
+    if grep -qE "^#!.*[/ ]zsh( |$)" "$work/first-line"; then
+      printf . >> "$work/zsh-count" || exit 1
+    else
+      [ "$?" -eq 1 ] || exit 1
+    fi
+  fi
+done
+`);
+}
 function shellcheckStep() {
   return `
 # Shell correctness. Scripts are discovered by shebang over TRACKED files at push time, so a
-# script added later is covered without regenerating this hook. zsh is NOT in the checked set:
+# script added later is covered without regenerating this hook. The commits BEING PUSHED are
+# the bytes that ship, so each one is materialised from git's object store and checked there \u2014
+# never the working tree (wrong in both directions: a fixed tree let an unfixed commit ship, and
+# a dirty tree shared by several sessions blocked an unrelated push) and never the tip alone (a
+# bad commit under a clean tip shipped while the gate read only the tip's fix). The classifier
+# is discover-shell-scripts.sh beside this hook \u2014 tracked and shebanged like what it classifies,
+# so the scan it implements finds and checks it too. zsh is NOT in the checked set:
 # the checker cannot parse it (SC1071 is a parser-level error no inline directive can silence),
 # so checking it would fail every push on the parser, not on the script. Excluded \u2014 and said so
 # at run time below, because a coverage hole that is silent is indistinguishable from coverage.
+# The same honesty splits the unreadable: a regular file that exists but cannot be read blocks
+# the push (coverage would otherwise silently shrink), while a tracked path with nothing readable
+# behind it \u2014 a submodule entry, a dangling symlink \u2014 is counted and said so below as skipped,
+# never a block.
 #
 # "the checker", not its name, on purpose: a comment whose first word is that name is read as
 # a DIRECTIVE, and an unparseable directive is itself an error (SC1072/SC1073). A hook that
 # explains why it skips a shell dialect must not break the checker while doing it.
 if command -v shellcheck >/dev/null 2>&1; then
-  scripts=$(git ls-files -z \\
-    | xargs -0 -I{} sh -c 'head -1 "{}" 2>/dev/null | grep -qE "^#!.*[/ ](ba|da)?sh( |$)" && echo "{}"' \\
-    | sort)
-  zsh_scripts=$(git ls-files -z \\
-    | xargs -0 -I{} sh -c 'head -1 "{}" 2>/dev/null | grep -qE "^#!.*[/ ]zsh( |$)" && echo "{}"' \\
-    | sort)
-  if [ -n "$zsh_scripts" ]; then
-    echo "\u203A shellcheck: $(printf '%s\\n' "$zsh_scripts" | wc -l | tr -d ' ') zsh script(s) excluded \u2014 shellcheck cannot parse zsh (SC1071); not checked, not failed"
-  fi
-  if [ -n "$scripts" ]; then
-    echo "\u203A shellcheck ($(printf '%s\\n' "$scripts" | wc -l | tr -d ' ') scripts, blocking at severity=warning)"
-    printf '%s\\n' "$scripts" | xargs shellcheck -S warning || {
-      echo "  fix, or justify inline with '# shellcheck disable=SCxxxx  # why'"
+  (
+    # POSIX pipelines report only the LAST command's status, so discovery tallies progress in
+    # files \u2014 one dot per decision, counted with wc -c after the pipeline \u2014 rather than
+    # streaming through it: a pipeline that dies halfway cannot then pass as complete coverage,
+    # and the same tallies carry the counts to the reporting below. The classifier writes the
+    # tallies; this half only reads them.
+    # NUL delimiters preserve filenames; positional arguments avoid xargs -I size limits and
+    # interpreting filenames as shell code (never -I{}). The subshell confines cleanup to
+    # this step. The classifier itself is the tracked, shebanged helper beside this hook, so
+    # the discovery it performs finds and checks it too \u2014 the gate covers its own classifier.
+    shellcheck_tmp=$(mktemp -d) || exit 1
+    trap 'rm -rf "$shellcheck_tmp"' 0
+    trap 'exit 1' 1 2 3 15
+    # Every commit in each pushed range, never the tip alone: pushing two commits \u2014 a bad
+    # script, then its fix \u2014 passed a tip-only read while the bad commit landed on the remote.
+    # An all-zero local sha is a delete (nothing to check). An all-zero REMOTE sha is a new
+    # branch: everything no remote already has is being pushed, so the range is the local sha
+    # minus every remote-tracking ref \u2014 commits a remote already received were gated when they
+    # landed there, and the residue is exactly this push's new commits. A remote sha this clone
+    # has never seen (the remote moved on since the last fetch) cannot bound a range, so it takes
+    # the same new-branch rule instead of refusing a push the gate could have read. Enumeration
+    # failure refuses the push: a range the gate could not list is a range it did not read.
+    # (pattern) with both parens: bash 3.2 (macOS /bin/sh) cannot parse an unbalanced )
+    # in a case pattern.
+    : > "$shellcheck_tmp/shas" || exit 1
+    printf '%s\\n' "$refs" | while read -r _lref lsha _rref rsha; do
+      case "$lsha" in
+        (*[!0]*) ;;
+        (*) continue ;;
+      esac
+      case "$rsha" in
+        (*[!0]*)
+          if git cat-file -e "\${rsha}^{commit}" 2>/dev/null; then
+            git rev-list "$rsha..$lsha"
+          else
+            git rev-list "$lsha" --not --remotes
+          fi ;;
+        (*) git rev-list "$lsha" --not --remotes ;;
+      esac >> "$shellcheck_tmp/shas" || exit 1
+    done || {
+      echo "etymd: could not enumerate the commits being pushed for shellcheck" >&2
       exit 1
     }
-    # Everything below the blocking bar, shown once the push is already cleared. Never affects
-    # the exit code \u2014 advice that can fail a push is not advice.
-    advice=$(printf '%s\\n' "$scripts" | xargs shellcheck -S style -f gcc 2>/dev/null \\
-      | grep -v ': warning:\\|: error:' || true)
-    if [ -n "$advice" ]; then
-      echo "  \xB7 style/info (not blocking):"
-      printf '%s\\n' "$advice" | sed 's/^/    /'
-    fi
-  fi
+    shas=$(sort -u "$shellcheck_tmp/shas") || exit 1
+    [ -n "$shas" ] || echo "\u203A shellcheck: no commit in the pushed refs (deletes only, or nothing on stdin) \u2014 nothing to check"
+    # Resolved once, before any cd: the classifier runs inside each materialised tree, and a
+    # relative hook path would no longer point at it from there.
+    discover="$(cd "$(dirname "$0")" && pwd)/discover-shell-scripts.sh" || exit 1
+    for sha in $shas; do
+      # A fresh directory per commit, removed once that commit is checked so a long push does
+      # not pile up one full tree per commit; the subshell trap above still cleans the root on
+      # every early exit.
+      tree=$(mktemp -d "$shellcheck_tmp/commit.XXXXXX") || exit 1
+      # Checked out through a scratch index, never \`git archive\`: archive honours the
+      # export-ignore and export-subst attributes, so a script marked export-ignore would leave
+      # the checked set without a word. read-tree + checkout-index writes every tracked blob.
+      # Large-file pointers stay pointers \u2014 they are never shell, and a push must not need the
+      # network to be checked.
+      if ! git cat-file -e "\${sha}^{commit}" 2>/dev/null \\
+         || ! GIT_INDEX_FILE="$shellcheck_tmp/index" git read-tree "$sha" 2>/dev/null \\
+         || ! GIT_INDEX_FILE="$shellcheck_tmp/index" GIT_LFS_SKIP_SMUDGE=1 \\
+              git checkout-index -a -f --prefix="$tree/" 2>/dev/null; then
+        echo "\u2717 shellcheck: could not materialise $(git rev-parse --short "$sha" 2>/dev/null || echo "$sha") \u2014 refusing the push rather than certifying bytes this gate did not read" >&2
+        exit 1
+      fi
+      if [ -n "$(git ls-tree -r --name-only "$sha")" ] && [ -z "$(ls -A "$tree")" ]; then
+        echo "\u2717 shellcheck: $(git rev-parse --short "$sha" 2>/dev/null || echo "$sha") extracted to an empty tree \u2014 refusing the push" >&2
+        exit 1
+      fi
+      : > "$shellcheck_tmp/scripts" && : > "$shellcheck_tmp/count" && : > "$shellcheck_tmp/zsh-count" && : > "$shellcheck_tmp/skip-count" || exit 1
+      git ls-tree -r -z --name-only "$sha" > "$shellcheck_tmp/tracked" || {
+        echo "etymd: cannot enumerate the tree of $(git rev-parse --short "$sha" 2>/dev/null || echo "$sha") for shellcheck" >&2
+        exit 1
+      }
+      ( cd "$tree" && xargs -0 "$discover" "$shellcheck_tmp" ) < "$shellcheck_tmp/tracked" || {
+        echo "etymd: shell script discovery failed; shellcheck coverage is incomplete" >&2
+        exit 1
+      }
+      count=$(wc -c < "$shellcheck_tmp/count") || exit 1
+      zsh_count=$(wc -c < "$shellcheck_tmp/zsh-count") || exit 1
+      skip_count=$(wc -c < "$shellcheck_tmp/skip-count") || exit 1
+      if [ "$skip_count" -gt 0 ]; then
+        echo "\u203A shellcheck: $((skip_count)) tracked path(s) with nothing readable behind them (submodule or dangling symlink) \u2014 not checked, not failed"
+      fi
+      if [ "$zsh_count" -gt 0 ]; then
+        echo "\u203A shellcheck: $((zsh_count)) zsh script(s) excluded \u2014 shellcheck cannot parse zsh (SC1071); not checked, not failed"
+      fi
+      if [ "$count" -gt 0 ]; then
+        echo "\u203A shellcheck ($((count)) scripts in $(git rev-parse --short "$sha" 2>/dev/null || echo "$sha"), blocking at severity=warning)"
+        ( cd "$tree" && xargs -0 shellcheck -S warning -- < "$shellcheck_tmp/scripts" ) || {
+          echo "  fix, or justify inline with '# shellcheck disable=SCxxxx  # why'"
+          exit 1
+        }
+        # Everything below the blocking bar, shown once the push is already cleared. Never affects
+        # the exit code \u2014 advice that can fail a push is not advice.
+        advice=$( ( cd "$tree" && xargs -0 shellcheck -S style -f gcc -- < "$shellcheck_tmp/scripts" 2>/dev/null ) \\
+          | grep -v ': warning:\\|: error:' || true)
+        if [ -n "$advice" ]; then
+          echo "  \xB7 style/info (not blocking):"
+          printf '%s\\n' "$advice" | sed 's/^/    /'
+        fi
+      fi
+      rm -rf "$tree" || exit 1
+    done
+  ) || exit 1
 else
   echo "\u203A shellcheck skipped (not on PATH) \u2014 install it to gate this repo's shell scripts"
 fi`;
@@ -315,7 +470,7 @@ fi`;
   return stampGenerated(`#!/usr/bin/env sh
 # etymd: correctness gate. Mirrors CI cheapest-first; blocks the push on any failure.
 
-${localHookCall("pre-push")}${runner}
+${localHookCall("pre-push", true)}${runner}
 ${body}${shellStep}
 ${auditStep}
 
@@ -359,98 +514,4 @@ exit 0
 `);
 }
 
-// src/core/generate.ts
-function derivedCommands(facts, existingHook) {
-  const c = facts.commands;
-  const base = [c.formatCheck, c.typecheck, c.lint].filter(
-    (k) => Boolean(k) && isSafeGateCommand(c.raw[k])
-  );
-  if (c.test && existingHook && new RegExp(`\\b${c.test}\\b`).test(existingHook)) {
-    base.push(c.test);
-  }
-  return base;
-}
-function riskReachability(facts) {
-  const reasons = [];
-  if (facts.publishRoute !== "none") {
-    reasons.push("an instruction file can name a package script that no longer exists");
-  }
-  if (facts.artifacts.some((a) => a.kind === "state" && a.exists)) {
-    reasons.push("a state doc can fall far enough behind the repo to escalate");
-  }
-  return reasons;
-}
-function deriveFailOn(facts, recorded) {
-  const reachable = riskReachability(facts);
-  if (recorded.explicit) return { failOn: recorded.failOn, source: "config", reachable };
-  if (recorded.failOn === "risk" && reachable.length === 0) {
-    return { failOn: "gap", source: "derived", reachable };
-  }
-  return { failOn: recorded.failOn, source: "default", reachable };
-}
-async function planWorkflow(root, facts, opts) {
-  const out = [];
-  const add = async (rel, contents, label, executable = false) => {
-    const abs = path.join(root, rel);
-    const exists = await pathExists(abs);
-    const existing = exists ? await readText(abs) : null;
-    const differs = exists ? existing !== contents : void 0;
-    const origin = differs && existing !== null ? fileOrigin(existing) : void 0;
-    out.push({
-      path: rel,
-      contents,
-      exists,
-      differs,
-      drift: origin === "pack" ? "stale" : origin,
-      executable,
-      label
-    });
-  };
-  if (opts.agents) {
-    await add("AGENTS.md", generateAgentsMd(facts), "Minimal operating contract (scaffold)");
-  }
-  if (opts.gates) {
-    const existingPrePush = await readText(path.join(root, ".githooks", "pre-push"));
-    const selfBuild = isSelfBuildRepo(facts);
-    await add(
-      ".githooks/pre-commit",
-      generatePreCommitHook(selfBuild),
-      "Process gate (pre-commit)",
-      true
-    );
-    await add(
-      ".githooks/commit-msg",
-      generateCommitMsgHook(opts.gateConfig),
-      "Message gate (content screen, format)",
-      true
-    );
-    const gateConfig = opts.gateConfig?.commands?.length ? opts.gateConfig : {
-      commands: derivedCommands(facts, existingPrePush ?? void 0),
-      failOn: opts.gateConfig?.failOn ?? DEFAULT_CONFIG.gates.failOn,
-      publishGate: opts.gateConfig?.publishGate,
-      commitFormat: opts.gateConfig?.commitFormat,
-      allowWriting: opts.gateConfig?.allowWriting ?? []
-    };
-    const tier = deriveFailOn(facts, {
-      failOn: gateConfig.failOn,
-      explicit: opts.gateFailOnPinned ?? false
-    });
-    await add(
-      ".githooks/pre-push",
-      generatePrePushHook(facts, { ...gateConfig, failOn: tier.failOn }, selfBuild),
-      "Correctness gate (pre-push)",
-      true
-    );
-    if (opts.gateConfig?.publishGate ?? opts.publishGate ?? facts.publishable) {
-      await add(
-        "scripts/artifact-check.sh",
-        generateArtifactCheckScript(selfBuild),
-        "Content screen (published artifact)",
-        true
-      );
-    }
-  }
-  return out;
-}
-
-export { deriveFailOn, derivedCommands, isSafeGateCommand, planWorkflow, riskReachability, runPrefix };
+export { fileOrigin, generateAgentsMd, generateArtifactCheckScript, generateClaudePointerMd, generateCommitMsgHook, generatePreCommitHook, generatePrePushHook, generateShellDiscoveryScript, isSafeGateCommand, isSelfBuildRepo, runPrefix };

package/dist/{chunk-WKP7M2B3.js → chunk-UMKC3OWQ.js}

@@ -1,10 +1,10 @@
 #!/usr/bin/env node
-import { stateFreshnessLens, rankFindings, listInstructionFiles, buildTruthEnv, emptyCounters, packageManagerUsage, checkDocRefs, listStateDocuments, loadDecisionLedger, checkDecisionRefs, checkTextClaims } from './chunk-FNA4R5KT.js';
+import { stateFreshnessLens, rankFindings, listInstructionFiles, buildTruthEnv, emptyCounters, packageManagerUsage, checkDocRefs, listStateDocuments, loadDecisionLedger, checkDecisionRefs, checkTextClaims } from './chunk-WKP72Z3J.js';
 import { readLedger, reconcileLedger, writeLedger, visibleFindings } from './chunk-3E2IPCRY.js';
 import { measureContext, contextFileLabel } from './chunk-HI7NWPRA.js';
-import { scanProject } from './chunk-446EZNAQ.js';
+import { scanProject } from './chunk-6DJMKZGK.js';
 import { DEFAULT_CONFIG, ETYMD_DIR, writeCachedFacts, readBaseline, readConfig, deriveProfile, baselineCarriesMachinePath, BASELINE_FILE, CONFIG_FILE } from './chunk-P6ATKV2R.js';
-import { PACK_VERSION } from './chunk-YQZDYDAK.js';
+import { PACK_VERSION } from './chunk-2DRA7S67.js';
 import { pathExists, readText, readJson, isCiEnvironment, isExecutable } from './chunk-4VPBP6K6.js';
 import path from 'path';
 import YAML from 'yaml';
@@ -316,7 +316,7 @@ async function localHookTools(root, facts, scripts) {
   const inertCompanions = [];
   const readHook = async (name) => {
     if (!hooks.dir) return empty;
-    const text = await readText(path.join(root, hooks.dir, name));
+    const text = await readText(path.resolve(root, hooks.dir, name));
     if (!text) return empty;
     const tools = new Set(matchTools(text, scripts));
     const companion = await companionOf(root, hooks.dir, name, text, scripts);
@@ -479,7 +479,7 @@ async function probeScreener(root, facts) {
   const doors = [];
   let devBuildArm = false;
   for (const name of HOOK_FILES) {
-    const text = await readText(path.join(root, dir, name));
+    const text = await readText(path.resolve(root, dir, name));
     if (!text || !SCREEN_CALL_RE.test(text)) continue;
     doors.push(`${dir}/${name}`);
     if (text.includes(DEV_BUILD_ARM)) devBuildArm = true;
@@ -923,6 +923,11 @@ var instructionTruthLens = {
         `${counters.prospectiveSkipped} path claim(s) sit in create-this prose (the file instructs generating them) \u2014 forward-looking, not stale; skipped, not flagged.`
       );
     }
+    if (counters.fetchedSkipped) {
+      disclosures.push(
+        `${counters.fetchedSkipped} path claim(s) sit beside the URL they are fetched from \u2014 another tree's files, unverifiable here; skipped, not flagged.`
+      );
+    }
     if (counters.placeholderSkipped) {
       disclosures.push(
         `${counters.placeholderSkipped} path claim(s) are naming stand-ins (e.g. \`my-custom-skill\`) rather than real references; skipped, not flagged.`
@@ -960,7 +965,7 @@ var instructionTruthLens = {
       );
     }
     disclosures.push(
-      `Checked ${files.length} instruction file(s); commands resolved against root + ${facts.packages.length} workspace manifest(s) plus installed binaries; paths matched against root and package roots. Heuristics: workspace-filtered commands skipped (${counters.filteredSkipped}); tokens without a recognized extension treated as prose (a dir claim needs a trailing slash); gitignored claims unverifiable; create-this and stand-in path claims skipped; absolute/globbed/placeholder tokens skipped; doc mentions inside \`~/\` home paths skipped; framework-pattern staleness not checked.`
+      `Checked ${files.length} instruction file(s); commands resolved against root + ${facts.packages.length} workspace manifest(s) plus installed binaries; paths matched against root, package roots, the claiming file's directory, and directories the same file names; existence judged on the working tree (gitignored-but-present is true, gitignored-and-absent unverifiable). Heuristics: workspace-filtered commands skipped (${counters.filteredSkipped}); tokens without a recognized extension treated as prose (a dir claim needs a trailing slash); schemeless hosts read as URLs; gitignored claims unverifiable; create-this, fetched-from-URL, and stand-in path claims skipped; absolute/globbed/placeholder tokens skipped; doc mentions inside \`~/\` home paths skipped; framework-pattern staleness not checked.`
     );
     return {
       lens: LENS_ID3,

package/dist/{chunk-FNA4R5KT.js → chunk-WKP72Z3J.js}

@@ -1,5 +1,5 @@
 #!/usr/bin/env node
-import { expandFileGlobs } from './chunk-446EZNAQ.js';
+import { expandFileGlobs } from './chunk-6DJMKZGK.js';
 import { DEFAULT_CONFIG, CONFIG_FILE } from './chunk-P6ATKV2R.js';
 import { readText, isDirectory, matchesAnyGlob, normalizeRelPath, readJson, pathExists, git } from './chunk-4VPBP6K6.js';
 import path3 from 'path';
@@ -439,10 +439,13 @@ function extractCommandClaims(text) {
   return { scripts, filteredSkipped };
 }
 var PATH_TOKEN_RE = /^[A-Za-z0-9_.-]+(\/[A-Za-z0-9_.$-]+)+\/?$/;
+var HOSTNAME_RE = /^[a-z0-9-]+(?:\.[a-z0-9-]+)*\.([a-z]{2,})$/i;
 var KNOWN_EXTENSIONS = /* @__PURE__ */ new Set([
   ..."ts tsx cts mts js jsx cjs mjs json jsonc json5 md mdx mdc yml yaml toml ini cfg conf env sh bash zsh fish ps1 bat cmd css scss sass less html htm xml svg sql prisma graphql gql proto py rb rs go java kt kts swift c h cc cpp hpp cs php vue svelte astro txt log lock csv tsv png jpg jpeg gif webp ico avif woff woff2 ttf otf wasm map pem key crt tf tfvars example sample local snap ejs hbs pug".split(" ")
 ]);
 var CREATION_CONTEXT_RE = /\b(?:creat(?:e|es|ed|ing)|generat(?:e|es|ed|ing)|scaffold(?:s|ed|ing)?|quarantin(?:e|es|ed|ing)|(?:writ(?:e|es|ten|ing)|output(?:s|ted)?|emit(?:s|ted|ting)?|sav(?:e|es|ed|ing)|mov(?:e|es|ed|ing)|copy|copi(?:es|ed))\s+(?:it\s+|them\s+)?(?:to|into)|new\s+(?:file|directory|folder)|will\s+(?:be\s+)?(?:created|generated|written)|add(?:s|ed|ing)?\s+(?:a|the)\s+new)\b/i;
+var FETCH_CONTEXT_RE = /\b(?:fetch(?:es|ed|ing)?|pull(?:s|ed|ing)?|clone(?:s|d)?|download(?:s|ed|ing)?)\b/i;
+var EXTERNAL_URL_RE = /https?:\/\/|\bwww\./i;
 var PLACEHOLDER_SEGMENTS = /* @__PURE__ */ new Set(["placeholder", "foo", "bar", "baz", "qux"]);
 var PLACEHOLDER_PREFIX_RE = /^(?:my|your)-/i;
 function isPlaceholderClaim(token) {
@@ -476,14 +479,21 @@ ${line}`;
 }
 function extractPathClaims(text, opts = {}) {
   const prospectiveOnly = /* @__PURE__ */ new Map();
+  const fetchedOnly = /* @__PURE__ */ new Map();
   const namespacedOnly = /* @__PURE__ */ new Map();
   const placeholder = /* @__PURE__ */ new Set();
+  const dirs = /* @__PURE__ */ new Set();
   for (const m of text.matchAll(/`([^`\n]+)`/g)) {
     const token = m[1].trim();
     if (token.includes(" ") || token.length > 120) continue;
     if (token.startsWith("/") || token.startsWith("~") || token.startsWith("@") || token.startsWith("$"))
       continue;
     if (token.includes("://") || token.startsWith("www.")) continue;
+    if (token.includes("/")) {
+      const firstSegment = token.split("/")[0] ?? token;
+      const hostSuffix = HOSTNAME_RE.exec(firstSegment)?.[1]?.toLowerCase();
+      if (hostSuffix && !KNOWN_EXTENSIONS.has(hostSuffix)) continue;
+    }
     if (/[*?{}<>|]/.test(token)) continue;
     if (token.includes("@")) continue;
     if (!PATH_TOKEN_RE.test(token)) continue;
@@ -496,8 +506,12 @@ function extractPathClaims(text, opts = {}) {
       placeholder.add(claim);
       continue;
     }
-    const prospective2 = CREATION_CONTEXT_RE.test(claimContext(text, m.index ?? 0));
+    if (isDirClaim) dirs.add(claim);
+    const context = claimContext(text, m.index ?? 0);
+    const prospective2 = CREATION_CONTEXT_RE.test(context);
     prospectiveOnly.set(claim, (prospectiveOnly.get(claim) ?? true) && prospective2);
+    const fetched2 = FETCH_CONTEXT_RE.test(context) && EXTERNAL_URL_RE.test(context);
+    fetchedOnly.set(claim, (fetchedOnly.get(claim) ?? true) && fetched2);
     if (opts.namespaces) {
       const nsLead = new RegExp(`(${NAMESPACE_IDENT}):[ \\t]*$`).exec(text.slice(0, m.index ?? 0));
       const prefixed = isNamespace(nsLead?.[1]);
@@ -506,13 +520,15 @@ function extractPathClaims(text, opts = {}) {
   }
   const paths = [];
   const prospective = [];
+  const fetched = [];
   const namespaced = [];
   for (const [claim, only] of prospectiveOnly) {
-    if (only) prospective.push(claim);
+    if (fetchedOnly.get(claim)) fetched.push(claim);
+    else if (only) prospective.push(claim);
     else if (namespacedOnly.get(claim)) namespaced.push(claim);
     else paths.push(claim);
   }
-  return { paths, prospective, namespaced, placeholder: [...placeholder] };
+  return { paths, dirs: [...dirs], prospective, fetched, namespaced, placeholder: [...placeholder] };
 }
 var LOCAL_REF_LEADINS = new Set(
   "decision decisions entry entries ruling rulings record records ledger id ids item items see per in of on at by to as is was are were the a an and or but not with under over from via vs than after before since between through against latest newest earliest only also still now supersedes superseded superseding amends amended extends extended cites cited citing adds added adding wrote written writes locked locks closed closes opened opens resolves resolved reopened recorded number numbers".split(" ")
@@ -582,12 +598,14 @@ async function buildTruthEnv(root, facts) {
     for (const key of Object.keys(pkgJson?.scripts ?? {})) knownScripts.add(key);
   }
   const bases = [root, ...facts.packages.map((p) => path3.join(root, p.dir))];
-  const pathResolves = async (claim) => {
+  const pathResolves = async (claim, fromDir) => {
     for (const base of bases) {
       if (await pathExists(path3.join(base, claim))) return true;
       if (await pathExists(path3.join(base, "src", claim))) return true;
       if (await pathExists(path3.join(base, "scripts", claim))) return true;
     }
+    if (fromDir && fromDir !== "." && await pathExists(path3.join(root, fromDir, claim)))
+      return true;
     return false;
   };
   const binResolves = async (name) => {
@@ -617,6 +635,7 @@ function emptyCounters() {
     unverifiableCommands: 0,
     gitignoredSkipped: 0,
     prospectiveSkipped: 0,
+    fetchedSkipped: 0,
     placeholderSkipped: 0,
     qualifiedRefsSkipped: 0,
     unresolvableRefs: 0,
@@ -659,19 +678,48 @@ async function checkTextClaims(env, file, opts, counters) {
       confidence: "high"
     });
   }
-  const { paths, prospective, placeholder, namespaced } = extractPathClaims(file.text, {
-    namespaces: opts.treatNamespacedPrefixes
-  });
+  const { paths, dirs, prospective, fetched, placeholder, namespaced } = extractPathClaims(
+    file.text,
+    { namespaces: opts.treatNamespacedPrefixes }
+  );
   counters.prospectiveSkipped += prospective.length;
+  counters.fetchedSkipped += fetched.length;
   counters.placeholderSkipped += placeholder.length;
   counters.namespacedSkipped += namespaced.length;
-  const missing = [];
+  const fromDir = path3.dirname(file.path);
+  const unresolved = [];
   for (const claim of paths) {
-    if (await env.pathResolves(claim)) examined.push({ kind: "path", value: claim, exists: true });
+    if (await env.pathResolves(claim, fromDir))
+      examined.push({ kind: "path", value: claim, exists: true });
+    else unresolved.push(claim);
+  }
+  const proseBases = /* @__PURE__ */ new Set();
+  for (const dirClaim of dirs) {
+    if (await env.pathResolves(dirClaim, fromDir)) {
+      proseBases.add(dirClaim);
+      proseBases.add(path3.dirname(dirClaim));
+    }
+  }
+  const missing = [];
+  for (const claim of unresolved) {
+    let anchored = false;
+    for (const base of proseBases) {
+      if (await pathExists(path3.join(env.root, base, claim))) anchored = true;
+      else if (fromDir !== "." && await pathExists(path3.join(env.root, fromDir, base, claim)))
+        anchored = true;
+      if (anchored) break;
+    }
+    if (anchored) examined.push({ kind: "path", value: claim, exists: true });
     else missing.push(claim);
   }
   const ignoredOut = missing.length ? await git(env.root, ["check-ignore", ...missing]) : null;
   const gitignored = new Set((ignoredOut ?? "").split("\n").filter(Boolean));
+  const unproven = missing.filter((claim) => !gitignored.has(claim));
+  if (unproven.length) {
+    const dirOut = await git(env.root, ["check-ignore", ...unproven.map((claim) => `${claim}/`)]);
+    for (const line of (dirOut ?? "").split("\n").filter(Boolean))
+      gitignored.add(line.replace(/\/$/, ""));
+  }
   let pathFindings = 0;
   for (const claim of missing) {
     if (opts.rootedFirstSegments && !opts.rootedFirstSegments.has(claim.split("/")[0] ?? claim)) {
@@ -780,4 +828,4 @@ function checkDecisionRefs(file, ledger, opts, counters) {
   return { findings, examined };
 }
 
-export { KNOWN_EXTENSIONS, NAMESPACE_IDENT, NAMESPACE_STOP, PATH_TOKEN_RE, buildTruthEnv, checkDecisionRefs, checkDocRefs, checkTextClaims, emptyCounters, listInstructionFiles, listStateDocuments, loadDecisionLedger, meetsFailOn, packageManagerUsage, parseFailOnTier, rankFindings, stateFreshnessLens };
+export { HOSTNAME_RE, KNOWN_EXTENSIONS, NAMESPACE_IDENT, NAMESPACE_STOP, PATH_TOKEN_RE, buildTruthEnv, checkDecisionRefs, checkDocRefs, checkTextClaims, emptyCounters, listInstructionFiles, listStateDocuments, loadDecisionLedger, meetsFailOn, packageManagerUsage, parseFailOnTier, rankFindings, stateFreshnessLens };