@evo-hq/pi-evo 0.5.0-alpha.11 → 0.5.0-alpha.13

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@evo-hq/pi-evo",
-  "version": "0.5.0-alpha.11",
+  "version": "0.5.0-alpha.13",
   "description": "Evo plugin for pi-coding-agent: optimize/discover/subagent skills + mid-run inject extension.",
   "publishConfig": {
     "access": "public"

package/skills/discover/SKILL.md

@@ -2,7 +2,7 @@
 name: discover
 description: Initialize evo for the current repository by exploring the codebase, proposing unexplored optimization dimensions, constructing the benchmark inside a baseline worktree, and running the first experiment. Use when the user invokes /evo:discover, mentions setting up evo, wants to instrument a codebase for autonomous optimization, or asks to start a new evo run on a project.
 argument-hint: <optional context about what to optimize>
-evo_version: 0.5.0-alpha.11
+evo_version: 0.5.0-alpha.13
 ---
 
 # Discover
@@ -116,20 +116,20 @@ evo --version
 The output must be exactly:
 
 ```
-evo-hq-cli 0.5.0-alpha.11
+evo-hq-cli 0.5.0-alpha.13
 ```
 
 Three outcomes:
 
 1. **Matches exactly** — continue to step 1.
 2. **Reports a different version** (`evo-hq-cli 0.4.2`, etc.) — the host refetched a newer/older skill bundle than the CLI on PATH. Drift breaks skills silently. Stop and tell the user:
-   > Your installed evo CLI is on a different version than this skill (`0.5.0-alpha.11`). Run:
+   > Your installed evo CLI is on a different version than this skill (`0.5.0-alpha.13`). Run:
    > ```
-   > uv tool install --force evo-hq-cli==0.5.0-alpha.11
+   > uv tool install --force evo-hq-cli==0.5.0-alpha.13
    > ```
    > Then re-invoke this skill.
 3. **`command not found`, or reports a different package** (commonly `evo 1.x` — the unrelated SLAM tool) — the CLI isn't installed. Tell the user:
-   > `evo-hq-cli` isn't on your PATH. Install it: `uv tool install evo-hq-cli==0.5.0-alpha.11` (or `pipx install evo-hq-cli==0.5.0-alpha.11`). Then re-invoke this skill.
+   > `evo-hq-cli` isn't on your PATH. Install it: `uv tool install evo-hq-cli==0.5.0-alpha.13` (or `pipx install evo-hq-cli==0.5.0-alpha.13`). Then re-invoke this skill.
 
 Do not try to auto-install. Host sandbox + network policy may block it; leaving the install as a user action keeps failure modes clear.
 
@@ -308,10 +308,10 @@ Dashboard live: http://127.0.0.1:8080 (pid 12345)
 **Benchmark commands must be eval-only.** Do NOT wrap training and evaluation into a single benchmark command. If your benchmark command runs training before scoring, every gate revalidation and every `evo run --check` retrains from scratch, and the experiment budget burns on duplicated training instead of new experiments. Training is a separate step the agent invokes BEFORE `evo run`:
 
 1. The agent makes changes (data curation, hyperparameter selection, technique choice, training code edits).
-2. The agent runs training to produce a checkpoint at the experiment worktree's `final_model/` (or wherever the technique's recipe in `evo:finetuning/references/glue.md` specifies).
-3. THEN `evo run <exp_id>` invokes the registered benchmark command, which loads the produced checkpoint and emits a score.
+2. The agent runs the build/training step to produce its artifact — a checkpoint, adapter, index, whatever the recipe makes. Write it to `EVO_CHECKPOINT_DIR` (durable: survives between-attempt cleanup and discard) and declare it in the benchmark result's `artifacts` field so it's preserved + reusable; the per-technique I/O contract is in `evo:finetuning/references/glue.md`. Never hardcode a fixed name like `final_model/`.
+3. THEN `evo run <exp_id>` invokes the registered benchmark command, which loads the produced artifact and emits a score.
 
-The registered benchmark command should call `evaluate.py`, `run_eval.py`, or equivalent -- NOT `train.py`. If the project's only existing evaluation tool runs train+eval together with no eval-only mode, wrap it: add a `--skip-train` flag, or have the wrapper detect an existing checkpoint at `final_model/` and short-circuit the train step. Without this, evo's gate-recheck and re-score mechanics retrain repeatedly and the budget evaporates.
+The registered benchmark command should call `evaluate.py`, `run_eval.py`, or equivalent -- NOT `train.py`. If the project's only existing evaluation tool runs build+eval together with no eval-only mode, wrap it: add a `--skip-build` flag, or have the wrapper detect an existing artifact (under `EVO_CHECKPOINT_DIR`) and short-circuit the build step. Without this, evo's gate-recheck and re-score mechanics rebuild repeatedly and the budget evaporates.
 
 **Runtime environment.** If the benchmark needs keys or other runtime variables, configure them through evo rather than copying `.env` into worktrees or hand-editing `config.json`:
 
@@ -323,6 +323,16 @@ evo env show
 
 Values are resolved fresh by the orchestrator on each `evo run`. Config stores dotenv source metadata and key names, not secret values. The benchmark and gates receive the resolved env; gates do not receive `EVO_*` artifact variables.
 
+### 7a. Record the task category (`task-skills`)
+
+You already decided what's being optimized (steps 2–4). Record the evo category skill(s) a builder should load for it, so every executing agent — prose subagent or workflow lane — loads the right method knowledge instead of rediscovering it each round:
+
+```bash
+evo config set task-skills finetuning   # any weight-update / training task
+```
+
+Rule of thumb: if the optimization updates model weights (SFT / LoRA / DPO / RL / continued-pretraining), set `task-skills finetuning`. **Leave it unset** for prompt / code / config / harness optimization — the subagent protocol already covers those; only set it when a dedicated category skill applies. Use a comma-separated list if more than one applies. Mirror the choice in `.evo/project.md` (step 12) so it's human-readable and survives as the fallback if config is ever cleared.
+
 ## 8. Set up gates
 
 Gates inherit down the experiment tree -- children automatically get all ancestor gates.

package/skills/infra-setup/SKILL.md

@@ -1,7 +1,7 @@
 ---
 name: infra-setup
 description: Non-user-invocable provider/setup reference for evo backend switching, prerequisite checks, and auth/install guidance.
-evo_version: 0.5.0-alpha.11
+evo_version: 0.5.0-alpha.13
 ---
 
 # Infra Setup

package/skills/optimize/SKILL.md

@@ -2,7 +2,7 @@
 name: optimize
 description: Drive structured autoresearch iteration after evo:discover and the baseline commit -- scan-subagent cross-cutting analysis between rounds, frontier-based parent selection, ideator dispatch on stall, verifier pre/post hooks, annotation discipline. Width is set via subagents=N (1 for serial workloads, larger for parallel); the loop's structural value applies at any width.
 argument-hint: "[subagents=N] [budget=N] [stall=N]"
-evo_version: 0.5.0-alpha.11
+evo_version: 0.5.0-alpha.13
 ---
 
 Run the `evo` optimization loop. Each round, the orchestrator writes structured briefs and spawns subagents that execute within them. Each subagent is semi-autonomous: it reads the pointer traces, forms the concrete edit, runs experiments, and can iterate within its branch. Runs until interrupted or the stall limit is reached.
@@ -102,17 +102,19 @@ evo defaults get subagents-only --json
 
 As your **very first actions, before the loop**, resolve each and arm it: run `evo autonomous on` / `evo subagents-only on` when it resolves on, or `evo autonomous off` / `evo subagents-only off` when an explicit instruction or stored default turned it off. If a behavior resolves off — whether from the user's instruction this run or a stored default — say so in your opening message (e.g. "autonomous off — running one round at a time, as you asked") so it's never invisible.
 
-**Orchestrator driver (Claude Code only).** evo can drive the loop two ways: the prose loop below (default, every host), or a deterministic **dynamic workflow** (Claude Code only, opt-in). Resolve which as part of your very first actions:
+**Orchestrator driver.** evo drives the loop two ways: a deterministic **dynamic workflow** (Claude Code only) or the **prose loop** below (every host). **On Claude Code the workflow is the DEFAULT — use it whenever it's available.** Resolve which as part of your very first actions:
 
