vigiles 33.2.0 → 34.0.0

package/README.md

@@ -235,8 +235,9 @@ The **hooks** keep it honest in-loop — nudging the agent to tag a linter-rule
 
 - **Both lint and test** by default; scope with `--lint` / `--test`.
 - **Already have a CLAUDE.md / AGENTS.md, skills, or subagents? `audit` and `lint` read them as-is** — nothing is moved or rewritten. For the structural rules that want a typed spec, `init` sets one up **non-destructively** (`eject` undoes it).
-- Adds `vigiles` to `devDependencies`; installs the Claude Code plugin (skills + hooks) via the marketplace — globally, never vendored.
-- Declares that plugin in your repo's `.claude/settings.json` (`extraKnownMarketplaces` + `enabledPlugins`, merged into whatever is already there). This is a **reference, not content** — nothing is vendored, and it does **not** install the plugin for a teammate: an external-source plugin declared project-level [doesn't load until each person installs it](https://code.claude.com/docs/en/discover-plugins#configure-team-marketplaces). What it buys is that Claude Code **prompts** them with the install command, instead of a fresh clone silently having the npm package and none of its skills.
+- Adds `vigiles` to `devDependencies` and **links its skills into your repo**: one relative symlink per skill, `.claude/skills/<name>` → `node_modules/vigiles/skills/<name>` (`.agents/skills/` for Codex). Commit them — every clone and every fresh container then has the skills as soon as `npm install` has run. A skill of yours with the same name is never replaced; `init` names the one you didn't get.
+- Installs the Claude Code plugin via the marketplace — globally, never vendored — because it carries the **hooks**. That install is per machine; its copy of the skills is listed as `vigiles:<name>` next to the linked `<name>` (same files).
+- Declares that plugin in your repo's `.claude/settings.json` (`extraKnownMarketplaces` + `enabledPlugins`, merged into whatever is already there). This is a **reference, not content**, and it does **not** install the plugin for a teammate: an external-source plugin declared project-level [doesn't load until each person installs it](https://code.claude.com/docs/en/discover-plugins#configure-team-marketplaces). What it buys is that Claude Code **prompts** them with the install command for the hooks.
 - Wires CI as a `zernie/vigiles@v1` workflow (needs only read + PR-comment permissions) that posts a sticky PR comment + a `valid` output.
 
 Targets Claude Code and Codex out of the box, or [your own harness](docs/authoring-an-adapter.md). Prefer to write tests yourself? JS **or** TS (`*.harness.{mjs,ts}`) — run with `npx vigiles test`.

package/action.yml

@@ -19,9 +19,15 @@ inputs:
     required: false
     default: ""
   version:
-    description: "Version of the vigiles npm package to run (e.g. '1', '1.2.3', 'latest'). Use 'local' to run the action's own checkout — for dogfooding via `uses: ./` in this repo's CI."
+    description: >
+      Version of the vigiles npm package to run (e.g. '34', '34.1.2', 'latest').
+      Empty (the default) runs the vigiles THIS repo declares in package.json:
+      the installed copy when node_modules has it, else the version in
+      package-lock.json, else the declared range — and 'latest' only when the
+      repo does not declare vigiles. Use 'local' to run the action's own
+      checkout — for dogfooding via `uses: ./` in this repo's CI.
     required: false
-    default: "latest"
+    default: ""
   max-rules:
     description: "Maximum number of rules per spec file (maps to the CLI's --max-rules)."
     required: false
@@ -109,17 +115,48 @@ runs:
         fi
 
         # Resolve the runner. 'local' runs the action's own build (CI
-        # dogfood via `uses: ./`); any other value runs the published npm
-        # package at that version, so the Action reuses the same tested
-        # artifact users get from `npx vigiles`.
-        version="${VIGILES_VERSION:-latest}"
+        # dogfood via `uses: ./`); an explicit version runs the published npm
+        # package at that version. EMPTY (the default) runs the vigiles this
+        # repo declares, so CI and a local `npx vigiles` are the same version
+        # rather than two pins that drift: the installed copy, else the
+        # lockfile's version, else the declared range; `latest` only when the
+        # repo does not declare vigiles at all.
+        version="${VIGILES_VERSION:-}"
         if [[ "$version" == "local" ]]; then
           runner=(node "${VIGILES_ACTION_PATH}/dist/cli.js")
-        else
+          from="the action's own checkout"
+        elif [[ -n "$version" ]]; then
           runner=(npx --yes "vigiles@${version}")
+          from="the version input"
+        else
+          declared="$(node -e '
+            const fs = require("fs");
+            const read = (f) => { try { return JSON.parse(fs.readFileSync(f, "utf8")); } catch { return null; } };
+            const pkg = read("package.json") ?? {};
+            const spec = pkg.devDependencies?.vigiles ?? pkg.dependencies?.vigiles;
+            if (typeof spec !== "string") { console.log("none"); process.exit(0); }
+            if (fs.existsSync("node_modules/.bin/vigiles")) { console.log("installed"); process.exit(0); }
+            const lock = read("package-lock.json") ?? {};
+            const locked = lock.packages?.["node_modules/vigiles"]?.version ?? lock.dependencies?.vigiles?.version;
+            console.log(typeof locked === "string" ? "lock " + locked : "range " + spec);
+          ' 2>/dev/null || echo none)"
+          case "$declared" in
+            installed)
+              runner=(npx --no-install vigiles)
+              from="this repo's installed vigiles" ;;
+            "lock "*)
+              runner=(npx --yes "vigiles@${declared#lock }")
+              from="package-lock.json" ;;
+            "range "*)
+              runner=(npx --yes "vigiles@${declared#range }")
+              from="the range package.json declares" ;;
+            *)
+              runner=(npx --yes "vigiles@latest")
+              from="latest (this repo does not declare vigiles)" ;;
+          esac
         fi
 
