aiblueprint-cli 1.4.108 → 1.4.110

package/agents-config/skills/arena/rubric.md

@@ -0,0 +1,79 @@
+# The arena rubric
+
+Every match in the arena is scored against this page. The judge scores both solutions, `bracket.py`
+does the arithmetic, and the higher weighted total goes through. The loser is out.
+
+## The five criteria
+
+Each criterion is scored 0 to 10. The weight is how much of the 100-point total it is worth.
+
+| criterion | weight | the question |
+| --- | --- | --- |
+| Correctness | 30 | Is it right? No false claims, no logic errors, no bugs, nothing that would mislead the user. |
+| Completeness | 25 | Does it meet every requirement the task actually states? Judged against the task text, not against what the judge would have liked. |
+| Specificity | 15 | Could the user act on it right now without guessing? Exact steps, values, names, code. |
+| Robustness | 20 | Does it hold up against the attacks raised in this match? Fixed, correctly rebutted, or still standing. |
+| Clarity | 10 | Is it easy to read and use, at a length that fits the task? |
+
+Weighted total = (correctness x 30 + completeness x 25 + specificity x 15 + robustness x 20 + clarity x 10) / 10.
+That gives a number from 0 to 100.
+
+## Anchors
+
+Use the whole scale. A 7 is not a polite default.
+
+**Correctness**
+- 10: nothing wrong that you can find after checking it yourself.
+- 7: minor slips that do not change the outcome for the user.
+- 4: at least one real error the user would trip on.
+- 0 to 2: wrong at the core, or it would cause harm if used.
+
+**Completeness**
+- 10: every stated requirement is met, fully.
+- 7: every requirement is touched, one is thin.
+- 4: a stated requirement is missing.
+- 0 to 2: it answers a different question from the one asked.
+
+**Specificity**
+- 10: the user can act on every part of it immediately.
+- 7: mostly concrete, with one or two places that need a guess.
+- 4: a lot of "consider", "ensure" and "it depends" without the actual answer.
+- 0 to 2: generic advice that would fit any task.
+
+**Robustness**
+- 10: every attack in this match is fixed in the revised solution or correctly rebutted, and nothing new is broken.
+- 7: one MINOR attack still standing.
+- 4: a MAJOR attack still standing, or a fix that broke something else.
+- 0 to 2: a FATAL attack still standing.
+
+A missing attack file means the opponent raised nothing. Score robustness on the flaws you found yourself.
+
+**Clarity**
+- 10: the shape makes it obvious how to use it. No padding.
+- 7: fine, with some padding or one confusing section.
+- 4: the user has to dig for the answer.
+- 0 to 2: hard to follow at all.
+
+## The fatal rule
+
+Mark a solution `fatal` only when you have verified a flaw that makes it wrong or unusable for the
+task: code that cannot work, a false central claim, a hard constraint broken, the wrong question
+answered. A fatal solution cannot beat a solution that is not fatal, whatever the totals say. If both
+are fatal, the totals decide.
+
+## Ties
+
+There are no draws. On an exact tie, the solution with fewer attacks still standing wins. If that is
+also level, the higher correctness score wins. If that is also level, pick the one you would hand to
+the user, and say why in the reason.
+
+## What the judge does not reward
+
+- **Length.** Longer is not better. A tight answer that meets every requirement beats a long one
+  that meets the same requirements.
+- **Confidence.** A defense that says "fixed" is not proof. Check the revised solution.
+- **The approach.** The judge never sees the strategy cards and does not guess at them. It scores
+  the work, not the method that produced it.
+- **Talking about quality.** "This robust, comprehensive solution" earns nothing. The solution has to
+  be robust and comprehensive.
+- **Agreement with the judge's own taste** where the task does not ask for it.

package/agents-config/skills/arena/strategies.json