-1. `evo host show` — must be `claude-code` for the workflow driver. If it prints `<not set>` (a pre-host workspace), determine your actual runtime from your own context (system prompt, env such as `CLAUDECODE=1`, self-identity): **only if you are genuinely Claude Code**, do the one-time host migration now (`evo host set claude-code`) and continue; if you are any other runtime, do NOT stamp the host here — leave it for Step 0.1 to record and use the prose loop. Any non-`claude-code` host uses the prose loop.
-2. `evo config get default-orchestrator` — `workflow` selects the workflow driver; anything else (including unset) resolves to `prose`. An explicit user instruction this run still wins.
+1. `evo host show` — the workflow driver requires `claude-code`. If it prints `<not set>` (a pre-host workspace), determine your actual runtime from your own context (system prompt, env such as `CLAUDECODE=1`, self-identity): **only if you are genuinely Claude Code**, do the one-time host migration now (`evo host set claude-code`) and continue; if you are any other runtime, do NOT stamp the host here — leave it for Step 0.1 and use the prose loop.
+2. `evo config get default-orchestrator` — `prose` is an explicit **opt-out** (honor it: use the prose loop). `workflow` **or unset** resolves to the workflow driver on Claude Code. An explicit user instruction this run still wins.
 
-If host is `claude-code` **and** the value is `workflow` **and** the Workflow tool is available in this session, do NOT drive the loop turn-by-turn. Launch the bundled workflow once instead:
+**Use the workflow** when host is `claude-code`, the value is not explicitly `prose`, AND the **Workflow tool is actually present in your available tools this session** — this is the default path, not opt-in. The availability check is load-bearing: **older Claude Code builds do not ship the Workflow tool**, so verify it's really in your toolset; do not assume it exists from the host alone. When (and only when) you will actually launch it, FIRST persist the choice so the rest of evo agrees (`evo config get` reflects it, and the autonomous stop-nudge auto-suppresses under the workflow): run `evo config set default-orchestrator workflow`. Then launch it once — do NOT drive the loop turn-by-turn:
 
 - Call the **Workflow** tool with `scriptPath: ${CLAUDE_PLUGIN_ROOT}/skills/optimize/workflows/evo-optimize.js` and `args: {pluginRoot: "${CLAUDE_PLUGIN_ROOT}", subagents: <N>, budget: <N>, stall: <N>}`, using the round sizing you resolved above. **Pass all four keys explicitly — never omit one.** For `stall`, use the user's `/optimize stall=N` override if given, else the default 5. (The workflow's stop condition is the stall limit, so a dropped `stall` silently reverts it to 5.)
-- Report the returned `runId` and tell the user to watch progress with `/workflows`. The workflow runs the round loop itself (orient → mandatory scan + cross-history axis check → ideators on stall/periodic → briefs → fan-out + verify → collect → frontier-select → stall); you do **not** execute "The Loop" section below.
+- Report the returned `runId` and tell the user to watch progress with `/workflows`. The workflow runs the round loop itself (orient → mandatory scan + cross-history axis check → ideators on stall/periodic → briefs → fan-out + verify → collect → frontier-select → stall) plus the concurrent meta controller; you do **not** execute "The Loop" section below, and you do **not** need autonomous mode (the workflow self-drives; its stall limit is the stop).
 
-Otherwise — any non-`claude-code` host, `default-orchestrator` unset/`prose`, or the Workflow tool unavailable — ignore this and follow **The Loop** below as the canonical driver. The workflow is only an execution strategy over the same `evo` CLI; gates, frontier, dashboard, and recovery are identical either way.
+Use **The Loop** below only when the workflow can't drive: host is not `claude-code`, `default-orchestrator` is explicitly `prose`, or the Workflow tool is unavailable (e.g. an older Claude Code build). The workflow is only an execution strategy over the same `evo` CLI; gates, frontier, dashboard, and recovery are identical either way.
+
+**Reconcile config when you fall back to prose.** The stop-nudge that drives the prose loop is auto-suppressed whenever `default-orchestrator` is `workflow`. So if you fall back to the prose loop on Claude Code because the Workflow tool isn't available (older build) while `default-orchestrator` is still `workflow` from a prior run, you MUST set it back — `evo config set default-orchestrator prose` — and arm autonomous as usual. Otherwise the prose loop's stop-nudge stays suppressed and the run stalls after one round. Invariant to preserve: `default-orchestrator=workflow` in config iff the workflow is actually the driver this run.
 
 **Autonomous mode.** Off lets you stop naturally at a turn boundary — finish a round, report, and stop. On arms the stop-nudge: at every turn boundary you are re-prompted to keep driving the loop until the **stall** limit is hit or the user interrupts. Without it, the loop does NOT force-continue across turn boundaries. To stop an autonomous run, the user runs `evo autonomous off` or `evo exit-optimize-mode`.
 

package/skills/optimize/workflows/evo-optimize.js

@@ -5,7 +5,7 @@
  * opt-in, Claude-Code-only driver; the prose skill remains the canonical, host-agnostic
  * default. The workflow encodes the loop CONTROL: while/stall, mandatory scan + cross-history
  * axis check, research escalation (ideators on stall / every ~5 commits), brief + diversity,
- * fan-out + verify, collect + frontier-select. A concurrent ANALYST thread (Opus, self-paced,
+ * fan-out + verify, collect + frontier-select. A concurrent META thread (Opus, self-paced,
  * read-only) runs alongside the round loop via Promise.all — host + cross-history checks during
  * rounds, feeding hints into the next brief. All domain work goes through the `evo` CLI inside
  * agents — the script itself never touches the filesystem/shell.
@@ -27,7 +27,7 @@
 
 export const meta = {
   name: 'evo-optimize',
-  description: 'Deterministic evo tree-search loop over the evo CLI (orient, scan, ideate-on-stall, brief, fan-out, verify, collect).',
+  description: 'evo tree-search loop over the evo CLI (orient, scan, ideate-on-stall, brief, fan-out, verify, collect) with a concurrent meta controller that stops doomed experiments and restructures the workflow (logic flow + prompts) live.',
   phases: [
     { title: 'Orient',   detail: 'read state + select frontier parents to extend' },
     { title: 'Scan',     detail: 'mandatory parallel cross-cutting scan + structural aggregation (incl. cross-history axis check)' },
@@ -36,7 +36,8 @@ export const meta = {
     { title: 'Optimize', detail: 'parallel optimization subagents (evo new/run)' },
     { title: 'Verify',   detail: 'validity audit + benchmark-noise confirm' },
     { title: 'Collect',  detail: 'prune dead lineages, record cross-cutting notes' },
-    { title: 'Analyst',  detail: 'concurrent independent observer (Opus) — host + cross-history checks during rounds' },
+    { title: 'Meta',      detail: 'concurrent controller (Opus) — host/cross-history checks, STOP doomed runs, suggest directions, AND restructure the workflow live (logic flow + prompts)' },
+    { title: 'Meta-step', detail: 'extra agent step the meta injected into the round via an inject-step harness edit' },
   ],
 }
 
@@ -65,6 +66,8 @@ const STATE = {
     committedCount: { type: 'integer' },    // total committed experiments (drives the periodic ideator trigger)
     verifyRepeats: { type: 'integer' },     // benchmark noise profile (1 = deterministic, no confirm-loop)
     summary: { type: 'string' },            // short scratchpad summary for subagent context
+    taskSkills: { type: 'array', items: { type: 'string' } },     // category skills a builder should load (e.g. ["finetuning"]) — resolved from config/project, never hardcoded in the workflow
+    knownLearnings: { type: 'array', items: { type: 'string' } }, // durable lessons to apply up front (drained from annotations) so a fresh stateless lane doesn't rediscover them
   },
 }
 
@@ -178,13 +181,59 @@ const PREVERDICT = {
   },
 }
 
