@xingular/harness 0.1.7 → 1.0.0

package/dist/sdk/refine/ledger.js

@@ -0,0 +1,76 @@
+// Budget accounting: R = 4k rollouts and P = 3k improvement stages per mode. Base executions
+// count toward each mode; retries are separate attempt counts; selection and reflection are
+// recorded outside this ledger.
+//
+// Ported from Harness² (Apache-2.0, Google LLC; `harness2/core/ledger.py`).
+/** R = 4k: k shared base + 2k candidates + k finals. */
+export const expectedRollouts = (k) => 4 * k;
+/** P = 3k: k INV + k DOM + k compositions. */
+export const expectedSessions = (k) => 3 * k;
+export class BudgetError extends Error {
+    constructor(message) {
+        super(message);
+        this.name = 'BudgetError';
+    }
+}
+const round = (value) => Math.round(value * 1e6) / 1e6;
+export class Ledger {
+    mode;
+    taskId;
+    k;
+    entries = [];
+    constructor(mode, taskId, k) {
+        this.mode = mode;
+        this.taskId = taskId;
+        this.k = k;
+    }
+    rollout(label, usd = 0, cached = false) {
+        this.entries.push({ kind: 'rollout', label, usd, cached, attempts: 1 });
+    }
+    session(label, usd = 0, options = {}) {
+        this.entries.push({ kind: 'session', label, usd, cached: options.cached ?? false, attempts: options.attempts ?? 1 });
+    }
+    labels(kind) {
+        return this.entries.filter((entry) => entry.kind === kind).map((entry) => entry.label);
+    }
+    get R() {
+        return this.labels('rollout').length;
+    }
+    get P() {
+        return this.labels('session').length;
+    }
+    usd(kind) {
+        return round(this.entries.filter((entry) => !kind || entry.kind === kind).reduce((sum, entry) => sum + entry.usd, 0));
+    }
+    /** Throws unless the entries show exactly R=4k and P=3k with no repeated label. */
+    assertIdentity() {
+        const wantR = expectedRollouts(this.k);
+        const wantP = expectedSessions(this.k);
+        const rl = this.labels('rollout');
+        const sl = this.labels('session');
+        const dupes = [...new Set([...rl.filter((label, i) => rl.indexOf(label) !== i), ...sl.filter((label, i) => sl.indexOf(label) !== i)])].sort();
+        if (!dupes.length && this.R === wantR && this.P === wantP)
+            return;
+        const detail = [`${this.mode}-${this.k} ${this.taskId}: R=${this.R} (want ${wantR}), P=${this.P} (want ${wantP})`, `  rollouts: ${rl.join(', ') || '(none)'}`, `  sessions: ${sl.join(', ') || '(none)'}`];
+        if (dupes.length)
+            detail.push(`  DUPLICATE labels: ${dupes.join(', ')} -- two stages wrote the same run id and one overwrote the other`);
+        throw new BudgetError(detail.join('\n'));
+    }
+    toRecord() {
+        return {
+            mode: this.mode,
+            taskId: this.taskId,
+            k: this.k,
+            R: this.R,
+            expectedR: expectedRollouts(this.k),
+            P: this.P,
+            expectedP: expectedSessions(this.k),
+            sessionAttempts: this.entries.filter((entry) => entry.kind === 'session').reduce((sum, entry) => sum + entry.attempts, 0),
+            usd: this.usd(),
+            rolloutUsd: this.usd('rollout'),
+            sessionUsd: this.usd('session'),
+            rollouts: this.labels('rollout'),
+            sessions: this.labels('session')
+        };
+    }
+}

package/dist/sdk/refine/library.d.ts

