From ec0b9317a722e944ea87b49413c64946b1a1a681 Mon Sep 17 00:00:00 2001
From: Dmitrij Zykovic <dmitrij.zykovic@ainovasystems.com>
Date: Sun, 11 Oct 2026 17:00:59 +0300
Subject: [PATCH 1/8] Recorded the decision on local and targeted source
 artifacts

---
 ...021-local-and-targeted-source-artifacts.md | 145 ++++++++++++++++++
 1 file changed, 145 insertions(+)
 create mode 100644 decisions/0021-local-and-targeted-source-artifacts.md

diff --git a/decisions/0021-local-and-targeted-source-artifacts.md b/decisions/0021-local-and-targeted-source-artifacts.md
new file mode 100644
index 0000000..8486386
--- /dev/null
+++ b/decisions/0021-local-and-targeted-source-artifacts.md
@@ -0,0 +1,145 @@
+# 0021 — Local and targeted source artifacts
+
+Date: 2026-10-11
+Status: accepted
+
+## Context
+
+Every rule, agent and skill in a configured source renders to every enabled
+adapter. Nothing in a source can say "only on my machine" or "only for this
+tool".
+
+A machine-local preference has no place. The documented home is a hand-made,
+gitignored root `CLAUDE.md`, which reaches one tool. A gitignored file placed in
+a source directory leaks instead: `AGENTS.md`, committed by default (decision
+0020), inlines an always-on rule's body and links every rule, agent and skill.
+A teammate without the file renders `AGENTS.md` without it, and `sync --check`
+in CI reports `out-of-date` for the same reason.
+
+Tool-specific guidance has no place either: advice that matters to one tool
+reaches all of them, and an always-on rule costs context in every one.
+
+Two delivery paths are shared, not per tool. Codex, Cursor, Copilot,
+Antigravity, Pi and OpenCode read `AGENTS.md` natively; Claude Code does not,
+and receives every rule in `.claude/rules/`. Codex, Antigravity, Pi and OpenCode
+read `.agents/skills/`. A filter can withhold an artifact from a shared path,
+never from one of its readers.
+
+Sources are enumerated two ways. `AGENTS.md` uses `find`, which returns
+dotfiles; every other adapter uses a shell glob, which skips them, so a `.x.md`
+rule reaches `AGENTS.md` and nothing else. `AGENTS.md` also lists and inlines
+every same-named rule from every source, while the copying adapters let the
+later source win.
+
+## Decision
+
+1. **Local is a name.** A rule or agent file named `*.local.md` and a skill
+   directory named `*.local/` are local. That is the pattern `.gitignore`
+   holds, so Git and the engine cannot disagree about which file is local:
+   `init` writes `<content-dir>/rules/*.local.md`,
+   `<content-dir>/agents/*.local.md` and `<content-dir>/skills/*.local/` to the
+   managed block, beside `.intelligence/`.
+2. **A name is the file name without a leading `.`, `.md` and a trailing
+   `.local`.** `.environment.local.md` and `environment.local.md` are the local
+   rule `environment`; `.local.md` is the local rule `local`; `.draft.md` is the
+   rule `draft`. A leading dot means nothing, so every adapter renders dotfile
+   sources, as `AGENTS.md` already did. A skill directory `deploy.local/`
+   renders as `deploy/`, so it still matches its own `name: deploy`.
+3. **Names stay unique.** Across sources the later source overrides the
+   earlier, as today, and now in `AGENTS.md` too. Sync refuses two artifacts
+   with one name in one source directory (`x.md` beside `.x.md`), and a local
+   and a non-local artifact with one name in any sources: a local file that
+   overrides or yields to a committed one would change what committed output
+   holds.
+4. **Two frontmatter fields select adapters.** `targets:` lists the adapters an
+   artifact is for; without it, every enabled adapter. `exclude_targets:`
+   removes adapters from that set. Both take built-in or project adapter ids and
+   the group `committed`, in the list syntax `paths:` accepts; skills carry them
+   in `SKILL.md`. An unknown id refuses the sync. A known adapter that is not
+   enabled is no target and no warning: enablement is the manifest's decision.
+   `targets: []` renders the artifact nowhere. Both fields are removed from
+   every rendered copy.
+5. **`committed` is every output Git tracks**: an output path that no `ignore`
+   record of its adapter's contract covers. It is resolved per path, not per
+   adapter — OpenCode's agents are ignored while its commands are tracked —
+   and `AGENTS.md` always belongs to it. `targets.copilot.commit_output: true`
+   moves Copilot's four directories into it, so a sync that resolves
+   `committed` evaluates contracts with the manifest. Decision 0020 kept that
+   read off every sync; a sync whose sources have no local artifact and name no
+   `committed` still has none.
+6. **A local artifact excludes `committed` implicitly.** Its own `targets` and
+   `exclude_targets` narrow the set further. A local artifact whose `targets`
+   names a committed output refuses the sync: the source exists in no other
+   clone and not in CI, which render that output without it.
+7. **Shared paths are delivered whole.** An artifact whose set contains
+   `agents` goes into `AGENTS.md`, and so reaches every tool that reads it,
+   listed or not. An always-on rule whose set leaves `agents` out reaches a tool
+   in its set through that tool's own channel:
+   - Claude Code: `.claude/rules/`, as today;
+   - Cursor: an `.mdc` file with `alwaysApply: true`;
+   - Copilot: an `.instructions.md` file with `applyTo: "**"`;
+   - Antigravity: `trigger: always_on`, the same Windsurf-lineage key family as
+     its `trigger: glob`, not vendor-documented;
+   - Pi: its generated rules extension, which adds the rule to the system
+     prompt;
+   - Codex: `AGENTS.override.md` beside `AGENTS.md`. Codex reads it instead of
+     `AGENTS.md` in that directory, so it holds the `AGENTS.md` content plus the
+     rules only Codex receives; Codex's contract ignores it, and it exists only
+     while such rules do;
+   - OpenCode: none — its `instructions:` live in a committed `opencode.json`.
+
+   A skill whose set contains any reader of `.agents/skills/` lands there. Sync
+   warns when a shared path delivers an artifact to an enabled adapter outside
+   its set, and when an adapter in its set can receive it through no channel —
+   for the adapters an artifact names explicitly and for a local artifact's
+   implicit set. An artifact with neither field nor a `.local` name keeps
+   today's routing and warnings.
+8. **One enumeration.** `AGENTS.md`, every built-in adapter and the adapter
+   template read sources through one function that applies the name rule,
+   overrides, locality and the target set; the per-adapter globs go.
+9. The work lands in two changes: local artifacts with `committed` and the
+   single enumeration (items 1–3, 5, 6, 8), then the fields, the new
+   always-on channels and the shared-path warnings (items 4 and 7).
+
+## Consequences
+
+- A personal rule, agent or skill is a `*.local.md` file or `*.local/`
+  directory in the content directory. It reaches every tool whose output is
+  ignored and never changes a committed file. Tests hold that invariant:
+  `AGENTS.md` is byte-identical with and without local artifacts, and
+  `sync --check` passes in a clone that has none.
+- With one enumeration, dotfile sources render in every adapter, and
+  `AGENTS.md` applies source overrides. A project with a dotfile source sees
+  new output in tool channels.
+- Same-named artifacts in one directory, and local/non-local pairs, now refuse
+  a sync that rendered before.
+- Cursor, Copilot, Antigravity and Pi gain an always-on channel and Codex an
+  override file; a project that never targets or localizes a rule never gets
+  one. OpenCode can receive neither a local nor a tool-targeted always-on rule.
+- A project adapter that enumerates sources itself bypasses locality and
+  targets, so a committed output it writes can leak a local artifact. The
+  template and the adapter guide point it at the shared function.
+
+## Rejected
+
+- **A `local: true` field.** It makes locality and the ignore pattern two facts
+  that can disagree: a flagged file that is committed is shared anyway, and an
+  ignored file without the flag leaks into `AGENTS.md`.
+- **Detecting local files with `git check-ignore`.** It costs a process per
+  sync, has no answer outside a Git work tree, and makes rendering depend on
+  `.gitignore` contents instead of a visible name.
+- **Target lists in `intelligence.yaml`.** Who an artifact is for is a property
+  of the artifact; a manifest list is a second source that drifts from it. The
+  list parser also reads a `rules:` key two spaces deep under any parent as a
+  source list.
+- **`exclude:` as the field name.** Beside `paths:` it reads as a path
+  exclusion.
+- **Negation inside `targets` (`!agents`).** Unquoted, `!agents` is a YAML tag,
+  not a string.
+- **Letting a local artifact name a committed output.** Every other clone and CI
+  render that output without it, so it flips on each teammate's sync and fails
+  `sync --check`.
+- **Skipping dotfiles everywhere.** It gives a leading dot a meaning — "hidden"
+  — that `targets: []` states in the file, and it would drop
+  `.environment.local.md` silently.
+- **Special-casing `.local.md`.** The name rule already yields `local`.

From b5141df31c785506d6ab0a7c492b873325bd33c4 Mon Sep 17 00:00:00 2001
From: Dmitrij Zykovic <dmitrij.zykovic@ainovasystems.com>
Date: Sun, 11 Oct 2026 20:43:12 +0300
Subject: [PATCH 2/8] Added local rules, agents and skills and read every
 source through one catalog

---
 README.md                                     |   5 +-
 cli/commands/init.sh                          |   3 +-
 cli/internal/check.sh                         |   8 +
 cli/lib/gitignore.sh                          |  21 +-
 cli/tests/e2e-compat.sh                       |   3 +
 cli/tests/e2e-local-artifacts.sh              | 225 +++++++++
 cli/tests/e2e-negative.sh                     |   3 +
 cli/tests/e2e-packages.sh                     |   3 +
 cli/tests/e2e-store-sha.sh                    |   3 +-
 cli/tests/unit-engine.sh                      | 112 +++++
 cli/tests/unit-gitignore.sh                   |  23 +-
 cli/tests/verify.sh                           |   2 +-
 docs/cli.md                                   |  22 +-
 engine/adapters/_template.sh                  |  37 +-
 engine/adapters/agents.sh                     |  80 +--
 engine/adapters/antigravity.sh                |  64 +--
 engine/adapters/claude.sh                     |  95 ++--
 engine/adapters/codex.sh                      |  23 +-
 engine/adapters/copilot.sh                    |  94 ++--
 engine/adapters/cursor.sh                     | 111 ++---
 engine/adapters/opencode.sh                   |  55 +--
 engine/adapters/pi.sh                         |  63 +--
 engine/lib/common.sh                          | 459 ++++++++++++++++--
 engine/sync.sh                                |  67 +--
 intelligence/rules/engine.md                  |  32 +-
 .../skills/dev-build-adapter/SKILL.md         |   6 +-
 packages/sync/references/adapters.md          |  54 +--
 packages/sync/references/conventions.md       |  33 +-
 .../sync/references/onboarding-migration.md   |   8 +-
 packages/sync/rules/intelligence-authoring.md |   2 +-
 .../SKILL.md                                  |  12 +-
 .../references/audit-checks.md                |   2 +-
 .../references/rules.md                       |   5 +
 33 files changed, 1215 insertions(+), 520 deletions(-)
 create mode 100644 cli/tests/e2e-local-artifacts.sh

