@sabaiway/agent-workflow-kit 14.19.0 → 14.20.0

package/CHANGELOG.md

@@ -4,6 +4,44 @@ Semantically versioned ([semver](https://semver.org)), newest first. The `versio
 is the current release. `upgrade` mode reads a project's `docs/ai/.workflow-version` and applies
 every `migrations/<version>-<slug>.md` newer than it, in semver order.
 
+## 14.20.0 — the kit installs the Jev vendor skill: pinned, one verified copy per agent skill root, by one command you run (AD-168)
+
+**Once `TYPESAFE_API_KEY` is set, the Recommendations item `jev-skill` offers the vendor's Jev skill for every agent the
+family drives.** Its apply is `HAND-APPLY: node <kit>/tools/jev-skill.mjs --apply --claude-dir <dir>`: after your yes
+in the chat the agent hands the line over and you run it in a terminal of your own. It writes a verified copy of the
+skill into the three agent skill roots: Codex `~/.agents/skills`, Claude Code `<claude dir>/skills`
+(`CLAUDE_CONFIG_DIR` when absolute, else `~/.claude`; the line always names the dir the agent resolved) and
+Antigravity CLI `~/.gemini/config/skills`. Then restart the agent from a new terminal.
+
+- **Pinned, never updated silently.** The kit ships the vendor's `SKILL.md` and MIT `LICENSE` at v0.5.7 (commit
+  65a39f39) under `references/vendor/typesafe-ai/`, the skill text as `SKILL.md.pinned` so no agent loads the kit's own
+  copy; the command checks both digests before any write and downloads nothing. A copy at an earlier pin is replaced
+  only by your own `--apply`.
+- **Your files stay yours.** Each target is judged by content: `current`, `earlier`, `absent` or `foreign`. A foreign
+  copy, a link, an extra file or another digest is left untouched and named. The command writes through no link below
+  your home or below a Claude dir outside it, makes its temp and aside directories beside a root, never inside one,
+  re-checks each target before its rename, and lists a leftover from an interrupted run instead of removing it.
+- **A dry run first.** Without `--apply` the command writes nothing and prints the plan, the leftovers and, when
+  something is to install or replace, the apply line; the agent runs only this form, and only when you ask to see the
+  plan.
+- **One jev item at a time.** `jev-connect` while the key is not set, `jev-skill` after. A decline is recorded per
+  project as `jevSkillAck` in `docs/ai/acks.json` (`ack-write --lane jev-skill`).
+- **The guide.** `/agent-workflow-kit jev` STEP 2 prints the kit route first; the vendor's own routes follow as
+  alternatives, then one mark per target.
+- **Delegated runs.** The bundled codex and agy bridge docs say a delegated run reads the skill from its root, never
+  inherits the key, and leaves Jev requests to the orchestrator.
+- Recorded debt (Issue-027 (39)-(41)): a cleanup removal that fails after a refused rename ends the run with an
+  exception; a home or Claude dir that is not normalized (`/x/claude/.`) is walked at a wrong path; on POSIX a
+  backslash in a Claude dir name is split as a separator.
+
+## 14.19.1 — the ADR navigator stamps a cap it honours (AD-167)
+
+`references/scripts/archive-decisions.mjs` and its test: byte-identical to memory 8.1.3. `--write-navigator` stamps
+`maxLines` 200 while `docs/ai/adr/log.md` fits and the navigator's own line count past it, so a navigator past 200
+lines no longer fails the docs gate. An upgrade keeps a project's deployed `scripts/archive-decisions.mjs` byte for
+byte: a project already on the ADR store copies `archive-decisions.mjs` and `archive-decisions.test.mjs` from the
+kit's `references/scripts/` into its `scripts/`, then runs `--write-navigator` once. Nothing else in the kit changed.
+
 ## 14.19.0 — the Jev key the vendor's way: `jev-connect` claims no connection, names one restart step and saves for fish and Windows; the guide and the Recommendations item say where to run it (AD-166)
 
 **`jev-connect` no longer prints `connected`.** A saved key reaches the agent only once the agent's environment is read

package/SKILL.md

@@ -3,7 +3,7 @@ name: agent-workflow-kit
 description: Deploy or upgrade a portable AI-agent memory-and-workflow system in any project. Use when the user wants to bootstrap `docs/ai/` + an entry-point `AGENTS.md` (+ `CLAUDE.md` alias) + cap/archive/index enforcement in a new or existing repo, set up the Memory Map and session protocols, install the docs-rotation pre-commit hook, or run `/agent-workflow-kit` / `/agent-workflow-kit upgrade`. Triggers on phrases like "set up the memory system", "deploy the AI workflow here", "bootstrap docs/ai", "upgrade the workflow". New to the epic, story and task tier? Run `/agent-workflow-kit tier`. A typed decision with a confidence from Jev? Run `/agent-workflow-kit jev`.
 disable-model-invocation: true
 metadata:
-  version: '14.19.0'
+  version: '14.20.0'
 ---
 
 # agent-workflow-kit

package/bridges/antigravity-cli-bridge/SKILL.md

@@ -2,7 +2,7 @@
 name: antigravity-cli-bridge
 description: Delegate work to Google's Antigravity CLI (`agy`) — the successor to Gemini CLI — to reach Gemini, Claude, and GPT-OSS models under a Google AI Pro/Ultra subscription from the terminal. Use when the user wants to run a headless `agy` prompt, hand a focused task or second-opinion review to `agy`, install or authenticate Antigravity CLI, check or economise its quota/models, bridge project context into `agy`, set up a second delegated-execution backend beside Codex, or troubleshoot `agy` flags, models, auth, conversations, or its headless behaviour.
 metadata:
-  version: '5.7.0'
+  version: '5.7.1'
 ---
 
 # antigravity-cli-bridge
@@ -234,6 +234,13 @@ AGY_MODEL="Gemini 3.7 Flash (Low)" agy-run \
   "Without me pointing you at any file, name a project-specific skill under .agents/skills/ here and cite its path."
 ```
 
+**The Jev skill in a delegated run.** A headless `agy-run` loads the vendor's Jev skill from the user root the kit's
+`jev-skill` command fills, `~/.gemini/config/skills` — measured 2026-10-02 on agy 1.2.14: a probe skill under that
+root was listed, and none under `~/.gemini/antigravity-cli/skills`. The run never inherits `TYPESAFE_API_KEY`: the
+wrapper unsets every `*_API_KEY` before agy starts. Jev requests are the orchestrator's own, made in the user's
+environment, and their answers are passed into a brief as text; whether a headless agy command reaches a network
+host is governed by the user's agy permissions and sandbox settings, not by the bridge.
+
 ## How the main agent drives `agy` efficiently
 
 See [`references/driving-agy.md`](references/driving-agy.md) for the full playbook (delegation

package/bridges/antigravity-cli-bridge/bin/agy-review.sh

@@ -343,7 +343,7 @@ DEFAULT_AGY_REVIEW_MODEL="Gemini 3.8 Flash (High)"
 # Review-receipt identity (AD-038). AW_BRIDGE_VERSION mirrors this bridge's SKILL.md/capability.json
 # version (drift-guarded by agy-review.test.mjs against capability.json).
 AW_RECEIPT_BACKEND="agy"
-AW_BRIDGE_VERSION="5.7.0"  # aw-version-anchor
+AW_BRIDGE_VERSION="5.7.1"  # aw-version-anchor
 # `-` not `:-` so an EXPLICIT empty AGY_MODEL= survives (drop --model, use settings.json — agy.sh:52).
 AGY_MODEL="${AGY_MODEL-$DEFAULT_AGY_REVIEW_MODEL}"
 # D5 control-byte screen — IMMEDIATELY after resolution, BEFORE the off-frontier advisory (or any

package/bridges/antigravity-cli-bridge/capability.json

@@ -3,7 +3,7 @@
   "schema": 1,
   "name": "antigravity-cli-bridge",
   "kind": "execution-backend",
-  "version": "5.7.0",
+  "version": "5.7.1",
   "provides": ["review", "probe"],
   "posture": { "model": "Gemini 3.8 Flash (High)" },
   "roles": {

package/bridges/codex-cli-bridge/SKILL.md

@@ -2,7 +2,7 @@
 name: codex-cli-bridge
 description: Delegate work to the OpenAI Codex CLI (`codex`) under a ChatGPT subscription — run plan/instruction EXECUTION in a sandboxed workspace, or get a read-only ADVISORY review of a plan or working-tree diff — as a second delegated-execution backend beside Antigravity. Use when the user wants to hand a bounded coding task or plan to `codex exec`, get a second-opinion review from codex, install or authenticate Codex CLI, understand its sandbox/network/approval policy, drive codex efficiently from the main agent (exec vs review, resume, the commit boundary), bridge project context (`AGENTS.md`) into codex, or troubleshoot codex flags, models, auth, or its no-TTY headless behaviour.
 metadata:
-  version: '3.8.0'
+  version: '3.8.1'
 ---
 
 # codex-cli-bridge
@@ -236,6 +236,12 @@ avoided). And the execution contract tells codex: if the project declares **no**
 set, **STOP and report** rather than invent checks. Pass `--skip-git-repo-check` to codex only when
 you truly mean it.
 
+**The Jev skill in a delegated run.** A `codex-exec` run loads the vendor's Jev skill from the user root the kit's
+`jev-skill` command fills, `~/.agents/skills` — measured 2026-10-02: a run under `--ignore-user-config` listed the
+skills of that root. The run never inherits `TYPESAFE_API_KEY`: the wrappers unset every `*_API_KEY` before codex
+starts. codex exec has no network, so Jev requests are the orchestrator's own, made in the user's environment, and
+their answers are passed into a brief as text.
+
 ## How the main agent drives `codex` efficiently
 
 See [`references/driving-codex.md`](references/driving-codex.md) for the full playbook. Essentials:

package/bridges/codex-cli-bridge/bin/codex-exec.sh

@@ -373,7 +373,7 @@ CHATGPT_LOGIN_GUARD="Logged in using ChatGPT"
 # receipt this wrapper mints; scripts/release/version-sync.mjs bumps it under the one-anchor-per-file
 # rule, so a release can never leave it behind (the AD-053 drift class).
 AW_RECEIPT_BACKEND="codex"
-AW_BRIDGE_VERSION="3.8.0"  # aw-version-anchor
+AW_BRIDGE_VERSION="3.8.1"  # aw-version-anchor
 # The kill grace handed to timeout(1) as --kill-after, and recorded in the receipt as killGraceS:
 # ONE constant, so the number the ledger checks against the dispatch deadline is the number the run
 # actually applied.

package/bridges/codex-cli-bridge/bin/codex-review.sh

@@ -284,7 +284,7 @@ DEFAULT_CODEX_EFFORT="high"
 # Review-receipt identity (AD-038). AW_BRIDGE_VERSION mirrors this bridge's SKILL.md/capability.json
 # version (drift-guarded by codex-review.test.mjs against capability.json).
 AW_RECEIPT_BACKEND="codex"
-AW_BRIDGE_VERSION="3.8.0"  # aw-version-anchor
+AW_BRIDGE_VERSION="3.8.1"  # aw-version-anchor
 CODEX_MODEL="${CODEX_MODEL:-$DEFAULT_CODEX_MODEL}"
 CODEX_EFFORT="${CODEX_EFFORT:-$DEFAULT_CODEX_EFFORT}"
 # Generous hard cap for a slow review at the pinned effort (subscription latency varies).

package/bridges/codex-cli-bridge/capability.json

@@ -3,7 +3,7 @@
   "schema": 1,
   "name": "codex-cli-bridge",
   "kind": "execution-backend",
-  "version": "3.8.0",
+  "version": "3.8.1",
   "posture": { "model": "gpt-6-astra", "effort": "high", "tier": null },
   "provides": ["execute", "review"],
   "roles": {

package/capability.json

@@ -3,7 +3,7 @@
   "schema": 1,
   "name": "agent-workflow-kit",
   "kind": "composition-root",
-  "version": "14.19.0",
+  "version": "14.20.0",
   "provides": [],
   "roles": {},
   "detect": {

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@sabaiway/agent-workflow-kit",
-  "version": "14.19.0",
+  "version": "14.20.0",
   "description": "Portable, cross-agent memory & workflow for AI coding agents — Claude Code, Codex, Cursor, Devin Desktop. One command deploys an AGENTS.md entry point + docs/ai context with cap/archive/index enforcement into any repo.",
   "keywords": [
     "ai-agents",

package/references/modes/jev.md

@@ -1,14 +1,15 @@
 ### Mode: jev
 
 <!-- opt-in-capability: jev-connect -->
+<!-- opt-in-capability: jev-skill -->
 
-Read-only. The Jev guide: what Jev (TypeSafe) is, why it pays in this workflow, what it is not, the two steps to a set key and three prompts where it pays. The guide writes no file, opens no connection, never prints the key's value and never commits.
+Read-only. The Jev guide: what Jev (TypeSafe) is, why it pays in this workflow, what it is not, the two steps — a set key and the vendor skill installed by the kit, pinned — and three prompts where it pays. The guide writes no file, opens no connection, never prints the key's value and never commits.
 
 Run `node ${CLAUDE_SKILL_DIR}/tools/jev-guide.mjs --dir <project> --json`.
 
 Render the returned envelope compactly in the user's conversational language. Never paste the JSON. Keep every path and every command verbatim, each command on its own line so it runs as printed; translate only the prose around them. Keep the one vendor-quoted text verbatim and in quotes, never translated or reflowed: the not-a-replacement sentence. The `Run it in <place>:` line, when the guide printed one, stays directly before the connect line and is never folded into it; the restart step is relayed whole.
 
-The connect line is the user's: hand it over as printed and never run it — the command refuses without a terminal, and a terminal is not consent. The install lines are the user's too: they change the agent's own configuration outside the project. No command the guide prints is run by the agent.
+The connect line and the skill's apply line are the user's: hand each over as printed and never run it — the connect command refuses without a terminal, and a terminal is not consent for either. Only when the user asks to see the plan, run the skill command without `--apply` yourself: a read-only dry run that writes nothing. The vendor's install lines are the user's too: they change the agent's own configuration outside the project. No command the guide prints is run by the agent.
 
 Keep this order: the fixed text (WHAT, WHY HERE, NOT, SOURCES); then the two steps — the key with its connect line and its mark, the vendor skill with its install lines, its mark and its first prompt; then the three prompts where it pays.
 

package/references/modes/recommendations.md

@@ -4,7 +4,7 @@
 
 Requires: ${CLAUDE_SKILL_DIR}/references/shared/report-footer.md
 
-The **read-only deployment advisor** — the deterministic section every `upgrade` run ends with, also invocable on its own. It computes what in THIS deployment is configured sub-optimally (allowlist not seeded, autonomy render drifted, sandbox unavailable, gates undeclared, a declared gate matrix that verifies nothing, bridge friction, sandbox-mask clutter, an unacknowledged sandbox recipe, a configured `subagent` carrier whose executor vehicle cannot carry it, a difference from the reference profile the project has not declined, Jev not connected on this host) and renders **verdict-first**: one composed verdict line, then each item as **{severity · what is sub-optimal · the benefit in ONE plain line · an optional `recipe:` line (the `sandbox-lane` live recipe — egress hosts + resolved writable dirs — the `worktrees-dir` hand-apply-first grant advice, or the `agents` / `executor-vehicle` hidden-mode reconcile follow-up) · the exact consent-gated apply one-liner}**. The tool computes deterministic English DATA; **you PRESENT the section in the user's conversational language** — every fact, count and item from the tool, nothing added or dropped; commands, paths, hosts and rule strings stay **byte-exact**; show the raw tool block on request (the AD-032 report-contract lane — the tool cannot know the dialogue language, so the language rendering is your presentation layer).
+The **read-only deployment advisor** — the deterministic section every `upgrade` run ends with, also invocable on its own. It computes what in THIS deployment is configured sub-optimally (allowlist not seeded, autonomy render drifted, sandbox unavailable, gates undeclared, a declared gate matrix that verifies nothing, bridge friction, sandbox-mask clutter, an unacknowledged sandbox recipe, a configured `subagent` carrier whose executor vehicle cannot carry it, a difference from the reference profile the project has not declined, Jev not connected on this host, the Jev skill not installed for every agent) and renders **verdict-first**: one composed verdict line, then each item as **{severity · what is sub-optimal · the benefit in ONE plain line · an optional `recipe:` line (the `sandbox-lane` live recipe — egress hosts + resolved writable dirs — the `worktrees-dir` hand-apply-first grant advice, or the `agents` / `executor-vehicle` hidden-mode reconcile follow-up) · the exact consent-gated apply one-liner}**. The tool computes deterministic English DATA; **you PRESENT the section in the user's conversational language** — every fact, count and item from the tool, nothing added or dropped; commands, paths, hosts and rule strings stay **byte-exact**; show the raw tool block on request (the AD-032 report-contract lane — the tool cannot know the dialogue language, so the language rendering is your presentation layer).
 
 **Live host/session facts are tool-composed only.** Every fact this section states about the current
 host or session — prompts fired, sandbox scope, whether a bypass was needed, network reachability,
@@ -39,6 +39,7 @@ Run `node ${CLAUDE_SKILL_DIR}/tools/recommendations.mjs --cwd <project-root> [--
 - `spec-adoption` — the feature-spec layer's ADOPTION STATE, judged from `docs/ai/specs/` alone through the same census `spec-check --all` runs, so a store the checker would refuse to observe is never counted here either. Both arms are OFFERS (`optional`) — the layer is opt-in, and `attention` stays reserved for a configured declaration that is broken. **`not-adopted`** (no store): every plan then cites zero governing specs by default and nothing says adoption never started; its apply is the spec-layer ensure one-liner (`ensure-configs --reconcile --only specs`, the same seed `upgrade` runs — it writes the reader/checker pairs and the store root, create-only, and skips with a stated reason where no Node evidence exists), and its `recipe:` line carries a NAMED **HAND-APPLY alternative** — the DECLINE preview (`ack-write --lane spec-adoption`, a dry-run that prints the exact `--apply`), which records `specAdoptionAck` in the family-owned `docs/ai/acks.json`. **The two are exclusive, and the order is part of the contract:** ask which the maintainer wants BEFORE the confirmation; on "seed" run the apply; on "decline" run NOTHING — hand over the preview line and let them run it and its printed `--apply`; never run the seed after a decline was chosen, and never run the decline preview for them. **`adopting`** (a store with no live contract): an optional item naming the draft count; its apply is that same decline preview (a dry-run; after the SAME confirmation you run the `--apply` it prints), and the honest remedy is authoring a contract from the skill's `SPEC_TEMPLATE.md`. A recorded decline silences BOTH arms and shows on `status` as ` — declined`; one live contract makes the decline moot. An unreadable store is a stated skip, never `flow optimal`. Risk profile: the seed writes only create-only files under `scripts/` and `docs/ai/specs/`; the decline writes one key into the ack store; nothing here authors a spec or blocks a plan.
 - `profile-gap` — each item's apply is a PREVIEW that writes nothing, and consent takes two steps: the confirmed pick runs the preview and you relay every line it prints (the environment-resolved slot values, each checker `entry:` line with its trust-chain disclosure, a Communication region the insert plans in the same run); the same line with ` --apply` appended runs only on a SECOND yes over those lines, never carried by the first. Items whose apply lines are byte-equal are one writer and take one answer: the tier preview's `--apply` writes the absent slots, the store seed and the queue seed together; the checker verb writes only its own entries; the insert writes every region it plans, all or nothing, so a `communication-absent` skip beside a declined `story-sessions-section` gets its own ask after the insert's full preview. A no records nothing and the item stays on the screen. A DECLINE is asked apart from later, before anything runs, and runs `node ${CLAUDE_SKILL_DIR}/tools/tier-preview.mjs --decline --cwd <project-root>` only when the user refuses EVERY item the tier preview then reports offered: it records each of them at the shipped lineage, and a declined item leaves the screen until a lineage step changes the profile. An undecidable entry is a stated skip naming its reason, the remedy by reason: a prior → the upgrade's `lens` reconcile; an absent region → the insert; a customized region → a hand edit only (the lens preserves it), so that skip stands and withholds `flow optimal`. Risk profile: the tier preview's `--apply` rewrites `docs/ai/orchestration.json` in canonical form with the `_README` note and creates `docs/ai/epics/.gitkeep` and `docs/plans/queue.md` create-only; the insert adds regions to `docs/ai/agent_rules.md`; the checker verb adds entries to the PRIVILEGED `docs/ai/gates.json`; the decline writes `docs/ai/profile-declines.json`; nothing here commits.
 - `jev-connect` — the apply is HAND-APPLY: the user runs the connect command in a terminal of their own, never the agent (the command refuses without a terminal, and a terminal is not consent); when the recipe line opens with `run the apply in <place>`, that place is the terminal to name. The command reads the key with no echo, makes one network call to api.typesafe.ai with the vendor's sample text only on the user's own run, and writes the key in plain text — as managed export lines in the shell's startup files (bash: ~/.bashrc and the login file, created as ~/.bash_profile when none exists; zsh: ~/.zshrc), as the kit's own file ~/.config/fish/conf.d/typesafe-api-key.fish for fish, or on Windows as the user environment variable TYPESAFE_API_KEY, stored in the Windows user environment; a process already running at the save can keep its old environment and hand it to what it starts — the guide's key mark confirms the agent sees it (a file is readable by any process running as that user, and by other local accounts when one is world-readable in a traversable home); the vendor keeps data under its processing agreement and offers zero retention only to enterprise accounts. The item reads the environment the agent's commands run in: a host setting that filters it shows the item while the key is set in the user's shell. The decline is the HAND-APPLY alternative on the recipe line, asked apart BEFORE the confirmation (the `spec-adoption` order): on "connect" hand over the apply line, on "decline" run nothing and hand over the recipe line; the decline is recorded per project as `jevConnectAck` in `docs/ai/acks.json`. Risk profile: a plain-text key in the user's startup files or the Windows user environment, written by a command the user runs; one network call from that run.
+- `jev-skill` — the apply is HAND-APPLY: the user runs the skill command in a terminal of their own, never the agent (a terminal is not consent); when the recipe line opens with `run the apply in <place>`, that place is the terminal to name. The skill is third-party text — the vendor's, MIT — that the kit ships pinned and installs as a verified copy into three agent skill roots: `~/.agents/skills`, the Claude Code skills dir (`CLAUDE_CONFIG_DIR` or `~/.claude`) and `~/.gemini/config/skills`. It is never updated silently: a copy at an earlier pin is replaced only by that command, and a foreign copy is left untouched and named on the recipe line. A copy the vendor's `skills` CLI wrote with the same bytes reads current, and a later pin move replaces it like a kit copy; a vendor plugin install is invisible to the file check, so the Claude Code root may read absent while the plugin serves it. Only when the user asks to see the plan does the agent run the command without `--apply` (a read-only dry run). The decline is the HAND-APPLY alternative on the recipe line, asked apart BEFORE the confirmation: on "install" hand over the apply line, on "decline" run nothing and hand over the recipe line; the decline is recorded per project as `jevSkillAck` in `docs/ai/acks.json`. Risk profile: third-party text written into the user's agent skill roots by a command the user runs; no network.
 - `adr-store-migration` — other items write project files too; what is unique here is that the crossing **overwrites and deletes files the project already has**: it replaces the deployed enforcement scripts in `scripts/` (the directional subset — only basenames the project already has; a locally-edited copy is snapshotted first, never silently clobbered) and, where a retired archive file exists, DELETES it once conservation has been proven. That is why it is **HAND-APPLY** and why the command shown in the apply slot is a **`--dry-run`** — it writes nothing and prints the whole plan. `--apply` is a SEPARATE step, run only after that plan has been shown and **fresh consent** obtained for it; the consent flow executes only the apply slot, so an item that needs consent AFTER its preview cannot use that lane at all. Every write is idempotent and the run is re-runnable to completion after any interruption, so a re-run repairs rather than double-applies. It never commits. Risk profile: overwrite + delete of existing project files, gated on a preview you have actually read.
 
 **Sandbox lanes (what to DO with the `sandbox-lane` recipe, per host class):**

package/references/scripts/archive-decisions.mjs

@@ -2,7 +2,7 @@
 // One-file-per-ADR store for docs/ai/decisions.md (ADRs) — the durable replacement for the retired
 // 3-tier cascade (HOT → WARM archive → a single COLD monolith whose cap was raised release after
 // release). Every ADR beyond the HOT window becomes its OWN immutable record so no artifact is ever
-// O(n) and no cap is ever raised again.
+// O(n) and no cap is raised by hand again (the navigator stamps its own count past 200).
 //
 // HOT   (docs/ai/decisions.md)          — the active ADR window (newest at the bottom), self-bounding
 //                                         under its own frontmatter maxLines.
@@ -95,7 +95,8 @@ export const ADR_DIR_REL = 'docs/ai/adr';
 export const NAV_REL = 'docs/ai/adr/log.md';
 
 // A per-record cap (generous vs the largest real ADR ~74 lines; a body over it is a genuine smell) and
-// the navigator cap (bounded — exceeding it is the future plateau-shard trigger, Decision 8).
+// the navigator's FLOOR: the navigator stamps 200 while it fits and its own line count past it, since
+// nothing rotates a governing row out (docs/ai/specs/memory/adr-navigator.md).
 export const RECORD_CAP = 400;
 export const NAV_MAXLINES = 200;
 // How many most-recent ids the navigator's recent window carries (status-annotated, incl. supersessions).
@@ -701,8 +702,8 @@ export const computeGoverningIds = (entries) => {
   return new Set(entries.filter((e) => e.status === IN_FORCE_STATUS && !superseded.has(e.id)).map((e) => e.id));
 };
 
-const NAV_FRONTMATTER = (today) =>
-  `---\ntype: reference\nlastUpdated: ${today}\nscope: permanent\nstaleAfter: never\nowner: none\nmaxLines: ${NAV_MAXLINES}\n---\n`;
+const NAV_FRONTMATTER = (today, cap) =>
+  `---\ntype: reference\nlastUpdated: ${today}\nscope: permanent\nstaleAfter: never\nowner: none\nmaxLines: ${cap}\n---\n`;
 
 // Build docs/ai/adr/log.md from the WHOLE corpus (HOT entries ∪ adr/ records). Governing heads
 // (accepted ∧ not-superseded) sorted newest-first; superseded ADRs drop OUT (still reachable by
@@ -744,7 +745,9 @@ export const buildNavigator = (corpus, today) => {
     '',
     ...recent,
   ].join('\n');
-  return `${NAV_FRONTMATTER(today)}\n${body}\n`;
+  // The cap sits on one line whatever its value, so the count with the floor is the final count.
+  const count = lineCountOf(`${NAV_FRONTMATTER(today, NAV_MAXLINES)}\n${body}\n`);
+  return `${NAV_FRONTMATTER(today, Math.max(NAV_MAXLINES, count))}\n${body}\n`;
 };
 
 // ── snapshot (durable, pre-delete — Decision 5) ─────────────────────────────────────────

package/references/scripts/archive-decisions.test.mjs

@@ -800,6 +800,47 @@ describe('1.5 navigator — governing heads (computed), superseded drop out but
   });
 });
 