-        echo "vigiles: ${runner[*]} ${args[*]}"
+        echo "vigiles: ${runner[*]} ${args[*]}  (version from ${from})"
 
         # Run, streaming to the log AND capturing for the summary/comment.
         out="$(mktemp)"

package/dist/adapter.d.ts

@@ -41,7 +41,7 @@ export { EMPTY_CHAIN } from "./core/instruction-chain.js";
  */
 export type { SettingsCodec } from "./core/settings-codec.js";
 export { jsonSettingsCodec, tomlSettingsCodec } from "./core/settings-codec.js";
-export type { HarnessRuntime } from "./core/runtime.js";
+export type { HarnessRuntime, RunEnvPolicy } from "./core/runtime.js";
 export type { HookProtocol } from "./core/hook-protocol.js";
 export type { ModelMock } from "./core/model-mock.js";
 /**

package/dist/adapters/claude-code/runtime.js

@@ -2,6 +2,75 @@
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.claudeCodeRuntime = void 0;
 exports.mockModelEnv = mockModelEnv;
+/**
+ * What a child `claude` run may inherit from its caller. The runners apply it
+ * through `src/core/run-env.ts`; this object is the only place the names live.
+ *
+ * `keep` — auth and backend selection only, as an allowlist. It replaced a
+ * `CLAUDE_*` prefix pass-through, which carried the parent session's identity
+ * into every scrubbed run. Measured 2026-10-07 on 2.1.292: a child started with
+ * the parent's session variables ran as the parent session, and a host-brokered
+ * child (`ANTHROPIC_BASE_URL`) authenticated with NO `CLAUDE_*` variable at all.
+ * Every `CLAUDE_*` name below is one the prefix used to carry and that selects
+ * or supplies credentials (each is referenced by the 2.1.292 binary).
+ * `CLAUDE_CONFIG_DIR` is left out on purpose: it points the child at the real
+ * config directory (settings, hooks, sessions, tasks) that the throwaway HOME
+ * exists to hide.
+ *
+ * `sessionIdentity` — the parent session. The first six were observed in a live
+ * session's env on 2026-10-07; the rest are session-identifying names present
+ * in the 2.1.292 binary, removed by name rather than by a measured effect.
+ */
+const claudeCodeRunEnv = {
+    keep: [
+        // Anthropic API auth + endpoint.
+        "ANTHROPIC_API_KEY",
+        "ANTHROPIC_BASE_URL",
+        "ANTHROPIC_AUTH_TOKEN",
+        "ANTHROPIC_MODEL",
+        // Carried over from the earlier list; not referenced by the 2.1.292 binary.
+        "ANTHROPIC_API_URL",
+        "ANTHROPIC_DEFAULT_HEADERS",
+        // Subscription token (`claude setup-token`) and client certificates.
+        "CLAUDE_CODE_OAUTH_TOKEN",
+        "CLAUDE_CODE_API_KEY_HELPER_TTL_MS",
+        "CLAUDE_CODE_CLIENT_CERT",
+        "CLAUDE_CODE_CLIENT_KEY",
+        "CLAUDE_CODE_CLIENT_KEY_PASSPHRASE",
+        // Cloud backends: the switch, the auth skip, and region/profile — never
+        // the secret-shaped AWS_* access keys.
+        "CLAUDE_CODE_USE_BEDROCK",
+        "CLAUDE_CODE_USE_VERTEX",
+        "CLAUDE_CODE_USE_FOUNDRY",
+        "CLAUDE_CODE_SKIP_BEDROCK_AUTH",
+        "CLAUDE_CODE_SKIP_VERTEX_AUTH",
+        "CLAUDE_CODE_SKIP_FOUNDRY_AUTH",
+        "AWS_REGION",
+        "AWS_DEFAULT_REGION",
+        "AWS_PROFILE",
+        "CLOUD_ML_REGION",
+        "GOOGLE_CLOUD_PROJECT",
+        "GOOGLE_APPLICATION_CREDENTIALS",
+    ],
+    keepHomeFiles: [".claude/.credentials.json"],
+    sessionIdentity: [
+        "CLAUDE_CODE_SESSION_ID",
+        "CLAUDE_CODE_REMOTE_SESSION_ID",
+        "CLAUDE_CODE_CHILD_SESSION",
+        "CLAUDE_CODE_MESSAGING_SOCKET",
+        "CLAUDE_CODE_MESSAGING_TOKEN",
+        "CLAUDE_SESSION_INGRESS_TOKEN_FILE",
+        "CLAUDE_SESSION_ID",
+        "CLAUDE_CODE_SESSION_ACCESS_TOKEN",
+        "CLAUDE_CODE_REMOTE_SESSION_UUID",
+        "CLAUDE_CODE_HOST_SESSION_ID",
+        "CLAUDE_CODE_CLOUD_SESSION_ID",
+        "CLAUDE_CODE_BRIDGE_SESSION_ID",
+        "CLAUDE_RUNNER_SESSION_ID",
+        "CLAUDE_RUNNER_SESSION_UUID",
+        "CLAUDE_PID",
+    ],
+};
 exports.claudeCodeRuntime = {
     name: "claude-code",
     agentBinary: "claude",
@@ -34,6 +103,7 @@ exports.claudeCodeRuntime = {
         const m = /(\d+)\.(\d+)\.\d+/.exec(raw);
         return m ? `${m[1]}.${m[2]}` : raw.trim();
     },
+    runEnv: claudeCodeRunEnv,
 };
 /**
  * Build the spawn env that points the agent CLI at the mock model: the caller's

package/dist/adapters/claude-code/skill-reachability.d.ts

@@ -4,10 +4,15 @@
  * vigiles publishes six user-facing skills (`SHIPPED_SKILLS`) — the teaching
  * surface. `test-harness` alone answers "which testing tier do I want?", the
  * question this project's docs are otherwise organized around. They reach the
- * agent through the GLOBAL plugin install (`vigiles init`, or
- * `claude plugin marketplace add zernie/vigiles` + `claude plugin install
- * vigiles@vigiles`), which lands in `~/.claude/plugins/` — deliberately never
- * vendored into the repo (`docs/agent-setup.md`).
+ * agent two ways (`docs/agent-setup.md`):
+ *
+ * - the LINKS `vigiles init` commits into `.claude/skills/` (one relative
+ *   symlink per skill into `node_modules/vigiles/skills/`, `src/skill-links.ts`)
+ *   — a fact about the REPOSITORY, so every clone and container has them once
+ *   `npm install` has run;
+ * - the GLOBAL plugin install (`claude plugin install vigiles@vigiles`, into
+ *   `~/.claude/plugins/`) — a fact about ONE machine, namespaced
+ *   `vigiles:<name>`.
  *
  * The failure this module makes loud: `npm install vigiles` ALSO puts those
  * skills on disk, at `node_modules/vigiles/skills/` (they are in package.json's
@@ -46,9 +51,10 @@
  * Shape follows `./dialect-drift.ts`: pure parsers + a best-effort local read
  * that NEVER throws + a formatter that returns null when there is nothing to
  * say, so `vigiles audit` can print it without a new verb, flag, or failure mode.
- * It is ADVISORY — it never touches the audit score, because reachability is a
- * property of the machine (is the plugin installed?), not of the repo, and a
- * score that moved between a laptop and CI for identical source would be a lie.
+ * It is ADVISORY — it never touches the audit score, because reachability is
+ * partly a property of the machine (is the plugin installed? has `npm install`
+ * run?), and a score that moved between a laptop and CI for identical source
+ * would be a lie.
  */
 import type { InstallReader } from "../../core/adapter.js";
 /** The plugin id `claude plugin install` records — `<plugin>@<marketplace>`. */
