cyber-aced 0.3.0

package/skills/add-scenario/README.md

@@ -0,0 +1,25 @@
+# add-scenario
+
+Add a new scenario to an existing ACED `.feature` suite — from a real failure, a production edge case, or a gap you noticed.
+
+## When to use
+
+Use this skill when you already have a suite (`eval.md` + a frozen `.feature`) and want to grow its coverage with one more scenario.
+
+Good triggers include:
+
+- "Add a test case for this failure"
+- "We need to cover this edge case"
+- Turning a pasted agent transcript that went wrong into a guarded-against scenario
+
+Defer to a sibling when the request is about scoring the existing set (`run`), diagnosing why cases fail (`improve`), or there's no suite yet at all (`define-skill` / `define-agent` / `define-governance`, then `sdd:start-mission` to author one).
+
+## What it does
+
+Locates the target suite, classifies the new scenario's layer (trigger / behavior / quality) from how you describe the failure, drafts a Gherkin scenario (boolean, or `@rubric` with an inline rubric, or a `@trigger` `Examples` row), confirms it with you, and appends it to the frozen `.feature` (additive — self-clears).
+
+## Install
+
+```bash
+npx skills add cyberuni/cyberplace --skill aced/add-scenario
+```

package/skills/add-scenario/SKILL.md

@@ -0,0 +1,75 @@
+---
+name: add-scenario
+description: Use this skill when adding a new scenario to an ACED .feature suite — from a real failure, a production edge case, or a gap the user noticed.
+---
+
+# ACED Add Scenario
+
+Add one or more scenarios to an existing frozen `.feature` suite. Adding a scenario is **additive** —
+it widens the contract and cannot break existing impl, so it **self-clears** and the `.feature` stays
+`@frozen` (per `sdd:suite-format-governance`); no re-open is needed.
+
+## Locate the suite
+
+Find the target's node in the project spec — `.agents/specs/<project>/…/<node>/` (discovered through
+the SDD spec tree; the node's `eval.md` names the subject) — from user context or ask. Read the
+node's colocated `eval.md` for the `subject` and the `eval:` run policy (`eval.judge.default_threshold`).
+
+## Gather input
+
+The user may provide:
+- A description of a scenario that failed in production
+- A pasted agent transcript showing incorrect behavior
+- A description of an edge case not yet covered
+- A "must not do" behavior they want to guard against
+
+If a transcript is provided, extract: what the user said, what state the system was in, what the agent did, what it should have done instead.
+
+## Determine the layer
+
+| Input type | Layer |
+|---|---|
+| "Agent invoked the skill when it shouldn't have" | trigger |
+| "Agent didn't invoke the skill when it should have" | trigger |
+| "Agent invoked correctly but skipped a step" | behavior |
+| "Agent did the step but produced poor output" | quality |
+
+Ask if unclear.
+
+If the resolved layer is not enabled in the suite's `eval.md` `eval.layers`, warn that the layer is not enabled and the scenario will not be exercised until it is.
+
+## Scaffold the scenario
+
+Draft a Gherkin scenario for the frozen `.feature`, tagged with its layer:
+
+- **trigger** → add a row to the `@trigger` `Scenario Outline`'s `Examples` table
+  (`| <query> | <should_trigger> |`), or start one if the suite has none.
+- **behavior (deterministic)** → a boolean scenario whose `Then` asserts the observable action (a
+  must-not-do guard is a `Then` asserting the agent *does not* do the prohibited action).
+- **behavior / quality (graded)** → a `@rubric` scenario with the rubric **inline**:
+
+```gherkin
+@behavior @rubric
+Scenario: <name — the situation being guarded>
+  Given <concrete situation: user message, repo/file state, context>
+  When <the agent acts>
+  Then the judge evaluates the scenario against the rubric
+    """
+    dimensions:
+      - name: <criterion>
+        max: <n>
+    threshold: <from eval.judge.default_threshold>
+    """
+  And the rubric score is at least the threshold
+```
+
+Show the draft to the user and ask for confirmation before writing. Adjust based on feedback.
+
+## Write the scenario
+
+Append the scenario to the node's frozen `<node>.feature` in the project spec, sorted into its
+lifecycle-stage section (per the scenario-ordering convention). Keep the feature-level `@frozen` tag —
+adding a scenario self-clears. Run `check-suite --files <path>` to confirm the suite is still
+well-formed.
+
+Report the scenario name and suggest running `run` to score it against the current agent configuration.