@@ -0,0 +1,205 @@
+{
+  "version": 1,
+  "about": "The strategy cards for /arena. Every competitor gets the same task and exactly one card: one reasoning mode, one workflow, one strategy. 15 x 12 x 12 = 2,160 distinct cards. bracket.py deals them with no repeats and spreads them evenly, so a 100-agent arena uses every reasoning mode, every workflow and every strategy. Edit freely: add an entry and the dealer picks it up. Ids must stay unique within a list.",
+  "reasoning": [
+    {
+      "id": "first-principles",
+      "name": "First principles",
+      "how": "Strip the task down to the facts and requirements nobody can argue with. Rebuild the answer from those alone, and keep a convention only if it earns its place again."
+    },
+    {
+      "id": "inversion",
+      "name": "Inversion",
+      "how": "Ask what would make this answer fail. List every way it could, then build the answer that makes each of those failures impossible."
+    },
+    {
+      "id": "analogy",
+      "name": "Analogy",
+      "how": "Find a problem in a different field that has already been solved and has the same shape. Port its solution over, then fix every place where the analogy breaks."
+    },
+    {
+      "id": "adversarial",
+      "name": "Adversarial",
+      "how": "Picture the harshest expert reviewer trying to tear the answer apart. Write their attacks down first and build the answer backwards from them."
+    },
+    {
+      "id": "constraint-first",
+      "name": "Constraint first",
+      "how": "List every hard constraint, stated and implied: time, budget, tools, format, audience, platform. Solve strictly inside that box and let the tightest constraint drive the design."
+    },
+    {
+      "id": "worked-example",
+      "name": "Worked example",
+      "how": "Solve one concrete, realistic instance end to end first, with real values. Generalise only from what that example actually taught you."
+    },
+    {
+      "id": "socratic",
+      "name": "Socratic",
+      "how": "Interrogate the task with the questions a sharp expert would ask before starting. Answer each one explicitly and let the answers decide the shape of the solution."
+    },
+    {
+      "id": "contrarian",
+      "name": "Contrarian",
+      "how": "Write down the obvious default answer, then argue seriously against it. Keep only what survives the argument, even if that takes you the unpopular way."
+    },
+    {
+      "id": "systems-thinking",
+      "name": "Systems thinking",
+      "how": "Map the moving parts, how they affect each other, and what happens second and third order. Optimise the whole system, not just the one part the task points at."
+    },
+    {
+      "id": "decomposition",
+      "name": "Decomposition",
+      "how": "Break the task into independent sub-problems. Solve each one completely, then integrate them and test the seams where they meet."
+    },
+    {
+      "id": "working-backwards",
+      "name": "Working backwards",
+      "how": "Describe the finished result precisely, as if it already exists. Then work backwards, step by step, to where the user is right now."
+    },
+    {
+      "id": "probabilistic",
+      "name": "Probabilistic",
+      "how": "Treat every claim and choice as uncertain. Weigh what is likely, prefer what holds up across most scenarios, and state your confidence where it changes the decision."
+    },
+    {
+      "id": "dialectical",
+      "name": "Dialectical",
+      "how": "State the strongest version of one answer, then the strongest opposing answer, then write the synthesis that keeps what is true in both."
+    },
+    {
+      "id": "evidence-first",
+      "name": "Evidence first",
+      "how": "Ground every claim in something checkable: the task text, the files it points to, the numbers given, documentation. Anything you cannot check gets labelled as an assumption."
+    },
+    {
+      "id": "expert-panel",
+      "name": "Expert panel",
+      "how": "Answer the task as three different experts would, picking roles that fit it. Take the strongest idea from each and settle every point where they disagree."
+    }
+  ],
+  "workflows": [
+    {
+      "id": "draft-critique-rewrite",
+      "name": "Draft, critique, rewrite",
+      "how": "Write a complete first draft. Critique it line by line against the task as if someone else wrote it. Then rewrite it from scratch using the critique."
+    },
+    {
+      "id": "outline-first",
+      "name": "Outline first",
+      "how": "Write a skeleton outline, check the outline against every requirement in the task, fix it, and only then fill it in."
+    },
+    {
+      "id": "test-first",
+      "name": "Test first",
+      "how": "Before writing the answer, write the checks it must pass: acceptance tests for code, pass or fail criteria for anything else. Then write the answer and run every check against it."
+    },
+    {
+      "id": "research-then-synthesise",
+      "name": "Research, then synthesise",
+      "how": "Gather every relevant fact first: the task, any files or context it points to, what is known about the domain. Write nothing until the research is done, then synthesise."
+    },
+    {
+      "id": "three-drafts",
+      "name": "Three drafts, pick one",
+      "how": "Write three short, genuinely different approaches. Pick the strongest on the task's own terms and develop only that one fully."
+    },
+    {
+      "id": "requirements-checklist",
+      "name": "Requirements checklist",
+      "how": "Pull every requirement out of the task into a numbered list. Solve, then tick each item off and say exactly where it is met."
+    },
+    {
+      "id": "iterative-deepening",
+      "name": "Iterative deepening",
+      "how": "Write a one-paragraph answer first. Then expand the parts that matter most in two more passes, each one deeper than the last."
+    },
+    {
+      "id": "build-then-break",
+      "name": "Build, then break",
+      "how": "Build the answer. Then throw five hostile inputs or scenarios at it, write down what breaks, and patch every break."
+    },
+    {
+      "id": "smallest-version-first",
+      "name": "Smallest version first",
+      "how": "Produce the smallest complete version that actually works. Then extend it one step at a time, keeping it working after every step."
+    },
+    {
+      "id": "options-matrix",
+      "name": "Options matrix",
+      "how": "List the realistic options, score them in a small matrix against the criteria that matter for this task, choose one, and write up the choice."
+    },
+    {
+      "id": "open-questions-first",
+      "name": "Open questions first",
+      "how": "List every open question the task leaves. Resolve each one with reasoning or a stated assumption, then answer."
+    },
+    {
+      "id": "write-then-restructure",
+      "name": "Write, then restructure",
+      "how": "Write freely and fast. Then outline what you actually wrote, fix the structure, and rewrite it to the new outline."
+    }
+  ],
+  "strategies": [
+    {
+      "id": "simplest",
+      "name": "Simplest thing that works",
+      "how": "Pick the least complicated answer that fully does the job. Every extra part has to justify itself."
+    },
+    {
+      "id": "maximal-rigour",
+      "name": "Maximal rigour",
+      "how": "Be exhaustive and exact. Check every step, verify every claim, and leave no hand-waving anywhere."
+    },
+    {
+      "id": "user-empathy",
+      "name": "User empathy first",
+      "how": "Start from the person who will use this: their situation, their skill level, and what they will actually do next. Shape everything around that."
+    },
+    {
+      "id": "edge-cases-first",
+      "name": "Edge cases first",
+      "how": "Hunt the edge cases, failure modes and weird inputs first, and design the answer around surviving them."
+    },
+    {
+      "id": "speed",
+      "name": "Speed",
+      "how": "Optimise for the fastest route to something usable today. Cut anything that does not move the result."
+    },
+    {
+      "id": "defensive",
+      "name": "Defensive",
+      "how": "Assume the inputs are bad and the conditions are hostile. Make the answer fail safely and loudly rather than quietly."
+    },
+    {
+      "id": "clarity",
+      "name": "Clarity above all",
+      "how": "Make it the easiest answer to read and act on: plain words, obvious structure, nothing the reader has to decode."
+    },
+    {
+      "id": "completeness",
+      "name": "Completeness",
+      "how": "Leave out nothing the task asks for or clearly implies. Cover every requirement explicitly."
+    },
+    {
+      "id": "fewest-moving-parts",
+      "name": "Fewest moving parts",
+      "how": "Remove things until it breaks, then put the last one back. Fewer steps, fewer dependencies, fewer words."
+    },
+    {
+      "id": "explicit-trade-offs",
+      "name": "Explicit trade-offs",
+      "how": "Name the real trade-offs, choose for the user's most likely constraints, and say plainly what that choice gives up."
+    },
+    {
+      "id": "built-to-last",
+      "name": "Built to last",
+      "how": "Optimise for how this holds up in six months: easy to maintain, easy to extend, no traps for the next person."
+    },
+    {
+      "id": "concrete-specifics",
+      "name": "Concrete specifics",
+      "how": "Exact numbers, names, commands, file paths and steps. Zero generic advice."
+    }
+  ]
+}

