@iceinvein/agent-skills 0.21.4 → 0.22.0

package/skills/sluice/SKILL.md

@@ -21,16 +21,21 @@ has to be taken back.
 |---------|--------|-------|-----|
 | `bypass` | No code change: a question, an explanation, a read | none | nothing, just answer |
 | `fast` | Existing interfaces, one subsystem (a new flag on an existing command still counts as existing) | test-first, verify | "Fast channel, existing interfaces. Test first, then implement." |
-| `main` | Adds an interface, or crosses subsystems | + agree intent, review before merge | "Main channel, new interface. Agreeing the shape first." |
-| `deep` | Several subsystems, or a plan was asked for | + written design and plan | "Deep channel, several subsystems. Design before code." |
+| `main` | Adds an interface, or crosses subsystems | + agree intent, hunt a checkable claim, review before merge | "Main channel, new interface. Agreeing the shape first." |
+| `deep` | Several subsystems, or a plan was asked for | + written design and plan, hunt after the flip | "Deep channel, several subsystems. Design before code." |
 
 Two subsystems is `main`; the third is what makes it `deep`.
 
 `bypass`, `fast`, and `main` proceed without stopping for approval; only
 `deep` stops: once for design sign-off before code, once for the plan and
-pre-flight together before Task 1. A stop ends your turn. Asking a question
-with a tool is not one, however many options it carried: the answer comes
-back to you and the run never left your hands.
+pre-flight together before Task 1. A stop ends your turn.
+
+A choice that is your partner's to make goes to them through `AskUserQuestion`
+wherever the harness has it, at a stop or between them: options to pick from,
+your recommendation first, not a paragraph or a lettered list to reply to.
+Asking is not itself a stop, however many options it carried, because the
+answer comes back to you and the run never left your hands. So at a stop, ask
+with the tool, then end the turn once the answers are in.
 
 Name the channel and the signal that actually routed you there. The strings above
 are examples, not fixed copy, and a channel with a two-part signal should say
@@ -66,9 +71,9 @@ announces nothing to measure from.
 One line each. Read the reference only on friction: the moment you notice
 yourself wanting to skip the rule, or arguing that this one is the exception.
 
-- **Agree intent** before building. One question at a time. Propose approaches
-  with a recommendation, not a survey. `main` agrees in a message, `deep` writes
-  it down. `references/intent.md`
+- **Agree intent** before building. One question at a time, through
+  `AskUserQuestion`. Propose approaches with a recommendation, not a survey.
+  `main` agrees in a message, `deep` writes it down. `references/intent.md`
 - **Test first.** The test comes before the code; run it while it should
   still be failing, then write the least code that turns it green. Skip that
   watching step and a green result is only an unchecked guess. A test no
@@ -78,7 +83,21 @@ yourself wanting to skip the rule, or arguing that this one is the exception.
   `references/root-cause.md`
 - **Verify** before claiming. Run the command in this turn and read its
   output; the claim comes after that, never before. How sure you feel is not
-  something anyone else can check. `references/verify.md`
+  something anyone else can check, so record the check: `status.sh verify --
+  <cmd>` notes the tree it passed on, or `--none "<reason>"` where no check
+  can cover the change. In `fast` and `main` a Stop hook refuses, once per
+  turn, a handback whose tree has moved since. `references/verify.md`
+- **Hunt** in `main`, once green and before review: when the intent agreed in
+  the message states a checkable claim (a limit, a boundary, an invariant, a
+  stated result), run bug-hunter on the diff; otherwise say in one line there
+  was none and skip it. Fix each proven bug test-first; ambiguities go to your
+  partner at the handback. Record the check last, `status.sh verify --` after
+  the hunt and any fix, since the hunt's report lands in the tree. No
+  bug-hunter? Say so in the announcement and again at the merge.
+  `references/review.md`
+- **Hunt** in `deep`, after the flip, once every task is done and before the
+  final review: bug-hunter on `<base>..HEAD` against the spec, each proven bug
+  one fix, test-first. `references/deep-channel.md`
 - **Review** before merge. Dispatch a reviewer with fresh context and put the
   diff on disk for it to read, so those bytes fill their context instead of
   yours. A session that dispatches only when asked has not refused you one, so
@@ -104,7 +123,10 @@ collapses to `fast`.
 
 Design to `docs/specs/YYYY-MM-DD-<topic>.md`, plan to
 `docs/plans/YYYY-MM-DD-<topic>.md`, unless the repo has a convention or