diff --git a/README.md b/README.md
index e363a6e..6959528 100644
--- a/README.md
+++ b/README.md
@@ -118,8 +118,9 @@ conventions](packages/sync/references/conventions.md#generated-output-and-versio
 `AGENTS.md` is the shared root instruction entry point. The learn skill proposes
 migrating still-valid guidance from backed-up legacy `.cursorrules` or
 instruction-bearing `CLAUDE.md` files into project-owned rules. It never
-restores the original root monolith; a small new local file is created only for
-separately approved machine-specific guidance.
+restores the original root monolith; separately approved machine-specific
+guidance becomes a local rule, `intelligence/rules/<name>.local.md`, which Git
+ignores and sync renders only into ignored tool output.
 
 Before the first sync can replace adapter-owned directories, `init` preserves
 existing AI instructions under the gitignored `intelligence/_backup/` (or the
diff --git a/cli/commands/init.sh b/cli/commands/init.sh
index 2f71cdd..66ab93e 100644
--- a/cli/commands/init.sh
+++ b/cli/commands/init.sh
@@ -356,7 +356,8 @@ manifest="$root/intelligence.yaml"
 } > "$manifest"
 
 # The package store is restorable state, never committed — the npm model.
-ensure_base_gitignore "$root"
+# Local rules, agents and skills stay on this machine (decision 0021).
+ensure_base_gitignore "$root" "$content_dir"
 for target in $targets; do
     ensure_target_gitignore "$root" "$manifest" "$target"
 done
diff --git a/cli/internal/check.sh b/cli/internal/check.sh
index 6117e5f..10bf4c5 100644
--- a/cli/internal/check.sh
+++ b/cli/internal/check.sh
@@ -198,6 +198,14 @@ while IFS= read -r target; do
     ok "adapter $target contract v1"
 done < <(target_names "$manifest")
 
+# A local rule, agent or skill is one these patterns name (decision 0021): the
+# engine keeps it out of every committed output, and without the pattern Git
+# would still offer to commit the file itself.
+while IFS= read -r pattern; do
+    ignore_file_has_line "$IP_ROOT/.gitignore" "$pattern" \
+        || warn "local artifact Git policy is missing '$pattern' — run 'intelligence init'"
+done < <(local_artifact_ignore_patterns "$content_dir")
+
 # Lock orphans.
 if [ "$lock_valid" -eq 1 ] && [ -f "$lock" ]; then
     while IFS= read -r name; do
diff --git a/cli/lib/gitignore.sh b/cli/lib/gitignore.sh
index cb0c895..1c9011f 100644
--- a/cli/lib/gitignore.sh
+++ b/cli/lib/gitignore.sh
@@ -312,10 +312,26 @@ ensure_gitignore_header() {
     fi
 }
 
+# local_artifact_ignore_patterns <content-dir> — the patterns that make a rule,
+# agent or skill local (decision 0021): a file or skill directory with one of
+# these names never reaches committed output, and Git never commits it. The
+# engine recognizes the same names, so the two cannot disagree; `init` writes
+# them and `status --check` reports one missing.
+local_artifact_ignore_patterns() {
+    local dir="${1#./}"
+    while [ "${dir%/}" != "$dir" ]; do dir="${dir%/}"; done
+    printf '%s\n' "$dir/rules/*.local.md" "$dir/agents/*.local.md" "$dir/skills/*.local/"
+}
+
+# ensure_base_gitignore <root> <content-dir> — the package store and the local
+# artifact patterns of the project's content directory.
 ensure_base_gitignore() {
-    local root="$1"
+    local root="$1" content_dir="$2" line
     ensure_gitignore_header "$root"
     gitignore_add_line "$root" '.intelligence/'
+    while IFS= read -r line; do
+        gitignore_add_line "$root" "$line"
+    done < <(local_artifact_ignore_patterns "$content_dir")
 }
 
 ensure_target_gitignore() {
@@ -343,7 +359,7 @@ ensure_target_gitignore() {
 
 ensure_manifest_gitignore() {
     local root="$1" manifest="$2" target
-    ensure_base_gitignore "$root"
+    ensure_base_gitignore "$root" "$(manifest_intelligence_dir "$manifest")"
     while IFS= read -r target; do
         [ -n "$target" ] || continue
         if [ "$(is_target_enabled "$manifest" "$target")" = "1" ]; then
@@ -420,6 +436,7 @@ managed_gitignore_patterns() {
     local root="$1" manifest="$2" content_dir target output records kind value
     content_dir="$(manifest_intelligence_dir "$manifest")"
     printf '%s\n' '.intelligence/' "$content_dir/_backup/"
+    local_artifact_ignore_patterns "$content_dir"
     while IFS= read -r target; do
         [ -n "$target" ] || continue
         [ "$(is_target_enabled "$manifest" "$target")" = "1" ] || continue
diff --git a/cli/tests/e2e-compat.sh b/cli/tests/e2e-compat.sh
index 3fe82f6..bfb53f6 100644
--- a/cli/tests/e2e-compat.sh
+++ b/cli/tests/e2e-compat.sh
@@ -111,6 +111,9 @@ MANIFEST
     printf '# Ctx\n\nCOMPAT_MARKER\n' > "$d/intelligence/rules/context.md"
     cat > "$d/.gitignore" <<'IGNORE'
 .intelligence/
+intelligence/rules/*.local.md
+intelligence/agents/*.local.md
+intelligence/skills/*.local/
 CLAUDE.md
 .claude/*
 !.claude/settings.json
diff --git a/cli/tests/e2e-local-artifacts.sh b/cli/tests/e2e-local-artifacts.sh
new file mode 100644
index 0000000..4df9da8
--- /dev/null
+++ b/cli/tests/e2e-local-artifacts.sh
@@ -0,0 +1,225 @@
+#!/bin/bash
+# Hermetic e2e for decision 0021: one source catalog names every artifact,
+# applies overrides everywhere, refuses ambiguous names, and keeps a local
+# rule, agent or skill out of every output Git tracks.
+set -euo pipefail
+unset CI
+REPO="${1:-$(cd "$(dirname "$0")/../.." && pwd)}"
+REPO="$(cd "$REPO" && pwd)"
+OUT="$(mktemp -d)"
+trap 'rm -rf "$OUT"' EXIT
+CLI="$REPO/cli/intelligence"
+fail=0
+chk() { if ! "$@" >/dev/null 2>&1; then echo "FAIL: $*"; fail=1; fi; }
+chknot() { if "$@" >/dev/null 2>&1; then echo "FAIL(not): $*"; fail=1; fi; }
+# is <label> <want> <got>
+is() { [ "$2" = "$3" ] || { echo "FAIL: $1 — want '$2', got '$3'"; fail=1; }; }
+
+# run <dir> <args>... — the CLI in a project; status in RC, output in LOG.
+RC=0
+LOG="$OUT/log"
+run() {
+    local dir="$1"
+    shift
+    RC=0
+    (cd "$dir" && IS_SUPPRESS_CLI_NOTE=1 bash "$CLI" "$@") > "$LOG" 2>&1 || RC=$?
+}
+commit_all() { git -C "$1" add -A >/dev/null 2>&1 && git -C "$1" commit -qm "$2" >/dev/null 2>&1; }
+# snapshot <dir> — one line naming every generated file and its bytes.
+snapshot() {
+    (cd "$1" && find AGENTS.md .claude .cursor .codex .github .agents .opencode -type f 2>/dev/null \
+        | LC_ALL=C sort | while IFS= read -r f; do printf '%s %s\n' "$f" "$(cksum < "$f")"; done)
+}
+
+TARGETS=agents,claude,cursor,codex,copilot,opencode
+P="$OUT/project"
+mkdir -p "$P"
+git -C "$P" init --quiet
+git -C "$P" config user.email e2e@example.com
+git -C "$P" config user.name e2e
+git -C "$P" config core.autocrlf false
+
+echo "== init writes the local artifact patterns into the managed block =="
+run "$P" init --bare --targets "$TARGETS"
+is "init exit" 0 "$RC"
+for pattern in 'intelligence/rules/*.local.md' 'intelligence/agents/*.local.md' 'intelligence/skills/*.local/'; do
+    chk grep -Fqx "$pattern" "$P/.gitignore"
+done
+for path in intelligence/rules/me.local.md intelligence/rules/.environment.local.md \
+    intelligence/agents/helper.local.md intelligence/skills/deploy.local/SKILL.md; do
+    chk git -C "$P" check-ignore -q --no-index "$path"
+done
+for path in intelligence/rules/team.md intelligence/rules/.draft.md intelligence/skills/deploy/SKILL.md; do
+    chknot git -C "$P" check-ignore -q --no-index "$path"
+done
+run "$P" status --check
+is "status --check on a fresh project" 0 "$RC"
+
+echo "== status --check reports a missing local pattern; init restores it =="
+grep -Fvx 'intelligence/agents/*.local.md' "$P/.gitignore" > "$OUT/gitignore" && cp "$OUT/gitignore" "$P/.gitignore"
+run "$P" status --check
+is "status --check exit" 1 "$RC"
+chk grep -Fq "local artifact Git policy is missing 'intelligence/agents/*.local.md'" "$LOG"
+run "$P" init
+is "init on the project" 0 "$RC"
+chk grep -Fqx 'intelligence/agents/*.local.md' "$P/.gitignore"
+run "$P" status --check
+is "status --check after init" 0 "$RC"
+
+mkdir -p "$P/intelligence/rules"
+printf '# Team\n\nTEAM_BODY\n' > "$P/intelligence/rules/team.md"
+run "$P" sync
+is "sync of the team rule" 0 "$RC"
+commit_all "$P" start
+cp "$P/AGENTS.md" "$OUT/AGENTS.committed"
+
+echo "== local artifacts leave AGENTS.md and the work tree untouched =="
+mkdir -p "$P/intelligence/agents" "$P/intelligence/skills/deploy.local/references"
+printf '# Environment\n\nLOCAL_ENV_BODY\n' > "$P/intelligence/rules/.environment.local.md"
+printf -- '---\npaths:\n  - "src/**"\n---\n\nLOCAL_SCOPED_BODY\n' > "$P/intelligence/rules/scoped.local.md"
+printf -- '---\nname: helper\ndescription: "Local helper"\ntier: standard\naccess: readonly\n---\n\nLOCAL_AGENT_BODY\n' \
+    > "$P/intelligence/agents/helper.local.md"
+printf -- '---\nname: deploy\ndescription: "Deploy from this machine"\n---\n\nLOCAL_SKILL_BODY\n' \
+    > "$P/intelligence/skills/deploy.local/SKILL.md"
+printf 'notes\n' > "$P/intelligence/skills/deploy.local/references/notes.md"
+run "$P" sync
+is "sync with local artifacts" 0 "$RC"
+chk cmp -s "$OUT/AGENTS.committed" "$P/AGENTS.md"
+for word in environment scoped helper deploy LOCAL_; do
+    chknot grep -q "$word" "$P/AGENTS.md"
+done
+is "work tree after sync" "" "$(git -C "$P" status --porcelain)"
+
+echo "== local artifacts reach ignored outputs under their names =="
+for f in .claude/rules/environment.md .claude/rules/scoped.md .claude/agents/helper.md \
+    .claude/skills/deploy/SKILL.md .claude/skills/deploy/references/notes.md .cursor/rules/scoped.mdc \
+    .cursor/agents/helper.md .cursor/skills/deploy/SKILL.md .github/instructions/scoped.instructions.md \
+    .github/agents/helper.agent.md .github/skills/deploy/SKILL.md .codex/agents/helper.toml \
+    .agents/skills/deploy/SKILL.md .opencode/agents/helper.md; do
+    chk test -f "$P/$f"
+done
+chk grep -q LOCAL_ENV_BODY "$P/.claude/rules/environment.md"
+chk grep -q 'name = "helper"' "$P/.codex/agents/helper.toml"
+# The tracked OpenCode commands directory never names a local skill.
+chknot test -e "$P/.opencode/commands/deploy.md"
+is "no .local in any output name" "" "$(cd "$P" && find .claude .cursor .github .codex .agents .opencode -name '*.local*' 2>/dev/null)"
+
+echo "== a clone, which has no local artifact, passes sync --check =="
+git clone --quiet "$P" "$OUT/clone"
+git -C "$OUT/clone" config core.autocrlf false
+run "$OUT/clone" sync
+is "first sync in the clone" 0 "$RC"
+run "$OUT/clone" sync --check
+is "sync --check in the clone" 0 "$RC"
+chk cmp -s "$OUT/AGENTS.committed" "$OUT/clone/AGENTS.md"
+
+echo "== commit_output: true keeps every local artifact out of Copilot =="
+C="$OUT/committed"
+cp -R "$P" "$C"
+sed 's#copilot: { enabled: true, output: ".github" }#copilot: { enabled: true, output: ".github", commit_output: true }#' \
+    "$C/intelligence.yaml" > "$OUT/manifest" && cp "$OUT/manifest" "$C/intelligence.yaml"
+chk grep -q 'commit_output: true' "$C/intelligence.yaml"
+run "$C" init
+is "init with commit_output" 0 "$RC"
+commit_all "$C" "track copilot output"
+run "$C" sync --force
+is "sync with commit_output" 0 "$RC"
+for f in .github/instructions/scoped.instructions.md .github/agents/helper.agent.md .github/skills/deploy; do
+    chknot test -e "$C/$f"
+done
+chk test -f "$C/.claude/rules/scoped.md"
+is "work tree with tracked Copilot output" "" "$(git -C "$C" status --porcelain)"
+
+echo "== a local and a non-local artifact of one name refuse =="
+before="$(snapshot "$P")"
+printf '# Team, mine\n' > "$P/intelligence/rules/team.local.md"
+run "$P" sync
+is "team.local.md beside team.md" 1 "$RC"
+chk grep -Fq 'intelligence/rules/team.local.md' "$LOG"
+chk grep -Fq 'intelligence/rules/team.md' "$LOG"
+is "outputs after the refusal" "$before" "$(snapshot "$P")"
+rm "$P/intelligence/rules/team.local.md"
+printf '# Team, dot\n' > "$P/intelligence/rules/.team.md"
+run "$P" sync
+is ".team.md beside team.md" 1 "$RC"
+chk grep -Fq 'intelligence/rules/.team.md' "$LOG"
+chk grep -Fq 'intelligence/rules/team.md' "$LOG"
+is "outputs after the second refusal" "$before" "$(snapshot "$P")"
+rm "$P/intelligence/rules/.team.md"
+mkdir -p "$P/intelligence/skills/deploy"
+printf -- '---\nname: deploy\ndescription: "Shared deploy"\n---\n' > "$P/intelligence/skills/deploy/SKILL.md"
+run "$P" sync
+is "deploy/ beside deploy.local/" 1 "$RC"
+chk grep -Fq "both the skill 'deploy'" "$LOG"
+rm -rf "$P/intelligence/skills/deploy"
+# Across sources: a local artifact can neither override nor yield to a
+# committed one.
+mkdir -p "$P/shared/rules"
+printf '# Environment, shared\n' > "$P/shared/rules/environment.md"
+awk '{ print } /^  rules:/ && !done { print "    - \"shared/rules\""; done = 1 }' "$P/intelligence.yaml" > "$OUT/manifest"
+cp "$OUT/manifest" "$P/intelligence.yaml"
+run "$P" sync
+is "shared environment.md under a local one" 1 "$RC"
+chk grep -Fq 'shared/rules/environment.md' "$LOG"
+chk grep -Fq 'intelligence/rules/.environment.local.md' "$LOG"
+chk grep -Fq 'one local and one not' "$LOG"
+is "outputs after the cross-source refusal" "$before" "$(snapshot "$P")"
+rm "$P/shared/rules/environment.md"
+
+echo "== AGENTS.md applies source overrides: a same-named rule is listed once =="
+# Regression: AGENTS.md listed and inlined `style` once per source while every
+# copying adapter rendered only the later one.
+printf '# Style\n\nSHARED_STYLE\n' > "$P/shared/rules/style.md"
+printf '# Style\n\nPROJECT_STYLE\n' > "$P/intelligence/rules/style.md"
+run "$P" sync
+is "sync with an override" 0 "$RC"
+is "style entries in AGENTS.md" 1 "$(grep -c '^- \[style\]' "$P/AGENTS.md")"
+chk grep -Fq -- '- [style](intelligence/rules/style.md) (global)' "$P/AGENTS.md"
+chk grep -q PROJECT_STYLE "$P/AGENTS.md"
+chknot grep -q SHARED_STYLE "$P/AGENTS.md"
+chk grep -q PROJECT_STYLE "$P/.claude/rules/style.md"
+
+echo "== a skill a later source overrides is replaced whole =="
+mkdir -p "$P/shared/skills/review/references" "$P/intelligence/skills/review"
+printf -- '---\nname: review\ndescription: "Shared review"\n---\nSHARED_REVIEW\n' > "$P/shared/skills/review/SKILL.md"
+printf 'shared only\n' > "$P/shared/skills/review/references/shared.md"
+printf -- '---\nname: review\ndescription: "Project review"\n---\nPROJECT_REVIEW\n' > "$P/intelligence/skills/review/SKILL.md"
+awk '{ print } /^  skills:/ && !done { print "    - \"shared/skills\""; done = 1 }' "$P/intelligence.yaml" > "$OUT/manifest"
+cp "$OUT/manifest" "$P/intelligence.yaml"
+run "$P" sync
+is "sync with a skill override" 0 "$RC"
+is "review entries in AGENTS.md" 1 "$(grep -c '^| \[review\]' "$P/AGENTS.md")"
+chk grep -Fq '| [review](intelligence/skills/review/SKILL.md) | Project review |' "$P/AGENTS.md"
+for tree in .claude/skills .cursor/skills .github/skills .agents/skills; do
+    chk grep -q PROJECT_REVIEW "$P/$tree/review/SKILL.md"
+    chknot test -e "$P/$tree/review/references/shared.md"
+done
+
+echo "== a dotfile source renders in every adapter under its name =="
+# Regression: AGENTS.md read `.draft.md` while every other adapter's glob
+# skipped it, so the rule reached AGENTS.md only.
+printf '# Draft\n\nDRAFT_BODY\n' > "$P/intelligence/rules/.draft.md"
+printf -- '---\npaths:\n  - "docs/**"\n---\n\nDOC_DRAFT_BODY\n' > "$P/intelligence/rules/.doc-draft.md"
+run "$P" sync
+is "sync with dotfile rules" 0 "$RC"
+chk grep -Fq -- '- [draft](intelligence/rules/.draft.md) (global)' "$P/AGENTS.md"
+chk grep -Fq -- '- [doc-draft](intelligence/rules/.doc-draft.md) (scoped)' "$P/AGENTS.md"
+chk grep -q DRAFT_BODY "$P/AGENTS.md"
+chk grep -q DRAFT_BODY "$P/.claude/rules/draft.md"
+chk grep -q DOC_DRAFT_BODY "$P/.cursor/rules/doc-draft.mdc"
+chk grep -q DOC_DRAFT_BODY "$P/.github/instructions/doc-draft.instructions.md"
+chknot test -e "$P/.claude/rules/.draft.md"
+
+echo "== a project content directory of its own name =="
+D="$OUT/brain"
+mkdir -p "$D"
+git -C "$D" init --quiet
+run "$D" init --bare --dir Brain --targets agents,claude
+is "init --dir Brain" 0 "$RC"
+for pattern in 'Brain/rules/*.local.md' 'Brain/agents/*.local.md' 'Brain/skills/*.local/'; do
+    chk grep -Fqx "$pattern" "$D/.gitignore"
+done
+chknot grep -Fq 'intelligence/rules/*.local.md' "$D/.gitignore"
+
+[ "$fail" -eq 0 ] && echo "E2E-LOCAL-ARTIFACTS: ALL OK"
+exit "$fail"
diff --git a/cli/tests/e2e-negative.sh b/cli/tests/e2e-negative.sh
index 9439e6b..fd8fa57 100644
--- a/cli/tests/e2e-negative.sh
+++ b/cli/tests/e2e-negative.sh
@@ -151,6 +151,9 @@ EOF
 printf '# Ctx\n\nproject context\n' > "$PROJ/intelligence/rules/context.md"
 cat > "$PROJ/.gitignore" <<'EOF'
 .intelligence/
+intelligence/rules/*.local.md
+intelligence/agents/*.local.md
+intelligence/skills/*.local/
 CLAUDE.md
 .claude/*
 !.claude/settings.json
diff --git a/cli/tests/e2e-packages.sh b/cli/tests/e2e-packages.sh
index 935d424..663400f 100644
--- a/cli/tests/e2e-packages.sh
+++ b/cli/tests/e2e-packages.sh
@@ -62,6 +62,9 @@ EOF
 printf '# Ctx\n\nproject context\n' > "$PROJ/intelligence/rules/context.md"
 cat > "$PROJ/.gitignore" <<'EOF'
 .intelligence/
+intelligence/rules/*.local.md
+intelligence/agents/*.local.md
+intelligence/skills/*.local/
 CLAUDE.md
 .claude/*
 !.claude/settings.json
diff --git a/cli/tests/e2e-store-sha.sh b/cli/tests/e2e-store-sha.sh
index 45a594d..f13892d 100644
--- a/cli/tests/e2e-store-sha.sh
+++ b/cli/tests/e2e-store-sha.sh
@@ -52,7 +52,8 @@ targets:
   agents: { enabled: true, output: "AGENTS.md" }
 EOF
 printf '# Ctx\n\nproject context\n' > "$PROJ/intelligence/rules/context.md"
-printf '.intelligence/\n' > "$PROJ/.gitignore"
+printf '%s\n' .intelligence/ 'intelligence/rules/*.local.md' 'intelligence/agents/*.local.md' \
+    'intelligence/skills/*.local/' > "$PROJ/.gitignore"
 git -C "$PROJ" init --quiet
 
 echo '== install the package at v1.0.0 =='
diff --git a/cli/tests/unit-engine.sh b/cli/tests/unit-engine.sh
index 560a666..dd72533 100644
--- a/cli/tests/unit-engine.sh
+++ b/cli/tests/unit-engine.sh
@@ -684,5 +684,117 @@ else
     echo "  NOTE: this host cannot create a symlink — skill source links not exercised"
 fi
 
+echo "== source_artifact_name_var: the name rule and locality (decision 0021) =="
+while IFS=' ' read -r section entry name local; do
+    source_artifact_name_var "$section" "$entry"
+    eq "$IS_ART_NAME/$IS_ART_LOCAL" "$name/$local" \
+        || { echo "FAIL: $section $entry: got $IS_ART_NAME/$IS_ART_LOCAL want $name/$local"; fail=1; }
+done <<'EOF'
+rules team.md team 0
+rules .draft.md draft 0
+rules environment.local.md environment 1
+rules .environment.local.md environment 1
+rules .local.md local 1
+rules local.md local 0
+rules x.local.local.md x.local 1
+agents helper.local.md helper 1
+agents .helper.md helper 0
+skills deploy deploy 0
+skills deploy.local deploy 1
+skills .deploy deploy 0
+skills .local local 1
+skills notes.md notes.md 0
+EOF
+
+echo "== policy_pattern_covers: contract ignore patterns as Git reads them =="
+while IFS=' ' read -r pattern path want; do
+    got=0
+    policy_pattern_covers "$pattern" "$path" || got=1
+    eq "$got" "$want" || { echo "FAIL: $pattern covers $path: got $got want $want"; fail=1; }
+done <<'EOF'
+.claude/* .claude/rules/x.md 0
+.claude/* .claude 1
+.agents/skills/ .agents/skills/deploy 0
+.agents/skills/ .agents/skillset/x 1
+.codex/agents/ .codex/agents/helper.toml 0
+.pi/prompts/intelligence-agent-*.md .pi/prompts/intelligence-agent-helper.md 0
+.pi/prompts/intelligence-agent-*.md .pi/prompts/mine.md 1
+./.github/agents/ .github/agents/helper.agent.md 0
+CLAUDE.md CLAUDE.md 0
+.claude/settings.json .claude/settings.json 0
+EOF
+
+echo "== source catalog: overrides, refusals and local membership =="
+chknot() { if "$@" >/dev/null 2>&1; then echo "FAIL(not): $*"; fail=1; fi; }
+S="$OUT/catalog"
+mkdir -p "$S/a/rules" "$S/b/rules" "$S/b/agents" "$S/b/skills/deploy.local" "$S/b/skills/review"
+printf 'sources:\n  rules:\n    - "a/rules"\n    - "b/rules"\n  agents:\n    - "b/agents"\n  skills:\n    - "b/skills"\n' > "$S/intelligence.yaml"
+printf 'shared style\n' > "$S/a/rules/style.md"
+printf 'project style\n' > "$S/b/rules/style.md"
+printf -- '---\npaths:\n  - "src/**"\n---\n' > "$S/b/rules/.scoped.md"
+printf 'mine\n' > "$S/b/rules/me.local.md"
+printf -- '---\nname: x\n---\n' > "$S/b/agents/x.local.md"
+printf -- '---\nname: deploy\n---\n' > "$S/b/skills/deploy.local/SKILL.md"
+printf -- '---\nname: review\n---\n' > "$S/b/skills/review/SKILL.md"
+IS_SOURCE_FILES_MEMO=0 source_catalog_build "$S" "$S/intelligence.yaml" 2> "$OUT/catalog.err"
+chk eq "$(cat "$OUT/catalog.err")" ""
+chk eq "$IS_CAT_NEED_COMMITTED" 1
+# A render that would need Git policy without the engine having read it stops.
+rc=0
+(IS_SOURCE_FILES_MEMO=0 source_artifacts_var "$S" "$S/intelligence.yaml" rules claude ".claude/rules/{}.md") \
+    > /dev/null 2>&1 || rc=$?
+chk eq "$rc" 1
+# shellcheck disable=SC2034  # read by output_committed
+IS_COMMIT_POLICY=$'claude\tignore\t.claude/*\nclaude\tinclude\t.claude/settings.json\ncodex\tignore\t.codex/agents/\n'
+# shellcheck disable=SC2034
+IS_COMMIT_POLICY_SET=1
+# Sources in manifest order, entries in byte order; the later style wins.
+IS_SOURCE_FILES_MEMO=0 source_artifacts_var "$S" "$S/intelligence.yaml" rules claude ".claude/rules/{}.md"
+chk eq "${IS_SOURCE_NAMES[*]}" "scoped me style"
+chk eq "${IS_SOURCE_FILES[*]}" "$S/b/rules/.scoped.md $S/b/rules/me.local.md $S/b/rules/style.md"
+chk eq "${IS_SOURCE_SCOPED[*]}" "1 0 0"
+chk eq "${IS_SOURCE_IN_AGENTS[*]}" "1 0 1"
+source_name_map_var "$IS_SOURCE_NAME_MAP" "$S/b/rules/me.local.md"
+chk eq "$IS_MAPPED_NAME" "me"
+# AGENTS.md is always committed; an output no contract ignores is too.
+IS_SOURCE_FILES_MEMO=0 source_artifacts_var "$S" "$S/intelligence.yaml" rules agents "AGENTS.md"
+chk eq "${IS_SOURCE_NAMES[*]}" "scoped style"
+IS_SOURCE_FILES_MEMO=0 source_artifacts_var "$S" "$S/intelligence.yaml" agents opencode ".opencode/commands/{}.md"
+chk eq "${#IS_SOURCE_FILES[@]}" 0
+IS_SOURCE_FILES_MEMO=0 source_artifacts_var "$S" "$S/intelligence.yaml" agents codex ".codex/agents/{}.toml"
+chk eq "${IS_SOURCE_NAMES[*]}" "x"
+# One of several readers is enough; a skill is keyed by its directory.
+IS_SOURCE_FILES_MEMO=0 source_artifacts_var "$S" "$S/intelligence.yaml" skills "opencode codex" ".codex/agents/{}"
+chk eq "${IS_SOURCE_NAMES[*]}" "deploy review"
+source_name_map_var "$IS_SOURCE_NAME_MAP" "$S/b/skills/deploy.local"
+chk eq "$IS_MAPPED_NAME" "deploy"
+copy_skill_bundle_dirs_named open "$OUT/catalog-out" "$IS_SOURCE_NAME_MAP" "$S/b/skills/deploy.local/" "$S/b/skills/review"
+chk test -f "$OUT/catalog-out/deploy/SKILL.md"
+chk test -f "$OUT/catalog-out/review/SKILL.md"
+chknot test -e "$OUT/catalog-out/deploy.local"
+finalize_copy_named "$OUT/catalog-out" $'\n'"$S/b/rules/me.local.md"$'\x1f'"me"$'\n' "$S/b/rules/me.local.md" "$S/b/rules/style.md"
+chk test -f "$OUT/catalog-out/me.md"
+chk test -f "$OUT/catalog-out/style.md"
+unset IS_COMMIT_POLICY IS_COMMIT_POLICY_SET
+# Two of one name in one directory, and a local beside a committed one,
+# refuse and name both files.
+printf 'dot style\n' > "$S/b/rules/.style.md"
+rc=0
+(IS_SOURCE_FILES_MEMO=0 source_catalog_build "$S" "$S/intelligence.yaml") > /dev/null 2> "$OUT/catalog.err" || rc=$?
+chk eq "$rc" 1
+chk grep -Fq "b/rules/.style.md and b/rules/style.md are both the rule 'style' in one directory" "$OUT/catalog.err"
+rm "$S/b/rules/.style.md"
+printf 'local style\n' > "$S/b/rules/style.local.md"
+rm "$S/b/rules/style.md"
+rc=0
+(IS_SOURCE_FILES_MEMO=0 source_catalog_build "$S" "$S/intelligence.yaml") > /dev/null 2> "$OUT/catalog.err" || rc=$?
+chk eq "$rc" 1
+chk grep -Fq "a/rules/style.md and b/rules/style.local.md are both the rule 'style', one local and one not" "$OUT/catalog.err"
+rm "$S/b/rules/style.local.md"
+# One directory listed twice is one artifact, not a conflict.
+printf 'sources:\n  rules:\n    - "a/rules"\n    - "a/rules/"\n' > "$S/twice.yaml"
+IS_SOURCE_FILES_MEMO=0 source_catalog_winners_var "$S" "$S/twice.yaml" rules
+chk eq "${#IS_SOURCE_FILES[@]}" 1
+
 [ "$fail" -eq 0 ] && echo "ENGINE-UNIT: ALL OK"
 exit "$fail"
diff --git a/cli/tests/unit-gitignore.sh b/cli/tests/unit-gitignore.sh
index b6c8491..ed1dfa1 100644
--- a/cli/tests/unit-gitignore.sh
+++ b/cli/tests/unit-gitignore.sh
@@ -214,7 +214,7 @@ COPILOT_HANDWRITTEN=(.github/workflows/ci.yml .github/PULL_REQUEST_TEMPLATE.md)
 echo "== Copilot output is ignored by default: its four directories, never .github/ =="
 D="$(fixture copilot)"
 copilot_manifest "$D" '  copilot: { enabled: true, output: ".github" }'
-ensure_base_gitignore "$D"
+ensure_base_gitignore "$D" intelligence
 ensure_target_gitignore "$D" "$D/intelligence.yaml" copilot
 for sub in "${COPILOT_DIRS[@]}"; do
     is ".github/$sub/ listed once" "1" "$(count_of "$D" ".github/$sub/")"
@@ -314,5 +314,26 @@ adapter_contract_unsafe() {
 EOF
 chknot adapter_contract_records unsafe "$D/unsafe.sh" .unsafe
 
+echo "== local artifact patterns: the content directory's, written once (decision 0021) =="
+D="$(fixture local-artifacts)"
+printf 'project:\n  name: local\n  intelligence_dir: "Brain"\ntargets:\n  agents: { enabled: true, output: "AGENTS.md" }\n' > "$D/intelligence.yaml"
+is "patterns of a content dir given with a slash" \
+    "Brain/rules/*.local.md Brain/agents/*.local.md Brain/skills/*.local/" \
+    "$(local_artifact_ignore_patterns ./Brain/ | tr '\n' ' ' | sed 's/ $//')"
+ensure_manifest_gitignore "$D" "$D/intelligence.yaml"
+cp "$D/.gitignore" "$OUT/local.once"
+ensure_manifest_gitignore "$D" "$D/intelligence.yaml"
+chk cmp -s "$OUT/local.once" "$D/.gitignore"
+for pattern in 'Brain/rules/*.local.md' 'Brain/agents/*.local.md' 'Brain/skills/*.local/'; do
+    is "$pattern listed once" "1" "$(count_of "$D" "$pattern")"
+    chk grep -Fqx "$pattern" <(managed_gitignore_patterns "$D" "$D/intelligence.yaml")
+done
+for path in Brain/rules/me.local.md Brain/rules/.env.local.md Brain/agents/a.local.md Brain/skills/deploy.local/SKILL.md; do
+    chk git -C "$D" check-ignore -q --no-index "$path"
+done
+for path in Brain/rules/me.md Brain/rules/.draft.md Brain/skills/deploy/SKILL.md Brain/skills/x/y.local.md; do
+    chknot git -C "$D" check-ignore -q --no-index "$path"
+done
+
 [ "$fail" -eq 0 ] && echo "CLI-UNIT-GITIGNORE: ALL OK"
 exit "$fail"
diff --git a/cli/tests/verify.sh b/cli/tests/verify.sh
index e9c7ff4..7226dd0 100644
--- a/cli/tests/verify.sh
+++ b/cli/tests/verify.sh
@@ -25,7 +25,7 @@ set -euo pipefail
 REPO="$(cd "$(dirname "$0")/../.." && pwd)"
 cd "$REPO"
 
-SUITES=(unit-semver unit-manifest unit-engine unit-gitignore unit-release unit-fetch unit-upgrade unit-verify e2e-sources e2e-packages e2e-lifecycle e2e-negative e2e-lock-validation e2e-compat e2e-sync-cache e2e-sync-check e2e-concurrency e2e-sync-lock e2e-store-sha)
+SUITES=(unit-semver unit-manifest unit-engine unit-gitignore unit-release unit-fetch unit-upgrade unit-verify e2e-sources e2e-local-artifacts e2e-packages e2e-lifecycle e2e-negative e2e-lock-validation e2e-compat e2e-sync-cache e2e-sync-check e2e-concurrency e2e-sync-lock e2e-store-sha)
 
 failed=0
 skipped=()
diff --git a/docs/cli.md b/docs/cli.md
index a1d8241..c780b1d 100644
--- a/docs/cli.md
+++ b/docs/cli.md
@@ -75,7 +75,10 @@ and toggling adapters and explains the generated-output version-control
 choices. Installing the starter package before learning lets repository
 analysis detect overlap with package-owned content. The CLI ignores restorable adapter-owned output while keeping
 `AGENTS.md`, hand-written `.github/` files, and shared tool settings trackable;
-`targets.copilot.commit_output: true` keeps Copilot's output tracked too. The exact patterns
+`targets.copilot.commit_output: true` keeps Copilot's output tracked too. It also
+ignores the local artifacts of the content directory — `<content-dir>/rules/*.local.md`,
+`<content-dir>/agents/*.local.md` and `<content-dir>/skills/*.local/` — which sync renders
+only into ignored output (decision 0021). The exact patterns
 are listed in the [artifact conventions](../packages/sync/references/conventions.md#generated-output-and-version-control).
 When `.vscodeignore`, `.npmignore`, or `.dockerignore` already exists, init
 also adds packaging exclusions for Intelligence development context and
@@ -105,6 +108,17 @@ For Intelligence projects, sync performs lifecycle preflight before rendering:
 A filtered adapter must be enabled explicitly; naming it does not bypass target
 state. Project adapters without a valid contract are refused before sync.
 
+Every renderer reads sources through one catalog (decision 0021). An artifact is
+named by its file or skill directory name without a leading `.`, `.md` and a
+trailing `.local`; of two with one name, the later source's renders everywhere,
+`AGENTS.md` included. Sync refuses, before any output is touched, two artifacts
+with one name in one directory and a local and a non-local artifact with one
+name anywhere. A local artifact (`*.local.md`, `*.local/`) renders only into
+outputs its adapter's contract ignores, so committed files are the same in every
+clone. Only a sync whose sources hold a local artifact reads the contracts with
+the manifest, which `targets.copilot.commit_output` needs; see the
+[artifact conventions](../packages/sync/references/conventions.md#artifact-names-and-local-artifacts).
+
 Built-in adapters render concurrently where their contracts allow it: adapters
 that share a managed directory run in order together, and an adapter that
 requires another starts after it. Each adapter's output still prints in list
@@ -232,7 +246,7 @@ It answers in one of two ways:
   the exact answer.
 - **By rendering.** Without a usable record — none yet, damaged, from an older
   CLI, or made by other code or in another environment (a different `PATH` is
-  enough) — the engine renders in a private project copy, compares every owned
+  enough) � the engine renders in a private project copy, compares every owned
   and managed path with its snapshot, and discards the copy. The live project's
   bytes, modification times and concurrent edits stay untouched. Names, entry
   kinds, link targets, bytes and executable bits count; nested generated links
@@ -426,7 +440,9 @@ that require trusted lock rows.
 manifest/lock divergence, missing package content, a package holding a commit
 other than the locked one or recording none, stale schema/content, invalid
 sources — a [package reference](#package-references) that names nothing
-included — or an alias that is malformed or that two packages declare. Each
+included — or an alias that is malformed or that two packages declare, and for
+a managed `.gitignore` pattern that is missing: an adapter's, or one of the three
+local artifact patterns of the content directory. Each
 package line reports the commit the store holds. Frozen store
 restoration verifies the locked commit SHA.
 
diff --git a/engine/adapters/_template.sh b/engine/adapters/_template.sh
index 2465a3d..46dea4e 100644
--- a/engine/adapters/_template.sh
+++ b/engine/adapters/_template.sh
@@ -30,9 +30,17 @@
 #   map_effort(tool, effort)            — the tool's level for a neutral effort; "" when none
 #   map_access_to_claude_tools(access)  — full->"" (no tools list; inherits all), readonly->restricted
 #   map_access_to_claude_disallowed(access) — readonly->"Write, Edit", full->""
-#   read_yaml_list(manifest, section)   — read a source list from intelligence.yaml,
-#                                         package references as their store paths
+#   source_artifacts_var(root, config, section, adapter, output)
+#                                       — the sources this adapter renders (below)
+#   finalize_copy_named(dir, map, file...) — copy and finalize files under their rendered names
+#   copy_skill_bundle_dirs_named(tool, dir, map, skill_dir...) — copy skills under their rendered names
 #   get_target_field(config, target, field) — read a target's config field
+#
+# Read sources through source_artifacts_var, never with a glob of your own: it
+# names each artifact (`.draft.md` is `draft`, `me.local.md` is `me`), renders
+# only the later of two same-named artifacts, and leaves a local artifact out of
+# every output path Git tracks (decision 0021). An adapter that globs sources
+# itself can write a teammate's local file into a committed output.
 
 # Project adapters are sourced by engine/sync.sh after the shared library is
 # loaded. Keep this template position-independent: after scaffolding it lives
@@ -61,13 +69,21 @@ adapter_contract_<name>() {
 #   - Copy as-is (like Claude)
 #   - Convert paths: to globs: (like Cursor)
 #   - Merge into single file (like Copilot)
+#
+# source_artifacts_var takes the repo-relative path an artifact lands at, `{}`
+# standing for its name, and fills IS_SOURCE_FILES (the source file, or a
+# skill's SKILL.md), IS_SOURCE_NAMES, IS_SOURCE_SCOPED (1 for a rule with
+# `paths:`) and IS_SOURCE_NAME_MAP, the names finalize_copy_named and
+# copy_skill_bundle_dirs_named write under.
 sync_<name>_rules() {
     local repo_root="$1"
     local config_file="$2"
     local output_dir="$3"
 
-    # TODO: Implement rule sync logic
-    echo "  rules: not implemented"
+    output_rel_var "$repo_root" "$output_dir"
+    source_artifacts_var "$repo_root" "$config_file" rules <name> "$IS_OUTPUT_REL/rules/{}.md"
+    # TODO: Render each of IS_SOURCE_FILES into $output_dir/rules/ under its IS_SOURCE_NAMES entry
+    echo "  rules: ${#IS_SOURCE_FILES[@]} found, not rendered"
 }
 
 # Sync skills for <agent-name>
@@ -76,8 +92,11 @@ sync_<name>_skills() {
     local config_file="$2"
     local output_dir="$3"
 
-    # TODO: Implement skill sync logic
-    echo "  skills: not implemented"
+    output_rel_var "$repo_root" "$output_dir"
+    source_artifacts_var "$repo_root" "$config_file" skills <name> "$IS_OUTPUT_REL/skills/{}"
+    # TODO: Copy each skill directory ("${IS_SOURCE_FILES[i]%/SKILL.md}") with
+    # copy_skill_bundle_dirs_named <name> "$output_dir/skills" "$IS_SOURCE_NAME_MAP" <dir>...
+    echo "  skills: ${#IS_SOURCE_FILES[@]} found, not rendered"
 }
 
 # Sync agents for <agent-name>
@@ -86,8 +105,10 @@ sync_<name>_agents() {
     local config_file="$2"
     local output_dir="$3"
 
-    # TODO: Implement agent sync logic
-    echo "  agents: not implemented"
+    output_rel_var "$repo_root" "$output_dir"
+    source_artifacts_var "$repo_root" "$config_file" agents <name> "$IS_OUTPUT_REL/agents/{}.md"
+    # TODO: Render each of IS_SOURCE_FILES into $output_dir/agents/ under its IS_SOURCE_NAMES entry
+    echo "  agents: ${#IS_SOURCE_FILES[@]} found, not rendered"
 }
 
 # Main entry point
diff --git a/engine/adapters/agents.sh b/engine/adapters/agents.sh
index c2f4f71..8037f0c 100644
--- a/engine/adapters/agents.sh
+++ b/engine/adapters/agents.sh
@@ -60,15 +60,19 @@ agents_md_append_agents_table() {
     local rows=""
     local count=0
 
-    local -a files=()
-    read_source_artifact_files "$repo_root" "$config_file" "agents"
-    [ "${#IS_SOURCE_FILES[@]}" -eq 0 ] || files=("${IS_SOURCE_FILES[@]}")
+    local -a files=() names=()
+    source_artifacts_var "$repo_root" "$config_file" agents agents "${output#"$repo_root"/}"
+    if [ "${#IS_SOURCE_FILES[@]}" -gt 0 ]; then
+        files=("${IS_SOURCE_FILES[@]}")
+        names=("${IS_SOURCE_NAMES[@]}")
+    fi
 
     if [ "${#files[@]}" -gt 0 ]; then
-        local path tier access desc name
+        local path tier access desc name i=0
+        # frontmatter_index prints one row per file, in argument order.
         while IFS=$'\x1f' read -r path tier access desc; do
-            [ -n "$path" ] || continue
-            name="${path##*/}"; name="${name%.md}"
+            name="${names[i]}"
+            i=$((i + 1))
             repo_rel_link_var "$repo_root" "$path"
             if [ -n "$IS_REPO_REL" ]; then
                 rows+="| [$name]($IS_REPO_REL) | ${tier:--} | ${access:--} | ${desc:--} |"$'\n'
@@ -101,21 +105,24 @@ agents_md_append_skills_table() {
     local rows=""
     local count=0
 
-    local dirname
-    local -a skill_files=()
-    read_source_artifact_files "$repo_root" "$config_file" "skills"
-    [ "${#IS_SOURCE_FILES[@]}" -eq 0 ] || skill_files=("${IS_SOURCE_FILES[@]}")
+    local name
+    local -a skill_files=() names=()
+    source_artifacts_var "$repo_root" "$config_file" skills agents "${output#"$repo_root"/}"
+    if [ "${#IS_SOURCE_FILES[@]}" -gt 0 ]; then
+        skill_files=("${IS_SOURCE_FILES[@]}")
+        names=("${IS_SOURCE_NAMES[@]}")
+    fi
 
     if [ "${#skill_files[@]}" -gt 0 ]; then
-        local path desc
+        local path desc i=0
         while IFS=$'\x1f' read -r path desc; do
-            [ -n "$path" ] || continue
-            dirname="${path%/SKILL.md}"; dirname="${dirname##*/}"
+            name="${names[i]}"
+            i=$((i + 1))
             repo_rel_link_var "$repo_root" "$path"
             if [ -n "$IS_REPO_REL" ]; then
-                rows+="| [$dirname]($IS_REPO_REL) | ${desc:--} |"$'\n'
+                rows+="| [$name]($IS_REPO_REL) | ${desc:--} |"$'\n'
             else
-                rows+="| $dirname | ${desc:--} |"$'\n'
+                rows+="| $name | ${desc:--} |"$'\n'
             fi
             count=$((count + 1))
         done < <(frontmatter_index "description" "${skill_files[@]}")
@@ -144,30 +151,25 @@ agents_md_append_rules_list() {
     local count=0
     local global_rule_files=()
 
-    local -a files=()
-    read_source_artifact_files "$repo_root" "$config_file" "rules"
-    [ "${#IS_SOURCE_FILES[@]}" -eq 0 ] || files=("${IS_SOURCE_FILES[@]}")
-
-    if [ "${#files[@]}" -gt 0 ]; then
-        local path hp name scope
-        while IFS=$'\x1f' read -r path hp; do
-            [ -n "$path" ] || continue
-            name="${path##*/}"; name="${name%.md}"
-            scope="global"
-            if [ "$hp" != "0" ]; then
-                scope="scoped"
-            else
-                global_rule_files+=("$path")
-            fi
-            repo_rel_link_var "$repo_root" "$path"
-            if [ -n "$IS_REPO_REL" ]; then
-                lines+="- [$name]($IS_REPO_REL) ($scope)"$'\n'
-            else
-                lines+="- $name ($scope)"$'\n'
-            fi
-            count=$((count + 1))
-        done < <(frontmatter_index "paths#" "${files[@]}")
-    fi
+    local i path name scope
+    source_artifacts_var "$repo_root" "$config_file" rules agents "${output#"$repo_root"/}"
+    for ((i = 0; i < ${#IS_SOURCE_FILES[@]}; i++)); do
+        path="${IS_SOURCE_FILES[i]}"
+        name="${IS_SOURCE_NAMES[i]}"
+        scope="global"
+        if [ "${IS_SOURCE_SCOPED[i]}" = 1 ]; then
+            scope="scoped"
+        else
+            global_rule_files+=("$path")
+        fi
+        repo_rel_link_var "$repo_root" "$path"
+        if [ -n "$IS_REPO_REL" ]; then
+            lines+="- [$name]($IS_REPO_REL) ($scope)"$'\n'
+        else
+            lines+="- $name ($scope)"$'\n'
+        fi
+        count=$((count + 1))
+    done
 
     [ "$count" -eq 0 ] && return 0
 
diff --git a/engine/adapters/antigravity.sh b/engine/adapters/antigravity.sh
index 4d3106d..4e1462f 100644
--- a/engine/adapters/antigravity.sh
+++ b/engine/adapters/antigravity.sh
@@ -95,30 +95,16 @@ sync_antigravity_rules() {
     antigravity_rule_limit "$config_file" || return 1
     rule_limit="$IS_AG_RULE_LIMIT"
 
-    local src f
-    local -a files=()
-    load_yaml_list "$config_file" "rules"
-    local list="$IS_YAML_LIST"
-    while IFS= read -r src; do
-        [ -z "$src" ] && continue
-        local dir="$repo_root/$src"
-        [ -d "$dir" ] || continue
-        for f in "$dir"/*.md; do
-            [ -f "$f" ] || continue
-            files+=("$f")
-        done
-    done <<< "$list"
-
     # Skip always-on rules: AGENTS.md (canonical) carries them.
-    local path hp base
-    local -a scoped=()
-    if [ "${#files[@]}" -gt 0 ]; then
-        while IFS=$'\x1f' read -r path hp; do
-            [ -n "$path" ] || continue
-            [ "$hp" -eq 0 ] && continue
-            scoped+=("$path")
-        done < <(frontmatter_index "paths#" "${files[@]}")
-    fi
+    local i
+    local -a scoped=() scoped_names=()
+    output_rel_var "$repo_root" "$output_dir"
+    source_artifacts_var "$repo_root" "$config_file" rules antigravity "$IS_OUTPUT_REL/rules/{}.md"
+    for ((i = 0; i < ${#IS_SOURCE_FILES[@]}; i++)); do
+        [ "${IS_SOURCE_SCOPED[i]}" = 1 ] || continue
+        scoped+=("${IS_SOURCE_FILES[i]}")
+        scoped_names+=("${IS_SOURCE_NAMES[i]}")
+    done
     if [ "${#scoped[@]}" -eq 0 ]; then
         echo "  -> Rules: 0 scoped (AGENTS.md carries always-on)"
         return 0
@@ -133,7 +119,7 @@ sync_antigravity_rules() {
     # limit check costs no extra process.
     local overflow
     is_fin_awk_vars
-    overflow="$(awk "${IS_FIN_V[@]}" -v dst="$output_dir/rules" -v limit="$rule_limit" "$IS_AWK_LIB"'
+    overflow="$(IS_NAME_MAP="$IS_SOURCE_NAME_MAP" awk "${IS_FIN_V[@]}" -v dst="$output_dir/rules" -v limit="$rule_limit" "$IS_AWK_LIB"'
         function emit(line,   rendered) {
             rendered = fin_line(line)
             print rendered > out
@@ -141,7 +127,7 @@ sync_antigravity_rules() {
         }
         FNR == 1 {
             if (out != "") close(out)
-            out = dst "/" base_name(FILENAME)
+            out = dst "/" art_file(FILENAME, ".md")
             chars[out] = 0
             fm = 0
         }
@@ -169,9 +155,8 @@ sync_antigravity_rules() {
         echo "WARNING: Antigravity limits a rule file to $rule_limit characters: ${over_file#"$repo_root/"} renders $over_chars; split the rule, shorten it, set targets.antigravity.warn_rule_limit to the effective limit, or set it to false to disable this warning." >&2
     done <<< "$overflow"
 
-    for f in "${scoped[@]}"; do
-        base="${f##*/}"
-        echo "  rule: $base (scoped)"
+    for ((i = 0; i < ${#scoped_names[@]}; i++)); do
+        echo "  rule: ${scoped_names[i]}.md (scoped)"
     done
     echo "  -> Rules: ${#scoped[@]} scoped"
 }
@@ -181,19 +166,13 @@ sync_antigravity_agents() {
     local config_file="$2"
     local agents_dir="$3"
 
-    local src f
-    local -a files=()
-    load_yaml_list "$config_file" "agents"
-    local list="$IS_YAML_LIST"
-    while IFS= read -r src; do
-        [ -z "$src" ] && continue
-        local dir="$repo_root/$src"
-        [ -d "$dir" ] || continue
-        for f in "$dir"/*.md; do
-            [ -f "$f" ] || continue
-            files+=("$f")
-        done
-    done <<< "$list"
+    local -a files=() names=()
+    output_rel_var "$repo_root" "$agents_dir"
+    source_artifacts_var "$repo_root" "$config_file" agents antigravity "$IS_OUTPUT_REL/{}.md"
+    if [ "${#IS_SOURCE_FILES[@]}" -gt 0 ]; then
+        files=("${IS_SOURCE_FILES[@]}")
+        names=("${IS_SOURCE_NAMES[@]}")
+    fi
 
     local count=0
     if [ "${#files[@]}" -gt 0 ]; then
@@ -201,8 +180,7 @@ sync_antigravity_agents() {
 
         local path tier access description name spec="" report="" LS=$'\x1e'
         while IFS=$'\x1f' read -r path tier access description; do
-            [ -n "$path" ] || continue
-            name="${path##*/}"; name="${name%.md}"
+            name="${names[count]}"
             resolve_model_var "$tier"
 
             local header
diff --git a/engine/adapters/claude.sh b/engine/adapters/claude.sh
index 1863f59..662bdfe 100644
--- a/engine/adapters/claude.sh
+++ b/engine/adapters/claude.sh
@@ -35,23 +35,15 @@ sync_claude_rules() {
     local config_file="$2"
     local output_dir="$3"
 
-    local src f
-    local -a files=()
-    load_yaml_list "$config_file" "rules"
-    local list="$IS_YAML_LIST"
-    while IFS= read -r src; do
-        [ -z "$src" ] && continue
-        local dir="$repo_root/$src"
-        [ -d "$dir" ] || continue
-        for f in "$dir"/*.md; do
-            [ -f "$f" ] || continue
-            files+=("$f")
-        done
-    done <<< "$list"
-    [ "${#files[@]}" -gt 0 ] || return 0
-    finalize_copy_files "$output_dir/rules" "${files[@]}"
-    for f in "${files[@]}"; do
-        echo "  rule: ${f##*/}"
+    local name
+    # Every source reaches this adapter through the source catalog (decision
+    # 0021): rendered names, overrides and local artifacts are settled there.
+    output_rel_var "$repo_root" "$output_dir"
+    source_artifacts_var "$repo_root" "$config_file" rules claude "$IS_OUTPUT_REL/rules/{}.md"
+    [ "${#IS_SOURCE_FILES[@]}" -gt 0 ] || return 0
+    finalize_copy_named "$output_dir/rules" "$IS_SOURCE_NAME_MAP" "${IS_SOURCE_FILES[@]}"
+    for name in "${IS_SOURCE_NAMES[@]}"; do
+        echo "  rule: $name.md"
     done
 }
 
@@ -61,29 +53,19 @@ sync_claude_skills() {
     local config_file="$2"
     local output_dir="$3"
 
-    local src d skill_name
+    local i name
     local -a skill_dirs=()
-    # The inventory decides which skills render, symlinked ones included
-    # (decision 0017); the glob keeps this adapter's own listing order.
-    skill_source_inventory "$repo_root" "$config_file"
-    load_yaml_list "$config_file" "skills"
-    local list="$IS_YAML_LIST"
-    while IFS= read -r src; do
-        [ -z "$src" ] && continue
-        local dir="$repo_root/$src"
-        [ -d "$dir" ] || continue
-        for d in "$dir"/*/; do
-            [ -d "$d" ] || continue
-            [ -f "$d/SKILL.md" ] || continue
-            skill_source_rendered "$d" || continue
-            skill_dirs+=("$d")
-        done
-    done <<< "$list"
-    [ "${#skill_dirs[@]}" -gt 0 ] || return 0
-    copy_skill_bundle_dirs_for claude "$output_dir/skills" "${skill_dirs[@]}"
-    for d in "${skill_dirs[@]}"; do
-        skill_name="${d%/}"
-        echo "  skill: ${skill_name##*/}"
+    # The catalog's skills are the ones the inventory renders, symlinked ones
+    # included (decision 0017).
+    output_rel_var "$repo_root" "$output_dir"
+    source_artifacts_var "$repo_root" "$config_file" skills claude "$IS_OUTPUT_REL/skills/{}"
+    [ "${#IS_SOURCE_FILES[@]}" -gt 0 ] || return 0
+    for ((i = 0; i < ${#IS_SOURCE_FILES[@]}; i++)); do
+        skill_dirs+=("${IS_SOURCE_FILES[i]%/SKILL.md}/")
+    done
+    copy_skill_bundle_dirs_named claude "$output_dir/skills" "$IS_SOURCE_NAME_MAP" "${skill_dirs[@]}"
+    for name in "${IS_SOURCE_NAMES[@]}"; do
+        echo "  skill: $name"
     done
 }
 
@@ -94,32 +76,27 @@ sync_claude_agents() {
     local config_file="$2"
     local output_dir="$3"
 
-    local src f
-    local -a files=()
-    load_yaml_list "$config_file" "agents"
-    local list="$IS_YAML_LIST"
-    while IFS= read -r src; do
-        [ -z "$src" ] && continue
-        local dir="$repo_root/$src"
-        [ -d "$dir" ] || continue
-        for f in "$dir"/*.md; do
-            [ -f "$f" ] || continue
-            files+=("$f")
-        done
-    done <<< "$list"
-    [ "${#files[@]}" -gt 0 ] || return 0
+    local i
+    local -a files=() names=()
+    output_rel_var "$repo_root" "$output_dir"
+    source_artifacts_var "$repo_root" "$config_file" agents claude "$IS_OUTPUT_REL/agents/{}.md"
+    [ "${#IS_SOURCE_FILES[@]}" -gt 0 ] || return 0
+    files=("${IS_SOURCE_FILES[@]}")
+    names=("${IS_SOURCE_NAMES[@]}")
+    local name_map="$IS_SOURCE_NAME_MAP"
 
     load_model_tiers "$config_file" "claude"
 
     local path tier access effort spec="" report=""
+    i=0
     while IFS=$'\x1f' read -r path tier access effort; do
-        [ -n "$path" ] || continue
         resolve_model_var "$tier"
         map_effort_var claude "$effort"
         map_access_to_claude_tools_var "$access"
         map_access_to_claude_disallowed_var "$access"
         spec+="$path"$'\x1f'"$IS_MODEL"$'\x1f'"$IS_CLAUDE_TOOLS"$'\x1f'"$IS_CLAUDE_DISALLOWED"$'\x1f'"$IS_EFFORT"$'\n'
-        report+="  agent: ${path##*/} (tier=$tier -> model=$IS_MODEL, access=$access)"$'\n'
+        report+="  agent: ${names[i]}.md (tier=$tier -> model=$IS_MODEL, access=$access)"$'\n'
+        i=$((i + 1))
     done < <(frontmatter_index "tier,access,effort" "${files[@]}")
 
     # The transform used to run per file with the values injected via -v;
@@ -128,7 +105,7 @@ sync_claude_agents() {
     # becomes Claude's level in place, or goes when there is none; a later
     # one goes too, since frontmatter_index read only the first.
     is_fin_awk_vars
-    IS_MAP_SPEC="$spec" awk "${IS_FIN_V[@]}" -v dst="$output_dir/agents" "$IS_AWK_LIB"'
+    IS_NAME_MAP="$name_map" IS_MAP_SPEC="$spec" awk "${IS_FIN_V[@]}" -v dst="$output_dir/agents" "$IS_AWK_LIB"'
         BEGIN {
             US = sprintf("%c", 31)
             n = split(ENVIRON["IS_MAP_SPEC"], recs, "\n")
@@ -140,7 +117,7 @@ sync_claude_agents() {
         }
         FNR == 1 {
             if (out != "") close(out)
-            out = dst "/" base_name(FILENAME)
+            out = dst "/" art_file(FILENAME, ".md")
             count = 0
             fm = 0
             effort_seen = 0
@@ -163,8 +140,8 @@ sync_claude_agents() {
     ' "${files[@]}"
     # awk never reads a record from an empty source; the old per-file shell
     # redirect still created an empty output for it.
-    for f in "${files[@]}"; do
-        [ -s "$f" ] || : > "$output_dir/agents/${f##*/}"
+    for ((i = 0; i < ${#files[@]}; i++)); do
+        [ -s "${files[i]}" ] || : > "$output_dir/agents/${names[i]}.md"
     done
     printf '%s' "$report"
 }
diff --git a/engine/adapters/codex.sh b/engine/adapters/codex.sh
index 5873094..af6ed55 100644
--- a/engine/adapters/codex.sh
+++ b/engine/adapters/codex.sh
@@ -83,19 +83,13 @@ sync_codex_agents() {
     local config_file="$2"
     local output_dir="$3"
 
-    local src f
-    local -a files=()
-    load_yaml_list "$config_file" "agents"
-    local list="$IS_YAML_LIST"
-    while IFS= read -r src; do
-        [ -z "$src" ] && continue
-        local dir="$repo_root/$src"
-        [ -d "$dir" ] || continue
-        for f in "$dir"/*.md; do
-            [ -f "$f" ] || continue
-            files+=("$f")
-        done
-    done <<< "$list"
+    local -a files=() names=()
+    output_rel_var "$repo_root" "$output_dir"
+    source_artifacts_var "$repo_root" "$config_file" agents codex "$IS_OUTPUT_REL/{}.toml"
+    if [ "${#IS_SOURCE_FILES[@]}" -gt 0 ]; then
+        files=("${IS_SOURCE_FILES[@]}")
+        names=("${IS_SOURCE_NAMES[@]}")
+    fi
 
     local count=0
     if [ "${#files[@]}" -gt 0 ]; then
@@ -103,8 +97,7 @@ sync_codex_agents() {
 
         local path tier access description effort name sandbox spec="" report="" LS=$'\x1e'
         while IFS=$'\x1f' read -r path tier access description effort; do
-            [ -n "$path" ] || continue
-            name="${path##*/}"; name="${name%.md}"
+            name="${names[count]}"
             resolve_model_var "$tier"
             map_effort_var codex "$effort"
             case "$access" in
diff --git a/engine/adapters/copilot.sh b/engine/adapters/copilot.sh
index f513fec..1c41fc3 100644
--- a/engine/adapters/copilot.sh
+++ b/engine/adapters/copilot.sh
@@ -112,35 +112,22 @@ sync_copilot_rules() {
 
     local scoped_count=0
 
-    local src f
-    local -a files=()
-    load_yaml_list "$config_file" "rules"
-    local list="$IS_YAML_LIST"
-    while IFS= read -r src; do
-        [ -z "$src" ] && continue
-        local dir="$repo_root/$src"
-        [ -d "$dir" ] || continue
-        for f in "$dir"/*.md; do
-            [ -f "$f" ] || continue
-            files+=("$f")
-        done
-    done <<< "$list"
-
-    local -a scoped=()
-    if [ "${#files[@]}" -gt 0 ]; then
-        local path hp
-        while IFS=$'\x1f' read -r path hp; do
-            [ -n "$path" ] || continue
-            [ "$hp" -eq 0 ] && continue
-            scoped+=("$path")
-        done < <(frontmatter_index "paths#" "${files[@]}")
-    fi
+    local i
+    local -a scoped=() scoped_names=()
+    output_rel_var "$repo_root" "$instructions_dir"
+    source_artifacts_var "$repo_root" "$config_file" rules copilot "$IS_OUTPUT_REL/{}.instructions.md"
+    for ((i = 0; i < ${#IS_SOURCE_FILES[@]}; i++)); do
+        [ "${IS_SOURCE_SCOPED[i]}" = 1 ] || continue
+        scoped+=("${IS_SOURCE_FILES[i]}")
+        scoped_names+=("${IS_SOURCE_NAMES[i]}")
+    done
 
     if [ "${#scoped[@]}" -gt 0 ]; then
-        local base paths_line spec="" report="" LS=$'\x1e'
+        local path base paths_line spec="" report="" LS=$'\x1e'
+        i=0
         while IFS=$'\x1f' read -r path paths_line; do
-            [ -n "$path" ] || continue
-            base="${path##*/}"; base="${base%.md}"
+            base="${scoped_names[i]}"
+            i=$((i + 1))
 
             local header
             header="${LS}---"
@@ -166,33 +153,23 @@ sync_copilot_skills() {
     local config_file="$2"
     local output_dir="$3"
 
-    local src d skill_name
+    local i name
     local -a skill_dirs=()
-    # The inventory decides which skills render, symlinked ones included
-    # (decision 0017); the glob keeps this adapter's own listing order.
-    skill_source_inventory "$repo_root" "$config_file"
-    load_yaml_list "$config_file" "skills"
-    local list="$IS_YAML_LIST"
-    while IFS= read -r src; do
-        [ -z "$src" ] && continue
-        local dir="$repo_root/$src"
-        [ -d "$dir" ] || continue
-        for d in "$dir"/*/; do
-            [ -d "$d" ] || continue
-            [ -f "$d/SKILL.md" ] || continue
-            skill_source_rendered "$d" || continue
-            skill_dirs+=("$d")
-        done
-    done <<< "$list"
+    # The catalog's skills are the ones the inventory renders, symlinked ones
+    # included (decision 0017).
+    output_rel_var "$repo_root" "$output_dir"
+    source_artifacts_var "$repo_root" "$config_file" skills copilot "$IS_OUTPUT_REL/skills/{}"
+    for ((i = 0; i < ${#IS_SOURCE_FILES[@]}; i++)); do
+        skill_dirs+=("${IS_SOURCE_FILES[i]%/SKILL.md}/")
+    done
 
     local count=0
     if [ "${#skill_dirs[@]}" -gt 0 ]; then
         # Copilot has no effort field: the copy carries no `effort:`.
-        copy_skill_bundle_dirs_for copilot "$output_dir/skills" "${skill_dirs[@]}"
-        for d in "${skill_dirs[@]}"; do
-            skill_name="${d%/}"
+        copy_skill_bundle_dirs_named copilot "$output_dir/skills" "$IS_SOURCE_NAME_MAP" "${skill_dirs[@]}"
+        for name in "${IS_SOURCE_NAMES[@]}"; do
             count=$((count + 1))
-            echo "  skill: ${skill_name##*/}"
+            echo "  skill: $name"
         done
     fi
 
@@ -205,19 +182,13 @@ sync_copilot_agents() {
     local config_file="$2"
     local output_dir="$3"
 
-    local src f
-    local -a files=()
-    load_yaml_list "$config_file" "agents"
-    local list="$IS_YAML_LIST"
-    while IFS= read -r src; do
-        [ -z "$src" ] && continue
-        local dir="$repo_root/$src"
-        [ -d "$dir" ] || continue
-        for f in "$dir"/*.md; do
-            [ -f "$f" ] || continue
-            files+=("$f")
-        done
-    done <<< "$list"
+    local -a files=() names=()
+    output_rel_var "$repo_root" "$output_dir"
+    source_artifacts_var "$repo_root" "$config_file" agents copilot "$IS_OUTPUT_REL/agents/{}.agent.md"
+    if [ "${#IS_SOURCE_FILES[@]}" -gt 0 ]; then
+        files=("${IS_SOURCE_FILES[@]}")
+        names=("${IS_SOURCE_NAMES[@]}")
+    fi
 
     local count=0
     if [ "${#files[@]}" -gt 0 ]; then
@@ -225,8 +196,7 @@ sync_copilot_agents() {
 
         local path tier access description name tools_line spec="" report="" LS=$'\x1e'
         while IFS=$'\x1f' read -r path tier access description; do
-            [ -n "$path" ] || continue
-            name="${path##*/}"; name="${name%.md}"
+            name="${names[count]}"
             resolve_model_var "$tier"
 
             # Build tools list based on access. Tool aliases per Copilot custom-agent
diff --git a/engine/adapters/cursor.sh b/engine/adapters/cursor.sh
index 0f1ddc0..1165443 100644
--- a/engine/adapters/cursor.sh
+++ b/engine/adapters/cursor.sh
@@ -41,29 +41,16 @@ sync_cursor_rules() {
     local config_file="$2"
     local output_dir="$3"
 
-    local src f
-    local -a files=()
-    load_yaml_list "$config_file" "rules"
-    local list="$IS_YAML_LIST"
-    while IFS= read -r src; do
-        [ -z "$src" ] && continue
-        local dir="$repo_root/$src"
-        [ -d "$dir" ] || continue
-        for f in "$dir"/*.md; do
-            [ -f "$f" ] || continue
-            files+=("$f")
-        done
-    done <<< "$list"
-    [ "${#files[@]}" -gt 0 ] || return 0
-
+    local i
+    local -a scoped=() scoped_names=()
+    output_rel_var "$repo_root" "$output_dir"
+    source_artifacts_var "$repo_root" "$config_file" rules cursor "$IS_OUTPUT_REL/rules/{}.mdc"
     # Skip always-on rules: AGENTS.md (canonical) carries them.
-    local path hp base
-    local -a scoped=()
-    while IFS=$'\x1f' read -r path hp; do
-        [ -n "$path" ] || continue
-        [ "$hp" -eq 0 ] && continue
-        scoped+=("$path")
-    done < <(frontmatter_index "paths#" "${files[@]}")
+    for ((i = 0; i < ${#IS_SOURCE_FILES[@]}; i++)); do
+        [ "${IS_SOURCE_SCOPED[i]}" = 1 ] || continue
+        scoped+=("${IS_SOURCE_FILES[i]}")
+        scoped_names+=("${IS_SOURCE_NAMES[i]}")
+    done
     [ "${#scoped[@]}" -gt 0 ] || return 0
 
     # Path-scoped rule -> Auto Attached (paths -> globs). The rewrite is
@@ -71,12 +58,10 @@ sync_cursor_rules() {
     # with `paths:` (a rule documenting rule syntax does exactly that), and
     # rewriting it would corrupt the text it teaches.
     is_fin_awk_vars
-    awk "${IS_FIN_V[@]}" -v dst="$output_dir/rules" "$IS_AWK_LIB"'
+    IS_NAME_MAP="$IS_SOURCE_NAME_MAP" awk "${IS_FIN_V[@]}" -v dst="$output_dir/rules" "$IS_AWK_LIB"'
         FNR == 1 {
             if (out != "") close(out)
-            nm = base_name(FILENAME)
-            sub(/\.md$/, ".mdc", nm)
-            out = dst "/" nm
+            out = dst "/" art_name(FILENAME) ".mdc"
             fm = 0
         }
         { sub(/\r$/, "") }
@@ -90,9 +75,8 @@ sync_cursor_rules() {
         fm == 1 { sub(/^paths:/, "globs:") }
         { print fin_line($0) > out }
     ' "${scoped[@]}"
-    for f in "${scoped[@]}"; do
-        base="${f##*/}"; base="${base%.md}"
-        echo "  rule: $base.mdc (scoped)"
+    for ((i = 0; i < ${#scoped_names[@]}; i++)); do
+        echo "  rule: ${scoped_names[i]}.mdc (scoped)"
     done
 }
 
@@ -102,29 +86,19 @@ sync_cursor_skills() {
     local config_file="$2"
     local output_dir="$3"
 
-    local src d skill_name
+    local i name
     local -a skill_dirs=()
-    # The inventory decides which skills render, symlinked ones included
-    # (decision 0017); the glob keeps this adapter's own listing order.
-    skill_source_inventory "$repo_root" "$config_file"
-    load_yaml_list "$config_file" "skills"
-    local list="$IS_YAML_LIST"
-    while IFS= read -r src; do
-        [ -z "$src" ] && continue
-        local dir="$repo_root/$src"
-        [ -d "$dir" ] || continue
-        for d in "$dir"/*/; do
-            [ -d "$d" ] || continue
-            [ -f "$d/SKILL.md" ] || continue
-            skill_source_rendered "$d" || continue
-            skill_dirs+=("$d")
-        done
-    done <<< "$list"
-    [ "${#skill_dirs[@]}" -gt 0 ] || return 0
-    copy_skill_bundle_dirs_for cursor "$output_dir/skills" "${skill_dirs[@]}"
-    for d in "${skill_dirs[@]}"; do
-        skill_name="${d%/}"
-        echo "  skill: ${skill_name##*/}"
+    # The catalog's skills are the ones the inventory renders, symlinked ones
+    # included (decision 0017).
+    output_rel_var "$repo_root" "$output_dir"
+    source_artifacts_var "$repo_root" "$config_file" skills cursor "$IS_OUTPUT_REL/skills/{}"
+    [ "${#IS_SOURCE_FILES[@]}" -gt 0 ] || return 0
+    for ((i = 0; i < ${#IS_SOURCE_FILES[@]}; i++)); do
+        skill_dirs+=("${IS_SOURCE_FILES[i]%/SKILL.md}/")
+    done
+    copy_skill_bundle_dirs_named cursor "$output_dir/skills" "$IS_SOURCE_NAME_MAP" "${skill_dirs[@]}"
+    for name in "${IS_SOURCE_NAMES[@]}"; do
+        echo "  skill: $name"
     done
 }
 
@@ -134,37 +108,32 @@ sync_cursor_agents() {
     local config_file="$2"
     local output_dir="$3"
 
-    local src f
-    local -a files=()
-    load_yaml_list "$config_file" "agents"
-    local list="$IS_YAML_LIST"
-    while IFS= read -r src; do
-        [ -z "$src" ] && continue
-        local dir="$repo_root/$src"
-        [ -d "$dir" ] || continue
-        for f in "$dir"/*.md; do
-            [ -f "$f" ] || continue
-            files+=("$f")
-        done
-    done <<< "$list"
-    [ "${#files[@]}" -gt 0 ] || return 0
+    local i
+    local -a files=() names=()
+    output_rel_var "$repo_root" "$output_dir"
+    source_artifacts_var "$repo_root" "$config_file" agents cursor "$IS_OUTPUT_REL/agents/{}.md"
+    [ "${#IS_SOURCE_FILES[@]}" -gt 0 ] || return 0
+    files=("${IS_SOURCE_FILES[@]}")
+    names=("${IS_SOURCE_NAMES[@]}")
+    local name_map="$IS_SOURCE_NAME_MAP"
 
     load_model_tiers "$config_file" "cursor"
 
     local path tier access spec="" report="" cursor_readonly
+    i=0
     while IFS=$'\x1f' read -r path tier access; do
-        [ -n "$path" ] || continue
         resolve_model_var "$tier"
         cursor_readonly=""
         [ "$access" = "readonly" ] && cursor_readonly="readonly: true"
         spec+="$path"$'\x1f'"$IS_MODEL"$'\x1f'"$cursor_readonly"$'\n'
-        report+="  agent: ${path##*/} (tier=$tier -> cursor)"$'\n'
+        report+="  agent: ${names[i]}.md (tier=$tier -> cursor)"$'\n'
+        i=$((i + 1))
     done < <(frontmatter_index "tier,access" "${files[@]}")
 
     # Always emit model: line (even when value matches Cursor's default)
     # so config is explicit and grep-able.
     is_fin_awk_vars
-    IS_MAP_SPEC="$spec" awk "${IS_FIN_V[@]}" -v dst="$output_dir/agents" "$IS_AWK_LIB"'
+    IS_NAME_MAP="$name_map" IS_MAP_SPEC="$spec" awk "${IS_FIN_V[@]}" -v dst="$output_dir/agents" "$IS_AWK_LIB"'
         BEGIN {
             US = sprintf("%c", 31)
             n = split(ENVIRON["IS_MAP_SPEC"], recs, "\n")
@@ -176,7 +145,7 @@ sync_cursor_agents() {
         }
         FNR == 1 {
             if (out != "") close(out)
-            out = dst "/" base_name(FILENAME)
+            out = dst "/" art_file(FILENAME, ".md")
             count = 0
             fm = 0
         }
@@ -194,8 +163,8 @@ sync_cursor_agents() {
         }
         { print fin_line($0) > out }
     ' "${files[@]}"
-    for f in "${files[@]}"; do
-        [ -s "$f" ] || : > "$output_dir/agents/${f##*/}"
+    for ((i = 0; i < ${#files[@]}; i++)); do
+        [ -s "${files[i]}" ] || : > "$output_dir/agents/${names[i]}.md"
     done
     printf '%s' "$report"
 }
diff --git a/engine/adapters/opencode.sh b/engine/adapters/opencode.sh
index 9c6df39..5103ded 100644
--- a/engine/adapters/opencode.sh
+++ b/engine/adapters/opencode.sh
@@ -88,32 +88,24 @@ sync_opencode_commands() {
         [ "${#generated[@]}" -gt 0 ] && rm -f "${generated[@]}"
     fi
 
-    local src d skill_name
-    local -a skill_mds=()
-    # The inventory decides which skills render, symlinked ones included
-    # (decision 0017); the glob keeps this adapter's own listing order.
-    skill_source_inventory "$repo_root" "$config_file"
-    load_yaml_list "$config_file" "skills"
-    local list="$IS_YAML_LIST"
-    while IFS= read -r src; do
-        [ -z "$src" ] && continue
-        local dir="$repo_root/$src"
-        [ -d "$dir" ] || continue
-        for d in "$dir"/*/; do
-            [ -d "$d" ] || continue
-            [ -f "$d/SKILL.md" ] || continue
-            skill_source_rendered "$d" || continue
-            skill_mds+=("${d%/}/SKILL.md")
-        done
-    done <<< "$list"
+    local skill_name
+    local -a skill_mds=() names=()
+    # The catalog's skills are the ones the inventory renders, symlinked ones
+    # included (decision 0017). The commands directory is tracked, so a local
+    # skill gets no command.
+    output_rel_var "$repo_root" "$commands_dir"
+    source_artifacts_var "$repo_root" "$config_file" skills opencode "$IS_OUTPUT_REL/{}.md"
+    if [ "${#IS_SOURCE_FILES[@]}" -gt 0 ]; then
+        skill_mds=("${IS_SOURCE_FILES[@]}")
+        names=("${IS_SOURCE_NAMES[@]}")
+    fi
 
     local count=0
     if [ "${#skill_mds[@]}" -gt 0 ]; then
         local path description argument_hint out_file
         local -a out_files=()
         while IFS=$'\x1f' read -r path description argument_hint; do
-            [ -n "$path" ] || continue
-            skill_name="${path%/SKILL.md}"; skill_name="${skill_name##*/}"
+            skill_name="${names[count]}"
             out_file="$commands_dir/$skill_name.md"
             yaml_dq_escape_var "$description"
             {
@@ -151,19 +143,13 @@ sync_opencode_agents() {
     local agents_dir="$output_dir/agents"
     mkdir -p "$agents_dir"
 
-    local src f
-    local -a files=()
-    load_yaml_list "$config_file" "agents"
-    local list="$IS_YAML_LIST"
-    while IFS= read -r src; do
-        [ -z "$src" ] && continue
-        local dir="$repo_root/$src"
-        [ -d "$dir" ] || continue
-        for f in "$dir"/*.md; do
-            [ -f "$f" ] || continue
-            files+=("$f")
-        done
-    done <<< "$list"
+    local -a files=() names=()
+    output_rel_var "$repo_root" "$agents_dir"
+    source_artifacts_var "$repo_root" "$config_file" agents opencode "$IS_OUTPUT_REL/{}.md"
+    if [ "${#IS_SOURCE_FILES[@]}" -gt 0 ]; then
+        files=("${IS_SOURCE_FILES[@]}")
+        names=("${IS_SOURCE_NAMES[@]}")
+    fi
 
     local count=0
     if [ "${#files[@]}" -gt 0 ]; then
@@ -171,8 +157,7 @@ sync_opencode_agents() {
 
         local path tier access description name edit_perm bash_perm spec="" report="" LS=$'\x1e'
         while IFS=$'\x1f' read -r path tier access description; do
-            [ -n "$path" ] || continue
-            name="${path##*/}"; name="${name%.md}"
+            name="${names[count]}"
             resolve_model_var "$tier"
 
             # Map source `access:` to opencode permission keys.
diff --git a/engine/adapters/pi.sh b/engine/adapters/pi.sh
index c27fe83..7704ec5 100644
--- a/engine/adapters/pi.sh
+++ b/engine/adapters/pi.sh
@@ -98,38 +98,28 @@ sync_pi_rules() {
 
     mkdir -p "$rules_root" "$(dirname "$extension_file")"
 
-    local src f
-    local -a files=()
-    load_yaml_list "$config_file" "rules"
-    local list="$IS_YAML_LIST"
-    while IFS= read -r src; do
-        [ -z "$src" ] && continue
-        local dir="$repo_root/$src"
-        [ -d "$dir" ] || continue
-        for f in "$dir"/*.md; do
-            [ -f "$f" ] || continue
-            files+=("$f")
-        done
-    done <<< "$list"
-
-    local -a scoped=()
-    if [ "${#files[@]}" -gt 0 ]; then
-        local path hp
-        while IFS=$'\x1f' read -r path hp; do
-            [ -n "$path" ] || continue
-            [ "$hp" -eq 0 ] && continue
-            scoped+=("$path")
-        done < <(frontmatter_index "paths#" "${files[@]}")
-    fi
+    local -a scoped=() scoped_names=()
+    local k=0
+    output_rel_var "$repo_root" "$rules_root"
+    source_artifacts_var "$repo_root" "$config_file" rules pi "$IS_OUTPUT_REL/{}.md"
+    while [ "$k" -lt "${#IS_SOURCE_FILES[@]}" ]; do
+        if [ "${IS_SOURCE_SCOPED[k]}" = 1 ]; then
+            scoped+=("${IS_SOURCE_FILES[k]}")
+            scoped_names+=("${IS_SOURCE_NAMES[k]}")
+        fi
+        k=$((k + 1))
+    done
 
     if [ "${#scoped[@]}" -gt 0 ]; then
-        finalize_copy_files "$rules_root" "${scoped[@]}"
+        finalize_copy_named "$rules_root" "$IS_SOURCE_NAME_MAP" "${scoped[@]}"
 
         local -a row_arr
         local base rel_rule_path patterns_js display sep display_sep pat i
+        k=0
         while IFS=$'\x1f' read -r -a row_arr; do
             [ "${#row_arr[@]}" -gt 0 ] || continue
-            base="${row_arr[0]##*/}"
+            base="${scoped_names[k]}.md"
+            k=$((k + 1))
             rel_rule_path="$output_rel/intelligence-sync/rules/$base"
             patterns_js=""
             display=""
@@ -223,25 +213,18 @@ sync_pi_agents() {
 
     mkdir -p "$prompts_dir"
 
-    local src f
-    local -a files=()
-    load_yaml_list "$config_file" "agents"
-    local list="$IS_YAML_LIST"
-    while IFS= read -r src; do
-        [ -z "$src" ] && continue
-        local dir="$repo_root/$src"
-        [ -d "$dir" ] || continue
-        for f in "$dir"/*.md; do
-            [ -f "$f" ] || continue
-            files+=("$f")
-        done
-    done <<< "$list"
+    local -a files=() names=()
+    output_rel_var "$repo_root" "$prompts_dir"
+    source_artifacts_var "$repo_root" "$config_file" agents pi "$IS_OUTPUT_REL/intelligence-agent-{}.md"
+    if [ "${#IS_SOURCE_FILES[@]}" -gt 0 ]; then
+        files=("${IS_SOURCE_FILES[@]}")
+        names=("${IS_SOURCE_NAMES[@]}")
+    fi
 
     if [ "${#files[@]}" -gt 0 ]; then
         local path desc access name template_desc spec="" report="" LS=$'\x1e'
         while IFS=$'\x1f' read -r path desc access; do
-            [ -n "$path" ] || continue
-            name="${path##*/}"; name="${name%.md}"
+            name="${names[count]}"
             repo_rel_link_var "$repo_root" "$path"
 
             template_desc="Use $name persona"
diff --git a/engine/lib/common.sh b/engine/lib/common.sh
index 04e67f1..57649d3 100644
--- a/engine/lib/common.sh
+++ b/engine/lib/common.sh
@@ -71,6 +71,24 @@ IS_AWK_LIB='
         return val
     }
     function base_name(p,   q, m) { m = split(p, q, "/"); return q[m] }
+    # The name a source renders under (decision 0021) comes from the source
+    # catalog, which hands a batch its `<path> US <name>` lines through
+    # ENVIRON["IS_NAME_MAP"]. A path the map does not hold keeps its own name.
+    BEGIN {
+        is_nm_n = split(ENVIRON["IS_NAME_MAP"], is_nm_rows, "\n")
+        for (is_nm_i = 1; is_nm_i <= is_nm_n; is_nm_i++) {
+            is_nm_p = index(is_nm_rows[is_nm_i], sprintf("%c", 31))
+            if (is_nm_p > 0) ART_NAME[substr(is_nm_rows[is_nm_i], 1, is_nm_p - 1)] = substr(is_nm_rows[is_nm_i], is_nm_p + 1)
+        }
+    }
+    # art_file(path, ext) — the output file name: the catalog name plus <ext>,
+    # or the source file name itself.
+    function art_file(p, ext) { return (p in ART_NAME) ? ART_NAME[p] ext : base_name(p) }
+    # art_name(path) — the catalog name, or the file name without `.md`.
+    function art_name(p,   b) {
+        if (p in ART_NAME) return ART_NAME[p]
+        b = base_name(p); sub(/\.md$/, "", b); return b
+    }
 '
 
 # is_fin_awk_vars — fill the global IS_FIN_V array with the -v bindings the
@@ -119,23 +137,51 @@ finalize_output_file() {
 finalize_copy_files() {
     local dst="$1"
     shift
+    finalize_copy_named "$dst" "" "$@"
+}
+
+# finalize_copy_named <dst_dir> <name-map> <src>... — finalize_copy_files with
+# each source written as <dst_dir>/<name>.md when <name-map> holds it: the
+# rendered names source_artifacts_var leaves in IS_SOURCE_NAME_MAP, so
+# `.draft.md` and `me.local.md` land as `draft.md` and `me.md`.
+finalize_copy_named() {
+    local dst="$1" map="$2" f
+    shift 2
     [ "$#" -gt 0 ] || return 0
-    local f
     # awk never reads a record from an empty source, so pre-create those to
     # keep the old cp behavior of producing an empty output file.
     for f in "$@"; do
-        [ -s "$f" ] || : > "$dst/${f##*/}"
+        [ -s "$f" ] && continue
+        if source_name_map_var "$map" "$f"; then
+            : > "$dst/$IS_MAPPED_NAME.md"
+        else
+            : > "$dst/${f##*/}"
+        fi
     done
     is_fin_awk_vars
-    awk "${IS_FIN_V[@]}" -v dst="$dst" "$IS_AWK_LIB"'
+    IS_NAME_MAP="$map" awk "${IS_FIN_V[@]}" -v dst="$dst" "$IS_AWK_LIB"'
         FNR == 1 {
             if (out_file != "") close(out_file)
-            out_file = dst "/" base_name(FILENAME)
+            out_file = dst "/" art_file(FILENAME, ".md")
         }
         { sub(/\r$/, ""); print fin_line($0) > out_file }
     ' "$@"
 }
 
+# source_name_map_var <name-map> <path> — set IS_MAPPED_NAME to the name the
+# map gives <path>; return 1 when it gives none. A map is "\n" followed by one
+# `<path> US <name>` line per source.
+source_name_map_var() {
+    local rest
+    IS_MAPPED_NAME=""
+    case "$1" in
+        *$'\n'"$2"$'\x1f'*) ;;
+        *) return 1 ;;
+    esac
+    rest="${1#*$'\n'"$2"$'\x1f'}"
+    IS_MAPPED_NAME="${rest%%$'\n'*}"
+}
+
 # frontmatter_index <keys-csv> <file>...
 # One awk pass over many files; prints one row per file, in argument order:
 # the path, then one value per requested key, all separated by \x1f (ASCII
@@ -492,32 +538,59 @@ copy_skill_bundle_dirs() {
 copy_skill_bundle_dirs_for() {
     local effort_tool="$1" dest_root="$2"
     shift 2
+    copy_skill_bundle_dirs_named "$effort_tool" "$dest_root" "" "$@"
+}
+
+# copy_skill_bundle_dirs_named <tool> <dest_root> <name-map> <src_dir>... — the
+# batch form with each skill copied to <dest_root>/<name> when <name-map> holds
+# its directory: the rendered names source_artifacts_var leaves in
+# IS_SOURCE_NAME_MAP, so `deploy.local/` lands as `deploy/` and still matches
+# its own `name: deploy`. Only a skill whose name differs from its directory
+# costs a copy of its own.
+copy_skill_bundle_dirs_named() {
+    local effort_tool="$1" dest_root="$2" map="$3"
+    shift 3
     [ "$#" -gt 0 ] || return 0
-    local src dest linked=0
-    local -a srcs=()
+    local src from name dest i linked=0 renamed=0
+    local -a srcs=() names=()
     for src in "$@"; do
         src="${src%/}"
         srcs+=("$src")
+        name="${src##*/}"
+        if source_name_map_var "$map" "$src" && [ "$IS_MAPPED_NAME" != "$name" ]; then
+            name="$IS_MAPPED_NAME"
+            renamed=1
+        fi
+        names+=("$name")
         ! _ski_planned "$src" || linked=1
     done
     mkdir -p "$dest_root"
-    if [ "$linked" = 0 ]; then
+    if [ "$linked" = 0 ] && [ "$renamed" = 0 ]; then
         cp -R "${srcs[@]}" "$dest_root/"
     else
-        for src in "${srcs[@]}"; do
+        for ((i = 0; i < ${#srcs[@]}; i++)); do
+            src="${srcs[i]}"
+            from="$src"
             if _ski_planned "$src"; then
                 _skill_bundle_materialize "$src" || return 1
-                cp -R "$IS_SKI_STAGED" "$dest_root/" || return 1
-                rm -rf "${IS_SKI_STAGED%/*}"
+                from="$IS_SKI_STAGED"
+            fi
+            dest="$dest_root/${names[i]}"
+            if [ "${names[i]}" = "${src##*/}" ]; then
+                cp -R "$from" "$dest_root/" || return 1
+            elif [ -e "$dest" ]; then
+                # A second skill of one name merges file by file, as the
+                # batch copy of same-named directories does.
+                cp -R "$from/." "$dest/" || return 1
             else
-                cp -R "$src" "$dest_root/" || return 1
+                cp -R "$from" "$dest" || return 1
             fi
+            [ "$from" = "$src" ] || rm -rf "${IS_SKI_STAGED%/*}"
         done
     fi
     _skill_bundles_reset
-    for src in "${srcs[@]}"; do
-        dest="$dest_root/${src##*/}"
-        _skill_bundle_note "$dest"
+    for name in "${names[@]}"; do
+        _skill_bundle_note "$dest_root/$name"
     done
     _skill_bundles_flush "$effort_tool"
 }
@@ -742,26 +815,27 @@ sync_open_skill_dirs() {
     fi
     mkdir -p "$output_dir"
 
-    local count=0 log="" d skill_file skill_name
+    local count=0 log="" i rel
     local -a skill_dirs=()
-    read_source_artifact_files "$repo_root" "$config_file" "skills"
+    # Every tool that reads this directory reads all of it, so a skill lands
+    # here when it is for any of them (decision 0021). The engine names the
+    # enabled readers from their contracts.
+    normalize_path_var "$output_dir"
+    rel="${IS_NORM_PATH#"$repo_root"/}"
+    source_artifacts_var "$repo_root" "$config_file" skills \
+        "${IS_OPEN_SKILLS_READERS-antigravity codex opencode pi}" "$rel/{}"
     # Guard on the count, then expand quoted: Bash 3.2 (macOS) errors on an
     # empty array under `set -u`, and quoting keeps a path with a space or a
     # glob character intact.
-    if [ "${#IS_SOURCE_FILES[@]}" -gt 0 ]; then
-        for skill_file in "${IS_SOURCE_FILES[@]}"; do
-            [ -n "$skill_file" ] || continue
-            d="${skill_file%/SKILL.md}"
-            skill_name="${d##*/}"
-            skill_dirs+=("$d/")
-            count=$((count + 1))
-            log+="  skill: $skill_name"$'\n'
-        done
-    fi
+    for ((i = 0; i < ${#IS_SOURCE_FILES[@]}; i++)); do
+        skill_dirs+=("${IS_SOURCE_FILES[i]%/SKILL.md}/")
+        count=$((count + 1))
+        log+="  skill: ${IS_SOURCE_NAMES[i]}"$'\n'
+    done
     # copy_skill_bundle_dirs owns the frontmatter-quoting pass, so every
     # target gets it — not just this open-standard dir.
     if [ "$count" -gt 0 ]; then
-        copy_skill_bundle_dirs_for open "$output_dir" "${skill_dirs[@]}"
+        copy_skill_bundle_dirs_named open "$output_dir" "$IS_SOURCE_NAME_MAP" "${skill_dirs[@]}"
         open_skill_invocation_policies "$output_dir" || return 1
     fi
 
@@ -935,7 +1009,13 @@ enforce_authored_invocation_policies() {
 # Usage: lint_frontmatter_files "a.md" "b.md" ...
 lint_frontmatter_files() {
     [ "$#" -gt 0 ] || return 0
-    awk -v levels="$IS_EFFORT_LEVELS" "$IS_AWK_LIB"'
+    awk -v levels="$IS_EFFORT_LEVELS" "$IS_AWK_LIB$_IS_AWK_LINT" "$@"
+}
+
+# The lint rules, shared with source_frontmatter_scan, which runs them in the
+# same pass that reads routing fields. Every rule may end with `next`, so a
+# program that joins them puts its own rules first.
+_IS_AWK_LINT='
         BEGIN {
             nl = split(levels, LV, " ")
             allowed = ""
@@ -990,8 +1070,7 @@ lint_frontmatter_files() {
                 printf "WARNING: %s:%d %s is %d chars — over the %d-char limit; the skill/agent will be REJECTED at load time\n", FILENAME, FNR, key, length(val), limit > "/dev/stderr"
             }
         }
-    ' "$@"
-}
+'
 
 # lint_frontmatter <file> — single-file form for project adapters.
 lint_frontmatter() {
@@ -2149,9 +2228,11 @@ read_source_artifact_files() {
         [ -d "$dir" ] || continue
         # Command substitution, so the pipeline's status is the assignment's:
         # `find` or `sort` failing aborts here instead of yielding a short list.
+        # A link to a regular file is one too, read where it points, as the
+        # adapters' globs always read it; a dangling one is no artifact.
         case "$section" in
             rules|agents)
-                listing="$(find "$dir" -maxdepth 1 -type f -name '*.md' -print | LC_ALL=C sort)" || {
+                listing="$(find "$dir" -maxdepth 1 -name '*.md' \( -type f -o -type l \) -print | LC_ALL=C sort)" || {
                     echo "ERROR: cannot enumerate $section under '$dir' — refusing to render a partial list." >&2
                     exit 1
                 }
@@ -2162,7 +2243,7 @@ read_source_artifact_files() {
         # A here-string redirect keeps this loop in the current shell, so the
         # array it fills survives and any failure inside it is this shell's.
         while IFS= read -r f; do
-            [ -n "$f" ] || continue
+            [ -f "$f" ] || continue
             IS_SOURCE_FILES+=("$f")
             joined="$joined$f"$'\n'
         done <<< "$listing"
@@ -2173,6 +2254,289 @@ read_source_artifact_files() {
     fi
 }
 
+# --- The source catalog (decision 0021) --------------------------------------
+#
+# Every renderer — AGENTS.md, every built-in adapter, the adapter template —
+# reads sources through source_artifacts_var, so one place decides what an
+# artifact is called, which artifact of a name renders, and where it may go:
+#
+#   name      the entry without a leading `.`, `.md` and a trailing `.local`:
+#             `.environment.local.md` is the rule `environment`, `.draft.md`
+#             the rule `draft`, the skill directory `deploy.local/` the skill
+#             `deploy`. A leading dot means nothing.
+#   local     a rule or agent named `*.local.md`, a skill directory named
+#             `*.local` — exactly the patterns `init` writes to .gitignore, so
+#             Git and the engine never disagree. A local artifact never renders
+#             into an output Git tracks (`committed`).
+#   override  across sources the later artifact of a name renders. Two of one
+#             name in one directory, or a local and a non-local one anywhere,
+#             refuse the sync: either would change what committed output holds
+#             depending on which file a clone has.
+#
+# source_catalog_build fills, in the caller's shell and fail-closed like the
+# listing it reads, one row per source entry in listing order:
+#   IS_CAT_SEC IS_CAT_PATH IS_CAT_NAME IS_CAT_LOCAL IS_CAT_WIN IS_CAT_SCOPED
+# (section; the file, or a skill's SKILL.md; the rendered name; 1 when local;
+# 1 when no later source overrides it; 1 for a rule with `paths:`), IS_CAT_N,
+# and IS_CAT_NEED_COMMITTED, 1 when rendering has to know which outputs Git
+# tracks. With IS_SOURCE_FILES_MEMO=1 a second call replays the first.
+
+# source_artifact_name_var <section> <entry> — IS_ART_NAME and IS_ART_LOCAL for
+# one file (rules, agents) or skill directory (skills) name.
+source_artifact_name_var() {
+    local n="$2"
+    IS_ART_LOCAL=0
+    case "$1:$n" in
+        skills:*.local|rules:*.local.md|agents:*.local.md) IS_ART_LOCAL=1 ;;
+    esac
+    n="${n#.}"
+    [ "$1" = skills ] || n="${n%.md}"
+    case "$n" in *.local) n="${n%.local}" ;; esac
+    IS_ART_NAME="$n"
+}
+
+# shellcheck disable=SC2034  # IS_CAT_NEED_COMMITTED is read by engine/sync.sh
+source_catalog_build() {
+    local repo_root="$1" config_file="$2" lint="${3:-}" key section f entry dir name
+    local seen=$'\n' errors="" i n=0 prev rest rows path scoped kind
+    local -a files=()
+    key="$repo_root"$'\n'"$config_file"
+    if [ "${IS_SOURCE_FILES_MEMO:-0}" = 1 ] && [ "${IS_CAT_KEY:-}" = "$key" ]; then
+        return 0
+    fi
+    IS_CAT_KEY=""
+    IS_CAT_SEC=(); IS_CAT_PATH=(); IS_CAT_NAME=(); IS_CAT_LOCAL=()
+    IS_CAT_WIN=(); IS_CAT_SCOPED=()
+    IS_CAT_NEED_COMMITTED=0
+    for section in rules agents skills; do
+        read_source_artifact_files "$repo_root" "$config_file" "$section"
+        for f in "${IS_SOURCE_FILES[@]+"${IS_SOURCE_FILES[@]}"}"; do
+            if [ "$section" = skills ]; then
+                dir="${f%/SKILL.md}"
+                entry="${dir##*/}"
+                dir="${dir%/*}"
+                kind="skill"
+            else
+                entry="${f##*/}"
+                dir="${f%/*}"
+                kind="${section%s}"
+            fi
+            source_artifact_name_var "$section" "$entry"
+            name="$IS_ART_NAME"
+            IS_CAT_SEC[n]="$section"
+            IS_CAT_PATH[n]="$f"
+            IS_CAT_NAME[n]="$name"
+            IS_CAT_LOCAL[n]="$IS_ART_LOCAL"
+            IS_CAT_WIN[n]=1
+            IS_CAT_SCOPED[n]=0
+            [ "$IS_ART_LOCAL" = 0 ] || IS_CAT_NEED_COMMITTED=1
+            case "$seen" in
+                *$'\n'"$section/$name"$'\t'*)
+                    rest="${seen##*$'\n'"$section/$name"$'\t'}"
+                    prev="${rest%%$'\n'*}"
+                    rest="${IS_CAT_PATH[prev]}"
+                    [ "$section" != skills ] || rest="${rest%/SKILL.md}"
+                    if [ "${IS_CAT_PATH[prev]}" = "$f" ]; then
+                        # One directory listed twice: the same artifact.
+                        IS_CAT_WIN[prev]=0
+                    elif [ "${rest%/*}" = "$dir" ]; then
+                        errors+="ERROR: ${IS_CAT_PATH[prev]#"$repo_root"/} and ${f#"$repo_root"/} are both the $kind '$name' in one directory — rename or remove one"$'\n'
+                    elif [ "${IS_CAT_LOCAL[prev]}" != "$IS_ART_LOCAL" ]; then
+                        errors+="ERROR: ${IS_CAT_PATH[prev]#"$repo_root"/} and ${f#"$repo_root"/} are both the $kind '$name', one local and one not — a local artifact cannot override or yield to a committed one; rename one"$'\n'
+                    else
+                        IS_CAT_WIN[prev]=0
+                    fi
+                    ;;
+            esac
+            seen="$seen$section/$name"$'\t'"$n"$'\n'
+            files+=("$f")
+            n=$((n + 1))
+        done
+    done
+    IS_CAT_N="$n"
+    if [ -n "$errors" ]; then
+        printf '%s' "$errors" >&2
+        exit 1
+    fi
+    if [ "$n" -gt 0 ]; then
+        # One pass reads what routing needs from every source's frontmatter
+        # and, for the engine, lints it. Captured, not streamed: a short answer
+        # must stop the run, not route the files it lost as always-on.
+        rows="$(source_frontmatter_scan "$lint" "${files[@]}")" || {
+            echo "ERROR: cannot read the frontmatter of the sources — refusing to render a partial list." >&2
+            exit 1
+        }
+        i=0
+        while IFS=$'\x1f' read -r path scoped; do
+            [ "$i" -lt "$n" ] && [ "$path" = "${IS_CAT_PATH[i]}" ] || {
+                echo "ERROR: cannot read the frontmatter of the sources — refusing to render a partial list." >&2
+                exit 1
+            }
+            [ "${IS_CAT_SEC[i]}" != rules ] || [ "$scoped" = 0 ] || IS_CAT_SCOPED[i]=1
+            i=$((i + 1))
+        done <<< "$rows"
+        if [ "$i" -ne "$n" ]; then
+            echo "ERROR: cannot read the frontmatter of the sources — refusing to render a partial list." >&2
+            exit 1
+        fi
+    fi
+    [ "${IS_SOURCE_FILES_MEMO:-0}" != 1 ] || IS_CAT_KEY="$key"
+}
+
+# source_frontmatter_scan <lint> <file>... — one row per file in argument
+# order: the path and its `paths:` line count, \x1f-separated, read with
+# frontmatter_index's `paths#` semantics. With <lint> = lint the same pass runs
+# lint_frontmatter_files over every file, its warnings on stderr.
+source_frontmatter_scan() {
+    local do_lint=0
+    [ "$1" != lint ] || do_lint=1
+    shift
+    awk -v levels="$IS_EFFORT_LEVELS" -v do_lint="$do_lint" "$IS_AWK_LIB"'
+        BEGIN { SX_US = sprintf("%c", 31) }
+        function sx_store() { if (sx_cur != "") SXR[sx_cur] = sx_cur SX_US sx_paths }
+        FNR == 1 { sx_store(); sx_cur = FILENAME; sx_paths = 0; sx_fm = 0 }
+        {
+            sx_l = $0
+            sub(/\r$/, "", sx_l)
+            if (FNR == 1) sx_fm = (sx_l == "---")
+            else if (sx_fm == 1) {
+                if (sx_l == "---") sx_fm = 2
+                else if (index(sx_l, ":") && substr(sx_l, 1, index(sx_l, ":") - 1) == "paths") sx_paths++
+            }
+        }
+        END {
+            sx_store()
+            for (sx_i = 1; sx_i < ARGC; sx_i++)
+                print (ARGV[sx_i] in SXR) ? SXR[ARGV[sx_i]] : ARGV[sx_i] SX_US 0
+        }
+        !do_lint { next }
+    '"$_IS_AWK_LINT" "$@"
+}
+
+# The source catalog's committed check needs every enabled adapter's Git
+# policy, which only the engine reads (sync.sh: IS_COMMIT_POLICY, one
+# `adapter TAB kind TAB pattern` line per ignore and include record, and
+# IS_COMMIT_POLICY_SET=1). It reads it only when IS_CAT_NEED_COMMITTED says a
+# render depends on it, so a project without local artifacts never pays for
+# the manifest read the Copilot contract makes (decision 0020).
+#
+# output_committed <adapter> <repo-relative path> — true when Git tracks that
+# output: no `ignore` record of the adapter's contract covers it, or an
+# `include` record takes it back. AGENTS.md always belongs here.
+output_committed() {
+    local adapter="$1" path="$2" a kind pat ignored=0 included=0
+    [ "$adapter" != agents ] || return 0
+    if [ "${IS_COMMIT_POLICY_SET:-0}" != 1 ]; then
+        echo "ERROR: rendering a local artifact needs the Git policy of every enabled adapter; run it through the engine: intelligence sync" >&2
+        exit 1
+    fi
+    while IFS=$'\t' read -r a kind pat; do
+        [ "$a" = "$adapter" ] || continue
+        case "$kind" in
+            ignore) [ "$ignored" = 1 ] || ! policy_pattern_covers "$pat" "$path" || ignored=1 ;;
+            include) [ "$included" = 1 ] || ! policy_pattern_covers "$pat" "$path" || included=1 ;;
+        esac
+    done <<< "$IS_COMMIT_POLICY"
+    [ "$ignored" = 1 ] && [ "$included" = 0 ] && return 1
+    return 0
+}
+
+# policy_pattern_covers <ignore-pattern> <path> — whether a contract's ignore
+# or include pattern covers a repo-relative path or one of its parents: a
+# trailing `/` names a directory, `*` and `?` match as Git's do inside one.
+policy_pattern_covers() {
+    local pat="${1#./}" path="$2"
+    pat="${pat#/}"
+    case "$pat" in
+        */)
+            pat="${pat%/}"
+            case "$path" in "$pat"|"$pat"/*) return 0 ;; esac
+            return 1
+            ;;
+    esac
+    # shellcheck disable=SC2254  # the pattern is a glob on purpose
+    case "$path" in
+        $pat|$pat/*) return 0 ;;
+    esac
+    return 1
+}
+
+# _cat_member <index> <adapter> <repo-relative output path> — whether the
+# catalog row renders into that adapter's output at that path.
+_cat_member() {
+    if [ "${IS_CAT_LOCAL[$1]}" = 1 ]; then
+        ! output_committed "$2" "$3" || return 1
+    fi
+    return 0
+}
+
+# source_artifacts_var <repo_root> <config> <section> <adapters> <output>
+# — the artifacts of a section that render for one of <adapters> (space-
+# separated ids) into <output>, a repo-relative path in which `{}` stands for
+# the artifact's name (`.claude/rules/{}.md`, `.agents/skills/{}`). Fills, in
+# catalog order — sources in manifest order, entries in byte order:
+#   IS_SOURCE_FILES      the source file, or a skill's SKILL.md
+#   IS_SOURCE_NAMES      the rendered name
+#   IS_SOURCE_SCOPED     1 for a rule with `paths:`
+#   IS_SOURCE_IN_AGENTS  1 when AGENTS.md carries the artifact too
+#   IS_SOURCE_NAME_MAP   the name map finalize_copy_named and
+#                        copy_skill_bundle_dirs_named take (a skill keyed by
+#                        its directory)
+source_artifacts_var() {
+    local repo_root="$1" config_file="$2" section="$3" adapters="$4" output="$5"
+    local i a pre post path member key ph='{}'
+    source_catalog_build "$repo_root" "$config_file"
+    IS_SOURCE_FILES=(); IS_SOURCE_NAMES=(); IS_SOURCE_SCOPED=(); IS_SOURCE_IN_AGENTS=()
+    IS_SOURCE_NAME_MAP=$'\n'
+    case "$output" in
+        *"$ph"*) pre="${output%%"$ph"*}"; post="${output#*"$ph"}" ;;
+        *) pre="$output"; post="" ;;
+    esac
+    for ((i = 0; i < IS_CAT_N; i++)); do
+        [ "${IS_CAT_SEC[i]}" = "$section" ] && [ "${IS_CAT_WIN[i]}" = 1 ] || continue
+        if [ "${IS_CAT_LOCAL[i]}" = 1 ]; then
+            case "$output" in *"$ph"*) path="$pre${IS_CAT_NAME[i]}$post" ;; *) path="$output" ;; esac
+            member=0
+            for a in $adapters; do
+                if _cat_member "$i" "$a" "$path"; then member=1; break; fi
+            done
+            [ "$member" = 1 ] || continue
+            IS_SOURCE_IN_AGENTS+=(0)
+        else
+            IS_SOURCE_IN_AGENTS+=(1)
+        fi
+        IS_SOURCE_FILES+=("${IS_CAT_PATH[i]}")
+        IS_SOURCE_NAMES+=("${IS_CAT_NAME[i]}")
+        IS_SOURCE_SCOPED+=("${IS_CAT_SCOPED[i]}")
+        key="${IS_CAT_PATH[i]}"
+        [ "$section" != skills ] || key="${key%/SKILL.md}"
+        IS_SOURCE_NAME_MAP="$IS_SOURCE_NAME_MAP$key"$'\x1f'"${IS_CAT_NAME[i]}"$'\n'
+    done
+}
+
+# output_rel_var <repo_root> <absolute output path> — IS_OUTPUT_REL, the
+# output's repo-relative path spelled as contracts and source_artifacts_var
+# spell it.
+# shellcheck disable=SC2034  # IS_OUTPUT_REL is the return channel read by adapters
+output_rel_var() {
+    normalize_path_var "$2"
+    IS_OUTPUT_REL="${IS_NORM_PATH#"$1"/}"
+}
+
+# source_catalog_winners_var <repo_root> <config> <section> — every artifact of
+# a section that renders anywhere, whatever its outputs: IS_SOURCE_FILES and
+# IS_SOURCE_SCOPED, for the adapter-agnostic context report.
+source_catalog_winners_var() {
+    local i
+    source_catalog_build "$1" "$2"
+    IS_SOURCE_FILES=(); IS_SOURCE_SCOPED=()
+    for ((i = 0; i < IS_CAT_N; i++)); do
+        [ "${IS_CAT_SEC[i]}" = "$3" ] && [ "${IS_CAT_WIN[i]}" = 1 ] || continue
+        IS_SOURCE_FILES+=("${IS_CAT_PATH[i]}")
+        IS_SOURCE_SCOPED+=("${IS_CAT_SCOPED[i]}")
+    done
+}
+
 # Apply the agents adapter's lexical output rule without consulting filesystem
 # state. An omitted output uses the generic adapter default directory.
 agents_output_path_var() {
@@ -2242,26 +2606,23 @@ context_files_bytes() {
 report_context_source_sizes() {
     local repo_root="$1"
     local config_file="$2"
-    local f path has_paths
-    local -a rule_files=() always_on_rules=() scoped_rules=() agent_files=() skill_files=()
-
-    read_source_artifact_files "$repo_root" "$config_file" "rules"
-    [ "${#IS_SOURCE_FILES[@]}" -eq 0 ] || rule_files=("${IS_SOURCE_FILES[@]}")
-    if [ "${#rule_files[@]}" -gt 0 ]; then
-        while IFS=$'\x1f' read -r path has_paths; do
-            [ -n "$path" ] || continue
-            if [ "$has_paths" = "0" ]; then
-                always_on_rules+=("$path")
-            else
-                scoped_rules+=("$path")
-            fi
-        done < <(frontmatter_index "paths#" "${rule_files[@]}")
-    fi
+    local i
+    local -a always_on_rules=() scoped_rules=() agent_files=() skill_files=()
+
+    # What renders anywhere: an artifact a later source overrides is no context.
+    source_catalog_winners_var "$repo_root" "$config_file" "rules"
+    for ((i = 0; i < ${#IS_SOURCE_FILES[@]}; i++)); do
+        if [ "${IS_SOURCE_SCOPED[i]}" = 0 ]; then
+            always_on_rules+=("${IS_SOURCE_FILES[i]}")
+        else
+            scoped_rules+=("${IS_SOURCE_FILES[i]}")
+        fi
+    done
 
-    read_source_artifact_files "$repo_root" "$config_file" "agents"
+    source_catalog_winners_var "$repo_root" "$config_file" "agents"
     [ "${#IS_SOURCE_FILES[@]}" -eq 0 ] || agent_files=("${IS_SOURCE_FILES[@]}")
 
-    read_source_artifact_files "$repo_root" "$config_file" "skills"
+    source_catalog_winners_var "$repo_root" "$config_file" "skills"
     [ "${#IS_SOURCE_FILES[@]}" -eq 0 ] || skill_files=("${IS_SOURCE_FILES[@]}")
 
     local always_bytes=0 custom_bytes=0 agents_output agents_bytes=0 agents_status="disabled"
diff --git a/engine/sync.sh b/engine/sync.sh
index 36df4e9..d22a3b3 100644
--- a/engine/sync.sh
+++ b/engine/sync.sh
@@ -115,40 +115,17 @@ done <<< "${IS_YL_UNRESOLVED:-}"
 
 
 # Sources stay read-only for the whole run (validate_output_path refuses an
-# output inside one), so read_source_artifact_files enumerates each section
-# once, in this shell, and its later callers — the agents adapter, the shared
-# skill directory, the context report — replay it. Adapters that list sources
-# with in-shell globs spawn nothing and keep their own, locale-ordered listing.
-# The skills pass also settles every symlink in a skills source and warns once
-# about each it leaves out (decision 0017).
+# output inside one), so the source catalog is built once, in this shell, and
+# every renderer replays it: AGENTS.md, every adapter, the shared skill
+# directory and the context report read sources through source_artifacts_var
+# (decision 0021). Building it names every artifact, settles which of a name
+# renders, refuses ambiguous names before any output is touched, settles every
+# symlink in a skills source (decision 0017), and lints the frontmatter of every
+# source — skills as the inventory renders them: SKILL.md behind a link inside
+# its source is linted, one that leaves its source is never read.
 # shellcheck disable=SC2034  # read by read_source_artifact_files in lib/common.sh
 IS_SOURCE_FILES_MEMO=1
-for section in rules agents skills; do
-    read_source_artifact_files "$REPO_ROOT" "$CONFIG_FILE" "$section"
-done
-
-# Lint frontmatter across all source files (rules, agents, skills).
-# Catches issues like unquoted colons that strict YAML consumers reject.
-# Skills are the rendered ones the pass above settled: SKILL.md behind a link
-# inside its source is linted, one that leaves its source is never read.
-LINT_FILES=()
-LINT_SKILLS=()
-[ "${#IS_SOURCE_FILES[@]}" -eq 0 ] || LINT_SKILLS=("${IS_SOURCE_FILES[@]}")
-for section in rules agents; do
-    load_yaml_list "$CONFIG_FILE" "$section"
-    while IFS= read -r src; do
-        [ -z "$src" ] && continue
-        src_dir="$REPO_ROOT/$src"
-        [ -d "$src_dir" ] || continue
-        for f in "$src_dir"/*.md; do
-            [ -f "$f" ] && LINT_FILES+=("$f")
-        done
-    done <<< "$IS_YAML_LIST"
-done
-[ "${#LINT_SKILLS[@]}" -eq 0 ] || LINT_FILES+=("${LINT_SKILLS[@]}")
-if [ "${#LINT_FILES[@]}" -gt 0 ]; then
-    lint_frontmatter_files "${LINT_FILES[@]}"
-fi
+source_catalog_build "$REPO_ROOT" "$CONFIG_FILE" lint
 
 # Adapters come from two places, discovered by filename (minus `.sh`,
 # `_template` excluded):
@@ -377,6 +354,17 @@ note_agents_dependent() {
 }
 SELECTED_RECORDS=()
 RENDER_PARALLEL="$SYNC_PARALLEL"
+# What a source may render into depends on Git policy only when the catalog
+# holds a local artifact: then every contract is read with the manifest, which
+# may choose that policy (targets.copilot.commit_output), and its ignore and
+# include records become IS_COMMIT_POLICY. Every other sync reads ownership
+# alone, as decision 0020 keeps it (decision 0021).
+policy_manifest=""
+[ "$IS_CAT_NEED_COMMITTED" != 1 ] || policy_manifest="$CONFIG_FILE"
+IS_COMMIT_POLICY=""
+# The tools that read .agents/skills/, by their contracts: a skill lands there
+# when it is for any of them.
+IS_OPEN_SKILLS_READERS=""
 preflight_idx=0
 while [ "$preflight_idx" -lt "${#ADAPTERS[@]}" ]; do
     adapter="${ADAPTERS[$preflight_idx]}"
@@ -387,13 +375,24 @@ while [ "$preflight_idx" -lt "${#ADAPTERS[@]}" ]; do
     target_output_var "$CONFIG_FILE" "$adapter"
     output="$IS_TGT_OUTPUT"
     [ -n "$output" ] || output=".$adapter"
-    records="$(adapter_contract_records "$adapter" "$adapter_file" "$output")" || exit 1
+    records="$(adapter_contract_records "$adapter" "$adapter_file" "$output" "$policy_manifest")" || exit 1
 
     if ! adapter_claims_add_records "$adapter" "$records"; then
         echo "ERROR: $IS_ADAPTER_CLAIM_CONFLICT." >&2
         echo "       Give each adapter its own output: intelligence adapter list" >&2
         exit 1
     fi
+    while IFS=$'\t' read -r kind value; do
+        case "$kind" in
+            ignore|include) IS_COMMIT_POLICY="$IS_COMMIT_POLICY$adapter"$'\t'"$kind"$'\t'"$value"$'\n' ;;
+            owned|managed)
+                adapter_contract_rel_path "$value"
+                if [ "$IS_ADAPTER_REL_PATH" = ".agents/skills" ]; then
+                    IS_OPEN_SKILLS_READERS="$IS_OPEN_SKILLS_READERS${IS_OPEN_SKILLS_READERS:+ }$adapter"
+                fi
+                ;;
+        esac
+    done <<< "$records"
 
     if [ -n "$TARGET_FILTER" ] && [ "$adapter" != "$TARGET_FILTER" ]; then
         # Not selected: its claims are registered, its output is not touched.
@@ -428,6 +427,8 @@ while [ "$preflight_idx" -lt "${#ADAPTERS[@]}" ]; do
         esac
     done <<< "$records"
 done
+# shellcheck disable=SC2034  # read by output_committed in lib/common.sh
+[ -z "$policy_manifest" ] || IS_COMMIT_POLICY_SET=1
 
 # Every adapter that requires `agents` skips always-on rules because AGENTS.md
 # carries them — and each of those tools reads AGENTS.md at the workspace root
diff --git a/intelligence/rules/engine.md b/intelligence/rules/engine.md
index 1e5c435..4d2b751 100644
--- a/intelligence/rules/engine.md
+++ b/intelligence/rules/engine.md
@@ -46,6 +46,19 @@ then reaches the adapter as fewer files, which renders an incomplete output that
 reports `IS_STATUS=ok`. Assemble in the current shell and check every pipeline that
 feeds it.
 
+Every renderer — `AGENTS.md`, each built-in adapter, the adapter template — reads
+sources through `source_artifacts_var`, never a glob of its own (decision 0021).
+`source_catalog_build` settles, once per run and before any output is touched, what
+each artifact is called (no leading `.`, `.md` or trailing `.local`), which of two
+same-named artifacts renders (the later source's), and refuses two of one name in
+one directory or a local and a non-local one anywhere. A local artifact
+(`*.local.md`, a `*.local/` skill) reaches only an output path its adapter's
+contract ignores, so an adapter passes the real path it writes: one that globs
+sources itself, or names a path it does not write, can put a teammate's local file
+into a committed output. Only a catalog holding a local artifact makes the engine
+read contracts with the manifest; every other sync keeps decision 0020's
+ownership-only read.
+
 ## Rule routing
 
 Always-on rules are inlined once into `AGENTS.md`. Cursor, Copilot, Codex, Pi and
@@ -88,15 +101,14 @@ files live there. A full sync is transactional across every selected adapter pat
 A symlink in a skills source renders as the file or directory it points at while it
 stays inside that source, and is left out with a `WARNING:` line otherwise; no
 generated tree holds a link (decision 0017). `skill_source_inventory` settles every
-link once per run, and every skill tree takes its answer: `copy_skill_bundle` applies
-its plan, and an adapter that globs a skills source filters with
-`skill_source_rendered`.
+link once per run, and every skill tree takes its answer: the catalog lists only the
+skills it renders, and `copy_skill_bundle` applies its plan.
 
 A per-file loop never spawns a process per file: on Git Bash for Windows one fork
 costs tens of milliseconds, so per-file awk/cp/mv turned large projects into
 minutes of pure process creation. Batch the loop through the helpers built for
-this — `finalize_output_files`, `finalize_copy_files`, `frontmatter_index`,
-`emit_wrapped_bodies`, `copy_skill_bundle_dirs` / `copy_skill_bundle_dirs_for`,
+this — `finalize_output_files`, `finalize_copy_named`, `frontmatter_index`,
+`emit_wrapped_bodies`, `copy_skill_bundle_dirs_named` / `copy_skill_bundle_dirs_for`,
 `lint_frontmatter_files` — and read the manifest through `load_yaml_lists` /
 `load_yaml_list` / the targets cache so a section is parsed once per run. The
 single-file forms remain for cold paths and project adapters.
@@ -106,11 +118,11 @@ takes has a `_var` form that returns through a variable — `read_schema_version
 `engine_version_var`, `get_model_default_var`, `map_effort_var`,
 `agents_output_path_var`, `count_matching_files`, `load_model_tiers` — and callers
 there use it; the printing form wraps it, so there is still one parser.
-`read_source_artifact_files` runs its `find | sort` once per section and replays
-the answer to later callers while the engine sets `IS_SOURCE_FILES_MEMO`, which
-is safe only because no output may land in a source. Adapters that list sources
-with in-shell globs spawn nothing; moving them onto the helper would change their
-locale-ordered listing to byte order.
+`read_source_artifact_files` runs its `find | sort` once per section, and the
+catalog is built once from it, while the engine sets `IS_SOURCE_FILES_MEMO`; every
+later `source_artifacts_var` replays it without a process, which is safe only
+because no output may land in a source. The catalog's routing fields come from the
+same awk pass that lints every source.
 
 Built-in adapters render concurrently (decision 0011): the plan comes from the
 contract, so the contract has to tell the truth about order. Adapters whose
diff --git a/intelligence/skills/dev-build-adapter/SKILL.md b/intelligence/skills/dev-build-adapter/SKILL.md
index 179d7c2..7d87f02 100644
--- a/intelligence/skills/dev-build-adapter/SKILL.md
+++ b/intelligence/skills/dev-build-adapter/SKILL.md
@@ -29,8 +29,10 @@ from the distributed sync package. Consumers retain the public CLI and adapter g
    Keep output within validated destinations and preserve hand-authored siblings.
 
 4. Update built-in discovery/defaults and dependency declarations where the engine
-   rules require them. Reuse batched source enumeration, finalization, skill-bundle,
-   and shared-output helpers from the closest built-in. Correct ignore policy in
+   rules require them. Read every source through `source_artifacts_var` with the
+   real output path, never a glob of the adapter's own, and write each output under
+   its rendered name; reuse the finalization, skill-bundle and shared-output
+   helpers from the closest built-in. Correct ignore policy in
    the contract rather than hand-editing generated policy. Resolve movable fixture
    paths from its manifest; implementation remains in source, never generated output.
 
diff --git a/packages/sync/references/adapters.md b/packages/sync/references/adapters.md
index 1292b4a..1f7eb00 100644
--- a/packages/sync/references/adapters.md
+++ b/packages/sync/references/adapters.md
@@ -141,22 +141,23 @@ The engine has already loaded `engine/lib/common.sh` before it sources the adapt
 
 `sources.rules`, `sources.agents` and `sources.skills` contain repo-relative directory paths. Packages have already been resolved, fetched and pinned by the CLI, so package content appears as an ordinary path under `.intelligence/packages/`. The manifest may name a package's directory by the package's full name or alias instead; `read_yaml_list` and `load_yaml_list` hand an adapter the store path either way, and leave out a reference that names nothing, so an adapter reads every source the same way. Adapters never perform network access or parse `packages:`.
 
-Iterate a source section in manifest order:
+Read a section through the source catalog, never with a glob of your own. `AGENTS.md`, every built-in adapter and the template read it the same way (decision 0021):
 
 ```bash
-while IFS= read -r src; do
-    [ -n "$src" ] || continue
-    dir="$(resolve_source_dir "$repo_root" "$src")"
-    [ -d "$dir" ] || continue
-
-    for file in "$dir"/*.md; do
-        [ -f "$file" ] || continue
-        # transform file
-    done
-done < <(read_yaml_list "$config_file" "rules")
+output_rel_var "$repo_root" "$output_dir"
+source_artifacts_var "$repo_root" "$config_file" rules mytool "$IS_OUTPUT_REL/rules/{}.md"
+for ((i = 0; i < ${#IS_SOURCE_FILES[@]}; i++)); do
+    # IS_SOURCE_FILES[i] is the source, IS_SOURCE_NAMES[i] its rendered name,
+    # IS_SOURCE_SCOPED[i] is 1 for a rule with paths:
+    :
+done
 ```
 
-Later sources intentionally overwrite same-named artifacts from earlier sources. Package sources are wired before project sources, so project content can override a package artifact by name.
+The last argument is the repository-relative path an artifact lands at, `{}` standing for its name. The catalog lists sources in manifest order and each directory's entries in byte order, and settles three things before any adapter runs:
+
+- **Names.** An artifact is named by its file name without a leading `.`, `.md` and a trailing `.local`, a skill by its directory name without the leading `.` and `.local`: `.draft.md` renders as `draft`, `deploy.local/` as `deploy/`. Write each output under `IS_SOURCE_NAMES`, never under the source file name; `finalize_copy_named` and `copy_skill_bundle_dirs_named` take the `IS_SOURCE_NAME_MAP` the call leaves.
+- **Overrides.** Of two artifacts with one name, only the later source's is listed. Package sources are wired before project sources, so project content overrides a package artifact by name. Two of one name in one directory, or a local and a non-local one anywhere, refuse the sync before any adapter runs.
+- **Local artifacts.** A `*.local.md` rule or agent and a `*.local/` skill are listed only for an output path no `ignore` record of your contract covers — what Git tracks never holds one. That is why the path must be the real one: an adapter that globs sources itself, or names a path it does not write, can put a teammate's local file into a committed output.
 
 ## Shared functions
 
@@ -164,6 +165,10 @@ Use the engine library instead of copying parsers or file-handling logic.
 
 | Function | Purpose |
 |---|---|
+| `source_artifacts_var(root, config, section, adapters, output)` | The artifacts of a section that render for one of `adapters` at `output` (`{}` is the name): `IS_SOURCE_FILES`, `IS_SOURCE_NAMES`, `IS_SOURCE_SCOPED`, `IS_SOURCE_IN_AGENTS`, `IS_SOURCE_NAME_MAP`. |
+| `output_rel_var(root, output_dir)` | The output's repository-relative path in `IS_OUTPUT_REL`, as `source_artifacts_var` takes it. |
+| `finalize_copy_named(dest, map, src...)` | Copy-and-finalize every source into `dest` under its rendered name, in one process. |
+| `copy_skill_bundle_dirs_named(tool, dest_root, map, src...)` | `copy_skill_bundle_dirs_for` with each skill copied under its rendered name. |
 | `resolve_source_dir(repo_root, source)` | Resolve a manifest source to its local directory. |
 | `read_yaml_list(config, section)` | Stream entries from `sources.<section>`, package references as their store paths. |
 | `load_yaml_list(config, section)` | Same list into `IS_YAML_LIST`, cached — no subprocess on repeat reads. |
@@ -178,7 +183,6 @@ Use the engine library instead of copying parsers or file-handling logic.
 | `copy_skill_bundle(src, dest)` | Copy `SKILL.md` and all resources safely, normalize Markdown, quote free-text frontmatter, and keep a valid `effort:` as written, as the shared skills tree does. |
 | `copy_skill_bundle_dirs(dest_root, src...)` | Batch form: copy every skill directory into `dest_root/<name>` with one copy and one finalize pass. |
 | `copy_skill_bundle_dirs_for(tool, dest_root, src...)` | The batch form for a tree one tool reads: `SKILL.md`'s `effort:` becomes that tool's level, or is removed when it has none. |
-| `skill_source_rendered(skill_dir)` | Whether sync renders a skill directory an adapter listed with its own glob; a skill left out for its symlinks fails it. |
 | `sync_open_skill_dirs(root, config, dest)` | Own and populate a shared Agent Skills directory such as `.agents/skills/`, deriving Codex's `agents/openai.yaml` for a skill with `disable-model-invocation: true`. |
 | `finalize_output_file(file)` | Expand layout tokens and normalize line endings; required for every emitted text file. |
 | `finalize_output_files(file...)` / `finalize_copy_files(dest, src...)` | Batch forms: finalize in place, or copy-and-finalize into a directory, in one process. |
@@ -242,7 +246,7 @@ copy_skill_bundle "$source_skill_dir" "$output_dir/skills/$skill_name"
 
 Do not use plain `cp` for skill bundles. `copy_skill_bundle` preserves non-Markdown assets, normalizes Markdown, expands layout tokens and quotes `description` and `argument-hint` where strict YAML readers require strings. It renders `effort:` as the shared tree does; a tree only one tool reads uses `copy_skill_bundle_dirs_for <tool>`, so the copy carries that tool's level or no effort at all. It never writes a symlink; how a link in a skills source renders is defined in [conventions](conventions.md#skill-body-and-resources).
 
-An adapter that lists a skills source with its own glob checks each directory with `skill_source_rendered`. A skill whose directory or `SKILL.md` is a link leaving its source is left out of every output, and sync has already warned about it once.
+`source_artifacts_var ... skills` lists only the skills sync renders: one whose directory or `SKILL.md` is a link leaving its source is left out of every output, and sync has already warned about it once. Copy them with `copy_skill_bundle_dirs_named` and the call's `IS_SOURCE_NAME_MAP`, so `deploy.local/` lands as `deploy/`.
 
 Antigravity, Codex, Pi and OpenCode share `.agents/skills/`. Any adapter writing that open-standard directory must call `sync_open_skill_dirs`; it is the single lifecycle owner for immediate skill subdirectories.
 
@@ -308,21 +312,16 @@ This example copies rules without frontmatter. A real adapter must decide how th
 #!/bin/bash
 
 sync_mytool_rules() {
-    local repo_root="$1" config_file="$2" output_dir="$3"
+    local repo_root="$1" config_file="$2" output_dir="$3" i out
     mkdir -p "$output_dir/rules"
 
-    while IFS= read -r src; do
-        [ -n "$src" ] || continue
-        local dir
-        dir="$(resolve_source_dir "$repo_root" "$src")"
-        [ -d "$dir" ] || continue
-
-        for file in "$dir"/*.md; do
-            [ -f "$file" ] || continue
-            strip_frontmatter "$file" > "$output_dir/rules/$(basename "$file")"
-            finalize_output_file "$output_dir/rules/$(basename "$file")"
-        done
-    done < <(read_yaml_list "$config_file" "rules")
+    output_rel_var "$repo_root" "$output_dir"
+    source_artifacts_var "$repo_root" "$config_file" rules mytool "$IS_OUTPUT_REL/rules/{}.md"
+    for ((i = 0; i < ${#IS_SOURCE_FILES[@]}; i++)); do
+        out="$output_dir/rules/${IS_SOURCE_NAMES[i]}.md"
+        strip_frontmatter "${IS_SOURCE_FILES[i]}" > "$out"
+        finalize_output_file "$out"
+    done
 }
 
 adapter_contract_mytool() {
@@ -352,6 +351,7 @@ Verify:
 
 - native file names, frontmatter and model/permission mappings;
 - scoped and always-on routing without duplicated context;
+- a dotfile or `*.local.md` source renders under its name, and a local one only into outputs the contract ignores;
 - skill resources are present;
 - no literal layout tokens remain;
 - hand-authored siblings under the tool root survive;
diff --git a/packages/sync/references/conventions.md b/packages/sync/references/conventions.md
index 2c30a26..68069ee 100644
--- a/packages/sync/references/conventions.md
+++ b/packages/sync/references/conventions.md
@@ -73,7 +73,7 @@ sources:
 
 A package's directory may also be named by the package instead of its store path: `@ainova-systems/sync/rules` names folder `rules` of the package `packages:` declares as `@ainova-systems/sync`, and `sync:rules` names it through the alias that package declares (`intelligence package alias @ainova-systems/sync sync`). Both render exactly as the store path, and both are installed package content like it: edit that content in its source repository. The CLI writes store paths and never rewrites a reference a person wrote; an `@scope/name/...` entry for a package `packages:` does not declare is an ordinary project path.
 
-Missing project-owned source directories are skipped, so a package-only project need not create empty `rules/`, `agents/` or `skills/` directories. Source order matters: later files with the same artifact name overwrite earlier ones. Package sources are wired before project sources so the project can override a package artifact deliberately.
+Missing project-owned source directories are skipped, so a package-only project need not create empty `rules/`, `agents/` or `skills/` directories. Source order matters: of two artifacts with one name, the later source's renders everywhere, `AGENTS.md` included, and the earlier one renders nowhere (see [Artifact names](#artifact-names-and-local-artifacts)). Package sources are wired before project sources so the project can override a package artifact deliberately.
 
 Project-owned entries are managed with `intelligence source add|remove|list` rather than by hand — it validates the path against the way the engine resolves it and prints the resulting order. `add` appends by default; `--before <entry>` / `--after <entry>` place content that should behave like a package ahead of the project's own directories.
 
@@ -164,6 +164,22 @@ Common skill verbs:
 
 The verb describes the outcome, not whether the skill implements the work or delegates to another command or skill.
 
+## Artifact names and local artifacts
+
+An artifact's name is its file name without a leading `.`, `.md` and a trailing `.local`; a skill's is its directory name without the leading `.` and the trailing `.local`. `backend.md`, `.backend.md` and `backend.local.md` are all the rule `backend`, `deploy.local/` is the skill `deploy`, and every generated copy carries the name: `.claude/rules/backend.md`, `.cursor/rules/backend.mdc`, `.claude/skills/deploy/`. A leading dot means nothing — a dotfile source renders like any other.
+
+Names stay unique. Across sources the later source's artifact renders and the earlier one does not, in `AGENTS.md` as in every tool's output; a skill a later source overrides is replaced whole, resources included. Sync refuses two artifacts with one name in one source directory (`backend.md` beside `.backend.md`), and a local and a non-local artifact with one name anywhere in the sources: a local file that overrode or yielded to a committed one would change what committed output holds.
+
+A **local** artifact is personal or machine-specific guidance — the OS, the shell, a local service, a personal habit — that only this clone loads: a rule or agent named `*.local.md`, or a skill directory named `*.local/`. `intelligence init` writes the matching patterns, for the project's content directory, into its managed `.gitignore` block, so Git and sync agree on which files are local:
+
+```gitignore
+intelligence/rules/*.local.md
+intelligence/agents/*.local.md
+intelligence/skills/*.local/
+```
+
+Sync renders a local artifact only into outputs Git ignores, and never into one it tracks: not `AGENTS.md`, not OpenCode's slash commands, not Copilot's output under `commit_output: true`. A clone without the file therefore renders the same committed files, and `intelligence sync --check` passes in CI. A local always-on rule reaches Claude Code only, because every other tool reads always-on rules from `AGENTS.md`; local scoped rules, agents and skills reach every enabled tool. `intelligence status --check` reports a missing pattern, and `intelligence init` restores it.
+
 ## Agent conventions
 
 ```yaml
@@ -354,7 +370,12 @@ By default, commit the manifest, lock, project-owned content and `AGENTS.md`. Ig
 # CLI-managed package store
 .intelligence/
 
-# Local root instructions migrate into project rules; local preferences stay ignored
+# Local rules, agents and skills of the content directory stay on this machine
+intelligence/rules/*.local.md
+intelligence/agents/*.local.md
+intelligence/skills/*.local/
+
+# Root tool instructions migrate into project rules and stay ignored
 CLAUDE.md
 .cursorrules
 GEMINI.md
@@ -430,9 +451,10 @@ than inferring contents from Git status.
 move useful repository guidance from legacy root files such as `.cursorrules`
 and instruction-bearing `CLAUDE.md` out of their quarantined backup copies and
 into project-owned rules, then verify the generated tool output. Do not restore
-the original root monolith. Create a new root tool-specific file only when it
-contains genuinely local configuration that an adapter cannot represent; keep
-that exception gitignored rather than maintaining a second committed source.
+the original root monolith. Genuinely machine-local guidance becomes a local
+rule, agent or skill (see
+[Artifact names and local artifacts](#artifact-names-and-local-artifacts)), not
+a new root tool-specific file.
 
 Before the first render, `intelligence init` preserves existing AI prompt paths
 under `<content-dir>/_backup/`. Its `manifest.tsv` labels the snapshot
@@ -496,6 +518,7 @@ Callers capture the real code with `command || rc=$?`. Do not use `if ! command;
 | `intelligence.yaml` | Manifest and schema contract | Tracked |
 | `intelligence.lock` | Resolved package state | Tracked |
 | `<content-dir>/{rules,agents,skills,adapters}/` | Project source of truth | Tracked |
+| `<content-dir>/{rules,agents}/*.local.md`, `<content-dir>/skills/*.local/` | Local artifacts, this clone only | Ignored |
 | `.intelligence/` | Restorable package store | Ignored |
 | `AGENTS.md` | Generated canonical project context | Normally tracked |
 | Tool output directories | Generated native content | Built-in adapter-owned paths ignored; shared settings tracked |
diff --git a/packages/sync/references/onboarding-migration.md b/packages/sync/references/onboarding-migration.md
index b21d250..b665083 100644
--- a/packages/sync/references/onboarding-migration.md
+++ b/packages/sync/references/onboarding-migration.md
@@ -47,7 +47,7 @@ Migrate meaning, not tool syntax:
 
 | Existing format | Project-owned destination |
 |---|---|
-| Root `AGENTS.md`, `CLAUDE.md`, `.cursorrules`, Copilot root instructions | Split verified guidance by topic into rules; keep local machine preferences in a gitignored root file only when no adapter representation exists |
+| Root `AGENTS.md`, `CLAUDE.md`, `.cursorrules`, Copilot root instructions | Split verified guidance by topic into rules; move machine-local preferences into local rules (`<content-dir>/rules/<name>.local.md`), which Git ignores and sync keeps out of committed output |
 | `.claude/rules/*.md` | Rule; preserve valid `paths:` |
 | `.cursor/rules/*.mdc` | Rule; rename `globs:` to `paths:` and remove `alwaysApply:` |
 | Claude/Cursor/Copilot agents, Codex `.codex/agents/*.toml` | Agent; map native model/readonly/tool fields back to `tier:` and `access:`, and a native effort level (`effort:`, `model_reasoning_effort`) back to `effort:` |
@@ -64,9 +64,9 @@ Obtain approval per `CREATE`, `UPDATE`, `REMOVE`, or `KEEP` proposal. Apply
 project-owned source changes first, then run `intelligence sync` and
 `intelligence status --check`. Inspect the enabled targets to prove the
 migrated guidance arrived and verify quarantined old root instructions remain
-absent. Create a new root tool file only from a separately approved, genuinely
-machine-local subset that has no adapter representation; never restore the
-original instruction monolith.
+absent. A separately approved, genuinely machine-local subset becomes a local
+rule, `<content-dir>/rules/<name>.local.md`, not a new root tool file; never
+restore the original instruction monolith.
 
 For every removed or renamed path, search all tracked files with `git ls-files`
 and report remaining references with file and line number. Apply an unambiguous
diff --git a/packages/sync/rules/intelligence-authoring.md b/packages/sync/rules/intelligence-authoring.md
index ee8b297..4c99c7c 100644
--- a/packages/sync/rules/intelligence-authoring.md
+++ b/packages/sync/rules/intelligence-authoring.md
@@ -54,7 +54,7 @@ The mistakes that actually happen, in order of frequency:
 
 **Derive from the code, not from prose that already exists.** Every REQUIRED and every invariant must be backed by something observed in the repository. Documentation is a claim, not evidence — read the file.
 
-**Describe the repository, not a machine.** The OS, the shell, the editor, a local dev stack, personal tooling — these are environment facts. They belong in a personal, gitignored `CLAUDE.md`. A rule is committed and read by everyone, so a shell-specific command or an absolute local path in it is simply wrong for whoever is on another platform.
+**Describe the repository, not a machine.** The OS, the shell, the editor, a local dev stack, personal tooling — these are environment facts. They belong in a local rule, `<content-dir>/rules/<name>.local.md`: Git ignores it, and sync renders it only into outputs Git ignores. A rule is committed and read by everyone, so a shell-specific command or an absolute local path in it is simply wrong for whoever is on another platform.
 
 **Explain the why — but only a why you can back.** A reason the reader can check is what makes an instruction survive a judgement call. An invented reason is worse than none: it sounds like evidence.
 
diff --git a/packages/sync/skills/intelligence-learn-from-repository/SKILL.md b/packages/sync/skills/intelligence-learn-from-repository/SKILL.md
index 35682ba..55a331c 100644
--- a/packages/sync/skills/intelligence-learn-from-repository/SKILL.md
+++ b/packages/sync/skills/intelligence-learn-from-repository/SKILL.md
@@ -59,9 +59,10 @@ mechanics; this skill supplies repository judgement.
    Treat backed-up legacy root instructions such as `.cursorrules` and an
    instruction-bearing `CLAUDE.md` as migration sources, not permanent parallel
    entry points. Move still-valid shared guidance into project-owned rules; do
-   not restore the original monolith. Only when approved machine-local guidance
-   remains, create a small new gitignored `CLAUDE.md` from that subset after
-   migration. `AGENTS.md` remains the shared root instruction entry point.
+   not restore the original monolith. Approved machine-local guidance becomes a
+   local rule, `<content-dir>/rules/<name>.local.md`, which Git ignores and sync
+   keeps out of committed output. `AGENTS.md` remains the shared root
+   instruction entry point.
 
    Review `.gitignore` and every existing `.vscodeignore`, `.npmignore`, and
    `.dockerignore` against the CLI-managed policy. Detect tracked files which
@@ -95,8 +96,9 @@ explains itself well.
     relevant generated `AGENTS.md`, Cursor rules, Claude rules, and any
     packaging/build file list affected by ignore policy. Verify quarantined
     legacy root entry points remain absent. If the user approved a genuinely
-    machine-local exception, create a concise new gitignored root file from only
-    that content; never copy the backed-up monolith back. Completion requires
+    machine-local exception, write only that content to a local rule
+    (`<content-dir>/rules/<name>.local.md`); never copy the backed-up monolith
+    back. Completion requires
     `IS_STATUS=ok`, a clean final check, and no `onboarding is pending` header
     after accepted migration.
 11. Report what was created, updated, removed, or deliberately kept. Remind the
diff --git a/packages/sync/skills/intelligence-review-context/references/audit-checks.md b/packages/sync/skills/intelligence-review-context/references/audit-checks.md
index c0142b8..13009e1 100644
--- a/packages/sync/skills/intelligence-review-context/references/audit-checks.md
+++ b/packages/sync/skills/intelligence-review-context/references/audit-checks.md
@@ -9,7 +9,7 @@ Apply these checks to the source groups resolved by the review skill.
 | **Over the cap** | `SKILL.md` over 1000 lines, rule over 500, agent over 200 | `SPLIT` — two artifacts, or move detail into `references/<topic>.md` |
 | **Shared instruction budget** | The measured shared agents output, or `agents-md` in sync's `CONTEXT:` summary, is over 32 KiB (32,768 bytes) | `COMPACT` — this is Intelligence's recommended maximum, not an adapter rejection threshold; use the compaction procedure in `intelligence-review-context` to reduce the owning sources without teaching terse output |
 | **Rule links to a rule** | A markdown link from one rule to another (`R1`) | `UNLINK` — name the rule instead: always-on rules are inlined into `AGENTS.md` and the scoped channels carry only scoped rules, so the link is dead in at least one output |
-| **Machine facts in a rule** | OS, shell, editor or a local absolute path (`R2`) | `MOVE` — these belong in a personal, gitignored `CLAUDE.md`; a rule is committed and read by everyone, including whoever is on another platform |
+| **Machine facts in a rule** | OS, shell, editor or a local absolute path (`R2`) | `MOVE` — these belong in a local rule, `<content-dir>/rules/<name>.local.md`, which Git ignores and sync keeps out of committed output; a rule is committed and read by everyone, including whoever is on another platform |
 | **Literal path or command in a skill** | A path *outside the skill's own folder* baked into a procedure (`R3`) | `PARAMETERIZE` — a skill is *executed*, so a literal path breaks the moment the layout moves; resolve it from a rule or from `<manifest>`. **Exempt:** the skill's own bundle (`references/`, `scripts/`, `assets/` — content is co-located with its skill by default); rules and agents (describing the repository is their job); an example inside an output-format block; the resolution step itself |
 | **Skill with no verification** | Nothing at the end proves the procedure worked (`R4`) | `FLAG` — a procedure that proves nothing is a note, or just the work: give it a verification, or delete it |
 | **Pressure marker** | A heading or section named CRITICAL / MANDATORY / HARD RULE / READ FIRST, or a density of `MUST` / `NEVER` / `ALWAYS` with no reason beside it (`R5`) | `REWRITE` - plain heading, one reason per constraint; when several instructions are each marked critical the marker stops carrying information, so keep emphasis for the one instruction demonstrably under-weighted without it |
diff --git a/packages/sync/skills/intelligence-update-context/references/rules.md b/packages/sync/skills/intelligence-update-context/references/rules.md
index 89ca679..b3cf3da 100644
--- a/packages/sync/skills/intelligence-update-context/references/rules.md
+++ b/packages/sync/skills/intelligence-update-context/references/rules.md
@@ -13,6 +13,11 @@
    Architecture, Build and test, Examples, and Patterns to recognize and replace.
    Keep reasons that guide judgment and reference real examples. An accepted
    user preference is identified as a preference, not a claim about existing code.
+5. Guidance that belongs to one machine or one person — the OS, the shell, a
+   local service, a personal habit — goes in a local rule,
+   `<content-dir>/rules/<name>.local.md`. Git ignores it, and sync renders it
+   only into outputs Git ignores, so it never reaches `AGENTS.md` or a teammate.
+   A local rule cannot share a name with a committed one.
 
 For a scoped rule:
 

From 8b43a0d50d04c15b093d9a6629f8c74f5665148f Mon Sep 17 00:00:00 2001
From: Dmitrij Zykovic <dmitrij.zykovic@ainovasystems.com>
Date: Sun, 11 Oct 2026 21:03:42 +0300
Subject: [PATCH 3/8] Added targets and exclude_targets, always-on channels
 outside AGENTS.md and shared-path warnings

---
 cli/tests/e2e-local-artifacts.sh              | 129 +++++++
 cli/tests/unit-engine.sh                      |  85 +++++
 docs/cli.md                                   |  12 +-
 engine/adapters/_template.sh                  |   7 +-
 engine/adapters/agents.sh                     |  12 +-
 engine/adapters/antigravity.sh                |  72 +++-
 engine/adapters/claude.sh                     |   2 +
 engine/adapters/codex.sh                      |  66 ++++
 engine/adapters/copilot.sh                    |  33 +-
 engine/adapters/cursor.sh                     |  75 +++-
 engine/adapters/pi.sh                         | 121 +++++-
 engine/lib/common.sh                          | 352 +++++++++++++++++-
 engine/sync.sh                                |  19 +-
 intelligence/rules/engine.md                  |  14 +-
 packages/sync/references/adapters.md          |  31 +-
 packages/sync/references/conventions.md       |  35 +-
 packages/sync/rules/intelligence-authoring.md |   2 +-
 17 files changed, 954 insertions(+), 113 deletions(-)

diff --git a/cli/tests/e2e-local-artifacts.sh b/cli/tests/e2e-local-artifacts.sh
index 4df9da8..2988b12 100644
--- a/cli/tests/e2e-local-artifacts.sh
+++ b/cli/tests/e2e-local-artifacts.sh
@@ -221,5 +221,134 @@ for pattern in 'Brain/rules/*.local.md' 'Brain/agents/*.local.md' 'Brain/skills/
 done
 chknot grep -Fq 'intelligence/rules/*.local.md' "$D/.gitignore"
 
+echo "== targeted artifacts: every always-on channel, and AGENTS.md left alone =="
+Q="$OUT/targeted"
+mkdir -p "$Q"
+git -C "$Q" init --quiet
+git -C "$Q" config user.email e2e@example.com
+git -C "$Q" config user.name e2e
+git -C "$Q" config core.autocrlf false
+run "$Q" init --bare --targets "$TARGETS"
+is "init of the targeted project" 0 "$RC"
+run "$Q" adapter enable antigravity
+is "enable antigravity" 0 "$RC"
+run "$Q" adapter enable pi
+is "enable pi" 0 "$RC"
+chk grep -Fqx 'AGENTS.override.md' "$Q/.gitignore"
+mkdir -p "$Q/intelligence/rules" "$Q/intelligence/agents" "$Q/intelligence/skills/ship"
+printf '# Team\n\nTEAM_BODY\n' > "$Q/intelligence/rules/team.md"
+run "$Q" sync
+commit_all "$Q" start
+printf -- '---\ntargets: [claude]\n---\n\nCLAUDE_ONLY_BODY\n' > "$Q/intelligence/rules/claude-only.md"
+printf -- '---\ntargets: [codex]\n---\n\nCODEX_ONLY_BODY\n' > "$Q/intelligence/rules/codex-only.md"
+printf -- '---\ndescription: "Tools"\nexclude_targets:\n  - agents\n---\n\nTOOLS_BODY "quoted" \\ back\n' > "$Q/intelligence/rules/tools.md"
+printf -- '---\ntargets: []\n---\n\nNOWHERE_BODY\n' > "$Q/intelligence/rules/nowhere.md"
+printf -- '---\nname: ship\ndescription: "Ship it"\ntargets: [codex]\n---\n\nSHIP_BODY\n' > "$Q/intelligence/skills/ship/SKILL.md"
+printf -- '---\nname: reviewer\ndescription: "Reviews"\ntier: standard\nexclude_targets: [copilot]\n---\n\nREVIEWER_BODY\n' > "$Q/intelligence/agents/reviewer.md"
+run "$Q" sync
+is "sync of targeted artifacts" 0 "$RC"
+for body in CLAUDE_ONLY_BODY CODEX_ONLY_BODY TOOLS_BODY NOWHERE_BODY SHIP_BODY; do
+    chknot grep -q "$body" "$Q/AGENTS.md"
+done
+chknot grep -q 'claude-only\|codex-only\|nowhere\|ship' "$Q/AGENTS.md"
+chk grep -Fq '[reviewer](intelligence/agents/reviewer.md)' "$Q/AGENTS.md"
+# targets: [claude] reaches Claude only, without the field.
+chk grep -q CLAUDE_ONLY_BODY "$Q/.claude/rules/claude-only.md"
+chknot grep -q '^targets:' "$Q/.claude/rules/claude-only.md"
+for f in .cursor/rules/claude-only.mdc .github/instructions/claude-only.instructions.md .agents/rules/claude-only.md; do
+    chknot test -e "$Q/$f"
+done
+# exclude_targets: [agents] reaches every tool through its own always-on channel.
+chk grep -q TOOLS_BODY "$Q/.claude/rules/tools.md"
+chknot grep -q '^exclude_targets:\|^  - agents' "$Q/.claude/rules/tools.md"
+chk grep -qx 'alwaysApply: true' "$Q/.cursor/rules/tools.mdc"
+chk grep -qx 'description: "Tools"' "$Q/.cursor/rules/tools.mdc"
+chk grep -qx 'applyTo: "\*\*"' "$Q/.github/instructions/tools.instructions.md"
+chk grep -qx 'trigger: always_on' "$Q/.agents/rules/tools.md"
+chk grep -Fq '{ name: "tools", body: "TOOLS_BODY \"quoted\" \\ back" }' "$Q/.pi/extensions/intelligence-sync-rules.ts"
+chk grep -Fq 'const projectRules' "$Q/.pi/extensions/intelligence-sync-rules.ts"
+chk grep -Fq "cannot reach opencode" "$LOG"
+# Codex reads AGENTS.override.md instead of AGENTS.md: all of it, plus its rules.
+chk test -f "$Q/AGENTS.override.md"
+is "override starts with AGENTS.md" "$(cat "$Q/AGENTS.md")" "$(head -n "$(grep -c '' "$Q/AGENTS.md")" "$Q/AGENTS.override.md")"
+chk grep -q CODEX_ONLY_BODY "$Q/AGENTS.override.md"
+chk grep -q TOOLS_BODY "$Q/AGENTS.override.md"
+chknot grep -q CLAUDE_ONLY_BODY "$Q/AGENTS.override.md"
+chk git -C "$Q" check-ignore -q --no-index AGENTS.override.md
+# targets: [] renders nowhere.
+is "files holding NOWHERE_BODY" "" "$(cd "$Q" && grep -rl NOWHERE_BODY AGENTS.md AGENTS.override.md .claude .cursor .codex .github .agents .opencode .pi 2>/dev/null)"
+# A skill for Codex lands in .agents/skills/, which three more tools read.
+chk test -f "$Q/.agents/skills/ship/SKILL.md"
+chknot grep -q '^targets:' "$Q/.agents/skills/ship/SKILL.md"
+for tree in .claude/skills .cursor/skills .github/skills; do
+    chknot test -e "$Q/$tree/ship"
+done
+chknot test -e "$Q/.opencode/commands/ship.md"
+chk grep -Fq 'WARNING: intelligence/skills/ship/ still reaches antigravity, opencode, pi through .agents/skills/' "$LOG"
+# exclude_targets: [copilot] keeps the agent out of Copilot's own channel.
+chknot test -e "$Q/.github/agents/reviewer.agent.md"
+chk test -f "$Q/.claude/agents/reviewer.md"
+chknot grep -q '^exclude_targets:' "$Q/.claude/agents/reviewer.md"
+chk test -f "$Q/.codex/agents/reviewer.toml"
+chk grep -Fq 'WARNING: intelligence/agents/reviewer.md still reaches copilot through AGENTS.md' "$LOG"
+# Only the reviewer agent, for AGENTS.md too, changed a tracked output.
+is "tracked outputs after targeted sync" " M AGENTS.md" "$(git -C "$Q" status --porcelain --untracked-files=no)"
+
+echo "== an untargeted project's Pi extension and outputs are unchanged by the fields' absence =="
+rm "$Q/intelligence/rules/codex-only.md" "$Q/intelligence/rules/tools.md"
+run "$Q" sync
+is "sync after removing the Codex rules" 0 "$RC"
+chknot test -e "$Q/AGENTS.override.md"
+chknot test -e "$Q/.pi/extensions/intelligence-sync-rules.ts"
+
+echo "== targets: [agents] with exclude_targets: [cursor] names cursor =="
+printf -- '---\ntargets: [agents]\nexclude_targets: [cursor]\n---\n\nAGENTS_ONLY_BODY\n' > "$Q/intelligence/rules/agents-only.md"
+run "$Q" sync
+is "sync of an AGENTS.md-only rule" 0 "$RC"
+chk grep -q AGENTS_ONLY_BODY "$Q/AGENTS.md"
+chknot test -e "$Q/.claude/rules/agents-only.md"
+chk grep -q 'WARNING: intelligence/rules/agents-only.md still reaches .*cursor.* through AGENTS.md' "$LOG"
+rm "$Q/intelligence/rules/agents-only.md"
+run "$Q" sync
+
+echo "== a hand-written AGENTS.override.md is never touched =="
+printf '# Mine\n' > "$Q/AGENTS.override.md"
+run "$Q" sync
+is "sync beside a hand-written override" 0 "$RC"
+is "hand-written override kept" "# Mine" "$(cat "$Q/AGENTS.override.md")"
+printf -- '---\ntargets: [codex]\n---\n\nCODEX_ONLY_BODY\n' > "$Q/intelligence/rules/codex-only.md"
+before="$(snapshot "$Q")"
+run "$Q" sync
+is "a Codex rule needing the hand-written path" 1 "$RC"
+chk grep -Fq 'AGENTS.override.md was not generated by intelligence-sync' "$LOG"
+is "hand-written override still kept" "# Mine" "$(cat "$Q/AGENTS.override.md")"
+is "outputs after the refusal" "$before" "$(snapshot "$Q")"
+rm "$Q/AGENTS.override.md" "$Q/intelligence/rules/codex-only.md"
+
+echo "== an unknown target, and a local artifact naming a committed output, refuse =="
+run "$Q" sync
+before="$(snapshot "$Q")"
+printf -- '---\ntargets: [cursr]\n---\n' > "$Q/intelligence/rules/typo.md"
+run "$Q" sync
+is "unknown target" 1 "$RC"
+chk grep -Fq "intelligence/rules/typo.md: targets names 'cursr', which is no adapter" "$LOG"
+is "outputs after the unknown target" "$before" "$(snapshot "$Q")"
+rm "$Q/intelligence/rules/typo.md"
+for id in agents committed; do
+    printf -- '---\ntargets: [%s]\n---\n' "$id" > "$Q/intelligence/rules/x.local.md"
+    run "$Q" sync
+    is "local rule with targets: [$id]" 1 "$RC"
+    chk grep -Fq "intelligence/rules/x.local.md is local, but its targets name $id, whose output Git tracks" "$LOG"
+    is "outputs after the local refusal ($id)" "$before" "$(snapshot "$Q")"
+done
+# A local rule may still narrow its set to an adapter whose output is ignored.
+printf -- '---\ntargets: [claude]\n---\n\nX_LOCAL_BODY\n' > "$Q/intelligence/rules/x.local.md"
+run "$Q" sync
+is "local rule with targets: [claude]" 0 "$RC"
+chk grep -q X_LOCAL_BODY "$Q/.claude/rules/x.md"
+chknot test -e "$Q/.cursor/rules/x.mdc"
+chknot test -e "$Q/AGENTS.override.md"
+rm "$Q/intelligence/rules/x.local.md"
+
 [ "$fail" -eq 0 ] && echo "E2E-LOCAL-ARTIFACTS: ALL OK"
 exit "$fail"
diff --git a/cli/tests/unit-engine.sh b/cli/tests/unit-engine.sh
index dd72533..4332e6f 100644
--- a/cli/tests/unit-engine.sh
+++ b/cli/tests/unit-engine.sh
@@ -796,5 +796,90 @@ printf 'sources:\n  rules:\n    - "a/rules"\n    - "a/rules/"\n' > "$S/twice.yam
 IS_SOURCE_FILES_MEMO=0 source_catalog_winners_var "$S" "$S/twice.yaml" rules
 chk eq "${#IS_SOURCE_FILES[@]}" 1
 
+echo "== source_frontmatter_scan: targets and exclude_targets in the list syntax paths: takes =="
+T="$OUT/targets"
+mkdir -p "$T"
+# <name> <frontmatter lines, \n-separated> <expected: has_t|t|has_x|x>
+tcase() {
+    printf -- '---\n%b\n---\ntargets: [body-is-not-frontmatter]\n' "$2" > "$T/$1.md"
+    printf '%s\n' "$1|$3" >> "$T/want"
+}
+: > "$T/want"
+tcase flow 'targets: [claude, cursor]' '1|claude cursor|0|'
+tcase quoted 'targets: ["claude", '"'"'codex'"'"']' '1|claude codex|0|'
+tcase block 'targets:\n  - claude\n  - "pi"\ndescription: x' '1|claude pi|0|'
+tcase empty 'targets: []' '1||0|'
+tcase null 'targets:\ndescription: x' '0||0|'
+tcase scalar 'targets: claude # only Claude' '1|claude|0|'
+tcase multiline 'targets: [claude,\n  cursor]\nexclude_targets: [committed]' '1|claude cursor|1|committed'
+tcase first 'exclude_targets: [pi]\nexclude_targets: [codex]' '0||1|pi'
+tcase indented 'meta:\n  targets: [claude]' '0||0|'
+printf -- '---\r\ntargets:\r\n  - codex\r\npaths:\r\n  - "src/**"\r\n---\r\n' > "$T/crlf.md"
+printf '%s\n' 'crlf|1|codex|0|' >> "$T/want"
+printf 'targets: [claude]\n' > "$T/nofm.md"
+printf '%s\n' 'nofm|0||0|' >> "$T/want"
+while IFS='|' read -r name has_t t has_x x; do
+    row="$(source_frontmatter_scan "" "$T/$name.md")"
+    IFS=$'\x1f' read -r _path _scoped got_ht got_t got_hx got_x <<< "$row"
+    eq "$got_ht|$got_t|$got_hx|$got_x" "$has_t|$t|$has_x|$x" \
+        || { echo "FAIL: targets scan $name: got [$got_ht|$got_t|$got_hx|$got_x] want [$has_t|$t|$has_x|$x]"; fail=1; }
+done < "$T/want"
+IFS=$'\x1f' read -r _path scoped _rest <<< "$(source_frontmatter_scan "" "$T/crlf.md")"
+chk eq "$scoped" 1
+
+echo "== rendered copies drop targets and exclude_targets, from the frontmatter only =="
+printf -- '---\ndescription: x\ntargets:\n  - claude\n  - cursor\nexclude_targets: [pi,\n  codex]\npaths:\n  - "src/**"\n---\ntargets: [kept in the body]\n' > "$T/strip.md"
+finalize_copy_named "$OUT" "" "$T/strip.md"
+chk eq "$(cat "$OUT/strip.md")" "$(printf -- '---\ndescription: x\npaths:\n  - "src/**"\n---\ntargets: [kept in the body]')"
+
+echo "== source catalog: targets, exclusions and the committed group =="
+G="$OUT/grouped"
+mkdir -p "$G/rules"
+printf 'sources:\n  rules:\n    - "rules"\n' > "$G/intelligence.yaml"
+printf -- '---\ntargets: [claude]\n---\n' > "$G/rules/only-claude.md"
+printf -- '---\nexclude_targets: [agents]\n---\n' > "$G/rules/not-agents.md"
+printf -- '---\ntargets: [committed]\n---\n' > "$G/rules/tracked.md"
+printf -- '---\nexclude_targets: [committed]\n---\n' > "$G/rules/ignored.md"
+printf -- '---\ntargets: []\n---\n' > "$G/rules/nowhere.md"
+printf 'plain\n' > "$G/rules/plain.md"
+IS_SOURCE_FILES_MEMO=0 source_catalog_build "$G" "$G/intelligence.yaml"
+chk eq "$IS_CAT_NEED_COMMITTED" 1
+# shellcheck disable=SC2034  # read by output_committed
+IS_COMMIT_POLICY=$'claude\tignore\t.claude/*\nopencode\tignore\t.opencode/agents/\n'
+# shellcheck disable=SC2034
+IS_COMMIT_POLICY_SET=1
+names_for() {
+    IS_SOURCE_FILES_MEMO=0 source_artifacts_var "$G" "$G/intelligence.yaml" rules "$1" "$2"
+    printf '%s' "${IS_SOURCE_NAMES[*]}"
+}
+chk eq "$(names_for claude '.claude/rules/{}.md')" "ignored not-agents only-claude plain"
+chk eq "$(names_for agents 'AGENTS.md')" "plain tracked"
+chk eq "$(names_for opencode '.opencode/commands/{}.md')" "not-agents plain tracked"
+chk eq "$(names_for opencode '.opencode/agents/{}.md')" "ignored not-agents plain"
+IS_SOURCE_FILES_MEMO=0 source_artifacts_var "$G" "$G/intelligence.yaml" rules claude '.claude/rules/{}.md'
+chk eq "${IS_SOURCE_IN_AGENTS[*]}" "0 0 0 1"
+# An id no adapter has refuses; `committed` is always known.
+printf -- '---\ntargets: [cursr, committed]\n---\n' > "$G/rules/typo.md"
+IS_SOURCE_FILES_MEMO=0 source_catalog_build "$G" "$G/intelligence.yaml"
+rc=0
+source_catalog_check_ids "$G" "agents claude cursor" 2> "$OUT/ids.err" || rc=$?
+chk eq "$rc" 1
+chk eq "$(cat "$OUT/ids.err")" "ERROR: rules/typo.md: targets names 'cursr', which is no adapter — use one of: agents, claude, cursor, or the group committed"
+rm "$G/rules/typo.md"
+# A local artifact may not name a committed output in its targets.
+printf -- '---\ntargets: [claude]\n---\n' > "$G/rules/fine.local.md"
+printf -- '---\ntargets: [agents]\n---\n' > "$G/rules/bad.local.md"
+IS_SOURCE_FILES_MEMO=0 source_catalog_build "$G" "$G/intelligence.yaml"
+# shellcheck disable=SC2034  # read by source_catalog_check_local
+IS_ENABLED_ADAPTERS="agents claude"
+# shellcheck disable=SC2034
+IS_ADAPTER_CLAIMS=$'agents\towned\tAGENTS.md\nclaude\towned\t.claude/rules\n'
+rc=0
+source_catalog_check_local "$G" 2> "$OUT/local.err" || rc=$?
+chk eq "$rc" 1
+chk grep -Fq "rules/bad.local.md is local, but its targets name agents, whose output Git tracks" "$OUT/local.err"
+chknot grep -Fq "fine.local.md" "$OUT/local.err"
+unset IS_COMMIT_POLICY IS_COMMIT_POLICY_SET IS_ENABLED_ADAPTERS IS_ADAPTER_CLAIMS
+
 [ "$fail" -eq 0 ] && echo "ENGINE-UNIT: ALL OK"
 exit "$fail"
diff --git a/docs/cli.md b/docs/cli.md
index c780b1d..2f64901 100644
--- a/docs/cli.md
+++ b/docs/cli.md
@@ -115,9 +115,15 @@ trailing `.local`; of two with one name, the later source's renders everywhere,
 with one name in one directory and a local and a non-local artifact with one
 name anywhere. A local artifact (`*.local.md`, `*.local/`) renders only into
 outputs its adapter's contract ignores, so committed files are the same in every
-clone. Only a sync whose sources hold a local artifact reads the contracts with
-the manifest, which `targets.copilot.commit_output` needs; see the
-[artifact conventions](../packages/sync/references/conventions.md#artifact-names-and-local-artifacts).
+clone. `targets:` and `exclude_targets:` in an artifact's frontmatter select the
+adapters it renders for; an id that names no adapter, and a local artifact whose
+targets name a committed output, refuse the sync before any output is touched,
+and a shared path (`AGENTS.md`, `.agents/skills/`) that still delivers an
+artifact beyond its targets is named in a `WARNING:` line. Only a sync whose
+sources hold a local artifact or name the group `committed` reads the contracts
+with the manifest, which `targets.copilot.commit_output` needs; see the
+[artifact conventions](../packages/sync/references/conventions.md#artifact-names-and-local-artifacts)
+and [selecting adapters](../packages/sync/references/conventions.md#selecting-adapters).
 
 Built-in adapters render concurrently where their contracts allow it: adapters
 that share a managed directory run in order together, and an adapter that
diff --git a/engine/adapters/_template.sh b/engine/adapters/_template.sh
index 46dea4e..a125835 100644
--- a/engine/adapters/_template.sh
+++ b/engine/adapters/_template.sh
@@ -73,8 +73,11 @@ adapter_contract_<name>() {
 # source_artifacts_var takes the repo-relative path an artifact lands at, `{}`
 # standing for its name, and fills IS_SOURCE_FILES (the source file, or a
 # skill's SKILL.md), IS_SOURCE_NAMES, IS_SOURCE_SCOPED (1 for a rule with
-# `paths:`) and IS_SOURCE_NAME_MAP, the names finalize_copy_named and
-# copy_skill_bundle_dirs_named write under.
+# `paths:`), IS_SOURCE_IN_AGENTS (1 when AGENTS.md carries the artifact too)
+# and IS_SOURCE_NAME_MAP, the names finalize_copy_named and
+# copy_skill_bundle_dirs_named write under. It lists only the artifacts whose
+# `targets:` / `exclude_targets:` select this adapter; the shared helpers drop
+# both fields from every copy, and a frontmatter copied by hand must too.
 sync_<name>_rules() {
     local repo_root="$1"
     local config_file="$2"
diff --git a/engine/adapters/agents.sh b/engine/adapters/agents.sh
index 8037f0c..9a70a04 100644
--- a/engine/adapters/agents.sh
+++ b/engine/adapters/agents.sh
@@ -198,17 +198,7 @@ agents_md_append_rules_list() {
             echo "<!-- Inlined from always-on rules in $content_rel/rules/ -->"
             echo ""
         } >> "$output"
-        # One awk inlines every global rule body, with a blank line after
-        # each — the same output the per-file passes produced.
-        awk '
-            FNR == 1 { if (NR != 1) print ""; in_fm = 0; past_fm = 0 }
-            { sub(/\r$/, "") }
-            /^---$/ {
-                if (!past_fm) { in_fm = !in_fm; if (!in_fm) { past_fm = 1 }; next }
-            }
-            past_fm || !in_fm { print }
-            END { print "" }
-        ' "${global_rule_files[@]}" >> "$output"
+        emit_rule_bodies "${global_rule_files[@]}" >> "$output"
         echo "  rules: ${#global_rule_files[@]} global rule(s) inlined"
     fi
 }
diff --git a/engine/adapters/antigravity.sh b/engine/adapters/antigravity.sh
index 4e1462f..562ff0e 100644
--- a/engine/adapters/antigravity.sh
+++ b/engine/adapters/antigravity.sh
@@ -11,7 +11,11 @@
 #   - Always-on (no `paths:`) -> SKIPPED here. The CLI docs tell a project to
 #     "Create a GEMINI.md or AGENTS.md file at your workspace root", and the
 #     `agents` adapter inlines always-on rule content into AGENTS.md. Emitting
-#     copies under .agents/rules/ would double-load the same text.
+#     copies under .agents/rules/ would double-load the same text. An always-on
+#     rule AGENTS.md does not carry — a local one, or one whose targets leave
+#     `agents` out — becomes .agents/rules/<name>.md with `trigger: always_on`,
+#     the same key family as `trigger: glob` and just as undocumented
+#     (decision 0021).
 #   - Path-scoped (with `paths:`) -> .agents/rules/<name>.md carrying
 #     `trigger: glob` and `globs:`. NOT vendor-documented: the rules page names
 #     four activation modes in prose (manual, always on, model decision, glob
@@ -95,31 +99,46 @@ sync_antigravity_rules() {
     antigravity_rule_limit "$config_file" || return 1
     rule_limit="$IS_AG_RULE_LIMIT"
 
-    # Skip always-on rules: AGENTS.md (canonical) carries them.
-    local i
-    local -a scoped=() scoped_names=()
+    # Skip always-on rules AGENTS.md (canonical) carries; one it does not
+    # carry takes the always_on trigger instead (decision 0021).
+    local i always="" always_count=0
+    local -a files=() names=() kinds=()
     output_rel_var "$repo_root" "$output_dir"
     source_artifacts_var "$repo_root" "$config_file" rules antigravity "$IS_OUTPUT_REL/rules/{}.md"
     for ((i = 0; i < ${#IS_SOURCE_FILES[@]}; i++)); do
-        [ "${IS_SOURCE_SCOPED[i]}" = 1 ] || continue
-        scoped+=("${IS_SOURCE_FILES[i]}")
-        scoped_names+=("${IS_SOURCE_NAMES[i]}")
+        if [ "${IS_SOURCE_SCOPED[i]}" = 1 ]; then
+            kinds+=(scoped)
+        elif [ "${IS_SOURCE_IN_AGENTS[i]}" = 0 ]; then
+            kinds+=(always-on)
+            always="$always${IS_SOURCE_FILES[i]}"$'\n'
+            always_count=$((always_count + 1))
+        else
+            continue
+        fi
+        files+=("${IS_SOURCE_FILES[i]}")
+        names+=("${IS_SOURCE_NAMES[i]}")
     done
-    if [ "${#scoped[@]}" -eq 0 ]; then
+    if [ "${#files[@]}" -eq 0 ]; then
         echo "  -> Rules: 0 scoped (AGENTS.md carries always-on)"
         return 0
     fi
 
-    # Path-scoped rule -> Glob activation (paths -> globs). The rewrite is
-    # anchored inside the frontmatter block: a body line may legitimately start
-    # with `paths:` (a rule documenting rule syntax does exactly that), and
-    # rewriting it would corrupt the text it teaches.
+    # Path-scoped rule -> Glob activation (paths -> globs); always-on rule ->
+    # `trigger: always_on`, with a frontmatter block of its own when the source
+    # has none. The rewrite is anchored inside the frontmatter block: a body
+    # line may legitimately start with `paths:` (a rule documenting rule
+    # syntax does exactly that), and rewriting it would corrupt the text it
+    # teaches.
     #
     # stdout carries nothing but the character-count overflow report, so the
     # limit check costs no extra process.
     local overflow
     is_fin_awk_vars
-    overflow="$(IS_NAME_MAP="$IS_SOURCE_NAME_MAP" awk "${IS_FIN_V[@]}" -v dst="$output_dir/rules" -v limit="$rule_limit" "$IS_AWK_LIB"'
+    overflow="$(IS_AG_ALWAYS="$always" IS_NAME_MAP="$IS_SOURCE_NAME_MAP" awk "${IS_FIN_V[@]}" -v dst="$output_dir/rules" -v limit="$rule_limit" "$IS_AWK_LIB"'
+        BEGIN {
+            n = split(ENVIRON["IS_AG_ALWAYS"], al, "\n")
+            for (k = 1; k <= n; k++) if (al[k] != "") ALWAYS[al[k]] = 1
+        }
         function emit(line,   rendered) {
             rendered = fin_line(line)
             print rendered > out
@@ -130,8 +149,18 @@ sync_antigravity_rules() {
             out = dst "/" art_file(FILENAME, ".md")
             chars[out] = 0
             fm = 0
+            tgt_reset()
         }
         { sub(/\r$/, "") }
+        FNR == 1 && (FILENAME in ALWAYS) {
+            emit("---")
+            emit("trigger: always_on")
+            if ($0 == "---") { fm = 1; next }
+            emit("---")
+            fm = 2
+            emit($0)
+            next
+        }
         FNR == 1 {
             if ($0 == "---") fm = 1
             emit($0)
@@ -139,6 +168,7 @@ sync_antigravity_rules() {
             next
         }
         fm == 1 && $0 == "---" { fm = 2; emit($0); next }
+        fm == 1 && tgt_drop($0) { next }
         fm == 1 { sub(/^paths:/, "globs:") }
         { emit($0) }
         END {
@@ -147,7 +177,7 @@ sync_antigravity_rules() {
                 for (f in chars)
                     if (chars[f] > limit) printf "%s\t%d\n", f, chars[f]
         }
-    ' "${scoped[@]}" | sort)"
+    ' "${files[@]}" | sort)"
 
     local over_file over_chars
     while IFS=$'\t' read -r over_file over_chars; do
@@ -155,10 +185,18 @@ sync_antigravity_rules() {
         echo "WARNING: Antigravity limits a rule file to $rule_limit characters: ${over_file#"$repo_root/"} renders $over_chars; split the rule, shorten it, set targets.antigravity.warn_rule_limit to the effective limit, or set it to false to disable this warning." >&2
     done <<< "$overflow"
 
-    for ((i = 0; i < ${#scoped_names[@]}; i++)); do
-        echo "  rule: ${scoped_names[i]}.md (scoped)"
+    for ((i = 0; i < ${#files[@]}; i++)); do
+        # awk never reads a record from an empty source.
+        if [ "${kinds[i]}" = always-on ] && [ ! -s "${files[i]}" ]; then
+            printf -- '---\ntrigger: always_on\n---\n' > "$output_dir/rules/${names[i]}.md"
+        fi
+        echo "  rule: ${names[i]}.md (${kinds[i]})"
     done
-    echo "  -> Rules: ${#scoped[@]} scoped"
+    if [ "$always_count" -gt 0 ]; then
+        echo "  -> Rules: $(( ${#files[@]} - always_count )) scoped, $always_count always-on"
+    else
+        echo "  -> Rules: ${#files[@]} scoped"
+    fi
 }
 
 sync_antigravity_agents() {
diff --git a/engine/adapters/claude.sh b/engine/adapters/claude.sh
index 662bdfe..b55846e 100644
--- a/engine/adapters/claude.sh
+++ b/engine/adapters/claude.sh
@@ -121,12 +121,14 @@ sync_claude_agents() {
             count = 0
             fm = 0
             effort_seen = 0
+            tgt_reset()
         }
         /^tier:/  { next }
         /^access:/ { next }
         { sub(/\r$/, "") }
         FNR == 1 && $0 == "---" { fm = 1 }
         /^---$/ { count++ }
+        fm && count == 1 && !/^---$/ && tgt_drop($0) { next }
         fm && count == 1 && substr($0, 1, 7) == "effort:" {
             if (!effort_seen++ && EFFORT[FILENAME] != "") print fin_line("effort: " EFFORT[FILENAME]) > out
             next
diff --git a/engine/adapters/codex.sh b/engine/adapters/codex.sh
index af6ed55..2b2498d 100644
--- a/engine/adapters/codex.sh
+++ b/engine/adapters/codex.sh
@@ -6,6 +6,13 @@
 # inlines always-on rules into AGENTS.md, so this adapter only emits skills
 # and subagent definitions.
 #
+# Rules: an always-on rule AGENTS.md does not carry — a local one, or one whose
+#   targets leave `agents` out — goes into AGENTS.override.md beside it
+#   (decision 0021). Codex reads that file instead of AGENTS.md in the same
+#   directory, so it holds the whole AGENTS.md plus those rules. The contract
+#   ignores it, and it exists only while such a rule does; one Intelligence did
+#   not generate is never touched, and refuses a render that needs the path.
+#
 # Skills: copy skill directories in full to .agents/skills/{name}/ (Codex
 #   reads from $REPO_ROOT/.agents/skills exclusively per official docs)
 # Agents: -> .codex/agents/{name}.toml (name, description, model,
@@ -26,8 +33,61 @@ adapter_contract_codex() {
     adapter_contract_requires agents
     adapter_contract_managed ".agents/skills"
     adapter_contract_owned "$output/agents"
+    # Marker-managed: a hand-written override is left alone.
+    adapter_contract_managed "AGENTS.override.md"
     adapter_contract_ignore ".agents/skills/"
     adapter_contract_ignore "$output/agents/"
+    adapter_contract_ignore "AGENTS.override.md"
+}
+
+CODEX_OVERRIDE_MARKER="<!-- Generated by intelligence-sync. Do not edit manually. -->"
+
+# sync_codex_override <repo_root> <config_file> — write AGENTS.override.md
+# while an always-on rule AGENTS.md does not carry is for Codex, and remove a
+# generated one otherwise.
+sync_codex_override() {
+    local repo_root="$1" config_file="$2" override="$1/AGENTS.override.md" first="" agents_file i
+    local -a files=() names=()
+    source_artifacts_var "$repo_root" "$config_file" rules codex "AGENTS.override.md"
+    for ((i = 0; i < ${#IS_SOURCE_FILES[@]}; i++)); do
+        [ "${IS_SOURCE_SCOPED[i]}" = 0 ] && [ "${IS_SOURCE_IN_AGENTS[i]}" = 0 ] || continue
+        files+=("${IS_SOURCE_FILES[i]}")
+        names+=("${IS_SOURCE_NAMES[i]}")
+    done
+    if [ -f "$override" ]; then
+        IFS= read -r first < "$override" || true
+        if [ "${first%$'\r'}" != "$CODEX_OVERRIDE_MARKER" ]; then
+            [ "${#files[@]}" -gt 0 ] || return 0
+            echo "ERROR: AGENTS.override.md was not generated by intelligence-sync, but ${names[*]} need it: always-on rules for Codex that AGENTS.md does not carry go there. Move its guidance into a rule, remove it, then sync." >&2
+            return 1
+        fi
+    fi
+    if [ "${#files[@]}" -eq 0 ]; then
+        rm -f "$override"
+        return 0
+    fi
+    target_output_var "$config_file" "agents"
+    agents_output_path_var "${IS_TGT_OUTPUT:-.agents}"
+    agents_file="$repo_root/$IS_AGENTS_OUTPUT_PATH"
+    {
+        if [ -f "$agents_file" ]; then
+            cat "$agents_file"
+        else
+            printf '%s\n\n' "$CODEX_OVERRIDE_MARKER"
+        fi
+        echo "---"
+        echo ""
+        echo "## Codex Project Context"
+        echo ""
+        echo "<!-- Always-on rules AGENTS.md does not carry. Codex reads this file instead of AGENTS.md. -->"
+        echo ""
+        emit_rule_bodies "${files[@]}"
+    } > "$override"
+    finalize_output_file "$override"
+    for ((i = 0; i < ${#names[@]}; i++)); do
+        echo "  rule: ${names[i]} (always-on, AGENTS.override.md)"
+    done
+    echo "  -> AGENTS.override.md"
 }
 
 # Codex-specific guard for its documented project-instruction byte budget.
@@ -52,6 +112,8 @@ codex_warn_project_doc_size() {
     target_output_var "$config_file" "agents"
     local output
     output="$(agents_output_path "${IS_TGT_OUTPUT:-.agents}")"
+    # Codex reads AGENTS.override.md instead of AGENTS.md when it exists.
+    [ ! -f "$repo_root/AGENTS.override.md" ] || output="AGENTS.override.md"
 
     local output_file="$repo_root/$output"
     [ -f "$output_file" ] || return 0
@@ -148,5 +210,9 @@ sync_to_codex() {
     mkdir -p "$agents_dir"
     sync_codex_agents "$repo_root" "$config_file" "$agents_dir"
 
+    # Rules AGENTS.md does not carry -> AGENTS.override.md. The contract
+    # requires `agents`, so AGENTS.md has rendered by now.
+    sync_codex_override "$repo_root" "$config_file" || return 1
+
     codex_warn_project_doc_size "$repo_root" "$config_file"
 }
diff --git a/engine/adapters/copilot.sh b/engine/adapters/copilot.sh
index 1c41fc3..af73a2a 100644
--- a/engine/adapters/copilot.sh
+++ b/engine/adapters/copilot.sh
@@ -8,7 +8,9 @@
 #     natively, and the `agents` adapter inlines always-on rule content
 #     into AGENTS.md. We also do not generate .github/copilot-instructions.md
 #     because Copilot bug copilot-cli#489 makes AGENTS.md ignored when
-#     copilot-instructions.md is present.
+#     copilot-instructions.md is present. An always-on rule AGENTS.md does not
+#     carry — a local one, or one whose targets leave `agents` out — becomes
+#     an .instructions.md file with `applyTo: "**"` (decision 0021).
 # Skills: copy skill directories in full to .github/skills/{name}/
 # Agents: -> .github/agents/{name}.agent.md (description, tools, model)
 #
@@ -100,8 +102,8 @@ copilot_paths_rows() {
     ' "$@"
 }
 
-# Sync rules to Copilot format. Only path-scoped rules are emitted —
-# always-on rules live in AGENTS.md (read by Copilot natively).
+# Sync rules to Copilot format. Path-scoped rules are emitted, and an always-on
+# rule only when AGENTS.md (read by Copilot natively) does not carry it.
 sync_copilot_rules() {
     local repo_root="$1"
     local config_file="$2"
@@ -112,18 +114,24 @@ sync_copilot_rules() {
 
     local scoped_count=0
 
-    local i
+    local i always_count=0 spec="" report="" LS=$'\x1e'
     local -a scoped=() scoped_names=()
     output_rel_var "$repo_root" "$instructions_dir"
     source_artifacts_var "$repo_root" "$config_file" rules copilot "$IS_OUTPUT_REL/{}.instructions.md"
     for ((i = 0; i < ${#IS_SOURCE_FILES[@]}; i++)); do
-        [ "${IS_SOURCE_SCOPED[i]}" = 1 ] || continue
-        scoped+=("${IS_SOURCE_FILES[i]}")
-        scoped_names+=("${IS_SOURCE_NAMES[i]}")
+        if [ "${IS_SOURCE_SCOPED[i]}" = 1 ]; then
+            scoped+=("${IS_SOURCE_FILES[i]}")
+            scoped_names+=("${IS_SOURCE_NAMES[i]}")
+        elif [ "${IS_SOURCE_IN_AGENTS[i]}" = 0 ]; then
+            # An always-on rule AGENTS.md does not carry applies everywhere.
+            spec+="${IS_SOURCE_FILES[i]}"$'\x1f'"$instructions_dir/${IS_SOURCE_NAMES[i]}.instructions.md"$'\x1f'"fence_nofm"$'\x1f'"0"$'\x1f'"none"$'\x1f'"${LS}---${LS}applyTo: \"**\"${LS}---${LS}"$'\x1f\n'
+            report+="  rule: ${IS_SOURCE_NAMES[i]}.instructions.md (always-on)"$'\n'
+            always_count=$((always_count + 1))
+        fi
     done
 
     if [ "${#scoped[@]}" -gt 0 ]; then
-        local path base paths_line spec="" report="" LS=$'\x1e'
+        local path base paths_line
         i=0
         while IFS=$'\x1f' read -r path paths_line; do
             base="${scoped_names[i]}"
@@ -139,12 +147,17 @@ sync_copilot_rules() {
             report+="  rule: $base.instructions.md (scoped)"$'\n'
             scoped_count=$((scoped_count + 1))
         done < <(copilot_paths_rows "${scoped[@]}")
-
+    fi
+    if [ -n "$spec" ]; then
         emit_wrapped_bodies "$spec"
         printf '%s' "$report"
     fi
 
-    echo "  rules: $scoped_count scoped"
+    if [ "$always_count" -gt 0 ]; then
+        echo "  rules: $scoped_count scoped, $always_count always-on"
+    else
+        echo "  rules: $scoped_count scoped"
+    fi
 }
 
 # Sync skills to Copilot format (SKILL.md in .github/skills/)
diff --git a/engine/adapters/cursor.sh b/engine/adapters/cursor.sh
index 1165443..24b6993 100644
--- a/engine/adapters/cursor.sh
+++ b/engine/adapters/cursor.sh
@@ -4,10 +4,13 @@
 #
 # Rules:
 #   - Path-scoped (with `paths:`)  -> .cursor/rules/<name>.mdc with `globs:`
-#   - Always-on (no `paths:`)      -> SKIPPED here. Cursor reads AGENTS.md
-#     natively for project-level context, and the `agents` adapter inlines
-#     always-on rule content into AGENTS.md. Generating .mdc copies of the
-#     same rules would cause double-loading and burn the context window.
+#   - Always-on (no `paths:`)      -> SKIPPED here while AGENTS.md carries it.
+#     Cursor reads AGENTS.md natively for project-level context, and the
+#     `agents` adapter inlines always-on rule content into AGENTS.md.
+#     Generating .mdc copies of the same rules would cause double-loading and
+#     burn the context window. An always-on rule AGENTS.md does not carry — a
+#     local one, or one whose targets leave `agents` out — becomes
+#     .cursor/rules/<name>.mdc with `alwaysApply: true` (decision 0021).
 # Skills: copy skill directories in full (SKILL.md + bundled resources)
 # Agents: strip tier/access/tools/disallowedTools, add model + readonly:true
 # Cursor has no per-agent or per-skill effort field (its effort is part of a
@@ -41,30 +44,55 @@ sync_cursor_rules() {
     local config_file="$2"
     local output_dir="$3"
 
-    local i
-    local -a scoped=() scoped_names=()
+    local i always=""
+    local -a files=() names=() kinds=()
     output_rel_var "$repo_root" "$output_dir"
     source_artifacts_var "$repo_root" "$config_file" rules cursor "$IS_OUTPUT_REL/rules/{}.mdc"
-    # Skip always-on rules: AGENTS.md (canonical) carries them.
+    # A scoped rule takes Cursor's own channel. An always-on rule does only
+    # when AGENTS.md, which Cursor reads, does not carry it: a local rule, or
+    # one whose targets leave `agents` out (decision 0021).
     for ((i = 0; i < ${#IS_SOURCE_FILES[@]}; i++)); do
-        [ "${IS_SOURCE_SCOPED[i]}" = 1 ] || continue
-        scoped+=("${IS_SOURCE_FILES[i]}")
-        scoped_names+=("${IS_SOURCE_NAMES[i]}")
+        if [ "${IS_SOURCE_SCOPED[i]}" = 1 ]; then
+            kinds+=(scoped)
+        elif [ "${IS_SOURCE_IN_AGENTS[i]}" = 0 ]; then
+            kinds+=(always-on)
+            always="$always${IS_SOURCE_FILES[i]}"$'\n'
+        else
+            continue
+        fi
+        files+=("${IS_SOURCE_FILES[i]}")
+        names+=("${IS_SOURCE_NAMES[i]}")
     done
-    [ "${#scoped[@]}" -gt 0 ] || return 0
-
-    # Path-scoped rule -> Auto Attached (paths -> globs). The rewrite is
-    # anchored inside the frontmatter block: a body line may legitimately start
-    # with `paths:` (a rule documenting rule syntax does exactly that), and
-    # rewriting it would corrupt the text it teaches.
+    [ "${#files[@]}" -gt 0 ] || return 0
+
+    # Path-scoped rule -> Auto Attached (paths -> globs); always-on rule ->
+    # Always (`alwaysApply: true`), with a frontmatter block of its own when the
+    # source has none. The rewrite is anchored inside the frontmatter block: a
+    # body line may legitimately start with `paths:` (a rule documenting rule
+    # syntax does exactly that), and rewriting it would corrupt the text it
+    # teaches.
     is_fin_awk_vars
-    IS_NAME_MAP="$IS_SOURCE_NAME_MAP" awk "${IS_FIN_V[@]}" -v dst="$output_dir/rules" "$IS_AWK_LIB"'
+    IS_MDC_ALWAYS="$always" IS_NAME_MAP="$IS_SOURCE_NAME_MAP" awk "${IS_FIN_V[@]}" -v dst="$output_dir/rules" "$IS_AWK_LIB"'
+        BEGIN {
+            n = split(ENVIRON["IS_MDC_ALWAYS"], al, "\n")
+            for (k = 1; k <= n; k++) if (al[k] != "") ALWAYS[al[k]] = 1
+        }
         FNR == 1 {
             if (out != "") close(out)
             out = dst "/" art_name(FILENAME) ".mdc"
             fm = 0
+            tgt_reset()
         }
         { sub(/\r$/, "") }
+        FNR == 1 && (FILENAME in ALWAYS) {
+            print fin_line("---") > out
+            print fin_line("alwaysApply: true") > out
+            if ($0 == "---") { fm = 1; next }
+            print fin_line("---") > out
+            fm = 2
+            print fin_line($0) > out
+            next
+        }
         FNR == 1 {
             if ($0 == "---") fm = 1
             print fin_line($0) > out
@@ -72,11 +100,16 @@ sync_cursor_rules() {
             next
         }
         fm == 1 && $0 == "---" { fm = 2; print fin_line($0) > out; next }
+        fm == 1 && tgt_drop($0) { next }
         fm == 1 { sub(/^paths:/, "globs:") }
         { print fin_line($0) > out }
-    ' "${scoped[@]}"
-    for ((i = 0; i < ${#scoped_names[@]}; i++)); do
-        echo "  rule: ${scoped_names[i]}.mdc (scoped)"
+    ' "${files[@]}"
+    for ((i = 0; i < ${#files[@]}; i++)); do
+        # awk never reads a record from an empty source.
+        if [ "${kinds[i]}" = always-on ] && [ ! -s "${files[i]}" ]; then
+            printf -- '---\nalwaysApply: true\n---\n' > "$output_dir/rules/${names[i]}.mdc"
+        fi
+        echo "  rule: ${names[i]}.mdc (${kinds[i]})"
     done
 }
 
@@ -148,6 +181,7 @@ sync_cursor_agents() {
             out = dst "/" art_file(FILENAME, ".md")
             count = 0
             fm = 0
+            tgt_reset()
         }
         /^tier:/  { next }
         /^access:/ { next }
@@ -156,6 +190,7 @@ sync_cursor_agents() {
         { sub(/\r$/, "") }
         FNR == 1 && $0 == "---" { fm = 1 }
         /^---$/ { count++ }
+        fm && count == 1 && !/^---$/ && tgt_drop($0) { next }
         fm && count == 1 && substr($0, 1, 7) == "effort:" { next }
         count == 2 && /^---$/ {
             print fin_line("model: " MODEL[FILENAME]) > out
diff --git a/engine/adapters/pi.sh b/engine/adapters/pi.sh
index 7704ec5..c6734f8 100644
--- a/engine/adapters/pi.sh
+++ b/engine/adapters/pi.sh
@@ -4,6 +4,9 @@
 #
 # Rules:
 #   - Always-on (no `paths:`) -> SKIPPED here. Pi reads AGENTS.md natively.
+#     An always-on rule AGENTS.md does not carry — a local one, or one whose
+#     targets leave `agents` out — goes into the generated extension, which
+#     adds its body to the system prompt (decision 0021).
 #   - Path-scoped (with `paths:`) -> copied to .pi/intelligence-sync/rules/
 #     and surfaced via a generated Pi extension that lists them in the system
 #     prompt so the model can `read` the relevant rule on demand.
@@ -85,6 +88,39 @@ pi_rule_paths_rows() {
     ' "$@"
 }
 
+# pi_rule_body_rows <file>... — one line per file in argument order: its body,
+# without the frontmatter and leading or trailing blank lines, escaped as the
+# contents of a TypeScript double-quoted string (`\`, `"`, tabs and line breaks
+# escaped).
+pi_rule_body_rows() {
+    [ "$#" -gt 0 ] || return 0
+    awk "$IS_AWK_LIB"'
+        function store(   j, first, last, s) {
+            if (cur == "") return
+            first = 0; last = 0
+            for (j = 1; j <= n; j++) if (B[j] != "") { if (!first) first = j; last = j }
+            s = ""
+            for (j = first; first && j <= last; j++) s = s (j > first ? "\\n" : "") B[j]
+            R[cur] = s
+        }
+        FNR == 1 { store(); cur = FILENAME; n = 0; in_fm = 0; past_fm = 0 }
+        { sub(/\r$/, "") }
+        FNR == 1 && $0 != "---" { past_fm = 1 }
+        /^---$/ && !past_fm { in_fm = !in_fm; if (!in_fm) past_fm = 1; next }
+        !past_fm { next }
+        {
+            line = is_repl($0, "\\", "\\\\")
+            line = is_repl(line, "\"", "\\\"")
+            line = is_repl(line, "\t", "\\t")
+            B[++n] = line
+        }
+        END {
+            store()
+            for (i = 1; i < ARGC; i++) print (ARGV[i] in R) ? R[ARGV[i]] : ""
+        }
+    ' "$@"
+}
+
 sync_pi_rules() {
     local repo_root="$1"
     local config_file="$2"
@@ -98,18 +134,34 @@ sync_pi_rules() {
 
     mkdir -p "$rules_root" "$(dirname "$extension_file")"
 
-    local -a scoped=() scoped_names=()
-    local k=0
+    local -a scoped=() scoped_names=() always=() always_names=()
+    local k=0 always_rules=""
     output_rel_var "$repo_root" "$rules_root"
     source_artifacts_var "$repo_root" "$config_file" rules pi "$IS_OUTPUT_REL/{}.md"
     while [ "$k" -lt "${#IS_SOURCE_FILES[@]}" ]; do
         if [ "${IS_SOURCE_SCOPED[k]}" = 1 ]; then
             scoped+=("${IS_SOURCE_FILES[k]}")
             scoped_names+=("${IS_SOURCE_NAMES[k]}")
+        elif [ "${IS_SOURCE_IN_AGENTS[k]}" = 0 ]; then
+            # An always-on rule AGENTS.md does not carry: the extension adds
+            # its body to the system prompt (decision 0021).
+            always+=("${IS_SOURCE_FILES[k]}")
+            always_names+=("${IS_SOURCE_NAMES[k]}")
         fi
         k=$((k + 1))
     done
 
+    if [ "${#always[@]}" -gt 0 ]; then
+        local body
+        k=0
+        while IFS= read -r body; do
+            pi_ts_escape_var "${always_names[k]}"
+            always_rules+="    { name: \"$IS_PI_TS_ESCAPED\", body: \"$body\" },"$'\n'
+            echo "  rule: ${always_names[k]} (always-on, in the extension)"
+            k=$((k + 1))
+        done < <(pi_rule_body_rows "${always[@]}")
+    fi
+
     if [ "${#scoped[@]}" -gt 0 ]; then
         finalize_copy_named "$rules_root" "$IS_SOURCE_NAME_MAP" "${scoped[@]}"
 
@@ -143,7 +195,64 @@ sync_pi_rules() {
         done < <(pi_rule_paths_rows "${scoped[@]}")
     fi
 
-    if [ "$count" -gt 0 ]; then
+    if [ "${#always[@]}" -gt 0 ]; then
+        {
+            cat <<'EOF'
+/**
+ * Generated by intelligence-sync. Do not edit manually.
+ * Adds the always-on project rules AGENTS.md does not carry to the system
+ * prompt, and lists path-scoped project rules generated from intelligence/rules/.
+ */
+
+import type { ExtensionAPI } from "@earendil-works/pi-coding-agent";
+
+const projectRules: Array<{ name: string; body: string }> = [
+EOF
+            printf '%s' "$always_rules"
+            cat <<'EOF'
+];
+
+const scopedRules: Array<{ path: string; patterns: string[] }> = [
+EOF
+            printf '%s' "$manifest"
+            cat <<'EOF'
+];
+
+export default function intelligenceSyncRulesExtension(pi: ExtensionAPI) {
+    pi.on("before_agent_start", async (event) => {
+        let systemPrompt = event.systemPrompt;
+
+        if (projectRules.length > 0) {
+            systemPrompt += `
+
+## Project Rules
+
+${projectRules.map((rule) => rule.body).join("\n\n")}`;
+        }
+
+        if (scopedRules.length > 0) {
+            const rulesList = scopedRules
+                .map((rule) => `- ${rule.path} — paths: ${rule.patterns.join(", ")}`)
+                .join("\n");
+
+            systemPrompt += `
+
+## Scoped Project Rules
+
+AGENTS.md already carries the always-on project rules. Additional path-scoped rules are available on demand:
+
+${rulesList}
+
+When the task touches files that match one of these path patterns, use the read tool to load the relevant rule file before making changes.`;
+        }
+
+        return { systemPrompt };
+    });
+}
+EOF
+        } > "$extension_file"
+        finalize_output_file "$extension_file"
+    elif [ "$count" -gt 0 ]; then
         {
             cat <<'EOF'
 /**
@@ -189,7 +298,11 @@ EOF
         finalize_output_file "$extension_file"
     fi
 
-    echo "  -> Rules: $count scoped"
+    if [ "${#always[@]}" -gt 0 ]; then
+        echo "  -> Rules: $count scoped, ${#always[@]} always-on"
+    else
+        echo "  -> Rules: $count scoped"
+    fi
 }
 
 sync_pi_skills() {
diff --git a/engine/lib/common.sh b/engine/lib/common.sh
index 57649d3..c2f4201 100644
--- a/engine/lib/common.sh
+++ b/engine/lib/common.sh
@@ -89,6 +89,28 @@ IS_AWK_LIB='
         if (p in ART_NAME) return ART_NAME[p]
         b = base_name(p); sub(/\.md$/, "", b); return b
     }
+    # tgt_drop(line) — whether a frontmatter line belongs to `targets:` or
+    # `exclude_targets:` (decision 0021), which select adapters and are
+    # removed from every rendered copy. Call tgt_reset() at the start of each
+    # file and tgt_drop() for each of its frontmatter lines in order: a block
+    # list, or a flow list spanning lines, goes with its key.
+    function tgt_reset() { tgt_cont = "" }
+    function tgt_drop(s,   v) {
+        if (tgt_cont == "block") {
+            if (s ~ /^[ \t]/ || s == "") return 1
+            tgt_cont = ""
+        } else if (tgt_cont == "flow") {
+            if (index(s, "]")) tgt_cont = ""
+            return 1
+        }
+        if (s !~ /^(targets|exclude_targets):/) return 0
+        v = substr(s, index(s, ":") + 1)
+        sub(/[ \t]+#.*$/, "", v)
+        gsub(/^[ \t]+|[ \t]+$/, "", v)
+        if (v == "") tgt_cont = "block"
+        else if (substr(v, 1, 1) == "[" && !index(v, "]")) tgt_cont = "flow"
+        return 1
+    }
 '
 
 # is_fin_awk_vars — fill the global IS_FIN_V array with the -v bindings the
@@ -163,8 +185,15 @@ finalize_copy_named() {
         FNR == 1 {
             if (out_file != "") close(out_file)
             out_file = dst "/" art_file(FILENAME, ".md")
+            tgt_reset()
+        }
+        { sub(/\r$/, "") }
+        FNR == 1 { cp_fm = ($0 == "---") }
+        FNR > 1 && cp_fm == 1 {
+            if ($0 == "---") cp_fm = 2
+            else if (tgt_drop($0)) next
         }
-        { sub(/\r$/, ""); print fin_line($0) > out_file }
+        { print fin_line($0) > out_file }
     ' "$@"
 }
 
@@ -440,6 +469,22 @@ emit_wrapped_bodies() {
     ' "${srcs[@]}"
 }
 
+# emit_rule_bodies <file>... — every rule's body without its frontmatter, in
+# one awk, a blank line after each: how AGENTS.md inlines always-on rules, and
+# how Codex's AGENTS.override.md adds the ones AGENTS.md does not carry.
+emit_rule_bodies() {
+    [ "$#" -gt 0 ] || return 0
+    awk '
+        FNR == 1 { if (NR != 1) print ""; in_fm = 0; past_fm = 0 }
+        { sub(/\r$/, "") }
+        /^---$/ {
+            if (!past_fm) { in_fm = !in_fm; if (!in_fm) { past_fm = 1 }; next }
+        }
+        past_fm || !in_fm { print }
+        END { print "" }
+    ' "$@"
+}
+
 # Copy a markdown file with frontmatter, ensuring free-text string fields are
 # wrapped in double quotes. Used by adapters that feed strict-YAML consumers
 # (Codex CLI rejects unquoted colons / booleans). Idempotent — already-quoted
@@ -740,12 +785,14 @@ _skill_bundles_flush() {
             out_file = FILENAME; line_n = 0
             state = (FILENAME in QUOTE) ? "before" : ""
             effort_seen = 0
+            tgt_reset()
         }
         { sub(/\r$/, "") }
         state == "before" {
             if (FNR == 1 && $0 == "---") state = "in_fm"
             else state = "after"
         }
+        state == "in_fm" && FNR > 1 && $0 != "---" && tgt_drop($0) { next }
         state == "in_fm" && FNR > 1 && substr($0, 1, 7) == "effort:" {
             if (effort_seen++) next
             val = fm_value_strip(substr($0, 8))
@@ -2272,14 +2319,22 @@ read_source_artifact_files() {
 #             name in one directory, or a local and a non-local one anywhere,
 #             refuse the sync: either would change what committed output holds
 #             depending on which file a clone has.
+#   targets   `targets:` lists the adapters an artifact is for, every enabled
+#             one without it; `exclude_targets:` removes adapters from that
+#             set. Both take adapter ids and the group `committed` — every
+#             output path Git tracks — and a local artifact excludes
+#             `committed` implicitly.
 #
 # source_catalog_build fills, in the caller's shell and fail-closed like the
 # listing it reads, one row per source entry in listing order:
 #   IS_CAT_SEC IS_CAT_PATH IS_CAT_NAME IS_CAT_LOCAL IS_CAT_WIN IS_CAT_SCOPED
+#   IS_CAT_HAS_T IS_CAT_T IS_CAT_HAS_X IS_CAT_X
 # (section; the file, or a skill's SKILL.md; the rendered name; 1 when local;
-# 1 when no later source overrides it; 1 for a rule with `paths:`), IS_CAT_N,
-# and IS_CAT_NEED_COMMITTED, 1 when rendering has to know which outputs Git
-# tracks. With IS_SOURCE_FILES_MEMO=1 a second call replays the first.
+# 1 when no later source overrides it; 1 for a rule with `paths:`; whether
+# `targets:` / `exclude_targets:` are set, and their ids, space-separated),
+# IS_CAT_N, and IS_CAT_NEED_COMMITTED, 1 when rendering has to know which
+# outputs Git tracks. With IS_SOURCE_FILES_MEMO=1 a second call replays the
+# first.
 
 # source_artifact_name_var <section> <entry> — IS_ART_NAME and IS_ART_LOCAL for
 # one file (rules, agents) or skill directory (skills) name.
@@ -2298,7 +2353,7 @@ source_artifact_name_var() {
 # shellcheck disable=SC2034  # IS_CAT_NEED_COMMITTED is read by engine/sync.sh
 source_catalog_build() {
     local repo_root="$1" config_file="$2" lint="${3:-}" key section f entry dir name
-    local seen=$'\n' errors="" i n=0 prev rest rows path scoped kind
+    local seen=$'\n' errors="" i n=0 prev rest rows path scoped kind has_t t has_x x
     local -a files=()
     key="$repo_root"$'\n'"$config_file"
     if [ "${IS_SOURCE_FILES_MEMO:-0}" = 1 ] && [ "${IS_CAT_KEY:-}" = "$key" ]; then
@@ -2307,6 +2362,7 @@ source_catalog_build() {
     IS_CAT_KEY=""
     IS_CAT_SEC=(); IS_CAT_PATH=(); IS_CAT_NAME=(); IS_CAT_LOCAL=()
     IS_CAT_WIN=(); IS_CAT_SCOPED=()
+    IS_CAT_HAS_T=(); IS_CAT_T=(); IS_CAT_HAS_X=(); IS_CAT_X=()
     IS_CAT_NEED_COMMITTED=0
     for section in rules agents skills; do
         read_source_artifact_files "$repo_root" "$config_file" "$section"
@@ -2329,6 +2385,7 @@ source_catalog_build() {
             IS_CAT_LOCAL[n]="$IS_ART_LOCAL"
             IS_CAT_WIN[n]=1
             IS_CAT_SCOPED[n]=0
+            IS_CAT_HAS_T[n]=0; IS_CAT_T[n]=""; IS_CAT_HAS_X[n]=0; IS_CAT_X[n]=""
             [ "$IS_ART_LOCAL" = 0 ] || IS_CAT_NEED_COMMITTED=1
             case "$seen" in
                 *$'\n'"$section/$name"$'\t'*)
@@ -2367,12 +2424,15 @@ source_catalog_build() {
             exit 1
         }
         i=0
-        while IFS=$'\x1f' read -r path scoped; do
+        while IFS=$'\x1f' read -r path scoped has_t t has_x x; do
             [ "$i" -lt "$n" ] && [ "$path" = "${IS_CAT_PATH[i]}" ] || {
                 echo "ERROR: cannot read the frontmatter of the sources — refusing to render a partial list." >&2
                 exit 1
             }
             [ "${IS_CAT_SEC[i]}" != rules ] || [ "$scoped" = 0 ] || IS_CAT_SCOPED[i]=1
+            IS_CAT_HAS_T[i]="$has_t"; IS_CAT_T[i]="$t"
+            IS_CAT_HAS_X[i]="$has_x"; IS_CAT_X[i]="$x"
+            case " $t $x " in *" committed "*) IS_CAT_NEED_COMMITTED=1 ;; esac
             i=$((i + 1))
         done <<< "$rows"
         if [ "$i" -ne "$n" ]; then
@@ -2384,30 +2444,101 @@ source_catalog_build() {
 }
 
 # source_frontmatter_scan <lint> <file>... — one row per file in argument
-# order: the path and its `paths:` line count, \x1f-separated, read with
-# frontmatter_index's `paths#` semantics. With <lint> = lint the same pass runs
-# lint_frontmatter_files over every file, its warnings on stderr.
+# order, \x1f-separated: the path; its `paths:` line count, read with
+# frontmatter_index's `paths#` semantics; then for `targets:` and for
+# `exclude_targets:` whether it is set and its ids, space-separated. Both take
+# the list syntax `paths:` takes — a block list or a flow list `[a, b]`, items
+# optionally quoted — and a bare value is a one-item list. The first
+# occurrence of a key wins, and a key with no value at all is not set
+# (`targets: []` is: it is the empty list). With <lint> = lint the same pass
+# runs lint_frontmatter_files over every file, its warnings on stderr.
 source_frontmatter_scan() {
     local do_lint=0
     [ "$1" != lint ] || do_lint=1
     shift
     awk -v levels="$IS_EFFORT_LEVELS" -v do_lint="$do_lint" "$IS_AWK_LIB"'
         BEGIN { SX_US = sprintf("%c", 31) }
-        function sx_store() { if (sx_cur != "") SXR[sx_cur] = sx_cur SX_US sx_paths }
-        FNR == 1 { sx_store(); sx_cur = FILENAME; sx_paths = 0; sx_fm = 0 }
+        function sx_items(s, k,   parts, m, j, v, q) {
+            m = split(s, parts, ",")
+            for (j = 1; j <= m; j++) {
+                v = parts[j]
+                gsub(/^[ \t]+|[ \t]+$/, "", v)
+                q = substr(v, 1, 1)
+                if (length(v) >= 2 && (q == "\"" || q == "\047") && substr(v, length(v), 1) == q)
+                    v = substr(v, 2, length(v) - 2)
+                if (v == "") continue
+                sx_v[k] = (sx_v[k] == "") ? v : sx_v[k] " " v
+                sx_n[k]++
+            }
+        }
+        # The end of a block list: one without an item is a key with no value.
+        function sx_close() {
+            if (sx_mode == "block" && sx_n[sx_list] == 0) sx_has[sx_list] = 0
+            sx_list = ""; sx_mode = ""
+        }
+        function sx_line(l,   c, k, v) {
+            if (sx_mode == "flow") {
+                c = index(l, "]")
+                if (c) { sx_items(substr(l, 1, c - 1), sx_list); sx_list = ""; sx_mode = "" }
+                else sx_items(l, sx_list)
+                return
+            }
+            if (sx_mode == "block") {
+                if (l ~ /^[ \t]+-/) {
+                    v = l
+                    sub(/^[ \t]+-[ \t]*/, "", v)
+                    sub(/[ \t]+#.*$/, "", v)
+                    sx_items(v, sx_list)
+                    return
+                }
+                if (l ~ /^[ \t]*$/ || l ~ /^[ \t]+#/) return
+                sx_close()
+            }
+            c = index(l, ":")
+            if (!c) return
+            k = substr(l, 1, c - 1)
+            if (k == "paths") { sx_paths++; return }
+            if ((k != "targets" && k != "exclude_targets") || sx_seen[k]) return
+            sx_seen[k] = 1; sx_has[k] = 1
+            v = substr(l, c + 1)
+            sub(/[ \t]+#.*$/, "", v)
+            gsub(/^[ \t]+|[ \t]+$/, "", v)
+            if (v == "") { sx_list = k; sx_mode = "block"; return }
+            if (substr(v, 1, 1) == "[") {
+                v = substr(v, 2)
+                c = index(v, "]")
+                if (c) sx_items(substr(v, 1, c - 1), k)
+                else { sx_items(v, k); sx_list = k; sx_mode = "flow" }
+                return
+            }
+            sx_items(v, k)
+        }
+        function sx_store() {
+            if (sx_cur == "") return
+            sx_close()
+            SXR[sx_cur] = sx_cur SX_US sx_paths SX_US sx_has["targets"] SX_US sx_v["targets"] \
+                SX_US sx_has["exclude_targets"] SX_US sx_v["exclude_targets"]
+        }
+        FNR == 1 {
+            sx_store()
+            sx_cur = FILENAME; sx_paths = 0; sx_fm = 0; sx_list = ""; sx_mode = ""
+            sx_seen["targets"] = 0; sx_has["targets"] = 0; sx_v["targets"] = ""; sx_n["targets"] = 0
+            sx_seen["exclude_targets"] = 0; sx_has["exclude_targets"] = 0
+            sx_v["exclude_targets"] = ""; sx_n["exclude_targets"] = 0
+        }
         {
             sx_l = $0
             sub(/\r$/, "", sx_l)
             if (FNR == 1) sx_fm = (sx_l == "---")
             else if (sx_fm == 1) {
-                if (sx_l == "---") sx_fm = 2
-                else if (index(sx_l, ":") && substr(sx_l, 1, index(sx_l, ":") - 1) == "paths") sx_paths++
+                if (sx_l == "---") { sx_close(); sx_fm = 2 }
+                else sx_line(sx_l)
             }
         }
         END {
             sx_store()
             for (sx_i = 1; sx_i < ARGC; sx_i++)
-                print (ARGV[sx_i] in SXR) ? SXR[ARGV[sx_i]] : ARGV[sx_i] SX_US 0
+                print (ARGV[sx_i] in SXR) ? SXR[ARGV[sx_i]] : ARGV[sx_i] SX_US 0 SX_US 0 SX_US SX_US 0 SX_US
         }
         !do_lint { next }
     '"$_IS_AWK_LINT" "$@"
@@ -2462,14 +2593,37 @@ policy_pattern_covers() {
 }
 
 # _cat_member <index> <adapter> <repo-relative output path> — whether the
-# catalog row renders into that adapter's output at that path.
+# catalog row renders into that adapter's output at that path: its targets
+# name the adapter, or `committed` while Git tracks the path, or it has none;
+# its exclusions name neither; and a local row never reaches a tracked path.
 _cat_member() {
-    if [ "${IS_CAT_LOCAL[$1]}" = 1 ]; then
-        ! output_committed "$2" "$3" || return 1
+    local i="$1" a="$2" path="$3"
+    if [ "${IS_CAT_HAS_T[i]}" = 1 ]; then
+        case " ${IS_CAT_T[i]} " in
+            *" $a "*) ;;
+            *" committed "*) output_committed "$a" "$path" || return 1 ;;
+            *) return 1 ;;
+        esac
+    fi
+    if [ "${IS_CAT_HAS_X[i]}" = 1 ]; then
+        case " ${IS_CAT_X[i]} " in *" $a "*) return 1 ;; esac
+        case " ${IS_CAT_X[i]} " in
+            *" committed "*) ! output_committed "$a" "$path" || return 1 ;;
+        esac
+    fi
+    if [ "${IS_CAT_LOCAL[i]}" = 1 ]; then
+        ! output_committed "$a" "$path" || return 1
     fi
     return 0
 }
 
+# _cat_routed <index> — the row selects its adapters: a local artifact, or one
+# with `targets:` or `exclude_targets:`. Every other row renders everywhere,
+# with no question asked.
+_cat_routed() {
+    [ "${IS_CAT_LOCAL[$1]}" = 1 ] || [ "${IS_CAT_HAS_T[$1]}" = 1 ] || [ "${IS_CAT_HAS_X[$1]}" = 1 ]
+}
+
 # source_artifacts_var <repo_root> <config> <section> <adapters> <output>
 # — the artifacts of a section that render for one of <adapters> (space-
 # separated ids) into <output>, a repo-relative path in which `{}` stands for
@@ -2494,14 +2648,19 @@ source_artifacts_var() {
     esac
     for ((i = 0; i < IS_CAT_N; i++)); do
         [ "${IS_CAT_SEC[i]}" = "$section" ] && [ "${IS_CAT_WIN[i]}" = 1 ] || continue
-        if [ "${IS_CAT_LOCAL[i]}" = 1 ]; then
+        if _cat_routed "$i"; then
             case "$output" in *"$ph"*) path="$pre${IS_CAT_NAME[i]}$post" ;; *) path="$output" ;; esac
             member=0
             for a in $adapters; do
                 if _cat_member "$i" "$a" "$path"; then member=1; break; fi
             done
             [ "$member" = 1 ] || continue
-            IS_SOURCE_IN_AGENTS+=(0)
+            # AGENTS.md is always committed, so its path decides nothing.
+            if _cat_member "$i" agents AGENTS.md; then
+                IS_SOURCE_IN_AGENTS+=(1)
+            else
+                IS_SOURCE_IN_AGENTS+=(0)
+            fi
         else
             IS_SOURCE_IN_AGENTS+=(1)
         fi
@@ -2514,6 +2673,161 @@ source_artifacts_var() {
     done
 }
 
+# The checks below run in the engine, after preflight read every enabled
+# contract: IS_ENABLED_ADAPTERS and IS_AGENTS_READERS (the enabled adapters,
+# and those that require `agents` and so read AGENTS.md), IS_OPEN_SKILLS_READERS
+# and IS_ADAPTER_CLAIMS (every enabled adapter's owned and managed paths).
+
+# source_catalog_check_ids <repo_root> <known adapter ids> — refuse a
+# `targets:` or `exclude_targets:` id that is neither an adapter, built-in or
+# the project's, nor `committed`. Every finding is printed before the refusal.
+source_catalog_check_ids() {
+    local repo_root="$1" known=" $2 committed " i id field ids bad=0
+    local -a list=()
+    for ((i = 0; i < IS_CAT_N; i++)); do
+        [ "${IS_CAT_WIN[i]}" = 1 ] || continue
+        for field in targets exclude_targets; do
+            if [ "$field" = targets ]; then
+                [ "${IS_CAT_HAS_T[i]}" = 1 ] || continue
+                ids="${IS_CAT_T[i]}"
+            else
+                [ "${IS_CAT_HAS_X[i]}" = 1 ] || continue
+                ids="${IS_CAT_X[i]}"
+            fi
+            read -r -a list <<< "$ids"
+            for id in "${list[@]+"${list[@]}"}"; do
+                case "$known" in *" $id "*) continue ;; esac
+                echo "ERROR: ${IS_CAT_PATH[i]#"$repo_root"/}: $field names '$id', which is no adapter — use one of: ${2// /, }, or the group committed" >&2
+                bad=1
+            done
+        done
+    done
+    return "$bad"
+}
+
+# _adapter_paths_var <adapter> — IS_AP_PATHS, the adapter's owned and managed
+# paths as preflight registered them.
+_adapter_paths_var() {
+    local a kind p
+    IS_AP_PATHS=()
+    while IFS=$'\t' read -r a kind p; do
+        if [ "$a" = "$1" ] && [ -n "$p" ]; then IS_AP_PATHS+=("$p"); fi
+    done <<< "${IS_ADAPTER_CLAIMS:-}"
+}
+
+# _cat_adapter_member <index> <adapter> — the row renders into any output of
+# the adapter: its set of adapters, read per path.
+_cat_adapter_member() {
+    local p
+    _adapter_paths_var "$2"
+    for p in "${IS_AP_PATHS[@]+"${IS_AP_PATHS[@]}"}"; do
+        if _cat_member "$1" "$2" "$p"; then return 0; fi
+    done
+    return 1
+}
+
+# source_catalog_check_local <repo_root> — refuse a local artifact whose
+# targets name a committed output: `committed` itself, `agents`, or an enabled
+# adapter all of whose paths Git tracks. The source exists in no other clone
+# and not in CI, which render that output without it.
+source_catalog_check_local() {
+    local repo_root="$1" i id p tracked bad=0
+    local -a list=()
+    for ((i = 0; i < IS_CAT_N; i++)); do
+        [ "${IS_CAT_WIN[i]}" = 1 ] && [ "${IS_CAT_LOCAL[i]}" = 1 ] && [ "${IS_CAT_HAS_T[i]}" = 1 ] || continue
+        read -r -a list <<< "${IS_CAT_T[i]}"
+        for id in "${list[@]+"${list[@]}"}"; do
+            tracked=0
+            case "$id" in
+                committed|agents) tracked=1 ;;
+                *)
+                    case " ${IS_ENABLED_ADAPTERS:-} " in *" $id "*) ;; *) continue ;; esac
+                    _adapter_paths_var "$id"
+                    [ "${#IS_AP_PATHS[@]}" -gt 0 ] || continue
+                    tracked=1
+                    for p in "${IS_AP_PATHS[@]}"; do
+                        if ! output_committed "$id" "$p"; then tracked=0; break; fi
+                    done
+                    ;;
+            esac
+            [ "$tracked" = 1 ] || continue
+            echo "ERROR: ${IS_CAT_PATH[i]#"$repo_root"/} is local, but its targets name $id, whose output Git tracks — a local artifact exists in no other clone, so it renders only into ignored output" >&2
+            bad=1
+        done
+    done
+    return "$bad"
+}
+
+# builtin_has_channel <adapter> <always|scoped|agent|skill> — whether a built-in
+# adapter has a channel of its own for that kind of artifact, AGENTS.md aside.
+# A project adapter's channels are its own business: it has one.
+builtin_has_channel() {
+    case "$1:$2" in
+        opencode:always|opencode:scoped|codex:scoped) return 1 ;;
+    esac
+    return 0
+}
+
+# source_catalog_warn <repo_root> — the WARNING: lines for an artifact that
+# selects its adapters (decision 0021): a shared path — AGENTS.md, or
+# .agents/skills/ — that delivers it to an enabled adapter outside its set, and
+# an adapter in its set that no channel reaches. An artifact with neither field
+# nor a `.local` name keeps the routing every sync had, and no new warning.
+source_catalog_warn() {
+    local repo_root="$1" i a rel kind in_agents outside unreach landed what
+    for ((i = 0; i < IS_CAT_N; i++)); do
+        [ "${IS_CAT_WIN[i]}" = 1 ] || continue
+        _cat_routed "$i" || continue
+        rel="${IS_CAT_PATH[i]#"$repo_root"/}"
+        case "${IS_CAT_SEC[i]}" in
+            rules) kind=always; [ "${IS_CAT_SCOPED[i]}" = 0 ] || kind=scoped ;;
+            agents) kind=agent ;;
+            *) kind=skill; rel="${rel%/SKILL.md}/" ;;
+        esac
+        in_agents=0
+        case " ${IS_ENABLED_ADAPTERS:-} " in
+            *" agents "*) if _cat_member "$i" agents AGENTS.md; then in_agents=1; fi ;;
+        esac
+        if [ "$in_agents" = 1 ]; then
+            outside=""
+            for a in ${IS_AGENTS_READERS:-}; do
+                _cat_adapter_member "$i" "$a" || outside="$outside${outside:+, }$a"
+            done
+            if [ -n "$outside" ]; then
+                echo "WARNING: $rel still reaches $outside through AGENTS.md, which they read, although its targets leave them out" >&2
+            fi
+        fi
+        if [ "$kind" = skill ]; then
+            landed=0
+            outside=""
+            for a in ${IS_OPEN_SKILLS_READERS:-}; do
+                if _cat_member "$i" "$a" ".agents/skills/${IS_CAT_NAME[i]}"; then
+                    landed=1
+                else
+                    outside="$outside${outside:+, }$a"
+                fi
+            done
+            if [ "$landed" = 1 ] && [ -n "$outside" ]; then
+                echo "WARNING: $rel still reaches $outside through .agents/skills/, which they read too, although its targets leave them out" >&2
+            fi
+        fi
+        unreach=""
+        for a in ${IS_ENABLED_ADAPTERS:-}; do
+            [ "$a" != agents ] || continue
+            _cat_adapter_member "$i" "$a" || continue
+            if [ "$in_agents" = 1 ]; then
+                case " ${IS_AGENTS_READERS:-} " in *" $a "*) continue ;; esac
+            fi
+            builtin_has_channel "$a" "$kind" || unreach="$unreach${unreach:+, }$a"
+        done
+        if [ -n "$unreach" ]; then
+            what="an always-on rule"
+            [ "$kind" != scoped ] || what="a scoped rule"
+            echo "WARNING: $rel cannot reach $unreach: no channel there carries $what outside AGENTS.md" >&2
+        fi
+    done
+}
+
 # output_rel_var <repo_root> <absolute output path> — IS_OUTPUT_REL, the
 # output's repo-relative path spelled as contracts and source_artifacts_var
 # spell it.
diff --git a/engine/sync.sh b/engine/sync.sh
index d22a3b3..71045a0 100644
--- a/engine/sync.sh
+++ b/engine/sync.sh
@@ -166,6 +166,11 @@ for adapters_dir in "$SCRIPT_DIR/adapters" "$INTELLIGENCE_DIR/adapters"; do
     done
 done
 
+# A `targets:` or `exclude_targets:` id must name an adapter this project has,
+# enabled or not, or the group `committed` (decision 0021). Refused here,
+# before anything is snapshotted or written.
+source_catalog_check_ids "$REPO_ROOT" "${ADAPTERS[*]}" || exit 1
+
 # Validate every selected adapter contract before any output is touched, then
 # snapshot the declared write-set. If a later adapter fails, the EXIT handler
 # restores all earlier adapter outputs so sync is atomic from the repository's
@@ -362,9 +367,12 @@ RENDER_PARALLEL="$SYNC_PARALLEL"
 policy_manifest=""
 [ "$IS_CAT_NEED_COMMITTED" != 1 ] || policy_manifest="$CONFIG_FILE"
 IS_COMMIT_POLICY=""
-# The tools that read .agents/skills/, by their contracts: a skill lands there
-# when it is for any of them.
+# The tools that read .agents/skills/ and AGENTS.md, by their contracts: a
+# skill lands in .agents/skills/ when it is for any of them, and a shared path
+# that delivers an artifact to a tool outside its targets is named.
 IS_OPEN_SKILLS_READERS=""
+IS_AGENTS_READERS=""
+IS_ENABLED_ADAPTERS=""
 preflight_idx=0
 while [ "$preflight_idx" -lt "${#ADAPTERS[@]}" ]; do
     adapter="${ADAPTERS[$preflight_idx]}"
@@ -382,8 +390,10 @@ while [ "$preflight_idx" -lt "${#ADAPTERS[@]}" ]; do
         echo "       Give each adapter its own output: intelligence adapter list" >&2
         exit 1
     fi
+    IS_ENABLED_ADAPTERS="$IS_ENABLED_ADAPTERS${IS_ENABLED_ADAPTERS:+ }$adapter"
     while IFS=$'\t' read -r kind value; do
         case "$kind" in
+            requires) [ "$value" != agents ] || IS_AGENTS_READERS="$IS_AGENTS_READERS${IS_AGENTS_READERS:+ }$adapter" ;;
             ignore|include) IS_COMMIT_POLICY="$IS_COMMIT_POLICY$adapter"$'\t'"$kind"$'\t'"$value"$'\n' ;;
             owned|managed)
                 adapter_contract_rel_path "$value"
@@ -429,6 +439,11 @@ while [ "$preflight_idx" -lt "${#ADAPTERS[@]}" ]; do
 done
 # shellcheck disable=SC2034  # read by output_committed in lib/common.sh
 [ -z "$policy_manifest" ] || IS_COMMIT_POLICY_SET=1
+# A local artifact that names a committed output in its targets is refused
+# before any adapter writes; then every shared path that delivers an artifact
+# beyond its targets, and every target no channel reaches, is named once.
+source_catalog_check_local "$REPO_ROOT" || exit 1
+source_catalog_warn "$REPO_ROOT"
 
 # Every adapter that requires `agents` skips always-on rules because AGENTS.md
 # carries them — and each of those tools reads AGENTS.md at the workspace root
diff --git a/intelligence/rules/engine.md b/intelligence/rules/engine.md
index 4d2b751..7df2ef1 100644
--- a/intelligence/rules/engine.md
+++ b/intelligence/rules/engine.md
@@ -55,16 +55,22 @@ one directory or a local and a non-local one anywhere. A local artifact
 (`*.local.md`, a `*.local/` skill) reaches only an output path its adapter's
 contract ignores, so an adapter passes the real path it writes: one that globs
 sources itself, or names a path it does not write, can put a teammate's local file
-into a committed output. Only a catalog holding a local artifact makes the engine
-read contracts with the manifest; every other sync keeps decision 0020's
-ownership-only read.
+into a committed output. `targets:` and `exclude_targets:` narrow an artifact's
+adapters the same way, per path for the group `committed`; the engine refuses an
+unknown id and a local artifact naming a committed output, and warns about shared
+paths, before any adapter writes. Only a catalog holding a local artifact or
+naming `committed` makes the engine read contracts with the manifest; every other
+sync keeps decision 0020's ownership-only read.
 
 ## Rule routing
 
 Always-on rules are inlined once into `AGENTS.md`. Cursor, Copilot, Codex, Pi and
 OpenCode consume that file, so their adapters omit always-on rules from tool-specific
 channels; path-scoped rules use native channels where those exist. Claude Code does
-not consume `AGENTS.md`, so its adapter receives every rule.
+not consume `AGENTS.md`, so its adapter receives every rule. An always-on rule
+`AGENTS.md` does not carry (`IS_SOURCE_IN_AGENTS` is 0: local, or targeted away
+from `agents`) takes each tool's own always-on channel instead — Codex's is
+`AGENTS.override.md`, Pi's its rules extension, and OpenCode has none.
 
 The `agents` target is therefore required whenever an enabled target relies on
 `AGENTS.md`. Adding an adapter means updating that list in `engine/sync.sh` in the
diff --git a/packages/sync/references/adapters.md b/packages/sync/references/adapters.md
index 1f7eb00..949a9d6 100644
--- a/packages/sync/references/adapters.md
+++ b/packages/sync/references/adapters.md
@@ -153,11 +153,14 @@ for ((i = 0; i < ${#IS_SOURCE_FILES[@]}; i++)); do
 done
 ```
 
-The last argument is the repository-relative path an artifact lands at, `{}` standing for its name. The catalog lists sources in manifest order and each directory's entries in byte order, and settles three things before any adapter runs:
+The last argument is the repository-relative path an artifact lands at, `{}` standing for its name. The catalog lists sources in manifest order and each directory's entries in byte order, and settles four things before any adapter runs:
 
 - **Names.** An artifact is named by its file name without a leading `.`, `.md` and a trailing `.local`, a skill by its directory name without the leading `.` and `.local`: `.draft.md` renders as `draft`, `deploy.local/` as `deploy/`. Write each output under `IS_SOURCE_NAMES`, never under the source file name; `finalize_copy_named` and `copy_skill_bundle_dirs_named` take the `IS_SOURCE_NAME_MAP` the call leaves.
 - **Overrides.** Of two artifacts with one name, only the later source's is listed. Package sources are wired before project sources, so project content overrides a package artifact by name. Two of one name in one directory, or a local and a non-local one anywhere, refuse the sync before any adapter runs.
 - **Local artifacts.** A `*.local.md` rule or agent and a `*.local/` skill are listed only for an output path no `ignore` record of your contract covers — what Git tracks never holds one. That is why the path must be the real one: an adapter that globs sources itself, or names a path it does not write, can put a teammate's local file into a committed output.
+- **Targets.** An artifact whose `targets:` leaves your adapter out, or whose `exclude_targets:` names it, is not listed for it; `committed` in either field is resolved against the path you pass ([Selecting adapters](conventions.md#selecting-adapters)). Your adapter's id is a valid target as soon as its file exists, and sync has removed both fields from every copy the shared helpers write; strip them from any frontmatter you copy yourself.
+
+`IS_SOURCE_IN_AGENTS` is 1 when `AGENTS.md` carries the artifact too. An adapter whose tool reads `AGENTS.md` renders an always-on rule only where it is 0: that is a local rule, or one whose targets leave `agents` out, and the tool's own always-on channel is the only way it arrives.
 
 ## Shared functions
 
@@ -200,18 +203,20 @@ Prefer the batched forms inside per-file loops: a process spawn costs tens of mi
 
 Rules without `paths:` are always-on. Rules with `paths:` are scoped.
 
-Intelligence routes always-on rules once through `AGENTS.md` for tools that consume it. An adapter for such a tool should not copy those rules again. If the tool has a native scoped-rule channel, transform `paths:` to the tool's equivalent.
+Intelligence routes always-on rules once through `AGENTS.md` for tools that consume it. An adapter for such a tool should not copy those rules again — except one `AGENTS.md` does not carry (`IS_SOURCE_IN_AGENTS` is 0), which reaches the tool only through its own always-on channel. If the tool has a native scoped-rule channel, transform `paths:` to the tool's equivalent.
 
-| Built-in | Always-on rules | Scoped rules |
-|---|---|---|
-| `agents` | Inline in `AGENTS.md` | List with links |
-| `antigravity` | Omit; reads `AGENTS.md` | `.agents/rules/*.md` with `trigger: glob` and `globs:` |
-| `claude` | Copy | Copy with `paths:` preserved |
-| `cursor` | Omit; reads `AGENTS.md` | `.mdc` with `globs:` |
-| `copilot` | Omit; reads `AGENTS.md` | `.instructions.md` with `applyTo:` |
-| `codex` | Omit; reads `AGENTS.md` | No native channel |
-| `pi` | Omit; reads `AGENTS.md` | Generated on-demand files and extension |
-| `opencode` | Omit; reads `AGENTS.md` | No native channel |
+| Built-in | Always-on rules | Always-on, not in `AGENTS.md` | Scoped rules |
+|---|---|---|---|
+| `agents` | Inline in `AGENTS.md` | — | List with links |
+| `antigravity` | Omit; reads `AGENTS.md` | `.agents/rules/*.md` with `trigger: always_on` | `.agents/rules/*.md` with `trigger: glob` and `globs:` |
+| `claude` | Copy | Copy | Copy with `paths:` preserved |
+| `cursor` | Omit; reads `AGENTS.md` | `.mdc` with `alwaysApply: true` | `.mdc` with `globs:` |
+| `copilot` | Omit; reads `AGENTS.md` | `.instructions.md` with `applyTo: "**"` | `.instructions.md` with `applyTo:` |
+| `codex` | Omit; reads `AGENTS.md` | `AGENTS.override.md`: all of `AGENTS.md` plus these rules | No native channel |
+| `pi` | Omit; reads `AGENTS.md` | Added to the system prompt by the generated extension | Generated on-demand files and extension |
+| `opencode` | Omit; reads `AGENTS.md` | No channel; sync warns | No native channel |
+
+Codex reads `AGENTS.override.md` instead of `AGENTS.md` in the same directory, so the Codex adapter writes it — the whole rendered `AGENTS.md`, then the rules only Codex receives — while such a rule exists, and removes it when none does. Its contract manages and ignores the path; a file there that Intelligence did not generate is never touched, and a render that needs the path refuses until it is moved.
 
 If a new adapter relies on `AGENTS.md` for always-on rules, its target must require `agents`. Add that invariant to `engine/sync.sh` when contributing the adapter upstream.
 
@@ -371,6 +376,6 @@ For a built-in adapter, add the same assertions to the repository's smoke or lif
 | `claude` | `.claude/rules`, `.claude/agents`, `.claude/skills` |
 | `cursor` | `.cursor/rules`, `.cursor/agents`, `.cursor/skills` |
 | `copilot` | `.github/instructions`, `.github/agents`, `.github/skills` |
-| `codex` | `.codex/agents`, `.agents/skills` |
+| `codex` | `.codex/agents`, `.agents/skills`, marker-owned `AGENTS.override.md` |
 | `pi` | `.pi/intelligence-sync`, `.pi/extensions`, `.pi/prompts`, `.agents/skills` |
 | `opencode` | `.opencode/agents`, marker-owned `.opencode/commands`, `.agents/skills` |
diff --git a/packages/sync/references/conventions.md b/packages/sync/references/conventions.md
index 68069ee..2033153 100644
--- a/packages/sync/references/conventions.md
+++ b/packages/sync/references/conventions.md
@@ -178,7 +178,24 @@ intelligence/agents/*.local.md
 intelligence/skills/*.local/
 ```
 
-Sync renders a local artifact only into outputs Git ignores, and never into one it tracks: not `AGENTS.md`, not OpenCode's slash commands, not Copilot's output under `commit_output: true`. A clone without the file therefore renders the same committed files, and `intelligence sync --check` passes in CI. A local always-on rule reaches Claude Code only, because every other tool reads always-on rules from `AGENTS.md`; local scoped rules, agents and skills reach every enabled tool. `intelligence status --check` reports a missing pattern, and `intelligence init` restores it.
+Sync renders a local artifact only into outputs Git ignores, and never into one it tracks: not `AGENTS.md`, not OpenCode's slash commands, not Copilot's output under `commit_output: true`. A clone without the file therefore renders the same committed files, and `intelligence sync --check` passes in CI. A local always-on rule reaches each tool through that tool's own always-on channel (see [Routing](#routing)), since `AGENTS.md` cannot carry it; OpenCode has none, and sync says so. `intelligence status --check` reports a missing pattern, and `intelligence init` restores it.
+
+## Selecting adapters
+
+Every rule, agent and skill renders to every enabled adapter. Two frontmatter fields narrow that, for guidance that matters to one tool or should cost no other tool context:
+
+```yaml
+---
+targets: [claude, cursor]      # only these adapters; without it, every enabled one
+exclude_targets: [committed]   # remove these from that set
+---
+```
+
+Both take adapter ids — built-in or the project's own — and the group `committed`: every output path Git tracks, resolved per path from each adapter's contract. `AGENTS.md` always belongs to it, and so do OpenCode's slash commands and, under `commit_output: true`, Copilot's output; OpenCode's agents and the shared `.agents/skills/` do not. Write them in the list syntax `paths:` takes — a flow list `[a, b]` or a block list — and in `SKILL.md` for a skill. `targets: []` renders the artifact nowhere. Sync removes both fields from every generated copy.
+
+An id that names no adapter refuses the sync. An adapter that is not enabled is simply no target: enablement stays the manifest's decision. A local artifact excludes `committed` already, and one whose `targets` names a committed output — `agents`, `committed`, or an adapter all of whose output Git tracks — refuses the sync, because every other clone and CI render that output without it.
+
+Two paths are shared, not per tool, and a filter can withhold an artifact from a shared path but never from one of its readers. An artifact whose set contains `agents` goes into `AGENTS.md` and reaches every tool that reads it. A skill whose set contains any reader of `.agents/skills/` — Antigravity, Codex, Pi, OpenCode — lands there for all of them. Sync prints a `WARNING:` line when a shared path delivers an artifact to an enabled adapter outside its set, and when an adapter in its set can receive it through no channel. An artifact with neither field nor a `.local` name keeps the routing, and the warnings, it always had.
 
 ## Agent conventions
 
@@ -262,9 +279,12 @@ Rule content in Markdown.
 |---|---|---|---|---|---|
 | Scoped | copied with `paths:` | `.mdc` with `globs:` | `.md` with `trigger: glob` and `globs:` | `.instructions.md` with `applyTo:` | listed in `AGENTS.md`; Pi also gets on-demand files and an extension |
 | Always-on | copied | omitted | omitted | omitted | inlined once into `AGENTS.md` |
+| Always-on, not in `AGENTS.md` | copied | `.mdc` with `alwaysApply: true` | `.md` with `trigger: always_on` | `.instructions.md` with `applyTo: "**"` | Codex: `AGENTS.override.md`; Pi: added to the system prompt by its extension; OpenCode: none |
 
 Cursor, Copilot, Codex, Pi, OpenCode and Antigravity consume `AGENTS.md`, so always-on rules are not duplicated in their tool-specific channels. Claude does not consume `AGENTS.md`, so it receives the full rule set. OpenCode and Codex have no generated path-scoped rule channel; OpenCode users may configure `instructions:` globs themselves.
 
+An always-on rule `AGENTS.md` does not carry — a local one, or one whose set leaves `agents` out (see [Selecting adapters](#selecting-adapters)) — reaches each tool in its set through that tool's own channel instead, the last row. Codex reads `AGENTS.override.md` instead of `AGENTS.md` in the same directory, so the file holds the whole `AGENTS.md` plus the rules only Codex receives; it is ignored, exists only while such a rule does, and one Intelligence did not generate is never touched. Antigravity's `trigger: always_on` belongs to the same undocumented key family as its `trigger: glob`. OpenCode reads instructions only from `AGENTS.md` or its committed `opencode.json`, so it can receive neither a local nor a tool-targeted always-on rule.
+
 Keep always-on rules small. Put narrow framework or component guidance behind `paths:` so unrelated tasks do not pay its context cost.
 
 ## Skill conventions
@@ -286,7 +306,7 @@ argument-hint: "<route-name>"
 4. Report the changed route and verification.
 ```
 
-Standard optional fields (`license`, `compatibility`, `metadata`, `allowed-tools`) and tool extensions pass through unchanged. A tool ignores fields it does not understand. `effort:` is the exception: sync renders it per tool, as [Effort mappings](#effort-mappings) describes.
+Standard optional fields (`license`, `compatibility`, `metadata`, `allowed-tools`) and tool extensions pass through unchanged. A tool ignores fields it does not understand. `effort:` is the exception: sync renders it per tool, as [Effort mappings](#effort-mappings) describes. `targets:` and `exclude_targets:` select the adapters that receive the skill and are removed from every copy ([Selecting adapters](#selecting-adapters)).
 
 `disable-model-invocation: true` makes a skill one only the owner starts, as a slash command: use it for a procedure that changes versions, the lock or generated outputs, where an agent selecting it unasked is the failure. Claude Code, Cursor and Copilot read the field itself; Codex does not, so sync writes `agents/openai.yaml` with `allow_implicit_invocation: false` beside the skill in `.agents/skills/`. Keep the source to the field. A skill that ships its own `agents/openai.yaml` keeps everything else in it: sync adds the policy when the file sets none, and refuses one that sets it otherwise or not as a plain `allow_implicit_invocation: false` directly under `policy:`.
 
@@ -354,12 +374,12 @@ Every line enters a finite context budget. Prefer subtraction, consolidation and
 | Target | Rules | Skills | Agents |
 |---|---|---|---|
 | `agents` | Always-on inlined; scoped listed in `AGENTS.md` | Listed | Listed |
-| Antigravity | `AGENTS.md` plus scoped `.agents/rules/*.md` | `.agents/skills/` | `.agents/agents/*.md` |
+| Antigravity | `AGENTS.md` plus `.agents/rules/*.md` | `.agents/skills/` | `.agents/agents/*.md` |
 | Claude | `.claude/rules/` | `.claude/skills/` | `.claude/agents/` |
-| Cursor | scoped `.cursor/rules/*.mdc` | `.cursor/skills/` | `.cursor/agents/` |
-| Copilot | scoped `.github/instructions/*.instructions.md` | `.github/skills/` | `.github/agents/` |
-| Codex | `AGENTS.md` only | `.agents/skills/` | `.codex/agents/*.toml` |
-| Pi | `AGENTS.md` plus scoped `.pi/intelligence-sync/rules/` | `.agents/skills/` | `.pi/prompts/intelligence-agent-*.md` |
+| Cursor | `AGENTS.md` plus `.cursor/rules/*.mdc` | `.cursor/skills/` | `.cursor/agents/` |
+| Copilot | `AGENTS.md` plus `.github/instructions/*.instructions.md` | `.github/skills/` | `.github/agents/` |
+| Codex | `AGENTS.md`, or `AGENTS.override.md` while a rule needs it | `.agents/skills/` | `.codex/agents/*.toml` |
+| Pi | `AGENTS.md` plus scoped `.pi/intelligence-sync/rules/` and its extension | `.agents/skills/` | `.pi/prompts/intelligence-agent-*.md` |
 | OpenCode | `AGENTS.md` only | `.agents/skills/` plus slash commands | `.opencode/agents/*.md` |
 
 `AGENTS.md` is regenerated by the `agents` adapter. Its optional static header is `targets.agents.header` in `intelligence.yaml`; generated rule, agent and skill sections follow it. Commit `AGENTS.md` when it is the project's shared canonical context.
@@ -395,6 +415,7 @@ GEMINI.md
 .agents/rules/
 .agents/agents/
 .codex/agents/
+AGENTS.override.md
 
 # Generated Pi content
 .pi/intelligence-sync/
diff --git a/packages/sync/rules/intelligence-authoring.md b/packages/sync/rules/intelligence-authoring.md
index 4c99c7c..a32f51e 100644
--- a/packages/sync/rules/intelligence-authoring.md
+++ b/packages/sync/rules/intelligence-authoring.md
@@ -48,7 +48,7 @@ The mistakes that actually happen, in order of frequency:
 
 ## Rules
 
-**Scope with `paths:`.** A rule without `paths:` is loaded into *every* session and inlined into `AGENTS.md` — the most expensive context real estate there is. Earn it. A rule that only matters when someone touches the frontend belongs scoped to the frontend.
+**Scope with `paths:`.** A rule without `paths:` is loaded into *every* session and inlined into `AGENTS.md` — the most expensive context real estate there is. Earn it. A rule that only matters when someone touches the frontend belongs scoped to the frontend. Guidance about one tool belongs to that tool: `targets: [claude]` keeps it out of every other tool's context. A rule whose targets leave `agents` out also leaves `AGENTS.md`, and sync names any tool that can then no longer receive it.
 
 **Lead with the positive default, then the invariant.** The model acts on the first instruction it reads, and it follows whatever is named — negation ("never do X") draws attention to X. Reserve absolute language (NEVER, MUST) for true must-nots: safety, security, output format. A judgement call written as a NEVER only teaches the model that NEVERs are negotiable.
 

From 97d8d0a0e3f4344e59d2b93506b5daddfd093a4f Mon Sep 17 00:00:00 2001
From: Dmitrij Zykovic <dmitrij.zykovic@ainovasystems.com>
Date: Sun, 11 Oct 2026 21:03:42 +0300
Subject: [PATCH 4/8] Recorded that decision 0021 lands in one pull request in
 two stages

---
 decisions/0021-local-and-targeted-source-artifacts.md | 7 ++++---
 1 file changed, 4 insertions(+), 3 deletions(-)

diff --git a/decisions/0021-local-and-targeted-source-artifacts.md b/decisions/0021-local-and-targeted-source-artifacts.md
index 8486386..cd37c05 100644
--- a/decisions/0021-local-and-targeted-source-artifacts.md
+++ b/decisions/0021-local-and-targeted-source-artifacts.md
@@ -97,9 +97,10 @@ later source win.
 8. **One enumeration.** `AGENTS.md`, every built-in adapter and the adapter
    template read sources through one function that applies the name rule,
    overrides, locality and the target set; the per-adapter globs go.
-9. The work lands in two changes: local artifacts with `committed` and the
-   single enumeration (items 1–3, 5, 6, 8), then the fields, the new
-   always-on channels and the shared-path warnings (items 4 and 7).
+9. The work lands in one pull request, in two stages of commits: local
+   artifacts with `committed` and the single enumeration first (items 1–3, 5,
+   6, 8), then the fields, the new always-on channels and the shared-path
+   warnings (items 4 and 7).
 
 ## Consequences
 

From 1730712504ea50b3e0743525c37647b1931ed798 Mon Sep 17 00:00:00 2001
From: Dmitrij Zykovic <dmitrij.zykovic@ainovasystems.com>
Date: Sun, 11 Oct 2026 21:07:38 +0300
Subject: [PATCH 5/8] Applied the local artifact and Codex override ignore
 patterns to this repository

---
 .gitignore | 4 ++++
 1 file changed, 4 insertions(+)

diff --git a/.gitignore b/.gitignore
index 7a1e8e7..9ee87b1 100644
--- a/.gitignore
+++ b/.gitignore
@@ -25,3 +25,7 @@ GEMINI.md
 .agents/agents/
 !.claude/
 .antigravity.md
+intelligence/rules/*.local.md
+intelligence/agents/*.local.md
+intelligence/skills/*.local/
+AGENTS.override.md

From a35c6980fceabaa74fb349755cf70d6ea6c6df1f Mon Sep 17 00:00:00 2001
From: Dmitrij Zykovic <dmitrij.zykovic@ainovasystems.com>
Date: Sun, 11 Oct 2026 21:07:39 +0300
Subject: [PATCH 6/8] Moved the pending version to 0.21.0 for local and
 targeted source artifacts

---
 CHANGELOG.md                                  | 29 +++++++++++++++++++
 engine/VERSION                                |  2 +-
 examples/cli-project/intelligence.yaml        |  4 +--
 .../intelligence.lock                         |  6 ++--
 .../intelligence.yaml                         |  4 +--
 .../go-api-with-antigravity/intelligence.lock |  6 ++--
 .../go-api-with-antigravity/intelligence.yaml |  4 +--
 .../go-api-with-opencode/intelligence.lock    |  6 ++--
 .../go-api-with-opencode/intelligence.yaml    |  4 +--
 .../intelligence.lock                         |  6 ++--
 .../intelligence.yaml                         |  4 +--
 examples/go-api/intelligence.lock             |  6 ++--
 examples/go-api/intelligence.yaml             |  4 +--
 .../intelligence.lock                         |  6 ++--
 .../intelligence.yaml                         |  4 +--
 examples/with-remote-skills/intelligence.yaml |  4 +--
 intelligence.lock                             |  6 ++--
 intelligence.yaml                             |  4 +--
 18 files changed, 69 insertions(+), 40 deletions(-)

diff --git a/CHANGELOG.md b/CHANGELOG.md
index ec9decc..9c67ced 100644
--- a/CHANGELOG.md
+++ b/CHANGELOG.md
@@ -4,6 +4,35 @@ All notable changes to Intelligence are recorded here.
 
 Legacy Intelligence Sync history remains in its [archive](https://github.com/ainova-systems/intelligence-sync/blob/main/CHANGELOG.md).
 
+## [0.21.0]
+
+### Added
+
+- Local rules, agents and skills: a `*.local.md` rule or agent and a `*.local/` skill directory in the content directory render only into outputs Git ignores, never into `AGENTS.md` or another tracked output, so every clone and CI render the same committed files; `.environment.local.md` renders as `environment` (decision 0021).
+- `intelligence init` writes `<content-dir>/rules/*.local.md`, `<content-dir>/agents/*.local.md` and `<content-dir>/skills/*.local/` into the managed `.gitignore` block, and `status --check` reports one missing.
+- `targets:` and `exclude_targets:` in a rule's, agent's or `SKILL.md`'s frontmatter select the adapters it renders for: adapter ids and the group `committed` (every output Git tracks), in the list syntax `paths:` takes. `targets: []` renders nowhere, an unknown id or a local artifact naming a committed output refuses the sync, and both fields are removed from every generated copy (decision 0021).
+- An always-on rule `AGENTS.md` does not carry — a local one, or one whose targets leave `agents` out — reaches each tool through its own channel: Cursor `.mdc` with `alwaysApply: true`, Copilot `.instructions.md` with `applyTo: "**"`, Antigravity `trigger: always_on`, Pi's rules extension, and Codex `AGENTS.override.md`, which holds all of `AGENTS.md` plus those rules, is ignored, and exists only while such a rule does (decision 0021).
+- Sync prints a `WARNING:` line when `AGENTS.md` or `.agents/skills/` delivers a local or targeted artifact to an enabled tool outside its targets, and when a tool in its targets has no channel for it — OpenCode for an always-on rule outside `AGENTS.md`.
+
+### Changed
+
+- `AGENTS.md`, every built-in adapter and the adapter template read sources through one catalog (`source_artifacts_var`): an artifact is named without a leading `.`, `.md` and a trailing `.local`, so a dotfile source renders in every adapter under that name, not only in `AGENTS.md` (decision 0021).
+- A skill a later source overrides is replaced whole in every skill tree; its earlier version's resources no longer merge into the copy.
+- Two artifacts with one name in one source directory (`x.md` beside `.x.md`), and a local and a non-local artifact with one name in any sources, refuse the sync before any output is touched, naming both files.
+- Pi's scoped-rule extension lists rules in byte order, as `AGENTS.md` does, instead of the locale's glob order.
+- The Codex contract manages and ignores `AGENTS.override.md`; with Codex enabled, run `intelligence init` once to add the pattern.
+
+### Fixed
+
+- `AGENTS.md` listed and inlined a same-named rule, agent or skill once per source while every other adapter rendered only the later one; it now applies the same override (decision 0021).
+- A rule or agent that is a symlink to a file is listed in `AGENTS.md`, as every other adapter already rendered it.
+
+### Breaking
+
+- [ ] No source directory holds two artifacts whose names differ only by a leading `.` or a trailing `.local`, and no artifact name is both local and committed across the sources: `intelligence sync` succeeds.
+- [ ] The CLI-managed block of `.gitignore` lists `<content-dir>/rules/*.local.md`, `<content-dir>/agents/*.local.md` and `<content-dir>/skills/*.local/`, and `AGENTS.override.md` when Codex is enabled — run `intelligence init` to apply it.
+- [ ] `intelligence status --check` exits 0.
+
 ## [0.20.0]
 
 ### Added
diff --git a/engine/VERSION b/engine/VERSION
index 5a03fb7..8854156 100644
--- a/engine/VERSION
+++ b/engine/VERSION
@@ -1 +1 @@
-0.20.0
+0.21.0
diff --git a/examples/cli-project/intelligence.yaml b/examples/cli-project/intelligence.yaml
index 7974bf4..d4c4725 100644
--- a/examples/cli-project/intelligence.yaml
+++ b/examples/cli-project/intelligence.yaml
@@ -11,7 +11,7 @@
 project:
   name: cli-project
 
-schema_version: "0.20.0"
+schema_version: "0.21.0"
 
 # Package sources come first, project sources last: adapters copy in order
 # and the last write wins, so a project file overrides a same-named package
@@ -39,7 +39,7 @@ targets:
 # aliases.
 packages:
   "@ainova-systems/sync":
-    version: "0.20.0"
+    version: "0.21.0"
   "@ainova-systems/core":
     version: "^0.3.0"
 
diff --git a/examples/dotnet-api-with-react-frontend/intelligence.lock b/examples/dotnet-api-with-react-frontend/intelligence.lock
index b7278b0..22144e3 100644
--- a/examples/dotnet-api-with-react-frontend/intelligence.lock
+++ b/examples/dotnet-api-with-react-frontend/intelligence.lock
@@ -1,10 +1,10 @@
 # Generated by the intelligence CLI. Do not edit.
 lockfile_version: 1
-engine_version: "0.20.0"
+engine_version: "0.21.0"
 packages:
   "@ainova-systems/sync":
-    requested: "0.20.0"
+    requested: "0.21.0"
     url: "https://github.com/ainova-systems/intelligence.git"
     path: "packages/sync"
-    resolved: "v0.20.0"
+    resolved: "v0.21.0"
     sha: ""
diff --git a/examples/dotnet-api-with-react-frontend/intelligence.yaml b/examples/dotnet-api-with-react-frontend/intelligence.yaml
index d75ae93..a97f23e 100644
--- a/examples/dotnet-api-with-react-frontend/intelligence.yaml
+++ b/examples/dotnet-api-with-react-frontend/intelligence.yaml
@@ -6,7 +6,7 @@
 project:
   name: my-platform
 
-schema_version: "0.20.0"
+schema_version: "0.21.0"
 
 sources:
   rules:
@@ -50,4 +50,4 @@ ignore:
 # and restored offline from the CLI bundle.
 packages:
   "@ainova-systems/sync":
-    version: "0.20.0"
+    version: "0.21.0"
diff --git a/examples/go-api-with-antigravity/intelligence.lock b/examples/go-api-with-antigravity/intelligence.lock
index b7278b0..22144e3 100644
--- a/examples/go-api-with-antigravity/intelligence.lock
+++ b/examples/go-api-with-antigravity/intelligence.lock
@@ -1,10 +1,10 @@
 # Generated by the intelligence CLI. Do not edit.
 lockfile_version: 1
-engine_version: "0.20.0"
+engine_version: "0.21.0"
 packages:
   "@ainova-systems/sync":
-    requested: "0.20.0"
+    requested: "0.21.0"
     url: "https://github.com/ainova-systems/intelligence.git"
     path: "packages/sync"
-    resolved: "v0.20.0"
+    resolved: "v0.21.0"
     sha: ""
diff --git a/examples/go-api-with-antigravity/intelligence.yaml b/examples/go-api-with-antigravity/intelligence.yaml
index 26f8201..473bbfd 100644
--- a/examples/go-api-with-antigravity/intelligence.yaml
+++ b/examples/go-api-with-antigravity/intelligence.yaml
@@ -6,7 +6,7 @@
 project:
   name: my-api
 
-schema_version: "0.20.0"
+schema_version: "0.21.0"
 
 sources:
   rules:
@@ -36,4 +36,4 @@ targets:
 # and restored offline from the CLI bundle.
 packages:
   "@ainova-systems/sync":
-    version: "0.20.0"
+    version: "0.21.0"
diff --git a/examples/go-api-with-opencode/intelligence.lock b/examples/go-api-with-opencode/intelligence.lock
index b7278b0..22144e3 100644
--- a/examples/go-api-with-opencode/intelligence.lock
+++ b/examples/go-api-with-opencode/intelligence.lock
@@ -1,10 +1,10 @@
 # Generated by the intelligence CLI. Do not edit.
 lockfile_version: 1
-engine_version: "0.20.0"
+engine_version: "0.21.0"
 packages:
   "@ainova-systems/sync":
-    requested: "0.20.0"
+    requested: "0.21.0"
     url: "https://github.com/ainova-systems/intelligence.git"
     path: "packages/sync"
-    resolved: "v0.20.0"
+    resolved: "v0.21.0"
     sha: ""
diff --git a/examples/go-api-with-opencode/intelligence.yaml b/examples/go-api-with-opencode/intelligence.yaml
index f980b2b..1e5ccc9 100644
--- a/examples/go-api-with-opencode/intelligence.yaml
+++ b/examples/go-api-with-opencode/intelligence.yaml
@@ -5,7 +5,7 @@
 project:
   name: my-api
 
-schema_version: "0.20.0"
+schema_version: "0.21.0"
 
 sources:
   rules:
@@ -35,4 +35,4 @@ targets:
 # and restored offline from the CLI bundle.
 packages:
   "@ainova-systems/sync":
-    version: "0.20.0"
+    version: "0.21.0"
diff --git a/examples/go-api-with-pi-and-codex/intelligence.lock b/examples/go-api-with-pi-and-codex/intelligence.lock
index b7278b0..22144e3 100644
--- a/examples/go-api-with-pi-and-codex/intelligence.lock
+++ b/examples/go-api-with-pi-and-codex/intelligence.lock
@@ -1,10 +1,10 @@
 # Generated by the intelligence CLI. Do not edit.
 lockfile_version: 1
-engine_version: "0.20.0"
+engine_version: "0.21.0"
 packages:
   "@ainova-systems/sync":
-    requested: "0.20.0"
+    requested: "0.21.0"
     url: "https://github.com/ainova-systems/intelligence.git"
     path: "packages/sync"
-    resolved: "v0.20.0"
+    resolved: "v0.21.0"
     sha: ""
diff --git a/examples/go-api-with-pi-and-codex/intelligence.yaml b/examples/go-api-with-pi-and-codex/intelligence.yaml
index d2c89be..e66add5 100644
--- a/examples/go-api-with-pi-and-codex/intelligence.yaml
+++ b/examples/go-api-with-pi-and-codex/intelligence.yaml
@@ -5,7 +5,7 @@
 project:
   name: my-api
 
-schema_version: "0.20.0"
+schema_version: "0.21.0"
 
 sources:
   rules:
@@ -36,4 +36,4 @@ targets:
 # and restored offline from the CLI bundle.
 packages:
   "@ainova-systems/sync":
-    version: "0.20.0"
+    version: "0.21.0"
diff --git a/examples/go-api/intelligence.lock b/examples/go-api/intelligence.lock
index b7278b0..22144e3 100644
--- a/examples/go-api/intelligence.lock
+++ b/examples/go-api/intelligence.lock
@@ -1,10 +1,10 @@
 # Generated by the intelligence CLI. Do not edit.
 lockfile_version: 1
-engine_version: "0.20.0"
+engine_version: "0.21.0"
 packages:
   "@ainova-systems/sync":
-    requested: "0.20.0"
+    requested: "0.21.0"
     url: "https://github.com/ainova-systems/intelligence.git"
     path: "packages/sync"
-    resolved: "v0.20.0"
+    resolved: "v0.21.0"
     sha: ""
diff --git a/examples/go-api/intelligence.yaml b/examples/go-api/intelligence.yaml
index 9adb44d..fe96058 100644
--- a/examples/go-api/intelligence.yaml
+++ b/examples/go-api/intelligence.yaml
@@ -4,7 +4,7 @@
 project:
   name: my-api
 
-schema_version: "0.20.0"
+schema_version: "0.21.0"
 
 sources:
   rules:
@@ -35,4 +35,4 @@ targets:
 # and restored offline from the CLI bundle.
 packages:
   "@ainova-systems/sync":
-    version: "0.20.0"
+    version: "0.21.0"
diff --git a/examples/platform-with-submodules/intelligence.lock b/examples/platform-with-submodules/intelligence.lock
index b7278b0..22144e3 100644
--- a/examples/platform-with-submodules/intelligence.lock
+++ b/examples/platform-with-submodules/intelligence.lock
@@ -1,10 +1,10 @@
 # Generated by the intelligence CLI. Do not edit.
 lockfile_version: 1
-engine_version: "0.20.0"
+engine_version: "0.21.0"
 packages:
   "@ainova-systems/sync":
-    requested: "0.20.0"
+    requested: "0.21.0"
     url: "https://github.com/ainova-systems/intelligence.git"
     path: "packages/sync"
-    resolved: "v0.20.0"
+    resolved: "v0.21.0"
     sha: ""
diff --git a/examples/platform-with-submodules/intelligence.yaml b/examples/platform-with-submodules/intelligence.yaml
index fef4462..5fcb5cf 100644
--- a/examples/platform-with-submodules/intelligence.yaml
+++ b/examples/platform-with-submodules/intelligence.yaml
@@ -6,7 +6,7 @@
 project:
   name: my-platform
 
-schema_version: "0.20.0"
+schema_version: "0.21.0"
 
 sources:
   rules:
@@ -53,4 +53,4 @@ submodules:
 # and restored offline from the CLI bundle.
 packages:
   "@ainova-systems/sync":
-    version: "0.20.0"
+    version: "0.21.0"
diff --git a/examples/with-remote-skills/intelligence.yaml b/examples/with-remote-skills/intelligence.yaml
index 21b78c7..16dbe1d 100644
--- a/examples/with-remote-skills/intelligence.yaml
+++ b/examples/with-remote-skills/intelligence.yaml
@@ -8,7 +8,7 @@
 project:
   name: my-app
 
-schema_version: "0.20.0"
+schema_version: "0.21.0"
 
 # Package sources come first, project sources last: adapters copy in order and
 # the last write wins, so a project file overrides a same-named package file.
@@ -44,7 +44,7 @@ targets:
 # `intelligence sync`.
 packages:
   "@ainova-systems/sync":
-    version: "0.20.0"
+    version: "0.21.0"
   # A package resolved through the trust list below — the name is all the
   # manifest needs, the registry supplies the url.
   "@org/shared-intel":
diff --git a/intelligence.lock b/intelligence.lock
index d1db007..3615bed 100644
--- a/intelligence.lock
+++ b/intelligence.lock
@@ -1,6 +1,6 @@
 # Generated by the intelligence CLI. Do not edit.
 lockfile_version: 1
-engine_version: "0.20.0"
+engine_version: "0.21.0"
 packages:
   "@ainova-systems/core":
     requested: "^0.9.3"
@@ -9,8 +9,8 @@ packages:
     resolved: "v0.9.3"
     sha: "75fca75f2aa40e8d8b738131ec39714af4ea7863"
   "@ainova-systems/sync":
-    requested: "0.20.0"
+    requested: "0.21.0"
     url: "https://github.com/ainova-systems/intelligence.git"
     path: "packages/sync"
-    resolved: "v0.20.0"
+    resolved: "v0.21.0"
     sha: ""
diff --git a/intelligence.yaml b/intelligence.yaml
index f641a51..7a71762 100644
--- a/intelligence.yaml
+++ b/intelligence.yaml
@@ -4,7 +4,7 @@ project:
   name: "intelligence"
 
 # Schema version of this manifest. The CLI keeps it in step with its engine.
-schema_version: "0.20.0"
+schema_version: "0.21.0"
 
 # Where content comes from. Nothing here has to exist: a directory that is
 # absent is skipped, so a project consuming only packages authors nothing of
@@ -67,6 +67,6 @@ registries:
 
 packages:
   "@ainova-systems/sync":
-    version: "0.20.0"
+    version: "0.21.0"
   "@ainova-systems/core":
     version: "^0.9.3"

From 48c935403aab13a3a520236e04eba46dc39fd0ff Mon Sep 17 00:00:00 2001
From: Dmitrij Zykovic <dmitrij.zykovic@ainovasystems.com>
Date: Sun, 11 Oct 2026 21:44:57 +0300
Subject: [PATCH 7/8] Corrected the skill inventory comments now that built-in
 adapters read skills through the catalog

---
 engine/lib/common.sh | 16 ++++++++++------
 1 file changed, 10 insertions(+), 6 deletions(-)

diff --git a/engine/lib/common.sh b/engine/lib/common.sh
index c2f4201..7627ec6 100644
--- a/engine/lib/common.sh
+++ b/engine/lib/common.sh
@@ -1873,10 +1873,11 @@ warn_unsynced() {
 # encloses it. Generated output never holds a link, and nothing is ever copied
 # from outside the source (decision 0006). Every consumer takes that decision
 # from here, once per run: the skill list read_source_artifact_files returns,
-# the membership the glob-listing adapters check (skill_source_rendered), and
-# the plan copy_skill_bundle_dirs applies to its copy. A skill rendered from a
-# link is an ordinary skill from then on — quoting, token expansion, the
-# effort rendering and the Codex invocation policy all run on the output copy.
+# which the source catalog reads, the membership skill_source_rendered
+# answers, and the plan copy_skill_bundle_dirs applies to its copy. A skill
+# rendered from a link is an ordinary skill from then on — quoting, token
+# expansion, the effort rendering and the Codex invocation policy all run on
+# the output copy.
 #
 # skill_source_inventory <repo_root> <config_file> fills, in the caller's
 # shell and fail-closed like read_source_artifact_files:
@@ -1923,8 +1924,11 @@ skill_source_inventory() {
     [ "${IS_SOURCE_FILES_MEMO:-0}" != 1 ] || IS_SKI_KEY="$memo_key"
 }
 
-# skill_source_rendered <skill_dir> — the inventory renders this skill. For
-# adapters that list a skills source with their own glob.
+# skill_source_rendered <skill_dir> — the inventory renders this skill. No
+# built-in adapter calls it: they read skills through source_artifacts_var
+# (decision 0021). It stays for a project adapter written against earlier
+# releases that still lists a skills source with its own glob — that adapter
+# keeps skipping skills sync leaves out, but not local or targeted ones.
 skill_source_rendered() {
     _ski_key_var "$1"
     case "${IS_SKI_KEYS:-}" in

From c8861c50fc65b691f05af54d82abecea83e7a2b4 Mon Sep 17 00:00:00 2001
From: Dmitrij Zykovic <dmitrij.zykovic@ainovasystems.com>
Date: Sun, 11 Oct 2026 22:19:35 +0300
Subject: [PATCH 8/8] Reported tracked files with local names in status --check

---
 CHANGELOG.md                                  |  2 ++
 cli/internal/check.sh                         | 31 +++++++++++++++++++
 cli/tests/e2e-local-artifacts.sh              | 27 ++++++++++++++++
 ...021-local-and-targeted-source-artifacts.md |  5 ++-
 docs/cli.md                                   |  4 ++-
 packages/sync/references/conventions.md       |  2 ++
 6 files changed, 69 insertions(+), 2 deletions(-)

diff --git a/CHANGELOG.md b/CHANGELOG.md
index 9c67ced..1b15ca0 100644
--- a/CHANGELOG.md
+++ b/CHANGELOG.md
@@ -10,6 +10,7 @@ Legacy Intelligence Sync history remains in its [archive](https://github.com/ain
 
 - Local rules, agents and skills: a `*.local.md` rule or agent and a `*.local/` skill directory in the content directory render only into outputs Git ignores, never into `AGENTS.md` or another tracked output, so every clone and CI render the same committed files; `.environment.local.md` renders as `environment` (decision 0021).
 - `intelligence init` writes `<content-dir>/rules/*.local.md`, `<content-dir>/agents/*.local.md` and `<content-dir>/skills/*.local/` into the managed `.gitignore` block, and `status --check` reports one missing.
+- `status --check` names a rule, agent or skill with a local name that Git tracks in any project-owned source: `.gitignore` never applies to a tracked file, so Git would share what sync renders only into ignored output.
 - `targets:` and `exclude_targets:` in a rule's, agent's or `SKILL.md`'s frontmatter select the adapters it renders for: adapter ids and the group `committed` (every output Git tracks), in the list syntax `paths:` takes. `targets: []` renders nowhere, an unknown id or a local artifact naming a committed output refuses the sync, and both fields are removed from every generated copy (decision 0021).
 - An always-on rule `AGENTS.md` does not carry — a local one, or one whose targets leave `agents` out — reaches each tool through its own channel: Cursor `.mdc` with `alwaysApply: true`, Copilot `.instructions.md` with `applyTo: "**"`, Antigravity `trigger: always_on`, Pi's rules extension, and Codex `AGENTS.override.md`, which holds all of `AGENTS.md` plus those rules, is ignored, and exists only while such a rule does (decision 0021).
 - Sync prints a `WARNING:` line when `AGENTS.md` or `.agents/skills/` delivers a local or targeted artifact to an enabled tool outside its targets, and when a tool in its targets has no channel for it — OpenCode for an always-on rule outside `AGENTS.md`.
@@ -30,6 +31,7 @@ Legacy Intelligence Sync history remains in its [archive](https://github.com/ain
 ### Breaking
 
 - [ ] No source directory holds two artifacts whose names differ only by a leading `.` or a trailing `.local`, and no artifact name is both local and committed across the sources: `intelligence sync` succeeds.
+- [ ] No file Git tracks in a project source is a rule or agent named `*.local.md` or a skill directory named `*.local/`: such a file now renders only into ignored output and leaves `AGENTS.md`. Rename it to keep it shared, or `git rm --cached` it to keep it on one machine.
 - [ ] The CLI-managed block of `.gitignore` lists `<content-dir>/rules/*.local.md`, `<content-dir>/agents/*.local.md` and `<content-dir>/skills/*.local/`, and `AGENTS.override.md` when Codex is enabled — run `intelligence init` to apply it.
 - [ ] `intelligence status --check` exits 0.
 
diff --git a/cli/internal/check.sh b/cli/internal/check.sh
index 10bf4c5..d8efa44 100644
--- a/cli/internal/check.sh
+++ b/cli/internal/check.sh
@@ -222,6 +222,7 @@ fi
 # is exactly why doctor names it). Each entry is judged by the directory the
 # engine renders it as, read through the same parser: a package reference by
 # its store path, one that resolves to nothing by why.
+local_specs=()
 for section in rules agents skills; do
     seen=$'\n'
     while IFS=$'\037' read -r src state dir alias holders; do
@@ -277,10 +278,40 @@ for section in rules agents skills; do
                 # authoring later needs no config edit.
                 *) ok "sources.$section '$src' — not created yet (optional)" ;;
             esac
+            continue
         fi
+        # A project-owned source is where a tracked file can carry a local
+        # name; store content is restorable state Git never tracks.
+        case "$dir" in
+            .intelligence/*) ;;
+            *)
+                if [ "$section" = skills ]; then
+                    local_specs+=(":(glob)${dir%/}/*.local/SKILL.md")
+                else
+                    local_specs+=(":(glob)${dir%/}/*.local.md")
+                fi
+                ;;
+        esac
     done < <(read_source_entries "$manifest" "$section")
 done
 
+# A name makes an artifact local (decision 0021), and .gitignore never applies
+# to a file Git already tracks: one committed before its name meant anything,
+# or added by hand, renders only into ignored output while every clone holds
+# it. Git and the engine would disagree about it, so it is named here.
+if [ "${#local_specs[@]}" -gt 0 ] \
+    && git -C "$IP_ROOT" rev-parse --is-inside-work-tree >/dev/null 2>&1; then
+    if tracked_local="$(git -C "$IP_ROOT" -c core.quotePath=false ls-files -- "${local_specs[@]}")"; then
+        while IFS= read -r path; do
+            [ -n "$path" ] || continue
+            case "$path" in */SKILL.md) path="${path%/SKILL.md}/" ;; esac
+            warn "$path is tracked by Git, but its name makes it local: sync renders it only into ignored output — rename it to share it, or 'git rm --cached' it to keep it on this machine"
+        done <<< "$tracked_local"
+    else
+        warn "tracked local artifacts could not be listed — 'git ls-files' failed"
+    fi
+fi
+
 if [ "$problems" -eq 0 ]; then
     echo "all good."
 else
diff --git a/cli/tests/e2e-local-artifacts.sh b/cli/tests/e2e-local-artifacts.sh
index 2988b12..420d8ff 100644
--- a/cli/tests/e2e-local-artifacts.sh
+++ b/cli/tests/e2e-local-artifacts.sh
@@ -90,6 +90,22 @@ for word in environment scoped helper deploy LOCAL_; do
 done
 is "work tree after sync" "" "$(git -C "$P" status --porcelain)"
 
+echo "== status --check names a tracked file with a local name =="
+# .gitignore never applies to a tracked file, so Git would share what the
+# engine renders as local.
+run "$P" status --check
+is "status --check with untracked local artifacts" 0 "$RC"
+git -C "$P" add -f intelligence/rules/.environment.local.md intelligence/skills/deploy.local
+run "$P" status --check
+is "status --check with tracked local artifacts" 1 "$RC"
+chk grep -Fq 'intelligence/rules/.environment.local.md is tracked by Git' "$LOG"
+chk grep -Fq 'intelligence/skills/deploy.local/ is tracked by Git' "$LOG"
+chknot grep -Fq 'notes.md is tracked' "$LOG"
+chknot grep -Fq 'scoped.local.md is tracked' "$LOG"
+git -C "$P" rm -q -r --cached intelligence/rules/.environment.local.md intelligence/skills/deploy.local
+run "$P" status --check
+is "status --check once they are untracked" 0 "$RC"
+
 echo "== local artifacts reach ignored outputs under their names =="
 for f in .claude/rules/environment.md .claude/rules/scoped.md .claude/agents/helper.md \
     .claude/skills/deploy/SKILL.md .claude/skills/deploy/references/notes.md .cursor/rules/scoped.mdc \
@@ -165,6 +181,17 @@ chk grep -Fq 'intelligence/rules/.environment.local.md' "$LOG"
 chk grep -Fq 'one local and one not' "$LOG"
 is "outputs after the cross-source refusal" "$before" "$(snapshot "$P")"
 rm "$P/shared/rules/environment.md"
+# A source outside the content directory has no ignore pattern, so a local
+# file there is the one Git offers to commit; once tracked it is named too.
+printf '# Mine\n' > "$P/shared/rules/mine.local.md"
+run "$P" status --check
+chknot grep -Fq 'mine.local.md is tracked' "$LOG"
+git -C "$P" add shared/rules/mine.local.md
+run "$P" status --check
+is "status --check with a tracked local rule in another source" 1 "$RC"
+chk grep -Fq 'shared/rules/mine.local.md is tracked by Git' "$LOG"
+git -C "$P" rm -q --cached shared/rules/mine.local.md
+rm "$P/shared/rules/mine.local.md"
 
 echo "== AGENTS.md applies source overrides: a same-named rule is listed once =="
 # Regression: AGENTS.md listed and inlined `style` once per source while every
diff --git a/decisions/0021-local-and-targeted-source-artifacts.md b/decisions/0021-local-and-targeted-source-artifacts.md
index cd37c05..b545635 100644
--- a/decisions/0021-local-and-targeted-source-artifacts.md
+++ b/decisions/0021-local-and-targeted-source-artifacts.md
@@ -38,7 +38,10 @@ later source win.
    holds, so Git and the engine cannot disagree about which file is local:
    `init` writes `<content-dir>/rules/*.local.md`,
    `<content-dir>/agents/*.local.md` and `<content-dir>/skills/*.local/` to the
-   managed block, beside `.intelligence/`.
+   managed block, beside `.intelligence/`. A pattern never applies to a file
+   Git already tracks, and a source outside the content directory has none, so
+   `status --check` names every tracked file with a local name in a
+   project-owned source.
 2. **A name is the file name without a leading `.`, `.md` and a trailing
    `.local`.** `.environment.local.md` and `environment.local.md` are the local
    rule `environment`; `.local.md` is the local rule `local`; `.draft.md` is the
diff --git a/docs/cli.md b/docs/cli.md
index 2f64901..8fa8b6f 100644
--- a/docs/cli.md
+++ b/docs/cli.md
@@ -448,7 +448,9 @@ other than the locked one or recording none, stale schema/content, invalid
 sources — a [package reference](#package-references) that names nothing
 included — or an alias that is malformed or that two packages declare, and for
 a managed `.gitignore` pattern that is missing: an adapter's, or one of the three
-local artifact patterns of the content directory. Each
+local artifact patterns of the content directory; and for a file with a local
+name (`*.local.md`, a `*.local/` skill) that Git tracks in a project-owned
+source. Each
 package line reports the commit the store holds. Frozen store
 restoration verifies the locked commit SHA.
 
diff --git a/packages/sync/references/conventions.md b/packages/sync/references/conventions.md
index 2033153..68dc3d5 100644
--- a/packages/sync/references/conventions.md
+++ b/packages/sync/references/conventions.md
@@ -180,6 +180,8 @@ intelligence/skills/*.local/
 
 Sync renders a local artifact only into outputs Git ignores, and never into one it tracks: not `AGENTS.md`, not OpenCode's slash commands, not Copilot's output under `commit_output: true`. A clone without the file therefore renders the same committed files, and `intelligence sync --check` passes in CI. A local always-on rule reaches each tool through that tool's own always-on channel (see [Routing](#routing)), since `AGENTS.md` cannot carry it; OpenCode has none, and sync says so. `intelligence status --check` reports a missing pattern, and `intelligence init` restores it.
 
+A pattern never applies to a file Git already tracks, and a source outside the content directory has no pattern at all. `intelligence status --check` therefore names every file with a local name that Git tracks in a project-owned source: rename it to share it, or `git rm --cached` it to keep it on this machine.
+
 ## Selecting adapters
 
 Every rule, agent and skill renders to every enabled adapter. Two frontmatter fields narrow that, for guidance that matters to one tool or should cost no other tool context: