From ceedd80b8ea836b67aea6b5fb756577c712ea9b3 Mon Sep 17 00:00:00 2001 From: firaen22 Date: Fri, 24 Jul 2026 23:21:09 +0800 Subject: [PATCH 01/13] =?UTF-8?q?cross-model-review=20=C2=A73:=20pre-exist?= =?UTF-8?q?ing-vs-regression=20is=20a=20baseline=20diff,=20applicability?= =?UTF-8?q?=20is=20a=20runtime-state=20question?= MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit Two adjudication gaps for reviews of behavior-preserving refactor branches, class-distilled from a mining pass over the owner's own sessions (no code taken). §3 already reproduces findings before acting and tracks a pre-existing-tracked disposition, but does not say how you ESTABLISH pre-existing: on a refactor branch a reproduced defect can be one the branch faithfully carried over from master, so reproduce on the merge-base before counting it a regression the branch owns. And a finding can be non-applicable against runtime/deployment state (empty store, never-deployed writer) even when the source reads as a bug — adjudicate against the running system, not source alone. Co-Authored-By: Claude Fable 5 --- skills/cross-model-review/SKILL.md | 33 ++++++++++++++++++++++++++++++ 1 file changed, 33 insertions(+) diff --git a/skills/cross-model-review/SKILL.md b/skills/cross-model-review/SKILL.md index 40f13fe..d1f1fb1 100644 --- a/skills/cross-model-review/SKILL.md +++ b/skills/cross-model-review/SKILL.md @@ -105,6 +105,29 @@ objection is not re-litigated — but a *reproduced* correctness or safety defec stays must-fix (§3 triage): it may be deferred only with the owner's explicit acceptance, never closed by the reviewers on their own. +**Pre-existing is a disposition you establish, not assume — reproduce the +finding on the merge-base too.** On a behavior-preserving refactor branch a +*reproduced* defect can still be one the branch faithfully carried over from +master, not one it introduced; recording it against the branch is a false +regression that blocks a clean refactor for a fault it did not create. Before +you count a reproduced finding as the branch's defect, re-run it against the +merge-base: present on both → `pre-existing-tracked`, spun off as its own +fix, never bloating the refactor; gone on master and live on the branch → a real +regression this branch owns. Reviewers do not see master (§2 packet is your +inlined lines), so this classification is yours to make, not theirs — a +reviewer's severity label ("not merge-ready", "CRITICAL") is a claim about +the code in front of it, blind to whether the branch introduced the behavior. +And applicability is itself a **runtime/deployment-state** question, not a +source one: a migration or identifier case-collision finding that no live +data can trigger — empty store, writer never deployed — is an irreproducible +false positive (§4), not a regression this branch owns. Reproduce against +what actually shipped (query the collection, check the deploy), not synthetic +data the bug reproduces on but the running system never holds. +neg: filing a reviewer's "P1, not merge-ready" against a refactor for a quirk +that reproduces identically on the merge-base — the review still pays off (spin +the quirk off as its own fix), but the branch is clean and the label was +baseline-blind. + **A proposed fix is a suggestion, not a patch.** Reproducing a finding licenses the finding, not its remedy — these are separate judgments, and a reviewer writes the remedy against only the lines you inlined (§2), so a real @@ -232,6 +255,16 @@ the reason recorded. The landed side is verifiable in-repo (PR #32's commits); the held side was never pushed, so the comparison itself is contributor-reported — the rule ships with an in-body `unprobed` marker per the README covenant's second branch. +The §3 baseline-classification and runtime-state adjudication rules +(2026-07-24) are class-distilled from a mining pass over the owner's own +sessions (no code taken): a moira-web behavior-preserving refactor where +codex's "not merge-ready" and agy's "CRITICAL" both dissolved under +reproduction as pre-existing master behaviors the branch faithfully preserved +(0 regressions, 4 pre-existing quirks spun off), and a TG-bot review where +codex's identifier-migration and case-collision findings were non-applicable +because the store was empty and the writer had never deployed. The lesson +is the general one — pre-existing-vs-regression is a baseline diff, and +applicability is a runtime-state question — not the specific findings. Re-verify line: model families, CLI availability, "flagship" identity, and effort tiers are volatile — re-discover at session time; never trust a model name or tier From 3272a11a615f0bb525d9a42cb1eb5b191f6ac654 Mon Sep 17 00:00:00 2001 From: firaen22 Date: Fri, 24 Jul 2026 23:22:15 +0800 Subject: [PATCH 02/13] =?UTF-8?q?delegation-and-review=20=C2=A73:=20a=20re?= =?UTF-8?q?ad-only=20survey=20reports=20leads,=20not=20facts?= MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit Fan-out finders scanning for dedup targets, dead code, or duplication over-claim in the scope-inflating direction — substring counts, false 'byte-identical', dissolving dedups, 'dead' code with live registrations. §3 already covers the empty-input synthesizer (confabulates from nothing) and the settled-tree re-read; this is the distinct third case: the survey ran, returned non-empty, and every finding was a confidently-wrong lead. Re-verify each in source before speccing, and re-check whenever a finding reverses scope, because the plan built on the survey is now stale. Class-distilled from a mining pass over the owner's own sessions (no code taken). Co-Authored-By: Claude Fable 5 --- skills/delegation-and-review/SKILL.md | 27 +++++++++++++++++++++++++++ 1 file changed, 27 insertions(+) diff --git a/skills/delegation-and-review/SKILL.md b/skills/delegation-and-review/SKILL.md index e031032..07e03e5 100644 --- a/skills/delegation-and-review/SKILL.md +++ b/skills/delegation-and-review/SKILL.md @@ -576,6 +576,20 @@ reviewers that they silently absorb as implementers. its inputs arrived. ❌ "the synthesis stage returned a thorough report, so the finders must have run." +- **A read-only survey reports leads, not facts — re-verify each in source + before you spec work on it.** Fan-out finders scanning for dedup targets, + dead code, or duplication over-claim in the direction that makes the work + look bigger: a substring grep calls "66 import sites" what is really 2 + files; "byte-identical" components turn out to diverge on a prop or a + fallback; a "duplicated" helper is two semantically incompatible families + that must not be merged; "dead" code has a live registry entry the finder + never traced. Each finding is a hypothesis — open the cited files and + confirm the claim before it enters the plan, and re-check after any finding + that reverses scope (a dissolved dedup, a resurrected dead file), because + the tier ranking built on the survey is now stale. Speccing on an + unverified survey buys a plan that reverses mid-execution. + ❌ "the survey found 66 three.js sites, so the dedup is a big win" — the + finder counted substrings; there are 2. - **Miss-is-costly audits** ("find ALL of X": security holes, money paths, data leaving the machine) need a different loop than one review pass: - Scout the work-list once in-context first — fan out over a known list, @@ -975,6 +989,19 @@ Rules bullet was also extended from "do not merge" to "do not commit, push, or merge" (generalizing mindfold-ai/Trellis's check-agent forbidden-operations list, AGPLv3 — strictly ideas only) — a widening of an existing prohibition, not a new standalone rule, so it owes no separate probe. +The §3 survey-reports-leads bullet (2026-07-24) is class-distilled from a +private mining pass over the owner's own sessions (no code taken): a single +lightweight-the-codebase session whose read-only fan-out survey was wrong four +separate ways, each over-claiming — a substring count of "66 three.js sites" +that was 2 files, "byte-identical" components that diverged on a prop and a +fallback, a "NumField duplication" that dissolved into two incompatible +families, and a "dead" component with a live registry entry — each reversal +re-ordering the tiered plan. Distinct from the synthesizer-fed-nothing bullet +above (empty input → confident synthesis) and the settled-tree bullet +(re-reading an already-fixed file): here the survey ran and returned +non-empty, confidently wrong leads. Private evidence, cited as shape per the +README covenant's second branch; no in-repo probe has run — in-body +`unprobed` marker. Stable behavioral rules; re-check worktree/agent mechanics and any recorded hosted-endpoint behavioral claims against the current environment. From 5a04f92a5613844d6363efba57181149f5378cfc Mon Sep 17 00:00:00 2001 From: firaen22 Date: Fri, 24 Jul 2026 23:23:46 +0800 Subject: [PATCH 03/13] ground-truth-gates: a gate over hardcoded facts asserts the facts, not just the shape MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit New rule 6 under 'What makes a gate real'. When code embeds domain constants (holiday dates, rates, valid-state sets), a structure-only suite passes whether the values are right or a later edit corrupted one. The values were cross-checked once — but in the conversation, which evaporates at session end. Anchor the load-bearing values as assertions from the authority you already consulted, so a future silent constant change fails. This is item 2's change-detector carve-out used correctly (the value IS the contract). Class-distilled from a mining pass over the owner's own sessions (no code taken): a 'tests check shape, not date-truth' cross-model finding on hardcoded holiday dates. Co-Authored-By: Claude Fable 5 --- skills/ground-truth-gates/SKILL.md | 34 ++++++++++++++++++++++++++++++ 1 file changed, 34 insertions(+) diff --git a/skills/ground-truth-gates/SKILL.md b/skills/ground-truth-gates/SKILL.md index f69a1b9..53452a8 100644 --- a/skills/ground-truth-gates/SKILL.md +++ b/skills/ground-truth-gates/SKILL.md @@ -269,6 +269,32 @@ A generic green test is not proof. A gate is real only if: elsewhere — is legitimate as-is and needs no anchor, as does an intrinsic gate like a syntax or forbidden-character scan. The rule bites only when agreement is made to stand in for an external fact.) +8. **A gate over hardcoded facts asserts the facts, not just the shape — and + the cross-check that established them belongs IN the fixture, not in the + chat** (`unprobed` — private incident as shape; see Provenance). When code + embeds domain constants (holiday dates, a tax rate, a fee schedule, the set + of valid states), a suite that checks structure — the array is non-empty, + each entry parses, the shape is right — passes identically whether the + values are correct or a later edit corrupted one. Those values were usually + cross-checked once, against an authority or several independent sources or a + reviewer's recall — but that check happened in the conversation and + evaporates when the session ends, so the next bad edit sails through a + shape-only gate. Anchor the fact: assert the specific load-bearing values + (a fixed holiday falls on its known date, the standard rate equals the + published number), from the authority you already consulted, so a future + silent change to a constant fails. This *extends* item 2's carve-out — + from an output-interface string to an embedded input constant — and is NOT + item 3's "hardcoded expected value" fake pass: the anchor's value comes from + an external authority, not copied back from the code's own output. Item 3's + tautology asserts the source is the source; this asserts the source matches + the world. It shares rule 7's remedy — an external anchor — but not its + trigger: rule 7 bites where *agreement between artifacts* is made to stand + in for an external fact, this one where *structure* is. A fact that + legitimately changes gets the value versioned (the regenerate-and-diff rule + below), an always-fixed one is cheap to anchor permanently. + ❌ "the holiday tests pass" — they assert the list has the right count and + types, never that any date is the right day; a fat-fingered edit to one + date stays green. **A red result is not automatically a real defect** — but ruling one "environmental" is a gate change, not the worker's call (rule 4): quarantine it @@ -446,5 +472,13 @@ unless the project opted in (MIT, ideas only), corroborated by NYCU-Chung/my-claude-devteam's bypassPermissions-hook framing (MIT) — it matches this pack's own no-auto-registered-hooks invariant. All three ship `unprobed` per the covenant; their probes join the private round-5 queue. +Rule 8 (fact-anchoring; 2026-07-24) is class-distilled from a mining pass +over the owner's own sessions (no code taken): hardcoded public-holiday dates +were cross-checked against four independent sources, but a cross-model +reviewer noted the suite validated structure only — "tests check shape, not +date-truth" — so the truth evidence lived in the conversation, not the gate; +the fix added anchor-date assertions as a regression guard against a future +bad edit. Ships `unprobed` per the covenant; its probe joins the private +round-5 queue. `template/` scripts are self-contained (Node + bash, zero deps) and were run green on 2026-07-06 with Node v23; re-verify with `bash template/run-all.sh`. From 89f505f7f81a1cfef5ce2befe3ac1d711712711f Mon Sep 17 00:00:00 2001 From: firaen22 Date: Fri, 24 Jul 2026 23:24:52 +0800 Subject: [PATCH 04/13] =?UTF-8?q?skill-authoring=20=C2=A72:=20a=20capabili?= =?UTF-8?q?ty=20you=20describe=20for=20a=20weaker=20executor=20is=20a=20cl?= =?UTF-8?q?aim=20to=20verify=20live=20before=20the=20doc=20ships?= MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit A skill/runbook that tells a weaker model a capability exists ('the engine auto-searches every category', 'this flag does X') is executed verbatim by the reader least able to notice it is wrong — shipping it unverified ships a false instruction. When the behavior is new or just-patched, prove it against a real gate, THEN finalize the doc; a scarce/expiring live session argues for verifying FIRST, not for shipping on the theory it probably works. Positive twin of §3's capability-negative rule. Class-distilled from a mining pass over the owner's own sessions (no code taken). Co-Authored-By: Claude Fable 5 --- skills/skill-authoring/SKILL.md | 22 ++++++++++++++++++++++ 1 file changed, 22 insertions(+) diff --git a/skills/skill-authoring/SKILL.md b/skills/skill-authoring/SKILL.md index 30df5c0..5af426d 100644 --- a/skills/skill-authoring/SKILL.md +++ b/skills/skill-authoring/SKILL.md @@ -84,6 +84,19 @@ artifact-producing step. - What cannot be verified is labeled `unverified` or `user-must-provide` — never silently invented. Unproven ideas stay labeled open/candidate; no oversell. +- **Verify-before-you-write-it bites hardest on a capability you describe for a + weaker executor** (`unprobed` — private incident as shape; see Provenance). + "The engine auto-searches every category", "this flag does X" — a weak model + executes such a line verbatim, with none of your context to catch it when it + is wrong, so an unverified capability claim is a false instruction to the one + reader least able to notice. When the behavior is new or just-patched, order + it: prove it against a real gate (ground-truth-gates), THEN finalize the doc + that describes it. A scarce live session (an auth window about to expire, a + costly remote setup) argues for verifying FIRST, not for shipping the doc on + the theory it probably works. + ❌ drafting "the engine now self-heals across categories" into the skill + while the self-heal fix is still unproven, to spend the login session before + it expires. - Embed the knowledge itself; do not make private paths or one person's memory a load-bearing reference. A hard-coded machine-absolute path is worse than a broken link: a stale duplicate clone resolves *silently* to an @@ -880,3 +893,12 @@ its scope-install / invoke-by-name / prune mitigation ladder (MathWorks field-of-use license — ideas only, no text). Both ship `unprobed` per the covenant; their probes join the private round-5 queue — the catalog-collision rule's is directly runnable against this pack's own 12 skills. +The §2 verify-capability-before-shipping-the-doc rule (2026-07-24) is +class-distilled from a mining pass over the owner's own sessions (no code +taken): with a scarce authenticated remote session about to expire, doc edits +describing a just-patched self-heal behavior were held until a regression gate +proved the behavior, on the explicit reasoning that telling the weaker model +"the engine auto-searches all categories" is a capability claim that must be +verified live first or it ships a false instruction. Ships `unprobed` per the +covenant; +its probe joins the private round-5 queue. From 91e2786db2ebb862ee738331b99cf865376de146 Mon Sep 17 00:00:00 2001 From: firaen22 Date: Sat, 25 Jul 2026 08:14:35 +0800 Subject: [PATCH 05/13] =?UTF-8?q?skill-authoring=20=C2=A73+=C2=A77:=20four?= =?UTF-8?q?=20maintenance-pass=20rules=20from=20one=20staleness=20incident?= MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit §3: staleness concentrates in world-fact rules (scope the audit there); an invalidation clause must bind to a surface the work already touches. §7: probe a candidate rule against the bare executor before folding it in; a derived file contradicting reality may be mirroring a wrong source. Co-Authored-By: Claude Opus 5 --- skills/skill-authoring/SKILL.md | 64 +++++++++++++++++++++++++++++++++ 1 file changed, 64 insertions(+) diff --git a/skills/skill-authoring/SKILL.md b/skills/skill-authoring/SKILL.md index 30df5c0..017199c 100644 --- a/skills/skill-authoring/SKILL.md +++ b/skills/skill-authoring/SKILL.md @@ -94,6 +94,17 @@ artifact-producing step. ## 3. Provenance and decay - Date-stamp volatile facts (versions, flags, model names, defaults). +- **Staleness concentrates in the world-fact rules — audit there first** + (`unprobed` — private incident as shape; see Provenance). A rule encoding a + fact about the outside world (which model or tool is default, how a CLI + behaves, a numeric threshold someone measured) goes stale on a timescale of + days. A rule encoding method (reproduce before trusting, verify by execution) + does not go stale at all. A staleness audit is therefore not a uniform sweep + of every file: concentrate the search on the files carrying dated facts and + treat the method-encoding files as low-yield. One sweep of four rules files + found every stale instance — 8 of 8 — in the single file that carried + world-facts; the three method files were clean. This scopes the SEARCH only: + a method file still gets corrected when something does surface in it. - **Capability-negative claims rot the worst** (`unprobed` — private incident as shape; see Provenance). About to write "no such flag", "only works interactively", "the API can't do X" into an instruction file — or @@ -158,6 +169,16 @@ artifact-producing step. - End each skill with a short provenance note and a one-line re-verification command for anything that may drift. A skill without a re-verification path decays into exactly the stale-instruction problem it was meant to solve. + **And that command has to hang off something the work already touches** + (`unprobed` — private incident as shape; see Provenance): an invalidation + condition needing a separate act of remembering is inert no matter how + precisely it is written. Bind it to a surface the next pass crosses anyway — + a line in the maintenance entry that pass must read, an assertion in a gate + that already runs, a trigger on a file someone edits regardless. A measured + finding carrying the clause "re-test if either file grows past ~250 lines" + sat at 297 and 318 for days, still cited as current: the threshold was + right, the condition was true, and nothing was reading it. + ❌ "the invalidation condition is documented at the end of the finding." - **A merged upstream integration is not necessarily the end of the campaign** (`unprobed` — the upstream half of the incident is verifiable in this repo's PR history, the sync half @@ -557,6 +578,31 @@ default; an AI rewrite does not launder a derivative). the §6 review. Ask the user first before weakening or deleting any rule that gates destructive actions, spending, or publishing — or any rule the user set explicitly. +- **Probe a candidate rule against the bare executor before folding it in** + (`unprobed` — measured in-house; see Provenance). §6's behavioral probe hunts + gaps: what the file fails to make happen. This asks the opposite question, + before the rule exists — run the scenario twice against the file's target + executor, once with no rule and once with it. Where the bare run already + produces the behavior, the rule is non-discriminating: it costs a line and + buys nothing, and belongs in a reference file or nowhere, not in the + always-loaded one. Eight rules folded into two files over one week were + probed this way afterwards; three were reproduced unaided. Non-discriminating + is not the same as wrong — the rule can be true and still not worth its line, + and that is the judgment the probe is for. + ❌ "the rule is correct and clearly written, so it earns a line." +- **A derived file contradicting reality has not necessarily drifted — read its + source before fixing it** (`unprobed` — private incident as shape; see + Provenance). Where a file is compiled from another (a cache over a playbook, a + rules file over a spec), the obvious reading of a wrong line is that the + derivative fell behind. Check whether the SOURCE carries the identical wrong + text first. If it does, this is not drift: the derivative is faithfully + mirroring a source that itself disagrees with the world, and correcting only + the derivative gets it silently re-broken by the next compile or write-back. + Fix both, and record which was authoritative. Distinct from §4's sync + contract, which governs two files that DISAGREE — here they agree with each + other and are both wrong (ground-truth-gates rule 7's mutual-agreement trap, + arising in maintenance rather than in a gate). + ❌ "the cache says X, reality says Y — so the cache drifted; fix the cache." - Compaction triggers — act when any of these is true: a skill outgrows what a reader can hold (~150 lines for discipline skills; domain-reference packs run longer, but every line must still earn its place); its description no @@ -880,3 +926,21 @@ its scope-install / invoke-by-name / prune mitigation ladder (MathWorks field-of-use license — ideas only, no text). Both ship `unprobed` per the covenant; their probes join the private round-5 queue — the catalog-collision rule's is directly runnable against this pack's own 12 skills. +The §3 world-fact-staleness and bound-invalidation rules and the §7 +bare-executor-probe and read-the-source-before-fixing rules (2026-07-25) are +class-distilled from a maintenance session on the owner's own rules files (no +code taken), and are one incident seen from four sides. A finding measuring +rule-following at two file sizes carried the clause "re-test if either file +grows past ~250 lines"; both files reached 297 and 318 and the clause never +fired, because nothing read it — the bound-invalidation rule. The re-test that +eventually ran added a bare-executor control arm the original lacked, and found +3 of 8 recently-folded rules reproduced with no rules file at all — the +bare-executor-probe rule, the one item here with a measurement rather than a +shape behind it (n=8 rules, 1 probe per cell; it detects a large effect, not a +small one). The staleness sweep that followed found all 8 stale instances in +the one file carrying model names and CLI behavior, none in the three carrying +method — the world-fact rule. And one of those stale lines turned out to be +copied faithfully from a source file carrying the same error, so fixing the +derived file alone would have been undone by the next write-back — the +read-the-source rule. All four ship `unprobed` per the covenant; their probes +join the private round-5 queue. From 8f8413f2b9a7f5b8c7f9b1fbe636abdc872d4690 Mon Sep 17 00:00:00 2001 From: F-e-u-e-r <189464303+F-e-u-e-r@users.noreply.github.com> Date: Sun, 26 Jul 2026 19:59:36 +0800 Subject: [PATCH 06/13] =?UTF-8?q?Fix=20#82's=20sync-contract=20cross-refer?= =?UTF-8?q?ence:=20the=20clause=20lives=20in=20=C2=A73,=20not=20=C2=A74?= MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit The sync-contract bullet ("When two files must agree, write the sync contract down... must name which file wins on disagreement") sits in §3 Provenance and decay; §5 already cites it as "§3's sync contract naming". §4 is Memory architecture and carries no sync contract. Co-Authored-By: Claude Fable 5 Claude-Session: https://claude.ai/code/session_01WMbbZQ8ZMMsNRGyV2nvJR8 --- skills/skill-authoring/SKILL.md | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/skills/skill-authoring/SKILL.md b/skills/skill-authoring/SKILL.md index b0378c8..3fc6110 100644 --- a/skills/skill-authoring/SKILL.md +++ b/skills/skill-authoring/SKILL.md @@ -611,7 +611,7 @@ default; an AI rewrite does not launder a derivative). text first. If it does, this is not drift: the derivative is faithfully mirroring a source that itself disagrees with the world, and correcting only the derivative gets it silently re-broken by the next compile or write-back. - Fix both, and record which was authoritative. Distinct from §4's sync + Fix both, and record which was authoritative. Distinct from §3's sync contract, which governs two files that DISAGREE — here they agree with each other and are both wrong (ground-truth-gates rule 7's mutual-agreement trap, arising in maintenance rather than in a gate). From 53d5271f64daa757e194ba9eb5eed38da5e72e8e Mon Sep 17 00:00:00 2001 From: F-e-u-e-r <189464303+F-e-u-e-r@users.noreply.github.com> Date: Sun, 26 Jul 2026 20:09:51 +0800 Subject: [PATCH 07/13] Fold gate r1 (grok-4.5 high): 3 must-fixes + 2 adopted nits MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit - cross-model-review §3: the applicability arm no longer files a synthetic-reproducible finding under §4's irreproducible-false-positive bucket (that bucket is for findings that do not reproduce at all); runtime non-applicability is now rejected-with-reason with counter- evidence or owner-accepted deferral, and a latent path the branch itself introduces stays must-fix. Ownership stays a merge-base question; applicability is severity, not ownership. - cross-model-review §3: 'gone on master' -> 'gone on the merge-base' (consistent with the arm's own re-run target on a long-lived branch). - cross-model-review §3: in-body unprobed marker + covenant line added (house convention; siblings carry it). - delegation-and-review §3: Provenance claimed an in-body unprobed marker the bullet lacked — marker added. - ground-truth-gates rule 8: a legitimately-changing fact now routes to rule 4's test-edit-is-a-contract-edit, not the regenerate-and-diff rule (that rule is for committed generated artifacts). Co-Authored-By: Claude Fable 5 Claude-Session: https://claude.ai/code/session_01WMbbZQ8ZMMsNRGyV2nvJR8 --- skills/cross-model-review/SKILL.md | 25 +++++++++++++++++-------- skills/delegation-and-review/SKILL.md | 3 ++- skills/ground-truth-gates/SKILL.md | 5 +++-- 3 files changed, 22 insertions(+), 11 deletions(-) diff --git a/skills/cross-model-review/SKILL.md b/skills/cross-model-review/SKILL.md index d1f1fb1..c483f43 100644 --- a/skills/cross-model-review/SKILL.md +++ b/skills/cross-model-review/SKILL.md @@ -106,23 +106,30 @@ stays must-fix (§3 triage): it may be deferred only with the owner's explicit acceptance, never closed by the reviewers on their own. **Pre-existing is a disposition you establish, not assume — reproduce the -finding on the merge-base too.** On a behavior-preserving refactor branch a +finding on the merge-base too** (`unprobed` — see Provenance). On a +behavior-preserving refactor branch a *reproduced* defect can still be one the branch faithfully carried over from master, not one it introduced; recording it against the branch is a false regression that blocks a clean refactor for a fault it did not create. Before you count a reproduced finding as the branch's defect, re-run it against the merge-base: present on both → `pre-existing-tracked`, spun off as its own -fix, never bloating the refactor; gone on master and live on the branch → a real -regression this branch owns. Reviewers do not see master (§2 packet is your +fix, never bloating the refactor; gone on the merge-base and live on the +branch → a real regression this branch owns. Reviewers do not see master (§2 packet is your inlined lines), so this classification is yours to make, not theirs — a reviewer's severity label ("not merge-ready", "CRITICAL") is a claim about the code in front of it, blind to whether the branch introduced the behavior. And applicability is itself a **runtime/deployment-state** question, not a -source one: a migration or identifier case-collision finding that no live -data can trigger — empty store, writer never deployed — is an irreproducible -false positive (§4), not a regression this branch owns. Reproduce against -what actually shipped (query the collection, check the deploy), not synthetic -data the bug reproduces on but the running system never holds. +source one: adjudicate a migration or identifier case-collision finding +against what actually shipped (query the collection, check the deploy), +never only against synthetic data the bug reproduces on but the running +system never holds. A finding whose premise no shipped state satisfies — +empty store, writer never deployed — is recorded `rejected-with-reason` +with that runtime counter-evidence attached, or held as an owner-accepted +deferral where the state could yet arrive; do not file it under §4's +irreproducible-false-positive bucket, which is for findings that do not +reproduce at all. Non-applicability is severity evidence, not ownership +evidence: a latent path the branch itself introduces stays its own +must-fix however empty today's store is — deployment catches up. neg: filing a reviewer's "P1, not merge-ready" against a refactor for a quirk that reproduces identically on the merge-base — the review still pays off (spin the quirk off as its own fix), but the branch is clean and the label was @@ -265,6 +272,8 @@ codex's identifier-migration and case-collision findings were non-applicable because the store was empty and the writer had never deployed. The lesson is the general one — pre-existing-vs-regression is a baseline diff, and applicability is a runtime-state question — not the specific findings. +Both rules ship `unprobed` per the covenant; their probes join the private +round-5 queue. Re-verify line: model families, CLI availability, "flagship" identity, and effort tiers are volatile — re-discover at session time; never trust a model name or tier diff --git a/skills/delegation-and-review/SKILL.md b/skills/delegation-and-review/SKILL.md index 07e03e5..658e5c3 100644 --- a/skills/delegation-and-review/SKILL.md +++ b/skills/delegation-and-review/SKILL.md @@ -577,7 +577,8 @@ reviewers that they silently absorb as implementers. ❌ "the synthesis stage returned a thorough report, so the finders must have run." - **A read-only survey reports leads, not facts — re-verify each in source - before you spec work on it.** Fan-out finders scanning for dedup targets, + before you spec work on it** (`unprobed` — private evidence as shape; see + Provenance). Fan-out finders scanning for dedup targets, dead code, or duplication over-claim in the direction that makes the work look bigger: a substring grep calls "66 import sites" what is really 2 files; "byte-identical" components turn out to diverge on a prop or a diff --git a/skills/ground-truth-gates/SKILL.md b/skills/ground-truth-gates/SKILL.md index 53452a8..ba3511e 100644 --- a/skills/ground-truth-gates/SKILL.md +++ b/skills/ground-truth-gates/SKILL.md @@ -290,8 +290,9 @@ A generic green test is not proof. A gate is real only if: the world. It shares rule 7's remedy — an external anchor — but not its trigger: rule 7 bites where *agreement between artifacts* is made to stand in for an external fact, this one where *structure* is. A fact that - legitimately changes gets the value versioned (the regenerate-and-diff rule - below), an always-fixed one is cheap to anchor permanently. + legitimately changes gets its anchor updated as a contract edit (rule 4: + state which contract changed and who approved it); an always-fixed one is + cheap to anchor permanently. ❌ "the holiday tests pass" — they assert the list has the right count and types, never that any date is the right day; a fat-fingered edit to one date stays green. From 006300396980876f1860825b9314aea1428d9137 Mon Sep 17 00:00:00 2001 From: F-e-u-e-r <189464303+F-e-u-e-r@users.noreply.github.com> Date: Sun, 26 Jul 2026 20:14:54 +0800 Subject: [PATCH 08/13] Fold gate r1 (gpt-5.6-luna ultra): 5 unique must-fixes + 1 adopted nit MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit Three of luna's eight were independent rediscoveries of grok's r1 findings, already folded. The five unique: - cross-model-review §3: pre-existing-tracked no longer reads as auto-non-blocking — pre-existing moves WHERE a reproduced correctness/safety defect gets fixed, never WHETHER; deferral stays the owner's call per this section's triage. - ground-truth-gates rule 8: each anchor assertion now carries its authority and consultation date beside the value — an unattributed literal is indistinguishable from item 3's copied-back expected value. - skill-authoring §3: 'does not go stale at all' -> 'goes stale rarely and slowly', low-yield 'not as exempt' (the absolute claim contradicted the bullet's own escape clause and overclaimed from an n=1 sweep; overturns this integrator's r1 rejection of the same point raised as a grok nit). - skill-authoring §7 bare-executor probe: a bare pass counts only when the run demonstrably met the rule's trigger (not-armed discipline), and one pass screens for a large effect only — close calls re-run before demoting. - skill-authoring §7 derived-file rule: 'Fix both' -> fix the source, bring the derivative along through its regeneration/write-back path (hand-editing a machine-compiled artifact is what ground-truth-gates forbids). - delegation-and-review §3 (nit adopted): confirming a survey claim now includes tracing the references its verdict depends on — matching the bullet's own dead-code-with-live-registry example. Co-Authored-By: Claude Fable 5 Claude-Session: https://claude.ai/code/session_01WMbbZQ8ZMMsNRGyV2nvJR8 --- skills/cross-model-review/SKILL.md | 6 ++++-- skills/delegation-and-review/SKILL.md | 3 ++- skills/ground-truth-gates/SKILL.md | 6 ++++-- skills/skill-authoring/SKILL.md | 21 ++++++++++++++------- 4 files changed, 24 insertions(+), 12 deletions(-) diff --git a/skills/cross-model-review/SKILL.md b/skills/cross-model-review/SKILL.md index c483f43..be1422c 100644 --- a/skills/cross-model-review/SKILL.md +++ b/skills/cross-model-review/SKILL.md @@ -113,8 +113,10 @@ master, not one it introduced; recording it against the branch is a false regression that blocks a clean refactor for a fault it did not create. Before you count a reproduced finding as the branch's defect, re-run it against the merge-base: present on both → `pre-existing-tracked`, spun off as its own -fix, never bloating the refactor; gone on the merge-base and live on the -branch → a real regression this branch owns. Reviewers do not see master (§2 packet is your +fix, never bloating the refactor — pre-existing moves where a reproduced +correctness or safety defect gets fixed, never whether (deferral stays the +owner's call per this section's triage); gone on the merge-base and live on +the branch → a real regression this branch owns. Reviewers do not see master (§2 packet is your inlined lines), so this classification is yours to make, not theirs — a reviewer's severity label ("not merge-ready", "CRITICAL") is a claim about the code in front of it, blind to whether the branch introduced the behavior. diff --git a/skills/delegation-and-review/SKILL.md b/skills/delegation-and-review/SKILL.md index 658e5c3..b84272f 100644 --- a/skills/delegation-and-review/SKILL.md +++ b/skills/delegation-and-review/SKILL.md @@ -584,7 +584,8 @@ reviewers that they silently absorb as implementers. files; "byte-identical" components turn out to diverge on a prop or a fallback; a "duplicated" helper is two semantically incompatible families that must not be merged; "dead" code has a live registry entry the finder - never traced. Each finding is a hypothesis — open the cited files and + never traced. Each finding is a hypothesis — open the cited files, tracing + the references its verdict depends on (registries, routes, call sites), and confirm the claim before it enters the plan, and re-check after any finding that reverses scope (a dissolved dedup, a resurrected dead file), because the tier ranking built on the survey is now stale. Speccing on an diff --git a/skills/ground-truth-gates/SKILL.md b/skills/ground-truth-gates/SKILL.md index ba3511e..a69e452 100644 --- a/skills/ground-truth-gates/SKILL.md +++ b/skills/ground-truth-gates/SKILL.md @@ -281,8 +281,10 @@ A generic green test is not proof. A gate is real only if: evaporates when the session ends, so the next bad edit sails through a shape-only gate. Anchor the fact: assert the specific load-bearing values (a fixed holiday falls on its known date, the standard rate equals the - published number), from the authority you already consulted, so a future - silent change to a constant fails. This *extends* item 2's carve-out — + published number), each assertion naming its authority and consultation + date beside the value — an unattributed literal is indistinguishable from + item 3's copied-back expected value — so a future silent change to a + constant fails. This *extends* item 2's carve-out — from an output-interface string to an embedded input constant — and is NOT item 3's "hardcoded expected value" fake pass: the anchor's value comes from an external authority, not copied back from the code's own output. Item 3's diff --git a/skills/skill-authoring/SKILL.md b/skills/skill-authoring/SKILL.md index 3fc6110..114d4d7 100644 --- a/skills/skill-authoring/SKILL.md +++ b/skills/skill-authoring/SKILL.md @@ -111,11 +111,11 @@ artifact-producing step. (`unprobed` — private incident as shape; see Provenance). A rule encoding a fact about the outside world (which model or tool is default, how a CLI behaves, a numeric threshold someone measured) goes stale on a timescale of - days. A rule encoding method (reproduce before trusting, verify by execution) - does not go stale at all. A staleness audit is therefore not a uniform sweep - of every file: concentrate the search on the files carrying dated facts and - treat the method-encoding files as low-yield. One sweep of four rules files - found every stale instance — 8 of 8 — in the single file that carried + days; a rule encoding method (reproduce before trusting, verify by + execution) goes stale rarely and slowly. A staleness audit therefore + concentrates the search on the files carrying dated facts and treats the + method-encoding files as low-yield — not as exempt. One sweep of four rules + files found every stale instance — 8 of 8 — in the single file that carried world-facts; the three method files were clean. This scopes the SEARCH only: a method file still gets corrected when something does surface in it. - **Capability-negative claims rot the worst** (`unprobed` — private incident @@ -595,7 +595,11 @@ default; an AI rewrite does not launder a derivative). (`unprobed` — measured in-house; see Provenance). §6's behavioral probe hunts gaps: what the file fails to make happen. This asks the opposite question, before the rule exists — run the scenario twice against the file's target - executor, once with no rule and once with it. Where the bare run already + executor, once with no rule and once with it. A bare pass counts only when + the run demonstrably met the rule's trigger (ground-truth-gates' not-armed + discipline: a run that never hit the guarded condition is excluded and + re-run), and one pass screens for a large effect only — a close or + surprising call re-runs before demoting. Where the armed bare run already produces the behavior, the rule is non-discriminating: it costs a line and buys nothing, and belongs in a reference file or nowhere, not in the always-loaded one. Eight rules folded into two files over one week were @@ -611,7 +615,10 @@ default; an AI rewrite does not launder a derivative). text first. If it does, this is not drift: the derivative is faithfully mirroring a source that itself disagrees with the world, and correcting only the derivative gets it silently re-broken by the next compile or write-back. - Fix both, and record which was authoritative. Distinct from §3's sync + Fix the source, bring the derivative along through its own regeneration or + write-back path where one exists (hand-editing a machine-compiled artifact + is what ground-truth-gates' regenerate-and-diff rule forbids), and record + which was authoritative. Distinct from §3's sync contract, which governs two files that DISAGREE — here they agree with each other and are both wrong (ground-truth-gates rule 7's mutual-agreement trap, arising in maintenance rather than in a gate). From 43a0116b7419c434608daa6c3292fbb199a9e510 Mon Sep 17 00:00:00 2001 From: F-e-u-e-r <189464303+F-e-u-e-r@users.noreply.github.com> Date: Sun, 26 Jul 2026 20:25:58 +0800 Subject: [PATCH 09/13] Fold gate r2: luna FIX 4 + adopted nits from both lenses (grok r2 PROCEED) MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit Luna's four (all confirmed; two were residues of my own r1 folds): - cross-model-review §3: 'present on both' -> the SAME failure on both (same trigger, same outcome, comparable blast radius); any widening the branch adds is the branch's own regression, not carried over. - skill-authoring §7 derived-file: the no-mechanical-path pair (a hand-maintained rules file over a spec) now has an explicit arm — corrected by hand against the fixed source; machine-compiled artifacts stay never-hand-edited. - same rule: 'identical wrong text' -> 'same wrong content — the identical text, or the source-side value it is generated from' (a compile-transformed pair no longer misreads as true drift). - same rule: §3's sync contract re-described accurately — it keeps coupled files agreeing and names which wins on disagreement; it is not scoped to files that currently disagree. Adopted nits: grok r2 #1 (residual 'master' x2 -> base), #2 (item-3 tautology label now 'code agrees with its own output'), #4 (explicit true-drift else-arm, folded into the rewrite above), #5 (Provenance 'codebase-lightening'); luna nit (authority naming gains source/version/URL parenthetical). Rejected: grok r2 #3 (standard English ellipsis; reviewer itself rates it polish), #6 (skill-name cross-refs are pack idiom, used by existing text in the same files); luna survey nit (existing text already prescribes the re-check: 'the tier ranking built on the survey is now stale'). Co-Authored-By: Claude Fable 5 Claude-Session: https://claude.ai/code/session_01WMbbZQ8ZMMsNRGyV2nvJR8 --- skills/cross-model-review/SKILL.md | 12 ++++++++---- skills/delegation-and-review/SKILL.md | 2 +- skills/ground-truth-gates/SKILL.md | 12 ++++++------ skills/skill-authoring/SKILL.md | 22 +++++++++++++--------- 4 files changed, 28 insertions(+), 20 deletions(-) diff --git a/skills/cross-model-review/SKILL.md b/skills/cross-model-review/SKILL.md index be1422c..38b3395 100644 --- a/skills/cross-model-review/SKILL.md +++ b/skills/cross-model-review/SKILL.md @@ -109,14 +109,18 @@ acceptance, never closed by the reviewers on their own. finding on the merge-base too** (`unprobed` — see Provenance). On a behavior-preserving refactor branch a *reproduced* defect can still be one the branch faithfully carried over from -master, not one it introduced; recording it against the branch is a false +its base, not one it introduced; recording it against the branch is a false regression that blocks a clean refactor for a fault it did not create. Before you count a reproduced finding as the branch's defect, re-run it against the -merge-base: present on both → `pre-existing-tracked`, spun off as its own +merge-base: the SAME failure on both — same trigger, same outcome, +comparable blast radius — → `pre-existing-tracked`, spun off as its own fix, never bloating the refactor — pre-existing moves where a reproduced correctness or safety defect gets fixed, never whether (deferral stays the -owner's call per this section's triage); gone on the merge-base and live on -the branch → a real regression this branch owns. Reviewers do not see master (§2 packet is your +owner's call per this section's triage), and any widening the branch adds +(a new trigger path, a broader blast radius) is not carried over: the +widened part is the branch's own regression; gone on the merge-base and +live on the branch → a real regression this branch owns. Reviewers do not +see the base (§2 packet is your inlined lines), so this classification is yours to make, not theirs — a reviewer's severity label ("not merge-ready", "CRITICAL") is a claim about the code in front of it, blind to whether the branch introduced the behavior. diff --git a/skills/delegation-and-review/SKILL.md b/skills/delegation-and-review/SKILL.md index b84272f..9422c65 100644 --- a/skills/delegation-and-review/SKILL.md +++ b/skills/delegation-and-review/SKILL.md @@ -993,7 +993,7 @@ list, AGPLv3 — strictly ideas only) — a widening of an existing prohibition, a new standalone rule, so it owes no separate probe. The §3 survey-reports-leads bullet (2026-07-24) is class-distilled from a private mining pass over the owner's own sessions (no code taken): a single -lightweight-the-codebase session whose read-only fan-out survey was wrong four +codebase-lightening session whose read-only fan-out survey was wrong four separate ways, each over-claiming — a substring count of "66 three.js sites" that was 2 files, "byte-identical" components that diverged on a prop and a fallback, a "NumField duplication" that dissolved into two incompatible diff --git a/skills/ground-truth-gates/SKILL.md b/skills/ground-truth-gates/SKILL.md index a69e452..64ba008 100644 --- a/skills/ground-truth-gates/SKILL.md +++ b/skills/ground-truth-gates/SKILL.md @@ -281,15 +281,15 @@ A generic green test is not proof. A gate is real only if: evaporates when the session ends, so the next bad edit sails through a shape-only gate. Anchor the fact: assert the specific load-bearing values (a fixed holiday falls on its known date, the standard rate equals the - published number), each assertion naming its authority and consultation - date beside the value — an unattributed literal is indistinguishable from - item 3's copied-back expected value — so a future silent change to a - constant fails. This *extends* item 2's carve-out — + published number), each assertion naming its authority (source, and its + version or URL where it has one) and consultation date beside the value — + an unattributed literal is indistinguishable from item 3's copied-back + expected value — so a future silent change to a constant fails. This *extends* item 2's carve-out — from an output-interface string to an embedded input constant — and is NOT item 3's "hardcoded expected value" fake pass: the anchor's value comes from an external authority, not copied back from the code's own output. Item 3's - tautology asserts the source is the source; this asserts the source matches - the world. It shares rule 7's remedy — an external anchor — but not its + tautology asserts the code agrees with its own output; this asserts the + code matches the world. It shares rule 7's remedy — an external anchor — but not its trigger: rule 7 bites where *agreement between artifacts* is made to stand in for an external fact, this one where *structure* is. A fact that legitimately changes gets its anchor updated as a contract edit (rule 4: diff --git a/skills/skill-authoring/SKILL.md b/skills/skill-authoring/SKILL.md index 114d4d7..bed91c8 100644 --- a/skills/skill-authoring/SKILL.md +++ b/skills/skill-authoring/SKILL.md @@ -611,17 +611,21 @@ default; an AI rewrite does not launder a derivative). source before fixing it** (`unprobed` — private incident as shape; see Provenance). Where a file is compiled from another (a cache over a playbook, a rules file over a spec), the obvious reading of a wrong line is that the - derivative fell behind. Check whether the SOURCE carries the identical wrong - text first. If it does, this is not drift: the derivative is faithfully + derivative fell behind. Check whether the SOURCE carries the same wrong + content first — the identical text, or the source-side value it is + generated from. If it does, this is not drift: the derivative is faithfully mirroring a source that itself disagrees with the world, and correcting only the derivative gets it silently re-broken by the next compile or write-back. - Fix the source, bring the derivative along through its own regeneration or - write-back path where one exists (hand-editing a machine-compiled artifact - is what ground-truth-gates' regenerate-and-diff rule forbids), and record - which was authoritative. Distinct from §3's sync - contract, which governs two files that DISAGREE — here they agree with each - other and are both wrong (ground-truth-gates rule 7's mutual-agreement trap, - arising in maintenance rather than in a gate). + Fix the source, then bring the derivative along through its regeneration or + write-back path; a machine-compiled artifact is never hand-edited + (ground-truth-gates' regenerate-and-diff rule), while a hand-maintained + derivative with no mechanical path is corrected by hand against the fixed + source. Record which side was authoritative. Only a source that checks out + clean makes it true drift — then the derivative alone is regenerated, or + corrected through that same path. Distinct from §3's sync contract, which + keeps coupled files agreeing and names which wins when they disagree — here + the pair already agrees and both are wrong (ground-truth-gates rule 7's + mutual-agreement trap, arising in maintenance rather than in a gate). ❌ "the cache says X, reality says Y — so the cache drifted; fix the cache." - Compaction triggers — act when any of these is true: a skill outgrows what a reader can hold (~150 lines for discipline skills; domain-reference packs From 885e234d74c97f43bb6652b327ed5897737993f1 Mon Sep 17 00:00:00 2001 From: F-e-u-e-r <189464303+F-e-u-e-r@users.noreply.github.com> Date: Sun, 26 Jul 2026 20:38:06 +0800 Subject: [PATCH 10/13] Fold gate r3: sol FIX 2 + tri-lens master residue + 3 adopted nits MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit (grok r3 PROCEED; luna r3 FIX 1 = the master residue.) - skill-authoring §3: 'a fact about the outside world ... goes stale on a timescale of days' was still categorical — symmetric residue of the L6 fold, and it contradicted GTG rule 8's always-fixed facts in the same diff. Now 'a MUTABLE fact ... CAN go stale within days'. - skill-authoring §7 derived-file: a clean source no longer jumps to 'true drift' — trial-regenerate and diff (correct output = derivative fell behind; wrong again = the generation path is defective and gets fixed first). Also supersedes grok r3 nit-3's wording concern. - cross-model-review Provenance: 'pre-existing master behaviors' -> 'pre-existing base-branch behaviors' (all three lenses converged on this line; rule body already used merge-base/base). - skill-authoring §7 bare-executor probe (luna nit): the two arms are independent fresh invocations, no shared state or history. - ground-truth-gates rule 8 (sol nit): 'the specific load-bearing values' -> 'every load-bearing value' (closes the single-sentinel reading). - ground-truth-gates rule 8 (grok nit-4): 'the set of valid states' -> 'a jurisdiction's valid state codes' (removes the state-machine ambiguity; the example is now unambiguously external-authority). Rejected: grok r3 nit-2 (bullet density — polish, thrash risk). Co-Authored-By: Claude Fable 5 Claude-Session: https://claude.ai/code/session_01WMbbZQ8ZMMsNRGyV2nvJR8 --- skills/cross-model-review/SKILL.md | 3 ++- skills/ground-truth-gates/SKILL.md | 7 ++++--- skills/skill-authoring/SKILL.md | 16 ++++++++++------ 3 files changed, 16 insertions(+), 10 deletions(-) diff --git a/skills/cross-model-review/SKILL.md b/skills/cross-model-review/SKILL.md index 38b3395..f836ac6 100644 --- a/skills/cross-model-review/SKILL.md +++ b/skills/cross-model-review/SKILL.md @@ -272,7 +272,8 @@ The §3 baseline-classification and runtime-state adjudication rules (2026-07-24) are class-distilled from a mining pass over the owner's own sessions (no code taken): a moira-web behavior-preserving refactor where codex's "not merge-ready" and agy's "CRITICAL" both dissolved under -reproduction as pre-existing master behaviors the branch faithfully preserved +reproduction as pre-existing base-branch behaviors the branch faithfully +preserved (0 regressions, 4 pre-existing quirks spun off), and a TG-bot review where codex's identifier-migration and case-collision findings were non-applicable because the store was empty and the writer had never deployed. The lesson diff --git a/skills/ground-truth-gates/SKILL.md b/skills/ground-truth-gates/SKILL.md index 64ba008..536e4ce 100644 --- a/skills/ground-truth-gates/SKILL.md +++ b/skills/ground-truth-gates/SKILL.md @@ -272,14 +272,15 @@ A generic green test is not proof. A gate is real only if: 8. **A gate over hardcoded facts asserts the facts, not just the shape — and the cross-check that established them belongs IN the fixture, not in the chat** (`unprobed` — private incident as shape; see Provenance). When code - embeds domain constants (holiday dates, a tax rate, a fee schedule, the set - of valid states), a suite that checks structure — the array is non-empty, + embeds domain constants (holiday dates, a tax rate, a fee schedule, a + jurisdiction's valid state codes), a suite that checks structure — the + array is non-empty, each entry parses, the shape is right — passes identically whether the values are correct or a later edit corrupted one. Those values were usually cross-checked once, against an authority or several independent sources or a reviewer's recall — but that check happened in the conversation and evaporates when the session ends, so the next bad edit sails through a - shape-only gate. Anchor the fact: assert the specific load-bearing values + shape-only gate. Anchor the fact: assert every load-bearing value (a fixed holiday falls on its known date, the standard rate equals the published number), each assertion naming its authority (source, and its version or URL where it has one) and consultation date beside the value — diff --git a/skills/skill-authoring/SKILL.md b/skills/skill-authoring/SKILL.md index bed91c8..5933e69 100644 --- a/skills/skill-authoring/SKILL.md +++ b/skills/skill-authoring/SKILL.md @@ -109,8 +109,8 @@ artifact-producing step. - Date-stamp volatile facts (versions, flags, model names, defaults). - **Staleness concentrates in the world-fact rules — audit there first** (`unprobed` — private incident as shape; see Provenance). A rule encoding a - fact about the outside world (which model or tool is default, how a CLI - behaves, a numeric threshold someone measured) goes stale on a timescale of + mutable fact about the outside world (which model or tool is default, how a + CLI behaves, a numeric threshold someone measured) can go stale within days; a rule encoding method (reproduce before trusting, verify by execution) goes stale rarely and slowly. A staleness audit therefore concentrates the search on the files carrying dated facts and treats the @@ -595,7 +595,9 @@ default; an AI rewrite does not launder a derivative). (`unprobed` — measured in-house; see Provenance). §6's behavioral probe hunts gaps: what the file fails to make happen. This asks the opposite question, before the rule exists — run the scenario twice against the file's target - executor, once with no rule and once with it. A bare pass counts only when + executor, as independent fresh invocations (no shared state or history + between the arms), once with no rule and once with it. A bare pass counts + only when the run demonstrably met the rule's trigger (ground-truth-gates' not-armed discipline: a run that never hit the guarded condition is excluded and re-run), and one pass screens for a large effect only — a close or @@ -620,9 +622,11 @@ default; an AI rewrite does not launder a derivative). write-back path; a machine-compiled artifact is never hand-edited (ground-truth-gates' regenerate-and-diff rule), while a hand-maintained derivative with no mechanical path is corrected by hand against the fixed - source. Record which side was authoritative. Only a source that checks out - clean makes it true drift — then the derivative alone is regenerated, or - corrected through that same path. Distinct from §3's sync contract, which + source. Record which side was authoritative. A source that checks out + clean does not yet establish true drift — trial-regenerate and diff: + correct output means the derivative had merely fallen behind; wrong output + again means the generation path itself is defective and gets fixed first. + Distinct from §3's sync contract, which keeps coupled files agreeing and names which wins when they disagree — here the pair already agrees and both are wrong (ground-truth-gates rule 7's mutual-agreement trap, arising in maintenance rather than in a gate). From bbffa2a0b36ba1c661e433a183281825a83429b9 Mon Sep 17 00:00:00 2001 From: F-e-u-e-r <189464303+F-e-u-e-r@users.noreply.github.com> Date: Sun, 26 Jul 2026 20:50:13 +0800 Subject: [PATCH 11/13] Fold gate r4: derived-file no-path/clean-source arm + bare-probe outcome matrix MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit (luna r4 PROCEED; grok r4 FIX 1 and sol r4 FIX 2 overlapped on the first item — third independent convergence on the derived-file rule.) - skill-authoring §7 derived-file: the clean-source arm now forks on mechanism — with a mechanical path, trial-regenerate and diff, and a correct output is LANDED (fix step, not just diagnosis); with no mechanical path, a clean source + wrong derivative is manual drift, hand-corrected against the clean source and recorded as such. Closes the LL2 one-property flip that S2's rewrite reopened. - skill-authoring §7 bare-executor probe (sol): the decision now reads the PAIR, both arms armed — both produce the behavior = non-discriminating; only the ruled arm = earns its line; neither = ineffective as written (rewrite or drop, never folded on truth alone); a ruled arm that loses behavior the bare arm had = harmful, dropped, not filed as reference. Co-Authored-By: Claude Fable 5 Claude-Session: https://claude.ai/code/session_01WMbbZQ8ZMMsNRGyV2nvJR8 --- skills/skill-authoring/SKILL.md | 31 +++++++++++++++++++------------ 1 file changed, 19 insertions(+), 12 deletions(-) diff --git a/skills/skill-authoring/SKILL.md b/skills/skill-authoring/SKILL.md index 5933e69..5e7d618 100644 --- a/skills/skill-authoring/SKILL.md +++ b/skills/skill-authoring/SKILL.md @@ -596,15 +596,18 @@ default; an AI rewrite does not launder a derivative). gaps: what the file fails to make happen. This asks the opposite question, before the rule exists — run the scenario twice against the file's target executor, as independent fresh invocations (no shared state or history - between the arms), once with no rule and once with it. A bare pass counts - only when - the run demonstrably met the rule's trigger (ground-truth-gates' not-armed - discipline: a run that never hit the guarded condition is excluded and - re-run), and one pass screens for a large effect only — a close or - surprising call re-runs before demoting. Where the armed bare run already - produces the behavior, the rule is non-discriminating: it costs a line and - buys nothing, and belongs in a reference file or nowhere, not in the - always-loaded one. Eight rules folded into two files over one week were + between the arms), once with no rule and once with it. An arm counts only + when its run demonstrably met the rule's trigger (ground-truth-gates' + not-armed discipline: a run that never hit the guarded condition is + excluded and re-run), and one run per arm screens for a large effect + only — a close or surprising call re-runs before deciding. Read the pair, + not the bare arm alone: both arms produce the behavior → the rule is + non-discriminating — it costs a line and buys nothing, and belongs in a + reference file or nowhere, not in the always-loaded one; only the ruled + arm produces it → the rule earns its line; neither arm does → the rule as + written is ineffective — rewrite or drop it, never fold it in on truth + alone; and a ruled arm that loses behavior the bare arm had is a harmful + rule — dropped, not filed as reference. Eight rules folded into two files over one week were probed this way afterwards; three were reproduced unaided. Non-discriminating is not the same as wrong — the rule can be true and still not worth its line, and that is the judgment the probe is for. @@ -623,9 +626,13 @@ default; an AI rewrite does not launder a derivative). (ground-truth-gates' regenerate-and-diff rule), while a hand-maintained derivative with no mechanical path is corrected by hand against the fixed source. Record which side was authoritative. A source that checks out - clean does not yet establish true drift — trial-regenerate and diff: - correct output means the derivative had merely fallen behind; wrong output - again means the generation path itself is defective and gets fixed first. + clean does not yet establish true drift — with a mechanical path, + trial-regenerate and diff: correct output means the derivative had merely + fallen behind, so land that regenerated output; wrong output again means + the generation path itself is defective and gets fixed before any + regeneration is trusted. With no mechanical path, a clean source and a + wrong derivative is manual drift: hand-correct the derivative against the + clean source and record it as such. Distinct from §3's sync contract, which keeps coupled files agreeing and names which wins when they disagree — here the pair already agrees and both are wrong (ground-truth-gates rule 7's From 978d673793ec5956a690644f0c4f1b09558afb47 Mon Sep 17 00:00:00 2001 From: F-e-u-e-r <189464303+F-e-u-e-r@users.noreply.github.com> Date: Sun, 26 Jul 2026 21:04:25 +0800 Subject: [PATCH 12/13] Fold gate r5: scope the derived-file Distinct-from sentence + parallel 2x2 cell MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit (grok r5 PROCEED + 3 nits; sol r5 PROCEED clean; luna r5 FIX 1 = grok nit-3, another nit/must-fix convergence on the same line.) - skill-authoring §7 derived-file: the closing Distinct-from sentence no longer reads as a scope limiter for the whole rule — it names the trap SUBCASE (pair agrees, both wrong) and points at the drift branches above for the disagreeing pair. - skill-authoring §7 bare-executor probe (grok nit-1 adopted): fourth cell reworded to the parallel form 'only the bare arm produces it -> harmful' — a literal reader can no longer read 'stopping bare misbehavior' as loss. Rejected: grok r5 nit-2 (double-fault source+generator single-pass completeness — the rule re-enters cleanly once the source is fixed; reviewer itself rates it residual-completeness, not wrong instruction). Co-Authored-By: Claude Fable 5 Claude-Session: https://claude.ai/code/session_01WMbbZQ8ZMMsNRGyV2nvJR8 --- skills/skill-authoring/SKILL.md | 12 +++++++----- 1 file changed, 7 insertions(+), 5 deletions(-) diff --git a/skills/skill-authoring/SKILL.md b/skills/skill-authoring/SKILL.md index 5e7d618..9ab40f7 100644 --- a/skills/skill-authoring/SKILL.md +++ b/skills/skill-authoring/SKILL.md @@ -606,8 +606,8 @@ default; an AI rewrite does not launder a derivative). reference file or nowhere, not in the always-loaded one; only the ruled arm produces it → the rule earns its line; neither arm does → the rule as written is ineffective — rewrite or drop it, never fold it in on truth - alone; and a ruled arm that loses behavior the bare arm had is a harmful - rule — dropped, not filed as reference. Eight rules folded into two files over one week were + alone; only the bare arm produces it → the rule is harmful — dropped, not + filed as reference. Eight rules folded into two files over one week were probed this way afterwards; three were reproduced unaided. Non-discriminating is not the same as wrong — the rule can be true and still not worth its line, and that is the judgment the probe is for. @@ -634,9 +634,11 @@ default; an AI rewrite does not launder a derivative). wrong derivative is manual drift: hand-correct the derivative against the clean source and record it as such. Distinct from §3's sync contract, which - keeps coupled files agreeing and names which wins when they disagree — here - the pair already agrees and both are wrong (ground-truth-gates rule 7's - mutual-agreement trap, arising in maintenance rather than in a gate). + keeps coupled files agreeing and names which wins when they disagree — this + rule's trap subcase is the pair that agrees while both are wrong + (ground-truth-gates rule 7's mutual-agreement trap, arising in maintenance + rather than in a gate); the drift branches above already cover the + disagreeing pair. ❌ "the cache says X, reality says Y — so the cache drifted; fix the cache." - Compaction triggers — act when any of these is true: a skill outgrows what a reader can hold (~150 lines for discipline skills; domain-reference packs From eace69435202a632d0618de2d5350abf39f3f351 Mon Sep 17 00:00:00 2001 From: F-e-u-e-r <189464303+F-e-u-e-r@users.noreply.github.com> Date: Sun, 26 Jul 2026 21:14:52 +0800 Subject: [PATCH 13/13] Fold gate r6: score bare-probe arms against INTENDED outcome + generator-unavailable carve-out MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit (grok r6 PROCEED + 2 polish nits; sol r6 PROCEED clean; luna r6 FIX 2 + 1 adopted nit.) - skill-authoring §7 bare-executor probe: arms are now scored against the rule's INTENDED outcome — for a preventive rule that is the abstention, so a bare arm committing the prohibited act FAILS its arm. Closes the literal reading under which a working preventive rule (bare commits, ruled abstains) landed in the 'only the bare arm produces it -> harmful' cell and was dropped. - skill-authoring §7 derived-file: the manual-drift branch is scoped to pairs hand-maintained BY DESIGN; a machine-compiled artifact whose generator is merely unavailable is explicitly not that case — restoring the generation path is the fix, artifact stays un-hand-edited (blocked, not manually drifted). - skill-authoring §3 (luna nit): 'files carrying dated facts' -> 'world-fact files' (undated mutable facts are in scope). Grok r6 nits: #1 land-wording asymmetry on the wrong-source arm — no action (same intent, reviewer rates polish; the arm's bring-along is already an action); #2 CMR density — settled (r3). Co-Authored-By: Claude Fable 5 Claude-Session: https://claude.ai/code/session_01WMbbZQ8ZMMsNRGyV2nvJR8 --- skills/skill-authoring/SKILL.md | 18 ++++++++++++------ 1 file changed, 12 insertions(+), 6 deletions(-) diff --git a/skills/skill-authoring/SKILL.md b/skills/skill-authoring/SKILL.md index 9ab40f7..a7941d1 100644 --- a/skills/skill-authoring/SKILL.md +++ b/skills/skill-authoring/SKILL.md @@ -113,7 +113,7 @@ artifact-producing step. CLI behaves, a numeric threshold someone measured) can go stale within days; a rule encoding method (reproduce before trusting, verify by execution) goes stale rarely and slowly. A staleness audit therefore - concentrates the search on the files carrying dated facts and treats the + concentrates the search on the world-fact files and treats the method-encoding files as low-yield — not as exempt. One sweep of four rules files found every stale instance — 8 of 8 — in the single file that carried world-facts; the three method files were clean. This scopes the SEARCH only: @@ -600,8 +600,11 @@ default; an AI rewrite does not launder a derivative). when its run demonstrably met the rule's trigger (ground-truth-gates' not-armed discipline: a run that never hit the guarded condition is excluded and re-run), and one run per arm screens for a large effect - only — a close or surprising call re-runs before deciding. Read the pair, - not the bare arm alone: both arms produce the behavior → the rule is + only — a close or surprising call re-runs before deciding. Score each arm + against the rule's INTENDED outcome — for a preventive rule the intended + outcome is the abstention or refusal, so a bare arm that commits the + prohibited act FAILS its arm — then read the pair, not the bare arm + alone: both arms produce the intended outcome → the rule is non-discriminating — it costs a line and buys nothing, and belongs in a reference file or nowhere, not in the always-loaded one; only the ruled arm produces it → the rule earns its line; neither arm does → the rule as @@ -630,9 +633,12 @@ default; an AI rewrite does not launder a derivative). trial-regenerate and diff: correct output means the derivative had merely fallen behind, so land that regenerated output; wrong output again means the generation path itself is defective and gets fixed before any - regeneration is trusted. With no mechanical path, a clean source and a - wrong derivative is manual drift: hand-correct the derivative against the - clean source and record it as such. + regeneration is trusted. For a pair that is hand-maintained by design, a + clean source and a wrong derivative is manual drift: hand-correct the + derivative against the clean source and record it as such. A + machine-compiled artifact whose generator is merely unavailable is NOT + that case — restoring the generation path is the fix, and the artifact + stays un-hand-edited (blocked, not manually drifted). Distinct from §3's sync contract, which keeps coupled files agreeing and names which wins when they disagree — this rule's trap subcase is the pair that agrees while both are wrong