@alessandroraffa/tangyr 4.2.0 → 5.0.0

package/README.md

@@ -363,6 +363,26 @@ acceptedLoss:
 
 `--ignore-errors` remains the blunt instrument: it suppresses the exit code for every error entry, including ones nobody has looked at yet.
 
+Not every error entry is structural. `rule-not-delivered` (below) reports a rule that did not reach a target on this run, which is usually fixable — by giving the target an instructions path of its own, or by not enabling it. Accept it when you have decided to live with it, not to quiet it.
+
+## Rules that did not arrive
+
+A rule reaches a target either as a file in that target's own rules slot or as a section in the instructions document it reads. Several targets resolve their instructions to one project-root `AGENTS.md` and write it in turn, so a rule folded into that file survives only for whoever wrote last.
+
+After every target has written, the run measures what is actually on disk and says so — one line per target, the count first, and the rules that did **not** arrive named:
+
+```text
+Rules reaching each target (3 declared, measured on disk):
+  claude-code  3/3
+  copilot      3/3
+  codex        0/3  missing: style, testing, review
+               its rules are folded into AGENTS.md, which cline wrote last
+  opencode     3/3
+  cline        3/3
+```
+
+Nothing is printed when every rule arrived; `--verbose` shows the block either way. The same fact reaches `--loss-report <path>` as a `rule-not-delivered` entry per rule per target, at `error` severity, so a run that loses a rule exits `3` rather than reporting success.
+
 ## Exit codes
 
 The full exit-code taxonomy, in numeric order. Every code below `5`