-your partner states a preference. Get the design signed off before code.
+your partner states a preference. Get the design signed off before code. When
+the design's shape turns on a fork only your partner can settle, ask that one
+question through `AskUserQuestion`, with your recommendation, before the design
+is written. `references/deep-channel.md` has the test for what counts.
 
 Take the design stop through the harness's plan mode where there is one. Its
 gate is enforced rather than requested and it holds edits shut while it is open,
@@ -162,8 +184,9 @@ instead of to the branch at large.
 
 Pre-flight rides in that same stop: which flagged tasks get a reviewer, which
 mechanical ones the plan marked for low effort, and whether the work runs
-in a worktree. Ask them as choices with the counts in them, never as a
-paragraph, then end the turn. Task 1 opens on their next
+in a worktree. Ask them through `AskUserQuestion`, one question each with the
+counts in the options, never as a paragraph or a lettered list, then end the
+turn on the answers. Task 1 opens on their next
 instruction, and an answer that already carries one is that instruction. A
 session that dispatches only when asked has not ruled dispatch out, it has made
 this question the place to ask; genuine unavailability is the tool not being

package/skills/sluice/evals/README.md

@@ -1,8 +1,8 @@
 # sluice evals
 
-Fifteen cases for `claude plugin eval`. Nine pin the routing decision: which
+Nineteen cases for `claude plugin eval`. Twelve pin the routing decision: which
 channel the run names, and whether the behaviour that channel owes actually
-happened. Six pin what a deep run does after pre-flight, where the question is
+happened. Seven pin what a deep run does after pre-flight, where the question is
 no longer which channel but whether the run keeps going.
 
 | Case | Signal under test | What it pins |
@@ -14,8 +14,11 @@ no longer which channel but whether the run keeps going.
 | `deep-plan-asks-the-fork` | The same plan with nothing saying where the counters can live | One question with a recommendation before any design; no spec yet |
 | `explicit-instruction-collapses-to-fast` | Main-shaped work plus "just do it" | Collapses to fast; no design, no proposal |
 | `superpowers-conflict-stands-down` | Repo mandates the superpowers sequence | Stands down once, names no channel |
-| `announcement-reaches-the-ledger` | A flag that a repo rule turns into a new export | `status.sh route fast`, then `status.sh route main` once the rule is read |
+| `announcement-reaches-the-ledger` | A flag that a surface test turns into a new export | `status.sh route main` before any write under `src/` and before any fast or deep route |
 | `fast-reads-the-unmentioned-convention` | Flags live in a table the prompt never names | The flag lands in the registry table and the generated `--help` |
+| `fast-verifies-before-handback` | A fast flag, then the handback | A passing `status.sh verify` after the last edit, before handing back |
+| `main-hunts-a-checkable-claim` | Main work whose intent states a checkable claim | bug-hunter on the diff once green; the `lastPage` remainder bug it proves, fixed test-first |
+| `main-skips-the-hunt-without-a-claim` | A new interface with nothing to check | No bug-hunter; one line saying the intent stated no checkable claim |
 
 Execution, where the run is already past both stops:
 
@@ -26,11 +29,12 @@ Execution, where the run is already past both stops:
 | `deep-run-survives-a-milestone` | Six tasks, the first three named a milestone | All six done; the Stop hook never had to refuse; the final message is a handback |
 | `deep-run-decides-a-non-blocking-choice` | A task leaves a choice open and says either is fine | Decided, written into the record, no task blocked, no decision list at the end |
 | `deep-run-waits-for-a-running-agent` | Every task goes to an implementer agent | A `T2:` labelled dispatch; the handback comes after the last result |
-| `deep-run-fans-out` | Three disjoint tasks under a worktree-per-implementer answer | Three dispatches in one message, then the flip; also the baseline for a time-budget A/B |
+| `deep-run-fans-out` | Three disjoint tasks under a worktree-per-implementer answer | Three dispatches in one message, then the flip; each task's files merged back into the run's own tree; also the baseline for a time-budget A/B |
+| `deep-run-hunts-after-the-flip` | Every task done, the flip included | bug-hunter on the plan diff against the spec before the final review; the proven off-by-one fixed test-first; a Hunt section in the record |
 
 ## Running
 
