@lchase/kiln 0.11.0 → 0.13.0

package/dist/intake/jira.js

@@ -1,3 +1,4 @@
+import { spawnSync } from "node:child_process";
 import { assertCanStack, listValidJobs, renderAddedJob, writeJob } from "../jobs.js";
 import { ISSUE_KEY } from "../schemas.js";
 import { assertWorkflowName } from "../workflow.js";
@@ -89,6 +90,92 @@ export async function addFromJira(config, input) {
         warnings,
     };
 }
+/**
+ * Search Jira with the operator's token. The token stays in the child
+ * environment and is never written to stdout, a job, or an event.
+ * `POST /rest/api/3/search/jql` is the read. There is no webhook here.
+ */
+export function searchJiraIssues(config, jql, env = process.env) {
+    const query = jql.trim();
+    if (!query || query.length > 2_000)
+        throw new Error("Jira poll JQL is empty or too long.");
+    const credentials = resolveJiraCredentials(config, env);
+    const script = [
+        "const base = process.env.KILN_JIRA_BASE;",
+        "const email = process.env.KILN_JIRA_EMAIL;",
+        "const token = process.env.KILN_JIRA_TOKEN;",
+        "const jql = process.env.KILN_JIRA_JQL;",
+        "if (!base || !email || !token || !jql) { console.error('jira search is missing credentials'); process.exit(2); }",
+        "const auth = Buffer.from(email + ':' + token, 'utf8').toString('base64');",
+        "let url;",
+        "try { url = new URL('/rest/api/3/search/jql', base.endsWith('/') ? base : base + '/'); }",
+        "catch { console.error('jira base url is invalid'); process.exit(2); }",
+        "const response = await fetch(url, {",
+        "  method: 'POST',",
+        "  headers: { Authorization: 'Basic ' + auth, Accept: 'application/json', 'Content-Type': 'application/json' },",
+        "  body: JSON.stringify({ jql, maxResults: 50, fields: ['summary', 'updated', 'description'] }),",
+        "});",
+        "const text = await response.text();",
+        "if (!response.ok) { console.error('jira search failed HTTP ' + response.status); process.exit(1); }",
+        "process.stdout.write(text);",
+    ].join("\n");
+    const result = spawnSync(process.execPath, ["--input-type=module", "-e", script], {
+        encoding: "utf8",
+        timeout: 20_000,
+        env: {
+            PATH: env.PATH,
+            KILN_JIRA_BASE: credentials.baseUrl,
+            KILN_JIRA_EMAIL: credentials.email,
+            KILN_JIRA_TOKEN: credentials.apiToken,
+            KILN_JIRA_JQL: query,
+        },
+    });
+    if (result.error || result.status !== 0) {
+        const detail = (result.stderr || result.error?.message || "jira search failed").trim().split("\n")[0] ?? "jira search failed";
+        throw new Error(redactSecrets(detail, credentials).slice(0, 300));
+    }
+    let parsed;
+    try {
+        parsed = JSON.parse(result.stdout || "{}");
+    }
+    catch {
+        throw new Error("Jira search returned data that is not JSON.");
+    }
+    return parseSearchIssues(parsed, credentials);
+}
+function parseSearchIssues(payload, credentials) {
+    const issues = typeof payload === "object" && payload !== null && "issues" in payload ? payload.issues : undefined;
+    if (!Array.isArray(issues))
+        throw new Error("Jira search returned data that is not a list of issues.");
+    const out = [];
+    for (const item of issues) {
+        if (typeof item !== "object" || item === null)
+            continue;
+        const record = item;
+        if (typeof record.key !== "string")
+            continue;
+        let key;
+        try {
+            key = normalizeIssueKey(record.key);
+        }
+        catch {
+            continue;
+        }
+        const fields = typeof record.fields === "object" && record.fields !== null ? record.fields : {};
+        const summary = typeof fields.summary === "string" ? fields.summary.trim().replace(/\s+/g, " ") : "";
+        if (!summary)
+            continue;
+        const updated = typeof fields.updated === "string" && fields.updated.trim() ? fields.updated.trim() : key;
+        const description = adfToMarkdown(fields.description).trim();
+        out.push({
+            key,
+            summary: redactSecrets(summary, credentials),
+            updated: redactSecrets(updated, credentials),
+            ...(description ? { description: redactSecrets(description, credentials) } : {}),
+        });
+    }
+    return out;
+}
 export function normalizeIssueKey(raw) {
     const key = raw.trim().toUpperCase();
     if (!ISSUE_KEY.test(key)) {

package/dist/jobs.js

@@ -5,7 +5,7 @@ import { appendEvent } from "./events.js";
 import { INVESTIGATION_WORKFLOW } from "./findings.js";
 import { jobBasename } from "./paths.js";
 import { JobSchema, parseIssueKey } from "./schemas.js";
-import { assertWorkflowName } from "./workflow.js";
+import { assertWorkflowName, REVIEW_WORKFLOW } from "./workflow.js";
 export function newJobId(now = new Date()) {
     const stamp = now.toISOString().replace(/[-:TZ.]/g, "").slice(0, 14);
     return `j${stamp}${randomBytes(2).toString("hex")}`;
@@ -149,8 +149,9 @@ export function assertCanStack(repo, dependsOn, stack, known = []) {
     }
     const upstreamId = dependsOn[0];
     const upstream = known.find((job) => job.id === upstreamId);
-    if (upstream?.workflow === INVESTIGATION_WORKFLOW) {
-        throw new Error(`stack cannot target investigation job ${upstreamId}. An investigation does not land a branch.`);
+    if (upstream?.workflow === INVESTIGATION_WORKFLOW || upstream?.workflow === REVIEW_WORKFLOW) {
+        const kind = upstream.workflow === INVESTIGATION_WORKFLOW ? "investigation" : "review";
+        throw new Error(`stack cannot target ${kind} job ${upstreamId}. ${kind === "investigation" ? "An investigation" : "A review"} does not land a branch.`);
     }
     if (upstream && upstream.repo !== repo) {
         throw new Error(`stack needs upstream ${upstreamId} to be in repo ${repo}. That job is in repo ${upstream.repo}.`);

package/dist/reconcile.js

@@ -1,4 +1,5 @@
 import { INVESTIGATION_WORKFLOW } from "./findings.js";
+import { REVIEW_WORKFLOW } from "./workflow.js";
 /**
  * Why an attempt failed. Written under `<kilnDir>/attempts`, not on the job.
  * `auth-failed` is not an automatic retry: the job stays in Needs human.
@@ -118,17 +119,20 @@ export function isLanded(job) {
  * `deliver=local`: landed. `deliver=pr`: landed and the pull request has merged.
  * An investigation is done once the gate says approve. There is no pull request.
  */
+function noPullRequest(workflow) {
+    return workflow === INVESTIGATION_WORKFLOW || workflow === REVIEW_WORKFLOW;
+}
 export function isDone(job) {
     if (!isLanded(job))
         return false;
-    if (job.workflow === INVESTIGATION_WORKFLOW)
+    if (noPullRequest(job.workflow))
         return true;
     if ((job.deliver ?? "local") !== "pr")
         return true;
     return job.delivery?.merged === true || job.delivery?.prState === "MERGED";
 }
 function landedState(job) {
-    if (job.workflow === INVESTIGATION_WORKFLOW)
+    if (noPullRequest(job.workflow))
         return "done";
     if ((job.deliver ?? "local") !== "pr")
         return "done";
@@ -146,7 +150,7 @@ function landedState(job) {
 function needsDelivery(job) {
     if (job.error)
         return false;
-    if (job.workflow === INVESTIGATION_WORKFLOW)
+    if (noPullRequest(job.workflow))
         return false;
     if ((job.deliver ?? "local") !== "pr")
         return false;

package/dist/report.js

@@ -132,6 +132,10 @@ export function statusDetails(job) {
         lines.push(`findings ${job.findingsPath}`);
     else if (job.workflow === INVESTIGATION_WORKFLOW && job.state === "done")
         lines.push("findings missing");
+    if (job.reviewUrl)
+        lines.push(`review ${job.reviewUrl}`);
+    if (job.reviewPostError)
+        lines.push(job.reviewPostError);
     if (job.prPending)
         lines.push("pull request not opened yet");
     if (job.state === "failed" && job.deliveryError)
@@ -222,6 +226,8 @@ function toStatusJob(job, observation) {
             ...(job.specPath ? { specPath: job.specPath } : {}),
             ...(job.logPath ? { logPath: job.logPath } : {}),
             ...(job.findingsPath ? { findingsPath: job.findingsPath } : {}),
+            ...(job.reviewPostError ? { reviewPostError: job.reviewPostError } : {}),
+            ...(job.reviewUrl ? { reviewUrl: job.reviewUrl } : {}),
             launchFailed: job.launchFailed,
             attemptCount: job.attemptCount ?? 0,
             maxAttempts: job.attemptCap ?? observation.maxAttempts,
@@ -270,6 +276,8 @@ function toStatusJob(job, observation) {
         ...(job.logPath ? { logPath: job.logPath } : {}),
         ...(job.specPath ? { specPath: job.specPath } : {}),
         ...(job.findingsPath ? { findingsPath: job.findingsPath } : {}),
+        ...(job.reviewPostError ? { reviewPostError: job.reviewPostError } : {}),
+        ...(job.reviewUrl ? { reviewUrl: job.reviewUrl } : {}),
         launchFailed: job.launchFailed,
         attemptCount: job.attemptCount ?? 0,
         maxAttempts: job.attemptCap ?? observation.maxAttempts,

package/dist/review-post.js

@@ -0,0 +1,269 @@
+import { existsSync, readFileSync } from "node:fs";
+import { join } from "node:path";
+import { appendEvent, readEvents } from "./events.js";
+import { classifyFailureText } from "./failure.js";
+import { realGitHub } from "./host.js";
+import { redact } from "./redact.js";
+import { parseReviewSource } from "./triggers.js";
+/**
+ * A review draft the human has not posted yet, and the COMMENT review Kiln
+ * writes after they approve the Inbox gate.
+ *
+ * The review event is always COMMENT. Kiln does not approve, request
+ * changes, or merge. A second approve at the same `review:<repo>:<number>:<sha>`
+ * does not post again.
+ */
+export const REVIEW_SEVERITIES = ["note", "nit", "warning", "blocking"];
+const NEEDS_HUMAN_REASON = "review-post";
+/** Target of a review-request job, or undefined when the draft is not tied to a pull request. */
+export function reviewTargetFrom(repo, sourceRef) {
+    if (!sourceRef)
+        return undefined;
+    const parsed = parseReviewSource(sourceRef);
+    if (!parsed || parsed.repo !== repo)
+        return undefined;
+    return {
+        repo: parsed.repo,
+        number: parsed.number,
+        sha: parsed.sha,
+        dedupe: `review:${parsed.repo}:${parsed.number}:${parsed.sha}`,
+    };
+}
+export function reviewAlreadyPosted(events, dedupe) {
+    return events.some((event) => event.event === "review.posted" && event.properties.dedupe === dedupe);
+}
+/**
+ * Latest post for this job. A `review.posted` for the same dedupe, including
+ * one recorded on another job, counts as posted.
+ */
+export function reviewPostForJob(events, job) {
+    const dedupe = job.source?.kind === "trigger" ? reviewTargetFrom(job.repo, job.source.ref)?.dedupe : undefined;
+    let url;
+    let error;
+    for (const event of events) {
+        const posted = event.event === "review.posted" &&
+            (event.job_id === job.jobId || (dedupe !== undefined && event.properties.dedupe === dedupe));
+        if (posted) {
+            url = event.properties.url;
+            error = undefined;
+            continue;
+        }
+        if (event.event === "review.failed" && event.job_id === job.jobId) {
+            url = undefined;
+            error = `Could not post the review (${event.properties.class}). ${event.properties.detail}`;
+        }
+    }
+    return { ...(url ? { url } : {}), ...(error ? { error } : {}) };
+}
+/** The draft step's artifact. Missing or unreadable is undefined. Extra fields are ignored. */
+export function readReviewDraft(checkout, runId) {
+    const path = join(checkout, ".runs", runId, "artifacts", "draft.json");
+    if (!existsSync(path))
+        return undefined;
+    try {
+        return parseReviewDraft(JSON.parse(readFileSync(path, "utf8")));
+    }
+    catch {
+        return undefined;
+    }
+}
+export function parseReviewDraft(value) {
+    if (typeof value !== "object" || value === null)
+        return undefined;
+    const markdown = value.markdown;
+    if (typeof markdown !== "string" || !markdown.trim())
+        return undefined;
+    const raw = value.findings;
+    const findings = [];
+    if (Array.isArray(raw)) {
+        for (const item of raw) {
+            const finding = parseFinding(item);
+            if (finding)
+                findings.push(finding);
+        }
+    }
+    return { markdown: markdown.trim(), findings };
+}
+/**
+ * Body is the draft markdown. Findings with a real file and line become
+ * inline comments. Anything else is folded into the body when the markdown
+ * does not already contain it. Line numbers are never invented.
+ */
+export function buildCommentReview(draft) {
+    const comments = [];
+    const skipped = [];
+    for (const finding of draft.findings) {
+        const path = commentPath(finding.file);
+        const line = commentLine(finding.line);
+        if (!path || line === undefined) {
+            skipped.push(finding);
+            continue;
+        }
+        comments.push({ path, line, body: commentText(finding) });
+    }
+    return {
+        body: redact(foldSkipped(draft.markdown, skipped)),
+        comments: comments.map((comment) => ({ ...comment, body: redact(comment.body) })),
+        findings: draft.findings.length,
+        inline: comments.length,
+        skipped: skipped.length,
+    };
+}
+/**
+ * Post the approved draft, or do nothing when that head SHA was already
+ * posted. Throws without calling gh when the factory is paused, the daily
+ * cap is blocking, or the post fails. The caller leaves the gate open on throw.
+ */
+export function postApprovedReview(input) {
+    const target = reviewTargetFrom(input.repo, input.sourceRef);
+    if (!target) {
+        recordNeedsHuman(input);
+        throw new Error("This review draft is not tied to a pull request, so Kiln will not post it.");
+    }
+    const events = readEvents(input.kilnDir, { warn: () => { } });
+    if (reviewAlreadyPosted(events, target.dedupe))
+        return;
+    if (input.paused) {
+        throw new Error("Paused. Kiln will not post this review until kiln resume.");
+    }
+    if (input.spendBlocked) {
+        throw new Error("Daily cap reached. Kiln will not post this review until the local day rolls over.");
+    }
+    const draft = readReviewDraft(input.checkout, input.runId);
+    if (!draft) {
+        failPost(input, target, "deterministic", "The draft artifact is missing or unreadable.");
+    }
+    const review = buildCommentReview(draft);
+    const poster = input.host.github.postCommentReview ?? realGitHub.postCommentReview;
+    if (!poster) {
+        failPost(input, target, "deterministic", "gh cannot post a review from this host.");
+    }
+    let posted;
+    try {
+        posted = poster.call(input.host.github, {
+            checkout: input.checkout,
+            number: target.number,
+            commitId: target.sha,
+            body: review.body,
+            comments: review.comments,
+        });
+    }
+    catch (error) {
+        const detail = publicDetail(error);
+        failPost(input, target, classifyFailureText(detail), detail);
+    }
+    appendEvent(input.kilnDir, {
+        job_id: input.jobId,
+        run_id: input.runId,
+        event: "review.posted",
+        step: "approve",
+        properties: {
+            repo: target.repo,
+            number: target.number,
+            sha: target.sha,
+            review_id: posted.id,
+            url: posted.url,
+            findings: review.findings,
+            inline: review.inline,
+            skipped: review.skipped,
+            dedupe: target.dedupe,
+            once: `posted:${target.dedupe}`,
+        },
+    });
+}
+function failPost(input, target, failureClass, detail) {
+    const clipped = detail.trim() || "The review was not posted.";
+    appendEvent(input.kilnDir, {
+        job_id: input.jobId,
+        run_id: input.runId,
+        event: "review.failed",
+        step: "approve",
+        properties: {
+            repo: target.repo,
+            number: target.number,
+            sha: target.sha,
+            class: failureClass,
+            detail: clipped,
+            dedupe: target.dedupe,
+        },
+    });
+    recordNeedsHuman(input);
+    throw new Error(`Could not post the review (${failureClass}). ${clipped}`);
+}
+function recordNeedsHuman(input) {
+    appendEvent(input.kilnDir, {
+        job_id: input.jobId,
+        run_id: input.runId,
+        event: "needs-human",
+        step: "approve",
+        properties: { reason: NEEDS_HUMAN_REASON, once: `needs-human:${NEEDS_HUMAN_REASON}` },
+    });
+}
+function publicDetail(error) {
+    const message = error instanceof Error ? error.message : String(error);
+    const cleaned = redact(message).replace(/\s+/g, " ").trim();
+    if (cleaned.length > 500)
+        return `${cleaned.slice(0, 499)}…`;
+    return cleaned || "The review was not posted.";
+}
+function parseFinding(value) {
+    if (typeof value !== "object" || value === null)
+        return undefined;
+    const record = value;
+    if (typeof record.comment !== "string" || !record.comment.trim())
+        return undefined;
+    const severity = REVIEW_SEVERITIES.find((item) => item === record.severity) ?? "note";
+    const file = typeof record.file === "string" ? record.file : undefined;
+    const line = commentLine(record.line);
+    return {
+        severity,
+        comment: record.comment.trim(),
+        ...(file !== undefined ? { file } : {}),
+        ...(line !== undefined ? { line } : {}),
+    };
+}
+/** A relative path inside the repo. Absolute paths and `..` are not locations. A leading `./` is a normal relative path. */
+export function commentPath(file) {
+    if (!file)
+        return undefined;
+    const raw = file.trim().replace(/\\/g, "/");
+    if (!raw || raw.startsWith("/") || raw.startsWith("~") || /^[A-Za-z]:/.test(raw))
+        return undefined;
+    if (/[\0\r\n]/.test(raw))
+        return undefined;
+    const parts = raw.split("/");
+    if (parts.some((part) => part === "" || part === ".."))
+        return undefined;
+    const cleaned = parts.filter((part) => part !== ".");
+    if (cleaned.length === 0)
+        return undefined;
+    return cleaned.join("/");
+}
+function commentLine(line) {
+    if (typeof line !== "number" || !Number.isInteger(line) || line < 1)
+        return undefined;
+    return line;
+}
+function commentText(finding) {
+    const text = finding.comment.trim();
+    if (finding.severity === "nit")
+        return `**nit** (not blocking)\n\n${text}`;
+    return `**${finding.severity}**\n\n${text}`;
+}
+function foldSkipped(markdown, skipped) {
+    const base = markdown.trim();
+    const extra = skipped.filter((finding) => !base.includes(finding.comment.trim()));
+    if (extra.length === 0)
+        return `${base}\n`;
+    const lines = [
+        base,
+        "",
+        "## Not posted on a line",
+        "",
+        "These findings had no file and line Kiln could check, so they are only in this review.",
+        "",
+    ];
+    for (const finding of extra)
+        lines.push(`- **${finding.severity}** ${finding.comment.trim()}`);
+    return `${lines.join("\n")}\n`;
+}

package/dist/schemas.js

@@ -127,8 +127,45 @@ const maxFixRounds = z
 /**
  * The subset `kiln serve` settings can edit. The file schema below uses these
  * same field validators. Settings does not accept jira, tokens, adapter,
- * workflows, or sandbox image.
+ * workflows, or sandbox image. Trigger edits are enable/disable only.
  */
+const TRIGGER_ID = /^[A-Za-z0-9][A-Za-z0-9._-]*$/;
+/**
+ * One trigger in `kiln.config.json`. `enabled` defaults to true.
+ * `schedule` uses `cron` (5 fields, local time). `jira` uses `jql` or
+ * `label` / `status` (compiled to JQL) and `every` (default `5m`).
+ * `pr` is the built-in Kiln-owned pull request source.
+ */
+export const TriggerConfigSchema = z
+    .object({
+    id: z.string().regex(TRIGGER_ID, "Trigger id must start with a letter or digit."),
+    enabled: z.boolean().optional(),
+    kind: z.enum(["schedule", "jira", "pr"]),
+    cron: z.string().min(1).optional(),
+    every: z.string().min(1).optional(),
+    repo: z.string().regex(REPO_NAME).optional(),
+    jql: z.string().min(1).optional(),
+    label: z.string().min(1).optional(),
+    status: z.string().min(1).optional(),
+})
+    .strict();
+/** Maps a trigger id to create a job or attach to one. Hot-reloaded with the config. */
+export const RouteConfigSchema = z
+    .object({
+    id: z.string().regex(TRIGGER_ID, "Route id must start with a letter or digit."),
+    trigger: z.string().regex(TRIGGER_ID),
+    action: z.enum(["create", "attach"]),
+    workflow: z.string().min(1).optional(),
+    repo: z.string().regex(REPO_NAME).optional(),
+})
+    .strict();
+/** Settings API body for enable/disable. Other trigger fields stay in the file. */
+export const TriggerToggleSchema = z
+    .object({
+    id: z.string().regex(TRIGGER_ID),
+    enabled: z.boolean(),
+})
+    .strict();
 export const EditableKilnSettingsSchema = z.object({
     repos: KilnReposSchema,
     stallTimeoutMs,
@@ -137,6 +174,7 @@ export const EditableKilnSettingsSchema = z.object({
     maxSameFingerprint,
     dailyDollarCap,
     sandbox: EditableSandboxSchema.optional(),
+    triggers: z.array(TriggerToggleSchema).optional(),
 });
 /** PUT /api/settings body. `revision` is the sha256 of the file the client loaded. */
 export const SettingsWriteSchema = EditableKilnSettingsSchema.extend({
@@ -156,14 +194,24 @@ export const KilnConfigFileSchema = z.object({
     workflows: z.record(z.string().regex(WORKFLOW_KEY), z.object({ sandbox: SandboxSettingsSchema.optional() })).optional(),
     repos: KilnReposSchema,
     jira: JiraConfigSchema.optional(),
+    /** Clock, Jira poll, and pull-request sources. Omitted entries use the built-ins. */
+    triggers: z.array(TriggerConfigSchema).optional(),
+    /** Trigger id → create a job or attach to an existing one. */
+    routes: z.array(RouteConfigSchema).optional(),
+    /**
+     * Reviewer prompt file. Relative paths resolve from the config directory.
+     * Omitted uses the packaged `prompts/kiln/review.md`.
+     */
+    reviewPrompt: z.string().min(1).optional(),
 });
 /**
  * Where a job came from. Adapters set this; tick and reconcile do not branch on it.
  * `ref` is an absolute spec path (`file`), `inline` or `stdin` (`prompt`), the
- * absolute ticket path (`tickets`), or the issue key (`jira`, such as `PROJ-123`).
+ * absolute ticket path (`tickets`), the issue key (`jira`, such as `SAMPLE-1`),
+ * or the trigger dedupe key (`trigger`).
  */
 export const JobSourceSchema = z.object({
-    kind: z.enum(["file", "prompt", "tickets", "jira"]),
+    kind: z.enum(["file", "prompt", "tickets", "jira", "trigger"]),
     ref: z.string().min(1),
 });
 /**

package/dist/serve-page.js

@@ -110,6 +110,7 @@ ${repos}
 ${item("/history", "history", "History", "history", board.history.length)}
 ${item("/stats", "stats", "Stats", "stats")}
 ${item("/report", "report", "Today", "report")}
+${item("/triggers", "triggers", "Triggers", "triggers")}
 ${item("/settings", "open-settings", "Settings", "settings")}
 </nav>`;
 }
@@ -127,15 +128,45 @@ function mainHtml(model, page) {
     if (model.section === "job" && model.detail) {
         return `${error}<main class="main detail">${detailHtml(model.detail, model.tab ?? "overview", page.csrf)}</main>`;
     }
+    if (model.section === "triggers") {
+        return `${error}<main class="main">${triggersHtml(model.triggers ?? [])}</main>`;
+    }
     return `${error}<main class="main">${listHtml(model, page.csrf)}</main>`;
 }
+function triggersHtml(rows) {
+    const body = rows.length === 0
+        ? `<p class="empty">No triggers.</p>`
+        : rows.map((row) => triggerCard(row)).join("\n");
+    return `<header class="list-head"><h2>Triggers</h2><p class="meta">The clock, Jira, and pull request activity can start work. A review is posted only after you approve it. Kiln does not approve or merge.</p><p class="form-error" id="trigger-error" role="alert" hidden></p></header>${body}`;
+}
+function triggerCard(row) {
+    const on = row.enabled;
+    const bits = [row.kind, row.schedule, on ? "enabled" : "disabled"];
+    const next = row.nextFire ? `<p class="meta">next <time datetime="${escapeHtml(row.nextFire)}" data-time>${escapeHtml(row.nextFire)}</time></p>` : "";
+    const last = row.lastFire ? `<p class="meta">last fire <time datetime="${escapeHtml(row.lastFire)}" data-time>${escapeHtml(row.lastFire)}</time></p>` : `<p class="meta">last fire none</p>`;
+    const error = row.lastError
+        ? `<p class="err">last error${row.lastErrorAt ? ` <time datetime="${escapeHtml(row.lastErrorAt)}" data-time>${escapeHtml(row.lastErrorAt)}</time>` : ""}: ${escapeHtml(row.lastError)}</p>`
+        : "";
+    const recent = row.recent.length === 0
+        ? `<p class="empty">No routed events yet.</p>`
+        : `<ul class="recent">${row.recent
+            .map((item) => `<li><time datetime="${escapeHtml(item.ts)}" data-time>${escapeHtml(item.ts)}</time> <span class="ev">${escapeHtml(item.event)}</span> ${escapeHtml(item.summary)}</li>`)
+            .join("")}</ul>`;
+    return `<article class="trigger" id="trigger-${escapeHtml(row.id)}">
+<h3>${escapeHtml(row.id)}</h3>
+<p class="meta">${escapeHtml(bits.join(" · "))}</p>
+${next}${last}${error}
+<button type="button" data-trigger-toggle="${escapeHtml(row.id)}" data-enabled="${on ? "true" : "false"}">${on ? "Disable" : "Enable"}</button>
+${recent}
+</article>`;
+}
 function listHtml(model, csrf) {
     const board = model.board;
     if (model.section === "inbox") {
         return `<header class="list-head"><h2>Inbox</h2><p class="meta">Approve, reject, or revise. Kiln does not do this on its own.</p></header>${jobList(board.inbox, "inbox", "Nothing is waiting on a gate.", csrf)}`;
     }
     if (model.section === "hand") {
-        return `<header class="list-head"><h2>Needs a hand</h2><p class="meta">A breaker tripped, a cap was hit, or a run failed with no retry left.</p></header>${jobList(board.hand, "hand", "Nothing needs a person.", csrf)}`;
+        return `<header class="list-head"><h2>Needs a hand</h2><p class="meta">A breaker tripped, a cap was hit, a review could not be posted, or a run failed with no retry left.</p></header>${jobList(board.hand, "hand", "Nothing needs a person.", csrf)}`;
     }
     if (model.section === "history") {
         return `<header class="list-head"><h2>History</h2></header>${jobList(board.history, "history", "No finished jobs.", csrf)}`;
@@ -235,7 +266,7 @@ function dependsHtml(job) {
     return `<p class="deps">depends on ${links}</p>${detail ? `<p class="meta">${escapeHtml(detail)}</p>` : ""}`;
 }
 function actionsHtml(job, section, csrf) {
-    const showGate = section === "inbox" || section === "job";
+    const showGate = section === "inbox" || section === "job" || (section === "hand" && Boolean(job.reviewPostError));
     const showRetry = section === "hand" || section === "repos" || section === "job";
     if (!showGate && !showRetry)
         return "";

package/dist/serve.js

@@ -10,13 +10,14 @@ import { browse } from "./fs-browse.js";
 import { branchOf, buildBoard, dayReport, jobDetail, parseSeenQuery, parseStatsWindow, readBranchCommits, readDiffStat, statsFor, unseenChanges, } from "./board-view.js";
 import { appendEvent, eventsForJob, readEvents } from "./events.js";
 import { INVESTIGATION_WORKFLOW } from "./findings.js";
-import { defaultHost } from "./host.js";
+import { productionHost } from "./host.js";
 import { intakeJobs } from "./intake-http.js";
 import { jobBasename, packageRoot } from "./paths.js";
 import { SANDBOX_PREFLIGHT_PREFIX } from "./sandbox.js";
 import { renderApp, renderMessagePage, renderTextPage } from "./serve-page.js";
 import { isPaused, pauseFactory, resumeFactory, spendFor } from "./rails.js";
 import { readSettings, saveSettings } from "./settings.js";
+import { triggerRows } from "./triggers.js";
 import { listWorkflowNames } from "./workflow.js";
 const BODY_LIMIT = 65_536;
 const TEXT_LIMIT = 100_000;
@@ -43,6 +44,7 @@ export function startServe(options) {
         let stopped = false;
         let timer;
         let firstTick;
+        let triggerStartup = true;
         const shutdown = () => {
             if (stopped)
                 return;
@@ -68,8 +70,10 @@ export function startServe(options) {
             const tick = () => {
                 if (stopped)
                     return;
+                const startup = triggerStartup;
+                triggerStartup = false;
                 refreshLiveConfig(state);
-                safeTick(state.config, state.secrets, false);
+                safeTick(state.config, state.secrets, startup);
             };
             firstTick = setTimeout(tick, 0);
             timer = setInterval(tick, options.tickSeconds * 1000);
@@ -83,9 +87,9 @@ export function loadServeCss() {
     }
     return readFileSync(path, "utf8");
 }
-function safeTick(config, secrets, startup) {
+function safeTick(config, secrets, triggerStartup) {
     try {
-        const report = runTick(config, defaultHost(), { startup });
+        const report = runTick(config, productionHost(), { startup: false, triggerStartup });
         if (report.startsWith(SANDBOX_PREFLIGHT_PREFIX) || report.startsWith(AUTH_PREFLIGHT_PREFIX)) {
             const tickAt = report.indexOf("\ntick ");
             const head = tickAt === -1 ? report : report.slice(0, tickAt);
@@ -734,6 +738,8 @@ function listSection(path) {
         return "report";
     if (path === "/settings")
         return "settings";
+    if (path === "/triggers")
+        return "triggers";
     return undefined;
 }
 function renderShell(state, css, csrf, section, extra = {}) {
@@ -751,6 +757,9 @@ function renderShell(state, css, csrf, section, extra = {}) {
         ...(section === "stats" && extra.window ? { stats: statsDocument(state, extra.window) } : {}),
         ...(section === "report" ? { report: reportDocument(state) } : {}),
         ...(extra.detail ? { detail: extra.detail, tab: extra.tab ?? "overview" } : {}),
+        ...(section === "triggers"
+            ? { triggers: triggerRows(state.config, readEvents(state.config.kilnDir, { warn: () => { } })) }
+            : {}),
     });
 }
 function boardPayload(state) {