+// ── the navigator's stamped cap (docs/ai/specs/memory/adr-navigator.md) ─────────────────
+//
+// The frame is 38 lines (15 ADRs or more), so 162 governing heads make exactly 200, 163 make 201 and 170 make 208.
+
+const capOf = (text) => Number(text.match(/^maxLines: (\d+)$/m)[1]);
+const corpusOf = (n) =>
+  Array.from({ length: n }, (_, i) => {
+    const id = String(i + 1).padStart(3, '0');
+    return { id, idNum: i + 1, title: `T${id}`, status: 'accepted', supersedes: [], supersededBy: [], fileName: `AD-${id}-t.md` };
+  });
+
+describe('the navigator stamps a cap it honours', () => {
+  it('200 while it fits, its own line count past it', () => {
+    // spec:adr-navigator/S1
+    for (const heads of [2, 162]) {
+      const nav = buildNavigator(corpusOf(heads), '2026-07-09');
+      assert.equal(capOf(nav), 200, `${heads} heads keep the 200 floor`);
+    }
+    assert.equal(lineCountOf(buildNavigator(corpusOf(162), '2026-07-09')), 200);
+    // 165 entries, two superseded: 163 heads, 201 lines — a stamp from the entry count would read 203.
+    const corpus = corpusOf(165).map((e, i) => (i < 2 ? { ...e, supersededBy: ['003'] } : e));
+    const big = buildNavigator(corpus, '2026-07-09');
+    assert.equal(lineCountOf(big), 201);
+    assert.equal(capOf(big), 201, 'past the floor the stamp is the file\'s own count');
+  });
+
+  it('a written navigator past 200 lines fits its cap, --check is green, a hand-edited cap is stale', () => {
+    // spec:adr-navigator/S2
+    const root = makeRoot();
+    seedMigrated(root, { hotIds: ['901'], storeIds: corpusOf(169).map((e) => e.id) });
+    const nav = readFileSync(join(root, NAV_REL), 'utf8');
+    assert.ok(lineCountOf(nav) > 200, 'the fixture is past the floor');
+    assert.ok(lineCountOf(nav) <= capOf(nav), 'the docs gate accepts the written navigator');
+    assert.equal(run(['--check', '--today=2026-07-09'], root).code, 0);
+    writeFileSync(join(root, NAV_REL), nav.replace(/^maxLines: \d+$/m, 'maxLines: 999'));
+    const stale = run(['--check', '--today=2026-07-09'], root);
+    assert.equal(stale.code, 1);
+    assert.match(stale.errText, /log\.md is stale/);
+  });
+});
+
 // ── item (h) degrade branches on the REAL default regenerator (no injection) ───────────
 
 describe('defaultRegenerateIndex — loud-degrade branches', () => {

package/references/vendor/typesafe-ai/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2026 TypeSafe AI
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

package/references/vendor/typesafe-ai/SKILL.md.pinned

@@ -0,0 +1,149 @@
+---
+name: typesafe-ai
+license: MIT
+description: >
+  Build AI-powered software with TypeSafe: small units of AI intelligence you
+  can use like programming primitives. Its System One models, including Jev,
+  turn natural language and application state into typed judgments and
+  probabilities that code can combine. Use when a feature needs programmable
+  common sense, when brainstorming what AI could make possible in an app, or
+  when an LLM prompt-and-parse step could become a structured decision.
+  Applications include routing, ranking, extraction, verification, and
+  interactive experiences; these are starting points, not the limits.
+  Read live docs and cookbooks to find useful patterns and discover new combinations.
+---
+
+# Build with TypeSafe
+
+TypeSafe makes units of AI intelligence usable like programming primitives: small
+judgments you can compose into larger capabilities. Its **System One models** return
+fast, focused judgments that software can consume directly. **Jev** is TypeSafe's
+flagship and first System One model. It understands natural language and returns
+typed answers and probabilities rather
+than generating text or reasoning explanations. Code owns the workflow; the model
+supplies programmable common sense where ordinary code needs semantic understanding.
+
+## Read the live docs
+
+**The live TypeSafe docs are the source of truth. Read them as part of the task.**
+This skill gives direction; the docs carry current concepts, prompting guidance,
+API contracts, SDK usage, models, limits, and worked examples.
+
+- Start with the [documentation index](https://docs.typesafe.ai/llms.txt) to discover
+  relevant pages and cookbooks. Use targeted reads rather than loading the entire site.
+- Mintlify serves Markdown by appending `.md` to a page path, for example
+  [how to build with TypeSafe](https://docs.typesafe.ai/concepts/how-to-build-with-system-one.md).
+  Follow links from the index; convert extensionless documentation page links to
+  `.md` when useful. Resolve relative links against `https://docs.typesafe.ai`.
+- Before writing an integration, read the current API or chosen SDK page and the
+  question guidance relevant to the design. For a new workflow, also inspect the
+  closest cookbook: it often shows a better decomposition than a generic classifier.
+- If the index is unavailable, use the direct links below or the site's navigation.
+  If Markdown fetching fails, try the normal page. If live access is unavailable,
+  use available local docs or installed SDK types, state that limitation, and avoid
+  inventing version-dependent details.
+
+| Task | Start here; follow the relevant details |
+| --- | --- |
+| Understand the programming model | [System One](https://docs.typesafe.ai/concepts/system-one.md), [building guide](https://docs.typesafe.ai/concepts/how-to-build-with-system-one.md) |
+| Explore what to build | [Use-case map](https://docs.typesafe.ai/concepts/use-case-map.md), then relevant cookbooks from the index |
+| Prepare inputs and questions | [State](https://docs.typesafe.ai/concepts/state.md), [primitives](https://docs.typesafe.ai/primitives.md), then the chosen primitive's page |
+| Decide how to handle uncertainty | [Confidence](https://docs.typesafe.ai/confidence.md) |
+| Write API code | [HTTP API](https://docs.typesafe.ai/api.md), [Python SDK](https://docs.typesafe.ai/sdk/python.md), or [JavaScript SDK](https://docs.typesafe.ai/sdk/javascript.md) |
+| Update an older integration | [Migration guide](https://docs.typesafe.ai/migrating-to-v1.md) and the installed SDK's current reference |
+
+## Find the useful shape
+
+Start from the behavior the user wants: what will the application show, select,
+change, or hand off? Work backward to the judgments it needs. Keep known rules,
+calculations, exact lookups, and execution in code. Preserve the user's chosen stack
+and scope; add TypeSafe where semantic understanding helps.
+
+When brainstorming or choosing an architecture, consider more than classification.
+The patterns below are starting points: combine primitives around the user's goal,
+including ideas that do not fit an established recipe.
+
+- **Route and fill known arguments.** A request can select a handler and its typed
+  parameters. Ask useful branch-specific questions up front and consume only the
+  relevant answers. Explore [function calling](https://docs.typesafe.ai/cookbooks/function_calling.md)
+  and [speculative fan-out](https://docs.typesafe.ai/patterns/fan-out.md).
+- **Select instead of generate.** Find candidate values or source spans in code,
+  use a judgment to select the intended one, then copy or normalize it. Code can
+  also assemble source text into a formatted document or reading guide. Explore
+  [value extraction](https://docs.typesafe.ai/cookbooks/pre_parsed_value_extraction_cookbook.md)
+  and [structure recovery](https://docs.typesafe.ai/cookbooks/autoformat.md).
+- **Find and judge evidence.** Retrieve candidates, compare their relevance to a
+  query, and select useful context. Explore [reranking](https://docs.typesafe.ai/cookbooks/rerank_typesafe.md)
+  and [hierarchical classification](https://docs.typesafe.ai/cookbooks/hierarchical_classification.md).
+- **Turn judgments into reusable data.** Score dimensions once, then let code or
+  user controls change weights, thresholds, rankings, and views. With labeled
+  outcomes, those signals can become classical ML features. Explore
+  [composite scoring](https://docs.typesafe.ai/patterns/composite-scoring.md) and
+  [feature discovery](https://docs.typesafe.ai/cookbooks/autoresearch_feature_discovery.md).
+- **Verify and escalate.** Check specific claims or fields against their evidence;
+  send uncertain or failing cases to a person or reasoning model. Explore
+  [citation checks](https://docs.typesafe.ai/cookbooks/citation_check.md) and
+  [extraction cascades](https://docs.typesafe.ai/cookbooks/sde_cascade.md).
+- **Respond to changing state.** Code can retain goals and observations while fresh
+  judgments guide the next bounded step. Keep inferred state distinct from observed
+  facts, and check freshness before applying a result to a changed situation.
+
+For open-ended requests, offer the few directions that best serve the user's goal
+and recommend a starting point. For a concrete request, choose the relevant pattern
+and build; a brainstorm is not a mandatory detour.
+
+## Design the judgments
+
+Choose by what the answer means, then read the relevant primitive page:
+
+| Need | Primitive | Important distinction |
+| --- | --- | --- |
+| One of a defined set | [Choice](https://docs.typesafe.ai/primitives/choice.md) | Picks one option; its distribution compares competing options |
+| Whether a condition holds | [Noul](https://docs.typesafe.ai/primitives/noul.md) | Probability of yes; no separate confidence; use one per label when several may apply |
+| Degree along a described dimension | [Score](https://docs.typesafe.ai/primitives/score.md) | Probability-weighted position on ordered levels; use comparable per-item Scores for graded ranking |
+
+Give each question enough relevant **state** to answer: source text, identities,
+relationships, policies, and current facts. Prefer named JSON fields when context
+has several parts. Put the judgment in **instructions** and define its possible
+answers in **criteria**. Question IDs are for code and are not sent to the model;
+include complete meaning in the question. Reference nested state with backticked
+paths such as `ticket.messages[0].text`.
+
+Ask one narrow, coherent judgment per question. Split independently useful dimensions,
+without destroying the relationship being judged. A bounded action selection or
+contextual interpretation is valid; atomic does not mean literal fact extraction
+or a one-sentence limit. Strings work for simple questions. Use structured objects
+or arrays when definitions, contrasts, exclusions, or examples clarify instructions
+or criteria. Score levels must describe concrete situations and stand on their own.
+
+Keep the needed answers available. Include a no-match outcome when nothing may fit;
+use a separate presence judgment when it is independently useful. For source-value
+selection, check candidate coverage: the model cannot choose an omitted value.
+
+## Compose and verify
+
+**Ask independent questions over the same state together**, including useful
+speculative questions. They run in parallel and cannot see one another's answers.
+State each speculative premise explicitly; code consumes the applicable answers.
+A second request is warranted when an earlier answer is needed to fetch evidence,
+construct new state, or determine the next options. Extra questions still use tokens;
+measure actual request budgets, cost, and end-to-end latency.
+
+Use probabilities and confidence to guide behavior, with thresholds evaluated on
+the user's data and consequences. Choice/Score confidence summarizes distribution
+concentration, not overall workflow correctness or permission to act. A Noul near
+0.5 means similar probability for yes and no, not medium intensity. Several
+acceptable alternatives can also spread probability; low confidence need not
+invalidate a harmless preference choice. Ignore uncertainty on unused branches.
+
+Keep policy explicit and raw judgments reusable. Weighted scores suit compensating
+preferences; an “any serious violation” rule needs separate conditions. Changing a
+weight or display filter need not rerun inference when evidence and question meanings
+are unchanged. Typed output guarantees the interface, not truth. System One models
+are trained for calibrated decisions; validate their performance in the target domain.
+
+Test representative cases and the resulting application behavior. For failures,
+inspect the exact state, questions, candidates, answers, composition, and observed
+outcome. Separate missing evidence, model errors, code errors, and service failures.
+Treat cookbook thresholds and demo results as examples to evaluate, not universal
+rules or permanent model limitations. Keep API credentials server-side in web apps.

package/tools/ack-store.mjs

@@ -15,6 +15,7 @@ export const ACKS_COVERAGE_DOMAIN_KEY = 'coverageDomainAck';
 export const ACKS_SOURCE_SIZE_COPY_KEY = 'sourceSizeCopyAck';
 export const ACKS_SPEC_ADOPTION_KEY = 'specAdoptionAck';
 export const ACKS_JEV_CONNECT_KEY = 'jevConnectAck';
+export const ACKS_JEV_SKILL_KEY = 'jevSkillAck';
 
 // The CLOSED-WORLD ack-lane registry: the lane name an advisor item renders on the writer's command line ->
 // the store key that writer sets. A lane the registry does not name is a usage refusal at the writer.
@@ -25,6 +26,7 @@ export const ACK_LANES = Object.freeze({
   'source-size-copy': ACKS_SOURCE_SIZE_COPY_KEY,
   'spec-adoption': ACKS_SPEC_ADOPTION_KEY,
   'jev-connect': ACKS_JEV_CONNECT_KEY,
+  'jev-skill': ACKS_JEV_SKILL_KEY,
 });
 
 export const FINGERPRINT_LENGTH = 16;

package/tools/jev-facts.mjs

@@ -1,8 +1,10 @@
 // spec:jev-guide — docs/ai/specs/kit/jev-guide/index.md
-// The one leaf the Jev surfaces share: the key rule, the connect line, and the vendor facts the
-// connect command's one request uses. No side effect, no import beyond node:path — the read-only
-// guide imports it under its closed import graph, the advisor and the connect command beside it.
-import { join } from 'node:path';
+// The one leaf the Jev surfaces share: the key rule, the connect line, the vendor facts the connect
+// command's one request uses, and the vendor skill's pin, targets, state rule and apply line. No side
+// effect, no import beyond node:path and node:crypto — the read-only guide imports it under its closed
+// import graph, the advisor and the two commands beside it; file primitives arrive through `io`.
+import { createHash } from 'node:crypto';
+import { join, posix, win32 } from 'node:path';
 
 export const KEY_VARIABLE = 'TYPESAFE_API_KEY';
 
@@ -56,3 +58,98 @@ export const JEV_ERROR_MEANINGS = Object.freeze({
   429: 'You have exceeded your rate limit. Back off and retry after a short delay.',
   529: 'TypeSafe is temporarily overloaded. Retry after a short delay.',
 });
+
+// ── the vendor skill (part jev-skill) ─────────────────────────────────────────────────────────────
+// Each target file name -> the name the kit ships it under. The shipped SKILL.md is renamed so no agent
+// walking the kit's own tree (a skill folder itself) loads the vendor's text before the user's --apply.
+export const SKILL_FILES = Object.freeze({ 'SKILL.md': 'SKILL.md.pinned', LICENSE: 'LICENSE' });
+// Newest first; a release that moves the pin puts the new entry first and removes none.
+export const SKILL_PINS = Object.freeze([Object.freeze({
+  tag: 'v0.5.7',
+  commit: '65a39f393687675ce170e6094757de20370365b9',
+  digests: Object.freeze({
+    'SKILL.md': '71ea90d7906c6554c4f4c460ef7361b2d26f59116ccdae986dc6d997b9389f52',
+    LICENSE: '835f233f1d6ed84a9b9a351aba0689b47644a4137d6316911fc7957bde523b02',
+  }),
+})]);
+export const AFTER_INSTALL = 'After an install, quit the agent and start it again from a new terminal.';
+export const NO_APPLY_LINE = 'the apply line cannot be printed here: a path holds a control character';
+
+const isControl = (char) => char.charCodeAt(0) < 0x20 || char.charCodeAt(0) === 0x7f;
+// Display only: every path, entry name and reason a surface prints; never a command line.
+export const printable = (text) => [...String(text)].map((char) => (isControl(char) ? '?' : char)).join('');
+
+// The Claude Code dir the agent's environment names: an absolute CLAUDE_CONFIG_DIR for the platform, else <home>/.claude.
+export const claudeDirOf = (env = {}, home = '', platform) => {
+  const value = env.CLAUDE_CONFIG_DIR;
+  const set = typeof value === 'string' && value !== '';
+  if (set && (platform === 'win32' ? win32 : posix).isAbsolute(value)) return { dir: value, fromEnv: true, note: '' };
+  const dir = home === '' ? '' : join(home, '.claude');
+  return { dir, fromEnv: false,
+    note: set ? printable(`CLAUDE_CONFIG_DIR is set to ${value}, not an absolute path: the Claude Code target is ${dir}`) : '' };
+};
+
+// The host separator, read off the host's own join.
+const SEP = join('a', 'b').slice(1, -1);
+const within = (path, dir) => path.startsWith(dir.endsWith(SEP) ? dir : `${dir}${SEP}`);
+// The three targets in their order; a later record on an earlier one's path merges into it, and a later
+// record inside an earlier one's path, or holding it, carries `overlaps`.
+export const skillTargets = ({ home = '', claudeDir = '' } = {}) => {
+  if (home === '') return [];
+  const records = [
+    { agent: 'Codex', base: home, root: join(home, '.agents', 'skills') },
+    { agent: 'Claude Code', base: within(claudeDir, home) ? home : claudeDir, root: join(claudeDir, 'skills') },
+    { agent: 'Antigravity CLI', base: home, root: join(home, '.gemini', 'config', 'skills') },
+  ].map((record) => ({ ...record, path: join(record.root, 'typesafe-ai') }));
+  return records.reduce((kept, record) => {
+    const same = kept.find(({ path }) => path === record.path);
+    if (same) return kept.map((item) => (item === same ? { ...item, agent: `${item.agent} and ${record.agent}` } : item));
+    const other = kept.find(({ path }) => within(record.path, path) || within(path, record.path));
+    return [...kept, other ? { ...record, overlaps: other.path } : record];
+  }, []);
+};
+
+const digestOf = (bytes) => createHash('sha256').update(bytes).digest('hex');
+const codeOf = (error) => error?.code ?? error?.message ?? String(error);
+// The state of one target, by content and never by name; pure over io.lstat, io.readdir, io.readFile and io.pins.
+export const skillState = (target, io) => {
+  const foreign = (reason) => ({ state: 'foreign', tag: null, reason });
+  if (target.overlaps) return foreign(`overlaps ${target.overlaps}`);
+  const pins = io.pins ?? SKILL_PINS;
+  try {
+    const names = target.path.slice(target.base.length).split(SEP).filter(Boolean);
+    let at = target.base;
+    for (const [index, name] of names.entries()) {
+      at = join(at, name);
+      let stat;
+      try { stat = io.lstat(at); } catch (error) {
+        if (error?.code === 'ENOENT' || error?.code === 'ENOTDIR') return { state: 'absent', tag: null, reason: null };
+        return foreign(codeOf(error));
+      }
+      if (stat.isSymbolicLink()) return foreign(`a link at ${at}`);
+      if (!stat.isDirectory()) return foreign(index === names.length - 1 ? 'not a directory' : `${at} is not a directory`);
+    }
+    const entries = [...io.readdir(target.path)].map(String).sort();
+    if (entries.join('/') !== 'LICENSE/SKILL.md') return foreign(`holds ${entries.join(', ') || 'no entry'}`);
+    for (const name of entries) {
+      if (!io.lstat(join(target.path, name)).isFile()) return foreign(`${name} is not a regular file`);
+    }
+    const found = Object.fromEntries(entries.map((name) => [name, digestOf(io.readFile(join(target.path, name)))]));
+    const pinAt = pins.findIndex(({ digests }) => Object.keys(SKILL_FILES).every((name) => digests[name] === found[name]));
+    if (pinAt === 0) return { state: 'current', tag: pins[0].tag, reason: null };
+    if (pinAt > 0) return { state: 'earlier', tag: pins[pinAt].tag, reason: null };
+    return foreign('matches no pin');
+  } catch (error) {
+    return foreign(codeOf(error));
+  }
+};
+
+// The skill command's apply line, always with the Claude Code dir its caller resolved; '' when a path holds a control byte.
+export const skillLine = (toolsDir, platform, claudeDir) => {
+  if ([...`${toolsDir}${claudeDir}`].some(isControl)) return '';
+  if (platform === 'win32') {
+    const quoted = (value) => `'${value.replace(/'/g, "''")}'`;
+    return `node ${quoted(`${toolsDir}\\jev-skill.mjs`)} --apply --claude-dir ${quoted(claudeDir)}`;
+  }
+  return `node ${quoteArg(join(toolsDir, 'jev-skill.mjs'))} --apply --claude-dir ${quoteArg(claudeDir)}`;
+};

package/tools/jev-guide.mjs

@@ -1,17 +1,17 @@
 #!/usr/bin/env node
 // spec:jev-guide — docs/ai/specs/kit/jev-guide/index.md
-import { statSync } from 'node:fs';
+import { lstatSync, readFileSync, readdirSync, statSync } from 'node:fs';
 import { homedir, hostname } from 'node:os';
 import { basename, dirname, join, resolve } from 'node:path';
 import { fileURLToPath } from 'node:url';
 import { fail } from '../references/scripts/markdown-blocks.mjs';
 import { isDirectRun } from './direct-run.mjs';
-import { KEY_VARIABLE, RESTART_STEP, connectLine, keySet, placeOf } from './jev-facts.mjs';
+import { AFTER_INSTALL, KEY_VARIABLE, NO_APPLY_LINE, RESTART_STEP, SKILL_PINS, claudeDirOf, connectLine, keySet, placeOf, printable, skillLine, skillState, skillTargets } from './jev-facts.mjs';
 
 const SCHEMA = 1;
 const TOOLS = dirname(fileURLToPath(import.meta.url));
 const SKILL_FILE = join('typesafe-ai', 'SKILL.md');
-const HELP = `jev — read-only: what Jev (TypeSafe) is, why it pays here, and the two steps to a set key.
+const HELP = `jev — read-only: what Jev (TypeSafe) is, why it pays here, and the two steps: the key and the vendor skill.
 
 Usage:
   node jev-guide.mjs [--dir PROJECT] [--json]
@@ -22,7 +22,7 @@ Usage:
 
 Exit codes: 0 rendered; 1 nothing rendered (a --dir that is not a directory); 2 usage.
 
-Reads only: the --dir, the home directory, the key variable's presence, five skill paths, and for the place WSL_DISTRO_NAME, SSH_CONNECTION, REMOTE_CONTAINERS, CODESPACES, the platform, the hostname and /.dockerenv; no network.`;
+Reads only: the --dir, the home directory, the key variable's presence, CLAUDE_CONFIG_DIR, five skill paths, the three skill targets, and for the place WSL_DISTRO_NAME, SSH_CONNECTION, REMOTE_CONTAINERS, CODESPACES, the platform, the hostname and /.dockerenv; no network.`;
 
 export const JEV_TEXT = Object.freeze([
   'WHAT: Jev is a decision model: it takes a state and typed questions (choice, score, noul) and returns typed answers with probabilities and a confidence; it does not write text.',
@@ -49,8 +49,10 @@ const KEY_CONNECT = 'Connect it from a terminal of your own, never through the a
 const KEY_RESTART = `Then ${RESTART_STEP}. Run /agent-workflow-kit jev again: the key mark should read set.`;
 const KEY_NEVER = 'Never paste the key into the chat or into a project file.';
 const KEY_NOT_SET = `key: ${KEY_VARIABLE} not set. A host setting that filters the environment of the agent's commands also hides it. If it still reads not set after that restart and no such setting applies, run the connect line again and follow its last line.`;
+const SKILL_OPTIONAL = 'Optional, for your own code and prompts — the vendor skill. The kit installs it pinned, one verified copy per agent skill root (Codex, Claude Code, Antigravity CLI); after your yes in the chat, run this in a terminal of your own:';
+const NO_HOME = 'no home directory found: the kit\'s install needs one';
 const INSTALL = [
-  'Optional, for your own code and prompts — the vendor skill:',
+  'Or the vendor\'s own routes:',
   'Claude Code:',
   'claude plugin marketplace add typesafe-ai/skills',
   'claude plugin install typesafe@typesafe-ai',
@@ -63,8 +65,8 @@ const NOT_SEEN = [
   'in a Claude Code session (the vendor); ask any other agent to use the TypeSafe skill (the vendor); or run Claude Code\'s own',
   'claude plugin list',
 ];
-const AFTER_INSTALL = [
-  'After an install, quit the agent and start it again from a new terminal.',
+const FIRST_USE = [
+  AFTER_INSTALL,
   'Then give the agent this prompt: using the TypeSafe skill, route these three tickets to billing, technical or sales, one request each, and print each choice and confidence — "I was charged twice this month.", "The app crashes when I upload a file.", "Is there a discount for a yearly plan?".',
   'Success: three choices, each with a confidence.',
 ];
@@ -109,11 +111,26 @@ const skillPaths = (dir, home) => [...new Set([join(dir, '.claude', 'skills'), j
   ...(home === '' ? [] : [join(home, '.claude', 'skills'), join(home, '.codex', 'skills'), join(home, '.cursor', 'skills')])]
   .map((root) => join(root, SKILL_FILE)))];
 
-const renderSteps = (found, set, connect, where) => [
+// The skill targets of the part jev-skill, each judged by the facts leaf's one state rule over the guide's own reads.
+const skillOf = (io, env, home, platform) => {
+  const { dir, note } = claudeDirOf(env, home, platform);
+  const fs = { lstat: lstatSync, readdir: readdirSync, readFile: readFileSync, pins: io.pins ?? SKILL_PINS };
+  const targets = skillTargets({ home, claudeDir: dir }).map((target) => {
+    const { state, tag, reason } = skillState(target, fs);
+    return { agent: target.agent, path: printable(target.path), state, tag, reason: reason === null ? null : printable(reason) };
+  });
+  return { targets, install: home === '' ? '' : skillLine(io.toolsDir ?? TOOLS, platform, dir), note: home === '' ? '' : note };
+};
+const markOf = ({ agent, path, state, tag, reason }) => `${agent} skill root: ${state} at ${path}${tag ? ` (${tag})` : ''}${
+  reason ? ` — ${reason}` : ''}`;
+const renderSteps = (found, set, connect, where, home, skill) => [
   ['STEP 1 — the key', KEY_GET, KEY_CONNECT, ...(where ? [`Run it in ${where}:`] : []), connect, KEY_RESTART, KEY_NEVER,
     set ? `key: ${KEY_VARIABLE} set.` : KEY_NOT_SET],
-  ['STEP 2 — the vendor skill', ...INSTALL,
-    ...(found.length ? found.map((path) => `skill: found at ${path}`) : NOT_SEEN), ...AFTER_INSTALL],
+  ['STEP 2 — the vendor skill', SKILL_OPTIONAL,
+    ...(home === '' ? [NO_HOME] : [...(where ? [`Run it in ${where}:`] : []), skill.install || NO_APPLY_LINE,
+      ...(skill.note ? [skill.note] : [])]),
+    ...INSTALL, ...skill.targets.map(markOf),
+    ...(found.length ? found.map((path) => `skill: found at ${path}`) : NOT_SEEN), ...FIRST_USE],
 ];
 
 export const main = (argv, io = {}) => {
@@ -132,9 +149,11 @@ export const main = (argv, io = {}) => {
   const platform = io.platform ?? process.platform;
   const connect = connectLine(io.toolsDir ?? TOOLS, platform);
   const where = placeFor(io, env, platform);
-  const steps = renderSteps(found, set, connect, where);
+  const home = homeOf(io);
+  const skill = skillOf(io, env, home, platform);
+  const steps = renderSteps(found, set, connect, where, home, skill);
   log(parsed.json
-    ? JSON.stringify({ schema: SCHEMA, command: 'jev', dir, text: JEV_TEXT, skill: { found }, key: { set }, connect, where, steps, prompts: PROMPTS }, null, 2)
+    ? JSON.stringify({ schema: SCHEMA, command: 'jev', dir, text: JEV_TEXT, skill: { found, targets: skill.targets, install: skill.install }, key: { set }, connect, where, steps, prompts: PROMPTS }, null, 2)
     : [...JEV_TEXT, ...steps.flat(), 'WHERE IT PAYS IN THIS WORKFLOW', ...PROMPTS].join('\n'));
   return 0;
 };

package/tools/jev-skill.mjs

@@ -0,0 +1,231 @@
+#!/usr/bin/env node
+// spec:jev-guide — docs/ai/specs/kit/jev-guide/jev-skill.md
+// The one command that installs the vendor's Jev skill, pinned and digest-checked, as a verified COPY into
+// the three agent skill roots. The USER runs it with --apply in a terminal of their own after their yes in
+// the chat; without --apply it is a read-only dry run. It reads no secret, needs no terminal, opens no
+// connection, never writes through a link below a base, and never removes what it did not mint this run.
+import { createHash } from 'node:crypto';
+import { lstatSync, mkdirSync, mkdtempSync, readdirSync, readFileSync, renameSync, rmSync, writeFileSync } from 'node:fs';
+import { homedir } from 'node:os';
+import { dirname, join, posix, win32 } from 'node:path';
+import { fileURLToPath } from 'node:url';
+import { fail } from '../references/scripts/markdown-blocks.mjs';
+import { isDirectRun } from './direct-run.mjs';
+import { AFTER_INSTALL, NO_APPLY_LINE, SKILL_FILES, SKILL_PINS, claudeDirOf, printable, skillLine, skillState,
+  skillTargets } from './jev-facts.mjs';
+
+export const EXIT = Object.freeze({ done: 0, nothingWritten: 1, usage: 2, inPart: 4 });
+const TOOLS = dirname(fileURLToPath(import.meta.url));
+const VENDOR_DIR = join(TOOLS, '..', 'references', 'vendor', 'typesafe-ai');
+const TMP_PREFIX = '.typesafe-ai.kit-tmp-';
+const OLD_PREFIX = '.typesafe-ai.kit-old-';
+const HELP = `jev-skill — installs the vendor's Jev (TypeSafe) skill, pinned, as one verified copy per agent skill root.
+
+Usage:
+  node jev-skill.mjs [--apply] [--claude-dir DIR]
+
+Without --apply: a dry run that writes nothing and prints the plan.
+--apply       install or replace the planned copies (Codex ~/.agents/skills, Claude Code <claude dir>/skills,
+              Antigravity CLI ~/.gemini/config/skills); a foreign copy is left untouched.
+--claude-dir  the Claude Code dir (absolute); default CLAUDE_CONFIG_DIR when absolute, else ~/.claude.
+--help        answered only when it is the whole invocation.
+
+Exit codes: 0 the dry run rendered or every planned write done; 1 nothing written (the kit's own copy fails
+its check, or no home directory); 2 usage; 4 applied in part (a target refused).`;
+
+const parseArgv = (argv, platform) => {
+  if (argv.includes('--help') || argv.includes('-h')) {
+    if (argv.length !== 1) throw fail(EXIT.usage, '--help is answered only when it is the whole invocation');
+    return { help: true };
+  }
+  const parsed = { help: false, apply: false, claudeDir: null };
+  for (let index = 0; index < argv.length; index += 1) {
+    const arg = argv[index];
+    if (arg === '--apply') parsed.apply = true;
+    else if (arg === '--claude-dir') {
+      const value = argv[index + 1];
+      if (value === undefined || value === '' || value.startsWith('-')) throw fail(EXIT.usage, '--claude-dir takes a value');
+      if (!(platform === 'win32' ? win32 : posix).isAbsolute(value)) throw fail(EXIT.usage, `--claude-dir takes an absolute path, not ${printable(value)}`);
+      parsed.claudeDir = value;
+      index += 1;
+    } else throw fail(EXIT.usage, `unknown argument "${printable(arg)}" — run with --help`);
+  }
+  return parsed;
+};
+
+const digestOf = (bytes) => createHash('sha256').update(bytes).digest('hex');
+const codeOf = (error) => error?.code ?? error?.message ?? String(error);
+const DEFAULT_IO = Object.freeze({
+  lstat: lstatSync, readdir: readdirSync, readFile: readFileSync, mkdir: mkdirSync, mkdtemp: mkdtempSync,
+  write: (path, bytes) => writeFileSync(path, bytes, { flag: 'wx' }), rename: renameSync, rm: rmSync,
+});
+const homeOf = (io) => {
+  if (io.home !== undefined) return io.home;
+  try { return homedir(); } catch { return ''; }
+};
+
+// The kit's own pair, digest-checked against the first pin: the bytes every install writes, or the refused file.
+const vendorBytes = (io) => {
+  const bytes = {};
+  for (const [name, shipped] of Object.entries(SKILL_FILES)) {
+    try { bytes[name] = io.readFile(join(io.vendorDir, shipped)); } catch { return { refused: shipped }; }
+    if (digestOf(bytes[name]) !== io.pins[0].digests[name]) return { refused: shipped };
+  }
+  return { bytes };
+};
+
+const ACTIONS = Object.freeze({ current: 'keep', earlier: 'replace', absent: 'install', foreign: 'untouched' });
+// Every target with its state and its action, the effective Claude Code dir, the note and the leftovers.
+export const planFor = (io) => {
+  const resolved = claudeDirOf(io.env, io.home, io.platform);
+  const claudeDir = io.claudeDir ?? resolved.dir;
+  const note = io.claudeDir ? '' : resolved.note;
+  const targets = skillTargets({ home: io.home, claudeDir }).map((target) => {
+    const state = skillState(target, io);
+    return { ...target, ...state, action: ACTIONS[state.state] };
+  });
+  const parents = [...new Set(targets.map(({ root }) => dirname(root)))];
+  const leftovers = parents.flatMap((parent) => {
+    try {
+      return [...io.readdir(parent)].map(String).filter((name) => name.startsWith(TMP_PREFIX) || name.startsWith(OLD_PREFIX))
+        .sort().map((name) => join(parent, name));
+    } catch { return []; }
+  });
+  return { claudeDir, note, targets, leftovers };
+};
+
+const countsOf = (targets) => Object.fromEntries(Object.values(ACTIONS)
+  .map((action) => [action, targets.filter((target) => target.action === action).length]));
+const detailOf = (target, newest) => ({
+  keep: `${target.tag}, keep`, replace: `${target.tag}, replace with ${newest}`, install: 'install',
+  untouched: `${printable(target.reason)}, left untouched`,
+})[target.action];
+
+// One target's write: install or replace, re-checking the target before each rename. Returns its lines and outcome.
+export const applyTarget = (entry, io) => {
+  const path = printable(entry.path);
+  const parent = dirname(entry.root);
+  const lines = [];
+  const minted = [];
+  const stateNow = () => skillState(entry, io).state;
+  const changed = (planned) => {
+    const now = stateNow();
+    return now === planned ? null : `changed since the plan: now ${now}`;
+  };
+  let aside = null;
+  const refuse = (cause) => {
+    lines.push(`refused: ${path} — ${cause}`);
+    for (const dir of minted) io.rm(dir, { recursive: true, force: true });
+    if (aside) {
+      const now = stateNow();
+      let kept = now === 'absent' ? null : `the target is now ${now}`;
+      if (kept === null) {
+        try {
+          io.rename(join(aside, 'typesafe-ai'), entry.path);
+          io.rm(aside, { recursive: true, force: true });
+        } catch (error) { kept = codeOf(error); }
+      }
+      if (kept !== null) lines.push(`kept aside: ${printable(join(aside, 'typesafe-ai'))} — ${kept}`);
+    }
+    return { lines, outcome: 'refused' };
+  };
+  try {
+    const below = entry.root.slice(entry.base.length).split(/[\\/]/).filter(Boolean);
+    below.reduce((at, name) => {
+      const next = join(at, name);
+      try { io.lstat(next); } catch (error) {
+        if (error?.code !== 'ENOENT') throw error;
+        io.mkdir(next, { mode: 0o700 });
+      }
+      return next;
+    }, entry.base);
+    const temp = io.mkdtemp(join(parent, TMP_PREFIX));
+    minted.push(temp);
+    const child = join(temp, 'typesafe-ai');
+    io.mkdir(child, { mode: 0o700 });
+    for (const name of Object.keys(SKILL_FILES)) io.write(join(child, name), io.bytes[name]);
+    for (const name of Object.keys(SKILL_FILES)) {
+      if (digestOf(io.readFile(join(child, name))) !== io.pins[0].digests[name]) return refuse('digest mismatch');
+    }
+    if (entry.state === 'earlier') {
+      const old = io.mkdtemp(join(parent, OLD_PREFIX));
+      minted.push(old);
+      const moved = changed('earlier');
+      if (moved) return refuse(moved);
+      io.rename(entry.path, join(old, 'typesafe-ai'));
+      minted.pop();
+      aside = old;
+    }
+    const placed = changed('absent');
+    if (placed) return refuse(placed);
+    io.rename(child, entry.path);
+    io.rm(temp, { recursive: true, force: true });
+    minted.length = 0;
+    if (!aside) {
+      lines.push(`installed: ${path} (${io.pins[0].tag})`);
+      return { lines, outcome: 'installed' };
+    }
+    const old = { base: aside, path: join(aside, 'typesafe-ai') };
+    const verified = skillState(old, io);
+    if (verified.state === 'earlier') io.rm(aside, { recursive: true, force: true });
+    else lines.push(`kept aside: ${printable(old.path)} — it reads ${verified.state}`);
+    lines.unshift(`replaced: ${path} (${entry.tag} → ${io.pins[0].tag})`);
+    return { lines, outcome: 'replaced' };
+  } catch (error) {
+    return refuse(codeOf(error));
+  }
+};
+
+const run = (parsed, io) => {
+  const pin = io.pins[0];
+  const { bytes, refused } = vendorBytes(io);
+  if (refused) {
+    io.error(`refused: the kit's own copy of ${refused} is missing, unreadable or does not match the pin — nothing written`);
+    return EXIT.nothingWritten;
+  }
+  if (io.home === '') { io.error('refused: no home directory found — nothing written'); return EXIT.nothingWritten; }
+  const plan = planFor({ ...io, claudeDir: parsed.claudeDir ?? undefined });
+  io.log(`pin: ${pin.tag}, commit ${pin.commit}`);
+  if (plan.note) io.log(plan.note);
+  const leftovers = plan.leftovers.map((path) => `leftover: ${printable(path)} — not removed; delete it by hand`);
+  const counts = countsOf(plan.targets);
+  if (!parsed.apply) {
+    for (const target of plan.targets) io.log(`${target.agent}: ${target.state} at ${printable(target.path)} — ${detailOf(target, pin.tag)}`);
+    for (const line of leftovers) io.log(line);
+    io.log(`dry run — nothing written. Planned: ${counts.install} to install, ${counts.replace} to replace, ${counts.keep} kept, ${counts.untouched} left untouched.`);
+    if (counts.install + counts.replace > 0) {
+      io.log('To install, run in a terminal of your own:');
+      io.log(skillLine(io.toolsDir, io.platform, plan.claudeDir) || NO_APPLY_LINE);
+    }
+    return EXIT.done;
+  }
+  const done = { installed: 0, replaced: 0, kept: 0, untouched: 0, refused: 0 };
+  for (const target of plan.targets) {
+    if (target.action === 'keep' || target.action === 'untouched') {
+      io.log(target.action === 'keep' ? `kept: ${printable(target.path)} (${target.tag})`
+        : `left untouched: ${printable(target.path)} — ${printable(target.reason)}`);
+      done[target.action === 'keep' ? 'kept' : 'untouched'] += 1;
+      continue;
+    }
+    const result = applyTarget(target, { ...io, bytes });
+    for (const line of result.lines) io.log(line);
+    done[result.outcome] += 1;
+  }
+  for (const line of leftovers) io.log(line);
+  io.log(`done — ${done.installed} installed, ${done.replaced} replaced, ${done.kept} kept, ${done.untouched} left untouched, ${done.refused} refused.`);
+  if (done.installed + done.replaced > 0) io.log(AFTER_INSTALL);
+  return done.refused === 0 ? EXIT.done : EXIT.inPart;
+};
+
+export const main = (argv, io = {}) => {
+  const resolved = {
+    ...DEFAULT_IO, log: console.log, error: console.error, env: process.env, platform: process.platform,
+    pins: SKILL_PINS, vendorDir: VENDOR_DIR, toolsDir: TOOLS, ...io,
+  };
+  let parsed;
+  try { parsed = parseArgv(argv, resolved.platform); } catch (err) { resolved.error(err.message); return EXIT.usage; }
+  if (parsed.help) { resolved.log(HELP); return EXIT.done; }
+  return run(parsed, { ...resolved, home: homeOf(io) });
+};
+
+if (isDirectRun(import.meta.url)) process.exitCode = main(process.argv.slice(2));

package/tools/recommendations.mjs

@@ -95,6 +95,7 @@ import {
   ACKS_COVERAGE_DOMAIN_KEY,
   ACKS_SOURCE_SIZE_COPY_KEY,
   ACKS_JEV_CONNECT_KEY,
+  ACKS_JEV_SKILL_KEY,
   ACK_LANES,
   factFingerprint,
   readAckValue,
@@ -102,12 +103,14 @@ import {
 import { ADOPTION, STORE_DIR_REL as SPEC_STORE_DIR_REL, SPEC_ADOPTION_LANE, declineFingerprint, readDeclineAck, surveySpecAdoption } from './spec-adoption.mjs';
 import { ENSURE_OPS } from './ensure-vocabulary.mjs';
 import { composeProfileGapScreen } from './profile-gap-screen.mjs';
-import { connectLine, keySet, placeOf } from './jev-facts.mjs';
+import { NO_APPLY_LINE, SKILL_PINS, claudeDirOf, connectLine, keySet, placeOf, printable, skillLine, skillState, skillTargets } from './jev-facts.mjs';
 
 // The upgrade ensure that seeds the spec store — the not-adopted item's apply; pinned to the vocabulary.
 const SPEC_LAYER_ENSURE = ENSURE_OPS.includes('specs') ? 'specs' : null;
 const JEV_CONNECT_DECLINED = 'jev-connect:declined';
 const JEV_CONNECT_DECLINE = factFingerprint(JEV_CONNECT_DECLINED);
+// The skill decline names the pin it declined, so a pin move brings the update offer back once.
+const JEV_SKILL_DECLINED = 'jev-skill:declined:';
 
 export { ACKS_FILE, ACKS_LANE_KEY, ACKS_WORKTREES_DIR_KEY, ACKS_COVERAGE_DOMAIN_KEY, ACKS_SOURCE_SIZE_COPY_KEY, ACK_LANES, factFingerprint };
 
@@ -206,6 +209,8 @@ export const SEVERITIES = Object.freeze({
   'spec-adoption': SEVERITY_OPTIONAL,
   'profile-gap': SEVERITY_OPTIONAL,
   'jev-connect': SEVERITY_OPTIONAL,
+  'jev-skill': SEVERITY_OPTIONAL,
+  'jev-skill.earlier': SEVERITY_OPTIONAL,
   'spec-adoption.adopting': SEVERITY_OPTIONAL,
 });
 // The per-item render tags (frozen presentation data, same language contract as the templates).
@@ -284,6 +289,8 @@ export const WHATS = Object.freeze({
   'spec-adoption': 'feature-spec store absent (docs/ai/specs) — no feature contract can govern a plan here yet; seed the store, or record the decline',
   'profile-gap': '{what}',
   'jev-connect': 'Jev (TypeSafe) is not connected: TYPESAFE_API_KEY is not in the environment the agent\'s commands run in',
+  'jev-skill': 'Jev\'s vendor skill is not installed for every agent here: a skill root the kit fills is absent or behind the kit\'s pin',
+  'jev-skill.earlier': 'Jev\'s vendor skill in the agent skill roots is at {old}, behind the kit\'s pin {new}; only copies matching a kit pin change',
   'spec-adoption.adopting': 'feature-spec store: {n} draft spec(s), no live contract — nothing governs a plan through it yet; land a live contract, or record the decline',
 });
 
@@ -346,6 +353,7 @@ export const BENEFITS = Object.freeze({
   'spec-adoption': 'contracts — a plan names the contract it builds to, and a change to a governed slice is visible at review instead of after it',
   'profile-gap': 'full flow — each difference from the reference profile is previewed by its own writer; a declined one returns only at a lineage step',
   'jev-connect': 'decisions — a typed choice with a confidence in under a second for your code and the agent\'s scripts, once for every project here',
+  'jev-skill': 'the TypeSafe skill for Claude Code, Codex and Antigravity CLI, one pinned verified copy per agent root, from one command you run',
 });
 
 // ── the CLOSED opt-in capability registry (OPT-IN-SHIPS-INVISIBLE) ──────────────────────────────
@@ -394,6 +402,7 @@ export const OPT_IN_CAPABILITIES = Object.freeze([
   { id: 'spec-adoption', mode: 'upgrade', advisorKey: 'spec-adoption' },
   { id: 'full-flow-profile', mode: 'upgrade', advisorKey: 'profile-gap' },
   { id: 'jev-connect', mode: 'jev', advisorKey: 'jev-connect' },
+  { id: 'jev-skill', mode: 'jev', advisorKey: 'jev-skill' },
   { id: 'adr-store-migration', mode: 'migrate-adr-store', advisorKey: 'adr-store-migration' },
   { id: 'review-recipe', mode: 'set-recipe', advisorKey: 'review-recipe' },
   // The execute slot is a DISTINCT opt-in from the review slot, and the same probe reports both —
@@ -1313,7 +1322,7 @@ const readReadLaneToggle = (root, deps) => {
 // D3: the risk-marked keys — every key here has a per-item posture note in the mode doc, surfaced
 // at the consent moment; the static contract test asserts EXACT bidirectional coverage
 // (risk-marked keys == mode-doc note keys — a dropped note goes red, not silent).
-export const RISK_NOTED_KEYS = Object.freeze(['sandbox-lane', 'read-lane', 'worktrees-dir', 'adr-store-migration', 'gates-inert', 'source-size', 'gate-hook', 'mcp-channel', 'spec-adoption', 'enforcement', 'profile-gap', 'jev-connect']);
+export const RISK_NOTED_KEYS = Object.freeze(['sandbox-lane', 'read-lane', 'worktrees-dir', 'adr-store-migration', 'gates-inert', 'source-size', 'gate-hook', 'mcp-channel', 'spec-adoption', 'enforcement', 'profile-gap', 'jev-connect', 'jev-skill']);
 
 // The feature-spec layer's adoption state (contract: kit/spec-adoption). The canon lets a plan cite
 // zero governing specs while a project adopts the layer, and nothing ever said whether adoption had
@@ -1625,6 +1634,40 @@ export const probeJevConnect = ({ root, deps, add, skip }) => {
   }
 };
 
+// The Jev skill offer (contract: kit/jev-guide, part jev-offer): only once the key is set, so one jev item shows at a time.
+// Each target is judged by the facts leaf's one state rule; the apply is the skill command the USER runs (HAND-APPLY).
+export const probeJevSkill = ({ root, deps, add, skip }) => {
+  try {
+    const env = deps.getenv ?? {};
+    if (!keySet(env)) return;
+    const host = deps.jevHost ?? {};
+    if (typeof host.home !== 'string' || host.home === '') return;
+    const pins = deps.jevPins ?? SKILL_PINS;
+    const { dir, note } = claudeDirOf(env, host.home, host.platform);
+    const io = { lstat: deps.lstat ?? lstatSync, readdir: deps.readdir ?? readdirSync, readFile: deps.readFile ?? readFileSync, pins };
+    const judged = skillTargets({ home: host.home, claudeDir: dir }).map((target) => ({ ...target, ...skillState(target, io) }));
+    if (!judged.some(({ state }) => state === 'absent' || state === 'earlier')) return;
+    const decline = factFingerprint(`${JEV_SKILL_DECLINED}${pins[0].tag}`);
+    if (readAckValue(root, deps, ACKS_JEV_SKILL_KEY) === decline) return;
+    const line = skillLine(HERE, host.platform, dir);
+    if (line === '') {
+      skip('jev-skill', new Error(NO_APPLY_LINE));
+      return;
+    }
+    const place = placeOf({ env, platform: host.platform, hostname: host.hostname, container: host.container });
+    const behind = judged.filter(({ state }) => state === 'earlier').map(({ tag }) => pins.findIndex((pin) => pin.tag === tag));
+    const what = behind.length ? fillTemplate(WHATS['jev-skill.earlier'], { old: pins[Math.max(...behind)].tag, new: pins[0].tag })
+      : WHATS['jev-skill'];
+    const untouched = judged.filter(({ state }) => state === 'foreign')
+      .map(({ path, reason }) => `left untouched: ${printable(path)} — ${printable(reason)}; `).join('');
+    const record = `node ${q(toolPath('ack-write.mjs'))} --lane jev-skill --fingerprint ${decline} --cwd ${q(root)}`;
+    add('jev-skill', what, `HAND-APPLY: ${line}`, behind.length ? 'jev-skill.earlier' : 'jev-skill',
+      `${place ? `run the apply in ${place}; ` : ''}${untouched}${note ? `${note}; ` : ''}HAND-APPLY alternative (instead of the apply, never after it): decline the offer by recording it — ${record}`);
+  } catch (err) {
+    skip('jev-skill', err);
+  }
+};
+
 export const probeProfileGaps = ({ root, deps, add, skip }) => {
   try {
     const { gaps, skips } = composeProfileGapScreen({ root, deps });
@@ -1658,6 +1701,7 @@ const PROBES = Object.freeze([
   probeMcpChannel,
   probeSpecAdoption,
   probeJevConnect,
+  probeJevSkill,
   probeProfileGaps,
 ]);
 
@@ -1760,9 +1804,10 @@ the consent-gated ack writer into docs/ai/acks.json (never a security key).
 Read-only: never writes, never commits, never runs a subscription CLI. Exit codes: 0 report
 rendered (items or empty); 1 error; 2 usage.`;
 
-// The host facts of the key offer's place: the platform, the hostname (a throw reads as none), /.dockerenv a regular file.
+// The host facts of the key and skill offers: the platform, the hostname (a throw reads as none), /.dockerenv a regular file, the home.
 const hostFacts = () => ({ platform: process.platform, hostname: (() => { try { return hostname(); } catch { return ''; } })(),
-  container: (() => { try { return statSync('/.dockerenv').isFile(); } catch { return false; } })() });
+  container: (() => { try { return statSync('/.dockerenv').isFile(); } catch { return false; } })(),
+  home: (() => { try { return homedir(); } catch { return ''; } })() });
 
 export const main = (argv, ctx = {}) => {
   try {