@lchase/kiln 0.9.0 → 0.11.0

package/dist/board.js

@@ -1,102 +1,5 @@
 import { existsSync, readFileSync, readdirSync } from "node:fs";
 import { join } from "node:path";
-import { scheduledRetry } from "./attention.js";
-const FEATURE_STAGES = ["spec", "build", "review", "approve", "land", "pr-review"];
-const CATALOG = [
-    { id: "queued", label: "Queued", who: "waiting · deps", tone: "queued" },
-    { id: "spec", label: "Spec", who: "spec-writer · opus" },
-    { id: "build", label: "Build", who: "builder · opus" },
-    { id: "review", label: "Review", who: "sec · ux · ui · code" },
-    { id: "approve", label: "Approve", who: "approver · opus" },
-    { id: "explore", label: "Explore", who: "investigator · opus" },
-    { id: "land", label: "Land", who: "git commit" },
-    { id: "pr-review", label: "PR review", who: "pr-sync" },
-    { id: "done", label: "Done", who: "local", tone: "merged" },
-    { id: "merged", label: "Merged", who: "pr", tone: "merged" },
-    { id: "needs-human", label: "Needs human", who: "approve · retry", tone: "human" },
-];
-const STEP_STAGE = {
-    spec: "spec",
-    build: "build",
-    verify: "build",
-    security: "review",
-    ux: "review",
-    ui: "review",
-    code: "review",
-    approver: "approve",
-    approve: "needs-human",
-    land: "land",
-    explore: "explore",
-};
-const HUMAN_STATES = new Set(["needs-human", "failed", "dead", "invalid", "rejected"]);
-/**
- * Column for one job. Human gates and broken runs sit in Needs human.
- * A failed job with an automatic retry still scheduled stays on the step
- * its last run reached. `scheduledRetry` is that decision.
- */
-export function stageOf(job) {
-    if (scheduledRetry(job))
-        return runStage(job);
-    if (HUMAN_STATES.has(job.state))
-        return "needs-human";
-    if (job.state === "in-review")
-        return "pr-review";
-    if (job.state === "done")
-        return job.prUrl || job.prNumber ? "merged" : "done";
-    const current = job.steps.find((step) => step.phase === "current" || step.phase === "failed");
-    if (job.state === "queued" || job.state === "blocked")
-        return "queued";
-    if (job.state === "approved") {
-        if (current && current.id !== "land" && current.id !== "approve" && STEP_STAGE[current.id])
-            return STEP_STAGE[current.id];
-        return "land";
-    }
-    if (current && STEP_STAGE[current.id])
-        return STEP_STAGE[current.id];
-    return runStage(job);
-}
-/**
- * Stage of the last step the run actually reached.
- * The approve gate's column is Needs human; a scheduled retry is not a gate,
- * so that step stays on Approve. Spec or Explore when the run never started a step.
- */
-function runStage(job) {
-    const last = [...job.steps].reverse().find((step) => step.phase === "current" || step.phase === "failed");
-    const stage = last ? STEP_STAGE[last.id] : undefined;
-    if (stage && stage !== "needs-human")
-        return stage;
-    if (stage === "needs-human") {
-        const earlier = [...job.steps].reverse().find((step) => {
-            const mapped = STEP_STAGE[step.id];
-            return step.phase === "done" && mapped !== undefined && mapped !== "needs-human";
-        });
-        if (earlier)
-            return STEP_STAGE[earlier.id] ?? "approve";
-        return "approve";
-    }
-    return job.workflow === "investigation" ? "explore" : "spec";
-}
-/** Stages to render. An empty kiln still shows the feature pipeline, collapsed. */
-export function stagesFor(jobs) {
-    const workflows = new Set(jobs.map((job) => job.workflow));
-    const wanted = new Set();
-    if (jobs.length === 0 || workflows.has("feature") || [...workflows].some((name) => name !== "investigation")) {
-        for (const id of FEATURE_STAGES)
-            wanted.add(id);
-    }
-    if (workflows.has("investigation"))
-        wanted.add("explore");
-    wanted.add("queued");
-    wanted.add("needs-human");
-    const reached = new Set(jobs.map((job) => stageOf(job)));
-    if (reached.has("done") || !reached.has("merged"))
-        wanted.add("done");
-    if (reached.has("merged"))
-        wanted.add("merged");
-    for (const id of reached)
-        wanted.add(id);
-    return CATALOG.filter((stage) => wanted.has(stage.id));
-}
 const REVIEW_FILE = /^(security|ux|ui|code)(?:\.(\d+))?\.json$/;
 const TEXT_LIMIT = 8_000;
 export function readReviewRounds(runDir) {

package/dist/cli.js

@@ -1,7 +1,8 @@
 #!/usr/bin/env node
 import { addRepo, renderRepoList, resolveKilnConfig } from "./config.js";
 import { renderSandboxStatus, runSandboxBuild } from "./sandbox.js";
-import { answerJob, retryJob, runStatus, runTick } from "./driver.js";
+import { answerJob, retryJob, reviseJob, runStatus, runTick } from "./driver.js";
+import { pauseFactory, resumeFactory } from "./rails.js";
 import { parseSince, renderLedgerFile } from "./ledger.js";
 import { startServe } from "./serve.js";
 import { addFromFile } from "./intake/file.js";
@@ -19,7 +20,10 @@ function usage() {
         "       kiln status [jobId] [--config <file>]",
         "       kiln approve <jobId> [--config <file>]",
         "       kiln reject <jobId> [--config <file>]",
+        "       kiln revise <jobId> --note <text> [--config <file>]",
         "       kiln retry <jobId> [--config <file>]",
+        "       kiln pause [--config <file>]",
+        "       kiln resume [--config <file>]",
         "       kiln ledger [--since 7d] [--repo <name>] [--config <file>]",
         "       kiln sandbox [build] [--config <file>]",
         "       kiln serve [--port 4100] [--tick <seconds>|--no-tick] [--config <file>]",
@@ -66,7 +70,13 @@ function usage() {
         "or a process that is already gone when tick or serve starts (orphaned) retries",
         "after 10s, 20s, 40s, and so on, capped at 5 minutes, up to maxAttempts",
         "A rejected Claude login (401 or an invalid bearer token) is auth-failed and is not retried.",
-        "(default 3). The job is then dead. A rejected gate is not retried.",
+        "(default 3, overridable per repo). Hitting the cap is a budget failure and the",
+        "job needs a person. The same failure fingerprint stops the job after",
+        "maxSameFingerprint (default 3). A test, build, or type error is not retried.",
+        "A rejected gate is not retried. revise sends the job around again with the",
+        "note in the next prompt. pause stops new runs until resume. In-flight runs",
+        "finish. A daily dollar cap, when set, does the same once today's recorded",
+        "spend reaches it. ledger prints that spend.",
         "Attempts are files under the kiln home, not fields on the job.",
         "Events are one JSON line each in <kiln-home>/events.jsonl. A write",
         "failure is reported and does not stop the job. kiln ledger counts",
@@ -227,6 +237,13 @@ function parseFlags(argv) {
             bag.noTick = true;
             continue;
         }
+        if (flag === "--note") {
+            if (!next || next.startsWith("--"))
+                usage();
+            bag.note = next;
+            i += 1;
+            continue;
+        }
         if (flag === "--since") {
             if (!next || next.startsWith("--"))
                 usage();
@@ -380,7 +397,7 @@ function sandboxCommand(argv) {
 function tickCommand(argv) {
     const flags = parseFlags(argv);
     rejectServeFlags(flags);
-    if (flags.positionals.length !== 0 || flags.test || hasIntakeFlags(flags) || flags.deliver || flags.base || flags.stack) {
+    if (flags.positionals.length !== 0 || flags.test || flags.note || hasIntakeFlags(flags) || flags.deliver || flags.base || flags.stack) {
         usage();
     }
     const config = resolveKilnConfig({ configPath: flags.configPath });
@@ -389,7 +406,7 @@ function tickCommand(argv) {
 function statusCommand(argv) {
     const flags = parseFlags(argv);
     rejectServeFlags(flags);
-    if (flags.positionals.length > 1 || flags.test || hasIntakeFlags(flags) || flags.deliver || flags.base || flags.stack) {
+    if (flags.positionals.length > 1 || flags.test || flags.note || hasIntakeFlags(flags) || flags.deliver || flags.base || flags.stack) {
         usage();
     }
     const config = resolveKilnConfig({ configPath: flags.configPath });
@@ -399,7 +416,7 @@ function retryCommand(argv) {
     const flags = parseFlags(argv);
     rejectServeFlags(flags);
     const jobId = flags.positionals[0];
-    if (!jobId || flags.positionals.length !== 1 || flags.test || hasIntakeFlags(flags) || flags.deliver || flags.base || flags.stack) {
+    if (!jobId || flags.positionals.length !== 1 || flags.test || flags.note || hasIntakeFlags(flags) || flags.deliver || flags.base || flags.stack) {
         usage();
     }
     const config = resolveKilnConfig({ configPath: flags.configPath });
@@ -429,13 +446,41 @@ function ledgerCommand(argv) {
     process.stdout.write(renderLedgerFile(config.kilnDir, {
         ...(since ? { since } : {}),
         ...(flags.repo ? { repo: flags.repo } : {}),
+        ...(config.dailyDollarCap !== undefined ? { dailyDollarCap: config.dailyDollarCap } : {}),
     }));
 }
+function reviseCommand(argv) {
+    const flags = parseFlags(argv);
+    rejectServeFlags(flags);
+    const jobId = flags.positionals[0];
+    if (!jobId ||
+        flags.positionals.length !== 1 ||
+        !flags.note ||
+        flags.test ||
+        hasIntakeFlags(flags) ||
+        flags.deliver ||
+        flags.base ||
+        flags.stack) {
+        usage();
+    }
+    const config = resolveKilnConfig({ configPath: flags.configPath });
+    process.stdout.write(reviseJob(config, jobId, flags.note));
+}
+function pauseCommand(argv, pause) {
+    const flags = parseFlags(argv);
+    rejectServeFlags(flags);
+    if (flags.positionals.length !== 0 || flags.test || hasIntakeFlags(flags) || flags.note || flags.deliver || flags.base || flags.stack) {
+        usage();
+    }
+    const config = resolveKilnConfig({ configPath: flags.configPath });
+    const changed = pause ? pauseFactory(config.kilnDir) : resumeFactory(config.kilnDir);
+    process.stdout.write(pause ? (changed ? "paused\n" : "already paused\n") : changed ? "resumed\n" : "already running\n");
+}
 function gateCommand(choice, argv) {
     const flags = parseFlags(argv);
     rejectServeFlags(flags);
     const jobId = flags.positionals[0];
-    if (!jobId || flags.positionals.length !== 1 || flags.test || hasIntakeFlags(flags) || flags.deliver || flags.base || flags.stack) {
+    if (!jobId || flags.positionals.length !== 1 || flags.test || flags.note || hasIntakeFlags(flags) || flags.deliver || flags.base || flags.stack) {
         usage();
     }
     const config = resolveKilnConfig({ configPath: flags.configPath });
@@ -511,6 +556,18 @@ async function main() {
         retryCommand(argv.slice(1));
         return;
     }
+    if (command === "revise") {
+        reviseCommand(argv.slice(1));
+        return;
+    }
+    if (command === "pause") {
+        pauseCommand(argv.slice(1), true);
+        return;
+    }
+    if (command === "resume") {
+        pauseCommand(argv.slice(1), false);
+        return;
+    }
     if (command === "ledger") {
         ledgerCommand(argv.slice(1));
         return;

package/dist/config.js

@@ -2,7 +2,7 @@ import { existsSync, mkdirSync, readFileSync, statSync, writeFileSync } from "no
 import { homedir } from "node:os";
 import { dirname, isAbsolute, join, resolve } from "node:path";
 import { KilnConfigError } from "./errors.js";
-import { DEFAULT_MAX_ATTEMPTS, DEFAULT_MAX_FIX_ROUNDS, DEFAULT_STALL_TIMEOUT_MS, KilnConfigFileSchema, REPO_NAME, } from "./schemas.js";
+import { DEFAULT_MAX_ATTEMPTS, DEFAULT_MAX_FIX_ROUNDS, DEFAULT_MAX_SAME_FINGERPRINT, DEFAULT_STALL_TIMEOUT_MS, KilnConfigFileSchema, REPO_NAME, } from "./schemas.js";
 const CONFIG_NAME = "kiln.config.json";
 export function loadKilnConfig(configPath, options = {}) {
     const home = options.home ?? homedir();
@@ -31,6 +31,8 @@ export function loadKilnConfig(configPath, options = {}) {
             ...(entry.base ? { base: entry.base } : {}),
             ...(entry.prTitle ? { prTitle: entry.prTitle } : {}),
             ...(entry.branch ? { branchTemplate: entry.branch } : {}),
+            ...(entry.maxAttempts !== undefined ? { maxAttempts: entry.maxAttempts } : {}),
+            ...(entry.maxFixRounds !== undefined ? { maxFixRounds: entry.maxFixRounds } : {}),
         };
     }
     const kilnDir = configDir;
@@ -46,6 +48,8 @@ export function loadKilnConfig(configPath, options = {}) {
         stallTimeoutMs: parsed.data.stallTimeoutMs ?? DEFAULT_STALL_TIMEOUT_MS,
         maxAttempts: parsed.data.maxAttempts ?? DEFAULT_MAX_ATTEMPTS,
         maxFixRounds: parsed.data.maxFixRounds ?? DEFAULT_MAX_FIX_ROUNDS,
+        maxSameFingerprint: parsed.data.maxSameFingerprint ?? DEFAULT_MAX_SAME_FINGERPRINT,
+        ...(parsed.data.dailyDollarCap !== undefined ? { dailyDollarCap: parsed.data.dailyDollarCap } : {}),
         adapter: parsed.data.adapter ?? "claude-code",
         sandbox: parsed.data.sandbox ?? {},
         workflowSandbox: workflowSandboxFrom(parsed.data.workflows),
@@ -112,6 +116,12 @@ export function addRepo(options) {
     const branchTemplate = previousString(previous, "branch");
     if (branchTemplate)
         entry.branch = branchTemplate;
+    const maxAttempts = previousNumber(previous, "maxAttempts");
+    if (maxAttempts !== undefined)
+        entry.maxAttempts = maxAttempts;
+    const maxFixRounds = previousNumber(previous, "maxFixRounds");
+    if (maxFixRounds !== undefined)
+        entry.maxFixRounds = maxFixRounds;
     repos[options.name] = entry;
     raw.repos = repos;
     const parsed = KilnConfigFileSchema.safeParse(raw);
@@ -138,6 +148,14 @@ export function addRepo(options) {
     lines.push(`wrote ${configPath}`);
     return `${lines.join("\n")}\n`;
 }
+/** Attempt cap for one repo: the repo override, otherwise the global cap. */
+export function attemptsFor(config, repo) {
+    return config.repos[repo]?.maxAttempts ?? config.maxAttempts;
+}
+/** Fix-round cap for one repo: the repo override, otherwise the global cap. */
+export function fixRoundsFor(config, repo) {
+    return config.repos[repo]?.maxFixRounds ?? config.maxFixRounds;
+}
 export function renderRepoList(config) {
     const names = Object.keys(config.repos).sort();
     if (names.length === 0)
@@ -226,6 +244,12 @@ function previousString(previous, key) {
     const value = previous[key];
     return typeof value === "string" && value.length > 0 ? value : undefined;
 }
+function previousNumber(previous, key) {
+    if (typeof previous !== "object" || previous === null || !(key in previous))
+        return undefined;
+    const value = previous[key];
+    return typeof value === "number" && Number.isFinite(value) ? value : undefined;
+}
 function previousDeliver(previous) {
     const value = previousString(previous, "deliver");
     if (value === "local" || value === "pr")

package/dist/driver.js

@@ -4,16 +4,20 @@ import { closeSync, existsSync, linkSync, mkdirSync, openSync, readdirSync, read
 import { basename, dirname, isAbsolute, join } from "node:path";
 import { claudeCredentialPreflight } from "./auth.js";
 import { buildAttention } from "./attention.js";
+import { attemptsFor, fixRoundsFor } from "./config.js";
 import { clearLaunchError, deliverJob, plannedRemoteBranch, readDelivery, readLaunchError, resolveLaunchBase, writeDelivery, writeLaunchError, isMerged, } from "./delivery.js";
 import { feedbackSpec, openFeedbackRound, planFeedback, readFeedbackLedger, writeFeedbackLedger, } from "./feedback.js";
-import { appendEvent } from "./events.js";
+import { appendEvent, readEvents } from "./events.js";
+import { costFromJournal } from "./failure.js";
+import { ensureFixTrailers } from "./fix-commit.js";
+import { holdDetail, pausedFrom, recordDailyCap, reviseNotesSinceRun, spendSnapshot, stopReasonFromEvents, withReviseNotes, } from "./rails.js";
 import { appendInvestigationFindings, existingFindingsPath, findingsFilePath, INVESTIGATION_WORKFLOW, readFindingsMarkdown, writeFindings, } from "./findings.js";
 import { defaultHost } from "./host.js";
 import { readJobSpec, resolveJobSpec } from "./jobs.js";
 import { jobBasename, packageRoot } from "./paths.js";
 import { decide, isLanded, jobState, } from "./reconcile.js";
 import { fileMtimeMs, isPidAlive, readAttemptLedger, recoverRuns, resetAttemptLedger, } from "./reliability.js";
-import { projectRunJournal } from "./project.js";
+import { projectRunJournal, promptsHash } from "./project.js";
 import { gateAnswerCommand, renderStatus, renderTick, statusView, yakCliPath, sandboxFailureDetail, } from "./report.js";
 import { AGENT_SANDBOX_IMAGE, injectAgentSandbox, jobIsSandboxed, probeSandboxEnvironment, PROXY_SANDBOX_IMAGE, requiredSandboxImages, resolveSandbox, sandboxIsEnabled, sandboxPreflight, sandboxPreflightFor, } from "./sandbox.js";
 import { JobSchema } from "./schemas.js";
@@ -42,16 +46,19 @@ export function runTick(config, host = defaultHost(), options = {}) {
     const startup = options.startup ?? true;
     const now = options.now ?? new Date();
     return withTickLock(config.kilnDir, () => {
-        const notes = recoverRuns(config, observe(config, host).observation.jobs, { startup, now });
+        const notes = recoverRuns(config, observe(config, host, now).observation.jobs, { startup, now });
         const facts = sandboxIsEnabled(config)
             ? (options.sandboxFacts ?? probeSandboxEnvironment(process.env, requiredSandboxImages(config)))
             : undefined;
-        const midway = observe(config, host);
+        const midway = observe(config, host, now);
         bindOpenFixRuns(config, midway);
         const published = publishReadyFixes(config, host, midway);
-        const world = observe(config, host);
+        const world = observe(config, host, now);
         const feedbackNotes = watchPullRequests(config, world, host);
         const actions = decide(world.observation, now);
+        if (world.observation.spendBlocked) {
+            recordDailyCap(config.kilnDir, spendSnapshot(readEvents(config.kilnDir, { warn: () => { } }), config.dailyDollarCap, now), now);
+        }
         const body = apply(config, world, actions, host, notes, now, [...published, ...feedbackNotes], facts);
         const heads = [
             claudeCredentialPreflight(process.env, config.adapter),
@@ -63,7 +70,7 @@ export function runTick(config, host = defaultHost(), options = {}) {
 /** Startup pass shared by `kiln tick` (via `runTick`) and `kiln serve`. Idempotent. */
 export function startupRecovery(config, host = defaultHost(), now = new Date()) {
     withTickLock(config.kilnDir, () => {
-        recoverRuns(config, observe(config, host).observation.jobs, { startup: true, now });
+        recoverRuns(config, observe(config, host, now).observation.jobs, { startup: true, now });
     });
 }
 export function answerJob(config, jobId, choice, host = defaultHost()) {
@@ -126,8 +133,8 @@ export function retryJob(config, jobId, host = defaultHost()) {
         if (observed.error)
             throw new Error(`Job ${jobId} is invalid: ${observed.error}`);
         const state = jobState(observed, world.observation);
-        if (state !== "failed" && state !== "dead") {
-            throw new Error(`Job ${jobId} is ${state}, not failed or dead.`);
+        if (!canManualRetry(state, observed)) {
+            throw new Error(`Job ${jobId} is ${state}, not failed, dead, or stopped for a person.`);
         }
         const job = world.jobs.get(jobId);
         if (!job)
@@ -154,7 +161,7 @@ export function retryJob(config, jobId, host = defaultHost()) {
             const detail = report.detail.endsWith("\n") || report.detail.length === 0 ? report.detail : `${report.detail}\n`;
             return `retry ${jobId}  ${job.repo}\n${clearedLine}${detail}`;
         }
-        if (state === "dead" && observed.run) {
+        if ((state === "dead" || observed.stopReason) && observed.run) {
             try {
                 spawnSync(process.execPath, [yakCliPath(), "cancel", observed.run.runId], {
                     cwd: observed.run.checkout,
@@ -174,6 +181,64 @@ export function retryJob(config, jobId, host = defaultHost()) {
         return `retry ${report.jobId}  ${report.repo}\n${clearedLine}${output}`;
     });
 }
+function canManualRetry(state, job) {
+    if (state === "failed" || state === "dead")
+        return true;
+    return state === "needs-human" && Boolean(job.stopReason) && (job.run?.gates.length ?? 0) === 0;
+}
+/**
+ * Send a gated job back for another round. The note is stored on a
+ * `gate.resolved` event (redacted, otherwise verbatim) and appended to the
+ * spec the next launch passes into the prompt.
+ */
+export function reviseJob(config, jobId, note, host = defaultHost()) {
+    const trimmed = note.trim();
+    if (!trimmed)
+        throw new Error("A revise note is required.");
+    if (trimmed.length > 8_000)
+        throw new Error("A revise note must be 8000 characters or fewer.");
+    return withTickLock(config.kilnDir, () => {
+        const world = observe(config, host);
+        const observed = world.observation.jobs.find((candidate) => candidate.jobId === jobId);
+        if (!observed)
+            throw new Error(`No job ${jobId}.`);
+        if (observed.error)
+            throw new Error(`Job ${jobId} is invalid: ${observed.error}`);
+        const state = jobState(observed, world.observation);
+        const gate = observed.run?.gates[0];
+        if (state !== "needs-human" || !observed.run || !gate) {
+            throw new Error(`Job ${jobId} is ${state}, not waiting on a gate.`);
+        }
+        const job = world.jobs.get(jobId);
+        if (!job)
+            throw new Error(`No job ${jobId}.`);
+        appendEvent(config.kilnDir, {
+            job_id: jobId,
+            run_id: observed.run.runId,
+            event: "gate.resolved",
+            step: gate.stepId,
+            properties: {
+                decision: "revise",
+                by: "human",
+                repo: job.repo,
+                note: trimmed,
+            },
+        });
+        resetAttemptLedger(config.kilnDir, jobId, observed.run.runId);
+        rmSync(breadcrumbPath(config.kilnDir, jobId), { force: true });
+        clearLaunchError(config.kilnDir, jobId);
+        const events = readEvents(config.kilnDir, { warn: () => { } });
+        const spend = spendSnapshot(events, config.dailyDollarCap);
+        const paused = pausedFrom(events);
+        const hold = holdDetail(paused, spend);
+        if (hold)
+            return `revised ${jobId}\n${hold}\n`;
+        const again = observe(config, host);
+        const report = launchJob(config, again, job, host);
+        const output = report.output.endsWith("\n") || report.output.length === 0 ? report.output : `${report.output}\n`;
+        return `revised ${jobId}  ${report.repo}\n${output}`;
+    });
+}
 function shouldRedeliver(job) {
     if (!isLanded(job))
         return false;
@@ -185,9 +250,13 @@ function gateForChoice(gates, choice) {
     return (gates.find((gate) => gate.choices?.includes(choice)) ??
         gates.find((gate) => !gate.choices?.length));
 }
-function observe(config, host) {
+function observe(config, host, now = new Date()) {
     const loaded = loadJobs(config);
     const runs = scanRuns(config);
+    const events = readEvents(config.kilnDir, { warn: () => { } });
+    const paused = pausedFrom(events);
+    const spend = spendSnapshot(events, config.dailyDollarCap, now);
+    const waiting = holdDetail(paused, spend);
     const breadcrumbs = readBreadcrumbs(config.kilnDir);
     const jobs = [];
     const records = new Map();
@@ -234,10 +303,13 @@ function observe(config, host) {
         const launchActivityMs = later(crumb ? fileMtimeMs(crumb.path) : undefined, logPath ? fileMtimeMs(logPath) : undefined);
         const attemptCount = ledger?.attempts.length ?? 0;
         const lastFailure = ledger?.attempts.at(-1);
-        const exhausted = attemptCount >= config.maxAttempts &&
+        const attemptCap = attemptsFor(config, entry.job?.repo ?? "");
+        const exhausted = attemptCount >= attemptCap &&
             attemptCount > 0 &&
             !launching &&
             (picked.retired || !run || run.status === "dead" || run.status === "failed");
+        const eventStop = entry.job ? stopReasonFromEvents(events, entry.job.id) : undefined;
+        const stopReason = eventStop ?? (exhausted ? "attempt-cap" : undefined);
         const specPath = entry.job ? resolveJobSpec(config.kilnDir, entry.job.spec) : undefined;
         const findingsPath = entry.job?.workflow === INVESTIGATION_WORKFLOW
             ? existingFindingsPath(config.kilnDir, entry.job.id)
@@ -276,6 +348,8 @@ function observe(config, host) {
             ...(lastFailure ? { lastFailureReason: lastFailure.reason } : {}),
             ...(ledger?.nextRetryAt && !exhausted ? { nextRetryAt: ledger.nextRetryAt } : {}),
             ...(exhausted ? { retriesExhausted: true } : {}),
+            ...(stopReason ? { stopReason } : {}),
+            attemptCap,
             ...(picked.retired ? { runRetired: true } : {}),
             ...(ledgerResult === "corrupt" ? { ledgerError: "attempt ledger is unreadable" } : {}),
             ...(entry.job ? { sandboxed: jobIsSandboxed(config, entry.job.id, entry.job.workflow) } : {}),
@@ -296,6 +370,9 @@ function observe(config, host) {
             maxAttempts: config.maxAttempts,
             jobs,
             breadcrumbsToClear,
+            ...(paused ? { paused: true } : {}),
+            ...(spend.blocked ? { spendBlocked: true } : {}),
+            ...(waiting ? { holdDetail: waiting } : {}),
         },
         jobs: records,
     };
@@ -438,7 +515,8 @@ function specHandedToYak(config, world, job) {
         }
         sections.push({ title: dep.title, markdown: readFileSync(path, "utf8") });
     }
-    return appendInvestigationFindings(base, sections);
+    const noted = withReviseNotes(appendInvestigationFindings(base, sections), reviseNotesSinceRun(readEvents(config.kilnDir, { warn: () => { } }), job.id));
+    return noted;
 }
 /** Remote name the stacked pull request targets. Falls back to the local yak ref. */
 function upstreamBranch(world, job) {
@@ -550,6 +628,15 @@ function publishReadyFixes(config, host, world) {
         const record = readDelivery(config.kilnDir, job.jobId);
         const checkout = job.run.checkout;
         const source = `yak/${job.run.runId}`;
+        const worktree = join(checkout, ".yak", "worktrees", job.run.runId);
+        if (existsSync(worktree)) {
+            ensureFixTrailers(worktree, {
+                jobId: job.jobId,
+                round: open.round,
+                promptsHash: hashForRun(config.kilnDir, job.jobId, job.run.runId),
+                title: job.title,
+            }, open.headSha);
+        }
         if (!record?.branch) {
             notes.push(`feedback ${job.jobId} failed: no pull request branch to publish`);
             continue;
@@ -607,6 +694,14 @@ function publishReadyFixes(config, host, world) {
     }
     return notes;
 }
+function hashForRun(kilnDir, jobId, runId) {
+    for (const event of readEvents(kilnDir, { warn: () => { } })) {
+        if (event.job_id === jobId && event.run_id === runId && event.event === "run.started") {
+            return event.properties.prompts_hash;
+        }
+    }
+    return promptsHash("fix", kilnDir, jobId);
+}
 function isNonFastForward(message) {
     return /non-fast-forward|\[rejected\]|failed to push some refs/i.test(message);
 }
@@ -676,7 +771,7 @@ function watchPullRequests(config, world, host) {
             continue;
         }
         job.feedbackPlan = planFeedback({
-            maxFixRounds: config.maxFixRounds,
+            maxFixRounds: fixRoundsFor(config, job.repo),
             ledger,
             snapshot,
         });
@@ -769,7 +864,7 @@ function startFix(config, world, job, host, now, sandboxFacts) {
         writeBreadcrumb(breadcrumbPath(config.kilnDir, job.id), { jobId: job.id, pid: 0, logPath });
         return { jobId: job.id, repo: job.repo, kind: "fix", output: message };
     }
-    const report = launchFixRun(config, job, host, repo.path, headSha, specText, sandboxFacts);
+    const report = launchFixRun(config, job, host, repo.path, headSha, specText, round, sandboxFacts);
     return { ...report, output: `round ${round}\n${report.output}` };
 }
 /** Relaunch the open fix round. Does not append a round. Failures become a dead launch so retry can see them. */
@@ -790,7 +885,7 @@ function launchOpenFix(config, world, job, host, checkout, open, sandboxFacts) {
         writeBreadcrumb(breadcrumbPath(config.kilnDir, job.id), { jobId: job.id, pid: 0, logPath });
         return { jobId: job.id, repo: job.repo, kind: "fix", output: message };
     }
-    return launchFixRun(config, job, host, checkout, headSha, specText, sandboxFacts);
+    return launchFixRun(config, job, host, checkout, headSha, specText, open.round, sandboxFacts);
 }
 function resolveCommit(host, checkout, sha) {
     try {
@@ -802,7 +897,7 @@ function resolveCommit(host, checkout, sha) {
     }
 }
 /** `workflows/fix.yaml` on `headSha`. Commits on `yak/<run-id>`. Does not push. */
-function launchFixRun(config, job, host, checkout, headSha, specText, sandboxFacts) {
+function launchFixRun(config, job, host, checkout, headSha, specText, round, sandboxFacts) {
     const refused = claudeCredentialPreflight(process.env, config.adapter);
     if (refused)
         return { jobId: job.id, repo: job.repo, kind: "fix", output: refused };
@@ -814,6 +909,7 @@ function launchFixRun(config, job, host, checkout, headSha, specText, sandboxFac
     const blocked = commitAgentSandbox(config, job.id, "fix", workflow, logPath, sandboxFacts);
     if (blocked)
         return { jobId: job.id, repo: job.repo, kind: "fix", output: blocked };
+    const hash = promptsHash("fix", config.kilnDir, job.id);
     ensureCheckoutExcludes(checkout);
     const input = workflowInputs(sourceWorkflow, {
         title: job.title,
@@ -826,6 +922,9 @@ function launchFixRun(config, job, host, checkout, headSha, specText, sandboxFac
         ...process.env,
         ...(repo?.test ? { KILN_TEST: repo.test } : {}),
         KILN_TASK_TITLE: job.title,
+        KILN_JOB: job.id,
+        KILN_ROUND: String(round),
+        KILN_PROMPTS_HASH: hash,
         KILN_VERIFY_WRAPPER: join(packageRoot(), "dist", "truncate-output.js"),
     };
     return spawnLogged(config, host, {
@@ -1056,6 +1155,7 @@ function scanRuns(config) {
             const stepPlan = readRunStepPlan(runDir);
             const stepEvents = stepEventsFrom(events);
             const sandboxError = sandboxFailureDetail(stepEvents);
+            const cost = costFromJournal(events);
             const pid = livePid(events);
             const activityMs = eventActivityMs(events) ?? fileMtimeMs(join(runDir, "journal.jsonl"));
             const finishedReason = finished && typeof finished.reason === "string" ? finished.reason : undefined;
@@ -1074,6 +1174,7 @@ function scanRuns(config) {
                 ...(activityMs !== undefined ? { activityMs } : {}),
                 ...(finishedReason ? { finishedReason } : {}),
                 ...(sandboxError ? { sandboxError } : {}),
+                cost,
             };
             const list = byTag.get(started.tag) ?? [];
             list.push(run);