@@ -0,0 +1,55 @@
+import { type SurfaceSpec, type Variant } from "../variant/surface.js";
+export interface Experience {
+    cue: string;
+    lesson: string;
+    evidence: string;
+    confidence?: string;
+    /** The edit-by-edit record the lesson rests on. */
+    edits?: string;
+}
+export declare function hasExperience(experience: Partial<Experience> | null | undefined): experience is Experience;
+/** One folder name for a task or area: separators collapse, nothing escapes. */
+export declare function slug(text: string): string;
+export interface LibraryEntry {
+    task: string;
+    label: string;
+    runId: string;
+    cue: string | null;
+    inventory: string;
+}
+export declare function libraryRoot(root: string): string;
+export declare class Library {
+    readonly root: string;
+    readonly scope: string;
+    readonly area: string;
+    readonly surface: SurfaceSpec;
+    constructor(root: string, scope: string, area?: string, surface?: SurfaceSpec);
+    get dir(): string;
+    get index(): string;
+    entryDir(task: string): string;
+    /** The folder handed to an improver, or null when nothing has been learned here yet. */
+    contextDir(): string | null;
+    entries(): string[];
+    variantOf(task: string): Variant;
+    experienceText(task: string): string | null;
+    list(): LibraryEntry[];
+    /** Drops these tasks' entries and rebuilds the index; unknown tasks are ignored. */
+    forget(tasks: readonly string[]): void;
+    /**
+     * Stores one adopted harness and why it was adopted, then rebuilds the index. Nothing is
+     * stored without a supported lesson. Returns the entry folder, or null.
+     */
+    add(task: string, variant: Variant, input: {
+        why?: string;
+        label?: string;
+        runId?: string;
+        experience?: Partial<Experience> | null;
+    }): string | null;
+    rebuildIndex(): string;
+}
+/** A one-line census of the components in a variant. */
+export declare function inventory(surface: SurfaceSpec, variant: Variant): string;
+/** Every scope that has a library. */
+export declare function libraryScopes(root: string): string[];
+/** Every area a scope has entries in. */
+export declare function libraryAreas(root: string, scope: string): string[];

package/dist/sdk/refine/library.js