package/agents-config/skills/audit-memories/SKILL.md

@@ -1,161 +1,35 @@
 ---
 name: audit-memories
-description: Manual-only audit and cleanup of agent-facing Markdown inside the current project. Run only from an explicit `$audit-memories` or `/audit-memories` user command; never select it implicitly.
+description: Audit and clean agent-facing Markdown in the current project. Use when the user invokes $audit-memories or /audit-memories to audit or clean AGENTS.md, rules, skills, plans, or task traces.
 argument-hint: "[audit|clean]"
 disable-model-invocation: true
 user-invocable: true
 ---
 
-# Audit Project Memories
+Proceed only on an explicit `$audit-memories` or `/audit-memories`. An OpenCode command that states the user invoked `/audit-memories` satisfies this guard. Default action is `audit`. `clean` audits first, then applies justified local cleanup.
 
-Treat agent instructions, rules, skills, plans, task traces, and outputs inside the current project as its agent memory. Compare them with current project truth, then remove noise without destroying durable guidance.
+Resolve the project root from `$PWD`. Do not switch checkouts. Do not read or modify `~/.codex/memories`. Classify only agent-facing Markdown: `AGENTS.md`, `CLAUDE.md`, `GEMINI.md`, `.agents/**/*.md`, `.claude/**/*.md`, `.cursor/**/*.{md,mdc}`, `.github/copilot-instructions.md`, `.github/instructions/**/*.md`, `skills/**/SKILL.md`, `.agents/skills/**`. Product docs, READMEs, changelogs, and public specs are truth evidence only.
 