-Fourteen cases scaffold a small Node repo and then change it, so they need the
+Eighteen cases scaffold a small Node repo and then change it, so they need the
 scaffold flag and a tool grant. Pin the model, because the eval child does not
 inherit it, and pin the judge, because `--model` does not reach it and the
 `llm` graders otherwise run on Haiku. From the repo root:
@@ -52,6 +56,14 @@ and halves the cost, and `--runs 1` drops the repeats. Traces are deleted when a
 ends, so a failing `llm` grader cannot be read back afterwards; add
 `--keep-temp` to any run whose failures you will need to diagnose.
 
+The verification gate is not in the case-local plugin copies: they register no
+hook, and the Stop hook a run meets is the globally installed one
+(`~/.claude/skills/sluice/scripts/stop-guard.sh`, wired by your settings). So
+the gate is measured only once this sluice version is installed. Once it is, a
+`fast` or `main` case that never calls `status.sh verify` takes one refusal
+turn before it stops, and a judge reading the last message reads the one
+written after that refusal.
+
 To gate CI, pick a floor and let a miss fail the job:
 
 ```bash
@@ -59,6 +71,78 @@ claude plugin eval skills/sluice --scaffold --allow-tools Bash Write Edit \
   --trust-plugin --threshold 0.8
 ```
 
+To check whether the rules in `rules.json` still earn their place on a model,
+run both arms through `eval:fresh`. It runs on your Claude plan, at
+`--runs 3 -j 2` by default, then diffs the result against
+`evals/baselines/<model>.json`:
+
+```bash
+bun run eval:fresh run skills/sluice --model claude-opus-5-5
+```
+
+Re-reading a result costs nothing, and `--against` diffs it against another
+model's baseline:
+
+```bash
+bun run eval:fresh diff skills/sluice <result.json> [--against <model>]
+```
+
+Writing the baseline is always a deliberate step of its own:
+
+```bash
+bun run eval:fresh accept skills/sluice <result.json>
+```
+
+`run` takes `--case <glob>`, `--runs <n>`, `-j <n>` and `--tolerance <x>`;
+`diff` takes `--against <model>` and `--tolerance <x>`. Both exit 0 when no
+case regressed, 1 when one did, and 2 on bad input (a missing flag value, an
+unreadable result or a malformed manifest). `run` also exits 2 when the eval
+writes no result. `accept` exits 2 on a result filtered with `--case`, since a
+baseline needs a full run, and on a result with any errored run. `diff` lists
+errored runs after the report without changing its exit code, and leaves them
+out of every mean, since an errored run's score says nothing about the skill; a
+case with no finished with-arm run is left out of the report. `diff` exits 2
+when `--against` names a model with no baseline, where a missing baseline for
+the result's own model only reads as "against no baseline". `run` passes
+`--no-publish`, so the HTML report stays local.
+
+A run cut short by a timeout, a quota limit or a closed session needs only
+the cases it lacks. Rerun those with `run --case`, then fold the rerun into
+the full result:
+
+```bash
+bun run eval:fresh merge skills/sluice <full.json> <rerun.json>
+```
+
+It writes `<full>-merged.json` beside the full result, which `accept` takes.
+It exits 2 when the two results differ in model, judge, CLI version, ablation,
+skill or runs per case, or when the full result was itself filtered with
+`--case`. It also exits 2 when the rerun misses a case the full result lacks,
+has an errored or short case of its own, names a case the skill does not have,
+or reruns a case the full result already finished. That last refusal keeps a
+finished case's score from being rerolled. It cannot stop a case that needed
+filling from being rerun several times with only the best rerun merged, so
+merge the first clean rerun.
+
+The diff gives each case its verdicts. `regressed` means the with-arm mean
+dropped below the baseline by more than `--tolerance` (default 0.1).
+`redundant` means the bare model matches the skill at 1.0. `skill-worse` means
+the without-arm mean beats the with-arm mean by more than the tolerance, so the
+skill is costing score. `flaky` means the runs disagree. `sandbox` is a drop past the tolerance on a case listed in
+`sandboxSensitive`, and it replaces `regressed` there, because the drop is read
+as the harness (see "Git inside the eval sandbox" below). `new` is a case the
+baseline does not have, and `steady` is a case none of the others apply to. A
+rule is "at risk" if any of its cases regressed, and an "expiry candidate" if
+all of its cases are redundant.
+
+Since a sandbox-sensitive case never reads `regressed`, a rule pinned only by
+such cases never reads "at risk", on this machine or any other.
+
+`vacuousWithout` lists cases whose graders, leaving out the `tool_used: Skill`
+grader the no-plugin arm drops, can pass when the model does nothing the rule
+asks for; those cases are never called redundant or skill-worse. `unclaimed` lists cases that
+pin no rule SKILL.md states, each with its reason.
+
 ## Scoring notes
 
 `tool_used: Skill` graders are excluded from the score in a two-arm run and