@@ -0,0 +1,177 @@
+// The experience library: what earlier refinements in one scope and area adopted, and why.
+// Read by improvers before each task, appended after it. The whole variant is carried, never a
+// summary.
+//
+//   <data>/library/<scope>/<area>/INDEX.md
+//   <data>/library/<scope>/<area>/variants/<task>/variant/<rel>   the full adopted variant
+//   <data>/library/<scope>/<area>/variants/<task>/EXPERIENCE.md   why it was picked, and the lesson
+//
+// Ported from Harness² (Apache-2.0, Google LLC; `harness2/core/library.py`).
+import { existsSync, mkdirSync, readdirSync, readFileSync, rmSync, writeFileSync } from 'node:fs';
+import { join } from 'node:path';
+import { safeId } from "../core/fs.js";
+import { PI_SURFACE } from "../variant/surface.js";
+import { alwaysOnText, pluginNames, readVariant, skillNames, subagentNames, writeVariant } from "../variant/variant.js";
+import { patterns } from "../variant/surface.js";
+import { assertVariantHasNoGraderVerdicts } from "./evidence.js";
+export function hasExperience(experience) {
+    return Boolean(experience) && ['cue', 'lesson', 'evidence'].every((key) => typeof experience[key] === 'string' && experience[key].trim().length > 0);
+}
+/** One folder name for a task or area: separators collapse, nothing escapes. */
+export function slug(text) {
+    return text.replace(/\s*[/\\]\s*/g, '__').replace(/[^A-Za-z0-9_.\-]/g, '_').replace(/^\.+/, '_').slice(0, 120).trim() || 'unknown';
+}
+export function libraryRoot(root) {
+    return join(root, 'library');
+}
+export class Library {
+    root;
+    scope;
+    area;
+    surface;
+    constructor(root, scope, area = scope, surface = PI_SURFACE) {
+        this.root = root;
+        this.scope = scope;
+        this.area = area;
+        this.surface = surface;
+        safeId(scope);
+    }
+    get dir() {
+        return join(libraryRoot(this.root), this.scope, slug(this.area));
+    }
+    get index() {
+        return join(this.dir, 'INDEX.md');
+    }
+    entryDir(task) {
+        return join(this.dir, 'variants', slug(task));
+    }
+    /** The folder handed to an improver, or null when nothing has been learned here yet. */
+    contextDir() {
+        return existsSync(this.index) && this.entries().length ? this.dir : null;
+    }
+    entries() {
+        const dir = join(this.dir, 'variants');
+        try {
+            return readdirSync(dir, { withFileTypes: true }).filter((entry) => entry.isDirectory() && existsSync(join(dir, entry.name, 'EXPERIENCE.md'))).map((entry) => entry.name).sort();
+        }
+        catch {
+            return [];
+        }
+    }
+    variantOf(task) {
+        return readVariant(this.surface, join(this.entryDir(task), 'variant'));
+    }
+    experienceText(task) {
+        try {
+            return readFileSync(join(this.entryDir(task), 'EXPERIENCE.md'), 'utf8');
+        }
+        catch {
+            return null;
+        }
+    }
+    list() {
+        return this.entries().map((name) => {
+            const text = readFileSync(join(this.dir, 'variants', name, 'EXPERIENCE.md'), 'utf8');
+            return {
+                task: name,
+                label: /^- adopted: `([^`]+)`/m.exec(text)?.[1] ?? '',
+                runId: /\(run `([^`]+)`\)/.exec(text)?.[1] ?? '',
+                cue: field(text, 'cue'),
+                inventory: inventory(this.surface, this.variantOf(name))
+            };
+        });
+    }
+    /** Drops these tasks' entries and rebuilds the index; unknown tasks are ignored. */
+    forget(tasks) {
+        let removed = false;
+        for (const task of tasks) {
+            const dir = this.entryDir(task);
+            if (existsSync(dir)) {
+                rmSync(dir, { recursive: true, force: true });
+                removed = true;
+            }
+        }
+        if (removed)
+            this.rebuildIndex();
+    }
+    /**
+     * Stores one adopted harness and why it was adopted, then rebuilds the index. Nothing is
+     * stored without a supported lesson. Returns the entry folder, or null.
+     */
+    add(task, variant, input) {
+        const experience = input.experience;
+        if (!hasExperience(experience))
+            return null;
+        assertVariantHasNoGraderVerdicts(variant);
+        assertVariantHasNoGraderVerdicts({ 'EXPERIENCE.md': JSON.stringify(experience) + (input.why ?? '') });
+        const dir = this.entryDir(task);
+        rmSync(join(dir, 'variant'), { recursive: true, force: true });
+        writeVariant(this.surface, variant, join(dir, 'variant'), { stubs: false });
+        const lines = [`# ${task}`, '', `- adopted: \`${input.label ?? ''}\`${input.runId ? `  (run \`${input.runId}\`)` : ''}`, `- components: ${inventory(this.surface, variant)}`, ''];
+        if (input.why?.trim())
+            lines.push('## Why this was chosen', input.why.trim(), '');
+        if (experience.edits?.trim())
+            lines.push('## What each edit did', experience.edits.trim(), '');
+        lines.push('## Transferable lesson');
+        for (const key of ['cue', 'lesson', 'evidence', 'confidence'])
+            if (experience[key])
+                lines.push(`- **${key}**: ${String(experience[key]).trim()}`);
+        lines.push('');
+        mkdirSync(dir, { recursive: true });
+        writeFileSync(join(dir, 'EXPERIENCE.md'), lines.join('\n'));
+        this.rebuildIndex();
+        return dir;
+    }
+    rebuildIndex() {
+        const rows = [`# Library — ${this.area}`, '', 'Each entry is an earlier task in THIS area whose harness was chosen, stored with its FULL component variant and why it was picked. Browse this index, then open the entries that look relevant to the matter in front of you.', ''];
+        const names = this.entries();
+        if (!names.length)
+            rows.push('_(empty — this is the first task in this area)_');
+        for (const name of names) {
+            const cue = field(readFileSync(join(this.dir, 'variants', name, 'EXPERIENCE.md'), 'utf8'), 'cue');
+            rows.push(`## \`variants/${name}/\``, `- variant: \`variants/${name}/variant/\` — ${inventory(this.surface, this.variantOf(name))}`, `- why:     \`variants/${name}/EXPERIENCE.md\``);
+            if (cue)
+                rows.push(`- cue:     ${cue}`);
+            rows.push('');
+        }
+        mkdirSync(this.dir, { recursive: true });
+        writeFileSync(this.index, rows.join('\n'));
+        return this.index;
+    }
+}
+/** A one-line census of the components in a variant. */
+export function inventory(surface, variant) {
+    const scripts = Object.keys(variant).filter((rel) => patterns(surface).script.test(rel)).length;
+    const counts = [
+        ['skills', skillNames(surface, variant).length],
+        ['sub_agents', subagentNames(surface, variant).length],
+        ['scripts', scripts],
+        ['plugins', pluginNames(surface, variant).length]
+    ];
+    const bits = counts.filter(([, n]) => n).map(([name, n]) => `${n} ${name}`);
+    return `${bits.length ? bits.join(', ') : 'always-on edits only'}; ${alwaysOnText(surface, variant).length.toLocaleString('en-US')} always-on chars`;
+}
+function field(text, name) {
+    for (const line of text.split('\n'))
+        if (line.startsWith(`- **${name}**:`))
+            return line.split(':').slice(1).join(':').trim();
+    return null;
+}
+/** Every scope that has a library. */
+export function libraryScopes(root) {
+    try {
+        return readdirSync(libraryRoot(root), { withFileTypes: true }).filter((entry) => entry.isDirectory()).map((entry) => entry.name).sort();
+    }
+    catch {
+        return [];
+    }
+}
+/** Every area a scope has entries in. */
+export function libraryAreas(root, scope) {
+    try {
+        return readdirSync(join(libraryRoot(root), safeId(scope)), { withFileTypes: true }).filter((entry) => entry.isDirectory()).map((entry) => entry.name).sort();
+    }
+    catch {
+        return [];
+    }
+}

