Launch research harness
Skill aburan28/crypto-autoresearcher/.claude/skills/launch-research-harness
Discover, select, and run a crypto-autoresearcher research goal through the Coordinator + dynamic-dispatch harness. Use when the user asks to run the harness, launch a research goal, continue GOAL-*, resume a campaign, or run crypto-autoresearcher.From its SKILL.md
npx -y skills add aburan28/crypto-autoresearcher --skill launch-research-harnessAssembled from the repository path, not quoted from the project. Check it against their README if it does not work.
2 things to look at
- no licenseNo license file was found in the repository. Code published without one is not open source by default, so using it at work is a question for whoever answers licensing questions where you are.
- 1 stars1 stars. Stars are a popularity signal and not a quality one, but at this level it is likely that nobody has read this closely except its author, and you would be relying on your own review.
SKILL.md
20.0 KB, as published. Nobody here has run it
Launch research harness
Entry point for starting or resuming a persistent GOAL-* campaign. This skill
selects the goal and binds committed state; the continuous batch loop is
/coordinate-research-goal.
The harness runs indefinitely. It is a standing process, not a one-shot errand: batches follow batches, and a goal reaching a terminal status hands off to the next goal rather than ending the session. Only the conditions in "Terminal stops" below end a run. Everything else — an empty ready set, a failed candidate, an exhausted campaign budget, a completed goal — is a transition to the next unit of work, taken through the standing loop in step 9. Indefinite operation changes what you do when work runs out; it changes none of the evidence, archival, or review rules, and it is never a licence to manufacture work to stay busy.
Do not invent runs, timings, or review verdicts. Do not change hypothesis or goal status outside Coordinator ledger archives.
Required reads (once per session)
AGENTS.md,CLAUDE.md.claude/skills/coordinate-research-goal/SKILL.md.claude/skills/research-status/SKILL.md(read-only overview)docs/dynamic-subagent-dispatch.md,docs/task-lifecycle.md(as needed)orchestration/model-policies.yamlfor role→policy aliases
Procedure
1. Research status (read-only)
Run the /research-status checklist: scan ledger/ and flag integrity issues
(uncommitted archives, broken refs). Do not mutate state in this step.
2. Discover goals
List ledger/goals/GOAL-*.yaml. For each, read research_goal.{id,status, title,current_batch_id,dispatch_queue_path,next_action,campaign_budget, completion_criteria,pause_conditions}.
Statuses: draft | active | paused | blocked | completed | cancelled.
Also note matching dirs under coordination/goals/GOAL-*/batches/.
3. Select a goal
Pick in this order:
- Explicit
GOAL-*in the user request. - Single
activegoal that matches the request text or current branch/area. - Any other
activegoal, highest ranked first, when the request names no specific one. In a standing run this is the ordinary case and needs no user prompt — the harness is expected to keep working the active portfolio. - Otherwise list
active/pausedgoals (ID, status, batch, next action) and ask which to run. Do not silently resume apausedorcompletedgoal: a pause was recorded for a reason, and resuming it requires either the user or a committed Coordinator decision clearing that reason.
If no active goal exists at all, do not stop — go to step 9's "when the
portfolio is empty".
Resume an existing goal: use its dispatch_queue_path and
current_batch_id; continue from next_action.
Start new: only when the user asks for a new campaign. Mint the goal with
python3 tools/allocate_id.py --next goal --area AREA, confirm the emitted
GOAL-<AREA>-<tok> with --check, and create its YAML record from
templates/research-records.md. Never choose a suffix or scan for a maximum.
Bind RQ-*, then create coordination/goals/GOAL-.../batches/BATCH-<tok>/
with handoffs + queue
(goal_id set), then follow /coordinate-research-goal launch steps.
Snapshot-archive the goal/queue/handoffs before any worker runs.
4. Bind committed state
Confirm before dispatching workers:
- Goal record is committed (or about to ride a Coordinator snapshot).
dispatch_queue_pathexists and queue top-levelgoal_idmatches.- Campaign budget still allows another batch (
maximum_batches,total_wall_clock_seconds, andmax_concurrentsized to what the environment can run without degrading — see "Concurrency" below). An exhausted budget stops this campaign, not the harness: pause the goal and move to the next one via step 9. Never quietly raise a budget to keep a campaign running — a budget extension is a Coordinator decision with a recorded rationale. next_actionis concrete; empty queue alone does not complete the goal.- The working branch exists, is pushed to origin, and has an open PR against
main. If not, create the branch, push it, and open the PR now — do not run a campaign that cannot surface its artifacts. - The working branch is current with
main(see "Branch and PR hygiene").
If a pause/completion criterion already holds, stop and report — do not invent work to fill capacity.
5. Render dispatch
From repo root, using the goal's queue path:
python3 tools/research_dispatch.py <dispatch_queue_path> \
--output <batch-dir>/dispatch_plan.json \
--report <batch-dir>/dispatch_plan.md
Use the paths the goal/batch already use (e.g. dispatch_queue.json or
dispatch_queue.v2.json). Fix validation errors before starting agents.
Execute only tasks listed under the plan's dispatches array (Ready Tasks).
6. Launch the subagents
Ready tasks are executed BY SUBAGENTS, never by this session. The top-level session orchestrates: it renders the plan, launches agents, archives their output, and reports. Doing a worker's job here loses the role's tool restrictions, its reasoning-effort calibration, and — for review tasks — the independence the policy requires.
Pick the subagent from (queue role, inference.policy). Each agent carries
its own reasoning effort, calibrated in orchestration/model-policies.yaml and
enforced against the binding by tools/check_runtime_bindings.py:
queue role | inference.policy | subagent_type | effort |
|---|---|---|---|
executor | executor-mechanical | executor-mechanical | low |
executor | executor-implementation | executor | medium |
coordinator | coordinator-orchestration-code, coordinator-orchestration | coordinator | high |
idea-generator | research-deep | idea-generator | high |
validator, reviewer | review-adversarial | validator | xhigh |
red-team | review-adversarial | red-team | xhigh |
validator, reviewer | review-breakthrough | validator-breakthrough | max |
red-team | review-breakthrough | red-team-breakthrough | max |
A task that names no policy takes its role's default_policy from
orchestration/roles.yaml. Resolve any doubt with the table the harness itself
reads — never from memory:
python3 tools/check_runtime_bindings.py --list # role → policy → effort → binding
Which tier a review gets is not a judgement call: routing_rules in
model-policies.yaml sends claimed_breakthrough, a proposed closure, or a
result contradicting prior validated evidence to review-breakthrough, and
that policy is degradable: false.
Effort is a property of the agent, not of the call. Do not pass a model
override to the Agent tool, and do not reach for a cheaper tier to get a stuck
task moving — substituting validator for validator-breakthrough is exactly
the silent downgrade the policy layer forbids. If the required tier cannot be
served, that is a pause condition for the goal (step 4), not a substitution.
How to launch:
- Put every ready task with a disjoint
write_scopein one message, one Agent call each, so they run concurrently. Separate messages serialize the batch and waste the whole point ofmax_concurrent. - Never exceed the queue's
max_concurrent, and size it to real headroom (see "Concurrency"). - Independent review is a fresh Agent call. Never continue the producing
agent's session with
SendMessageto obtain a review — a continuation carries the producer's context and is the opposite of the independent sessionreview-adversarialandreview-breakthroughrequire. - Producers may run with
run_in_background: true; the snapshot archive waits for their terminal results. Coordinatorsnapshotandledgerarchive tasks run alone, never alongside other agents. - Subagents do not spawn subagents. Nesting puts work outside the batch the Coordinator authorised.
Bind every prompt to the committed task card rather than restating it:
Execute task <TASK-ID> for goal <GOAL-ID>.
Read first, and follow exactly:
- <batch-dir>/tasks/<TASK-ID>/task_card.yaml (your task card)
- ledger/handoffs/<TASK-ID>.yaml (your handoff envelope)
- AGENTS.md and your role contract
Snapshot commit to read (review roles): <sha>
write_scope: <exact paths> — write nothing outside it; never commit.
Budget: <wall clock / trials / cells>.
Requested policy: <policy-id>. Record it alongside the model that actually
answered; if this session cannot honour it, refuse rather than downgrade.
Deliverable: <artifact_paths>.
Return only the output record your role contract declares.
When an agent returns, record its result in the task receipt and move to the archive step. A returned artifact is not evidence until a Coordinator archive commits it and the dispatcher's post-commit verifier accepts it.
7. Run the coordinate loop
Follow /coordinate-research-goal for every batch:
- Start ≤ the queue's declared
max_concurrentnon-archive ready tasks with disjointwrite_scope, each via the subagent chosen in step 6. - On producer terminal: Coordinator-only
snapshotarchive alone; verify via dispatcher/Git before any review reads artifacts. - Independent Reviewer / Validator / Red Team as required, at the tier step 6
selects (
review-adversarial→validator/red-team;review-breakthrough→validator-breakthrough/red-team-breakthrough). Fresh agent call, independent session; never the producing agent alone on claim-changing results. - Coordinator-only
ledgerarchive alone; verify parent, paths, hashes, record IDs. - Update the
GOAL-*record in that ledger commit: batch checkpoint, decision refs,latest_verified_commit, exactly onenext_action. Rerank only after the verified checkpoint. - Regenerate the dispatch plan; open the next bounded batch while status is
active. Do not pause between batches for user confirmation — return to step 5 and keep going. When the goal leavesactive, go to step 9.
Lifecycle stage skills when a ready task maps to them: /propose-ideas,
/design-experiment, /run-experiment, /review-evidence,
/curate-knowledge.
Handoffs live in ledger/handoffs/ (envelope in AGENTS.md). Task cards and
receipts stay under the batch/task write_scope.
8. Branch and PR hygiene
Research only exists as durable evidence when it is committed AND pushed to a
branch that has an open PR against main. Two git duties ride alongside every
generation step — new goals, ideas, experiments, evidence, decisions, and
knowledge entries all require them:
Pull in changes from main before generating. Before creating or resuming
a goal, and before each new batch, merge origin/main into the working branch:
git fetch origin
git merge origin/main # merge, never rebase — AGENTS.md rule
Never rebase: the branch carries pushed run records and rebasing rewrites the
commits they were archived in. If the merge conflicts, do NOT resolve it by
picking a side — stop, report the conflict, and let the Coordinator create a
new superseding record (the same rule as any other immutable-record conflict).
After the merge, re-run the ledger validator (tools/validate_ledger.py) and
tools/check_merge_hygiene.py before dispatching workers.
Open or update the PR when new records are generated. Each time a snapshot
or ledger archive adds new GOAL-*, RQ-*, IDEA-*, H-*, EXP-*, EV-*,
DEC-*, TASK-*, or KN-* records, push the branch and open or refresh a PR
against main:
git push -u origin <branch>
gh pr create --base main --head <branch> --title "research: <summary>" --body "<records>"
# or, for an existing PR:
gh pr edit <number> --title "research: <summary>" --body "<records>"
Keep the PR open for the life of the campaign and mark it draft only while the batch is mid-flight; it exists so the work is reviewable and mergeable, not as a claim of closure. A goal, idea, or experiment that exists only in a local commit is not generated — it is unpublished.
9. Standing loop: goal terminal → next goal
A goal ending is a campaign boundary, not the end of the run. When the selected
goal leaves active, record its terminal state properly and then re-enter the
loop at step 2:
- Completed. The goal reached a declared
completion_criteriaitem via a committed Coordinator decision → markcompleted. The three-model closure quorum that also gated this is suspended (AGENTS.md rule 13), so a met criterion now suffices; a quorum without a met criterion still does not close a goal. The decision record must name which criterion was met and cite the evidence for it. Then rediscover goals and select the next one. - Paused or blocked. A declared
pause_conditionsitem triggered (budget exhausted, archive verification failure, unresolved required model policy withfallback_allowed: false) → markpausedwith a concrete resume action, then select the nextactivegoal. Pausing one campaign never pauses the harness, and the pressure to keep running is never a reason to press on through a triggered pause condition: an archive that will not verify or a policy that cannot be honored still halts that campaign immediately. - Required model policy cannot be honored without a silent downgrade —
refuse and pause that goal rather than substitute, then move on. This is
unchanged by the quorum suspension: it governs review policies such as
review-breakthrough, which is stilldegradable: false. If the policy is unresolvable for every goal in the portfolio, that is a terminal stop below.
When the portfolio is empty — no active goal, and every remaining one is
paused, blocked, or completed — the harness still does not exit. In priority
order:
- Resume a
pausedgoal whose recorded pause reason is now demonstrably cleared (budget renewed by decision, archive repaired, policy resolvable). The clearing goes in the resuming Coordinator decision; do not just flip the status. - Open a new campaign against the highest-ranked open
RQ-*orKN-OPEN-*item, following step 3's "Start new" path. - If no open question justifies a campaign, run
/propose-ideason the best-supported research question to generate candidates, then rank them and open a campaign against the winner.
Idling is a last resort and is reported as such. Continuous operation must not degrade into make-work: a campaign opened only to keep the loop turning, with no ranked justification, is worse than an honest report that the portfolio needs direction. If you reach that point, say so plainly and stop.
Terminal stops
Only these end the run itself:
- The user asks to stop.
- Every goal is terminal and none of the three portfolio-refill paths above yields a justified campaign.
- An attempted Amazon Bedrock resolution. Refuse it before inference and reroute only to an allowed backend that satisfies the same model policy. If none exists, report a harness-wide infrastructure stop; fallback or downgrade permission never authorizes Bedrock.
- A missing
api_directcredential is not itself terminal when an authenticated native Codex or Claude Code session satisfies the requested policy. Verify and record that direct session's model provenance, and refuse it if its resolved provider is Bedrock. - A harness-wide integrity failure that makes any durable work impossible:
no resolvable backend for a
degradable: falsepolicy, a repository that cannot be pushed, or a ledger that will not validate onmain. Report the failure and what would clear it; do not keep dispatching work that cannot be archived.
A failed candidate, empty ready set, or timeout is none of these. It is scoped evidence: record it, set the next action, continue.
Attestations are optional but never fictional. If you record one it asserts a review that happened; never record a quorum you did not obtain, and do not present a single-model review as independent corroboration. Nothing in indefinite operation relaxes this — a long run produces more claims, not cheaper ones.
Safety rules (non-negotiable)
- Only the Coordinator changes official hypothesis/goal status or shared ledgers.
- Snapshot archive before independent review; ledger archive before promotion.
- Never fabricate commands, outputs, timings, statistics, citations, or runs.
- Infra failures/timeouts are not mathematical counterevidence.
- Small- or toy-curve results are admissible; record the tested parameters and any transfer or extrapolation assumptions explicitly. Toy-curve results never become crypto-scale claims.
- Record requested policy + resolved model; no silent policy downgrade — including by dispatching a lower-effort subagent than the task's policy selects (step 6).
- Research work runs in subagents, not in the top-level session; independent review is a fresh agent call, never a continuation of the producer's.
- Never use Amazon Bedrock. OpenCode and the inference adapter must reject any Bedrock provider, backend, endpoint, or model before a request is sent.
- Workers do not commit into a shared worktree; Coordinator archive tasks alone stage declared paths and must pass post-commit verification.
- Concurrency ("Concurrency" note below): do not fill idle slots without a
ranked next action, regardless of how high
max_concurrentis set. - Every batch merges
origin/maininto the working branch (never rebases) and pushes with an open/updated PR againstmainbefore the next batch starts; never resolve a sync conflict by editing a record.
Concurrency
The fixed ceiling of three concurrent tasks was REMOVED on the user's
EXPLICIT DIRECTION of 2026-08-05 ("remove the concurrent limit from the code
rules") — see tools/research_dispatch.py's MAX_CONCURRENT_CEILING for the
mechanism and its restore path. A dispatch queue's max_concurrent field is
no longer bounded by the tooling; it is bounded by what the Coordinator sets.
That does not make sizing it a formality. GOAL-AES-003 BATCH-002 dispatched
three producers onto a 4-core machine against that batch's own instruction
that it wait rather than run degraded: load average reached 13, one
producer's entire first segment produced zero numbers, another lost five of
eight trials to timeouts (DEC-20260802-b226fb budget_accounting). Removing
the tooling ceiling removes the thing that used to catch an oversized value
before dispatch; it does not remove the machine's actual headroom. Check
available cores/memory before raising max_concurrent past what the prior
ceiling of three assumed, and size to the environment, not to the absence of
a check.
Output after each batch (and on stop)
Report: goal ID + status; completed task IDs + verified commits; evidence /
decision IDs with claim boundaries; knowledge promotions or not_warranted
reasons; exact next action (or pause/complete rationale); PR number/branch the
batch was pushed to and how current it is with main.
The report is a checkpoint, not a handover — write it and immediately begin the next batch or the next goal. When the run does end, say which terminal stop fired and what would let it resume.
Quick examples
User: run the harness for GOAL-ECDLP-001
→ status scan → bind GOAL-ECDLP-001 → render its dispatch_queue_path →
execute ready tasks → snapshot → review → ledger → rerank / next batch
User: continue the active ECDLP goal
→ prefer matching active GOAL-* → same loop from next_action
User: launch a new research goal for RQ-SSI-001
→ allocate and check GOAL-SSI-<tok> + BATCH-<tok> → snapshot → then coordinate loop
User: just keep the harness running
→ select highest-ranked active goal → batch → checkpoint → next batch → ...
→ on goal completion/pause, select or open the next goal → continue until a
terminal stop