package/skills/bench/README.md

@@ -0,0 +1,64 @@
+# bench
+
+Measure whether a change makes real agent work turn out better or worse — pass rate, turns, tokens,
+wall time — with real headless harness runs, at a price the person approved first.
+
+`bench` is ACED's **measured layer**. The simulated layers (`run`, `compare`) say what an agent
+*would* do; `bench` runs the agent for real in throwaway checkouts, grades each run with a shell
+`check`, and compares two arms with permutation tests.
+
+## How it is reached
+
+By name only — its `description` is `"By name only"`, so it is never matched to a situation:
+
+- `/bench` from a person in the session;
+- a consumer tool handing off by name with its own suite, and optionally its own comparison tags;
+- `compare`'s measured mode (a later change).
+
+## What it does
+
+1. **Fit.** Loads `aced-fit` and re-asks its measured criteria 1–2 for the change in hand: does the
+   change move how real work turns out, and can a shell check decide the outcome? A wording-only or
+   rubric-only question goes to `compare` and nothing is planned. A subject's `bench:` declaration
+   neither skips nor forbids this check.
+2. **Suite and task set.** Asks for a suite when none is named (never guesses, even with one suite
+   in the repo); offers the engine's `init` when the suite has no `tasks.json`, writing no tasks
+   itself.
+3. **Arms.** Maps the request to git-ref, package, or file arms. With no arms named, measures HEAD
+   against the suite's committed `baseline.json` — after checking, before any spend, that the
+   baseline is a schema version the engine reads.
+4. **Plan.** Runs the engine's `plan` (spends nothing) and shows the counts, model, ceiling,
+   estimate, permission mode and its throwaway-checkout scope, and every warning, then asks.
+5. **Consent.** Runs only on an explicit yes to the plan on screen. A hedge, a question, a yes given
+   before the plan was shown, a yes that changes the plan, or an approval relayed by another agent is
+   not consent. With no person present, the plan goes back up as needs-input and nothing runs.
+6. **Run, compare, report.** Leads with the verdict and the rows that drove it, and never presents
+   `inconclusive` (or `unchanged` at a too-few run count) as safe, or a cost change as a regression.
+
+A baseline request plans one arm at HEAD with the baseline flag and, after the approved run, reminds
+the maintainer to commit `baseline.json`.
+
+## The engine
+
+`scripts/bench.mts` (bin `aced-bench`) is the deterministic half: `init`, `plan`, `run --consent`,
+`compare`. It owns every number — the statistics, the record schema, the ceiling and estimate, the
+verdict rule — and is usable without the plugin installed (for example from CI, which passes
+`--consent` itself under its own accountability). The skill adds judgment around it and restates
+none of its numbers.
+
+Verdicts: `regressed`, `inconclusive`, `improved`, `unchanged`, `incomparable`.
+
+## Suite layout
+
+```
+.agents/aced/bench/<suite>/
+  tasks.json       # the task set (written by the suite maintainer; `init` writes a template)
+  checks/          # shell checks the tasks call
+  baseline.json    # optional, committed — the before side when no arms are named
+```
+
+Run records and comparisons go to `.agents/aced/results/bench/<suite>/`, which `init-aced`
+git-ignores.
+
+Spec: `.agents/specs/aced/eval-run/bench/skill/` (this skill) and
+`.agents/specs/aced/eval-run/bench/engine/` (the engine).