@@ -68,7 +152,7 @@ the model's own habits.
 
 The two stops a deep run is allowed are both before Task 1: design sign-off and
 plan-plus-pre-flight. `deep-plan-across-subsystems` pins the first. Everything
-after pre-flight is covered by the two execution cases, which is where a run
+after pre-flight is covered by the execution cases, which is where a run
 that checks in per task would show up. Their `.sluice/run.json` fixtures were
 produced by `status.sh` and `plan.sh import` rather than typed by hand, so the
 tiers and the graph columns match what the plan actually says; the plans pass
@@ -88,6 +172,27 @@ only from the case's own directory.
 
 ## Verification status
 
+The accepted baseline is `baselines/claude-opus-5-5.json`; what follows is the
+history that led to it.
+
+### Opus 5.5, 2026-10-14
+
+CLI 2.1.296 and then 2.1.299, `eval:fresh` with both arms and three runs per
+case, judged by Opus 5.5. The first baseline (skill 0.23.2, CLI 2.1.296) left
+three cases reading the harness or the fixture rather than the skill, each
+fixed and then measured in the 2.1.299 baseline (skill 0.23.4):
+
+| Case | With / without before | With / without after | Fix |
+|---|---|---|---|
+| `deep-run-survives-a-milestone` | below the without arm | 1.00 / 1.00 | The fixture's Task 5 timed steps it never ran, so the reviewer rightly blocked on 0 ms timings; it now runs them through `runStep` |
+| `deep-run-fans-out` | 0.62 / 0.90 | 1.00 / 0.90 | The harness refuses Agent worktree isolation; `references/deep-channel.md` now cuts each implementer's worktree by hand under `.claude/worktrees/` |
+| `announcement-reaches-the-ledger` | 0.40 / 0.40 | 1.00 / 0.40 | Opus 5.5 reads a fixture this small whole before routing, so the staged fast-then-main escalation never happened; the case now pins routing main first, and `escalate-out-loud` is unpinned |
+
+Git in the sandbox failed differently this time: `/opt/homebrew/bin/git` is a
+link into the Cellar, which the sandbox cannot read, so the shell fell back to
+the xcrun shim. A one-line wrapper at `/usr/local/bin/git` that execs Homebrew's
+git fixed it on this machine; another machine needs the same.
+
 ### Opus 5.5, 2026-09-23
 
 CLI 2.1.280, `--model claude-opus-5-5`, one run per case, no no-plugin arm, so

package/skills/sluice/evals/announcement-reaches-the-ledger/fixture.sh

@@ -1,8 +1,9 @@
 #!/usr/bin/env bash
-# The fast-flag repo plus a house rule the prompt does not mention: flags are
-# public API, and the first new flag has to create the flags() export that
-# API.md lists. That export is a new interface, so a run that starts fast and
-# reads CONTRIBUTING.md has a real reason to re-route to main mid-turn.
+# The fast-flag repo plus a house rule the prompt does not mention: a surface
+# test fails once the CLI accepts a flag beyond --dry-run, saying flags are
+# public API and need a flags() export listed in API.md. That export is a new
+# interface, so a run that reads the repo before routing has its reason to go
+# main before it touches source.
 set -euo pipefail
 
 mkdir -p src/cli tests
@@ -69,6 +70,31 @@ test("a full deploy reports every step", () => {
 });
 JS
 
