From 796378543fc7ce4f74ba830000b0d3e9af6b46a6 Mon Sep 17 00:00:00 2001 From: firaen22 Date: Tue, 21 Jul 2026 22:13:06 +0800 Subject: [PATCH 1/7] =?UTF-8?q?delegation-and-review=20=C2=A72:=20scope=20?= =?UTF-8?q?a=20sweep=20by=20every=20generator,=20not=20one=20grep=20patter?= =?UTF-8?q?n?= MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit A find-and-fix-every-instance sweep needs the same rigor as any other owned-scope field. Private incident: a 53-file styling sweep, three review rounds, and a merged fix all missed the real defect — it lived in a shared global utility class the token grep pattern never touched — and each follow-up round's "still broken?" surfaced a different category (a color-tier band, a class-emitting helper function) the prior round's search structurally excluded. Rule: enumerate every generator (literals, shared/global definitions, class- emitting helpers) and the full value space before dispatching or accepting such a sweep, and gate acceptance on observing the effect rather than on the search returning zero. Ships unprobed per the README covenant. --- skills/delegation-and-review/SKILL.md | 21 +++++++++++++++++++++ 1 file changed, 21 insertions(+) diff --git a/skills/delegation-and-review/SKILL.md b/skills/delegation-and-review/SKILL.md index 9689451..deeeb45 100644 --- a/skills/delegation-and-review/SKILL.md +++ b/skills/delegation-and-review/SKILL.md @@ -33,6 +33,19 @@ Every packet names: - **Goal + motivation** — what and why. - **Owned scope + explicit non-scope** — files/modules it may and may not touch. + For a find-and-fix-every-instance sweep, scope means every surface that can + generate the target pattern, not one search pattern: a 53-file styling sweep, + three review rounds, and a merged fix all missed the actual defect because it + lived in a shared utility class the token grep never matched, and each + follow-up round found a different category (a color-tier band, a + class-emitting helper function) the prior round's pattern structurally + excluded (`unprobed` — private incident as shape; see Provenance). Before + dispatching or accepting such a sweep, enumerate every generator (literals, + shared/global definitions, helper functions returning the pattern) and the + full value space (every tier/variant in the family, not a sample), and gate + acceptance on observing the effect (render it, run it) rather than on the + search returning zero — a clean grep proves one spelling is gone, not that + the defect is. - **Invariant** — property to close and properties to preserve. - **Proof gate** — concrete check that would fail under the broken behavior; worker-chosen "tests pass" is not a gate. @@ -301,5 +314,13 @@ enforcement or a defect in that sandbox is unestablished, so the rule prescribes only the defensive split. Private evidence, cited as shape per the README covenant's second branch; no in-repo probe has run — in-body `unprobed` marker. +The §2 sweep-scope bullet (2026-07-21) comes from a private incident: a +find-and-fix-every-instance styling sweep (53 files), three review rounds, and +a merged fix all missed the actual defect — it lived in a shared global +utility class the token grep pattern never touched, and each follow-up round's +"still broken?" surfaced a different category (a color-tier band, a +class-emitting helper function) the prior round's search structurally +excluded. 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 only worktree/agent mechanics against the current harness. From 5437d9168ff5c4d7fc97a429d68fed04cc03d96f Mon Sep 17 00:00:00 2001 From: F-e-u-e-r <189464303+F-e-u-e-r@users.noreply.github.com> Date: Wed, 22 Jul 2026 17:13:51 +0800 Subject: [PATCH 2/7] delegation-and-review: restructure the sweep-scope addition per r1 dual review PR #50 round-1 gate (grok-4.5 high: FIX 1,2,3,4; gpt-5.6-sol max: FIX 1-5). Reproduced and addressed: - search scope vs write scope split: inspecting a generator does not own it; out-of-scope generators are reported, never edited on discovery (codex F2) - generator inventory from definition surfaces, never the token grep; unresolved discovery gaps block exhaustive claims (grok F2 / codex F1) - acceptance moved into the Proof gate field and bound to every inventoried surface and tier, declared partitions the only shortcut; zero-hit search demoted to a report (grok F1, F4 / codex F3) - open-ended families get a declared bound per S3's bounded-sweep clause instead of a forbidden-sampling mandate (grok F3 / codex F4) - pos/neg pair added at the proof gate; dangling 'not that the defect is' parallel completed (grok n5, n6) - S3 sweep bullet now points at the S2 sweep fields so the review path lands on the acceptance rule (grok F4) - codex F5 (contributor Checks self-vouch) rejected-with-reason: factual process self-report, independently re-verified by this gate; packet rubric clarified to stop this recurring false-positive class Co-Authored-By: Claude Fable 5 Claude-Session: https://claude.ai/code/session_01GhLu6NCGzM9HxnqNb87MAx --- skills/delegation-and-review/SKILL.md | 43 +++++++++++++++++---------- 1 file changed, 27 insertions(+), 16 deletions(-) diff --git a/skills/delegation-and-review/SKILL.md b/skills/delegation-and-review/SKILL.md index deeeb45..5c57c8e 100644 --- a/skills/delegation-and-review/SKILL.md +++ b/skills/delegation-and-review/SKILL.md @@ -33,22 +33,29 @@ Every packet names: - **Goal + motivation** — what and why. - **Owned scope + explicit non-scope** — files/modules it may and may not touch. - For a find-and-fix-every-instance sweep, scope means every surface that can - generate the target pattern, not one search pattern: a 53-file styling sweep, - three review rounds, and a merged fix all missed the actual defect because it - lived in a shared utility class the token grep never matched, and each - follow-up round found a different category (a color-tier band, a - class-emitting helper function) the prior round's pattern structurally - excluded (`unprobed` — private incident as shape; see Provenance). Before - dispatching or accepting such a sweep, enumerate every generator (literals, - shared/global definitions, helper functions returning the pattern) and the - full value space (every tier/variant in the family, not a sample), and gate - acceptance on observing the effect (render it, run it) rather than on the - search returning zero — a clean grep proves one spelling is gone, not that - the defect is. + For a find-and-fix-every-instance sweep, scope splits in two + (`unprobed` — private incident as shape; see Provenance): the SEARCH + scope is every surface that can generate the target — literals, + shared/global definitions, helpers that construct or return it — + inventoried from the definition surfaces themselves, never from the + token grep (a 53-file styling sweep missed its defect in a shared + utility class the token grep never matched, and each review round + surfaced another category the prior round's pattern structurally + excluded); the WRITE scope stays this field, and a generator discovered + outside it is reported for escalation, never edited on discovery. Name + the value family and close it (every tier/variant listed), or declare + the bound per §3's bounded-sweep clause — an unresolved discovery gap + blocks any exhaustive claim. - **Invariant** — property to close and properties to preserve. - **Proof gate** — concrete check that would fail under the broken behavior; - worker-chosen "tests pass" is not a gate. + worker-chosen "tests pass" is not a gate. For an every-instance sweep, + the gate is the observed effect on every inventoried generator surface + and value tier (render or run each; a declared coverage partition with + its gaps stated is the only shortcut) — a zero-hit search is a report, + not the gate: a clean grep proves one spelling is gone, not that the + defect is gone. + ✅ "every tier rendered through the shared helper path — effect gone." + ❌ "the grep is clean across all 53 files, so the sweep is done." - **Output contract** — conclusions + `file:line` refs, each tagged `[verified: ran ]`, `[verified: read ]`, or `[unverified: ]`; long artifacts go to files, return paths. @@ -103,7 +110,9 @@ reviewers that they silently absorb as implementers. 'none')"). The reviewer re-runs that named search, never takes it on trust — then challenges its coverage with one differently-shaped query (a broader or structural pattern, or a class-aware check): re-running a - narrow pattern reproduces its hits AND its misses. + narrow pattern reproduces its hits AND its misses. (An every-instance + sweep's dispatch scope and acceptance gate are §2's sweep fields — + generator inventory and effect-per-surface, never search-zero.) - **Machinery is not the user.** Tool completions, CI events, and agent statuses are state changes, not approval or proof. Open the artifact and verify. - **Auditing a completion claim** (an agent's or contractor's "done", a @@ -314,7 +323,9 @@ enforcement or a defect in that sandbox is unestablished, so the rule prescribes only the defensive split. Private evidence, cited as shape per the README covenant's second branch; no in-repo probe has run — in-body `unprobed` marker. -The §2 sweep-scope bullet (2026-07-21) comes from a private incident: a +The §2 sweep-scope additions (2026-07-21; search-scope/write-scope split, +definition-surface inventory, effect-per-surface proof gate, and the §3 +pointer) come from a private incident: a find-and-fix-every-instance styling sweep (53 files), three review rounds, and a merged fix all missed the actual defect — it lived in a shared global utility class the token grep pattern never touched, and each follow-up round's From 3b68c4575bf00281a457eb22ed0d01bc0f24f020 Mon Sep 17 00:00:00 2001 From: F-e-u-e-r <189464303+F-e-u-e-r@users.noreply.github.com> Date: Wed, 22 Jul 2026 17:23:10 +0800 Subject: [PATCH 3/7] delegation-and-review: r2 rework of the sweep-scope fields - inventory closure via S3's own loop PR #50 round-2 gate (grok-4.5 high: FIX 1,2,5; gpt-5.6-sol max: FIX 1,2,3,4,5,7). All reproduced and addressed: - inventory gains a concrete build procedure (axis-diverse searches) and a closure criterion borrowed from S3's discovery loop (two consecutive empty passes); the token-grep ban is now aimed at the completeness INFERENCE, not at using search - fixes the direct- literal flip (grok F1, F2 / codex F1) - partition shortcut replaced: equivalence-class observation with the shared-outcome reason stated; unobserved = reported unverified, never folded into exhaustive (codex F2) - S3 pointer now quotes the canonical report-not-the-gate sentence verbatim instead of paraphrasing it (codex F3) - pos example covers every inventoried surface class (codex F4) - WRITE-scope referent pinned to the explicitly listed owned files/modules (grok F5 / codex F7) - PR body Checks line to be updated to disclose the S3 amendment (grok n4 / codex F5); codex n6 (in-packet unverifiability of checks.py claim) recorded - the gate-runner re-runs checks.py independently each round Co-Authored-By: Claude Fable 5 Claude-Session: https://claude.ai/code/session_01GhLu6NCGzM9HxnqNb87MAx --- skills/delegation-and-review/SKILL.md | 50 ++++++++++++++++----------- 1 file changed, 29 insertions(+), 21 deletions(-) diff --git a/skills/delegation-and-review/SKILL.md b/skills/delegation-and-review/SKILL.md index 5c57c8e..e33acc5 100644 --- a/skills/delegation-and-review/SKILL.md +++ b/skills/delegation-and-review/SKILL.md @@ -35,26 +35,33 @@ Every packet names: - **Owned scope + explicit non-scope** — files/modules it may and may not touch. For a find-and-fix-every-instance sweep, scope splits in two (`unprobed` — private incident as shape; see Provenance): the SEARCH - scope is every surface that can generate the target — literals, - shared/global definitions, helpers that construct or return it — - inventoried from the definition surfaces themselves, never from the - token grep (a 53-file styling sweep missed its defect in a shared - utility class the token grep never matched, and each review round - surfaced another category the prior round's pattern structurally - excluded); the WRITE scope stays this field, and a generator discovered - outside it is reported for escalation, never edited on discovery. Name - the value family and close it (every tier/variant listed), or declare - the bound per §3's bounded-sweep clause — an unresolved discovery gap - blocks any exhaustive claim. + scope is every surface that can generate the target — literals and + direct references, shared/global definitions, helpers that construct + or return it. Searches build that inventory — reference search from + the symbol, reads of the defining files, tracing of emitting helpers, + one axis per pass so blind spots don't line up — and it closes per + §3's discovery loop: stop only after two consecutive passes surface + nothing new; no single pattern's zero hits ever prove it complete (a + 53-file styling sweep missed its defect in a shared utility class the + token grep never matched, and each review round surfaced another + category the prior round's pattern structurally excluded). The packet + lists the inventory (each surface and how it was found) and the value + family, closed (every tier/variant listed) or bounded per §3's + bounded-sweep clause. The WRITE scope stays the owned files/modules + explicitly listed above: a generator discovered outside that WRITE + scope is reported for escalation, never edited on discovery. - **Invariant** — property to close and properties to preserve. - **Proof gate** — concrete check that would fail under the broken behavior; worker-chosen "tests pass" is not a gate. For an every-instance sweep, the gate is the observed effect on every inventoried generator surface - and value tier (render or run each; a declared coverage partition with - its gaps stated is the only shortcut) — a zero-hit search is a report, - not the gate: a clean grep proves one spelling is gone, not that the - defect is gone. - ✅ "every tier rendered through the shared helper path — effect gone." + and value tier (render or run each); within a value family, one + observation may stand for a declared equivalence class only with the + shared-outcome reason stated, and anything unobserved is reported + unverified — never folded into an exhaustive claim. A zero-hit search + is a report, not the gate: a clean grep proves one spelling is gone, + not that the defect is gone. + ✅ "literals swept, the shared class rebuilt, every tier rendered + through the emitting helper — effect gone on each inventoried surface." ❌ "the grep is clean across all 53 files, so the sweep is done." - **Output contract** — conclusions + `file:line` refs, each tagged `[verified: ran ]`, `[verified: read ]`, or @@ -110,9 +117,10 @@ reviewers that they silently absorb as implementers. 'none')"). The reviewer re-runs that named search, never takes it on trust — then challenges its coverage with one differently-shaped query (a broader or structural pattern, or a class-aware check): re-running a - narrow pattern reproduces its hits AND its misses. (An every-instance - sweep's dispatch scope and acceptance gate are §2's sweep fields — - generator inventory and effect-per-surface, never search-zero.) + narrow pattern reproduces its hits AND its misses. (A + find-and-fix-every-instance sweep's dispatch scope and acceptance gate + are §2's sweep fields; there, "a zero-hit search is a report, not the + gate.") - **Machinery is not the user.** Tool completions, CI events, and agent statuses are state changes, not approval or proof. Open the artifact and verify. - **Auditing a completion claim** (an agent's or contractor's "done", a @@ -324,8 +332,8 @@ prescribes only the defensive split. Private evidence, cited as shape per the README covenant's second branch; no in-repo probe has run — in-body `unprobed` marker. The §2 sweep-scope additions (2026-07-21; search-scope/write-scope split, -definition-surface inventory, effect-per-surface proof gate, and the §3 -pointer) come from a private incident: a +axis-diverse inventory closed per §3's discovery loop, effect-per-surface +proof gate, and the §3 pointer) come from a private incident: a find-and-fix-every-instance styling sweep (53 files), three review rounds, and a merged fix all missed the actual defect — it lived in a shared global utility class the token grep pattern never touched, and each follow-up round's From 2727c6844084e671c30fe7018e40f232fa5c9a9d Mon Sep 17 00:00:00 2001 From: F-e-u-e-r <189464303+F-e-u-e-r@users.noreply.github.com> Date: Wed, 22 Jul 2026 17:38:26 +0800 Subject: [PATCH 4/7] delegation-and-review: r3 rework of the sweep fields - spelling-free axis, verbatim loop cite, textual carve-out PR #50 round-3 gate (grok-4.5 high: FIX 1,2; gpt-5.6-sol max: FIX 1,2,3,4). All reproduced and addressed: - at least one inventory axis must never match the target's spelling (effect-source definitions/constructors) - the axis set was spelling-seeded and could not reach the cited utility class (grok F1) - S3 anchors cited by real name with the loop quoted verbatim ('Stop only after two consecutive empty rounds; one clean round is not convergence'), a round defined as every-axis-ran, dedup imported (grok F2 / codex F1 / grok r3 n5 of r2) - equivalence classes need verified branch-free shared paths, not a stated reason (codex F2) - textual-invariant carve-out: an exact-spelling sweep over a declared corpus is gated by the scoped search itself; effect-gate scoped to behavioral targets (codex F3) - bounded/gap-carrying sweeps return a non-exhaustive outcome; scope reduction needs the dispatcher's say; every-instance claims with unobserved members are false (codex F4) - inventory neg example added; pos example names per-surface observations (grok n6 / codex n5); target forms glossed (grok n4) Co-Authored-By: Claude Fable 5 Claude-Session: https://claude.ai/code/session_01GhLu6NCGzM9HxnqNb87MAx --- skills/delegation-and-review/SKILL.md | 60 +++++++++++++++++---------- 1 file changed, 37 insertions(+), 23 deletions(-) diff --git a/skills/delegation-and-review/SKILL.md b/skills/delegation-and-review/SKILL.md index e33acc5..65d308c 100644 --- a/skills/delegation-and-review/SKILL.md +++ b/skills/delegation-and-review/SKILL.md @@ -37,31 +37,45 @@ Every packet names: (`unprobed` — private incident as shape; see Provenance): the SEARCH scope is every surface that can generate the target — literals and direct references, shared/global definitions, helpers that construct - or return it. Searches build that inventory — reference search from - the symbol, reads of the defining files, tracing of emitting helpers, - one axis per pass so blind spots don't line up — and it closes per - §3's discovery loop: stop only after two consecutive passes surface - nothing new; no single pattern's zero hits ever prove it complete (a - 53-file styling sweep missed its defect in a shared utility class the - token grep never matched, and each review round surfaced another - category the prior round's pattern structurally excluded). The packet - lists the inventory (each surface and how it was found) and the value - family, closed (every tier/variant listed) or bounded per §3's - bounded-sweep clause. The WRITE scope stays the owned files/modules - explicitly listed above: a generator discovered outside that WRITE - scope is reported for escalation, never edited on discovery. + or return it. Build the inventory from the target's forms (symbol, + string, or emit site) AND from at least one axis that never matches + its spelling — the shared definitions and constructors that produce + that kind of output (a 53-file styling sweep missed its defect in a + shared utility class the token grep never matched, and each review + round surfaced another category the prior round's pattern + structurally excluded). The inventory closes per §3's miss-is-costly + loop, verbatim: "Stop only after two consecutive empty rounds; one + clean round is not convergence" — a round counts only when every axis + ran, with dedup against everything already surfaced; no single + pattern's zero hits ever prove completeness. The packet lists the + inventory (each surface and how it was found) and the value family, + closed (every tier/variant listed) or bounded per §3's "State + anything you bounded" clause — and a bounded or gap-carrying sweep + returns a non-exhaustive outcome: reducing scope needs the + dispatcher's explicit say, and an every-instance claim with + unobserved members is false. The WRITE scope stays the owned + files/modules explicitly listed above: a generator discovered outside + that WRITE scope is reported for escalation, never edited on + discovery. + ❌ "the inventory is the 53 grep hits — the shared utility never made + the list." - **Invariant** — property to close and properties to preserve. - **Proof gate** — concrete check that would fail under the broken behavior; - worker-chosen "tests pass" is not a gate. For an every-instance sweep, - the gate is the observed effect on every inventoried generator surface - and value tier (render or run each); within a value family, one - observation may stand for a declared equivalence class only with the - shared-outcome reason stated, and anything unobserved is reported - unverified — never folded into an exhaustive claim. A zero-hit search - is a report, not the gate: a clean grep proves one spelling is gone, - not that the defect is gone. - ✅ "literals swept, the shared class rebuilt, every tier rendered - through the emitting helper — effect gone on each inventoried surface." + worker-chosen "tests pass" is not a gate. For an every-instance sweep + whose target is behavior or rendered effect, the gate is the observed + effect at every inventoried generator surface and value tier (render + or run each); one observation may stand for a declared equivalence + class only when the shared path is verified branch-free for that + outcome (read the path — a stated "they share a helper" is a claim, + not evidence), and anything unobserved is reported unverified — never + folded into an exhaustive claim. Where the invariant is itself textual + (an exact forbidden spelling in a declared corpus), a correctly scoped + search over that corpus IS the gate. A zero-hit search on a behavioral + target is a report, not the gate: a clean grep proves one spelling is + gone, not that the defect is gone. + ✅ "each literal's site re-rendered, the shared class's consumers + re-rendered, every tier through the emitting helper — effect gone at + each observation point." ❌ "the grep is clean across all 53 files, so the sweep is done." - **Output contract** — conclusions + `file:line` refs, each tagged `[verified: ran ]`, `[verified: read ]`, or From d38c63635a4e7883fc00fa96624b8eded4d8380d Mon Sep 17 00:00:00 2001 From: F-e-u-e-r <189464303+F-e-u-e-r@users.noreply.github.com> Date: Wed, 22 Jul 2026 17:51:52 +0800 Subject: [PATCH 5/7] delegation-and-review: r4 rework of the sweep fields - closure honesty, equivalence evidence, contained observation PR #50 round-4 gate (grok-4.5 high: FIX 1,2; gpt-5.6-sol max: FIX 1,2,3,4). All reproduced and addressed: - textual carve-out guarded: only when the declared corpus covers every inventoried surface AND no inventoried generator can emit the target without the literal; token sweeps with emitters stay on the effect gate (grok F1 / grok n6) - value family closes only via its named canonical source (file:line) or the same discovery loop, else bounded - the color-tier axis of the incident (grok F2) - rounds must add a broadened or new query; identical reruns count for nothing (codex F1) - equivalence requires evidence across inputs, backing data, and downstream context; branch-free control flow alone is not equivalence (codex F2) - observation runs inside an authorized side-effect-contained harness; undrivable outward effects reported unverified + escalated, never fired for the gate (codex F4) - 'behavioral target' qualifier restored at both categorical zero-hit statements and the S3 pointer, which now also carries the positive half of acceptance (codex F3 / grok n4); scope-side pos example added (grok n5) Co-Authored-By: Claude Fable 5 Claude-Session: https://claude.ai/code/session_01GhLu6NCGzM9HxnqNb87MAx --- skills/delegation-and-review/SKILL.md | 63 +++++++++++++++++---------- 1 file changed, 39 insertions(+), 24 deletions(-) diff --git a/skills/delegation-and-review/SKILL.md b/skills/delegation-and-review/SKILL.md index 65d308c..26c20be 100644 --- a/skills/delegation-and-review/SKILL.md +++ b/skills/delegation-and-review/SKILL.md @@ -46,33 +46,47 @@ Every packet names: structurally excluded). The inventory closes per §3's miss-is-costly loop, verbatim: "Stop only after two consecutive empty rounds; one clean round is not convergence" — a round counts only when every axis - ran, with dedup against everything already surfaced; no single - pattern's zero hits ever prove completeness. The packet lists the - inventory (each surface and how it was found) and the value family, - closed (every tier/variant listed) or bounded per §3's "State - anything you bounded" clause — and a bounded or gap-carrying sweep - returns a non-exhaustive outcome: reducing scope needs the - dispatcher's explicit say, and an every-instance claim with - unobserved members is false. The WRITE scope stays the owned - files/modules explicitly listed above: a generator discovered outside - that WRITE scope is reported for escalation, never edited on - discovery. + ran AND it adds a broadened or newly derived query (rerunning + yesterday's identical searches is empty by construction and counts + for nothing), with dedup against everything already surfaced; for a + behavioral target, no single pattern's zero hits ever prove + completeness. The packet lists the inventory (each surface and how it + was found) and the value family — closed only by its named canonical + source (the enum, config, or definition site, `file:line`) or by the + same discovery loop, else bounded per §3's "State anything you + bounded" clause — and a bounded or gap-carrying sweep returns a + non-exhaustive outcome: reducing scope needs the dispatcher's + explicit say, and an every-instance claim with unobserved members is + false. The WRITE scope stays the owned files/modules explicitly + listed above: a generator discovered outside that WRITE scope is + reported for escalation, never edited on discovery. + ✅ "inventory: 53 literal sites (reference search), the shared class + (style audit), the emitting helper (trace); tiers from the palette + enum at its definition site." ❌ "the inventory is the 53 grep hits — the shared utility never made the list." - **Invariant** — property to close and properties to preserve. - **Proof gate** — concrete check that would fail under the broken behavior; worker-chosen "tests pass" is not a gate. For an every-instance sweep whose target is behavior or rendered effect, the gate is the observed - effect at every inventoried generator surface and value tier (render - or run each); one observation may stand for a declared equivalence - class only when the shared path is verified branch-free for that - outcome (read the path — a stated "they share a helper" is a claim, - not evidence), and anything unobserved is reported unverified — never - folded into an exhaustive claim. Where the invariant is itself textual - (an exact forbidden spelling in a declared corpus), a correctly scoped - search over that corpus IS the gate. A zero-hit search on a behavioral - target is a report, not the gate: a clean grep proves one spelling is - gone, not that the defect is gone. + effect at every inventoried generator surface and value tier — render + or run each inside an authorized, side-effect-contained harness; an + outward effect you cannot safely drive (a payment, a send, a delete) + is reported unverified and escalated, never fired for the gate + (operational-rigor §2's gates govern). One observation may stand for + a declared equivalence class only when equivalence is verified across + the members' inputs, backing data, and downstream context — + branch-free control flow alone is not equivalence (a table lookup + differs per entry), and a stated "they share a helper" is a claim, + not evidence; anything unobserved is reported unverified — never + folded into an exhaustive claim. Where the invariant is itself + textual (an exact forbidden spelling; the declared corpus covers + every inventoried surface) AND no inventoried generator can emit the + target without that literal appearing, the correctly scoped search + over that corpus IS the gate — any emitting generator in the + inventory keeps the sweep on the effect gate. A zero-hit search on a + behavioral target is a report, not the gate: a clean grep proves one + spelling is gone, not that the defect is gone. ✅ "each literal's site re-rendered, the shared class's consumers re-rendered, every tier through the emitting helper — effect gone at each observation point." @@ -132,9 +146,10 @@ reviewers that they silently absorb as implementers. trust — then challenges its coverage with one differently-shaped query (a broader or structural pattern, or a class-aware check): re-running a narrow pattern reproduces its hits AND its misses. (A - find-and-fix-every-instance sweep's dispatch scope and acceptance gate - are §2's sweep fields; there, "a zero-hit search is a report, not the - gate.") + find-and-fix-every-instance sweep's dispatch scope and acceptance + gate are §2's sweep fields — acceptance is the effect at every + inventoried surface; there, for behavioral targets, "a zero-hit + search is a report, not the gate.") - **Machinery is not the user.** Tool completions, CI events, and agent statuses are state changes, not approval or proof. Open the artifact and verify. - **Auditing a completion claim** (an agent's or contractor's "done", a From 7a2e355742a46a6a3c4ec2d3e9ed1f9f81ab5fc9 Mon Sep 17 00:00:00 2001 From: F-e-u-e-r <189464303+F-e-u-e-r@users.noreply.github.com> Date: Wed, 22 Jul 2026 18:04:50 +0800 Subject: [PATCH 6/7] delegation-and-review: r5 de-escalation of the sweep fields - probes vs target, ledgered hunt, clean textual discriminator PR #50 round-5 gate (grok-4.5 high: FIX 1,2,3; gpt-5.6-sol max: FIX 1-6). All reproduced; the fix removes guarantee surfaces instead of adding conditions: - TARGET defined as the defect/effect, spellings demoted to probes; trigger gains task-phrasing synonyms (grok F1, F3) - generator hunt delegated to S3's miss-is-costly loop as written (axis-diverse finders, dedup, stop rule) instead of restating a two-axis floor with its own round semantics (codex F1 / grok F3) - per-round query/result ledger (empty rounds included) carried in the packet; seed inventory + worker-continues resolves the packet- closure-vs-delegation tension (codex F5 / grok r5 n6) - value-family closure needs a verified-finite source; extensible registries/configs are never closed (codex F2) - gate covers declared variation axes where the outcome can differ; untested combinations reported unobserved (codex F3) - textual branch rewritten to a single discriminator (string-absence IS the invariant; nothing produces the outcome without the exact spelling) - removes the self-contradicting emitting-generator clause (codex F4 / grok F1) - S3 pointer reduced to a pure pointer, no acceptance restatement (grok F2); unprobed marker added on the proof-gate half (grok n5); 53-file unit drift fixed in both examples (codex F6) Co-Authored-By: Claude Fable 5 Claude-Session: https://claude.ai/code/session_01GhLu6NCGzM9HxnqNb87MAx --- skills/delegation-and-review/SKILL.md | 80 +++++++++++++-------------- 1 file changed, 40 insertions(+), 40 deletions(-) diff --git a/skills/delegation-and-review/SKILL.md b/skills/delegation-and-review/SKILL.md index 26c20be..1827a42 100644 --- a/skills/delegation-and-review/SKILL.md +++ b/skills/delegation-and-review/SKILL.md @@ -33,44 +33,48 @@ Every packet names: - **Goal + motivation** — what and why. - **Owned scope + explicit non-scope** — files/modules it may and may not touch. - For a find-and-fix-every-instance sweep, scope splits in two - (`unprobed` — private incident as shape; see Provenance): the SEARCH - scope is every surface that can generate the target — literals and - direct references, shared/global definitions, helpers that construct - or return it. Build the inventory from the target's forms (symbol, - string, or emit site) AND from at least one axis that never matches - its spelling — the shared definitions and constructors that produce - that kind of output (a 53-file styling sweep missed its defect in a - shared utility class the token grep never matched, and each review - round surfaced another category the prior round's pattern - structurally excluded). The inventory closes per §3's miss-is-costly - loop, verbatim: "Stop only after two consecutive empty rounds; one - clean round is not convergence" — a round counts only when every axis - ran AND it adds a broadened or newly derived query (rerunning - yesterday's identical searches is empty by construction and counts - for nothing), with dedup against everything already surfaced; for a - behavioral target, no single pattern's zero hits ever prove - completeness. The packet lists the inventory (each surface and how it - was found) and the value family — closed only by its named canonical - source (the enum, config, or definition site, `file:line`) or by the - same discovery loop, else bounded per §3's "State anything you - bounded" clause — and a bounded or gap-carrying sweep returns a + For a find-and-fix-every-instance sweep — a "purge every X", "replace + all Y", "no instance of Z survives" task — scope splits in two + (`unprobed` — private incident as shape; see Provenance). The TARGET + is the defect or effect to eliminate, never the first search string — + a spelling is a probe. The SEARCH scope is every surface that can + produce that target: literals and direct references, shared/global + definitions, helpers that construct or return it. Hunt generators + per §3's miss-is-costly loop (its axis-diverse finders, dedup, and + two-consecutive-empty-rounds stop rule apply as written there), with + the spelling-based probes as only some of the axes — the effect-side + axes (what shared definitions and constructors can produce this kind + of output) never match the spelling at all; a 53-file styling sweep + missed its defect in a shared utility class the token grep never + matched, and each review round surfaced another category the prior + round's pattern structurally excluded. The packet carries the seed + inventory, the hunt method, and a per-round ledger duty (each round's + queries and results, empty ones included — the worker continues the + loop to closure); it also names the value family (the tiers/variants + the target ranges over), closed only by a verified-finite source (a + sealed enum read at its `file:line` — an extensible registry or + config is never closed), else bounded per §3's "State anything you + bounded" clause. A bounded or gap-carrying sweep returns a non-exhaustive outcome: reducing scope needs the dispatcher's explicit say, and an every-instance claim with unobserved members is false. The WRITE scope stays the owned files/modules explicitly listed above: a generator discovered outside that WRITE scope is reported for escalation, never edited on discovery. - ✅ "inventory: 53 literal sites (reference search), the shared class - (style audit), the emitting helper (trace); tiers from the palette - enum at its definition site." - ❌ "the inventory is the 53 grep hits — the shared utility never made + ✅ "seed inventory: the 53-file hit list (reference search), the + shared class (style audit), the emitting helper (trace); tiers from + the sealed palette enum at its definition site; round ledger in the + packet." + ❌ "the inventory is the grep hit list — the shared utility never made the list." - **Invariant** — property to close and properties to preserve. - **Proof gate** — concrete check that would fail under the broken behavior; worker-chosen "tests pass" is not a gate. For an every-instance sweep - whose target is behavior or rendered effect, the gate is the observed - effect at every inventoried generator surface and value tier — render - or run each inside an authorized, side-effect-contained harness; an + whose target is behavior or rendered effect (`unprobed` — same + provenance as the sweep-scope field above), the gate is the observed + effect at every inventoried generator surface, across each declared + variation axis where the outcome can differ (tier, theme, locale — + untested combinations are unobserved, reported as such) — render or + run each inside an authorized, side-effect-contained harness; an outward effect you cannot safely drive (a payment, a send, a delete) is reported unverified and escalated, never fired for the gate (operational-rigor §2's gates govern). One observation may stand for @@ -79,14 +83,12 @@ Every packet names: branch-free control flow alone is not equivalence (a table lookup differs per entry), and a stated "they share a helper" is a claim, not evidence; anything unobserved is reported unverified — never - folded into an exhaustive claim. Where the invariant is itself - textual (an exact forbidden spelling; the declared corpus covers - every inventoried surface) AND no inventoried generator can emit the - target without that literal appearing, the correctly scoped search - over that corpus IS the gate — any emitting generator in the - inventory keeps the sweep on the effect gate. A zero-hit search on a - behavioral target is a report, not the gate: a clean grep proves one - spelling is gone, not that the defect is gone. + folded into an exhaustive claim. Only when the invariant is literally + the string's absence — nothing at runtime produces the outcome + without that exact spelling — is the correctly scoped search over the + declared corpus itself the gate. A zero-hit search on a behavioral + target is a report, not the gate: a clean grep proves one spelling is + gone, not that the defect is gone. ✅ "each literal's site re-rendered, the shared class's consumers re-rendered, every tier through the emitting helper — effect gone at each observation point." @@ -147,9 +149,7 @@ reviewers that they silently absorb as implementers. broader or structural pattern, or a class-aware check): re-running a narrow pattern reproduces its hits AND its misses. (A find-and-fix-every-instance sweep's dispatch scope and acceptance - gate are §2's sweep fields — acceptance is the effect at every - inventoried surface; there, for behavioral targets, "a zero-hit - search is a report, not the gate.") + gate are §2's sweep fields.) - **Machinery is not the user.** Tool completions, CI events, and agent statuses are state changes, not approval or proof. Open the artifact and verify. - **Auditing a completion claim** (an agent's or contractor's "done", a From 27ac396a2f9894e5921561913877a2d615ea0b61 Mon Sep 17 00:00:00 2001 From: F-e-u-e-r <189464303+F-e-u-e-r@users.noreply.github.com> Date: Wed, 22 Jul 2026 18:30:10 +0800 Subject: [PATCH 7/7] delegation-and-review: r6 rework of the sweep fields - branch-first, mandatory producer axis, honest closure PR #50 round-6 gate (grok-4.5 high: FIX 1; gpt-5.6-sol max: FIX 1-7). All reproduced and addressed: - textual-vs-behavioral branched FIRST; textual gate claims corpus- level absence only, corpus = packet's readable scope named explicitly, never the seed hit list (codex F3 / grok n4-of-r6) - producer/effect axis made a MUST before loop close; spelling-only axis sets non-compliant regardless of rounds (grok F1) - S3 finder list quoted verbatim; dedup + stop rule cited, not restated (codex F4) - closure honesty: producer surfaces/variation axes not closable from a verified-finite source -> non-exhaustive outcome (codex F1); verified-finite wording covers const unions (grok n5-of-r6) - equivalence requires the producing implementation itself; unproved divergence -> per-member observation (codex F2) - search bounded to the packet's readable scope; outside surfaces are reported gaps (codex F6) - outward effects carry per-invocation authorization at fire time (codex F7) - PR-body Rule sync next (codex F5) Co-Authored-By: Claude Fable 5 Claude-Session: https://claude.ai/code/session_01GhLu6NCGzM9HxnqNb87MAx --- skills/delegation-and-review/SKILL.md | 92 +++++++++++++++------------ 1 file changed, 52 insertions(+), 40 deletions(-) diff --git a/skills/delegation-and-review/SKILL.md b/skills/delegation-and-review/SKILL.md index 1827a42..fb3b409 100644 --- a/skills/delegation-and-review/SKILL.md +++ b/skills/delegation-and-review/SKILL.md @@ -35,31 +35,42 @@ Every packet names: - **Owned scope + explicit non-scope** — files/modules it may and may not touch. For a find-and-fix-every-instance sweep — a "purge every X", "replace all Y", "no instance of Z survives" task — scope splits in two - (`unprobed` — private incident as shape; see Provenance). The TARGET - is the defect or effect to eliminate, never the first search string — - a spelling is a probe. The SEARCH scope is every surface that can - produce that target: literals and direct references, shared/global - definitions, helpers that construct or return it. Hunt generators - per §3's miss-is-costly loop (its axis-diverse finders, dedup, and - two-consecutive-empty-rounds stop rule apply as written there), with - the spelling-based probes as only some of the axes — the effect-side - axes (what shared definitions and constructors can produce this kind - of output) never match the spelling at all; a 53-file styling sweep - missed its defect in a shared utility class the token grep never - matched, and each review round surfaced another category the prior - round's pattern structurally excluded. The packet carries the seed - inventory, the hunt method, and a per-round ledger duty (each round's - queries and results, empty ones included — the worker continues the - loop to closure); it also names the value family (the tiers/variants - the target ranges over), closed only by a verified-finite source (a - sealed enum read at its `file:line` — an extensible registry or - config is never closed), else bounded per §3's "State anything you - bounded" clause. A bounded or gap-carrying sweep returns a - non-exhaustive outcome: reducing scope needs the dispatcher's - explicit say, and an every-instance claim with unobserved members is - false. The WRITE scope stays the owned files/modules explicitly - listed above: a generator discovered outside that WRITE scope is - reported for escalation, never edited on discovery. + (`unprobed` — private incident as shape; see Provenance). First branch + by what the invariant IS. Textual: the deliverable is literally the + string's absence from a declared corpus — the corpus is the packet's + readable scope, named explicitly, never the seed grep's hit list — + and the correctly scoped search over that corpus is the gate, claiming + corpus-level textual absence and nothing more. Behavioral: the TARGET + is the defect or effect to eliminate; a spelling is a probe. The + SEARCH scope is then every surface that can produce that target: + literals and direct references, shared/global definitions, helpers + that construct or return it. Hunt generators per §3's miss-is-costly + loop — its finders quoted verbatim: "Run axis-diverse finders — by- + container, by-content, by-entity, by-time — one axis per finder so + blind spots don't line up", with dedup against everything surfaced + and its two-consecutive-empty-rounds stop rule — and at least one + producer/effect axis (what shared definitions and constructors can + produce this kind of output) MUST run before the loop may close: a + spelling-only axis set is non-compliant however many rounds it ran (a + 53-file styling sweep missed its defect in a shared utility class the + token grep never matched, and each review round surfaced another + category the prior round's pattern structurally excluded). Searching + stays inside the packet's readable scope: a surface outside it is a + reported gap, never a silent crossing. The packet carries the seed + inventory, the hunt method, and a per-round ledger duty — each + round's queries and results, empty ones included; the worker + continues the loop to closure. It also names the value family (the + tiers/variants the target ranges over), closed only by a + verified-finite source (a sealed enum or const union read at its + `file:line` — an extensible registry or config is never closed), else + bounded per §3's "State anything you bounded" clause. Producer + surfaces or variation axes not closable from a verified-finite source + → the sweep returns a non-exhaustive outcome, as does any bounded or + gap-carrying run: reducing scope needs the dispatcher's explicit say, + and an every-instance claim with unobserved members is false. The + WRITE scope stays the owned files/modules explicitly listed above: a + generator discovered outside that WRITE scope is reported for + escalation, never edited on discovery. ✅ "seed inventory: the 53-file hit list (reference search), the shared class (style audit), the emitting helper (trace); tiers from the sealed palette enum at its definition site; round ledger in the @@ -74,21 +85,22 @@ Every packet names: effect at every inventoried generator surface, across each declared variation axis where the outcome can differ (tier, theme, locale — untested combinations are unobserved, reported as such) — render or - run each inside an authorized, side-effect-contained harness; an - outward effect you cannot safely drive (a payment, a send, a delete) - is reported unverified and escalated, never fired for the gate - (operational-rigor §2's gates govern). One observation may stand for - a declared equivalence class only when equivalence is verified across - the members' inputs, backing data, and downstream context — - branch-free control flow alone is not equivalence (a table lookup - differs per entry), and a stated "they share a helper" is a claim, - not evidence; anything unobserved is reported unverified — never - folded into an exhaustive claim. Only when the invariant is literally - the string's absence — nothing at runtime produces the outcome - without that exact spelling — is the correctly scoped search over the - declared corpus itself the gate. A zero-hit search on a behavioral - target is a report, not the gate: a clean grep proves one spelling is - gone, not that the defect is gone. + run each inside a side-effect-contained harness; every outward + effect keeps operational-rigor §2's per-invocation authorization at + the moment it fires, and one you cannot safely and authorizedly + drive (a payment, a send, a delete) is reported unverified and + escalated, never fired for the gate. One observation may stand for a + declared equivalence class only when equivalence is verified across + the members' inputs, backing data, downstream context, AND the + producing implementation itself (two independent renderers are never + one class on shared inputs alone; branch-free control flow is not + equivalence — a table lookup differs per entry; "they share a + helper" is a claim, not evidence); unproved divergence forces + per-member observation, and anything unobserved is reported + unverified — never folded into an exhaustive claim. A zero-hit + search on a behavioral target is a report, not the gate: a clean + grep proves one spelling is gone, not that the defect is gone (the + textual branch above is the only search-as-gate case). ✅ "each literal's site re-rendered, the shared class's consumers re-rendered, every tier through the emitting helper — effect gone at each observation point."