@@ -404,9 +424,9 @@ reaches them).
 ## Supported tools
 
 - **Claude Code** — instructions (`AGENTS.md` plus the `CLAUDE.md` shim), agents, skills, commands, rules, output styles, hooks, settings, and MCP, placed in scope-resolved Claude Code paths (fanned out across every configured global root — see [Multiple Claude Code global roots](#multiple-claude-code-global-roots))
-- **GitHub Copilot** — instructions (`AGENTS.md` plus the always-read `.github/copilot-instructions.md` mirror; project scope only, since Copilot has no global instructions slot), agents, prompts (compiled from commands), skills, hooks (`~/.copilot/hooks` or `.github/hooks`), and MCP. Hook matchers are rewritten to Copilot's own lowercase tool names (`bash`, `view`, `create`, `edit`, `grep`) — an untranslated `Bash` matcher never fires
-- **OpenAI Codex** — `AGENTS.md`, agent TOML files, rules (`.rules` files for `exec-policy`, appended to the instructions file as guidance otherwise), hooks (`hooks.json` plus the shared `~/.agents/hooks` script bridge; macOS and Linux only), and MCP in `config.toml`
-- **OpenCode** — instructions (`AGENTS.md`), agents, commands, skills (OpenCode-local plus the shared `~/.agents/skills` link), and `opencode.json` (MCP, permissions, custom provider), in XDG config paths. Hooks are **not** delivered: OpenCode exposes hooks only as plugin code, so every hook event is dropped and recorded as a `hook-as-plugin` loss
+- **GitHub Copilot** — instructions (`AGENTS.md` plus the always-read `.github/copilot-instructions.md` mirror; project scope only, since Copilot has no global instructions slot), agents, prompts (compiled from commands), rules (`.github/instructions/<name>.instructions.md`, each carrying the rule's path scope as an `applyTo` glob; project scope only, since that is a repository path with no user-level equivalent), skills, hooks (`~/.copilot/hooks` or `.github/hooks`), and MCP. Hook matchers are rewritten to Copilot's own lowercase tool names (`bash`, `view`, `create`, `edit`, `grep`) — an untranslated `Bash` matcher never fires
+- **OpenAI Codex** — `AGENTS.md`, agent TOML files, rules (`.rules` files for `exec-policy`, appended to the instructions file as guidance otherwise), skills and commands (both as skill directories at Codex's documented skills path — `~/.agents/skills` globally, `.agents/skills` inside a repository — because Codex deprecated its custom prompts in favour of skills), hooks (`hooks.json` plus the shared `~/.agents/hooks` script bridge; macOS and Linux only), and MCP in `config.toml`
+- **OpenCode** — instructions (`~/.config/opencode/AGENTS.md` globally; `.opencode/AGENTS.md` inside a project, declared in the `instructions` field of `opencode.json`, because the project-root `AGENTS.md` is written by four other targets in turn and only the last writer's content survives), agents, commands, skills (OpenCode-local plus the shared `~/.agents/skills` link), and `opencode.json` (MCP, permissions, custom provider), in XDG config paths. Hooks are **not** delivered: OpenCode exposes hooks only as plugin code, so a declared hook event is dropped and recorded as a `hook-as-plugin` loss
 - **Cursor** — instructions, subagents, `.mdc` rules, commands, skills (Cursor-local plus shared), `hooks.json` plus the shared hook-script bridge (matchers rewritten to Cursor's tool names — `Shell`, `Read`, `Write`, `Grep`), `mcp.json`, and `permissions.json`
 - **Cline** — instructions (`AGENTS.md`, project scope only), rules, workflows (compiled from commands), skills, and MCP. Agents and hooks are **not** delivered: Cline has no committable persona file (`persona-not-representable`) and exposes hooks only as `@cline/sdk` plugin code (`hook-as-plugin`); both are recorded as losses rather than silently skipped
 

package/dist/index.js

@@ -21625,6 +21625,19 @@ var lossSeverityByEntryType = {
   "rule-as-instruction": "info",
   "rule-mode-downgrade": "warning",
   "rule-path-scoping": "warning",
+  // The rule is not there. Measured on the files each target reads, after every
+  // target has written, so this says what arrived rather than what a compiler
+  // intended — the two have disagreed, most often where several targets write
+  // one instructions file and only the last writer's content survives.
+  //
+  // Error by the severity ladder's own definition: `warning` is "a real
+  // reduction in fidelity that still produces a working artifact", and an
+  // absent rule is not reduced, it is absent. `error` is "an intent that could
+  // not be emitted at all and requires a manual step or a kit change", which is
+  // exactly the remedy the run prints: give the target an instructions path of
+  // its own, or disable it. `acceptedLoss` is how a project that has decided to
+  // live with it says so.
+  "rule-not-delivered": "error",
   "hook-event-drop": "warning",
   // A declaration the parser refuses installs nothing, anywhere, and used to
   // do so silently. Error severity is what makes install and sync exit 3.
@@ -26421,6 +26434,26 @@ Rules reaching each target (${String(declared)} declared, measured on disk):`
 function missingRulesByTarget(coverage) {
   return new Map(coverage.map((entry) => [entry.target, entry.missing]));
 }
+function recordRulesCoverageLoss(coverage, lossReport) {
+  for (const entry of coverage) {
+    if (entry.missing.length === 0) {
+      continue;
+    }
+    addLoss(lossReport, entry.target, "rules", {
+      source: "rules",
+      fields: entry.missing.map((rule) => ({
+        field: rule,
+        action: "rule-not-delivered",
+        severity: resolveLossSeverity(
+          "agent-field",
+          rule,
+          "rule-not-delivered"
+        ),
+        detail: `${rule}: not readable by ${entry.target}${entry.reason ? ` \u2014 ${entry.reason}` : ""}`
+      }))
+    });
+  }
+}
 
 // src/adapters/claude-code.ts
 import fs38 from "fs";
@@ -27725,23 +27758,6 @@ function compileOpenCodeHooks(sourceHooksJson, lossReport, sourceLabel) {
       ]
     });
   }
-  if (Object.keys(sourceHooks).length === 0) {
-    addLoss(lossReport, "opencode", "hooks", {
-      source: sourceLabel,
-      fields: [
-        {
-          field: "hooks",
-          action: "hook-as-plugin",
-          severity: resolveLossSeverity(
-            "agent-field",
-            "hooks",
-            "hook-as-plugin"
-          ),
-          detail: "OpenCode exposes hooks only as plugin code \u2014 no declarative hook file emitted"
-        }
-      ]
-    });
-  }
   return { payload: {}, translated: 0, dropped: 0, droppedEvents: [] };
 }
 function compileClineHooks(sourceHooksJson, lossReport, sourceLabel) {
@@ -27763,23 +27779,6 @@ function compileClineHooks(sourceHooksJson, lossReport, sourceLabel) {
       ]
     });
   }
-  if (Object.keys(sourceHooks).length === 0) {
-    addLoss(lossReport, "cline", "hooks", {
-      source: sourceLabel,
-      fields: [
-        {
-          field: "hooks",
-          action: "hook-as-plugin",
-          severity: resolveLossSeverity(
-            "agent-field",
-            "hooks",
-            "hook-as-plugin"
-          ),
-          detail: "Cline exposes hooks only as @cline/sdk AgentPlugin TypeScript/JS code \u2014 no declarative hook file emitted"
-        }
-      ]
-    });
-  }
   return { payload: {}, translated: 0, dropped: 0, droppedEvents: [] };
 }
 function compileCopilotHooks(sourceHooksJson, mappings, lossReport, sourceLabel) {
@@ -31877,6 +31876,7 @@ SKIPPED CONFLICTS (${skippedTargetPaths.size} target(s) left unchanged):`
     missingRulesByTarget(rulesCoverage)
   );
   reportRulesCoverage(rulesCoverage, logger);
+  recordRulesCoverageLoss(rulesCoverage, installLossReport);
   for (const [relativePath, sourcePath] of collectAllFiles(kitInfo, config)) {
     addFileToManifest(manifest, {
       relativePath,
@@ -35009,6 +35009,7 @@ async function runSyncCommand(options, logger) {
         missingRulesByTarget(rulesCoverage)
       );
       reportRulesCoverage(rulesCoverage, logger);
+      recordRulesCoverageLoss(rulesCoverage, lossReport);
     }
   }
   writeLossReport(options.lossReport, lossReport);

package/mappings/README.md

@@ -5,9 +5,9 @@ Declarative translation inputs for `tangyr`.
 These files are part of the canonical runtime bundle, but they are design-time metadata rather than user-facing runtime artifacts. They define the current active v1 translation baseline for:
 
 - `Claude Code`
-- `GitHub Copilot`
-- `Codex`
-- `OpenCode` — full six-slot profile: `instructions` (`AGENTS.md` at the XDG-based `~/.config/opencode/` path), `agents`, `commands`, `skills` (OpenCode-local), `skills_shared` (cross-tool `~/.agents/skills`), and `config_doc` (`opencode.json`)
+- `GitHub Copilot` — `rules` is a project-only slot (`.github/instructions/`), `null` at global scope: that path is a repository surface with no documented user-level equivalent
+- `Codex` — skills and commands both land at Codex's documented skills path (`~/.agents/skills` globally, `.agents/skills` in a repository), since Codex deprecated custom prompts in favour of skills; `exec-policy` rules emit as `.rules` files and guidance rules are folded into the instructions document
+- `OpenCode` — full six-slot profile: `instructions` (`AGENTS.md` at the XDG-based `~/.config/opencode/` path globally; `.opencode/AGENTS.md` in a project, declared in the `instructions` field of `opencode.json`, because the project-root `AGENTS.md` is claimed by four other targets), `agents`, `commands`, `skills` (OpenCode-local), `skills_shared` (cross-tool `~/.agents/skills`), and `config_doc` (`opencode.json`)
 - `Cursor` — full eight-slot profile: `instructions` (`AGENTS.md` at `~/.cursor/rules/`), `agents` (`~/.cursor/agents/`), `rules` (`~/.cursor/rules/`), `skills` (Cursor-local `~/.cursor/skills/`), `skills_shared` (cross-tool `~/.agents/skills`), `hooks_file` (`~/.cursor/hooks.json`), `mcp_file` (`~/.cursor/mcp.json`), and `permissions_file` (`~/.cursor/permissions.json`)
 - `Cline` — five-slot profile: `instructions` (`AGENTS.md` at project root — project scope only; global `instructions` is `null` because Cline has no documented global `AGENTS.md` read location and the global custom-instructions field is interface-only), `rules` (project: `.clinerules/`; global: `~/Documents/Cline/Rules` — macOS primary), `workflows` (project: `.clinerules/workflows/`; global: `~/Documents/Cline/Workflows/`), `skills` (project: `.cline/skills/`; global: `~/.cline/skills/`), and `mcp_file` (project: `cline-mcp.json`; global: `~/.cline/mcp.json`)
 

package/mappings/loss-severity.yaml

@@ -18,13 +18,23 @@ notes:
   - Severity is resolved per entry type, not per target - `resolveLossSeverity`
     (compiler/loss-report.ts) keys only on the entry type, with an explicit severity from
     hook-events.yaml overriding it.
+  - "`rule-not-delivered` was added on 2026-09-16 and is the one entry measured on the
+    files rather than recorded by the compiler that wrote them. It is emitted after every
+    target has run, once per rule that did not reach a target, which is the machine-readable
+    half of the per-target coverage block the run prints."
+  - "`hook-declaration-invalid` and `hook-source-ambiguous` were in the code's table and
+    missing from this one until 2026-09-16. Nothing compared the two, so the drift was
+    silent; tests/unit/mappings/loss-severity-matches-code.test.ts now does."
 
 entry_types:
   command-as-skill: info
   rule-as-instruction: info
   rule-mode-downgrade: warning
   rule-path-scoping: warning
+  rule-not-delivered: error
   hook-event-drop: warning
+  hook-declaration-invalid: error
+  hook-source-ambiguous: error
   hook-as-plugin: error
   instructions-shim: info
   permission-coarsening: error

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@alessandroraffa/tangyr",
-  "version": "4.2.0",
+  "version": "5.0.0",
   "description": "CLI for the Tangyr discipline — install and manage operating kits for AI coding tools",
   "license": "MIT",
   "engines": {