+cat > tests/surface.test.js <<'JS'
+import assert from "node:assert/strict";
+import { readFileSync } from "node:fs";
+import { test } from "node:test";
+
+// Integrators wrap shipit and read its flags from the package rather than
+// parsing --help, so the flag surface is public API. --dry-run predates the
+// rule; the first flag after it brings the flags() export with it.
+test("every flag the CLI accepts is published by flags()", async () => {
+  const source = readFileSync(new URL("../src/cli/deploy.js", import.meta.url), "utf8");
+  const accepted = [...new Set([...source.matchAll(/"(--[a-z][a-z-]*)"/g)].map((m) => m[1]))];
+  if (accepted.every((flag) => flag === "--dry-run")) return;
+
+  const api = await import("../src/index.js");
+  assert.equal(
+    typeof api.flags,
+    "function",
+    "flags are public API: src/index.js must export flags(), returning { name, description } for every accepted flag including --dry-run, and API.md must document it",
+  );
+  const published = api.flags().map((flag) => flag.name).sort();
+  assert.deepEqual(published, [...accepted].sort());
+  for (const flag of api.flags()) assert.ok(flag.description, `${flag.name} has no description`);
+});
+JS
+
 cat > API.md <<'MD'
 # shipit public API
 
@@ -84,21 +110,8 @@ MD
 cat > CONTRIBUTING.md <<'MD'
 # Contributing to shipit
 
-Run `npm test` before you push. Every behaviour change comes with a test.
-
-## Flags are public API
-
-Integrators build their own wrappers around shipit and need to know which flags
-the installed version accepts without parsing `--help`. So, starting with the
-next flag we add:
-
-- every flag the CLI accepts is returned by a `flags()` function exported from
-  `src/index.js`, as `{ name, description }` objects;
-- `flags()` is documented in `API.md`, like every other export;
-- `--dry-run` predates this rule and goes into `flags()` alongside the first new
-  flag.
-
-A PR that adds a flag without both is not merged.
+Run `npm test` before you push. Every behaviour change comes with a test, and
+a PR with a red suite is not merged.
 MD
 
 cat > README.md <<'MD'

package/skills/sluice/evals/announcement-reaches-the-ledger/graders/routes-main-before-source.md

@@ -0,0 +1,14 @@
+---
+type: regex
+# The surface test turns the first new flag into a new public flags() export,
+# so the route that fits is main, and it has to come before source changes.
+# Matches from the start of the trace to a Bash call invoking
+# status.sh route main, refusing any Write or Edit under src/ or any fast or
+# deep route on the way. Anchored as the announces graders are, so a quoted
+# mention such as grep 'status.sh route main' does not count.
+# file_path is found wherever it sits in the input: an Edit's opens with
+# replace_all, so anchoring on file_path first let an early Edit through.
+pattern: '^(?:(?!"name":"(?:Write|Edit|MultiEdit)","input":\{(?:"(?:[^"\\]|\\.)*"|[^"{}])*?"file_path":"[^"]*/src/|"command":"(?:(?:[^"\\]|\\.)*?(?:[\s/]|\\[nt]))?status\.sh(?:\\"|'')?(?:\s|\\[nt])+route(?:\s|\\[nt])+(?:fast|deep)(?:\s|\\[nt]|[;&|]|"))[\s\S])*?"command":"(?:(?:[^"\\]|\\.)*?(?:[\s/]|\\[nt]))?status\.sh(?:\\"|'')?(?:\s|\\[nt])+route(?:\s|\\[nt])+main(?:\s|\\[nt]|[;&|]|")'
+target: trace
+weight: 3
+---

package/skills/sluice/evals/announcement-reaches-the-ledger/prompt.md

@@ -1,11 +1,11 @@
 ---
 name: announcement-reaches-the-ledger
-description: A new flag reads as fast until the repo's contributing rule turns it into a new public export. Pins that the run routes fast and then re-routes to main out loud, on the ledger.
+description: A new flag the repo's surface test turns into a new public export. Pins that the run reads far enough to route main through status.sh before touching source.
 tags: [routing, fast, main, escalation, scaffold, write]
 max_turns: 60
 timeout_seconds: 1800
 allowed_tools: [Read, Glob, Grep, Skill, Write, Edit, Bash]
-expected_outcome: Routes fast through status.sh, reads CONTRIBUTING.md, sees that the first new flag creates a public flags() export listed in API.md, re-routes to main through status.sh, then ships --verbose with the suite green.
+expected_outcome: Reads the repo, sees from the surface test that the first new flag needs a public flags() export listed in API.md, routes main through status.sh before editing src/, then ships --verbose and flags() with the suite green.
 ---
 
 Add a `--verbose` flag to the deploy command. After each step's progress line it prints one more line saying the step finished, for example `   build done`. Without the flag the output stays exactly as it is.

package/skills/sluice/evals/baselines/claude-opus-5-5.json