-// Analyst tick output: work-quality hints (fed into the next brief) + runtime/host alerts (surfaced).
-const ANALYST_FINDINGS = {
+// Meta tick output: work-quality hints (fed into the next brief) + runtime/host alerts (surfaced).
+const META_FINDINGS = {
   type: 'object',
-  required: ['briefHints', 'alerts'],
+  required: ['briefHints', 'alerts', 'stops'],
   properties: {
     briefHints: { type: 'array', items: { type: 'string' } },
     alerts: { type: 'array', items: { type: 'string' } },
+    // STOP recommendations for in-flight experiments that are clearly doomed.
+    // A stop is NOT a crash: each carries the diagnosis + a fix so the gated
+    // enforcer can abort, annotate (lesson outlives the worktree), and classify+
+    // preserve — and the fix feeds the next round (and, if general, a skill prior).
+    stops: {
+      type: 'array',
+      items: {
+        type: 'object',
+        required: ['expId', 'failureClass', 'reason', 'fixHint'],
+        properties: {
+          expId: { type: 'string' },
+          failureClass: { enum: ['build', 'eval', 'hypothesis'] },
+          reason: { type: 'string' },    // what's wrong + the concrete evidence
+          fixHint: { type: 'string' },   // what the NEXT experiment must change
+        },
+      },
+    },
+    // FREE-WILL harness edits: the meta agent restructures the WORKFLOW itself, live
+    // (its logic flow + prompts). Applied directly each tick — no allow-list, no caps —
+    // and audited (editLog + run log + returned state). It edits only the search harness;
+    // it never touches the benchmark / grader / verifier (those are not part of the
+    // workflow it controls, so they stay fixed and the score stays comparable).
+    harnessEdits: {
+      type: 'array',
+      items: {
+        type: 'object',
+        required: ['op', 'rationale'],
+        properties: {
+          op: { enum: ['set-knob', 'toggle-phase', 'set-prompt', 'inject-step'] },
+          rationale: { type: 'string' },   // why this edit, with evidence
+          // set-knob — retune the loop's control flow
+          knob: { enum: ['width', 'budget', 'stall', 'ideateEvery', 'ideateStall'] },
+          value: { type: 'number' },
+          // toggle-phase — turn a discretionary phase on/off
+          phaseName: { enum: ['scan', 'ideate'] },
+          enabled: { type: 'boolean' },
+          // set-prompt — edit a prompt the workflow uses (append a directive or replace it wholesale)
+          target: { enum: ['state', 'scan', 'aggregate', 'brief', 'implement', 'run', 'ideator', 'collect'] },
+          mode: { enum: ['append', 'replace'] },
+          text: { type: 'string' },
+          // inject-step — add an extra agent step at a fixed seam each round
+          at: { enum: ['before-scan', 'after-scan', 'before-brief', 'after-collect'] },
+          label: { type: 'string' },
+        },
+      },
+    },
   },
 }
 
@@ -206,17 +255,17 @@ const LIMIT = Number(A.stall) || 5
 const IDEATE_STALL = Math.max(1, Math.min(3, LIMIT - 1))
 const IDEATE_EVERY_COMMITS = 5   // periodic research cadence (matches prose step 6b)
 const PREVERIFY_MAX = 3          // pre-run verify <-> revise attempts before discarding a rigged edit
-// Concurrent analyst thread (runs alongside the round loop, NOT per-round).
-const ANALYST_ENABLED = true
-const ANALYST_MODEL = 'opus'    // the analyst always reasons with Opus (judgment-heavy)
-const ANALYST_INTERVAL_S = 300  // self-pace: observe ~every 5 min, during rounds
-const ANALYST_HOP_S = 15        // the wait is INTERRUPTIBLE in hops of this size: when the optimize loop
-                                // ends mid-wait it drops a sentinel the analyst polls, so the in-flight
-                                // tick exits within ~ANALYST_HOP_S instead of stalling the run for the
+// Concurrent meta thread (runs alongside the round loop, NOT per-round).
+const META_ENABLED = true
+const META_MODEL = 'opus'    // the meta always reasons with Opus (judgment-heavy)
+const META_INTERVAL_S = 300  // self-pace: observe ~every 5 min, during rounds
+const META_HOP_S = 15        // the wait is INTERRUPTIBLE in hops of this size: when the optimize loop
+                                // ends mid-wait it drops a sentinel the meta polls, so the in-flight
+                                // tick exits within ~META_HOP_S instead of stalling the run for the
                                 // full interval (the script can't interrupt an agent's `sleep` directly).
-const DONE_SENTINEL = '.evo/.wf_optimize_done'  // optimize -> analyst "loop is over" signal (a file,
+const DONE_SENTINEL = '.evo/.wf_optimize_done'  // optimize -> meta "loop is over" signal (a file,
                                 // since the in-memory `done` flag isn't visible to the agent's process)
-const ANALYST_MAX_FAILS = 3     // consecutive failed ticks before the advisory analyst self-disables
+const META_MAX_FAILS = 3     // consecutive failed ticks before the advisory meta self-disables
                                 // (guards against a hot-spin when ticks fail instantly, e.g. a bad schema)
 // Experiments per scan agent. Heuristic for the prose "small enough to read in one pass" rule —
 // the workflow can't recursively self-partition like the prose loop, so this is fixed up front.
@@ -281,11 +330,14 @@ function statePrompt() {
     'Read-only. Do NOT edit files or run experiments. Run these and parse their output:',
     '`evo scratchpad`, `evo frontier` (already prints a JSON envelope), `evo status`, `evo awaiting`.',
     'Also read `.evo/project.md` for the metric goal, direction, and the benchmark-determinism line.',
+    'Also run `evo config get task-skills` (if unset/blank, infer the task category from project.md) and read recent `evo annotations` for durable learnings already found this run.',
     'Return: bestScore + bestExpId; the theoretical ceiling (1.0 for max metric, 0.0 for min)',
     'and direction; the frontier nodes ALREADY ranked by the configured strategy',
     '(id, score, rank) — preserve evo\'s ordering, do not re-rank; the list of evaluated-but-',
     'undecided experiment ids; committedCount (number of committed experiments, from `evo status`);',
     'verifyRepeats (from project.md: 1 if deterministic, 3 if sampling-based / variance-expected);',
+    'taskSkills (category skills a builder should load, e.g. ["finetuning"] — from `evo config get task-skills`, else inferred from project.md);',
+    'knownLearnings (short durable lessons from annotations to apply up front: trainer-API quirks, device placement, eval-side config, etc.);',
     'and a 2-3 sentence scratchpad summary for subagent context.',
   ].join(' ')
 }
@@ -305,6 +357,7 @@ function scanBrief(batch) {
     '- Shared failure causes -- root-cause reasons recurring across 2+ experiments (the *why*, not the surface gate name).',
     '- Wall patterns -- approaches or gates multiple experiments consistently fail on.',
     '- Compound-failure standouts -- single experiments hitting multiple failure modes.',
+    '- Axis exhaustion vs fixable plumbing -- read each node\'s `failure_class` (build|eval|hypothesis) from outcome.json. A cluster of `hypothesis` failures across STRUCTURALLY DISTINCT approaches means the axis itself is unpromising (flag it so the next briefs diverge); `build`/`eval` failures are fixable plumbing (recipe/scoring) and must NOT be read as axis exhaustion.',
     '',
     'Evidence must be VERBATIM quotes from outcome.json fields, trace messages, or error text -- not paraphrases. If you cannot cite verbatim evidence for a finding, drop it. Evidence: short quotes (<200 chars), max 3 per finding.',
     'Return JSON only: {"findings":[{"description","experiment_ids":[],"evidence":[]}]}.',
@@ -326,11 +379,15 @@ function aggregatePrompt(ids) {
     '~the same score (a plateau), the bottleneck is not where those hypotheses aimed — emit kind:"axis-warning" whose',
     'label names the saturated axis AND suggests the orthogonal axis (harness, score definition, input data, or a',
     'different mechanism) the next briefs should pivot to. At most one axis-warning.',
+    'Also read DISCARDED nodes (`evo discards` + their outcome.json `failure_class`): a cluster of 3+ failure_class="hypothesis"',
+    'discards across STRUCTURALLY DISTINCT approaches is itself an axis-warning (the direction keeps not helping). IGNORE',
+    'failure_class="build"/"eval" discards for axis purposes — those are fixable plumbing (retry/resume or eval-retest), not',
+    'evidence the axis is wrong.',
     'Return JSON only.',
   ].join(' ')
 }
 