package/dist/sdk/refine/pi.d.ts

@@ -0,0 +1,72 @@
+import type { RunRegistry } from "../sessions/registry.js";
+import type { Effort } from "../sessions/runner.js";
+import type { SessionRunInput } from "../sessions/sessions.js";
+import { type RefineHost } from "./host.js";
+import { type Executor, type Improver, type ImproverCall, type ImproverReply, type RefineTask, type Rollout } from "./types.js";
+/** What the Pi executor and improver need of the harness. */
+export interface RefineRuntime {
+    root: () => string;
+    runs: RunRegistry;
+    run: (input: SessionRunInput) => Promise<{
+        runId: string;
+        nativeSessionId: string | null;
+    }>;
+}
+/** Triggers that mark refinement's own runs; a tool policy can tell them apart. */
+export declare const PROBE_TRIGGER = "probe";
+export declare const IMPROVER_TRIGGER = "improver";
+/** How a session built on the improver differs from refinement's own improver. */
+export interface ImproverRole {
+    /** The run's trigger; refinement's improver is `improver`. */
+    trigger?: string;
+    /** The one identity section the session gets. */
+    identity?: string;
+    /** Its file tools; refinement's improver may also edit and write. */
+    tools?: string[];
+}
+/** Resolves when a run has settled, with its final status. Interrupts it when `signal` aborts. */
+export declare function settled(runtime: RefineRuntime, runId: string, signal?: AbortSignal, timeoutMs?: number): Promise<string>;
+/** The folder, inside a rollout's record, that holds its retained workspace. */
+export declare const RETAINED_WORKSPACE = "workspace";
+export interface ExecutorOptions {
+    /** Copy each execution's workspace into its record before the host cleans it up (PROP-0002). */
+    retainWorkspaces?: boolean;
+    /** Model, effort and account for executions when the host's session settings name none (PROP-0003). */
+    settings?: ImproverSettings;
+}
+/** Runs each execution as a probe session in a workspace the host prepared. */
+export declare class PiExecutor implements Executor {
+    private readonly runtime;
+    private readonly host;
+    private readonly refineId;
+    private readonly dir;
+    private readonly signal?;
+    private readonly options;
+    constructor(runtime: RefineRuntime, host: RefineHost, refineId: string, dir: string, signal?: AbortSignal | undefined, options?: ExecutorOptions);
+    execute(task: RefineTask, variantDir: string | null, label: string, runId: string): Promise<Rollout>;
+    trajectory(rollout: Rollout, options: {
+        obsTrunc: number;
+    }): string;
+    deliverableFiles(rollout: Rollout): Record<string, string>;
+}
+export interface ImproverSettings {
+    model?: string | null;
+    effort?: Effort | null;
+    accountId?: string | null;
+    poolId?: string | null;
+}
+/**
+ * Runs an improver, selector or reflector session in a temporary folder that holds only the
+ * evidence (`context/`). It has file tools and nothing else: no network, no connected apps, no
+ * application tools, no subagents. A reply is cached by its mission and evidence, so resuming
+ * a refinement does not pay twice.
+ */
+export declare class PiImprover implements Improver {
+    private readonly runtime;
+    private readonly dir;
+    private readonly settings;
+    private readonly signal?;
+    private readonly role;
+    constructor(runtime: RefineRuntime, dir: string, settings?: ImproverSettings, signal?: AbortSignal | undefined, role?: ImproverRole);
+    call(input: ImproverCall): Promise<ImproverReply>;
+}