@@ -61,7 +67,7 @@ export declare const VIGILES_PLUGIN_ID = "vigiles@vigiles";
 export type ReachabilitySource = 
 /** `~/.claude/plugins/installed_plugins.json` — what `claude plugin install` writes. */
 "global-plugin"
-/** The skills vendored into the repo's own `.claude/skills/` (standalone config, always loaded). */
+/** The repo's own `.claude/skills/<name>/SKILL.md` resolves — a link `init` made, or a copy. */
  | "repo-skills";
 /** The advisory: can the agent see vigiles's skills from this repo? */
 export interface SkillReachability {
@@ -82,6 +88,18 @@ export interface SkillReachability {
      * nothing stranded if they are wired) or when the package isn't installed yet.
      */
     readonly strandedSkills: readonly string[];
+    /**
+     * Shipped skills whose `.claude/skills/<name>` entry is a LINK that does not
+     * resolve: the links came with `git clone`, the package they point into did
+     * not. The fix is `npm install`, not re-linking.
+     */
+    readonly danglingLinks: readonly string[];
+    /**
+     * Skills the package ships that the repo has not linked while it HAS linked
+     * others — the state after an upgrade adds a skill. Empty unless at least one
+     * shipped skill resolves in the repo.
+     */
+    readonly unlinkedSkills: readonly string[];
 }
 /**
  * Does the global registry record a live install of the vigiles plugin? Pure over
@@ -101,25 +119,28 @@ export declare function hasEnabledPlugin(settingsJson: string): boolean;
  * reader performs degrades to "not found".
  *
  * 🔴 IT READS THROUGH A REPO-BOUND {@link InstallReader}, NOT `node:fs`. Two of
- * its five reads are of files NO adapter claims (`package.json`, vigiles's own
+ * its reads are of files NO adapter claims (`package.json`, vigiles's own
  * package under `node_modules`), so the domain performs those and passes the
  * ANSWER; the rest go through a reader that refuses any path this adapter does
- * not claim. That is why this module no longer imports `node:fs` at all.
+ * not claim. That is why this module does not import `node:fs` at all.
  *
- * ⚠️ ONE MEASURED CHANGE, NAMED BECAUSE IT IS A CHANGE: the repo-vendored check
- * used to ENUMERATE `.claude/skills/` and compare directory names. Enumeration
- * is precisely what the reader exists to prevent, and it is not needed here —
- * the names being looked for are a fixed list — so each shipped skill is probed
- * for its own `SKILL.md` instead. The narrow difference: a directory named after
- * a shipped skill but holding no `SKILL.md` used to count as reachable and no
- * longer does. It was never loadable by the agent, which is the question asked.
+ * Each shipped skill is probed for its own `SKILL.md` rather than by listing
+ * `.claude/skills/` — enumeration is what the reader exists to prevent, and the
+ * names are known: the installed package's when it is installed, else the
+ * shipped list. A directory named after a shipped skill but holding no
+ * `SKILL.md` is not reachable; it was never loadable by the agent.
  */
 export declare function checkSkillReachability(read: InstallReader): SkillReachability | null;
 /**
- * The warning for an un-wired repo, or null when there is nothing to say
- * (reachable, or the check did not apply). Names the skill the user most likely
- * went looking for, says where the copies are stranded when they exist, and ends
- * on a command that fixes it.
+ * The advisory, or null when there is nothing to say. Most specific state
+ * first, each ending on the command that fixes it:
+ *
+ * 1. links that dangle — `npm install`;
+ * 2. nothing reaches the agent — link them (per repo), or install the plugin
+ *    (per machine);
+ * 3. only this machine's plugin reaches it — a fresh clone or container will
+ *    not have them. Not a failure; said in one line;
+ * 4. some linked, some not (an upgrade added one) — link the rest.
  */
 export declare function formatSkillReachability(r: SkillReachability | null): string | null;
 //# sourceMappingURL=skill-reachability.d.ts.map