-## Invocation guard
+Read the nearest `AGENTS.md`, `CLAUDE.md`, and repository rules first. Record `git status --short` before and after. Never inspect secret values. Never use `rm -rf`; `trash` approved removals. Use `apply_patch` for text. Label provider/runtime claims `NOT VERIFIED` unless this run checks the live system. Do not delete instruction, security, migration, incident, or destructive-safeguard files because they are old.
 
-Proceed only when the user explicitly invokes `$audit-memories` or `/audit-memories`. An OpenCode command may satisfy this guard by explicitly stating that the user invoked `/audit-memories` before injecting this file.
-
-Supported actions:
-
-- `$audit-memories audit`: exhaustive read-only audit. This is the default action when only `$audit-memories` is supplied.
-- `$audit-memories clean`: run or refresh the exhaustive audit, then apply justified local cleanup.
-- `/audit-memories audit` and `/audit-memories clean`: equivalent manual commands in clients that use slash-command syntax.
-
-Do not read or modify `~/.codex/memories`. Do not classify product documentation, public docs, README files, changelogs, or general project plans. They may be read only as truth evidence when an agent document references them.
-
-## Hard boundaries
-
-- Resolve the project root from the current working directory. Never silently switch to another checkout.
-- Read the nearest applicable `AGENTS.md`, `CLAUDE.md`, and repository rules before auditing.
-- Preserve unrelated dirty-tree changes. Record `git status --short` before and after.
-- Never inspect secret values. Compare environment-variable names through examples, schemas, and code only.
-- Never use `rm -rf`. Use `trash` for approved file removal.
-- Use `apply_patch` for textual edits. Use formatters only for mechanical normalization.
-- Do not infer deployed truth from local code. Label provider/runtime claims `NOT VERIFIED` unless the audit explicitly checks the live system.
-- Do not delete instruction files, security guidance, migration procedures, incident runbooks, or destructive-operation safeguards merely because they are old or rarely linked.
-
-## Action: audit
-
-### 1. Inventory every agent-facing Markdown file
+## Audit
 
 Run:
 
 ```bash
-python3 ~/.agents/skills/audit-memories/scripts/inventory_project_markdown.py \
-  --root "$PWD" \
-  --format json
-```
-
-Include only:
-
-- `AGENTS.md`, `CLAUDE.md`, `GEMINI.md`, and equivalent agent entrypoints;
-- `.agents/**/*.md`, `.claude/**/*.md`, and `.cursor/**/*.{md,mdc}`;
-- `.github/copilot-instructions.md` and `.github/instructions/**/*.md`;
-- project skill files under `skills/**/SKILL.md` or `.agents/skills/**`.
-
-This intentionally includes agent-generated plans, task traces, and output folders because they are prime cleanup candidates. Exclude public/local documentation such as `content/docs`, normal README files, product specs, and application changelogs from classification.
-
-The byte-level ledger must show `visited == eligible`. It is not a semantic audit by itself.
-
-### 2. Build the project truth map
-
-Inspect current primary evidence before classifying documents:
-
-1. repository instructions and package/workspace manifests;
-2. source tree, routes, exported APIs, schemas, migrations, and configuration;
-3. tests and CI workflows;
-4. current Git history only when a document makes a historical claim;
-5. live provider/runtime state only when explicitly requested and safely accessible.
-
-Start with `rg --files`, `package.json` or equivalent manifests, key configs, and the files referenced by Markdown. Follow repository instructions about required reading. Use targeted searches rather than loading the entire source tree blindly.
-
-Truth priority:
-
-```text
-explicit current user instruction
-> current code/config/schema
-> current tests and CI contracts
-> verified provider/runtime read-back
-> Markdown claims
-> historical memory
+python3 ~/.agents/skills/audit-memories/scripts/inventory_project_markdown.py --root "$PWD" --format json
 ```
 