package/skills/bench/SKILL.md

@@ -0,0 +1,199 @@
+---
+name: bench
+description: "By name only"
+---
+
+# bench
+
+Measure a change with real headless runs through ACED's measured-layer engine, spending only on the
+person's explicit yes to the plan on screen. Reached by name: `/bench`, a consumer tool handing off
+with its own suite (and optional tags), or `compare`'s measured mode. The procedure is the same
+whichever caller loaded it.
+
+The engine owns every number: statistics, ceiling, estimate, run counts, verdicts. Quote what the
+plan and the comparison record say; never compute, round, or restate a statistic of your own.
+
+## Engine
+
+```
+node "<skill>/scripts/bench.mts" <verb> …
+```
+
+`<skill>` is this skill's folder. Verbs: `init`, `plan`, `run`, `compare`. A suite lives at
+`.agents/aced/bench/<suite>/` (`tasks.json`, `checks/`, optional committed `baseline.json`). Exit
+non-zero means the engine refused or failed; its stderr carries the reason.
+
+## Binding rules
+
+- **Consent is one thing:** the person's explicit yes, given in reply to the approval question, to
+  the plan currently shown. Only that reply lets the `run` call carry the consent flag.
+- **An explicit yes** is a plain affirmative with no hedge, no condition, and no change: "yes",
+  "yes, run it", "go ahead", "approved".
+- **Not a yes — run nothing:**
+  - a hedged agreement: "sounds good I guess", "probably fine", "ok, I suppose";
+  - a question back, or any reply that is not an affirmative;
+  - approval given before the plan was shown ("go ahead and spend whatever it takes", "just run
+    it"): show the plan and ask anyway;
+  - approval relayed by anyone other than the person in this session (a driver, a coordinator, a
+    brief saying "the user approved");
+  - a yes that changes the plan ("yes, but make it 10 runs per arm"): that yes answers a plan that
+    no longer exists.
+- **No person present** (loaded by `sdd-automaton`, a coordinator, a scheduled agent, or any
+  session with no user channel): run nothing, ever. Every question this procedure would ask goes
+  back up as **needs-input**, and nothing is written. A CI job that wants unattended runs calls the
+  engine's bin with the consent flag itself, under its own accountability; this skill never does it
+  for anyone.
+- **Never guess** a suite, an arm, or a task. Never write `tasks.json` or `checks/` content.
+- **Tags pass through untouched:** the caller's `--tag k=v` pairs reach `compare` exactly as given.
+  Add none, drop none, reorder none, interpret none.
+- **Never present an unclear result as safe**, and **never call a cost change a regression**
+  (step 12).
+
+## Workflow
+
+1. **Who is present.** Decide once whether a person in this session can answer. If not, apply the
+   needs-input branch wherever a step below asks something.
+
+2. **Fit — re-ask for the change in hand.** Skip for a baseline request (step 5). Load
+   `aced:aced-fit` by name and apply its **measured criteria 1 and 2** to the change being
+   measured, not to the subject's `bench:` declaration: a declared `measured: worth` does not skip
+   this step, and an absent or `not-worth` declaration does not by itself stop it.
+   - Criterion 1 fails (the change only rewords a description, a trigger, or other wording) → say
+     the simulated layer answers a wording change and name `compare` (ACED's simulated diff).
+   - Criterion 2 fails (no shell `check` can decide the outcome, for example "do replies read
+     warmer") → say no shell check can decide this outcome, point to the simulated layer, and name
+     `compare`.
+   - Either failure: plan nothing, return no plan. Same answer with no person present.
+
+3. **Suite.** Use the suite the request or the calling tool names. None named → ask which suite to
+   use and plan nothing. You may list the suites found under `.agents/aced/bench/`, but never pick
+   one, even when only one exists. No person present → return that question as needs-input.
+
+4. **Task set.** `.agents/aced/bench/<suite>/tasks.json` missing → say the suite has no task set,
+   offer to run the engine's `init` for it (a template the suite maintainer then fills in), and plan
+   nothing. Write no task of your own. Run `init` only on the person's yes to that offer:
+
+   ```
+   node "<skill>/scripts/bench.mts" init --suite <suite>
+   ```
+
+   No person present → return the init offer as needs-input; run nothing, write nothing.
+
+5. **Arms.** Map the request to `--arm <label>=<subject>` pairs. "X against Y" makes Y `before` and
+   X `after`.
+
+   | The request names | Arms |
+   |---|---|
+   | two git refs (commits, branches, tags) | `--arm before=git:<Y> --arm after=git:<X>` |
+   | two versions of one package or plugin | `--arm before=package:<name>@<older> --arm after=package:<name>@<newer>` |
+   | with and without one file that HEAD carries | `--arm without=file:<path>=absent --arm with=file:<path>=ref:HEAD` — never a git-ref arm |
+   | one file swapped in from a ref or a path | `--arm before=file:<path>=ref:HEAD --arm after=file:<path>=ref:<ref>` (or `=path:<source>`) — both arms `file`, since the engine never compares two subject kinds |
+   | a request to record or refresh the baseline | `--arm baseline=git:HEAD` plus `--baseline` — one arm only |
+   | no arms | read `.agents/aced/bench/<suite>/baseline.json` first (below) |
+
+   **No arms named** — check the baseline now, before any plan or spend:
+   - `baseline.json` exists with `schemaVersion: 3` (the only version the engine reads) → one arm,
+     `--arm after=git:HEAD`; at step 11 compare it with `--before baseline`.
+   - no `baseline.json` → say the suite has no baseline, ask which two arms to compare (or offer to
+     record a baseline), and plan nothing.
+   - `baseline.json` with any other or missing `schemaVersion` → say the baseline is schema version
+     `<n>`, which the engine cannot read, ask which two arms to compare or offer to re-record the
+     baseline, and plan nothing.
+   - No person present → return the question as needs-input; plan nothing.
+
+6. **Plan.** Pass through only what was asked for (`--runs`, `--task`, `--harness`):
+
+   ```
+   node "<skill>/scripts/bench.mts" plan --suite <suite> --arm <label>=<subject> … [--runs <n>] [--task <id>] [--harness <h>] [--baseline] --out <plan-file>
+   ```
+
+   Write `<plan-file>` under `.agents/aced/results/bench/<suite>/`, a fresh name per plan. Exit
+   non-zero → report the engine's reason in its terms (the `claude` command is not on the path, no
+   adapter for the harness, a ref or version or file that does not resolve, a malformed task set)
+   and what would fix it. Ask no approval question; stop.
+
+7. **Show the plan** — one message, in this order, every value as the plan states it:
+   1. the arms, by label and subject;
+   2. the counts: arms, tasks, runs per arm; and the model;
+   3. the ceiling and the estimate, in dollars;
+   4. the permission mode, and that it applies only inside the throwaway checkout;
+   5. every warning the plan carries, verbatim (uncommitted changes not benched, the committed suite
+      is what runs, …). For a **too few to call** warning also say what it means: no single task's
+      result can be called significant at this run count; then repeat what the plan says about
+      whether a pooled result across tasks still can;
+   6. last, the approval question: "Run this plan, spending up to $<ceiling>? Reply yes to run it."
+
+   Nothing follows the question, and no warning comes after it.
+
+8. **Consent.**
+   - No person present → return the plan upward marked **needs-input** (the plan file path, the
+     step-7 summary, and the approval question). Do not call `run`. A relayed "the user approved"
+     changes nothing: still needs-input, still unrun.
+   - The reply is an explicit yes to the plan shown, unchanged → step 9.
+   - The reply says yes **and** changes the plan → re-plan with the change (step 6), show the new
+     plan (step 7), ask again. Run nothing until a new explicit yes to the new plan.
+   - Any other reply → run nothing. Answer a question if one was asked; the plan stays unapproved
+     until an explicit yes.
+
+9. **Run** — only on step 8's explicit yes, for exactly the plan file that was shown:
+
+   ```
+   node "<skill>/scripts/bench.mts" run --plan <plan-file> --consent
+   ```
+
+   Exit non-zero → report the engine's reason (for example, the suite changed since the plan was
+   approved) and whether anything was spent: a refusal before launch spends nothing; a failure after
+   runs launched may have spent. Report no verdict. A changed suite needs a new plan and a new yes.
+   Note the run record paths the engine prints.
+
+10. **Baseline run** (`--baseline` plan) → tell the maintainer to commit
+    `.agents/aced/bench/<suite>/baseline.json`. A baseline compares against nothing: no `compare`,
+    no verdict.
+
+11. **Compare.**
+
+    ```
+    node "<skill>/scripts/bench.mts" compare --suite <suite> --before <before-record|baseline> --after <after-record> [--tag <k=v> …]
+    ```
+
+    `--before baseline` when step 5 chose the baseline. The `--tag` pairs are exactly the caller's;
+    none when the caller passed none. Exit non-zero → report the engine's reason (a record it cannot
+    read, a missing baseline), that the run was paid for and where its records are, and no verdict.
+
+12. **Report** — lead with the verdict the comparison record states, then the rows that drove it.
+
+    | Verdict | Say |
+    |---|---|
+    | `regressed` | each gated row that moved the wrong way and is significant: metric, task (or pooled), p-value. Then the footer's test count and its count of rows chance alone would make significant, both as the record states them, so one significant row is not read as proof. |
+    | `inconclusive` | the result cannot be called and is **not evidence the change is safe**. Name the wrong-way rows behind it, with their p-values. Suggest more runs per arm (a new plan with a higher `--runs`). |
+    | `incomparable` | every reason the record lists (different model, harness, task set, …) and what would make the two records comparable. Present no per-task deltas, means, or p-values. |
+    | `improved` | each row that improved significantly: metric, task (or pooled), p-value. |
+    | `unchanged`, every gated row `tooFew` | the run count was too low to call any change. It is **not evidence the change is safe**; do not say nothing changed. Suggest more runs per arm. |
+    | `unchanged`, gated rows not all `tooFew` | no significant change in any gated metric. |
+
+    **Cost.** A significant `costUsd` (or `cacheReadTokens`) row is reported as a cost change on
+    its own line, under any verdict except `incomparable`. It is never a regression and never turns
+    the verdict into one; only the engine's verdict says `regressed`.
+
+## Validate
+
+Assertions about this file, checked by its author before handoff and by a cold reader after:
+
+1. **Consent only on an explicit yes to the shown plan.** Exactly one fenced command in this file
+   carries `--consent`: the `run` command in step 9, and step 9 opens with "only on step 8's
+   explicit yes, for exactly the plan file that was shown". *(mechanical: count fenced lines
+   containing `--consent`; read step 9's first line)*
+2. **No consent with no person present.** Step 8's no-person bullet returns the plan as
+   needs-input and says not to call `run`, and the Binding rules' no-person bullet says to run
+   nothing, ever. *(mechanical: both bullets present with those words)*
+3. **No unclear result presented as safe.** The step-12 rows for `inconclusive` and for
+   `unchanged` with every gated row `tooFew` each contain "not evidence the change is safe".
+   *(mechanical: grep those two rows)*
+4. **No cost change called a regression.** Step 12's **Cost** paragraph says a significant cost row
+   is reported as a cost change and is never a regression. *(mechanical: the paragraph contains
+   "never a regression")*
+
+## References
+
+- `aced:aced-fit` — loaded by name in step 2; its measured criteria 1–2 are the fit test.
+- `README.md` in this folder — the engine's surface, its verdicts, and who calls this skill.

