@lchase/kiln 0.4.0 → 0.5.0

package/dist/reconcile.js

@@ -5,7 +5,7 @@ export function inFlightCount(observation) {
     return observation.jobs.filter((job) => inFlight(job, observation)).length;
 }
 function inFlight(job, observation) {
-    if (job.error)
+    if (job.error || job.feedbackExhausted || job.feedbackAmbiguous)
         return false;
     const state = jobState(job, observation);
     return state === "running" || state === "needs-human" || state === "approved";
@@ -20,8 +20,17 @@ function inFlight(job, observation) {
  * An investigation is `done` on approve and never `in-review`.
  */
 export function jobState(job, observation) {
-    if (job.launching && (!job.run || job.runRetired))
+    if (job.fixAwaitingPublish)
+        return "in-review";
+    if (job.launching && (!job.run || job.runRetired || job.fixInProgress))
         return "running";
+    if ((job.feedbackExhausted || job.feedbackAmbiguous) && isLanded(job) && !job.fixInProgress) {
+        if (job.delivery?.merged || job.delivery?.prState === "MERGED")
+            return "done";
+        if (job.delivery?.prState === "CLOSED")
+            return "failed";
+        return "needs-human";
+    }
     if (job.run && !job.runRetired)
         return activeRunState(job);
     if (job.run && isLanded(job))
@@ -126,10 +135,16 @@ function needsDelivery(job) {
     return true;
 }
 function canLaunch(job, observation) {
-    if (job.error || job.run || job.launching || job.launchFailed)
+    if (job.error || job.run || job.launching || job.launchFailed || job.fixInProgress)
         return false;
     return dependenciesMet(job, observation);
 }
+/** An in-review job with new pull request feedback and room under `maxFixRounds`. */
+function canStartFix(job) {
+    if (job.error || job.launching || job.fixInProgress || job.fixAwaitingPublish)
+        return false;
+    return job.feedbackPlan?.action === "fix";
+}
 /** A recorded transient failure whose backoff has elapsed. One retry per tick, ahead of a new job. */
 function canRetry(job, observation, now) {
     if (job.error || job.launching || job.retriesExhausted || job.ledgerError)
@@ -164,6 +179,14 @@ export function decide(observation, now = new Date()) {
             continue;
         actions.push({ type: "deliver", jobId: job.jobId, repo: job.repo });
     }
+    for (const job of observation.jobs) {
+        if (job.feedbackPlan?.action === "exhaust") {
+            actions.push({ type: "mark-feedback", jobId: job.jobId, reason: "feedback-exhausted" });
+        }
+        else if (job.feedbackPlan?.action === "ambiguous") {
+            actions.push({ type: "mark-feedback", jobId: job.jobId, reason: "feedback-ambiguous" });
+        }
+    }
     if (inFlightCount(observation) >= observation.maxConcurrent)
         return actions;
     const retry = observation.jobs.find((job) => canRetry(job, observation, now));
@@ -171,6 +194,11 @@ export function decide(observation, now = new Date()) {
         actions.push({ type: "retry", jobId: retry.jobId, repo: retry.repo });
         return actions;
     }
+    const fix = observation.jobs.find((job) => canStartFix(job));
+    if (fix) {
+        actions.push({ type: "start-fix", jobId: fix.jobId, repo: fix.repo });
+        return actions;
+    }
     const ready = observation.jobs.filter((job) => canLaunch(job, observation));
     const healthy = ready.filter((job) => !job.launchError);
     const picked = healthy[0] ?? ready[0];

package/dist/report.js

@@ -2,6 +2,7 @@ import { readFileSync } from "node:fs";
 import { createRequire } from "node:module";
 import { dirname, join } from "node:path";
 import { readBoardFiles, readReviewRounds } from "./board.js";
+import { feedbackRoundText } from "./feedback.js";
 import { INVESTIGATION_WORKFLOW } from "./findings.js";
 import { inFlightCount, isDone, isLanded, jobState, } from "./reconcile.js";
 export function shellQuote(value) {
@@ -125,6 +126,12 @@ export function statusDetails(job) {
         lines.push(job.launchError);
     if (job.ledgerError)
         lines.push(job.ledgerError);
+    if (job.feedbackLedgerError)
+        lines.push(job.feedbackLedgerError);
+    if ((job.feedbackRounds?.length ?? 0) > 0)
+        lines.push(`feedback ${job.feedbackRounds?.length}`);
+    if (job.state === "needs-human" && job.feedbackReason)
+        lines.push(`reason ${job.feedbackReason}`);
     if (job.attemptCount > 0)
         lines.push(`attempts ${job.attemptCount}`);
     if (job.lastFailureReason)
@@ -197,10 +204,15 @@ function toStatusJob(job, observation) {
         };
     }
     const state = jobState(job, observation);
-    const gates = state === "needs-human" && job.run ? job.run.gates.map(toGateView) : [];
+    const feedbackReason = job.feedbackExhausted
+        ? "feedback-exhausted"
+        : job.feedbackAmbiguous
+            ? "feedback-ambiguous"
+            : undefined;
+    const gates = state === "needs-human" && job.run && !feedbackReason ? job.run.gates.map(toGateView) : [];
     const prNumber = job.delivery?.prNumber;
     const runId = job.run?.runId;
-    const showBranch = (state === "done" || state === "in-review") && runId !== undefined;
+    const showBranch = runId !== undefined && (state === "done" || state === "in-review" || feedbackReason !== undefined);
     const failureDetail = job.run?.stepEvents ? latestStepFailure(job.run.stepEvents) : undefined;
     return {
         jobId: job.jobId,
@@ -224,6 +236,8 @@ function toStatusJob(job, observation) {
         ...(job.lastFailureReason ? { lastFailureReason: job.lastFailureReason } : {}),
         ...(job.nextRetryAt && !job.retriesExhausted ? { nextRetryAt: job.nextRetryAt } : {}),
         ...(job.ledgerError ? { ledgerError: job.ledgerError } : {}),
+        ...(job.feedbackLedgerError ? { feedbackLedgerError: job.feedbackLedgerError } : {}),
+        ...(feedbackReason ? { feedbackReason } : {}),
         ...(job.launchError ? { launchError: job.launchError } : {}),
         ...(job.delivery?.error ? { deliveryError: job.delivery.error } : {}),
         ...(job.delivery?.viewError ? { viewError: job.delivery.viewError } : {}),
@@ -258,12 +272,29 @@ function boardFields(job) {
         ...(job.workflow ? { workflow: job.workflow } : {}),
         gates: job.run?.gates ?? [],
     });
+    for (const round of job.feedbackRounds ?? []) {
+        const label = round.trigger === "ci" ? "CI" : "review";
+        files.push({
+            id: `feedback-r${round.round}`,
+            group: "Feedback",
+            label: `R${round.round} ${label}.md`,
+            text: feedbackRoundText(round),
+            tone: round.outcome ? "good" : "warn",
+        });
+    }
     return {
         ...(rounds.length > 0 ? { rounds } : {}),
+        ...(job.feedbackRounds?.length ? { feedbackRounds: job.feedbackRounds } : {}),
         ...(files.length > 0 ? { files } : {}),
     };
 }
 function progressFor(job) {
+    if (job.fixInProgress && !job.run) {
+        return [
+            { id: "build", phase: "current" },
+            { id: "land", phase: "pending" },
+        ];
+    }
     const plan = job.run?.stepPlan?.length ? job.run.stepPlan : (job.stepPlan ?? []);
     return stepProgress(plan, job.run?.stepEvents ?? []);
 }
@@ -317,7 +348,7 @@ function blockReasons(job, observation) {
     }
     return reasons;
 }
-export function renderTick(observation, actions, launches, delivers = [], findings = [], notes = []) {
+export function renderTick(observation, actions, launches, delivers = [], findings = [], notes = [], feedbackNotes = []) {
     const lines = [`tick  inFlight=${inFlightCount(observation)}  maxConcurrent=${observation.maxConcurrent}`];
     for (const job of observation.jobs) {
         if (job.error)
@@ -341,18 +372,26 @@ export function renderTick(observation, actions, launches, delivers = [], findin
         const next = note.nextRetryAt ? `  next ${note.nextRetryAt}` : "  dead";
         lines.push(`${note.kind} ${note.jobId}  ${note.reason}  attempt ${note.attempt}${next}`);
     }
+    for (const note of feedbackNotes) {
+        if (note.trim())
+            lines.push(note);
+    }
     for (const launch of launches) {
-        lines.push(`${launch.retry ? "retry" : "launch"} ${launch.jobId}  ${launch.repo}`);
+        const verb = launch.kind === "fix" ? "fix" : launch.retry ? "retry" : "launch";
+        lines.push(`${verb} ${launch.jobId}  ${launch.repo}`);
         for (const line of launch.output.split("\n")) {
             if (line.trim())
                 lines.push(`  ${line}`);
         }
     }
-    if (!actions.some((action) => action.type === "launch" || action.type === "retry") &&
-        launches.length === 0 &&
-        delivers.length === 0 &&
-        findings.length === 0) {
+    const acted = actions.some((action) => action.type === "launch" ||
+        action.type === "retry" ||
+        action.type === "start-fix" ||
+        action.type === "mark-feedback") ||
+        launches.length > 0 ||
+        delivers.length > 0 ||
+        findings.length > 0;
+    if (!acted)
         lines.push("nothing to launch");
-    }
     return `${lines.join("\n")}\n`;
 }

package/dist/schemas.js

@@ -30,6 +30,8 @@ export const JiraConfigSchema = z.object({
 export const DEFAULT_STALL_TIMEOUT_MS = 15 * 60 * 1000;
 /** Transient failures retry until this many attempts, then the job is dead. */
 export const DEFAULT_MAX_ATTEMPTS = 3;
+/** Pull request fix rounds before the job is needs-human (`feedback-exhausted`). */
+export const DEFAULT_MAX_FIX_ROUNDS = 2;
 export const KilnConfigFileSchema = z.object({
     note: z.string().min(1).optional(),
     maxConcurrent: z.number().int().min(1).optional(),
@@ -40,6 +42,11 @@ export const KilnConfigFileSchema = z.object({
     stallTimeoutMs: z.number().int().optional(),
     /** Transient failures before the job is dead. Default 3. */
     maxAttempts: z.number().int().min(1).optional(),
+    /**
+     * Fix rounds for an open pull request before the job is needs-human with
+     * reason `feedback-exhausted`. Default 2. Kiln does not merge.
+     */
+    maxFixRounds: z.number().int().min(1).optional(),
     adapter: z.enum(["mock", "claude-code"]).optional(),
     repos: z.record(z.string(), RepoEntrySchema),
     jira: JiraConfigSchema.optional(),

package/dist/serve-page.js

@@ -2,6 +2,7 @@ import { readFileSync } from "node:fs";
 import { join } from "node:path";
 import { scheduledRetry } from "./attention.js";
 import { readBoardFiles, stageOf, stagesFor } from "./board.js";
+import { feedbackRoundLabel } from "./feedback.js";
 import { INVESTIGATION_WORKFLOW } from "./findings.js";
 import { packageRoot } from "./paths.js";
 const REVIEWERS = [
@@ -201,7 +202,12 @@ function roundsHtml(job, stage) {
     const rounds = job.rounds ?? [];
     const last = rounds[rounds.length - 1]?.n;
     const rows = rounds.map((round) => roundRow(round, stage === "review" && job.state === "running" && round.n === last));
-    if (job.state === "in-review" || (job.state === "done" && safeUrl(job.prUrl))) {
+    for (const round of job.feedbackRounds ?? []) {
+        const tone = round.outcome ? " PASS" : " CHANGES";
+        rows.push(`<div class="round"><span class="r">R${round.round}</span><span class="chip${tone}" style="grid-column: 2 / -1">${escapeHtml(feedbackRoundLabel(round))}</span></div>`);
+    }
+    const inReview = job.state === "in-review" || (job.state === "done" && safeUrl(job.prUrl));
+    if (inReview && (job.feedbackRounds?.length ?? 0) === 0) {
         const n = (last ?? 0) + 1;
         const tone = job.state === "done" ? " PASS" : "";
         rows.push(`<div class="round"><span class="r">R${n}</span><span class="chip${tone}" style="grid-column: 2 / -1">PR review</span></div>`);

package/dist/workflow.js

@@ -6,10 +6,12 @@ const FACTORY_DIRECTIVE = /^<!--\s*factory:\s*(prompts\/factory\/[a-z0-9-]+\.md)
 const WORKFLOW_NAME = /^[A-Za-z0-9][A-Za-z0-9._-]*$/;
 const FEATURE_PROMPTS = 7;
 const INVESTIGATION_PROMPTS = 1;
+const FIX_PROMPTS = 1;
 /** Prompt files Kiln rewrites before launch. A mismatch refuses the launch. */
 const PROMPT_COUNTS = {
     feature: FEATURE_PROMPTS,
     investigation: INVESTIGATION_PROMPTS,
+    fix: FIX_PROMPTS,
 };
 /**
  * Values Kiln can pass into a workflow. A workflow's inputSchema lists the

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@lchase/kiln",
-  "version": "0.4.0",
+  "version": "0.5.0",
   "description": "Run a workflow on any registered repo. A markdown spec is the input.",
   "type": "module",
   "bin": {

package/prompts/kiln/fix.md

@@ -0,0 +1,17 @@
+<!-- factory: prompts/factory/builder.md -->
+
+Kiln runs this factory agent inside yak to answer pull request feedback. The working directory is the worktree (there is no separate worktree path). There is no `.factory/` job folder and no `.factory/repo.md`; read the repo for conventions. `.factory/lessons.md` applies only when that file is really present.
+
+`<main branch>` is the base SHA `{{input.baseRef}}` (the pull request head this worktree was branched from, via yak `--from`). Use that SHA wherever the factory instructions say `<main branch>`. Do not guess `main`.
+
+Your branch is whatever `git branch --show-current` prints. It is `yak/<run-id>`. That is the branch name in this prompt. Do not BLOCK because it is not `factory/...` or `main`.
+
+Commit on that branch. Do not push. Do not force-push. Do not open a pull request. Do not approve one. Do not comment on one. Kiln fast-forwards the existing pull request branch after this run.
+
+Do not write `build.md`. Return JSON: `status` is `READY` or `BLOCKED`, `summary` is what you changed. The original spec and the feedback items are the task text below, not files.
+
+Task: {{input.title}}
+
+{{input.description}}
+
+The factory agent instructions follow. Their frontmatter is the original definition; follow the prose, and return the JSON above instead of writing the file they name.

package/workflows/fix.yaml

@@ -0,0 +1,44 @@
+# One pull-request fix, run by yak (@lchase/yak).
+#
+# The same builder as workflows/feature.yaml (factory builder, opus). Kiln
+# launches it with `yak run --isolation worktree --from <pull request head>`
+# on a job whose pull request is already open. Yak cuts a worktree branch
+# `yak/<run-id>` from that commit. The agent commits there. Kiln fast-forwards
+# the open pull request branch. This workflow does not open, approve, merge,
+# or comment on a pull request, and it does not force-push.
+name: kiln-fix
+version: "1"
+inputSchema:
+  inline:
+    type: object
+    additionalProperties: false
+    properties:
+      title: { type: string }
+      description: { type: string }
+      acceptance: { type: string }
+      runNonce: { type: string }
+      baseRef: { type: string }
+    required: [title, description, acceptance, runNonce, baseRef]
+steps:
+  - id: build
+    needs: [input]
+    agent:
+      model: opus
+      prompt:
+        file: prompts/kiln/fix.md
+      schema:
+        inline:
+          type: object
+          additionalProperties: false
+          properties:
+            summary: { type: string }
+            status: { type: string, enum: [READY, BLOCKED] }
+          required: [summary, status]
+      tools: [Read, Grep, Glob, Bash, Write, Edit, Skill]
+    produces: build
+
+  - id: land
+    needs: [input, build]
+    skipIf: 'build.status != "READY"'
+    command:
+      run: 'git add -A && git diff --cached --quiet || git commit -m "kiln: $KILN_TASK_TITLE"'