@gajae-code/coding-agent 0.14.2 → 0.15.0

package/src/autoresearch/git.ts

@@ -1,8 +1,22 @@
-import type { ExtensionAPI } from "../extensibility/extensions";
+/**
+ * Autoresearch branch isolation (ported from the deleted extension's `git.ts`).
+ *
+ * Every mission is meant to run on a dedicated `autoresearch/*` branch created
+ * from a slugified goal. On that branch `keep` auto-commits the iteration and
+ * `discard` resets the worktree to HEAD; off-branch (no repo, or a dirty tree
+ * that prevents branch creation) we degrade: `keep` skips auto-commits and
+ * `discard` reverts only run-modified paths instead of resetting to baseline.
+ *
+ * Dirty-worktree behavior is faithful to the extension contract: when the tree
+ * is dirty and we are NOT already on an autoresearch branch, we return a
+ * warning and continue on the current branch rather than failing.
+ */
+import * as fs from "node:fs";
+import * as path from "node:path";
 import * as git from "../utils/git";
-import { normalizePathSpec } from "./helpers";
+import { HARNESS_FILENAME, normalizePathSpec } from "./harness";
 
-const AUTORESEARCH_BRANCH_PREFIX = "autoresearch/";
+export const AUTORESEARCH_BRANCH_PREFIX = "autoresearch/";
 const BRANCH_NAME_MAX_LENGTH = 48;
 
 export interface EnsureAutoresearchBranchFailure {
@@ -19,21 +33,38 @@ export interface EnsureAutoresearchBranchSuccess {
 
 export type EnsureAutoresearchBranchResult = EnsureAutoresearchBranchFailure | EnsureAutoresearchBranchSuccess;
 
-export async function getCurrentAutoresearchBranch(_api: ExtensionAPI, workDir: string): Promise<string | null> {
-	const currentBranch = (await git.branch.current(workDir)) ?? "";
-	return currentBranch.startsWith(AUTORESEARCH_BRANCH_PREFIX) ? currentBranch : null;
+export function getCurrentAutoresearchBranch(workDir: string): Promise<string | null> {
+	return git.branch.current(workDir).then(currentBranch => {
+		return currentBranch?.startsWith(AUTORESEARCH_BRANCH_PREFIX) ? currentBranch : null;
+	});
+}
+
+/**
+ * True when `rawPath` is one of the mission's own research artifacts: the
+ * `autoresearch.sh` harness at the working-directory root. This is the complete
+ * agent-writable surface for an active mission — product code, manifests,
+ * dependencies, and every other path stay blocked by the research-only
+ * mutation guard regardless of branch name.
+ *
+ * Mission state under `.gjc/**` is intentionally NOT listed here: it is
+ * runtime-owned and only the sanctioned `gjc autoresearch` CLI writes it.
+ */
+export function isAutoresearchAuthorizedResearchPath(_cwd: string, rawPath: string): boolean {
+	const normalized = normalizePathSpec(rawPath);
+	if (normalized === ".") return false;
+	return normalized === HARNESS_FILENAME;
 }
 
 /**
  * Ensure the working tree is on an `autoresearch/*` branch when possible.
  *
- * If the worktree is dirty and we're not already on an autoresearch branch, this returns
- * `{ ok: true, branchName: null, warning }` rather than failing. The caller surfaces the
- * warning and continues on the current branch — `keep` will skip auto-commits and `discard`
- * will revert only run-modified paths instead of resetting to baseline.
+ * When the worktree is dirty and we are not already on an autoresearch branch,
+ * this returns `{ ok: true, branchName: null, warning }` rather than failing:
+ * the caller surfaces the warning and continues on the current branch — `keep`
+ * will skip auto-commits and `discard` will revert only run-modified paths
+ * instead of resetting to baseline.
  */
 export async function ensureAutoresearchBranch(
-	api: ExtensionAPI,
 	workDir: string,
 	goal: string | null,
 ): Promise<EnsureAutoresearchBranchResult> {
@@ -58,21 +89,27 @@ export async function ensureAutoresearchBranch(
 		};
 	}
 
-	const workDirPrefix = await readGitWorkDirPrefix(api, workDir);
+	const workDirPrefix = await readGitWorkDirPrefix(workDir);
 	const dirtyPaths = collectRelativeDirtyPaths(dirtyPathsOutput, workDirPrefix);
-	const currentBranch = await getCurrentAutoresearchBranch(api, workDir);
+	const currentBranch = await getCurrentAutoresearchBranch(workDir);
 	if (currentBranch) {
 		return { ok: true, branchName: currentBranch, created: false };
 	}
 	if (dirtyPaths.length > 0) {
 		const preview = formatDirtyPaths(dirtyPaths);
 		return {
-			ok: false,
-			error: `Worktree is dirty (${preview}). Commit or stash these changes before starting autoresearch — a fresh autoresearch/* branch needs a clean baseline.`,
+			ok: true,
+			branchName: null,
+			created: false,
+			warning:
+				`Worktree is dirty (${preview}). Continuing autoresearch on the current branch without a dedicated ` +
+				"`autoresearch/*` branch: `keep` will skip auto-commits and `discard` will revert only run-modified " +
+				"files instead of resetting to baseline. Commit or stash these changes and re-run to get full branch " +
+				"isolation.",
 		};
 	}
 
-	const branchName = await allocateBranchName(api, workDir, goal);
+	const branchName = await allocateBranchName(workDir, goal);
 	try {
 		await git.branch.checkoutNew(workDir, branchName);
 	} catch (err) {
@@ -109,8 +146,7 @@ export function relativizeGitPathToWorkDir(repoRelativePath: string, workDirPref
 	return normalizePathSpec(normalizedPath.slice(normalizedPrefix.length + 1));
 }
 
-async function readGitWorkDirPrefix(api: ExtensionAPI, workDir: string): Promise<string> {
-	void api;
+async function readGitWorkDirPrefix(workDir: string): Promise<string> {
 	try {
 		return await git.show.prefix(workDir);
 	} catch {
@@ -170,23 +206,18 @@ export function normalizeStatusPath(rawPath: string): string {
 	return normalizePathSpec(normalized);
 }
 
-async function allocateBranchName(api: ExtensionAPI, workDir: string, goal: string | null): Promise<string> {
+async function allocateBranchName(workDir: string, goal: string | null): Promise<string> {
 	const baseName = `${AUTORESEARCH_BRANCH_PREFIX}${slugifyGoal(goal)}-${currentDateStamp()}`;
 	let candidate = baseName;
 	let suffix = 2;
-	while (await branchExists(api, workDir, candidate)) {
+	while (await git.ref.exists(workDir, `refs/heads/${candidate}`)) {
 		candidate = `${baseName}-${suffix}`;
 		suffix += 1;
 	}
 	return candidate;
 }
 
-async function branchExists(api: ExtensionAPI, workDir: string, branchName: string): Promise<boolean> {
-	void api;
-	return git.ref.exists(workDir, `refs/heads/${branchName}`);
-}
-
-function slugifyGoal(goal: string | null): string {
+export function slugifyGoal(goal: string | null): string {
 	const normalized = (goal ?? "")
 		.toLowerCase()
 		.replace(/[^a-z0-9]+/g, "-")
@@ -317,3 +348,132 @@ export function computeRunModifiedPaths(
 	}
 	return { tracked, untracked };
 }
+
+// ---------------------------------------------------------------------------
+// keep / discard
+// ---------------------------------------------------------------------------
+
+export interface KeepAutoresearchRunInput {
+	cwd: string;
+	description: string;
+	status: string;
+	metric: number;
+	metrics: { [key: string]: number };
+	/** Paths modified by this run (workdir-relative). */
+	files: string[];
+	/** True when on a dedicated `autoresearch/*` branch. */
+	onAutoresearchBranch: boolean;
+	primaryMetric: string;
+}
+
+export interface KeepAutoresearchRunResult {
+	/** Error text when the commit failed; `ok` is false. */
+	error?: string;
+	/** Human note for the caller (e.g. "nothing to commit", "committed", "skipped"). */
+	note?: string;
+	/** Commit SHA after the keep (null when nothing was committed). */
+	commitHash?: string | null;
+}
+
+/**
+ * Keep an iteration: commit the modified files on a dedicated autoresearch
+ * branch. Off-branch (degraded mode) auto-commit is skipped and the files stay
+ * in the worktree, matching the extension contract.
+ */
+export async function keepAutoresearchRun(input: KeepAutoresearchRunInput): Promise<KeepAutoresearchRunResult> {
+	if (!input.onAutoresearchBranch) {
+		return {
+			note: "Auto-commit skipped: not on a dedicated autoresearch branch. Modified files remain in the worktree.",
+			commitHash: null,
+		};
+	}
+	if (input.files.length === 0) {
+		return { note: "nothing to commit", commitHash: null };
+	}
+	try {
+		await git.stage.files(input.cwd, input.files);
+	} catch (err) {
+		return { error: `git add failed: ${err instanceof Error ? err.message : String(err)}` };
+	}
+	if (!(await git.diff.has(input.cwd, { cached: true, files: input.files }))) {
+		return { note: "nothing to commit", commitHash: null };
+	}
+	const payload: { [key: string]: string | number } = {
+		status: input.status,
+		[input.primaryMetric]: input.metric,
+	};
+	for (const [name, value] of Object.entries(input.metrics)) {
+		payload[name] = value;
+	}
+	const commitMessage = `${input.description}\n\nResult: ${JSON.stringify(payload)}`;
+	try {
+		await git.commit(input.cwd, commitMessage, { files: input.files });
+		const commitHash = await git.head.sha(input.cwd);
+		return { note: `committed at ${(commitHash ?? "").slice(0, 12)}`, commitHash };
+	} catch (err) {
+		return { error: `git commit failed: ${err instanceof Error ? err.message : String(err)}` };
+	}
+}
+
+export interface DiscardAutoresearchRunInput {
+	cwd: string;
+	/** Paths that were already dirty before the run started (workdir-relative). */
+	preRunDirtyPaths: string[];
+	/** True when on a dedicated `autoresearch/*` branch. */
+	onAutoresearchBranch: boolean;
+}
+
+export interface DiscardAutoresearchRunResult {
+	error?: string;
+	note?: string;
+}
+
+/**
+ * Discard a failed/crashed iteration. On a dedicated autoresearch branch the
+ * worktree resets to HEAD (never rewinding prior `keep` commits); off-branch
+ * only run-modified paths are reverted so pre-existing user dirt survives.
+ */
+export async function discardAutoresearchRun(
+	input: DiscardAutoresearchRunInput,
+): Promise<DiscardAutoresearchRunResult> {
+	if (input.onAutoresearchBranch) {
+		try {
+			await git.reset(input.cwd, { hard: true, target: "HEAD" });
+			await git.clean(input.cwd);
+			return { note: "worktree reset to HEAD" };
+		} catch (err) {
+			return { error: `git reset/clean failed: ${err instanceof Error ? err.message : String(err)}` };
+		}
+	}
+
+	let statusText: string;
+	try {
+		statusText = await git.status(input.cwd, { porcelainV1: true, untrackedFiles: "all", z: true });
+	} catch (err) {
+		return { error: `git status failed: ${err instanceof Error ? err.message : String(err)}` };
+	}
+	let workDirPrefix: string;
+	try {
+		workDirPrefix = await git.show.prefix(input.cwd);
+	} catch {
+		workDirPrefix = "";
+	}
+	const { tracked, untracked } = computeRunModifiedPaths(input.preRunDirtyPaths, statusText, workDirPrefix);
+	const total = tracked.length + untracked.length;
+	if (total === 0) return { note: "nothing to revert" };
+	if (tracked.length > 0) {
+		try {
+			await git.restore(input.cwd, { files: tracked, source: "HEAD", staged: true, worktree: true });
+		} catch (err) {
+			return { error: `git restore failed: ${err instanceof Error ? err.message : String(err)}` };
+		}
+	}
+	for (const filePath of untracked) {
+		try {
+			fs.rmSync(path.join(input.cwd, filePath), { force: true, recursive: true });
+		} catch {
+			// best effort
+		}
+	}
+	return { note: `reverted ${total} file${total === 1 ? "" : "s"}` };
+}

package/src/autoresearch/{helpers.ts → harness.ts}

@@ -1,6 +1,24 @@
-import * as git from "../utils/git";
+/**
+ * Autoresearch harness contract: the `autoresearch.sh` entrypoint contract plus
+ * parsing of `METRIC <name>=<value>` and `ASI <key>=<value>` lines out of
+ * captured output.
+ *
+ * The contract (ported from the deleted extension's `helpers.ts`):
+ * - the harness is `./autoresearch.sh` at the working directory;
+ * - it exits 0 on success and non-zero on failure;
+ * - it prints the primary metric as `METRIC <name>=<value>` and any secondary
+ *   metrics as additional `METRIC` lines;
+ * - it may print `ASI <key>=<value>` lines for opaque structured learnings.
+ *
+ * Parsing tolerates interleaved noise: only well-formed lines are recognized,
+ * malformed lines are ignored (never thrown), and prototype-polluting key
+ * names are dropped.
+ */
 import type { ASIData, ASIValue, MetricDirection, NumericMetricMap } from "./types";
 
+export const HARNESS_FILENAME = "autoresearch.sh";
+export const DEFAULT_HARNESS_COMMAND = `bash ${HARNESS_FILENAME}`;
+
 export const METRIC_LINE_PREFIX = "METRIC";
 export const ASI_LINE_PREFIX = "ASI";
 export const EXPERIMENT_MAX_LINES = 10;
@@ -8,33 +26,36 @@ export const EXPERIMENT_MAX_BYTES = 4 * 1024;
 
 const DENIED_KEY_NAMES = new Set(["__proto__", "constructor", "prototype"]);
 
+const METRIC_LINE_RE = new RegExp(`^${METRIC_LINE_PREFIX}\\s+([\\w.µ-]+)=(\\S+)\\s*$`, "gm");
+const ASI_LINE_RE = new RegExp(`^${ASI_LINE_PREFIX}\\s+([\\w.-]+)=(.+)\\s*$`, "gm");
+
+/** All `METRIC name=value` lines found anywhere in the captured output. */
 export function parseMetricLines(output: string): Map<string, number> {
 	const metrics = new Map<string, number>();
-	const regex = new RegExp(`^${METRIC_LINE_PREFIX}\\s+([\\w.µ-]+)=(\\S+)\\s*$`, "gm");
-	let match = regex.exec(output);
+	let match = METRIC_LINE_RE.exec(output);
 	while (match !== null) {
-		const name = match[1];
+		const name = match[1] ?? "";
 		if (!DENIED_KEY_NAMES.has(name)) {
 			const value = Number(match[2]);
 			if (Number.isFinite(value)) {
 				metrics.set(name, value);
 			}
 		}
-		match = regex.exec(output);
+		match = METRIC_LINE_RE.exec(output);
 	}
 	return metrics;
 }
 
+/** All `ASI key=value` lines found anywhere in the captured output, or null when none parse. */
 export function parseAsiLines(output: string): ASIData | null {
 	const asi: ASIData = {};
-	const regex = new RegExp(`^${ASI_LINE_PREFIX}\\s+([\\w.-]+)=(.+)\\s*$`, "gm");
-	let match = regex.exec(output);
+	let match = ASI_LINE_RE.exec(output);
 	while (match !== null) {
-		const key = match[1];
+		const key = match[1] ?? "";
 		if (!DENIED_KEY_NAMES.has(key)) {
-			asi[key] = parseAsiValue(match[2]);
+			asi[key] = parseAsiValue(match[2] ?? "");
 		}
-		match = regex.exec(output);
+		match = ASI_LINE_RE.exec(output);
 	}
 	return Object.keys(asi).length > 0 ? asi : null;
 }
@@ -50,8 +71,7 @@ function parseAsiValue(raw: string): ASIValue {
 	}
 	if (value.startsWith("{") || value.startsWith("[") || value.startsWith('"')) {
 		try {
-			const parsed = JSON.parse(value) as ASIValue;
-			return parsed;
+			return JSON.parse(value) as ASIValue;
 		} catch {
 			return value;
 		}
@@ -59,6 +79,38 @@ function parseAsiValue(raw: string): ASIValue {
 	return value;
 }
 
+export interface ParsedHarnessOutput {
+	/** Every parsed metric, keyed by name. */
+	metrics: NumericMetricMap;
+	/**
+	 * The surfaced primary metric: `metrics[primaryMetricName]` when a name is
+	 * supplied, otherwise the value of the first `METRIC` line in the output.
+	 */
+	primary: number | null;
+	/** Parsed ASI learnings, or null when no ASI line parsed. */
+	asi: ASIData | null;
+}
+
+/**
+ * Parse captured harness output into the primary metric, secondary values, and
+ * ASI learnings. Malformed or noisy lines are ignored, never thrown.
+ */
+export function parseHarnessOutput(output: string, primaryMetricName?: string): ParsedHarnessOutput {
+	const metricMap = parseMetricLines(output);
+	const metrics: NumericMetricMap = {};
+	for (const [name, value] of metricMap.entries()) {
+		metrics[name] = value;
+	}
+	let primary: number | null = null;
+	if (primaryMetricName !== undefined) {
+		primary = metricMap.get(primaryMetricName) ?? null;
+	} else {
+		const first = metricMap.entries().next();
+		primary = first.done ? null : first.value[1];
+	}
+	return { metrics, primary, asi: parseAsiLines(output) };
+}
+
 export function mergeAsi(base: ASIData | null, override: ASIData | undefined): ASIData | undefined {
 	if (!base && !override) return undefined;
 	return {
@@ -101,18 +153,7 @@ export function formatElapsed(milliseconds: number): string {
 	return `${seconds}s`;
 }
 
-export function killTree(pid: number, signal: NodeJS.Signals | number = "SIGTERM"): void {
-	try {
-		process.kill(-pid, signal);
-	} catch {
-		try {
-			process.kill(pid, signal);
-		} catch {
-			// Process already exited.
-		}
-	}
-}
-
+/** True when `current` beats `best` under the given direction. */
 export function isBetter(current: number, best: number, direction: MetricDirection): boolean {
 	return direction === "lower" ? current < best : current > best;
 }
@@ -200,19 +241,3 @@ function sanitizeAsiValue(value: unknown): ASIValue | undefined {
 	}
 	return undefined;
 }
-
-export async function tryGitStatus(cwd: string): Promise<string> {
-	try {
-		return await git.status(cwd, { porcelainV1: true, untrackedFiles: "all", z: true });
-	} catch {
-		return "";
-	}
-}
-
-export async function tryGitPrefix(cwd: string): Promise<string> {
-	try {
-		return await git.show.prefix(cwd);
-	} catch {
-		return "";
-	}
-}

package/src/autoresearch/{prompt-setup.md → prompts/prompt-setup.md}

@@ -2,13 +2,13 @@
 
 ## Autoresearch Mode — Phase 1: Harness Setup
 
-Autoresearch mode is active and there is no session yet. Your job in this turn is to **build the benchmark harness**, not to optimise anything. Optimisation starts only after you call `init_experiment`.
+Autoresearch mode is active and there is no mission yet. Your job in this turn is to **build the benchmark harness**, not to optimise anything. Optimisation starts only after the mission is written.
 
 {{#if has_goal}}
 Primary goal (for context — implement the harness so it can measure this):
 {{goal}}
 {{else}}
-There is no goal recorded yet. Infer what to optimise from the latest user message and design the harness to measure that. Capture the goal when you call `init_experiment`.
+There is no goal recorded yet. Infer what to optimise from the latest user message and design the harness to measure that. Capture the goal when you write the mission.
 {{/if}}
 
 Working directory: `{{working_dir}}`
@@ -27,17 +27,17 @@ Write `./autoresearch.sh` at the working directory. It is the canonical benchmar
 - print any secondary metrics as additional `METRIC <name>=<value>` lines;
 - run the same workload deterministically every time (no live network, no time-of-day dependencies, fixed seeds where applicable).
 
-You **may** edit anything else needed to make `autoresearch.sh` work — benchmark binaries, `Cargo.toml`, `package.json`, helper scripts, fixtures. All those edits are part of the harness baseline and will be committed for you when you call `init_experiment` on an autoresearch branch.
+Do not edit product source, manifests, or dependencies. The harness must use existing checked-in commands and fixtures, or report that the mission requires the normal approval-gated implementation path before benchmarking can proceed.
 
 ### Steps
 
 1. Inspect the target. Read source, identify what to measure, decide on the workload.
-2. Write `autoresearch.sh` plus any supporting files (benchmark binaries, fixtures, etc.).
+2. Write `autoresearch.sh` only when it is an explicitly approved research artifact; otherwise use an existing benchmark command.
 3. Validate it: invoke `bash autoresearch.sh` through the regular `bash` tool. Confirm it exits 0 and emits at least one `METRIC` line. Iterate on the harness until it does.
-4. Call `init_experiment` with the goal, primary metric (matching the `METRIC` name), and scope. This snapshots the worktree as the baseline and starts Phase 2 (the iteration loop).
+4. Start the mission with `gjc autoresearch` (cold intake: goal, constraints, deliverables, and an explicit mode) or `gjc autoresearch --spec <spec>` (handoff intake). Record the primary metric name and its direction (lower/higher is better) with the mission. The harness baseline is snapshotted at mission start and Phase 2 (the iteration loop) begins.
 
 ### Rules
 
-- Do **not** call `run_experiment`, `log_experiment`, or `update_notes` yet. They will error with "no active autoresearch session" until `init_experiment` runs.
+- Do **not** start the iteration loop yet. The experiment machinery is unavailable until a mission exists.
 - Do **not** treat a compile-only check as a benchmark. The harness must actually execute the workload and emit `METRIC`.
-- Do **not** create `autoresearch.md`, `autoresearch.checks.sh`, `autoresearch.program.md`, `autoresearch.ideas.md`, `autoresearch.jsonl`, `.autoresearch/`, or `autoresearch.config.json`. Session state is tracked for you.
+- Do **not** create `autoresearch.md`, `autoresearch.checks.sh`, `autoresearch.program.md`, `autoresearch.ideas.md`, `autoresearch.jsonl`, `.autoresearch/`, or `autoresearch.config.json`. Mission and run state is tracked for you under `.gjc/_session-{id}/autoresearch/`.

package/src/autoresearch/prompts/prompt.md

@@ -0,0 +1,103 @@
+{{base_system_prompt}}
+
+## Autoresearch Mode
+
+Autoresearch mode is active.
+
+{{#if has_goal}}
+Primary goal:
+{{goal}}
+{{else}}
+There is no goal recorded for this mission yet. Infer what to optimize from the latest user message and the conversation; capture the goal in your notes once it is clear.
+{{/if}}
+
+Mission state and run artifacts are managed for you under `.gjc/_session-{id}/autoresearch/`. The benchmark entrypoint is `bash autoresearch.sh` (committed during Phase 1). Do not edit `autoresearch.sh` mid-segment unless you intentionally start a fresh baseline. Do not create `autoresearch.md` or `.autoresearch/` in this repo.
+
+Working directory: `{{working_dir}}`
+{{#if has_branch}}Active branch: `{{branch}}`{{/if}}
+{{#if has_baseline_commit}}Baseline commit: `{{baseline_commit}}`{{/if}}
+
+You are running a research-only evidence loop. Do not modify product code, manifests, dependencies, or benchmark harnesses. Stop with a caveat when evidence requires an implementation change.
+
+### Available tools
+
+- `python` — a persistent session REPL. Variables, imports, and loaded data survive across calls.
+- `bash` — run an existing benchmark command. Output is captured automatically; `METRIC name=value` and `ASI key=value` lines are parsed back to you, with any other output treated as noise.
+- Run ledger — record each experiment result and flag suspect runs; flagged runs are excluded from baseline and best-metric math.
+
+### Operating protocol
+
+1. Understand the target without modifying it: read source, identify the bottleneck, verify prerequisites and benchmark inputs.
+2. Record the goal, scope, and constraints with the mission.
+3. Establish a baseline first.
+4. Iterate: run the existing benchmark or data experiment, record honestly. One coherent experiment per iteration.
+5. Keep the primary metric as the decision maker:
+   - `keep` when it improves;
+   - `discard` when it regresses or stays flat;
+   - `crash` when the run fails;
+   - `checks_failed` when validation fails (you decide what validation means; run it through the regular `bash` tool).
+6. Use ASI freely — it is opaque, just stash useful learnings (`hypothesis`, `rollback_reason`, `next_action_hint`, anything else).
+7. When confidence is low, re-run promising changes before keeping them. Each kept run reports a confidence score (multiples of the observed noise floor).
+
+### Scope, off-limits, and accountability
+
+- Product edits are prohibited. A benchmark or data experiment that needs changes is evidence for a separate approval-gated implementation request.
+- If a previous run looks reward-hacked or otherwise wrong, flag it so it is excluded from baseline and best-metric calculations.
+
+{{#if has_notes}}
+### Your notes
+
+{{notes}}
+
+{{/if}}
+{{#if has_recent_results}}
+### Current segment snapshot
+- segment: `{{current_segment}}`
+- runs in current segment: `{{current_segment_run_count}}`
+{{#if has_baseline_metric}}
+- baseline `{{metric_name}}`: `{{baseline_metric_display}}`
+{{/if}}
+{{#if has_best_result}}
+- best kept `{{metric_name}}`: `{{best_metric_display}}`{{#if best_run_number}} from run `#{{best_run_number}}`{{/if}}
+{{/if}}
+
+Recent runs:
+{{#each recent_results}}
+- run `#{{run_number}}`: `{{status}}` `{{metric_display}}` — {{description}}
+{{#if has_asi_summary}}
+  ASI: {{asi_summary}}
+{{/if}}
+{{#if has_deviations}}
+  Modified outside scope: {{deviations}}{{#unless justified}} (no justification){{/unless}}
+{{/if}}
+{{#if flagged}}
+  FLAGGED: {{flagged_reason}}
+{{/if}}
+{{/each}}
+{{/if}}
+{{#if has_unjustified_runs}}
+
+### Unjustified deviations
+{{#each unjustified_runs}}
+- run `#{{run_number}}` modified `{{paths}}` outside scope without justification. Either accept it, justify it on the next log, or flag it.
+{{/each}}
+{{/if}}
+{{#if has_pending_run}}
+
+### Pending run
+An unlogged run is waiting:
+- run: `#{{pending_run_number}}`
+- command: `{{pending_run_command}}`
+{{#if has_pending_run_metric}}
+- parsed `{{metric_name}}`: `{{pending_run_metric_display}}`
+{{/if}}
+- result: {{#if pending_run_passed}}passed{{else}}failed{{/if}}
+
+Record the run in the ledger before starting another benchmark.
+{{/if}}
+
+### Guardrails
+- Do not game the benchmark.
+- Do not overfit to synthetic inputs if the real workload is broader.
+- Preserve correctness.
+- If the user sends another message while a run is in progress, finish the current run and recording cycle first, then address the new input in the next iteration.