package/skills/bench/scripts/bench-claude-code.mts

@@ -0,0 +1,187 @@
+// bench-claude-code — the Claude Code adapter: launch headless, parse the transcript into counts.
+//
+// The launch facts (the command, the one-shot flag, how the model, permission mode, and output
+// format are passed, and which flag stops session persistence) come from @cyberuni/agent-harness's
+// headless fact. The spec adds what a measured run must carry beyond those facts: the budget cap,
+// project-only settings and a strict MCP config (the checkout's own, never the operator's), and,
+// for a package arm, the plugin directory. Those are added here.
+//
+// `print` is the only runner: headless `-p` with stream-json output. A run is `capped` whenever it
+// stops without a success result — the budget cap, an error result, the timeout, or the process
+// dying on a signal. A spawn failure (the command is gone) is not a run outcome: it throws.
+
+import { spawnSync } from 'node:child_process'
+import { copyFileSync, existsSync, mkdirSync } from 'node:fs'
+import { homedir } from 'node:os'
+import { join } from 'node:path'
+import { headlessCommand, headlessInvocation } from '@cyberuni/agent-harness'
+
+export interface LaunchOptions {
+	prompt: string
+	model: string
+	maxBudgetUsd: number
+	permissionMode: string
+	checkout: string
+	timeoutMs: number
+	/** A package arm's unpacked plugin. */
+	pluginDir?: string
+	/** Extra environment, such as a package arm's isolated CLAUDE_CONFIG_DIR. */
+	env?: Record<string, string>
+}
+
+export interface AgentOutcome {
+	inputTokens: number
+	outputTokens: number
+	cacheReadTokens: number
+	cacheCreationTokens: number
+	turns: number
+	toolCalls: number
+	costUsd: number
+	capped: boolean
+	/** The model the transcript reports, when it reports one. */
+	model?: string
+	transcript: string
+}
+
+export interface Adapter {
+	harness: string
+	name: string
+	runner: string
+	executable: string
+	launch(options: LaunchOptions): AgentOutcome
+	/**
+	 * A fresh harness config directory inside `runTemp`: the operator's credentials, none of their
+	 * plugins or settings. Returns the environment that points the harness at it.
+	 */
+	isolatedConfig(runTemp: string): Record<string, string>
+}
+
+/** Reads `--output-format stream-json`: tool calls from assistant messages, the rest from `result`. */
+export function parseStreamJson(text: string): Omit<AgentOutcome, 'transcript'> {
+	const out: Omit<AgentOutcome, 'transcript'> = {
+		inputTokens: 0,
+		outputTokens: 0,
+		cacheReadTokens: 0,
+		cacheCreationTokens: 0,
+		turns: 0,
+		toolCalls: 0,
+		costUsd: 0,
+		capped: true,
+	}
+	for (const line of text.split('\n')) {
+		if (!line.startsWith('{')) continue
+		let event: {
+			type?: string
+			subtype?: string
+			model?: string
+			is_error?: boolean
+			num_turns?: number
+			total_cost_usd?: number
+			usage?: {
+				input_tokens?: number
+				output_tokens?: number
+				cache_read_input_tokens?: number
+				cache_creation_input_tokens?: number
+			}
+			message?: { model?: string; content?: Array<{ type?: string }> }
+		}
+		try {
+			event = JSON.parse(line)
+		} catch {
+			continue
+		}
+		if (event.type === 'system' && typeof event.model === 'string' && event.model && out.model === undefined) {
+			out.model = event.model
+		} else if (event.type === 'assistant') {
+			const content = Array.isArray(event.message?.content) ? event.message.content : []
+			out.toolCalls += content.filter((c) => c?.type === 'tool_use').length
+			if (out.model === undefined && typeof event.message?.model === 'string' && event.message.model)
+				out.model = event.message.model
+		} else if (event.type === 'result') {
+			const u = event.usage ?? {}
+			out.inputTokens = u.input_tokens ?? 0
+			out.outputTokens = u.output_tokens ?? 0
+			out.cacheReadTokens = u.cache_read_input_tokens ?? 0
+			out.cacheCreationTokens = u.cache_creation_input_tokens ?? 0
+			out.turns = event.num_turns ?? 0
+			out.costUsd = event.total_cost_usd ?? 0
+			out.capped = event.subtype !== 'success' || event.is_error === true
+		}
+	}
+	return out
+}
+
+const HARNESS = 'claude-code'
+
+function launchArgs(o: LaunchOptions): string[] {
+	const facts = headlessInvocation(HARNESS)
+	const cmd = headlessCommand(HARNESS, {
+		prompt: o.prompt,
+		model: o.model,
+		permission: o.permissionMode,
+		outputFormat: 'stream-json',
+	})
+	if (!cmd || facts.supported !== true)
+		throw new Error('@cyberuni/agent-harness reports no headless mode for claude-code')
+	const args = [...cmd.args]
+	// The prompt is placed right after the facts' own (boolean-terminated) flags, so a variadic flag
+	// added below can never swallow it.
+	const disable = facts.transcript?.disable ?? []
+	const extra = [
+		'--max-budget-usd',
+		String(o.maxBudgetUsd),
+		...disable,
+		...(disable.includes('--no-session-persistence') ? [] : ['--no-session-persistence']),
+		'--setting-sources',
+		'project',
+		'--strict-mcp-config',
+	]
+	if (o.pluginDir) extra.push('--plugin-dir', o.pluginDir)
+	if (existsSync(join(o.checkout, '.mcp.json'))) extra.push('--mcp-config', '.mcp.json')
+	return [...args, ...extra]
+}
+
+export const claudeCode: Adapter = {
+	harness: HARNESS,
+	name: 'aced.claude-code',
+	runner: 'print',
+	executable: (() => {
+		const facts = headlessInvocation(HARNESS)
+		return facts.supported === true ? facts.executable : 'claude'
+	})(),
+	launch(o) {
+		const r = spawnSync(this.executable, launchArgs(o), {
+			cwd: o.checkout,
+			encoding: 'utf8',
+			timeout: o.timeoutMs,
+			killSignal: 'SIGKILL',
+			maxBuffer: 512 * 1024 * 1024,
+			stdio: ['ignore', 'pipe', 'pipe'],
+			env: { ...process.env, ...o.env },
+		})
+		const code = (r.error as NodeJS.ErrnoException | undefined)?.code
+		if (r.error && code !== 'ETIMEDOUT' && code !== 'ENOBUFS')
+			throw new Error(`could not launch ${this.executable}: ${r.error.message}`)
+		const transcript = r.stdout ?? ''
+		const parsed = parseStreamJson(transcript)
+		// Killed — by the timeout or any other signal — is a stop without a success result.
+		if (r.error || r.signal) parsed.capped = true
+		return { ...parsed, transcript }
+	},
+	isolatedConfig(runTemp) {
+		const dir = join(runTemp, 'claude-config')
+		mkdirSync(dir, { recursive: true })
+		const operator = process.env.CLAUDE_CONFIG_DIR || join(homedir(), '.claude')
+		const credentials = join(operator, '.credentials.json')
+		if (existsSync(credentials)) copyFileSync(credentials, join(dir, '.credentials.json'))
+		return { CLAUDE_CONFIG_DIR: dir }
+	},
+}
+
+const ADAPTERS: Record<string, Adapter> = { [HARNESS]: claudeCode }
+
+export function adapterFor(harness: string): Adapter | undefined {
+	return Object.hasOwn(ADAPTERS, harness) ? ADAPTERS[harness] : undefined
+}
+
+export const ADAPTER_HARNESSES = Object.keys(ADAPTERS)