package/dist/sdk/refine/pi.js

@@ -0,0 +1,248 @@
+// The Pi-backed executor and improver: refinement's executions and improver sessions are
+// ordinary harness sessions, recorded as runs like any other, marked by their trigger.
+import { createHash, randomUUID } from 'node:crypto';
+import { cpSync, existsSync, mkdirSync, mkdtempSync, readFileSync, rmSync, writeFileSync } from 'node:fs';
+import { tmpdir } from 'node:os';
+import { dirname, join } from 'node:path';
+import { readJsonOr, writeJson } from "../core/fs.js";
+import { isActiveStatus } from "../sessions/contracts.js";
+import { findRun, readEvents } from "../sessions/runStore.js";
+import { defaultDeliverable } from "./host.js";
+import { costOf, finalText, renderEvents } from "./trajectory.js";
+import { ImproverError } from "./types.js";
+/** Triggers that mark refinement's own runs; a tool policy can tell them apart. */
+export const PROBE_TRIGGER = 'probe';
+export const IMPROVER_TRIGGER = 'improver';
+const IMPROVER_IDENTITY = 'You improve the harness an autonomous agent runs with, from evidence of how it ran. Work only inside the current folder: the evidence is under `context/`. Follow the mission in the user message exactly.';
+/** Resolves when a run has settled, with its final status. Interrupts it when `signal` aborts. */
+export function settled(runtime, runId, signal, timeoutMs = 60 * 60_000) {
+    return new Promise((resolve) => {
+        let done = false;
+        const finish = (status) => {
+            if (done)
+                return;
+            done = true;
+            stop();
+            clearTimeout(timer);
+            signal?.removeEventListener('abort', abort);
+            resolve(status);
+        };
+        const stop = runtime.runs.listen((event) => {
+            if (event.runId !== runId)
+                return;
+            if (event.type === 'completed')
+                finish('completed');
+            else if (event.type === 'failed')
+                finish('failed');
+            else if (event.type === 'status.changed' && event.payload.status === 'interrupted')
+                finish('interrupted');
+        });
+        const abort = () => void runtime.runs.interrupt(runId).catch(() => { }).finally(() => finish('interrupted'));
+        signal?.addEventListener('abort', abort, { once: true });
+        const timer = setTimeout(() => void runtime.runs.interrupt(runId).catch(() => { }).finally(() => finish('interrupted')), timeoutMs);
+        timer.unref?.();
+        // It may have settled before the listener was added.
+        const record = findRun(runtime.root(), runId);
+        if (record && !isActiveStatus(record.status) && record.status !== 'queued')
+            finish(record.status);
+        if (signal?.aborted)
+            abort();
+    });
+}
+function events(runtime, runId) {
+    try {
+        return readEvents(runtime.root(), runId);
+    }
+    catch {
+        return [];
+    }
+}
+/** The folder, inside a rollout's record, that holds its retained workspace. */
+export const RETAINED_WORKSPACE = 'workspace';
+/** The host's session settings win; the caller's executor settings fill what the host left out. */
+function withDefaults(session, defaults) {
+    if (!defaults)
+        return session;
+    return {
+        ...session,
+        model: session.model ?? defaults.model ?? null,
+        effort: session.effort ?? defaults.effort ?? null,
+        accountId: session.accountId ?? defaults.accountId ?? null,
+        poolId: session.poolId ?? defaults.poolId ?? null
+    };
+}
+/** Copies a workspace whole, links as links; returns the error instead of throwing. */
+function retain(cwd, into) {
+    try {
+        rmSync(into, { recursive: true, force: true });
+        cpSync(cwd, into, { recursive: true, dereference: false, verbatimSymlinks: true });
+        return '';
+    }
+    catch (error) {
+        return error instanceof Error ? error.message : String(error);
+    }
+}
+/** Runs each execution as a probe session in a workspace the host prepared. */
+export class PiExecutor {
+    runtime;
+    host;
+    refineId;
+    dir;
+    signal;
+    options;
+    constructor(runtime, host, refineId, dir, signal, options = {}) {
+        this.runtime = runtime;
+        this.host = host;
+        this.refineId = refineId;
+        this.dir = dir;
+        this.signal = signal;
+        this.options = options;
+    }
+    async execute(task, variantDir, label, runId) {
+        const started = Date.now();
+        const dir = join(this.dir, 'rollouts', label);
+        rmSync(dir, { recursive: true, force: true });
+        mkdirSync(dir, { recursive: true });
+        const base = { label, runId, dir, costUsd: 0, wallMs: 0 };
+        const workspace = await this.host.prepareWorkspace({ refineId: this.refineId, label, task });
+        try {
+            const settings = withDefaults(await this.host.session({ refineId: this.refineId, label, task }), this.options.settings);
+            await this.runtime.run({
+                run: { id: runId, sessionId: runId, trigger: PROBE_TRIGGER, goal: task.prompt.slice(0, 4000), parentRunId: null, relation: null },
+                accountId: settings.accountId ?? null,
+                poolId: settings.poolId ?? null,
+                model: settings.model ?? null,
+                effort: settings.effort ?? null,
+                cwd: workspace.cwd,
+                sessionDir: join(this.dir, 'sessions', label),
+                text: task.prompt,
+                automatic: true,
+                subagents: { maxDepth: 1 },
+                caller: { ...settings.caller, runId, sessionId: runId },
+                launch: settings.launch,
+                tools: settings.tools,
+                connections: settings.connections,
+                providers: settings.providers,
+                variant: variantDir ? { dir: variantDir, scope: task.scope } : { scope: task.scope }
+            });
+            const status = await settled(this.runtime, runId, this.signal);
+            const recorded = events(this.runtime, runId);
+            const reply = finalText(recorded);
+            const produced = this.host.deliverable ? await this.host.deliverable({ cwd: workspace.cwd, reply, task }) : defaultDeliverable(workspace.cwd, reply, task.sourceDir);
+            for (const [name, text] of Object.entries(produced)) {
+                const path = join(dir, 'deliverables', name);
+                mkdirSync(dirname(path), { recursive: true });
+                writeFileSync(path, text);
+            }
+            writeJson(join(dir, 'rollout.json'), { runId, status, files: Object.keys(produced).sort() });
+            const delivered = Object.keys(produced).length > 0;
+            return { ...base, ok: status === 'completed', delivered, costUsd: costOf(recorded), wallMs: Date.now() - started, error: status === 'completed' ? '' : `run ${status}` };
+        }
+        catch (error) {
+            return { ...base, ok: false, delivered: false, wallMs: Date.now() - started, error: error instanceof Error ? error.message : String(error) };
+        }
+        finally {
+            if (this.options.retainWorkspaces) {
+                const workspaceError = retain(workspace.cwd, join(dir, RETAINED_WORKSPACE));
+                if (workspaceError)
+                    writeJson(join(dir, 'rollout.json'), { ...readJsonOr(join(dir, 'rollout.json'), { runId }), workspaceError });
+            }
+            await workspace.cleanup?.().catch(() => { });
+        }
+    }
+    trajectory(rollout, options) {
+        return renderEvents(events(this.runtime, rollout.runId), { obsTrunc: options.obsTrunc });
+    }
+    deliverableFiles(rollout) {
+        const record = readJsonOr(join(rollout.dir, 'rollout.json'), {});
+        const out = {};
+        for (const name of record.files ?? []) {
+            try {
+                out[name] = readFileSync(join(rollout.dir, 'deliverables', name), 'utf8');
+            }
+            catch {
+                // A file that went missing is simply not shown.
+            }
+        }
+        return out;
+    }
+}
+const IMPROVER_TOOLS = ['read', 'grep', 'find', 'ls', 'edit', 'write'];
+/**
+ * Runs an improver, selector or reflector session in a temporary folder that holds only the
+ * evidence (`context/`). It has file tools and nothing else: no network, no connected apps, no
+ * application tools, no subagents. A reply is cached by its mission and evidence, so resuming
+ * a refinement does not pay twice.
+ */
+export class PiImprover {
+    runtime;
+    dir;
+    settings;
+    signal;
+    role;
+    constructor(runtime, dir, settings = {}, signal, role = {}) {
+        this.runtime = runtime;
+        this.dir = dir;
+        this.settings = settings;
+        this.signal = signal;
+        this.role = role;
+    }
+    async call(input) {
+        const key = createHash('sha1').update(input.label).update('\0').update(input.mission).digest('hex').slice(0, 16);
+        const cacheDir = join(this.dir, 'improver', input.label);
+        const cached = readJsonOr(join(cacheDir, 'reply.json'), null);
+        if (cached?.key === key && cached.text && (!input.harvest || (cached.workspace && existsSync(cached.workspace)))) {
+            return { label: input.label, text: cached.text, costUsd: 0, attempts: 0, cached: true, workspace: cached.workspace ?? null };
+        }
+        const work = mkdtempSync(join(tmpdir(), 'harness-improver-'));
+        const runId = randomUUID();
+        let cost = 0;
+        try {
+            cpSync(input.contextDir, join(work, 'context'), { recursive: true });
+            await this.runtime.run({
+                run: { id: runId, sessionId: runId, trigger: this.role.trigger ?? IMPROVER_TRIGGER, goal: input.label },
+                accountId: this.settings.accountId ?? null,
+                poolId: this.settings.poolId ?? null,
+                model: this.settings.model ?? null,
+                effort: this.settings.effort ?? 'high',
+                cwd: work,
+                sessionDir: join(cacheDir, 'session'),
+                text: input.mission,
+                automatic: true,
+                subagents: null,
+                providers: false,
+                connections: false,
+                harnessTools: false,
+                caller: { runId, sessionId: runId, actor: 'Code' },
+                launch: { sections: [{ id: 'identity', title: 'Identity', body: this.role.identity ?? IMPROVER_IDENTITY, budget: 1000, order: 10 }] },
+                tools: { allow: this.role.tools ?? IMPROVER_TOOLS },
+                variant: null
+            });
+            const status = await settled(this.runtime, runId, input.signal ?? this.signal);
+            const recorded = events(this.runtime, runId);
+            cost = costOf(recorded);
+            const text = finalText(recorded);
+            if (status !== 'completed' || !text.trim())
+                throw new ImproverError(status === 'completed' ? 'empty reply' : `improver run ${status}`, 1, cost);
+            let workspace = null;
+            if (input.harvest) {
+                const from = join(work, input.harvest);
+                if (existsSync(from)) {
+                    workspace = join(cacheDir, 'harvest');
+                    rmSync(workspace, { recursive: true, force: true });
+                    cpSync(from, workspace, { recursive: true });
+                }
+            }
+            writeJson(join(cacheDir, 'reply.json'), { key, text, costUsd: cost, workspace, runId });
+            return { label: input.label, text, costUsd: cost, attempts: 1, cached: false, workspace };
+        }
+        catch (error) {
+            if (error instanceof ImproverError)
+                throw error;
+            throw new ImproverError(error instanceof Error ? error.message : String(error), 1, cost);
+        }
+        finally {
+            rmSync(work, { recursive: true, force: true });
+        }
+    }
+}