-### 3. Review files one by one
-
-Read every eligible agent-facing Markdown file. Sampling is not completion.
-
-For more than 30 files, split the exact manifest into disjoint batches of 10–20. Use parallel subagents when available. Give each worker the shared truth map plus exact Markdown paths and read-only boundaries. Require one result row per path; verify that batch union equals the manifest with no duplicates.
-
-For each file, record:
-
-- purpose and intended audience;
-- whether referenced paths, commands, APIs, routes, names, versions, statuses, and architecture match current evidence;
-- overlap with other Markdown files;
-- broken local links and missing referenced files;
-- historical value and operational risk;
-- evidence paths and line numbers;
-- verdict: `KEEP`, `UPDATE`, `MERGE`, `ARCHIVE`, `DELETE`, or `VERIFY`.
-
-For important claims, use:
-
-- `VERIFIED`: directly supported by current local evidence;
-- `CONTRADICTED`: current evidence disproves it;
-- `NOT VERIFIED`: needs external/runtime evidence;
-- `HISTORICAL`: intentionally describes an old state;
-- `OPINION`: product/design intent, not a factual implementation claim.
-
-Load [cleanup-rubric.md](references/cleanup-rubric.md) before classification.
-
-### 4. Produce the audit report
-
-Return:
-
-- project root and Git status boundary;
-- files eligible, byte-visited, semantically reviewed, skipped, and failed;
-- current lines/bytes and projected post-clean totals;
-- verdict counts and defensible removal percentage;
-- one concise row per agent-facing Markdown file;
-- contradiction table with exact document and truth-source lines;
-- duplicate/merge clusters and canonical destination;
-- broken local links;
-- protected documents and why they must survive;
-- claims marked `NOT VERIFIED`.
-
-Do not create another report Markdown inside the project unless the user explicitly asks for a durable report.
-
-## Action: clean
-
-Run the complete audit first unless a still-current exhaustive audit exists for the same Git tree. Recheck hashes and `git status`; refresh changed files.
-
-Apply verdicts as follows:
-
-- `KEEP`: no change.
-- `UPDATE`: make the smallest accurate edit and preserve useful history.
-- `MERGE`: move unique knowledge into the declared canonical file, update inbound links, then `trash` the redundant file.
-- `ARCHIVE`: use only when historical value is real and the repository already has an archive convention.
-- `DELETE`: `trash` only after proving the file is redundant, contradicted without historical value, generated noise, or obsolete execution residue.
-- `VERIFY`: leave unchanged unless the required evidence is obtained.
-
-Before modifying any file, obey repository-specific read requirements. If the worktree is dirty, never overwrite overlapping user changes; downgrade that action to `BLOCKED` and continue with disjoint files.
-
-After edits:
+The byte ledger must show `visited == eligible`. Then read every eligible file. Over 30 files: disjoint batches of 10–20, one row per path, union equals the manifest.
 