-function briefPrompt(state, findings, patterns, parents, ideated, analystHints) {
+function briefPrompt(state, findings, patterns, parents, ideated, metaHints) {
   return [
     'You are the evo orchestrator\'s brief writer.',
     'State summary:', state.summary || '',
@@ -341,10 +398,10 @@ function briefPrompt(state, findings, patterns, parents, ideated, analystHints)
       ? '\nFRESH IDEATOR PROPOSALS may be available — read `.evo/run_*/ideator/proposals.jsonl` and reconcile BEFORE writing: skip any whose technique was already tried (`evo discards --like "<keyword>"`); score the rest by expected_score_uplift x confidence (frontier_extrapolation > failure_analysis > literature, all else equal); let the top 1-2 become brief objectives, citing the proposal\'s hypothesis/technique. Proposals are advisory — if none beat the in-graph scan findings, ignore them.'
       : '',
     '\nIf the patterns include an "axis-warning", the current axis is saturated — target the ORTHOGONAL axis it names rather than iterating the plateaued one.',
-    (analystHints && analystHints.length)
-      ? '\nLIVE ANALYST SIGNALS (from the concurrent observer — fold relevant ones into objectives/boundaries, e.g. switch off a saturated axis, avoid a flagged dead direction): ' + JSON.stringify(analystHints)
+    (metaHints && metaHints.length)
+      ? '\nLIVE META SIGNALS (from the concurrent observer — fold relevant ones into objectives/boundaries, e.g. switch off a saturated axis, avoid a flagged dead direction): ' + JSON.stringify(metaHints)
       : '',
-    `\nWrite up to ${WIDTH} briefs (use the full round width of ${WIDTH} whenever you can find that many genuinely DISTINCT objectives — multiple briefs MAY branch from the SAME parent when fewer than ${WIDTH} frontier parents exist, as long as each attacks a different surface; do not pad with redundant briefs). One per subagent, each with four fields:`,
+    `\nWrite up to ${harness.width} briefs (use the full round width of ${harness.width} whenever you can find that many genuinely DISTINCT objectives — multiple briefs MAY branch from the SAME parent when fewer than ${harness.width} frontier parents exist, as long as each attacks a different surface; do not pad with redundant briefs). One per subagent, each with four fields:`,
     '1. objective -- one sentence naming WHERE in system behavior the gain hides, with evidence; NO file/function/edit names.',
     '2. parent -- which experiment id to branch from (choose from the selected parents).',
     '3. boundaries -- what NOT to try and why (discarded approaches, gates not to regress, what adjacent briefs this round do).',
@@ -356,9 +413,24 @@ function briefPrompt(state, findings, patterns, parents, ideated, analystHints)
 }
 
 // IMPLEMENT — allocate + edit, but do NOT run (a pre-run verifier audits the edit first).
+// Context capsule shared by every builder/runner lane: which category skills to load on demand,
+// and the durable learnings to apply up front — so a fresh stateless agent inherits the priors and
+// hard-won lessons a prose single-subagent would have had, instead of rediscovering them.
+function capsuleLines(state) {
+  const skills = (state && state.taskSkills) || []
+  const learnings = (state && state.knownLearnings) || []
+  const lines = []
+  lines.push(skills.length
+    ? `Task-category skills — load IN FULL via your host skill loader if the work needs them (they carry this category's priors, recipes, and pre-run checks): ${skills.join(', ')}.`
+    : "Identify the task category from `.evo/project.md` and load the matching evo skill (e.g. evo:finetuning for a training move) IN FULL before you build — it carries this category's priors and pre-run checks.")
+  if (learnings.length) lines.push(`KNOWN LEARNINGS to apply before acting (already found this run — do not rediscover): ${JSON.stringify(learnings)}.`)
+  return lines
+}
+
 function implementPrompt(brief, parent, state) {
   return [
     `First, load and follow the evo subagent skill: Read ${pr}/skills/subagent/SKILL.md IN FULL and follow it as your operating protocol — do not skip it even if the brief looks simple.`,
+    ...capsuleLines(state),
     `Allocate your experiment via \`evo new --parent ${parent}\`, then edit inside the returned worktree to implement the brief.`,
     'IMPORTANT: do NOT run `evo run` yet — a pre-run verifier audits your change first. Stop once the edit is complete.',
     'Do NOT edit benchmark, gate, or framework code; do NOT weaken/bypass any gate.',
@@ -397,12 +469,14 @@ function revisePrompt(expId, worktree, findings) {
 }
 
 // RUN — evaluate + commit the (pre-verified) experiment.
-function runPrompt(expId) {
+function runPrompt(expId, state) {
   return [
     `First, load the evo subagent skill: Read ${pr}/skills/subagent/SKILL.md IN FULL and follow its run protocol (it covers \`evo run ${expId} --check\` for non-committing wiring validation that does not consume the attempt budget).`,
-    `CRITICAL ordering: if this experiment produces its artifact through a build or training step (e.g. a finetune that writes final_model/), run that step to COMPLETION and confirm the artifact exists BEFORE the real run. Never call \`evo run\` while training is still in flight or before final_model/ exists — evaluating a not-yet-produced model is the "final_model not found" failure and it wastes the attempt. If the experiment trains, the parent checkpoint is in EVO_PARENT_POLICY (warm-start from it; do not retrain from base).`,
+    ...capsuleLines(state),
+    `CRITICAL ordering: if this experiment produces an output artifact through a build or training step (whatever your recipe declares — a checkpoint dir, adapter, merged model, index, etc.), run that step to COMPLETION and confirm the artifact exists BEFORE the real run. Never call \`evo run\` while that step is still in flight or before its output exists — evaluating a not-yet-produced artifact wastes the attempt. If the experiment warm-starts, the parent's reusable artifact is in EVO_PARENT_POLICY (start from it; do not redo from scratch).`,
     `Then run \`evo run ${expId}\` to evaluate and (if it improves and passes gates) commit it.`,
     'If it exits GATE_FAILED, do not fight the gate — report status=evaluated.',
+    'If `evo run` is terminated externally mid-flight (the concurrent meta can STOP a doomed experiment — it aborts the run and discards this node with a diagnosis), do NOT retry: report status:none and stop. The diagnosis is already recorded as an annotation and will steer the next brief.',
     `Return: expIds:["${expId}"]; status (committed|evaluated|failed|none); committedImprover = true ONLY if evo printed COMMITTED;`,
     'bestExpId + bestScore (required when committedImprover is true); any gates added; learnings.',
   ].join(' ')
@@ -450,16 +524,16 @@ function collectPrompt(results, round) {
   ].join(' ')
 }
 
-// One analyst tick (a FRESH Opus agent each call — no memory across ticks, so `reported` carries
+// One meta tick (a FRESH Opus agent each call — no memory across ticks, so `reported` carries
 // the dedup state in the loop's closure). Read-only: observes host + cross-history signals DURING
 // rounds, returns work-quality briefHints (folded into the next brief) + runtime alerts (surfaced).
-function analystPrompt(ctx, intervalS, reported) {
+function metaPrompt(ctx, intervalS, reported) {
   return [
-    'You are the evo ANALYST — an independent observer running CONCURRENTLY with the optimize loop.',
-    'Read-only: do NOT edit code, run experiments, or mutate evo state.',
+    'You are the evo META agent — an independent controller running CONCURRENTLY with the optimize loop.',
+    'You do NOT edit experiment code, run experiments, or touch the benchmark/grader/verifier. But you DO shape the optimize WORKFLOW: stop doomed experiments, suggest next directions (briefHints), AND restructure the running workflow itself — its logic flow + prompts — via harnessEdits (your distinctive power, detailed below).',
     `FIRST pace yourself with an INTERRUPTIBLE wait, so you stop promptly when the optimize loop ends. Run this single Bash command with a tool timeout of at least ${(intervalS + 30) * 1000} ms:`,
-    `  \`if [ -f ${DONE_SENTINEL} ]; then echo OPTIMIZE_DONE; else for i in $(seq 1 ${Math.ceil(intervalS / ANALYST_HOP_S)}); do sleep ${ANALYST_HOP_S}; [ -f ${DONE_SENTINEL} ] && { echo OPTIMIZE_DONE; break; }; done; fi\``,
-    `If that prints OPTIMIZE_DONE, the optimize loop has finished — return {"briefHints":[],"alerts":[]} immediately WITHOUT gathering any signals. Otherwise the full interval elapsed: now gather signals and report.`,
+    `  \`if [ -f ${DONE_SENTINEL} ]; then echo OPTIMIZE_DONE; else for i in $(seq 1 ${Math.ceil(intervalS / META_HOP_S)}); do sleep ${META_HOP_S}; [ -f ${DONE_SENTINEL} ] && { echo OPTIMIZE_DONE; break; }; done; fi\``,
+    `If that prints OPTIMIZE_DONE, the optimize loop has finished — return {"briefHints":[],"alerts":[],"stops":[],"harnessEdits":[]} immediately WITHOUT gathering any signals. Otherwise the full interval elapsed: now gather signals and report.`,
     `Current loop state: round=${ctx.round}, stall=${ctx.stall}/${LIMIT}, best=${ctx.bestScore}.`,
     `Already reported (do NOT repeat — only emit findings NEW since these): ${JSON.stringify(reported || [])}.`,
     'Walk these checks (skip any whose inputs are unavailable; cite evidence; nothing speculative):',
@@ -468,7 +542,13 @@ function analystPrompt(ctx, intervalS, reported) {
     '- Stuck experiment / time-budget overrun: from `evo status`/`evo show`, an experiment active far longer than its peers, or a round overrunning the others. ALERT.',
     '- Stuck axis: from `evo tree`, 3+ structurally-distinct committed hypotheses plateaued at ~the same score → name the saturated axis + one orthogonal axis. BRIEF HINT.',
     '- Dead direction / ignored mechanism: annotations repeatedly naming a mechanism the recent work ignores, or a direction that keeps regressing. BRIEF HINT.',
-    'Return {briefHints:[...], alerts:[...]}. briefHints feed the NEXT round\'s briefs (work-quality redirections); alerts surface to the user (runtime/host issues). Empty arrays are fine — most ticks should be quiet.',
+    '- Heading toward failure (STOP): an in-flight experiment that is CLEARLY doomed or wasting the budget — a divergent / NaN / flatlined progress metric; projected completion beyond the remaining time budget; or a known-fatal signature (e.g. output the scorer cannot parse; a silent resource mis-placement that tanks throughput with no error; a corrupt input/format that invalidates the result). HIGH PRECISION ONLY: default to NOT stopping — recommend a STOP only with concrete evidence that finishing is wasted, and only for an experiment still `active`. Emit a stop with: expId; failureClass (build = the build/produce step is broken; eval = artifact is fine but scoring/serving is wrong; hypothesis = it runs but won\'t help); reason (the diagnosis + the evidence you saw); fixHint (what the NEXT experiment must change).',
+    'For STOPs you stay READ-ONLY: do NOT run `evo abort` / `evo discard` yourself. A gated enforcer acts on each stop — it aborts the run + its subprocess tree, annotates your diagnosis (so it outlives the worktree and feeds the next round), and discards with the failureClass so the partial artifact is preserved. A STOP is a diagnosed, recoverable stop, never a silent kill.',
+    '',
+    'HARNESS CONTROL (your distinctive power): you may restructure the optimize workflow itself, live, when you judge it will help — edits apply directly (free will) and take effect next round. Current harness state: ' + JSON.stringify(harnessSummary()) + '.',
+    'harnessEdits ops: (1) set-knob {knob: width|budget|stall|ideateEvery|ideateStall, value} — retune the loop (widen the round, deepen branches, change the stall limit or ideation cadence). (2) toggle-phase {phaseName: scan|ideate, enabled} — turn a phase off/on (e.g. skip scan when traces are uninformative; force ideation early). (3) set-prompt {target: state|scan|aggregate|brief|implement|run|ideator|collect, mode: append|replace, text} — edit the prompt that step uses (append a directive, or replace it wholesale). (4) inject-step {at: before-scan|after-scan|before-brief|after-collect, text, label} — add an extra agent step at that seam each round. Every edit needs a rationale citing the evidence.',
+    'HARD CONSTRAINT: edit ONLY the search harness above. NEVER propose edits to the benchmark, grader, scorer, held-out test, or any gate — those define how results are judged; if you change them the score stops meaning anything. Emit harnessEdits ONLY with concrete evidence the current workflow SHAPE is the bottleneck; most ticks should emit none.',
+    'Return {briefHints:[...], alerts:[...], stops:[...], harnessEdits:[...]}. briefHints feed the NEXT round\'s briefs; alerts surface to the user; each stop triggers the gated enforcer; each harnessEdit is applied directly to the running workflow. All-empty is fine — most ticks should be quiet.',
   ].join('\n')
 }
 
@@ -476,11 +556,21 @@ function analystPrompt(ctx, intervalS, reported) {
 // iteration budget (deepening the branch each time a committed improver lands). The independent
 // evo:verifier gates EACH run for design-time cheating BEFORE the experiment is evaluated; its
 // findings are fed back to a revise agent on the same experiment until it passes or is discarded.
+//
+// Lane decomposition (decompose only at CONTEXT SEAMS): build+eval are a SINGLE agent — `run`
+// produces the artifact and evaluates it end-to-end (one coherent context, no handoff mid-build).
+// The only split is `implement` (write the edit) vs `run`, separated by the read-only evo:verifier
+// seam — a genuinely different concern (adversarial diff audit, different agentType/model) that has
+// to interpose between the edit and the expensive run. The two share state by REFERENCE (the
+// worktree on disk), not by passing a context window, and BOTH receive the capsule (category skills
+// + known learnings via capsuleLines), so neither reverts to base-model defaults. Merging implement
+// into run would erase the verifier gate for no real gain, since the code already lives in the
+// worktree the run agent reads.
 async function runBrief(brief, state) {
   let parent = brief.parent
   let best = null
-  for (let depth = 0; depth < ITER; depth++) {
-    const impl = await agent(implementPrompt(brief, parent, state), {
+  for (let depth = 0; depth < harness.budget; depth++) {
+    const impl = await agent(withHarnessPrompt('implement', implementPrompt(brief, parent, state)), {
       schema: IMPL_RESULT, model: brief.hard ? 'opus' : 'sonnet', phase: 'Optimize', label: `impl:${parent}#${depth}`,
     })
     if (!impl || !impl.expId) break
@@ -504,7 +594,7 @@ async function runBrief(brief, state) {
     }
 
     // run -> evaluate + commit
-    const r = await agent(runPrompt(impl.expId), { schema: SUBAGENT_RESULT, phase: 'Optimize', label: `run:${impl.expId}` })
+    const r = await agent(withHarnessPrompt('run', runPrompt(impl.expId, state)), { schema: SUBAGENT_RESULT, phase: 'Optimize', label: `run:${impl.expId}` })
     if (!r) break
 
     // post-run validity audit (evo:verifier, post-phase) on committed improvers
@@ -539,51 +629,131 @@ let stall = 0
 let round = 0
 let lastIdeatedCommit = 0      // committedCount at the last ideator dispatch (periodic cadence)
 let ideatedThisStall = false   // fire ideators once per stall episode, not every stalled round
-let lastBestScore = null       // latest best score, surfaced to the concurrent analyst thread
-let done = false               // set when the optimize loop ends -> stops the analyst thread
-const analystSignals = []      // briefHints the analyst pushes; drained into the next round's brief
+let lastBestScore = null       // latest best score, surfaced to the concurrent meta thread
+let done = false               // set when the optimize loop ends -> stops the meta thread
+const metaSignals = []      // briefHints the meta pushes; drained into the next round's brief
 
-log(`evo-optimize start: subagents=${WIDTH} budget=${ITER} stall=${LIMIT} analyst=${ANALYST_ENABLED ? ANALYST_MODEL : 'off'} | argsType=${typeof args} A.subagents=${A.subagents} A.budget=${A.budget} A.stall=${A.stall}`)
+// ---------------------------------------------------------------------------
+// Mutable HARNESS (the round-plan + prompts the meta agent edits live, free-will).
+// Initialized to the resolved defaults, so a run where the meta emits no edits behaves
+// byte-identically to before. The optimize loop READS this object each round; the meta
+// thread WRITES it via applyHarnessEdit. Single-threaded event loop => edits applied in a
+// meta tick land between optimize-loop awaits and take effect at the next read (next round).
+// Every edit is audited: harness.editLog + a run-log line + the workflow's return value.
+// Scope boundary: this controls the SEARCH harness only — never the grader/verifier.
+// ---------------------------------------------------------------------------
+const harness = {
+  width: WIDTH,
+  budget: ITER,
+  stall: LIMIT,
+  ideateEvery: IDEATE_EVERY_COMMITS,
+  ideateStall: IDEATE_STALL,
+  phases: { scan: true, ideate: true },
+  prompts: {},          // target -> { mode: 'append'|'replace', text }
+  injectedSteps: [],    // { at, prompt, label }
+  editLog: [],          // audit trail: { round, op, ...spec, rationale }
+}
+
+// Apply a meta prompt override (append a directive, or replace wholesale) to a base prompt.
+function withHarnessPrompt(target, baseText) {
+  const o = harness.prompts[target]
+  if (!o || !o.text) return baseText
+  return o.mode === 'replace'
+    ? o.text
+    : baseText + '\n\n[META-ADDED DIRECTIVE — injected live by the meta agent]: ' + o.text
+}
 
-// The optimize round loop (runs concurrently with analystLoop via Promise.all).
+// Run any meta-injected extra steps registered at a given seam (insert-step op).
+async function runInjected(at, ctxLabel) {
+  for (const s of harness.injectedSteps.filter((x) => x.at === at)) {
+    try {
+      await agent(s.prompt, { phase: 'Meta-step', label: s.label || `injected:${at}:${ctxLabel}` })
+    } catch (e) {
+      log(`META injected step (${at}) errored (ignored): ${(e && e.message) || e}`)
+    }
+  }
+}
+
+// Apply ONE harness edit with free will (no validation gate, no caps) — then audit it.
+function applyHarnessEdit(e, atRound) {
+  if (!e || !e.op) return
+  const rec = { round: atRound, op: e.op, rationale: e.rationale || '' }
+  if (e.op === 'set-knob' && e.knob && typeof e.value === 'number') {
+    harness[e.knob] = e.value; rec.knob = e.knob; rec.value = e.value
+  } else if (e.op === 'toggle-phase' && e.phaseName) {
+    harness.phases[e.phaseName] = e.enabled !== false; rec.phaseName = e.phaseName; rec.enabled = harness.phases[e.phaseName]
+  } else if (e.op === 'set-prompt' && e.target && e.text) {
+    harness.prompts[e.target] = { mode: e.mode === 'replace' ? 'replace' : 'append', text: e.text }
+    rec.target = e.target; rec.mode = harness.prompts[e.target].mode
+  } else if (e.op === 'inject-step' && e.at && e.text) {
+    harness.injectedSteps.push({ at: e.at, prompt: e.text, label: e.label || `meta:${e.at}` }); rec.at = e.at; rec.label = e.label || `meta:${e.at}`
+  } else {
+    log(`META harness edit IGNORED (incomplete spec for op=${e.op}): ${JSON.stringify(e)}`); return
+  }
+  harness.editLog.push(rec)
+  log(`META HARNESS EDIT [r${atRound}] ${JSON.stringify(rec)}`)
+}
+
+function harnessSummary() {
+  return {
+    width: harness.width, budget: harness.budget, stall: harness.stall,
+    ideateEvery: harness.ideateEvery, ideateStall: harness.ideateStall,
+    phases: harness.phases,
+    promptsOverridden: Object.entries(harness.prompts).map(([k, v]) => `${k}:${v.mode}`),
+    injectedSteps: harness.injectedSteps.map((s) => `${s.at}:${s.label}`),
+    edits: harness.editLog.length,
+  }
+}
+
+log(`evo-optimize start: subagents=${WIDTH} budget=${ITER} stall=${LIMIT} meta=${META_ENABLED ? META_MODEL : 'off'} | argsType=${typeof args} A.subagents=${A.subagents} A.budget=${A.budget} A.stall=${A.stall}`)
+
+// The optimize round loop (runs concurrently with metaLoop via Promise.all).
 async function optimizeLoop() {
-  while (stall < LIMIT) {
+  while (stall < harness.stall) {
     round += 1
 
     phase('Orient')
-    const state = await agent(statePrompt(), { schema: STATE, agentType: 'Explore', model: 'sonnet', phase: 'Orient', label: `state:r${round}` })
+    await runInjected('before-scan', `r${round}`)   // meta seam (pre-orient/scan)
+    const state = await agent(withHarnessPrompt('state', statePrompt()), { schema: STATE, agentType: 'Explore', model: 'sonnet', phase: 'Orient', label: `state:r${round}` })
     lastBestScore = state.bestScore
     if (state.bestScore === state.ceiling) { log(`ceiling reached (best=${state.bestScore}) — stopping`); break }
-    const parents = (state.frontier || []).slice(0, WIDTH)
+    const parents = (state.frontier || []).slice(0, harness.width)
     if (parents.length === 0) { log('no explorable frontier nodes — stopping'); break }
 
-    // N1 + N1.5 — mandatory parallel scan + structural aggregation (barrier). Scan runs EVERY round
-    // (hard rule); when there are no evaluated-undecided nodes yet (round 1) it falls back to the
-    // committed frontier so at least one scan agent still runs before briefs.
-    phase('Scan')
-    const evaluatedIds = state.evaluatedIds || []
-    const frontierIds = (state.frontier || []).map((f) => f.id).filter(Boolean)
-    const scanTargets = evaluatedIds.length ? evaluatedIds : frontierIds
-    const batches = chunk(scanTargets, SCAN_BATCH)
-    const scanThunks = batches.map((b) => () => agent(scanBrief(b), { schema: FINDINGS, agentType: 'Explore', phase: 'Scan', label: `scan ${b.length}: ${batchLabel(b)}` }))
-    const aggregateIds = [...new Set([...evaluatedIds, ...frontierIds])]
-    const aggThunk = aggregateIds.length
-      ? [() => agent(aggregatePrompt(aggregateIds), { schema: PATTERNS, agentType: 'Explore', phase: 'Scan', label: 'aggregate' })]
-      : []
-    const scanResults = (await parallel([...scanThunks, ...aggThunk])).filter(Boolean)
-    const findings = scanResults.flatMap((r) => (r && r.findings) ? r.findings : [])
-    const patterns = scanResults.flatMap((r) => (r && r.patterns) ? r.patterns : [])
-
-    // N1.7 — research escalation (6b): on stall (before the hard limit) or every ~5 commits, fire the
-    // three ideators in parallel. parallel() blocks until all return (proposals land before briefing).
+    // N1 + N1.5 — parallel scan + structural aggregation (barrier). Scan normally runs EVERY round
+    // (hard rule), but the meta agent MAY disable it via a toggle-phase edit (free will) — when off,
+    // the round briefs from prior signals only. Round 1 falls back to the committed frontier.
+    let findings = []
+    let patterns = []
+    if (harness.phases.scan) {
+      phase('Scan')
+      const evaluatedIds = state.evaluatedIds || []
+      const frontierIds = (state.frontier || []).map((f) => f.id).filter(Boolean)
+      const scanTargets = evaluatedIds.length ? evaluatedIds : frontierIds
+      const batches = chunk(scanTargets, SCAN_BATCH)
+      const scanThunks = batches.map((b) => () => agent(withHarnessPrompt('scan', scanBrief(b)), { schema: FINDINGS, agentType: 'Explore', phase: 'Scan', label: `scan ${b.length}: ${batchLabel(b)}` }))
+      const aggregateIds = [...new Set([...evaluatedIds, ...frontierIds])]
+      const aggThunk = aggregateIds.length
+        ? [() => agent(withHarnessPrompt('aggregate', aggregatePrompt(aggregateIds)), { schema: PATTERNS, agentType: 'Explore', phase: 'Scan', label: 'aggregate' })]
+        : []
+      const scanResults = (await parallel([...scanThunks, ...aggThunk])).filter(Boolean)
+      findings = scanResults.flatMap((r) => (r && r.findings) ? r.findings : [])
+      patterns = scanResults.flatMap((r) => (r && r.patterns) ? r.patterns : [])
+    } else {
+      log('scan phase disabled by meta — briefing from prior signals only')
+    }
+    await runInjected('after-scan', `r${round}`)
+
+    // N1.7 — research escalation (6b): on stall (before the hard limit) or every ~N commits, fire the
+    // three ideators in parallel. Gated by harness.phases.ideate + the harness cadence knobs (meta-tunable).
     const commits = Number(state.committedCount) || 0
-    const stalledTrigger = stall >= IDEATE_STALL && !ideatedThisStall
-    const periodicTrigger = commits - lastIdeatedCommit >= IDEATE_EVERY_COMMITS
+    const stalledTrigger = stall >= harness.ideateStall && !ideatedThisStall
+    const periodicTrigger = commits - lastIdeatedCommit >= harness.ideateEvery
     let ideated = false
-    if (stalledTrigger || periodicTrigger) {
+    if (harness.phases.ideate && (stalledTrigger || periodicTrigger)) {
       phase('Ideate')
       await parallel(['frontier_extrapolation', 'failure_analysis', 'literature'].map((b) => () =>
-        agent(ideatorPrompt(b), { agentType: 'evo:ideator', phase: 'Ideate', label: `ideate:${b}` })))
+        agent(withHarnessPrompt('ideator', ideatorPrompt(b)), { agentType: 'evo:ideator', phase: 'Ideate', label: `ideate:${b}` })))
       lastIdeatedCommit = commits
       if (stalledTrigger) ideatedThisStall = true
       ideated = true
@@ -591,10 +761,11 @@ async function optimizeLoop() {
     }
 
     // N2 — brief writer: reconciles ideator proposals (6c), acts on axis-warning, and folds in any
-    // live analyst hints accumulated since the last round; JS diversity dedupe afterwards.
+    // live meta hints accumulated since the last round; JS diversity dedupe afterwards.
+    await runInjected('before-brief', `r${round}`)
     phase('Brief')
-    const analystHints = analystSignals.splice(0)
-    const briefOut = await agent(briefPrompt(state, findings, patterns, parents, ideated, analystHints), { schema: BRIEFS, phase: 'Brief', label: `briefs:r${round}` })
+    const metaHints = metaSignals.splice(0)
+    const briefOut = await agent(withHarnessPrompt('brief', briefPrompt(state, findings, patterns, parents, ideated, metaHints)), { schema: BRIEFS, phase: 'Brief', label: `briefs:r${round}` })
     const briefs = dedupeBriefs((briefOut && briefOut.briefs) || [])
     if (briefs.length === 0) { log('no briefs produced — stopping'); break }
 
@@ -603,7 +774,8 @@ async function optimizeLoop() {
 
     // N5 — collect: prune dead lineages, record notes.
     phase('Collect')
-    await agent(collectPrompt(results, round), { phase: 'Collect', label: `collect:r${round}` })
+    await agent(withHarnessPrompt('collect', collectPrompt(results, round)), { phase: 'Collect', label: `collect:r${round}` })
+    await runInjected('after-collect', `r${round}`)
 
     // Loop control: stall resets only when this round produced a VERIFIED committed score that beats
     // the PRIOR BEST in the metric direction (a beat-its-own-parent commit is branch progress, not a
@@ -619,56 +791,95 @@ async function optimizeLoop() {
     log(`round ${round}: improved=${improved} roundBest=${roundBest} prevBest=${state.bestScore} stall=${stall}/${LIMIT} spent=${budget.spent()}`)
   }
   done = true
-  // Wake any in-flight analyst tick now (its `sleep` can't see the in-memory `done`): the sentinel
-  // makes the tick's interruptible wait exit within ~ANALYST_HOP_S instead of running the full interval.
-  if (ANALYST_ENABLED) await agent(`mkdir -p .evo && : > ${DONE_SENTINEL} && echo signalled`, { phase: 'Collect', label: 'signal:optimize-done' })
+  // Wake any in-flight meta tick now (its `sleep` can't see the in-memory `done`): the sentinel
+  // makes the tick's interruptible wait exit within ~META_HOP_S instead of running the full interval.
+  if (META_ENABLED) await agent(`mkdir -p .evo && : > ${DONE_SENTINEL} && echo signalled`, { phase: 'Collect', label: 'signal:optimize-done' })
   log(`optimize loop finished after ${round} round(s), final stall=${stall}/${LIMIT}`)
   return { rounds: round, finalStall: stall }
 }
 
-// Concurrent analyst thread (P1-sliver/P2-P5/P7): an independent, self-paced Opus observer that runs
+// Concurrent meta thread (P1-sliver/P2-P5/P7): an independent, self-paced Opus observer that runs
 // DURING rounds (not per-round). Each tick is a FRESH agent (no cross-tick memory), so `reported`
-// holds the dedup state in this closure. Work-quality findings -> analystSignals (next brief);
+// holds the dedup state in this closure. Work-quality findings -> metaSignals (next brief);
 // runtime/host alerts -> the run log. Stops when optimizeLoop sets `done`.
-async function analystLoop() {
-  if (!ANALYST_ENABLED) return
+// Gated ENFORCER for an meta STOP: detect (meta) and act (this agent) stay separate. Verifies
+// the experiment is still active, then aborts its run (driver + subprocess tree), annotates the
+// diagnosis (survives the worktree + feeds the next round via knownLearnings), and discards with the
+// failure class so the partial artifact is preserved + classified. A STOP is a diagnosed, recoverable
+// stop — never a silent kill.
+function enforceStopPrompt(s) {
+  return [
+    `A concurrent meta flagged experiment ${s.expId} as heading toward failure and recommends STOPPING it. You are the gated ENFORCER — read-only except for the three evo commands below; do NOT edit code or run training.`,
+    `First VERIFY: run \`evo show ${s.expId}\`. Only proceed if its status is still \`active\`. If it is committed / evaluated / discarded / not found, do NOTHING and report skipped (it already resolved).`,
+    `If still active, run in order:`,
+    `  1. \`evo abort ${s.expId}\` — stop the evo run driver and its subprocess tree.`,
+    `  2. annotate the diagnosis so it outlives the worktree and feeds the next round: \`evo annotate ${s.expId} "STOPPED (${s.failureClass}): ${s.reason} | FIX: ${s.fixHint}"\` (quote carefully).`,
+    `  3. classify + preserve: \`evo discard ${s.expId} --force --failure-class ${s.failureClass} --reason "meta stop: ${s.reason}"\` (--force because abort already killed the driver; declared artifacts are preserved).`,
+    `Report what you did (aborted / annotated / discarded) or that you skipped because it was no longer active. This is a diagnosed, recoverable stop, not a crash.`,
+  ].join('\n')
+}
+
+async function metaLoop() {
+  if (!META_ENABLED) return
   const reported = []   // closure memory across the stateless ticks (caps re-alerting)
   let t = 0
   let fails = 0   // consecutive tick failures; trips the self-disable below
   while (!done) {
     t += 1
-    // The analyst is purely advisory and read-only: a failed tick must NEVER reject this loop and
+    // The meta is purely advisory and read-only: a failed tick must NEVER reject this loop and
     // abort the optimizer. Swallow any tick error, log it, and continue (or exit if `done` flipped).
     let tick = null
     try {
-      tick = await agent(analystPrompt({ round, stall, bestScore: lastBestScore }, ANALYST_INTERVAL_S, reported.slice(-30)), {
-        agentType: 'Explore', model: ANALYST_MODEL, schema: ANALYST_FINDINGS, phase: 'Analyst', label: `analyst#${t}`,
+      tick = await agent(metaPrompt({ round, stall, bestScore: lastBestScore }, META_INTERVAL_S, reported.slice(-30)), {
+        agentType: 'Explore', model: META_MODEL, schema: META_FINDINGS, phase: 'Meta', label: `meta#${t}`,
       })
     } catch (e) {
-      log(`ANALYST tick #${t} errored (ignored, optimize unaffected): ${(e && e.message) || e}`)
+      log(`META tick #${t} errored (ignored, optimize unaffected): ${(e && e.message) || e}`)
     }
     if (tick) {
       fails = 0   // a real tick resets the failure streak
-      for (const h of (tick.briefHints || [])) { analystSignals.push(h); reported.push(h) }
-      for (const a of (tick.alerts || [])) { log(`ANALYST ALERT: ${a}`); reported.push(a) }
-    } else if (++fails >= ANALYST_MAX_FAILS) {
+      for (const h of (tick.briefHints || [])) { metaSignals.push(h); reported.push(h) }
+      for (const a of (tick.alerts || [])) { log(`META ALERT: ${a}`); reported.push(a) }
+      // HARNESS EDITS (new ability): the meta restructures the workflow itself live — applied
+      // directly with free will (no gate, no caps), audited via harness.editLog + the run log.
+      // Takes effect at the next round (the optimize loop reads `harness` at each round start).
+      for (const e of (tick.harnessEdits || [])) applyHarnessEdit(e, round)
+      // STOP recommendations: hand each to a gated enforcer (detect/act separation). The fix also
+      // feeds the next round's brief so the loop corrects rather than just abandons.
+      for (const s of (tick.stops || [])) {
+        if (!s || !s.expId) continue
+        const stopKey = `stop:${s.expId}`
+        if (reported.includes(stopKey)) continue   // never re-enforce the same experiment
+        reported.push(stopKey)
+        log(`META STOP: ${s.expId} [${s.failureClass}] ${s.reason}`)
+        metaSignals.push(`Experiment ${s.expId} was stopped (${s.failureClass}): ${s.reason} — next: ${s.fixHint}`)
+        try {
+          await agent(enforceStopPrompt(s), { phase: 'Meta', label: `enforce-stop:${s.expId}` })
+        } catch (e) {
+          log(`META enforce-stop ${s.expId} errored (ignored): ${(e && e.message) || e}`)
+        }
+      }
+    } else if (++fails >= META_MAX_FAILS) {
       // The pacing wait lives INSIDE the agent, so a tick that fails before sleeping (e.g. a schema
       // reject) leaves nothing to pace the retry — left unchecked the loop hot-spins agents. The
-      // analyst is optional, so after a short streak of failures, disable it for the rest of the run.
-      log(`ANALYST disabled after ${fails} consecutive failed ticks — optimize continues without it.`)
+      // meta is optional, so after a short streak of failures, disable it for the rest of the run.
+      log(`META disabled after ${fails} consecutive failed ticks — optimize continues without it.`)
       return
     }
   }
 }
 
-// Clear any stale sentinel from a prior run BEFORE the threads start, else the analyst's first wait
+// Clear any stale sentinel from a prior run BEFORE the threads start, else the meta's first wait
 // would see it and exit instantly. The script can't touch the filesystem itself, so an agent does it.
-if (ANALYST_ENABLED) await agent(`rm -f ${DONE_SENTINEL}; echo cleared`, { phase: 'Orient', label: 'init:clear-sentinel' })
+if (META_ENABLED) await agent(`rm -f ${DONE_SENTINEL}; echo cleared`, { phase: 'Orient', label: 'init:clear-sentinel' })
 
-// optimizeLoop is the run's result; analystLoop is advisory. The `.catch` is the definitive guard that
+// optimizeLoop is the run's result; metaLoop is advisory. The `.catch` is the definitive guard that
 // the observer thread can NEVER reject the combined promise and fail an otherwise-good optimize run.
 const [optimizeResult] = await Promise.all([
   optimizeLoop(),
-  analystLoop().catch((e) => log(`ANALYST thread exited abnormally (ignored): ${(e && e.message) || e}`)),
+  metaLoop().catch((e) => log(`META thread exited abnormally (ignored): ${(e && e.message) || e}`)),
 ])
-return optimizeResult
+// Surface the harness audit alongside the optimize result: final round-plan + every live edit the
+// meta agent applied (knobs, phase toggles, prompt overrides, injected steps), so the run is fully
+// reconstructable from the return value + the run log.
+return { ...optimizeResult, harness: harnessSummary(), harnessEditLog: harness.editLog }

package/skills/report/SKILL.md

@@ -1,7 +1,7 @@
 ---
 name: report
 description: Print the dashboard's dot chart (score over experiment order, status colors, best-path stair) inline in the terminal for every run in the workspace. Use when the user invokes /evo:report, asks for a quick score chart without opening the dashboard, or wants the scatter plot in chat output.
-evo_version: 0.5.0-alpha.11
+evo_version: 0.5.0-alpha.13
 ---
 
 # Report

package/skills/subagent/SKILL.md

@@ -1,7 +1,7 @@
 ---
 name: subagent
 description: Protocol that evo optimization subagents follow when dispatched from /optimize. Auto-loaded by spawned subagents via their host's skill loader. The orchestrator may also invoke this skill to understand the brief shape its dispatched subagents expect + what they're required to emit -- useful when writing briefs or debugging a subagent's behavior.
-evo_version: 0.5.0-alpha.11
+evo_version: 0.5.0-alpha.13
 ---
 
 # Evo Subagent Protocol
@@ -124,8 +124,10 @@ evo gate add <id> --name <name> --command "<command>"  # add a gate
 
 # Write paths used during iteration
 evo new --parent <id> -m "<hypothesis>"   # allocate sibling experiment
+evo new --parent <id> -m "<h>" --from-artifact <exp[:label]>  # seed from a preserved artifact (EVO_SEED_ARTIFACT)
 evo run <id> [--check]                    # run (or --check to validate without consuming attempts)
-evo discard <id> --reason "<text>"        # reject + park (keeps anchor ref)
+evo abort <id>                            # stop a mid-run experiment (driver + its subprocess tree)
+evo discard <id> --reason "<text>" [--failure-class build|eval|hypothesis]  # reject + park (keeps anchor ref)
 evo restore <id>                          # un-discard or un-prune
 evo annotate <id> [<task_id>] "<text>"    # per-attempt analysis
 evo set <id> --note "<text>" [--tag <t>]  # per-node note from orchestrator
@@ -138,6 +140,7 @@ see `references/cli-quick-reference.md` "Reading workspace state".
 ## First Steps
 
 1. Read `.evo/project.md` to understand the target, what can be changed, and how to interpret results.
+1a. **Load this task's category skill(s).** Run `evo config get task-skills`; for each name returned (e.g. `finetuning`), load that evo skill IN FULL via your host's skill loader before you form an edit — it carries this category's method priors, recipes, and pre-run checks. If it returns blank, infer the category from `.evo/project.md` and load the matching skill if one applies (the subagent protocol alone covers prompt/code/config tasks). Skipping this is how a builder reverts to base-model defaults and reintroduces known mistakes (wrong device placement, stale trainer APIs, eval-before-build).
 2. Read the scratchpad for current state: `evo scratchpad`
    It surfaces: best path (★-marked in the tree), frontier (strategy-ranked branchable nodes), evaluated nodes awaiting decision, gates, annotations, what not to try, infra events, and notes. The Drill-downs section at the bottom lists the read-only commands for going deeper on any section.
 3. Study the pointer traces from your brief:
@@ -246,6 +249,20 @@ portable progress files there. evo mirrors that directory back into
 restart from benchmark-owned checkpoint files, but it does not freeze/restore an
 arbitrary Linux process.
 
+**Declare reusable outputs as artifacts (any category).** If your experiment
+produces an expensive, reusable output — a checkpoint, an adapter, a built
+index, a compiled prompt, anything — write it to `EVO_CHECKPOINT_DIR` (durable:
+it survives between-attempt cleanup and discard) and name it in the benchmark
+result's `artifacts` field: `{"score": ..., "artifacts": {"<label>": "<path>"}}`.
+Declared artifacts are preserved when the node is discarded, so a later
+experiment can reuse them via `evo new --from-artifact <exp[:label]>` (the path
+arrives as `EVO_SEED_ARTIFACT`). Never hardcode a name like `final_model/` — the
+label is whatever your recipe declares. If a run is clearly heading toward
+failure mid-flight (divergent loss, projected budget blow-out, a known-failure
+signature), it can be stopped with `evo abort <id>` — that kills the driver and
+its subprocess tree, and a partial artifact already written to
+`EVO_CHECKPOINT_DIR` survives for reuse.
+
 **If the workspace was initialized with `commit_strategy=tracked-only` (the default for `--backend pool`):** `evo run` only commits modifications to *tracked* files. New files require an explicit `git add` from inside the worktree, then a shisa-kanko ack on the run command:
 
 ```bash
@@ -270,7 +287,10 @@ The ack flag is required when the worktree has any untracked, non-gitignored fil
 
   Then either:
   - Fixable edit-bug (off-by-one, wrong signature): edit the worktree and `evo run <id>` again. Bounded by `max_attempts` (default 3). Before retrying, compare your planned edit against the previous attempts' `outcome.json` on this same node -- if two earlier attempts hit the same gate, a small tweak won't fix it. When the cap is hit, run is refused -- you must discard.
-  - Hypothesis is wrong, no fix: `evo discard <id> --reason "..."` and branch a new experiment from the **original parent**.
+  - Otherwise discard, and **classify why** with `--failure-class` so the orchestrator can route reuse vs branch:
+    - **`eval`** — the produced artifact is good but the scoring / serving / decode config is wrong. Make sure the artifact was declared + preserved; a sibling can **retest it in seconds** via `evo new --from-artifact <id>` (arrives as `EVO_SEED_ARTIFACT`) instead of rebuilding. `evo discard <id> --reason "..." --failure-class eval`.
+    - **`build`** — the artifact-production step itself broke. Fix it, then retry/resume *from the last checkpoint in `EVO_CHECKPOINT_DIR`* rather than rebuilding from scratch. `evo discard <id> --reason "..." --failure-class build` only if you're abandoning this node.
+    - **`hypothesis`** — it ran clean but didn't help. `evo discard <id> --reason "..." --failure-class hypothesis` and branch a new experiment from the **original parent** (a different direction, not a retry of the same idea).
 
 - **`FAILED`** (infra error, non-zero exit, timeout): couldn't evaluate. Doesn't consume the retry budget.
   - Transient / fixable locally: retry.