@lchase/kiln 0.1.0 → 0.4.0

package/dist/driver.js

@@ -1,15 +1,18 @@
 import { spawn, spawnSync } from "node:child_process";
 import { randomUUID } from "node:crypto";
-import { closeSync, existsSync, linkSync, mkdirSync, openSync, readdirSync, readFileSync, rmSync, writeFileSync, } from "node:fs";
+import { closeSync, existsSync, linkSync, mkdirSync, openSync, readdirSync, readFileSync, readSync, rmSync, statSync, writeFileSync, } from "node:fs";
 import { basename, dirname, isAbsolute, join } from "node:path";
+import { buildAttention } from "./attention.js";
 import { clearLaunchError, deliverJob, readDelivery, readLaunchError, resolveLaunchBase, writeDelivery, writeLaunchError, isMerged, } from "./delivery.js";
+import { appendInvestigationFindings, existingFindingsPath, findingsFilePath, INVESTIGATION_WORKFLOW, readFindingsMarkdown, writeFindings, } from "./findings.js";
 import { defaultHost } from "./host.js";
-import { readJobSpec } from "./jobs.js";
+import { readJobSpec, resolveJobSpec } from "./jobs.js";
 import { jobBasename, packageRoot } from "./paths.js";
-import { decide, jobState, } from "./reconcile.js";
-import { gateAnswerCommand, renderStatus, renderTick, yakCliPath, } from "./report.js";
+import { decide, isLanded, jobState, } from "./reconcile.js";
+import { fileMtimeMs, isPidAlive, readAttemptLedger, recoverRuns, resetAttemptLedger, } from "./reliability.js";
+import { gateAnswerCommand, renderStatus, renderTick, statusView, yakCliPath, } from "./report.js";
 import { JobSchema } from "./schemas.js";