-1. rerun the inventory and local-link checks;
-2. search for references to removed or renamed files;
-3. run proportionate repository validation through its required supervisor;
-4. inspect the final diff and confirm no non-Markdown behavior changed unintentionally;
-5. report exact files updated, merged, archived, trashed, blocked, and untouched.
+Load [cleanup-rubric.md](references/cleanup-rubric.md) before classifying. Verdict each file `KEEP`, `UPDATE`, `MERGE`, `ARCHIVE`, `DELETE`, or `VERIFY`. Mark important claims `VERIFIED`, `CONTRADICTED`, `NOT VERIFIED`, `HISTORICAL`, or `OPINION`.
 
-Do not commit or push unless explicitly requested.
+Return the root, git boundary, counts, projected totals, one row per file, contradictions with line evidence, merge clusters, broken links, protected files, and `NOT VERIFIED` claims. Do not write a report file unless asked.
 
-## Completion criteria
+## Clean
 
-Complete `audit` only when every eligible Markdown file has one semantic verdict and evidence.
+Reuse a still-current exhaustive audit for this Git tree; otherwise re-audit. Recheck hashes and `git status`. Apply verdicts: `KEEP` unchanged; `UPDATE` smallest accurate edit; `MERGE` unique knowledge into the canonical file, fix inbound links, then `trash`; `ARCHIVE` only with an existing archive convention; `DELETE` via `trash` only after a proven replacement or no-value rationale; `VERIFY` unchanged until evidence exists.
 
-Complete `clean` only when:
+If the worktree is dirty, skip overlapping user changes (`BLOCKED`) and continue on disjoint files. After edits: rerun inventory and link checks, search for removed or renamed paths, run proportionate repo validation, confirm the diff is Markdown-only. Do not commit or push unless asked.
 
-- the exhaustive ledger still matches the current tree;
-- every applied deletion has a proven canonical replacement or explicit no-value rationale;
-- links and references are repaired;
-- protected operational knowledge remains accessible;
-- validation results and blockers are reported separately;
-- the final dirty tree contains no accidental out-of-scope edits.
+Stop `audit` when every eligible file has one evidenced verdict. Stop `clean` when the ledger matches the tree, every deletion has a proven rationale, links are repaired, protected knowledge remains, validation and blockers are reported separately, and the dirty tree has no out-of-scope edits.

package/agents-config/skills/audit-skills/SKILL.md

@@ -5,75 +5,16 @@ argument-hint: "[audit|fix] [project-root]"
 disable-model-invocation: true
 ---
 
-# Audit Skills
-
-Audit skill discovery cost and placement from current files plus observable Codex and Claude session evidence. Treat missing telemetry as uncertainty, not proof that a skill has never been useful.
-
-## Invocation guard
-
-Proceed only when the current user message explicitly invokes `$audit-skills`.
-
-- `$audit-skills audit [project-root]`: produce a read-only audit. This is the default.
-- `$audit-skills fix [project-root]`: audit first, then apply only high-confidence corrections.
-
-Resolve `project-root` from the argument or current repository. Preserve unrelated dirty changes and record Git status for every modified repository.
-
-## Audit
-
-Run the deterministic inventory as a bounded job:
+Proceed only on an explicit `$audit-skills` invocation. Default `audit`; `fix` applies only high-confidence corrections after the ledger exists. Resolve `project-root` from the argument or current repo. Preserve unrelated dirty changes.
 
 ```bash
-bun ~/.agents/skills/audit-skills/scripts/audit-skills.mjs \
-  --project "$PWD" \
-  --format markdown
+bun ~/.agents/skills/audit-skills/scripts/audit-skills.mjs --project "$PWD" --format markdown
 ```
 
