@mikenguyen69/harness 0.1.0-beta.1

package/dist/internal/orchestration/prompts/index.js

@@ -0,0 +1,199 @@
+function criteriaBlock(b) {
+    return b.acceptanceCriteria
+        .map((c, i) => {
+        const how = c.verifier
+            ? `verifier: ${c.verifier}`
+            : `manual: ${c.manual ?? "(unspecified)"}`;
+        return `  ${i + 1}. ${c.statement}\n     (${how})`;
+    })
+        .join("\n");
+}
+function factsBlock(b) {
+    const f = b.mergeFacts;
+    const on = Object.entries({
+        door: f.door,
+        "adds-dependency": f.addsDependency,
+        "schema-change": f.schemaChange,
+        security: f.security,
+        "gate-external": f.gateExternal,
+        "artifact-producer-change": f.artifactProducerChange,
+    })
+        .filter(([, v]) => v)
+        .map(([k, v]) => (v === true ? k : `${k}=${String(v)}`));
+    return on.length ? on.join(", ") : "none declared";
+}
+function retryBlock(retry) {
+    if (!retry)
+        return "";
+    return `
+
+## RETRY (attempt ${retry.attempt}) — the previous attempt failed at: ${retry.source}
+
+The branch ALREADY carries the previous attempt(s)' committed work — it was not
+thrown away. Orient before doing anything else:
+  1. \`git log --oneline <base-branch>..HEAD\` and \`git diff --stat <base-branch>\`
+     — see what is already implemented and committed.
+  2. Re-read only the acceptance criteria the feedback below implicates.
+
+Then work IN PLACE on the same branch and fix EXACTLY what the feedback says.
+Do NOT reset or start over, do NOT re-audit criteria that already pass, and do
+NOT re-explore the whole codebase from scratch — a retry is a targeted fix, not
+a fresh implementation.
+
+\`\`\`
+${retry.evidence.trim()}
+\`\`\`
+`;
+}
+/**
+ * Implementer: make the change and stay in scope. The orchestrator runs the
+ * authoritative harness verification after the session; letting an agent run
+ * a bare verify can append a second envelope with inferred, incorrect identity.
+ */
+export function renderImplementerPrompt(b, retry) {
+    return `You are the IMPLEMENTER for unit ${b.unitId}${b.component ? ` (component: ${b.component})` : ""}.
+
+## You are inside an already-running harness orchestrator
+This session was dispatched by \`orchestrate run\` (orchestration-harness). You are
+a nested worker for ONE unit — not the DAG driver. The briefing below is the
+source of truth for this turn.
+
+Do NOT open, follow, or invoke external orchestrate / unit / loop skills (for
+example \`~/.claude/skills/orchestrate\`, wfo \`unit\` CLI workflows, or Cursor
+\`/orchestrate\`). Do NOT claim units, open review PRs, merge, or advance other
+units — the outer orchestrator owns claim → verify → land → next.
+
+If repo conventions are unclear, prefer \`AGENTS.md\` in this workspace over any
+personal skill.
+
+## Intent
+${b.intent}
+
+## Acceptance criteria — implement to ALL of these
+${criteriaBlock(b)}
+
+## Scope — you may ONLY touch these paths
+${b.scope.map((s) => `  - ${s}`).join("\n")}
+
+A write outside this scope halts the unit. If the scope is too narrow to satisfy
+the intent, STOP and run \`agent-harness escalate --reason "<why>" --wants "widen scope"\`
+rather than working around it.
+
+## Branch
+Work on \`${b.branch}\` (already checked out). Commit with a \`Unit: ${b.unitId}\` trailer.
+
+## Declared merge facts (informational — the orchestrator passes these to \`harness merge\`)
+${factsBlock(b)}
+
+## Definition of done
+Implement every acceptance criterion, run any relevant ordinary project tests or
+build checks, and commit the result. Do NOT run \`harness verify\`, \`harness merge\`,
+\`harness claim\`, \`harness next\`, or other harness state-changing commands. The
+orchestrator runs authoritative verification after your session. Do not stop until
+the project checks pass or you have escalated.${retryBlock(retry)}
+`;
+}
+/**
+ * Verifier: review the rebased diff against the acceptance criteria. READ-ONLY —
+ * the runner denies all write tools; a verifier that writes voids its verdict.
+ * Ends with a single machine-readable verdict line.
+ */
+export function renderVerifierPrompt(b, diff, envelopeRef) {
+    return `You are the VERIFIER for unit ${b.unitId}. You are READ-ONLY: you have no
+write tools. Do not attempt to modify the tree — inspect and judge only.
+
+Do NOT start servers, daemons, watchers, or any process that does not exit on
+its own (e.g. \`harness board serve\`, \`npm run dev\`). Judge behaviour from the
+code and from the unit's own test suite (\`npm test\`, which exits). If a
+criterion genuinely needs a long-running process, launch it with a hard
+timeout and kill it before you finish — a process you leave running hangs the
+orchestrator on this step.
+
+## You are inside an already-running harness orchestrator
+This session was dispatched by \`orchestrate run\`. Judge only this unit's diff
+against the criteria below. Do NOT follow external orchestrate / unit / loop
+skills, and do not drive the DAG, open PRs, or merge.
+
+## Intent
+${b.intent}
+
+## Acceptance criteria — the review spec, judge the diff against EACH
+${criteriaBlock(b)}
+${envelopeRef ? `\n## Verify envelope\n${envelopeRef}\n` : ""}
+## The change under review (rebased onto the base branch)
+\`\`\`diff
+${diff.trim() || "(empty diff)"}
+\`\`\`
+
+## Your task
+For each acceptance criterion, decide whether the diff satisfies it and say why.
+Then emit EXACTLY ONE final line, nothing after it:
+
+  VERDICT: APPROVE
+or
+  VERDICT: REJECT — <comma-separated reasons, each tied to a criterion>
+
+Reject if any criterion is unmet, if the change exceeds the stated scope, or if
+the tests do not actually exercise the new behaviour.
+`;
+}
+/**
+ * Terse follow-up for a RESUMED implementer session (cursor-agent --resume) —
+ * the session already holds the full briefing and its own prior work; it only
+ * needs the failure and a reminder to stay narrow.
+ */
+export function renderRetryFollowup(retry) {
+    return `RETRY (attempt ${retry.attempt}). Your previous attempt failed at: ${retry.source}.
+
+The branch is unchanged and still carries your commits — do NOT reset. Fix
+EXACTLY the following, in place, then stop. Do not re-audit criteria that
+already pass, do not re-explore the codebase.
+
+\`\`\`
+${retry.evidence.trim()}
+\`\`\`
+`;
+}
+/**
+ * Follow-up for a RESUMED verifier session — it holds its prior criterion-by-
+ * criterion analysis; a new implement attempt has landed, so re-judge against
+ * the updated diff and re-emit the verdict line.
+ */
+export function renderReviewFollowup(diff) {
+    return `RE-REVIEW: a new implement attempt landed since your last verdict. The
+updated diff (rebased onto the base branch) follows. Re-judge each acceptance
+criterion — reuse your prior analysis for parts that did not change — then emit
+EXACTLY ONE final line: \`VERDICT: APPROVE\` or \`VERDICT: REJECT — <reasons>\`.
+
+\`\`\`diff
+${diff.trim() || "(empty diff)"}
+\`\`\`
+`;
+}
+/** Parse the verifier's final `VERDICT:` line. Absent / malformed → reject. */
+export function parseVerdict(text) {
+    // Strip leading markdown emphasis / quote / list / heading markers and
+    // surrounding `**`/`__`/backticks — agents routinely bold the verdict line
+    // (`**VERDICT: APPROVE**`), and a strict `startsWith("VERDICT:")` would then
+    // miss it and reject a genuine pass.
+    const line = text
+        .split("\n")
+        .map((l) => l.trim().replace(/^[>*_#`\s-]+/, "").replace(/[*_`]+$/, "").trim())
+        .filter((l) => l.toUpperCase().startsWith("VERDICT:"))
+        .at(-1);
+    if (!line) {
+        return { approved: false, reasons: ["no VERDICT line in the verifier output"] };
+    }
+    const body = line.slice(line.indexOf(":") + 1).trim();
+    if (/^APPROVE\b/i.test(body))
+        return { approved: true, reasons: [] };
+    const dash = body.search(/[—-]/);
+    const reasonText = dash >= 0 ? body.slice(dash + 1).trim() : "";
+    return {
+        approved: false,
+        reasons: reasonText
+            ? reasonText.split(",").map((r) => r.trim()).filter(Boolean)
+            : ["verifier rejected without stated reasons"],
+    };
+}
+//# sourceMappingURL=index.js.map

package/dist/internal/orchestration/report/index.js

@@ -0,0 +1,125 @@
+const esc = (s) => String(s).replace(/[&<>]/g, (c) => ({ "&": "&amp;", "<": "&lt;", ">": "&gt;" })[c]);
+function laneRow(l) {
+    const outcome = l.settled
+        ? l.step === "land"
+            ? "merged"
+            : "settled"
+        : "in-flight";
+    const prov = [
+        l.envelopeHash
+            ? `<span class="dim">env</span> <code>${esc(l.envelopeHash.slice(0, 12))}…</code>`
+            : "",
+        l.doorId ? `<span class="chip warn">door ${esc(l.doorId)}</span>` : "",
+    ]
+        .filter(Boolean)
+        .join(" ") || `<span class="dim">—</span>`;
+    return `<tr>
+    <td><code>${esc(l.unitId)}</code></td>
+    <td>${esc(outcome)} <span class="dim">(${esc(l.step)})</span></td>
+    <td>${esc(l.attempt)}</td>
+    <td>$${l.cost.toFixed(4)}</td>
+    <td><span class="chip">${esc(l.runner)}</span> ${esc(l.model)}</td>
+    <td class="dim">${esc(l.emitter)}</td>
+    <td>${prov}</td>
+  </tr>`;
+}
+function findingRow(f) {
+    return `<tr>
+    <td><code>${esc(f.id)}</code></td>
+    <td><code>${esc(f.unitId)}</code></td>
+    <td><span class="chip ${f.severity === "action" ? "warn" : ""}">${esc(f.severity)}</span></td>
+    <td>${esc(f.evidence.length)}</td>
+  </tr>`;
+}
+/** Only rendered when `analysis` has something to show — a single-run report
+ * has no "insufficient data" state to represent, unlike a board panel. */
+function analysisSection(analysis) {
+    if (!analysis || (analysis.units.length === 0 && analysis.findings.length === 0))
+        return "";
+    const table = analysis.findings.length
+        ? `<table>
+        <thead><tr><th>rule</th><th>unit</th><th>severity</th><th>evidence</th></tr></thead>
+        <tbody>${analysis.findings.map(findingRow).join("")}</tbody>
+       </table>`
+        : `<div class="dim">no findings</div>`;
+    return `\n<h2>Analysis</h2>\n<div class="panel">${table}</div>\n`;
+}
+export function renderRunReport(state, analysis) {
+    const json = JSON.stringify(state, null, 2).replace(/</g, "\\u003c");
+    const totalCost = state.lanes.reduce((s, l) => s + l.cost, 0);
+    const dur = state.heartbeatAt && state.startedAt
+        ? `${Math.max(0, Math.round((state.heartbeatAt - state.startedAt) / 1000))}s`
+        : "—";
+    const lanes = state.lanes.length
+        ? `<table>
+        <thead><tr><th>unit</th><th>outcome</th><th>attempts</th><th>cost</th><th>runner / model</th><th>telemetry</th><th>provenance</th></tr></thead>
+        <tbody>${state.lanes.map(laneRow).join("")}</tbody>
+       </table>`
+        : `<div class="dim">no lanes ran</div>`;
+    const needsYou = state.needsYou.length
+        ? `<ul>${state.needsYou
+            .map((n) => `<li><span class="chip warn">${esc(n.kind)}</span> ${esc(n.unitId ?? "")} — ${esc(n.message)}<br><code>${esc(n.unblock)}</code></li>`)
+            .join("")}</ul>`
+        : `<div class="dim">none — the run needs nothing from you</div>`;
+    const parked = state.parked.length
+        ? state.parked.map((p) => `<span class="chip">${esc(p.unitId)} · ${esc(p.reason)}</span>`).join(" ")
+        : `<span class="dim">none</span>`;
+    const notes = state.notes.length
+        ? `<ul>${state.notes.map((n) => `<li><code>${esc(n.unitId)}</code> — ${esc(n.note)}</li>`).join("")}</ul>`
+        : `<div class="dim">none</div>`;
+    return `<!doctype html>
+<html lang="en"><head><meta charset="utf-8"><title>orchestrate run — ${esc(state.systemId || "run")}</title>
+<style>
+  :root{color-scheme:light dark}
+  body{font:14px/1.5 ui-sans-serif,system-ui,sans-serif;margin:0;padding:24px;background:#0e1216;color:#e5e9ee}
+  h1{font-size:1.3rem;margin:0 0 4px} h2{font-size:.8rem;letter-spacing:.08em;text-transform:uppercase;color:#9aa4b1;margin:22px 0 10px}
+  .sub{color:#9aa4b1;margin-bottom:18px;font-size:.85rem}
+  .panel{border:1px solid #2a333d;border-radius:10px;background:#161c22;padding:14px 16px;margin-bottom:14px}
+  .counts{display:flex;flex-wrap:wrap;gap:8px}
+  .stat{border:1px solid #2a333d;border-radius:8px;background:#12181e;padding:8px 12px}
+  .stat b{display:block;font-size:1.2rem}
+  table{border-collapse:collapse;width:100%} th,td{text-align:left;padding:6px 10px;border-bottom:1px solid #222a33;font-size:.85rem}
+  th{color:#9aa4b1;font-weight:600;text-transform:uppercase;font-size:.7rem;letter-spacing:.06em}
+  code{font-family:ui-monospace,monospace;font-size:.82em;color:#5bb8d4}
+  .dim{color:#6b7583} .chip{display:inline-block;font-family:ui-monospace,monospace;font-size:.72rem;border:1px solid #3b4653;border-radius:99px;padding:1px 7px}
+  .chip.warn{border-color:#7a5b2e;color:#e0b062}
+  .outcome{font-size:1rem;padding:2px 10px;border-radius:6px}
+  .outcome.completed{background:#1c3323;color:#7fdca0} .outcome.halted{background:#3a2626;color:#e79a9a} .outcome.crashed{background:#3a2626;color:#e79a9a}
+</style></head>
+<body>
+<h1>orchestrate run</h1>
+<div class="sub">
+  system <code>${esc(state.systemId || "—")}</code> ·
+  run <code>${esc(state.runId || "—")}</code> ·
+  machine <code>${esc(state.machineId || "—")}</code> ·
+  spec <code>${esc(state.specRef || "—")}</code> ·
+  ${dur} ·
+  <span class="outcome ${esc(state.outcome ?? "crashed")}">${esc(state.outcome ?? "crashed (no terminal frame)")}</span>
+</div>
+
+<div class="panel counts">
+  <div class="stat"><b>${state.counts.merged}</b>merged / ${state.dagSize}</div>
+  <div class="stat"><b>${state.counts.escalated}</b>escalated</div>
+  <div class="stat"><b>${state.counts.parked}</b>parked</div>
+  <div class="stat"><b>${state.counts.inFlight}</b>in-flight</div>
+  <div class="stat"><b>${state.counts.needsYou}</b>needs you</div>
+  <div class="stat"><b>$${totalCost.toFixed(4)}</b>run cost</div>
+</div>
+
+<h2>Lanes</h2>
+<div class="panel">${lanes}</div>
+
+<h2>Needs you</h2>
+<div class="panel">${needsYou}</div>
+
+<h2>Parked</h2>
+<div class="panel">${parked}</div>
+
+<h2>Notes</h2>
+<div class="panel">${notes}</div>
+${analysisSection(analysis)}
+<script id="runstate" type="application/json">${json}</script>
+</body></html>
+`;
+}
+//# sourceMappingURL=index.js.map

package/dist/internal/orchestration/routes/index.js

@@ -0,0 +1,85 @@
+/**
+ * routes — reads the routing decision for a unit. Routing *policy* (which
+ * model / config / mode / runner a unit gets) lives in agent-harness's
+ * `resolveRoute` (routes.toml). This product only reads the decision and obeys
+ * it (mission: "Routing policy … is out of scope — permanently").
+ *
+ * The real source is `agent-harness route <unit-id> --profile <p> --json →
+ * {runner, model, config, mode, until}` (AH P7.0). Portfolio rule 1 forbids
+ * importing `resolveRoute` across `repos/`, so `CliRouteSource` shells the
+ * subcommand. The dry loop (M1) still runs against `FakeRouteSource`; M2 wires
+ * `CliRouteSource` into the real run.
+ *
+ * `agent-harness route`'s `mode` is `standard | propose-only`; this product's
+ * `Policy.mode` is `auto | propose-only` — `standard` maps to `auto`. Until AH
+ * P7.1 adds a `runner` field, the CLI always reports `runner: "claude"`.
+ */
+import { callProcess } from "../harness/cli.js";
+const DEFAULT_POLICY = {
+    runner: "claude",
+    model: "claude-sonnet-5",
+    mode: "auto",
+};
+/** Map the CLI's `{runner, model, config, mode, until}` onto this product's `Policy`. */
+export function mapRouteCliOutput(out) {
+    const policy = {
+        runner: out.runner || "claude",
+        model: out.model,
+        mode: out.mode === "propose-only" ? "propose-only" : "auto",
+    };
+    if (out.config !== undefined)
+        policy.config = { preset: out.config };
+    if (out.until !== undefined)
+        policy.until = out.until;
+    return policy;
+}
+/**
+ * Reads routing by shelling `agent-harness route` — the only legal consumption
+ * path (portfolio rule 1). One process per unit; the loop resolves each unit
+ * once at plan time.
+ */
+export class CliRouteSource {
+    opts;
+    constructor(opts) {
+        this.opts = opts;
+    }
+    async resolve(unitId, component) {
+        const profile = this.opts.profileForComponent(component);
+        if (!profile) {
+            throw new Error(`CliRouteSource: no profile for ${unitId} (component ${component ?? "?"}) — is it declared in system.toml?`);
+        }
+        const args = [
+            "route",
+            unitId,
+            "--profile",
+            profile,
+            "--json",
+            ...(this.opts.routesPath ? ["--routes", this.opts.routesPath] : []),
+            ...(this.opts.ledgerDir ? ["--ledger", this.opts.ledgerDir] : []),
+        ];
+        const result = await (this.opts.processCall ?? callProcess)({
+            command: this.opts.bin,
+            args: [...(this.opts.binArgs ?? []), ...args],
+            cwd: this.opts.cwd,
+        });
+        if (result.code !== 0) {
+            throw new Error(`agent-harness route ${unitId} failed (exit ${result.code}): ${(result.stderr || result.stdout).trim()}`);
+        }
+        return mapRouteCliOutput(JSON.parse(result.stdout));
+    }
+}
+export class FakeRouteSource {
+    base;
+    overrides = new Map();
+    constructor(base = DEFAULT_POLICY) {
+        this.base = base;
+    }
+    set(unitId, policy) {
+        this.overrides.set(unitId, policy);
+        return this;
+    }
+    async resolve(unitId, _component) {
+        return { ...this.base, ...this.overrides.get(unitId) };
+    }
+}
+//# sourceMappingURL=index.js.map

package/dist/internal/orchestration/run/index.js

@@ -0,0 +1,221 @@
+/**
+ * run — assembles a real `LoopDeps` from a driven repo + `orchestration.json`,
+ * wiring the CLI-backed implementations: `CliHarness` (harness), `CliRouteSource`
+ * (agent-harness route), `ShellGit`, `LocalForge` / `GithubForge`, and one
+ * `ClaudeRunner` per enabled `claude` runner. This is the seam between the pure
+ * loop and the outside world; `orchestrate run` is a thin shell over it.
+ */
+import { existsSync, readFileSync } from "node:fs";
+import { hostname } from "node:os";
+import { basename, dirname, join, resolve } from "node:path";
+import { parse as parseToml } from "smol-toml";
+import { loadOrchestrationConfig } from "../config/index.js";
+import { LocalForge, GithubForge } from "../forge/index.js";
+import { ShellGit } from "../git/index.js";
+import { CliHarness, resolveCommandSpec } from "../harness/cli.js";
+import { ActivityLogWriter } from "../activity/index.js";
+import { CliRouteSource } from "../routes/index.js";
+import { RunLog } from "../runstate/index.js";
+import { CliRunPublisher } from "../runstate/publish.js";
+import { ClaudeRunner } from "../runners/claude/index.js";
+import { CodexRunner } from "../runners/codex/index.js";
+import { CursorRunner } from "../runners/cursor/index.js";
+import { GitWorktreeManager } from "../worktree/index.js";
+/** component id → absolute root + profile, parsed from Contract C. */
+export function loadComponentDescriptors(systemTomlPath) {
+    const raw = parseToml(readFileSync(systemTomlPath, "utf8"));
+    const out = new Map();
+    for (const c of raw.component ?? []) {
+        if (typeof c.id !== "string" || typeof c.profile !== "string")
+            continue;
+        const declaredRoot = c.root ?? c.repo;
+        if (typeof declaredRoot !== "string")
+            continue;
+        out.set(c.id, {
+            id: c.id,
+            root: resolve(dirname(systemTomlPath), declaredRoot),
+            profile: c.profile,
+        });
+    }
+    return out;
+}
+/** Backward-compatible profile view used by routing. */
+export function loadComponentProfiles(systemTomlPath) {
+    return new Map([...loadComponentDescriptors(systemTomlPath)].map(([id, descriptor]) => [id, descriptor.profile]));
+}
+export function assembleRun(opts) {
+    const repo = resolve(opts.repo);
+    const runId = `run-${Date.now().toString(36)}`;
+    const assembledAt = Date.now();
+    const systemId = basename(repo);
+    const configPath = opts.configPath ?? join(repo, "orchestration.json");
+    const config = loadOrchestrationConfig(configPath);
+    const harnessInput = opts.harnessBin ?? process.env.HARNESS_BIN ?? "harness";
+    const agentHarnessInput = opts.agentHarnessBin ?? process.env.AGENT_HARNESS_BIN ?? "agent-harness";
+    const harnessCommand = opts.harnessBinArgs
+        ? { command: harnessInput, args: opts.harnessBinArgs }
+        : resolveCommandSpec(harnessInput, repo);
+    const agentHarnessCommand = opts.agentHarnessBinArgs
+        ? { command: agentHarnessInput, args: opts.agentHarnessBinArgs }
+        : resolveCommandSpec(agentHarnessInput, repo);
+    const ledgerDir = opts.ledgerDir ?? join(repo, ".harness", "ledger");
+    const specsDir = opts.specsDir ?? join(repo, "specs");
+    // discover the driven project's system.toml — ring-2 target; absent = brownfield.
+    const systemTomlPath = join(repo, "system.toml");
+    const hasSystemToml = existsSync(systemTomlPath);
+    config.systemToml = hasSystemToml ? systemTomlPath : null;
+    const components = hasSystemToml
+        ? loadComponentDescriptors(systemTomlPath)
+        : new Map();
+    const profiles = new Map([...components].map(([id, descriptor]) => [id, descriptor.profile]));
+    const harness = new CliHarness({
+        bin: harnessCommand.command,
+        binArgs: harnessCommand.args,
+        cwd: repo,
+        ledgerDir,
+        specsDir,
+        profilesDir: join(repo, "profiles"),
+        components,
+        systemId,
+        actorId: runId,
+        ...(config.systemToml ? { systemToml: config.systemToml } : {}),
+    });
+    const routes = new CliRouteSource({
+        bin: agentHarnessCommand.command,
+        binArgs: agentHarnessCommand.args,
+        cwd: repo,
+        ...(opts.routesPath ? { routesPath: opts.routesPath } : {}),
+        ledgerDir,
+        profileForComponent: (component) => component ? profiles.get(component) : undefined,
+    });
+    const git = new ShellGit({ cwd: repo });
+    const workspaces = new GitWorktreeManager({
+        controlRepo: repo,
+        root: opts.worktreeRoot ?? join(repo, ".harness", "worktrees"),
+    });
+    const forge = config.forge === "github" ? new GithubForge({ cwd: repo }) : new LocalForge(git);
+    const log = new RunLog();
+    // Retry feedback the loop recorded as `lane.retry` — thread the latest one
+    // back into the next implementer session so it fixes exactly what failed
+    // instead of re-exploring from the plain briefing (analyze/index.ts flagged
+    // this as unwired). The branch already carries the prior attempt's commits.
+    const retryFor = (unitId) => {
+        for (let i = log.all().length - 1; i >= 0; i--) {
+            const e = log.all()[i];
+            if (e.t === "lane.retry" && e.unitId === unitId) {
+                return {
+                    attempt: e.attempt,
+                    source: "verification / review of the previous attempt",
+                    evidence: e.evidence,
+                };
+            }
+        }
+        return undefined;
+    };
+    // Per-run session store: a retry / re-review resumes the prior cursor-agent
+    // conversation (same unit + kind, same model) instead of re-briefing from
+    // scratch. Ids are process-local — they do not survive an `orchestrate run`
+    // restart, and the fallback (fresh session) is always safe.
+    const sessions = new Map();
+    const sessionKey = (unitId, kind) => `${unitId}:${kind}`;
+    const resumeFor = (unitId, kind) => sessions.get(sessionKey(unitId, kind));
+    const recordSession = (unitId, kind, id, model) => {
+        sessions.set(sessionKey(unitId, kind), { id, model });
+    };
+    // one runner per implementation this installation enables. v0 only ships
+    // `claude`; a route to any other enabled name that has no impl here is caught
+    // in step() (config-error halt).
+    const runners = new Map();
+    for (const name of config.runnersEnabled) {
+        if (name === "claude") {
+            runners.set("claude", new ClaudeRunner({
+                cwd: repo,
+                harnessBin: harnessCommand.command,
+                harnessBinArgs: harnessCommand.args,
+                agentHarnessBin: agentHarnessCommand.command,
+                agentHarnessBinArgs: agentHarnessCommand.args,
+                ledgerDir,
+                systemId,
+                sessionPrefix: runId,
+                ...(config.maxRunCost !== undefined
+                    ? { maxRunCost: config.maxRunCost }
+                    : {}),
+                ...(config.maxRunDuration !== undefined
+                    ? { deadlineAt: assembledAt + config.maxRunDuration }
+                    : {}),
+                diffFor: (unitId) => git.diffText(`unit/${unitId}`, config.baseBranch),
+                retryFor,
+            }));
+        }
+        else if (name === "codex") {
+            runners.set("codex", new CodexRunner({
+                cwd: repo,
+                harnessBin: harnessCommand.command,
+                ...(config.maxRunDuration !== undefined
+                    ? { deadlineAt: assembledAt + config.maxRunDuration }
+                    : {}),
+                diffFor: (unitId) => git.diffText(`unit/${unitId}`, config.baseBranch),
+                retryFor,
+            }));
+        }
+        else if (name === "cursor") {
+            runners.set("cursor", new CursorRunner({
+                resumeFor,
+                recordSession,
+                cwd: repo,
+                harnessBin: harnessCommand.command,
+                ...(config.maxRunDuration !== undefined
+                    ? { deadlineAt: assembledAt + config.maxRunDuration }
+                    : {}),
+                ...(opts.watch ? { watchStderr: true } : {}),
+                diffFor: (unitId) => git.diffText(`unit/${unitId}`, config.baseBranch),
+                retryFor,
+            }));
+        }
+    }
+    const machineId = process.env.HARNESS_MACHINE_ID ?? safeHostname();
+    const deps = {
+        harness,
+        routes,
+        runners,
+        git,
+        workspaces,
+        forge,
+        config,
+        log,
+        runId,
+        machineId,
+        ...(opts.onlyPrefix ? { onlyPrefix: opts.onlyPrefix } : {}),
+    };
+    // Capture is on by default and NOT coupled to `--spool` — whether the board
+    // is running has nothing to do with whether the operator wants a durable
+    // record afterwards (plan doc, "Default on/off" — settled).
+    if (opts.activityLog !== false) {
+        const runsRoot = opts.activityLogDir ?? join(repo, ".harness", "runs");
+        deps.activityLog = new ActivityLogWriter({
+            path: join(runsRoot, runId, "activity.jsonl"),
+            ...(opts.resumesRunId ? { resumes: opts.resumesRunId } : {}),
+        });
+    }
+    // D1 — publish the run-status feed only when a hub spool is given.
+    if (opts.spoolDir) {
+        deps.publisher = new CliRunPublisher({
+            harnessBin: harnessCommand.command,
+            harnessBinArgs: harnessCommand.args,
+            cwd: repo,
+            spoolDir: opts.spoolDir,
+            machineId,
+            log,
+        });
+    }
+    return { deps, runId, machineId, systemId, specRef: specsDir };
+}
+function safeHostname() {
+    try {
+        return hostname() || "local";
+    }
+    catch {
+        return "local";
+    }
+}
+//# sourceMappingURL=index.js.map