@@ -0,0 +1,237 @@
+{
+  "model": "claude-opus-5-5",
+  "judgeModel": "claude-opus-5-5",
+  "claudeVersion": "2.1.300",
+  "skillVersion": "0.24.1",
+  "date": "2026-10-15T10:16:06.877Z",
+  "cases": {
+    "announcement-reaches-the-ledger": {
+      "with": [
+        1,
+        1,
+        1
+      ],
+      "without": [
+        0.4,
+        0.4,
+        0.4
+      ]
+    },
+    "bypass-question-stays-silent": {
+      "with": [
+        1,
+        1,
+        1
+      ],
+      "without": [
+        1,
+        1,
+        1
+      ]
+    },
+    "deep-plan-across-subsystems": {
+      "with": [
+        0.7142857142857143,
+        1,
+        1
+      ],
+      "without": [
+        0.42857142857142855,
+        0.42857142857142855,
+        0.42857142857142855
+      ]
+    },
+    "deep-plan-asks-the-fork": {
+      "with": [
+        0.6666666666666666,
+        0.6666666666666666,
+        1
+      ],
+      "without": [
+        0.4444444444444444,
+        0.4444444444444444,
+        0.4444444444444444
+      ]
+    },
+    "deep-run-blocks-on-a-real-decision": {
+      "with": [
+        1,
+        1,
+        1
+      ],
+      "without": [
+        0.7272727272727273,
+        1,
+        1
+      ]
+    },
+    "deep-run-decides-a-non-blocking-choice": {
+      "with": [
+        1,
+        1,
+        1
+      ],
+      "without": [
+        1,
+        1,
+        1
+      ]
+    },
+    "deep-run-fans-out": {
+      "with": [
+        1,
+        1,
+        1
+      ],
+      "without": [
+        0.5,
+        1,
+        1
+      ]
+    },
+    "deep-run-finishes-every-task": {
+      "with": [
+        1,
+        1,
+        1
+      ],
+      "without": [
+        1,
+        1,
+        1
+      ]
+    },
+    "deep-run-hunts-after-the-flip": {
+      "with": [
+        1,
+        1,
+        1
+      ],
+      "without": [
+        0.4444444444444444,
+        0.6666666666666666,
+        0.4444444444444444
+      ]
+    },
+    "deep-run-survives-a-milestone": {
+      "with": [
+        1,
+        1,
+        1
+      ],
+      "without": [
+        1,
+        1,
+        1
+      ]
+    },
+    "deep-run-waits-for-a-running-agent": {
+      "with": [
+        1,
+        1,
+        1
+      ],
+      "without": [
+        0.75,
+        0.75,
+        0.75
+      ]
+    },
+    "explicit-instruction-collapses-to-fast": {
+      "with": [
+        1,
+        1,
+        1
+      ],
+      "without": [
+        0.7142857142857143,
+        0.42857142857142855,
+        0.42857142857142855
+      ]
+    },
+    "fast-flag-on-existing-command": {
+      "with": [
+        1,
+        1,
+        0.7142857142857143
+      ],
+      "without": [
+        0.2857142857142857,
+        0.2857142857142857,
+        0.2857142857142857
+      ]
+    },
+    "fast-reads-the-unmentioned-convention": {
+      "with": [
+        1,
+        1,
+        1
+      ],
+      "without": [
+        1,
+        1,
+        1
+      ]
+    },
+    "fast-verifies-before-handback": {
+      "with": [
+        1,
+        1,
+        1
+      ],
+      "without": [
+        0.25,
+        0.25,
+        0.25
+      ]
+    },
+    "main-hunts-a-checkable-claim": {
+      "with": [
+        1,
+        1,
+        1
+      ],
+      "without": [
+        0.42857142857142855,
+        0.42857142857142855,
+        0.42857142857142855
+      ]
+    },
+    "main-new-interface": {
+      "with": [
+        1,
+        0.6666666666666666,
+        1
+      ],
+      "without": [
+        0.3333333333333333,
+        0.3333333333333333,
+        0.3333333333333333
+      ]
+    },
+    "main-skips-the-hunt-without-a-claim": {
+      "with": [
+        1,
+        1,
+        0.5
+      ],
+      "without": [
+        0,
+        0,
+        0
+      ]
+    },
+    "superpowers-conflict-stands-down": {
+      "with": [
+        1,
+        1,
+        1
+      ],
+      "without": [
+        0.5,
+        0.5,
+        0.5
+      ]
+    }
+  }
+}