-The script inventories global `~/.agents/skills` and `<project>/.agents/skills`, then scans observable Codex and Claude histories for:
-
-- explicit user references such as `$skill-name` or `/skill-name`;
-- Claude `Skill` tool calls;
-- agent reads of a matching `SKILL.md`;
-- working directories associated with observed use;
-- Claude `disable-model-invocation` and Codex `policy.allow_implicit_invocation` controls;
-- name collisions and hardcoded project-root references.
-
-Report these evidence classes separately:
-
-- `OBSERVED_USER`: explicitly named by a user in scanned history;
-- `OBSERVED_MODEL`: loaded or invoked by an agent in scanned history;
-- `UNOBSERVED`: no matching evidence in scanned sources;
-- `EXPLICIT_ONLY`: protected for both Claude and Codex;
-- `INVOCATION_MISMATCH`: protected on only one platform;
-- `LOCALITY_CANDIDATE`: global skill with a project-specific runtime dependency or at least two observed uses confined to one project;
-- `NAME_COLLISION`: same skill name discovered globally and locally.
-
-Include scan coverage and limitations. Cursor ACP stores are opaque blobs and are not counted unless a reliable parser becomes available. Never label `UNOBSERVED` as “never used” without naming the scanned time range and sources.
-
-## Fix
-
-Apply changes only after the audit ledger exists.
-
-Safe automatic corrections:
-
-1. Mirror an existing explicit-only decision across platforms: add `disable-model-invocation: true` when Codex already blocks implicit invocation, or add `policy.allow_implicit_invocation: false` when Claude already blocks it.
-2. Mark a skill explicit-only when its own instructions already require direct user invocation but one or both platform controls are missing.
-3. Repair metadata made stale by a move or rename.
-
-Require explicit user direction or a project-specific runtime dependency before moving a skill between scopes. Multiple uses confined to one project justify review, not automatic relocation; a single observed use is insufficient evidence.
-
-When moving a skill:
-
-1. copy the complete directory, including scripts, references, assets, and `agents/openai.yaml`;
-2. rewrite absolute self-paths and dependencies to their new canonical locations;
-3. validate the destination before removing the source;
-4. use `trash` for source removal;
-5. search all skill roots and plugin/profile metadata for stale references;
-6. confirm the name is discovered exactly once in the intended scope.
-
-For unobserved skills, recommend rather than mutate unless their own text clearly establishes user-only intent. Rarely used incident, security, recovery, and migration skills remain protected from usage-only pruning.
+Report every inventoried skill with scan coverage and one evidence class: `OBSERVED_USER`, `OBSERVED_MODEL`, `UNOBSERVED`, `EXPLICIT_ONLY`, `INVOCATION_MISMATCH`, `LOCALITY_CANDIDATE`, `NAME_COLLISION`. Cursor ACP stores are opaque. Do not label `UNOBSERVED` as never used without naming the scanned range.
 
-## Completion criteria
+Safe automatic fixes: mirror an existing explicit-only decision across Claude/Codex; add missing explicit-only controls when the skill text already requires direct invocation; repair stale move/rename metadata. Move a skill between scopes only with explicit user direction or a project-specific runtime dependency. Copy the full directory, rewrite self-paths, validate, `trash` the source, then confirm the name is discovered once.
 
-Complete an audit only when every inventoried skill has a row, scan coverage is reported, and every recommendation cites static or usage evidence.
+Recommend rather than mutate unobserved skills. Protect incident, security, recovery, and migration skills from usage-only pruning.
 
-Complete a fix only when touched skills validate, moved dependencies resolve, unintended duplicate discovery is absent, and final Git status distinguishes pre-existing changes from this run.
+Done when every skill has a row, every recommendation cites evidence, and — on `fix` — touched skills validate and Git status distinguishes this run.