-import { materializeWorkflow, workflowInputs } from "./workflow.js";
+import { leafStepIds, materializeWorkflow, workflowInputs, workflowNeedsTestCommand, workflowStepPlan } from "./workflow.js";
 const TAG_PREFIX = "kiln:";
 export function jobTag(jobId) {
     return `${TAG_PREFIX}${jobId}`;
@@ -22,14 +25,28 @@ export function parseJobTag(tag) {
         return undefined;
     return id;
 }
+/** The derived view `kiln status` prints and `kiln serve` renders. */
+export function readStatus(config, jobId, host = defaultHost()) {
+    const view = statusView(observe(config, host).observation, jobId);
+    return { ...view, attention: buildAttention(view.jobs) };
+}
 export function runStatus(config, jobId, host = defaultHost()) {
-    return renderStatus(observe(config, host).observation, jobId);
+    return renderStatus(readStatus(config, jobId, host));
 }
-export function runTick(config, host = defaultHost()) {
+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 world = observe(config, host);
-        const actions = decide(world.observation);
-        return apply(config, world, actions, host);
+        const actions = decide(world.observation, now);
+        return apply(config, world, actions, host, notes);
+    });
+}
+/** 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 });
     });
 }
 export function answerJob(config, jobId, choice, host = defaultHost()) {
@@ -55,8 +72,79 @@ export function answerJob(config, jobId, choice, host = defaultHost()) {
     if (result.status !== 0) {
         throw new Error(output.trim() || `Could not ${choice} job ${jobId}.`);
     }
+    if (choice === "approve") {
+        recordInvestigationFindings(config, observe(config, host), jobId);
+    }
     return output.endsWith("\n") || output.length === 0 ? output : `${output}\n`;
 }
+/**
+ * Run a failed or dead job again. The board Retry button and `kiln retry`
+ * both call this.
+ * A landed job whose only failure is opening the pull request is handed to
+ * the same deliver path tick uses. Everything else is a new `yak run`, the
+ * same launch tick uses. The attempt ledger is cleared either way, and the
+ * current run id is ignored so a dead job is not stuck on the old journal.
+ * A dead journal is cancelled first.
+ */
+export function retryJob(config, jobId, host = defaultHost()) {
+    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);
+        if (state !== "failed" && state !== "dead") {
+            throw new Error(`Job ${jobId} is ${state}, not failed or dead.`);
+        }
+        const job = world.jobs.get(jobId);
+        if (!job)
+            throw new Error(`No job ${jobId}.`);
+        const crumb = readBreadcrumbs(config.kilnDir).find((candidate) => candidate.jobId === jobId);
+        if (crumb && pidAlive(crumb.pid)) {
+            throw new Error(`Job ${jobId} is already launching.`);
+        }
+        const cleared = observed.attemptCount ?? 0;
+        resetAttemptLedger(config.kilnDir, jobId, observed.run?.runId);
+        rmSync(breadcrumbPath(config.kilnDir, jobId), { force: true });
+        clearLaunchError(config.kilnDir, jobId);
+        const noun = cleared === 1 ? "attempt" : "attempts";
+        const clearedLine = `cleared ${cleared} ${noun}\n`;
+        if (shouldRedeliver(observed)) {
+            const report = deliverObserved(config, world, jobId, host);
+            if (!report.ok)
+                throw new Error(report.detail);
+            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) {
+            try {
+                spawnSync(process.execPath, [yakCliPath(), "cancel", observed.run.runId], {
+                    cwd: observed.run.checkout,
+                    encoding: "utf8",
+                    timeout: 20_000,
+                });
+            }
+            catch {
+                // Cancel is the same cleanup status prints. The new run still supersedes the journal.
+            }
+        }
+        const logPath = join(config.kilnDir, "logs", `${jobBasename(job.id)}.log`);
+        if (existsSync(logPath))
+            writeFileSync(logPath, "");
+        const report = launchJob(config, world, job, host);
+        const output = report.output.endsWith("\n") || report.output.length === 0 ? report.output : `${report.output}\n`;
+        return `retry ${report.jobId}  ${report.repo}\n${clearedLine}${output}`;
+    });
+}
+function shouldRedeliver(job) {
+    if (!isLanded(job))
+        return false;
+    if (job.delivery?.prState === "CLOSED")
+        return false;
+    return Boolean(job.delivery?.error) && !job.delivery?.prNumber;
+}
 function gateForChoice(gates, choice) {
     return (gates.find((gate) => gate.choices?.includes(choice)) ??
         gates.find((gate) => !gate.choices?.length));
@@ -78,11 +166,16 @@ function observe(config, host) {
         if (entry.job)
             records.set(entry.job.id, entry.job);
         const tag = jobTag(entry.meta.jobId);
-        const run = runs.get(tag);
+        const ledgerResult = readAttemptLedger(config.kilnDir, entry.meta.jobId);
+        const ledger = ledgerResult && ledgerResult !== "corrupt" ? ledgerResult : undefined;
+        const picked = selectRun(runs.get(tag) ?? [], ledger);
+        const run = picked.run;
         const crumb = breadcrumbs.find((candidate) => candidate.jobId === entry.meta.jobId);
-        if (crumb && run)
+        if (crumb && run && !picked.retired)
             breadcrumbsToClear.push({ path: crumb.path });
         const childAlive = crumb ? pidAlive(crumb.pid) : false;
+        const launching = Boolean(crumb) && childAlive && (!run || picked.retired);
+        const launchFailed = Boolean(crumb) && !childAlive && (!run || picked.retired);
         const repoKnown = entry.job ? Boolean(config.repos[entry.job.repo]) : false;
         const repoError = entry.job && !repoKnown ? `Repo ${entry.job.repo} is not registered.` : undefined;
         const repo = entry.job ? config.repos[entry.job.repo] : undefined;
@@ -94,6 +187,27 @@ function observe(config, host) {
         const stackError = entry.job?.stack && (entry.job.dependsOn?.length ?? 0) !== 1
             ? "stack needs exactly one dependency."
             : undefined;
+        const logPath = crumb?.logPath || existingLog(config.kilnDir, entry.meta.jobId);
+        if (run && logPath)
+            run.activityMs = later(run.activityMs, fileMtimeMs(logPath));
+        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 &&
+            attemptCount > 0 &&
+            !launching &&
+            (picked.retired || !run || run.status === "dead" || run.status === "failed");
+        const specPath = entry.job ? resolveJobSpec(config.kilnDir, entry.job.spec) : undefined;
+        const findingsPath = entry.job?.workflow === INVESTIGATION_WORKFLOW
+            ? existingFindingsPath(config.kilnDir, entry.job.id)
+            : undefined;
+        const logTail = readLogTail(logPath);
+        const stepPlan = entry.job ? workflowStepPlan(entry.job.workflow) : undefined;
+        const diffSummary = run &&
+            run.status === "suspended" &&
+            entry.job?.workflow !== INVESTIGATION_WORKFLOW
+            ? readDiffSummary(run.checkout, run.runId)
+            : undefined;
         jobs.push({
             jobId: entry.meta.jobId,
             repo: entry.job?.repo ?? "",
@@ -101,14 +215,28 @@ function observe(config, host) {
             title: entry.job?.title ?? "",
             dependsOn: entry.job?.dependsOn ?? [],
             ...(entry.job?.source ? { source: entry.job.source } : {}),
+            ...(specPath ? { specPath } : {}),
             deliver,
             ...(entry.job?.stack ? { stack: true } : {}),
             ...(delivery ? { delivery } : {}),
-            launching: Boolean(crumb) && !run && childAlive,
-            launchFailed: Boolean(crumb) && !run && !childAlive,
+            ...(findingsPath ? { findingsPath } : {}),
+            launching,
+            launchFailed,
             ...(launchError ? { launchError } : {}),
-            ...(crumb?.logPath ? { logPath: crumb.logPath } : {}),
+            ...(crumb ? { launchPid: crumb.pid } : {}),
+            ...(launchActivityMs !== undefined ? { launchActivityMs } : {}),
+            ...(logPath ? { logPath } : {}),
+            ...(entry.job?.createdAt ? { createdAt: entry.job.createdAt } : {}),
+            ...(logTail ? { logTail } : {}),
+            ...(diffSummary ? { diffSummary } : {}),
+            ...(stepPlan && stepPlan.length > 0 ? { stepPlan } : {}),
             ...(run ? { run } : {}),
+            attemptCount,
+            ...(lastFailure ? { lastFailureReason: lastFailure.reason } : {}),
+            ...(ledger?.nextRetryAt && !exhausted ? { nextRetryAt: ledger.nextRetryAt } : {}),
+            ...(exhausted ? { retriesExhausted: true } : {}),
+            ...(picked.retired ? { runRetired: true } : {}),
+            ...(ledgerResult === "corrupt" ? { ledgerError: "attempt ledger is unreadable" } : {}),
             ...(entry.meta.error || repoError || stackError
                 ? { error: entry.meta.error ?? repoError ?? stackError }
                 : {}),
@@ -117,15 +245,17 @@ function observe(config, host) {
     return {
         observation: {
             maxConcurrent: config.maxConcurrent,
+            maxAttempts: config.maxAttempts,
             jobs,
             breadcrumbsToClear,
         },
         jobs: records,
     };
 }
-function apply(config, world, actions, host) {
+function apply(config, world, actions, host, notes = []) {
     const launches = [];
     const delivers = [];
+    const findings = [];
     for (const action of actions) {
         if (action.type === "clear-breadcrumb") {
             rmSync(action.path, { force: true });
@@ -135,13 +265,39 @@ function apply(config, world, actions, host) {
             delivers.push(deliverObserved(config, world, action.jobId, host));
             continue;
         }
+        if (action.type === "record-findings") {
+            const recorded = recordInvestigationFindings(config, world, action.jobId);
+            if (recorded.status !== "skip")
+                findings.push(recorded);
+            continue;
+        }
         const job = world.jobs.get(action.jobId);
         if (!job) {
             throw new Error(`Tick planned a launch for ${action.jobId}, which is not in the observed jobs.`);
         }
-        launches.push(launchJob(config, world, job, host));
+        const report = launchJob(config, world, job, host);
+        launches.push(action.type === "retry" ? { ...report, retry: true } : report);
+    }
+    return renderTick(world.observation, actions, launches, delivers, findings, notes);
+}
+/**
+ * Copy an approved investigation's markdown into `<kilnDir>/findings`.
+ * A file that is already present is left as it is. A missing or incomplete
+ * artifact is reported and does not fail the tick.
+ */
+function recordInvestigationFindings(config, world, jobId) {
+    const job = world.jobs.get(jobId);
+    const observed = world.observation.jobs.find((candidate) => candidate.jobId === jobId);
+    if (!job || job.workflow !== INVESTIGATION_WORKFLOW || !observed?.run || !isLanded(observed)) {
+        return { status: "skip", jobId };
     }
-    return renderTick(world.observation, actions, launches, delivers);
+    if (observed.findingsPath)
+        return { status: "skip", jobId };
+    const markdown = readFindingsMarkdown(observed.run.checkout, observed.run.runId);
+    if (!markdown)
+        return { status: "missing", jobId };
+    const path = writeFindings(config.kilnDir, job.id, markdown);
+    return { status: "wrote", jobId, path };
 }
 function deliverObserved(config, world, jobId, host) {
     const job = world.jobs.get(jobId);
@@ -190,6 +346,33 @@ function pullRequestBase(world, job, repo, host) {
     host.git.fetch(repo.path);
     return host.git.defaultBranch(repo.path);
 }
+function assertStackTarget(world, job) {
+    if (!job.stack)
+        return;
+    const upstreamId = job.dependsOn?.[0];
+    if (!upstreamId)
+        return;
+    const upstream = world.jobs.get(upstreamId);
+    if (upstream?.workflow !== INVESTIGATION_WORKFLOW)
+        return;
+    throw new Error(`stack cannot target investigation job ${upstream.id}. An investigation does not land a branch.`);
+}
+/** Spec text for this launch. Investigation dependencies append their findings. */
+function specHandedToYak(config, world, job) {
+    const base = readJobSpec(config.kilnDir, job);
+    const sections = [];
+    for (const depId of job.dependsOn ?? []) {
+        const dep = world.jobs.get(depId);
+        if (!dep || dep.workflow !== INVESTIGATION_WORKFLOW)
+            continue;
+        const path = findingsFilePath(config.kilnDir, dep.id);
+        if (!existsSync(path)) {
+            throw new Error(`Job ${job.id} depends on investigation ${dep.id} (${dep.title}), which has no findings file at ${path}.`);
+        }
+        sections.push({ title: dep.title, markdown: readFileSync(path, "utf8") });
+    }
+    return appendInvestigationFindings(base, sections);
+}
 function upstreamBranch(world, job) {
     const upstreamId = job.dependsOn?.[0];
     if (!upstreamId)
@@ -233,8 +416,9 @@ function launchJob(config, world, job, host) {
     if (!repo) {
         throw new Error(`Repo ${job.repo} is not registered. Run kiln repo add ${job.repo} <path>.`);
     }
+    const sourceWorkflow = readFileSync(join(packageRoot(), "workflows", `${job.workflow}.yaml`), "utf8");
     const testCommand = repo.test;
-    if (!testCommand?.trim()) {
+    if (workflowNeedsTestCommand(sourceWorkflow) && !testCommand?.trim()) {
         throw new Error(`Repo ${job.repo} has no test command. Set repos.${job.repo}.test. The feature workflow refuses to run an empty KILN_TEST.`);
     }
     const workflow = materializeWorkflow(config.kilnDir, job.id, job.workflow);
@@ -243,8 +427,10 @@ function launchJob(config, world, job, host) {
     const crumbPath = breadcrumbPath(config.kilnDir, job.id);
     ensureCheckoutExcludes(repo.path);
     let baseSha;
+    let specText;
     try {
         clearLaunchError(config.kilnDir, job.id);
+        assertStackTarget(world, job);
         baseSha = resolveLaunchBase({
             checkout: repo.path,
             deliver: repo.deliver,
@@ -253,6 +439,7 @@ function launchJob(config, world, job, host) {
             ...(job.stack ? { upstreamBranch: upstreamBranch(world, job) } : {}),
             git: host.git,
         });
+        specText = specHandedToYak(config, world, job);
     }
     catch (error) {
         const message = error instanceof Error ? error.message : String(error);
@@ -260,8 +447,6 @@ function launchJob(config, world, job, host) {
         writeFileSync(logPath, `${message}\n`);
         return { jobId: job.id, repo: job.repo, output: message };
     }
-    const specText = readJobSpec(config.kilnDir, job);
-    const sourceWorkflow = readFileSync(join(packageRoot(), "workflows", `${job.workflow}.yaml`), "utf8");
     const input = workflowInputs(sourceWorkflow, {
         title: job.title,
         specText,
@@ -359,6 +544,12 @@ function scanRuns(config) {
             const status = classify(events);
             const gateDecision = readApproveDecision(runDir);
             const title = readRunTitle(runDir);
+            const finished = [...events].reverse().find((event) => event.t === "run.finished");
+            const stepPlan = readRunStepPlan(runDir);
+            const stepEvents = stepEventsFrom(events);
+            const pid = livePid(events);
+            const activityMs = eventActivityMs(events) ?? fileMtimeMs(join(runDir, "journal.jsonl"));
+            const finishedReason = finished && typeof finished.reason === "string" ? finished.reason : undefined;
             const run = {
                 runId,
                 checkout: repo.path,
@@ -366,14 +557,175 @@ function scanRuns(config) {
                 gates: status === "suspended" ? openGates(runDir, events) : [],
                 ...(gateDecision ? { gateDecision } : {}),
                 ...(title ? { title } : {}),
+                ...(typeof started?.at === "string" ? { startedAt: started.at } : {}),
+                ...(typeof finished?.at === "string" ? { finishedAt: finished.at } : {}),
+                ...(stepPlan.length > 0 ? { stepPlan } : {}),
+                ...(stepEvents.length > 0 ? { stepEvents } : {}),
+                ...(pid !== undefined ? { pid } : {}),
+                ...(activityMs !== undefined ? { activityMs } : {}),
+                ...(finishedReason ? { finishedReason } : {}),
             };
-            const previous = byTag.get(started.tag);
-            if (!previous || run.runId > previous.runId)
-                byTag.set(started.tag, run);
+            const list = byTag.get(started.tag) ?? [];
+            list.push(run);
+            byTag.set(started.tag, list);
         }
     }
     return byTag;
 }
+function stepEventsFrom(events) {
+    const found = [];
+    for (const event of events) {
+        if (event.t !== "step.started" && event.t !== "step.completed" && event.t !== "step.failed")
+            continue;
+        if (!event.stepId)
+            continue;
+        const detail = event.t === "step.failed" ? formatFailure(event.failure) : undefined;
+        found.push({
+            t: event.t,
+            stepId: event.stepId,
+            ...(detail ? { detail } : {}),
+        });
+    }
+    return found;
+}
+function formatFailure(failure) {
+    if (!failure)
+        return undefined;
+    const detail = typeof failure.detail === "string" ? failure.detail.trim() : "";
+    const reason = typeof failure.reason === "string" ? failure.reason.trim() : "";
+    const text = detail && reason ? `${detail} (${reason})` : detail || reason;
+    return text || undefined;
+}
+function readRunStepPlan(runDir) {
+    const file = join(runDir, "workflow.json");
+    if (!existsSync(file))
+        return [];
+    try {
+        const parsed = JSON.parse(readFileSync(file, "utf8"));
+        return leafStepIds(parsed.steps);
+    }
+    catch {
+        return [];
+    }
+}
+function readDiffSummary(checkout, runId) {
+    const worktree = join(checkout, ".yak", "worktrees", runId);
+    if (existsSync(worktree)) {
+        const result = spawnSync("git", ["diff", "--stat", "HEAD"], {
+            cwd: worktree,
+            encoding: "utf8",
+            timeout: 5_000,
+        });
+        const text = result.status === 0 ? result.stdout.trim() : "";
+        if (text)
+            return clipText(text, 1500);
+    }
+    return readBuildSummary(join(checkout, ".runs", runId));
+}
+function readBuildSummary(runDir) {
+    const dir = join(runDir, "artifacts");
+    if (!existsSync(dir))
+        return undefined;
+    let files;
+    try {
+        files = readdirSync(dir);
+    }
+    catch {
+        return undefined;
+    }
+    let best;
+    for (const file of files) {
+        const match = /^build(?:\.(\d+))?\.json$/.exec(file);
+        if (!match)
+            continue;
+        const iter = match[1] ? Number(match[1]) : 0;
+        if (!best || iter >= best.iter)
+            best = { iter, file };
+    }
+    if (!best)
+        return undefined;
+    try {
+        const parsed = JSON.parse(readFileSync(join(dir, best.file), "utf8"));
+        if (typeof parsed.summary !== "string" || !parsed.summary.trim())
+            return undefined;
+        return clipText(parsed.summary.trim(), 280);
+    }
+    catch {
+        return undefined;
+    }
+}
+function readLogTail(logPath) {
+    if (!logPath)
+        return undefined;
+    let size;
+    try {
+        size = statSync(logPath).size;
+    }
+    catch {
+        return undefined;
+    }
+    if (size <= 0)
+        return undefined;
+    const take = Math.min(size, 64_000);
+    let fd;
+    try {
+        fd = openSync(logPath, "r");
+        const buffer = Buffer.alloc(take);
+        readSync(fd, buffer, 0, take, size - take);
+        const text = buffer.toString("utf8");
+        const lines = text.split(/\r?\n/);
+        if (size > take)
+            lines.shift();
+        while (lines.length > 0 && lines[lines.length - 1] === "")
+            lines.pop();
+        const tail = lines.slice(-40).join("\n").trim();
+        return tail || undefined;
+    }
+    catch {
+        return undefined;
+    }
+    finally {
+        if (fd !== undefined)
+            closeSync(fd);
+    }
+}
+/**
+ * Prefer a run that is not already a recorded failure, so a retry is visible
+ * even when its id does not sort after the failed one. Otherwise keep the
+ * latest id, which is what a single-run job has always shown.
+ */
+function selectRun(runs, ledger) {
+    const ignored = new Set(ledger?.ignoredRunIds ?? []);
+    const failed = new Set((ledger?.attempts ?? []).flatMap((attempt) => (attempt.runId ? [attempt.runId] : [])));
+    const visible = runs.filter((run) => !ignored.has(run.runId));
+    visible.sort((left, right) => (left.runId < right.runId ? 1 : left.runId > right.runId ? -1 : 0));
+    const fresh = visible.filter((run) => !failed.has(run.runId));
+    if (fresh[0])
+        return { run: fresh[0], retired: false };
+    if (visible[0])
+        return { run: visible[0], retired: true };
+    return { retired: false };
+}
+function later(left, right) {
+    if (left === undefined)
+        return right;
+    if (right === undefined)
+        return left;
+    return Math.max(left, right);
+}
+function eventActivityMs(events) {
+    let latest;
+    for (const event of events) {
+        if (!event.at)
+            continue;
+        const parsed = Date.parse(event.at);
+        if (!Number.isFinite(parsed))
+            continue;
+        if (latest === undefined || parsed > latest)
+            latest = parsed;
+    }
+    return latest;
+}
 function listRunDirs(checkout) {
     const runsDir = join(checkout, ".runs");
     if (!existsSync(runsDir))
@@ -467,20 +819,141 @@ function openGates(runDir, events) {
     return gates;
 }
 function readGate(runDir, stepId) {
+    const reviews = readReviewArtifacts(runDir);
     const file = join(runDir, "pending", `${stepId}.request.json`);
-    if (!existsSync(file))
-        return { stepId, prompt: "(request file missing)" };
+    if (!existsSync(file)) {
+        return { stepId, prompt: "(request file missing)", ...(reviews.length > 0 ? { reviews } : {}) };
+    }
     const request = JSON.parse(readFileSync(file, "utf8"));
     const prompt = request.kind === "loop-exhausted"
         ? `loop exhausted (${request.tripped ?? "budget"} at iteration ${request.iteration ?? "?"})`
         : (request.rendered ?? stepId).split("\n")[0] ?? stepId;
     const shape = answerShape(request.answerSchema);
+    const rendered = typeof request.rendered === "string" ? clipText(request.rendered, 2000) : undefined;
+    const artifacts = readNamedArtifacts(runDir, artifactNames(request.context?.artifacts));
     return {
         stepId,
         prompt,
+        ...(rendered ? { rendered } : {}),
         ...(shape ? { answerField: shape.field, choices: shape.choices } : {}),
+        ...(artifacts.length > 0 ? { artifacts } : {}),
+        ...(reviews.length > 0 ? { reviews } : {}),
     };
 }
+const REVIEW_STEPS = ["security", "ux", "ui", "code"];
+const ARTIFACT_NAME = /^[A-Za-z0-9._-]+$/;
+const SECRET_KEY = /api[_-]?token|password|secret|authorization|credential/i;
+/** The launch log stays after the breadcrumb is cleared. Status prints it only for a failed launch. */
+function existingLog(kilnDir, jobId) {
+    let name;
+    try {
+        name = jobBasename(jobId);
+    }
+    catch {
+        return undefined;
+    }
+    const path = join(kilnDir, "logs", `${name}.log`);
+    return existsSync(path) ? path : undefined;
+}
+function artifactNames(value) {
+    if (!Array.isArray(value))
+        return [];
+    const names = [];
+    for (const entry of value) {
+        if (typeof entry !== "string" || !ARTIFACT_NAME.test(entry) || names.includes(entry))
+            continue;
+        names.push(entry);
+    }
+    return names;
+}
+function readNamedArtifacts(runDir, names) {
+    const found = [];
+    for (const name of names) {
+        const file = join(runDir, "artifacts", `${name}.json`);
+        if (!existsSync(file))
+            continue;
+        found.push(readArtifactSummary(file, name));
+    }
+    return found;
+}
+function readReviewArtifacts(runDir) {
+    const dir = join(runDir, "artifacts");
+    if (!existsSync(dir))
+        return [];
+    let files;
+    try {
+        files = readdirSync(dir);
+    }
+    catch {
+        return [];
+    }
+    const best = new Map();
+    for (const file of files) {
+        const match = /^(security|ux|ui|code)(?:\.(\d+))?\.json$/.exec(file);
+        if (!match?.[1])
+            continue;
+        const iter = match[2] ? Number(match[2]) : 0;
+        const previous = best.get(match[1]);
+        if (!previous || iter >= previous.iter)
+            best.set(match[1], { iter, file });
+    }
+    const found = [];
+    for (const step of REVIEW_STEPS) {
+        const picked = best.get(step);
+        if (!picked)
+            continue;
+        found.push(readArtifactSummary(join(dir, picked.file), step));
+    }
+    return found;
+}
+function readArtifactSummary(file, name) {
+    if (!existsSync(file))
+        return { name, summary: "(missing artifact)" };
+    try {
+        const parsed = JSON.parse(readFileSync(file, "utf8"));
+        return { name, summary: summarizeArtifact(name, parsed) };
+    }
+    catch {
+        return { name, summary: "(unreadable artifact)" };
+    }
+}
+function summarizeArtifact(name, value) {
+    const clean = redactSecrets(value);
+    if (name === "input" && isRecord(clean)) {
+        const title = clean.title;
+        return typeof title === "string" && title.trim() ? `title: ${clipText(title, 120)}` : "(no title)";
+    }
+    if (isRecord(clean)) {
+        const head = typeof clean.decision === "string" ? clean.decision : typeof clean.verdict === "string" ? clean.verdict : undefined;
+        const detail = typeof clean.reason === "string" ? clean.reason : typeof clean.findings === "string" ? clean.findings : undefined;
+        if (head)
+            return clipText(detail ? `${head} — ${detail}` : head, 280);
+    }
+    try {
+        return clipText(JSON.stringify(clean), 280);
+    }
+    catch {
+        return "(unreadable artifact)";
+    }
+}
+function redactSecrets(value) {
+    if (Array.isArray(value))
+        return value.map(redactSecrets);
+    if (!isRecord(value))
+        return value;
+    const out = {};
+    for (const [key, inner] of Object.entries(value)) {
+        out[key] = SECRET_KEY.test(key) ? "[redacted]" : redactSecrets(inner);
+    }
+    return out;
+}
+function isRecord(value) {
+    return typeof value === "object" && value !== null && !Array.isArray(value);
+}
+function clipText(text, max) {
+    const trimmed = text.trim();
+    return trimmed.length <= max ? trimmed : `${trimmed.slice(0, max - 1)}...`;
+}
 function answerShape(schema) {
     if (typeof schema !== "object" || schema === null || !("properties" in schema))
         return undefined;
@@ -616,15 +1089,7 @@ function releaseLock(lockPath) {
     }
 }
 function pidAlive(pid) {
-    if (!Number.isInteger(pid) || pid <= 0)
-        return false;
-    try {
-        process.kill(pid, 0);
-        return true;
-    }
-    catch (error) {
-        return isErrno(error, "EPERM");
-    }
+    return isPidAlive(pid);
 }
 function isErrno(error, code) {
     return typeof error === "object" && error !== null && "code" in error && error.code === code;