From bbf9ae0945d868afb4879aa8ef3b3966248f8515 Mon Sep 17 00:00:00 2001 From: Bram Date: Sun, 6 Sep 2026 22:17:39 +0200 Subject: [PATCH 1/2] docs(skills): default routine Astra work to medium reasoning --- CHANGELOG.md | 3 +++ skills/arena/SKILL.md | 4 ++-- skills/figure-it-out/SKILL.md | 2 +- skills/how/SKILL.md | 8 ++++---- skills/poteto-mode/SKILL.md | 2 +- skills/poteto-mode/playbooks/bug-fix.md | 2 +- skills/poteto-mode/playbooks/eval.md | 2 +- skills/poteto-mode/playbooks/feature.md | 2 +- skills/poteto-mode/playbooks/hillclimb.md | 2 +- skills/poteto-mode/playbooks/multi-phase-plan.md | 2 +- skills/poteto-mode/playbooks/orchestrate.md | 6 +++--- skills/poteto-mode/playbooks/perf-issue.md | 2 +- skills/poteto-mode/playbooks/refactoring.md | 2 +- skills/poteto-mode/references/poteto-agent.md | 2 +- skills/why/SKILL.md | 6 +++--- 15 files changed, 25 insertions(+), 22 deletions(-) diff --git a/CHANGELOG.md b/CHANGELOG.md index 491f0a4..20c71c1 100644 --- a/CHANGELOG.md +++ b/CHANGELOG.md @@ -4,6 +4,9 @@ summary: Timeline of guardrail helper changes mirrored from Sweetistics and rela # Changelog +## 2026-09-06: Astra Reasoning Defaults +- Defaulted routine Astra work in PStack skills and Poteto playbooks to medium reasoning; retained high for reviews and reasoning-heavy tasks, including Autoreview, with fast mode still forbidden. + ## 2026-09-04: Autoreview Astra Default - Changed the autoreview skill and helper default to `gpt-6-astra` at high reasoning, using Sol as the access-only fallback and preserving explicit model selection; skill instructions require standard mode. diff --git a/skills/arena/SKILL.md b/skills/arena/SKILL.md index b168a63..f4b1bef 100644 --- a/skills/arena/SKILL.md +++ b/skills/arena/SKILL.md @@ -24,12 +24,12 @@ The N candidates will receive the same prompt, so the prompt is the contract. Ge 1. State the artifact each candidate is producing. 2. Derive the rubric. State what success looks like for *this* task, then turn it into 3-6 concrete gradeable criteria. Concrete: `Adds a --dry-run flag that skips writes`. Vague: `code is correct`. The rubric is the picker's tool in Phase D; candidates only see the task. -3. Pick the runners. For judgment-sensitive work, cycle through `gpt-6-astra`, `gpt-5.6-sol`, `gpt-5.6-terra`, and `gpt-5.6-luna`, each at `high` reasoning; repeat the pool when `N > 4`. For generation-bound work, use `gpt-5.6-luna` at `high` reasoning for every runner. Use standard mode; never use fast mode or substitute another model or reasoning level. Spawn more when the arena covers multiple design directions. +3. Pick the runners. For judgment-sensitive work, cycle through `gpt-6-astra`, `gpt-5.6-sol`, `gpt-5.6-terra`, and `gpt-5.6-luna`, using Astra at `medium` reasoning by default and the other models at `high`; repeat the pool when `N > 4`. Use Astra `high` for reviews or reasoning-heavy candidates involving architectural or algorithmic tradeoffs, ambiguous root causes, or cross-system constraints. For generation-bound work, use `gpt-5.6-luna` at `high` reasoning for every runner. Use standard mode; never use fast mode or substitute another model or reasoning level. Spawn more when the arena covers multiple design directions. 4. Assign output paths. Each candidate writes to its own location (an authorized Codex worktree where possible, otherwise `/tmp/arena-/candidate-/`). N candidates writing to the same path is shared mutable state and fails the the **separate-before-serializing-shared-state** principle skill test. ## Phase B: Fan out -Spawn all N Codex collaboration agents in one concurrent batch when capacity allows and otherwise in waves, each with its Phase A model, `reasoning_effort: "high"`, `fork_turns: "none"`, the task, the path to the shared grounding, its own output path, and instructions to produce both the artifact and a short rationale. +Spawn all N Codex collaboration agents in one concurrent batch when capacity allows and otherwise in waves, each with its Phase A model and explicit `reasoning_effort`, `fork_turns: "none"`, the task, the path to the shared grounding, its own output path, and instructions to produce both the artifact and a short rationale. The rationale is mandatory. Without it, the parent cannot tell whether a candidate's structure is principled or accidental, which makes Phase E grafting unreliable. Each rationale names the alternatives the candidate considered and what it rejected. diff --git a/skills/figure-it-out/SKILL.md b/skills/figure-it-out/SKILL.md index 50a1320..9721633 100644 --- a/skills/figure-it-out/SKILL.md +++ b/skills/figure-it-out/SKILL.md @@ -28,7 +28,7 @@ Present the framing and tradeoffs before committing to a long run. Reversible wo Decompose into atomic, independently-landable units. Sequence riskiest-unknown-first so option value stays high. Scaffold and verification come before features (the **foundational-thinking** principle skill). - Build the verification harness before the work, with the baseline captured from the pre-change state, so the check reads as "old value vs new value". -- For one-way-door design decisions, run the **architect** skill (it runs **arena**) with isolated, opinionated candidates and a separately prompted judge. Follow **arena**'s model pool and judge contract, all at `high` reasoning and never fast mode. Skip it for mechanical work whose shape is already concrete. A second arena over a settled design is over-engineering (the **laziness-protocol** principle skill). +- For one-way-door design decisions, run the **architect** skill (it runs **arena**) with isolated, opinionated candidates and a separately prompted judge. Follow **arena**'s model and effort contracts, using Astra `high` for these consequential design decisions. Never use fast mode. Skip it for mechanical work whose shape is already concrete. A second arena over a settled design is over-engineering (the **laziness-protocol** principle skill). - Decide what fans out. Parallelize only across genuine seams, and give each worker its own worktree or branch (the **separate-before-serializing-shared-state** principle skill). Don't over-fan. - Write the designed phase list down. That list is what the human reviews. diff --git a/skills/how/SKILL.md b/skills/how/SKILL.md index 0bfdf4f..05c41dd 100644 --- a/skills/how/SKILL.md +++ b/skills/how/SKILL.md @@ -14,11 +14,11 @@ Two modes: ## Codex Agent Contracts -Every agent uses `reasoning_effort: "high"` and `fork_turns: "none"` in standard mode. +Every agent uses `fork_turns: "none"` in standard mode. Set `reasoning_effort` explicitly by role below. -- Explorers use `model: "gpt-5.6-luna"`. -- Explainers and synthesizers use `model: "gpt-6-astra"`. -- Architectural critics use `gpt-6-astra`, `gpt-5.6-sol`, and `gpt-5.6-terra`, one critic per model. +- Explorers use `model: "gpt-5.6-luna"` at `high` reasoning. +- Explainers and synthesizers use `model: "gpt-6-astra"` at `medium` reasoning. Use `high` when explaining complex cross-system behavior or reconciling conflicting evidence requires substantial reasoning. +- Architectural critics use `gpt-6-astra`, `gpt-5.6-sol`, and `gpt-5.6-terra`, one critic per model, all at `high` reasoning because these are reviews. Never use fast mode. If a required configuration is unavailable, stop and report the blocker rather than substituting another model or reasoning level. diff --git a/skills/poteto-mode/SKILL.md b/skills/poteto-mode/SKILL.md index a38a15d..85b5fab 100644 --- a/skills/poteto-mode/SKILL.md +++ b/skills/poteto-mode/SKILL.md @@ -87,7 +87,7 @@ Read the leaf skill in full for any principle you apply. Each entry names when i **Use the `poteto-agent` instructions in `references/poteto-agent.md` for any subagent you spawn inside a playbook step** (code-writing delegates, ad-hoc helpers). `$poteto-mode` and `poteto-agent` route through the same wrapper. Routed workflow skills (`how`, `why`, `interrogate`, `reflect`, `swarm`) set their own subagent instructions; respect what the skill prescribes, don't override them with `poteto-agent`. -**Model routing.** Routed workflow skills own their model contracts. For subagents spawned directly inside a playbook step, use `model: "gpt-6-astra"` for implementation, synthesis, and judgment; `model: "gpt-5.6-luna"` for read-only discovery and procedural verification; and `model: "gpt-5.6-sol"` for an independent review of Astra work. If Sol performed the work being reviewed, use `model: "gpt-5.6-terra"` for that review. Comment Sicko follows the **no-comments** skill and uses Luna. Every spawn uses `reasoning_effort: "high"`, `fork_turns: "none"`, and standard mode. Never use fast mode. Never substitute another model or reasoning level. If the required configuration is unavailable, stop and report the blocker. Run concurrently when the work is independent, with file pointers rather than inlined context. Codex collaboration agents share the checkout, so concurrent writers need disjoint file ownership; serialize shared writes unless the user explicitly authorized isolated worktree tasks. +**Model routing.** Routed workflow skills own their model contracts. For subagents spawned directly inside a playbook step, use `model: "gpt-6-astra"` for implementation, synthesis, and judgment; `model: "gpt-5.6-luna"` for read-only discovery and procedural verification; and `model: "gpt-5.6-sol"` for an independent review of Astra work. If Sol performed the work being reviewed, use `model: "gpt-5.6-terra"` for that review. Comment Sicko follows the **no-comments** skill and uses Luna. For Astra, use `reasoning_effort: "medium"` by default for implementation, explanation, and synthesis. Use `high` for reviews and reasoning-heavy work: architectural or algorithmic tradeoffs, ambiguous root-cause analysis, concurrency or performance diagnosis, or decisions spanning several systems. Task size or duration alone does not justify high. Assign the effort explicitly in each spawn. Sol, Terra, and Luna retain `high`. Every spawn uses `fork_turns: "none"` and standard mode. Never use fast mode. Never substitute another model or reasoning level. If the required configuration is unavailable, stop and report the blocker. Run concurrently when the work is independent, with file pointers rather than inlined context. Codex collaboration agents share the checkout, so concurrent writers need disjoint file ownership; serialize shared writes unless the user explicitly authorized isolated worktree tasks. You own every subagent's work. Review the diff and write your own summary, don't pass through what it said. Interrupt-chained resumes silently drop directives, so fire a fresh subagent with consolidated scope rather than trusting a "done" summary. A second opinion is the same prompt in an independent fresh context. Agreement is high-signal. diff --git a/skills/poteto-mode/playbooks/bug-fix.md b/skills/poteto-mode/playbooks/bug-fix.md index 7331ca4..8eb42fb 100644 --- a/skills/poteto-mode/playbooks/bug-fix.md +++ b/skills/poteto-mode/playbooks/bug-fix.md @@ -6,7 +6,7 @@ Be scientific. Every shipped line traces to runtime evidence. Belt-and-suspender 1. Reproduce it yourself on the matching surface via the verification skill or tool (Non-negotiables). Don't hand the repro to the user. A debug or instrumentation protocol that says to ask the user does not override this; you drive the instrumented runtime. Ask the user only with a stated, specific reason the verification surface cannot reach the target, and only after driving it as far as it goes. Won't reproduce directly, force it: synthesize the trigger, tighten conditions, or instrument until it fires. A bug you can't reproduce, you can't prove fixed. 2. Binary-search the cause. Form the candidate hypotheses, then rule them out until one survives. Seed them with `how` over the affected subsystem and the **why** skill for regression history. Each pass, take the split that cuts the most remaining problem space, get runtime evidence, eliminate. When program state is unclear, add instrumentation or logging and read it as the code runs. Don't guess. Drive a long or stubborn hunt with Codex Goal mode (`/goal`). Confirm the surviving *mechanism* with runtime evidence before the step-3 architect/interrogate fan-out; a design grounded on a plausible-but-unconfirmed cause can be unanimously wrong while the real cause sits one subsystem over. -3. Plan the fix. If it crosses a function boundary, `architect` first. Delegate implementation to a subagent using `gpt-6-astra` at high reasoning with a specific scope; review the diff. +3. Plan the fix. If it crosses a function boundary, `architect` first. Delegate implementation to a subagent using `gpt-6-astra` at medium reasoning, or high for reasoning-heavy work under **Model routing**, with a specific scope; review the diff. 4. Verify on the same surface; the original repro now passes. "Inconclusive" or wrong-surface is not a pass; flag it. Unit tests show branch behavior, not bug absence. 5. When commits are authorized, stage them so the failing repro lands before the fix in git history; the diff tells the story. Otherwise keep the failing repro and fix as local changes in that order. See the **tdd** skill for the failing-test-first cadence when the bug has a cheap local test path; skip it when the test would be expensive, integration-heavy, or unclear. This is the canonical **sequence-verifiable-units** principle skill, the failing test first and the fix on top. diff --git a/skills/poteto-mode/playbooks/eval.md b/skills/poteto-mode/playbooks/eval.md index 5337110..4119e3e 100644 --- a/skills/poteto-mode/playbooks/eval.md +++ b/skills/poteto-mode/playbooks/eval.md @@ -19,7 +19,7 @@ Evals test how a change affects agent behavior before promoting it: a new skill 1. **Frame.** State what variant is under test and what behavior counts as success. Write the rubric (3-6 concrete criteria) for the judge only. Hold it back from candidates. 2. **Set up sanitized environments.** Per-candidate working dir with the variant in place. Plant any context an organic task would have: a project skeleton, the skills the candidate would naturally read. 3. **Author one organic prompt.** What a user would type. No leakage of what's being measured. -4. **Spawn N parallel candidates** in independent fresh contexts per the **arena** skill's Phase B. Use the Phase A model pool declared by **arena**, at high reasoning. Each works in its own sanitized dir; same prompt to each. +4. **Spawn N parallel candidates** in independent fresh contexts per the **arena** skill's Phase B. Use the Phase A model pool and reasoning efforts declared by **arena**. Each works in its own sanitized dir; same prompt to each. 5. **Spawn one blinded judge** in another independent fresh context per the **arena** skill's Phase C. The judge uses `gpt-6-astra` at high reasoning and sees outputs by sanitized label and the rubric, never a run label. 6. **Verify the chain from transcripts, not self-report.** Read each candidate's exact current-thread rollout under `${CODEX_HOME:-$HOME/.codex}/sessions`, resolved from `CODEX_THREAD_ID`. Do not read unrelated sessions. Look at which files each candidate actually opened. Citing a principle is not reading its leaf skill, and reading it is not applying it. Grade chain-following from the files it really read plus the shape of the code, never from the candidate's own claims. 7. **Read every candidate output yourself** end to end. Compare to the judge's verdict. Disagreement means a model is biased or the rubric is ambiguous. Synthesize. diff --git a/skills/poteto-mode/playbooks/feature.md b/skills/poteto-mode/playbooks/feature.md index 9a74b7d..3c014c9 100644 --- a/skills/poteto-mode/playbooks/feature.md +++ b/skills/poteto-mode/playbooks/feature.md @@ -9,7 +9,7 @@ - **Independent workstreams.** Disjoint files, services, or layers parallelize. Shared writes serialize. - **Shared mutable state.** Default to splitting the target (the **separate-before-serializing-shared-state** principle skill). Serialize only for real invariants. - **Smallest safe decomposition.** If one worker is best, name why. -4. Delegate code-writing to a subagent using `gpt-6-astra` at high reasoning with a specific scope (file paths, named data shape and its organizing structure per **principle-model-the-domain** — a state machine over scattered booleans, a table/registry over branching, a typed model over repeated shape assumptions, chosen before the delegate writes logic — and success criteria); review its diff yourself. When the implementation admits multiple valid shapes (error handling, abstraction layer, test structure), delegate via the **arena** skill instead so the runners surface the alternatives and the cross-judge guards the pick. Mandatory: no skip-with-reason escape, and Laziness Protocol does not override it (the gain is review separation, not lines saved). You can spawn a subagent even though you are one; "the app is small" and "a subagent cannot spawn one" are both wrong. A subagent forbidden to spawn satisfies this by owning the diff directly with the same review separation; no "standing by" reply that waits on a nested agent. Comments per **Comments**. Surgical edits, re-ground against the source for upstream-derived files. Port shared-primitive improvements to all consumers and verify each. Commit liberally when commits are authorized. +4. Delegate code-writing to a subagent using `gpt-6-astra` at medium reasoning, or high for reasoning-heavy work under **Model routing**, with a specific scope (file paths, named data shape and its organizing structure per **principle-model-the-domain** — a state machine over scattered booleans, a table/registry over branching, a typed model over repeated shape assumptions, chosen before the delegate writes logic — and success criteria); review its diff yourself. When the implementation admits multiple valid shapes (error handling, abstraction layer, test structure), delegate via the **arena** skill instead so the runners surface the alternatives and the cross-judge guards the pick. Mandatory: no skip-with-reason escape, and Laziness Protocol does not override it (the gain is review separation, not lines saved). You can spawn a subagent even though you are one; "the app is small" and "a subagent cannot spawn one" are both wrong. A subagent forbidden to spawn satisfies this by owning the diff directly with the same review separation; no "standing by" reply that waits on a nested agent. Comments per **Comments**. Surgical edits, re-ground against the source for upstream-derived files. Port shared-primitive improvements to all consumers and verify each. Commit liberally when commits are authorized. 5. Verify on the matching surface. "Inconclusive" or wrong-surface is not a pass; flag it. 6. Rebase into small, ordered commits; stack follow-ups. Use the **sequence-verifiable-units** principle skill, building, verifying, and committing each small unit before the next. diff --git a/skills/poteto-mode/playbooks/hillclimb.md b/skills/poteto-mode/playbooks/hillclimb.md index 02e8ca5..24a3275 100644 --- a/skills/poteto-mode/playbooks/hillclimb.md +++ b/skills/poteto-mode/playbooks/hillclimb.md @@ -9,7 +9,7 @@ Core discipline: one change, one measurement, keep or revert. Never stack untest 3. Open the decision log via the **show-me-your-work** skill. A `decision.tsv`, one row per attempt: id, hypothesis, change, before, after, delta, tests, verdict (kept or reverted), note. This is the run's memory. Read it before each attempt so the search accumulates instead of circling. Keep it out of the tree (gitignored) so it survives reverts. 4. Ground each hypothesis in the architecture model from step 1, so it names a specific mechanism ("defer X off the boot path because it blocks first paint"), not "try memoizing something". 5. Loop, one hypothesis per iteration: - - Hand the change to a subagent using `gpt-6-astra` at high reasoning with a tight scope; supervise and review the diff rather than typing it (the **guard-the-context-window** principle skill). When several independent hypotheses are live, fan them to parallel subagents, each with disjoint file ownership; use isolated worktree tasks only when the user authorized them (the **separate-before-serializing-shared-state** principle skill). + - Hand the change to a subagent using `gpt-6-astra` at medium reasoning, or high for reasoning-heavy work under **Model routing**, with a tight scope; supervise and review the diff rather than typing it (the **guard-the-context-window** principle skill). When several independent hypotheses are live, fan them to parallel subagents, each with disjoint file ownership; use isolated worktree tasks only when the user authorized them (the **separate-before-serializing-shared-state** principle skill). - Measure before and after with the frozen harness, and run the regression gate. - Accept only when the metric moves past noise and the gate stays green. Otherwise revert the change in full; a tweak that "might help" does not ride along. - When commits are authorized, make one commit per accepted fix, staging only the files you changed (`git add `, never `-A`). Log the row either way, kept or reverted. diff --git a/skills/poteto-mode/playbooks/multi-phase-plan.md b/skills/poteto-mode/playbooks/multi-phase-plan.md index 5d4abe1..5abc83d 100644 --- a/skills/poteto-mode/playbooks/multi-phase-plan.md +++ b/skills/poteto-mode/playbooks/multi-phase-plan.md @@ -63,7 +63,7 @@ Tests alone are not sufficient verification. A PR is verified only when its unit ### Verdict and merge, for every PR -- [ ] At the merge-ready head SHA, run the swarm per `${CODEX_HOME:-$HOME/.codex}/skills/swarm/SKILL.md`. The ten live lanes from the PR's **Verify, live** block use `gpt-5.6-luna` at high reasoning. One gates lane, the perf lane from its **Verify, perf** block, and one audit lane that reads the diff and the receipts and distrusts the PR body use `gpt-6-astra` at high reasoning. +- [ ] At the merge-ready head SHA, run the swarm per `${CODEX_HOME:-$HOME/.codex}/skills/swarm/SKILL.md`. The ten live lanes from the PR's **Verify, live** block use `gpt-5.6-luna` at high reasoning. The gates lane and the perf lane from its **Verify, perf** block use `gpt-6-astra` at medium reasoning; use high if they require reasoning-heavy diagnosis under **Model routing**. One audit lane that reads the diff and the receipts and distrusts the PR body uses `gpt-6-astra` at high reasoning. - [ ] Clean only when every lane is `PASS`. Findings go back to the owner. A new head gets a fresh swarm and a fresh verdict. - [ ] diff --git a/skills/poteto-mode/playbooks/orchestrate.md b/skills/poteto-mode/playbooks/orchestrate.md index 1e43614..5cb6411 100644 --- a/skills/poteto-mode/playbooks/orchestrate.md +++ b/skills/poteto-mode/playbooks/orchestrate.md @@ -16,7 +16,7 @@ Open a plan with the steps below copied in verbatim. A step you skip stays liste - **Coordinator (this chat).** Local. Frames, authors briefs, drains the inbox, owns the human report, makes judgment calls. It never authors or edits code: conflicted merges, restacks, and code changes are always tasks. When commits and pushes are authorized, mechanically landing a verified unit (fast-forward or clean cherry-pick of a worker's commit, then push) is bookkeeping the coordinator may do itself on repos where local git is cheap; queueing finished work behind an idle stacker is how a deadline harvests nothing. The loop is agentic end to end. Agents are spawned, resumed, and drained only through the Codex collaboration tools. State reads and writes go through `${CODEX_HOME:-$HOME/.codex}/skills/poteto-mode/scripts/dist/orch` at drain points, one command in and one line out, to conserve context. The CLI never spawns, waits, or wakes anything. - **Sub-coordinator.** Always local, durable, one per track, and only when the program exceeds what one coordinator's drains can manage. A track the coordinator can drain itself needs no middle layer: each nested layer re-pays a full orientation preamble, and a blocking sub-coordinator hides its children while the parent idles. Owns its track's units and boards, authors its workers' briefs, spawns its own workers and verifiers (nesting works within Codex's available collaboration depth and concurrency). Rolls up aggregates at wave boundaries; never forwards raw child reports. Cap in-flight children at what one drain can process, roughly ten, as a rolling window; never as blocking batches, which cost the slowest child of every batch. -- **Worker / verifier.** Use Codex collaboration subagents at high reasoning and in standard mode. Workers use `gpt-6-astra`. Procedural or live verifiers use `gpt-5.6-luna`; judgment-heavy or high-blast-radius final verifiers use `gpt-6-astra`. Never use fast mode. Runtime verification uses the matching project `verify-` skill, `$browser-use`, `$peekaboo`, or a terminal or PTY; local transcripts are exact current-thread rollouts under `${CODEX_HOME:-$HOME/.codex}/sessions/`; simulators and local IDE state stay local. Subagents share the checkout and can read the local store. Prefer fewer, broader workers; one writer per disjoint file set. Serialize shared writes unless the user explicitly authorized isolated worktree tasks (principle-separate-before-serializing-shared-state). Run a unit's verifier in an independent fresh context from its worker. +- **Worker / verifier.** Use Codex collaboration subagents in standard mode. Workers use `gpt-6-astra` at medium reasoning, or high for reasoning-heavy work under **Model routing**. Procedural or live verifiers use `gpt-5.6-luna` at high reasoning; judgment-heavy or high-blast-radius final verifiers use `gpt-6-astra` at high reasoning. Never use fast mode. Runtime verification uses the matching project `verify-` skill, `$browser-use`, `$peekaboo`, or a terminal or PTY; local transcripts are exact current-thread rollouts under `${CODEX_HOME:-$HOME/.codex}/sessions/`; simulators and local IDE state stay local. Subagents share the checkout and can read the local store. Prefer fewer, broader workers; one writer per disjoint file set. Serialize shared writes unless the user explicitly authorized isolated worktree tasks (principle-separate-before-serializing-shared-state). Run a unit's verifier in an independent fresh context from its worker. Depth stays at coordinator, track, worker. Author the track decomposition per project (build, landing, and verification are common cuts, not a required shape); hard-coded swarm trees were tried and parked as too rigid. @@ -53,7 +53,7 @@ STANDING Size the brief to the unit. A one-command unit gets the template collapsed to a paragraph that still names goal, scope, the verify command, and the report shape; a 4KB scaffold around a two-line edit costs more to write and obey than the edit. Spawns may reference the standing-orders file by store path when they share the local filesystem; paste it verbatim for every other spawn and every resume. -A sub-coordinator brief adds its track boundary and unit list, its spawn budget with `gpt-6-astra` high reasoning for workers, `gpt-5.6-luna` high reasoning for procedural or live verifiers, and `gpt-6-astra` high reasoning for judgment-heavy or high-blast-radius final verifiers, plus the local-surface exception list, the drain protocol, and the rollup format (per child: name, status, PR, head SHA, verdict, one line; plus track status and frontier delta). +A sub-coordinator brief adds its track boundary and unit list, its spawn budget with `gpt-6-astra` medium reasoning for workers, with high reserved for reasoning-heavy work under **Model routing**, `gpt-5.6-luna` high reasoning for procedural or live verifiers, and `gpt-6-astra` high reasoning for judgment-heavy or high-blast-radius final verifiers, plus the local-surface exception list, the drain protocol, and the rollup format (per child: name, status, PR, head SHA, verdict, one line; plus track status and frontier delta). A dependency is a context relay, not just ordering: undeclared upstream context makes the worker guess. Missing fields are a refuse-to-spawn condition. Audit one sampled worker brief per sub-coordinator per wave, concurrently with the wave it samples, never as a gate in front of it; a failing brief stops that track and fixes the sub-coordinator's instructions, not just the worker, because brief quality decays late in a run. Never resume-chain a brief; respawn fresh with consolidated scope. @@ -88,7 +88,7 @@ This orchestration runtime is GitHub-only. If the active forge is Origin, stop b #### Verification -Scale verification to the unit. When VERIFY is a single cheap command, the worker runs it and reports the output, and the coordinator spot-checks receipts; a dedicated verifier agent in an independent fresh context uses `gpt-5.6-luna` for procedural or live verification and `gpt-6-astra` when verification is judgment-laden or high-blast-radius. A verifier agent whose entire product would be rerunning one command is ceremony, not verification. +Scale verification to the unit. When VERIFY is a single cheap command, the worker runs it and reports the output, and the coordinator spot-checks receipts; a dedicated verifier agent in an independent fresh context uses `gpt-5.6-luna` for procedural or live verification and `gpt-6-astra` at high reasoning when verification is judgment-laden or high-blast-radius. A verifier agent whose entire product would be rerunning one command is ceremony, not verification. Write ledger rows with `orch ledger record`. Check the current PR and head SHA with `orch ledger check`. `ledger.tsv`, one row per verdict, keyed by PR number plus head SHA: `live-ui-verified | unit-test-verified | type-check-only | verifier-blocked | verifier-failed`. CI green is an input to a verdict, not a verdict. Behavioral work needs better than `type-check-only`. `verifier-blocked` is not a pass; respawn when the environment heals. `verifier-failed` gets a fix unit, not a re-verify. A worker may self-report; a verifier overrides it on the same key. A new head SHA voids the row, so re-verify after restack. The ledger answers "was this verified", not memory and not the transcript. diff --git a/skills/poteto-mode/playbooks/perf-issue.md b/skills/poteto-mode/playbooks/perf-issue.md index d45080c..be92cae 100644 --- a/skills/poteto-mode/playbooks/perf-issue.md +++ b/skills/poteto-mode/playbooks/perf-issue.md @@ -13,7 +13,7 @@ - **Redundancy.** The wait hangs on one slow instance or attempt. Duplicate the work (replicas, hedged requests, speculative execution) and take the fastest result. This trades extra load for lower tail latency, so the trace has to show the wait dominates and the system has headroom; duplication without that tradeoff only adds load. - **Lazy evaluation.** Cost lands on results that are never used or not needed yet (eager init on the boot path, rendering offscreen items). Defer the work until first use. - **Scheduling.** The work must happen, but not during the interactive moment. Move it to where nobody is waiting: idle callbacks, a background warmup after boot, precompute before the user arrives, cleanup after the frame commits. Distinct from Lazy (later-when-needed): Scheduling often runs the work *earlier* than the hot moment, or in its shadow. The win is perceived latency, so measure the interactive path, not total work done. -3. Plan the fix from the trace. If it crosses a function boundary, `architect` first. Delegate implementation to a subagent using `gpt-6-astra` at high reasoning; review the diff. Capture a post-fix trace. +3. Plan the fix from the trace. If it crosses a function boundary, `architect` first. Delegate implementation to a subagent using `gpt-6-astra` at medium reasoning. Use high when the implementation still requires complex performance or concurrency reasoning. Review the diff. Capture a post-fix trace. Apply the **sequence-verifiable-units** principle skill, verifying each attempt before trying the next. 4. Parse and compare the artifacts (JSON to sqlite, diff). "Inconclusive" or wrong-surface is not a pass; flag it. 5. Cite the measurement in the PR. diff --git a/skills/poteto-mode/playbooks/refactoring.md b/skills/poteto-mode/playbooks/refactoring.md index 86898a6..ed5b520 100644 --- a/skills/poteto-mode/playbooks/refactoring.md +++ b/skills/poteto-mode/playbooks/refactoring.md @@ -8,7 +8,7 @@ A refactor that smuggles in a behavior change loses its safety net. If the clean 2. Name the structure the code is missing per **principle-model-the-domain**: a state machine over scattered booleans, a table or registry over spread-out branching, a typed model over repeated shape assumptions, a reducer over ad hoc mutations. Boring code stays when the shape is already clear and local; the reshape must delete branches or invalid states, not add indirection. 3. Name the target shape. State what the module layout, types, and call graph should be if built today (**principle-foundational-thinking**, **principle-redesign-from-first-principles**). If the target crosses a function boundary, run the **architect** skill for parallel design exploration of the shape before the move. 4. Subtract before you add. Delete dead weight, collapse one-caller wrappers, drop redundant validators, and remove orphan references before introducing the new shape (**principle-subtract-before-you-add**). The smallest change that reaches the target shape ships (**principle-laziness-protocol**). A speculative cleanup that "might help" gets reverted, not left to ride. -5. Move in small behavior-preserving steps, each keeping the pin green. For API reshapes, migrate every caller and delete the old API in the same wave (**principle-migrate-callers-then-delete-legacy-apis**). No compatibility shims, no parallel old-and-new paths. Spot-check every rename against the actual files; renames silently miss usages in strings, prose, and back-references. Delegate the mechanical edits to a subagent using `gpt-6-astra` at high reasoning with a specific scope (file paths, the names being moved, the behavior to hold); review the diff yourself. +5. Move in small behavior-preserving steps, each keeping the pin green. For API reshapes, migrate every caller and delete the old API in the same wave (**principle-migrate-callers-then-delete-legacy-apis**). No compatibility shims, no parallel old-and-new paths. Spot-check every rename against the actual files; renames silently miss usages in strings, prose, and back-references. Delegate the mechanical edits to a subagent using `gpt-6-astra` at medium reasoning with a specific scope (file paths, the names being moved, the behavior to hold); review the diff yourself. 6. Prove behavior is unchanged on the real artifact, not "it compiles" (**principle-prove-it-works**). For larger reshapes, run an equivalence check: a script that diffs old-vs-new outputs, a recorded baseline replayed against the new code, or a smoke run on the matching surface via the relevant verification skill or tool. Own the verification yourself; do not trust a delegate's "looks good" summary. 7. Confirm the change earns its place. The success measure is reduced reader load (**principle-minimize-reader-load**): fewer layers between question and answer, less hidden state, fewer indirections without a second consumer. If the diff does not lower reader load somewhere, revert it. 8. Rebase into small ordered commits that tell the story. A subtraction commit, then the reshape, then any follow-on cleanup, so a single revert undoes one slice. Shape them with the **sequence-verifiable-units** principle skill, so each behavior-preserving slice stays green before the next. Run **Opening a PR**. diff --git a/skills/poteto-mode/references/poteto-agent.md b/skills/poteto-mode/references/poteto-agent.md index 7f6cfff..b69fd16 100644 --- a/skills/poteto-mode/references/poteto-agent.md +++ b/skills/poteto-mode/references/poteto-agent.md @@ -5,4 +5,4 @@ description: Routing instructions for `$poteto-mode` and any request for poteto' # Poteto subagent -You are operating as poteto-mode's full agent style. Use the model explicitly assigned by the parent under the routed skill or playbook contract; default to `gpt-6-astra` when none is assigned. Always use `high` reasoning and standard mode. Never use fast mode or substitute another model. Read the `poteto-mode` skill's `SKILL.md` in full before doing any work, including its inline Principles index. Navigate to a leaf `principle-*` skill whenever you apply that principle. +You are operating as poteto-mode's full agent style. Use the model explicitly assigned by the parent under the routed skill or playbook contract; default to `gpt-6-astra` when none is assigned. Honor the parent's assigned reasoning effort under the **Model routing** contract. For Astra, default to `medium`; use `high` for reviews and reasoning-heavy work under that contract. Other assigned models retain `high`. Always use standard mode. Never use fast mode or substitute another model. Read the `poteto-mode` skill's `SKILL.md` in full before doing any work, including its inline Principles index. Navigate to a leaf `principle-*` skill whenever you apply that principle. diff --git a/skills/why/SKILL.md b/skills/why/SKILL.md index 4f29b4f..059601a 100644 --- a/skills/why/SKILL.md +++ b/skills/why/SKILL.md @@ -11,10 +11,10 @@ Companion to the `how` skill. `how` answers what the code does and how it works. ## Codex Agent Contracts -Every agent uses `reasoning_effort: "high"` and `fork_turns: "none"` in standard mode. +Every agent uses `fork_turns: "none"` in standard mode. Set `reasoning_effort` explicitly by role below. -- Investigators use `model: "gpt-5.6-luna"`. -- The synthesizer uses `model: "gpt-6-astra"`. +- Investigators use `model: "gpt-5.6-luna"` at `high` reasoning. +- The synthesizer uses `model: "gpt-6-astra"` at `medium` reasoning. Use `high` when conflicting historical evidence or architectural tradeoffs require substantial reasoning. Never use fast mode. If a required configuration is unavailable, stop and report the blocker rather than substituting another model or reasoning level. From b6994047db1e9a96acdf33911860eb660f4ad8c5 Mon Sep 17 00:00:00 2001 From: Bram Van Rompuy Date: Sun, 6 Sep 2026 23:12:14 +0200 Subject: [PATCH 2/2] Fix numbering for output paths assignment step Co-authored-by: Copilot Autofix powered by AI <175728472+Copilot@users.noreply.github.com> --- skills/arena/SKILL.md | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/skills/arena/SKILL.md b/skills/arena/SKILL.md index f4b1bef..1ef136f 100644 --- a/skills/arena/SKILL.md +++ b/skills/arena/SKILL.md @@ -25,7 +25,7 @@ The N candidates will receive the same prompt, so the prompt is the contract. Ge 1. State the artifact each candidate is producing. 2. Derive the rubric. State what success looks like for *this* task, then turn it into 3-6 concrete gradeable criteria. Concrete: `Adds a --dry-run flag that skips writes`. Vague: `code is correct`. The rubric is the picker's tool in Phase D; candidates only see the task. 3. Pick the runners. For judgment-sensitive work, cycle through `gpt-6-astra`, `gpt-5.6-sol`, `gpt-5.6-terra`, and `gpt-5.6-luna`, using Astra at `medium` reasoning by default and the other models at `high`; repeat the pool when `N > 4`. Use Astra `high` for reviews or reasoning-heavy candidates involving architectural or algorithmic tradeoffs, ambiguous root causes, or cross-system constraints. For generation-bound work, use `gpt-5.6-luna` at `high` reasoning for every runner. Use standard mode; never use fast mode or substitute another model or reasoning level. Spawn more when the arena covers multiple design directions. -4. Assign output paths. Each candidate writes to its own location (an authorized Codex worktree where possible, otherwise `/tmp/arena-/candidate-/`). N candidates writing to the same path is shared mutable state and fails the the **separate-before-serializing-shared-state** principle skill test. +4. Assign output paths. Each candidate writes to its own location (an authorized Codex worktree where possible, otherwise `/tmp/arena-/candidate-/`). N candidates writing to the same path is shared mutable state and fails the **separate-before-serializing-shared-state** principle skill test. ## Phase B: Fan out