package/dist/adapters/claude-code/skill-reachability.js

@@ -6,6 +6,9 @@ exports.hasEnabledPlugin = hasEnabledPlugin;
 exports.checkSkillReachability = checkSkillReachability;
 exports.formatSkillReachability = formatSkillReachability;
 const setup_plan_js_1 = require("../../setup-plan.js");
+const layout_js_1 = require("../../core/layout.js");
+const skill_link_target_js_1 = require("../../core/skill-link-target.js");
+const layout_js_2 = require("./layout.js");
 /** The plugin id `claude plugin install` records — `<plugin>@<marketplace>`. */
 exports.VIGILES_PLUGIN_ID = "vigiles@vigiles";
 /**
@@ -36,6 +39,10 @@ function hasEnabledPlugin(settingsJson) {
         return false;
     }
 }
+/** Where this harness keeps a repo's skills — the layout's answer, not a literal. */
+const SKILLS_HOME = (0, layout_js_1.skillsHome)(layout_js_2.claudeCodeLayout) ?? ".claude/skills";
+/** The per-repo fix, printed wherever the repo itself lacks the links. */
+const LINK_FIX = "npx vigiles init — links each skill into .claude/skills/ (relative links into node_modules; commit them), and leaves any skill you already have alone";
 /**
  * Best-effort, read-local reachability check for `vigiles audit`. Returns null
  * when the question does not apply — the repo does not depend on vigiles, or IS
@@ -43,54 +50,110 @@ function hasEnabledPlugin(settingsJson) {
  * reader performs degrades to "not found".
  *
  * 🔴 IT READS THROUGH A REPO-BOUND {@link InstallReader}, NOT `node:fs`. Two of
- * its five reads are of files NO adapter claims (`package.json`, vigiles's own
+ * its reads are of files NO adapter claims (`package.json`, vigiles's own
  * package under `node_modules`), so the domain performs those and passes the
  * ANSWER; the rest go through a reader that refuses any path this adapter does
- * not claim. That is why this module no longer imports `node:fs` at all.
+ * not claim. That is why this module does not import `node:fs` at all.
  *
- * ⚠️ ONE MEASURED CHANGE, NAMED BECAUSE IT IS A CHANGE: the repo-vendored check
- * used to ENUMERATE `.claude/skills/` and compare directory names. Enumeration
- * is precisely what the reader exists to prevent, and it is not needed here —
- * the names being looked for are a fixed list — so each shipped skill is probed
- * for its own `SKILL.md` instead. The narrow difference: a directory named after
- * a shipped skill but holding no `SKILL.md` used to count as reachable and no
- * longer does. It was never loadable by the agent, which is the question asked.
+ * Each shipped skill is probed for its own `SKILL.md` rather than by listing
+ * `.claude/skills/` — enumeration is what the reader exists to prevent, and the
+ * names are known: the installed package's when it is installed, else the
+ * shipped list. A directory named after a shipped skill but holding no
+ * `SKILL.md` is not reachable; it was never loadable by the agent.
  */
 function checkSkillReachability(read) {
     if (!read.repoDependsOnVigiles)
         return null;
-    const sources = [];
-    const installed = read.home(".claude/plugins/installed_plugins.json");
-    if (installed !== null && hasGlobalPluginInstall(installed))
-        sources.push("global-plugin");
-    // Vendored copies: only vigiles's OWN skill names count. A repo with 38
-    // unrelated skills in `.claude/skills/` is still un-wired.
-    if (setup_plan_js_1.SHIPPED_SKILLS.some((s) => read.repo(`.claude/skills/${s}/SKILL.md`)))
-        sources.push("repo-skills");
+    const shipped = read.vendoredSkillNames.length > 0
+        ? read.vendoredSkillNames
+        : setup_plan_js_1.SHIPPED_SKILLS;
+    const { inRepo, dangling } = repoSkillState(read, shipped);
+    const sources = reachabilitySources(read, inRepo);
     const reachable = sources.length > 0;
     // A project declaration is NOT a source — it makes Claude Code prompt for an
     // install, it does not perform one. Only meaningful while unreachable.
     const settings = read.repo(".claude/settings.json");
-    const declaredNotInstalled = !reachable && settings !== null && hasEnabledPlugin(settings);
     const vendored = new Set(read.vendoredSkillNames);
     return {
         reachable,
         sources,
-        declaredNotInstalled,
+        declaredNotInstalled: !reachable && settings !== null && hasEnabledPlugin(settings),
         strandedSkills: reachable
             ? []
             : setup_plan_js_1.SHIPPED_SKILLS.filter((s) => vendored.has(s)),
+        danglingLinks: dangling,
+        unlinkedSkills: inRepo.length > 0
+            ? shipped.filter((s) => !inRepo.includes(s) && !dangling.includes(s))
+            : [],
+    };
+}
+/** Which shipped skills resolve in the repo, and which are links that dangle. */
+function repoSkillState(read, shipped) {
+    const resolves = (s) => read.repo(`${SKILLS_HOME}/${s}/SKILL.md`) !== null;
+    return {
+        inRepo: shipped.filter(resolves),
+        dangling: shipped.filter((s) => !resolves(s) && isOurLink(read.repoLink(`${SKILLS_HOME}/${s}`), s)),
     };
 }
 /**
- * The warning for an un-wired repo, or null when there is nothing to say
- * (reachable, or the check did not apply). Names the skill the user most likely
- * went looking for, says where the copies are stranded when they exist, and ends
- * on a command that fixes it.
+ * A link `vigiles init` wrote (into `node_modules/vigiles/skills/<name>`). A
+ * dangling link that only shares a shipped skill's NAME is the user's own, and
+ * "run npm install" would be advice about the wrong thing.
+ */
+function isOurLink(target, name) {
+    return target !== null && (0, skill_link_target_js_1.isVigilesSkillTarget)(target, name);
+}
+/** The sources that resolved, in check order. */
+function reachabilitySources(read, inRepo) {
+    const installed = read.home(".claude/plugins/installed_plugins.json");
+    return [
+        ...(installed !== null && hasGlobalPluginInstall(installed)
+            ? ["global-plugin"]
+            : []),
+        // Only vigiles's OWN skill names count. A repo with 38 unrelated skills in
+        // `.claude/skills/` is still un-wired.
+        ...(inRepo.length > 0 ? ["repo-skills"] : []),
+    ];
+}
+/**
+ * The advisory, or null when there is nothing to say. Most specific state
+ * first, each ending on the command that fixes it:
+ *
+ * 1. links that dangle — `npm install`;
+ * 2. nothing reaches the agent — link them (per repo), or install the plugin
+ *    (per machine);
+ * 3. only this machine's plugin reaches it — a fresh clone or container will
+ *    not have them. Not a failure; said in one line;
+ * 4. some linked, some not (an upgrade added one) — link the rest.
  */
 function formatSkillReachability(r) {
-    if (!r || r.reachable)
+    if (!r)
         return null;
+    if (r.danglingLinks.length > 0)
+        return formatDangling(r);
+    if (!r.reachable)
+        return formatUnreachable(r);
+    if (!r.sources.includes("repo-skills"))
+        return (`ℹ vigiles's skills reach your agent only through this machine's plugin ` +
+            `install (~/.claude/plugins/), so a fresh clone or container won't have ` +
+            `them.\n  Fix (per repo): ${LINK_FIX}`);
+    if (r.unlinkedSkills.length > 0)
+        return (`⚠ ${String(r.unlinkedSkills.length)} of vigiles's skills aren't linked ` +
+            `into ${SKILLS_HOME}/: ${r.unlinkedSkills.join(", ")}.\n  Fix: ${LINK_FIX}`);
+    return null;
+}
+/** Links that came with the clone, into a package that did not. */
+function formatDangling(r) {
+    const plugin = r.sources.includes("global-plugin")
+        ? " This machine's plugin install still provides them as vigiles:<name>."
+        : "";
+    return (`⚠ ${String(r.danglingLinks.length)} of vigiles's skills are linked into ` +
+        `${SKILLS_HOME}/ but the links don't resolve here — node_modules/vigiles ` +
+        `isn't installed.${plugin}\n` +
+        `  Fix: npm install (a session that started before it may need /reload-skills or a restart)`);
+}
+/** Nothing reaches the agent: the per-repo fix first, the per-machine one second. */
+function formatUnreachable(r) {
     const stranded = r.strandedSkills.length > 0
         ? ` ${String(r.strandedSkills.length)} of them are sitting in ` +
             `node_modules/vigiles/skills/, which the agent never scans.`
@@ -100,12 +163,12 @@ function formatSkillReachability(r) {
             `project declaration doesn't install it — Claude Code loads an ` +
             `external-source plugin only once each collaborator installs it on their ` +
             `own machine.`
-        : `This repo depends on vigiles, but its plugin isn't installed.`;
+        : `This repo depends on vigiles, but it does not link vigiles's skills and the plugin isn't installed here.`;
     return (`⚠ vigiles's skills are NOT reachable by your agent here. ${why} So the ` +
         `shipped skills (${setup_plan_js_1.SHIPPED_SKILLS.join(", ")}) can't be selected — ` +
         `including test-harness, which picks the testing tier for you.${stranded}\n` +
-        `  Fix (per machine): claude plugin marketplace add zernie/vigiles && ` +
-        `claude plugin install ${exports.VIGILES_PLUGIN_ID}\n` +
-        `  (or run \`vigiles init\`, which does both)`);
+        `  Fix (per repo, reaches every clone): ${LINK_FIX}\n` +
+        `  Or per machine: claude plugin marketplace add zernie/vigiles && ` +
+        `claude plugin install ${exports.VIGILES_PLUGIN_ID}`);
 }
 //# sourceMappingURL=skill-reachability.js.map

package/dist/cli-flag-check.js

@@ -75,6 +75,7 @@ exports.COMMAND_FLAGS = {
         "--no-gha",
         "--no-plugin",
         "--ci-only",
+        "--full",
     ],
     compile: [],
     eject: ["--keep-spec"],