@alphacoder-v0/pi-loops 0.20.0 → 0.22.1

package/src/cli.ts

@@ -15,8 +15,11 @@ import * as path from "node:path";
 import * as readline from "node:readline";
 import { fileURLToPath } from "node:url";
 import { SessionManager, getAgentDir } from "@earendil-works/pi-coding-agent";
-import { exportSession, defaultExportPath, importSession, inspectArchive } from "./archive.ts";
+import { applyImport, automationOf, exportSession, defaultExportPath, importSession, inspectArchive, offerToEnable, parseActivateMode } from "./archive.ts";
 import { askHost, renderHostSnapshot } from "./host-control-channel.ts";
+import { FINDING_FIELDS, Inbox, type InboxEntry, inProject, resolveInboxRef } from "./inbox.ts";
+import { sameProject } from "./presence.ts";
+import { redact } from "./redact.ts";
 import { liveHost, stopHost } from "./host-control.ts";
 import { type UiPrefs, readUiPrefs } from "./ui-prefs.ts";
 import { JobStore, defaultLoopsDir } from "./store.ts";
@@ -96,7 +99,7 @@ export const CLI_USAGE = [
 	"",
 	"pi-loops import <file> [--cwd <dir>] [--activate-triggers=off|ask|on]",
 	"    Restore an archive into --cwd (default: the current directory).",
-	"    Imported automation stays disabled unless --activate-triggers=on (ask: prompt on a terminal).",
+	"    --activate-triggers: off never asks, on activates, ask (the default) prompts after the import.",
 	"",
 	"pi-loops sessions [--all] [--limit <n>]",
 	"    List sessions, newest first: short id, when it started, its automation, what was first said in it.",
@@ -110,6 +113,10 @@ export const CLI_USAGE = [
 	"pi-loops recipe list | show <name|path> | add <name|path> [--cwd <dir>] [--level report|propose|act] [--overwrite]",
 	"    The packaged recipes; what one installs; copy its playbooks into a project (.agents/skills/<name>/).",
 	"    The setup script and the jobs need a pi open in the project: /recipe add <name> finds the copies and finishes.",
+	"",
+	"pi-loops inbox list [--all] [--cwd <dir>] | claim <id> | dismiss <id> [--reason <text>]   [--json]",
+	"    The triage inbox with no pi open: what /inbox lists, and the two things it does to a finding.",
+	"    --json prints the shape docs/downstream.md fixes for programs.",
 ].join("\n");
 
 /**
@@ -188,6 +195,12 @@ interface Parsed {
 	flags: Map<string, string | true>;
 }
 
+/**
+ * Flags that never take a value, so the word after them is a positional: `inbox claim --json <id>`
+ * must not read the id as the value of `--json`.
+ */
+const BOOLEAN_FLAGS = new Set(["all", "json", "check", "overwrite", "exclude-triggers", "help"]);
+
 export function parseCliArgs(argv: string[]): Parsed {
 	const [command = "", ...rest] = argv;
 	const positional: string[] = [];
@@ -200,7 +213,7 @@ export function parseCliArgs(argv: string[]): Parsed {
 		}
 		const eq = arg.indexOf("=");
 		if (eq > 0) flags.set(arg.slice(2, eq), arg.slice(eq + 1));
-		else if (rest[i + 1] !== undefined && !rest[i + 1].startsWith("--")) flags.set(arg.slice(2), rest[++i]);
+		else if (!BOOLEAN_FLAGS.has(arg.slice(2)) && rest[i + 1] !== undefined && !rest[i + 1].startsWith("--")) flags.set(arg.slice(2), rest[++i]);
 		else flags.set(arg.slice(2), true);
 	}
 	return { command, positional, flags };
@@ -250,6 +263,7 @@ export async function runCli(argv: string[], out: (line: string) => void = conso
 	if (command === "upgrade") return upgrade(flags.has("check"), out);
 	if (command === "install-launcher") return installLauncher(str("dir"), out);
 	if (command === "recipe") return recipeCommand(positional, { level: str("level"), overwrite: flags.has("overwrite") }, cwd, loopsDir, out);
+	if (command === "inbox") return inboxCommand(positional, { all: flags.has("all"), json: flags.has("json"), reason: flags.get("reason") }, cwd, loopsDir, out);
 
 	if (command === "sessions") {
 		// `pickSession` refuses an unknown id, and there was no way to discover one.
@@ -287,9 +301,9 @@ export async function runCli(argv: string[], out: (line: string) => void = conso
 		const sessions = listSessions(path.join(agentDir, "sessions"));
 		const picked = pickSession(sessions, { id: str("session"), cwd });
 		const jobStore = new JobStore(loopsDir);
-		// The archive carries this project's automation, the way the slash command does.
-		const jobs = jobStore.load().filter((job) => job.cwd === picked.cwd);
-		const rules = new TriggerStore(loopsDir).load().filter((rule) => rule.cwd === picked.cwd);
+		// The archive carries what the picked session created in its project — the one rule
+		// `/session-export` follows too, in `automationOf`.
+		const { jobs, rules } = automationOf(jobStore.load(), new TriggerStore(loopsDir).load(), picked.cwd, picked.id);
 		const states: Record<string, string> = {};
 		for (const job of jobs) {
 			const loopState = job.stateful ? jobStore.readState(job.id) : undefined;
@@ -305,28 +319,31 @@ export async function runCli(argv: string[], out: (line: string) => void = conso
 	if (command === "import") {
 		const file = positional[0];
 		if (!file) throw new Error("import needs an archive path");
-		const mode = str("activate-triggers") ?? "off";
-		if (!["off", "ask", "on"].includes(mode)) throw new Error(`--activate-triggers must be off, ask or on (got ${mode})`);
+		const mode = parseActivateMode(str("activate-triggers"));
 		const jobStore = new JobStore(loopsDir);
 		const triggerStore = new TriggerStore(loopsDir);
 		// pi encodes a project as `--home-u-proj--` and `SessionManager.list()` reads only that one
 		// directory, with no fallback — a hand-rolled name here would restore a session pi never sees.
 		const sessionDir = SessionManager.create(cwd).getSessionDir();
-		const activate = mode === "on" || (mode === "ask" && (await askYesNo("Activate the imported automation now?")));
 		const existingJobs = jobStore.load();
 		const existingRules = triggerStore.load();
-		const summary = importSession({ archivePath: path.resolve(file), sessionDir, targetCwd: cwd, activate, existingJobs, existingRules, existingJobIds: new Set(existingJobs.map((j) => j.id)), existingRuleIds: new Set(existingRules.map((r) => r.id)) });
-		// The same order the slash command uses, so a half-import leaves neither store inconsistent.
-		if (summary.jobs.length) await jobStore.mutate((jobs) => ({ jobs: [...jobs, ...summary.jobs], result: undefined }));
-		for (const [id, text] of Object.entries(summary.states)) jobStore.writeState(id, text);
-		if (summary.rules.length) await triggerStore.mutate((rules) => rules.push(...summary.rules));
+		const summary = importSession({ archivePath: path.resolve(file), sessionDir, targetCwd: cwd, activate: mode === "on", existingJobs, existingRules, existingJobIds: new Set(existingJobs.map((j) => j.id)), existingRuleIds: new Set(existingRules.map((r) => r.id)) });
+		// The writes and the rollback the slash command does, in `applyImport`.
+		await applyImport(summary, jobStore, triggerStore);
 		const skipped = (summary.skippedJobs ?? 0) + (summary.skippedRules ?? 0);
 		// The id and the notes come out of the archive's own header, like everything `inspect` prints.
 		out(`imported ${plain(summary.originalSessionId)} → ${summary.sessionId}`);
 		out(`entries=${plain(String(summary.entryCount))} cron=${summary.jobs.length} triggers=${summary.rules.length} automation=${summary.automationEnabled ? "enabled" : "disabled"}${skipped ? ` skipped=${skipped} (already imported)` : ""}`);
 		for (const note of summary.notes ?? []) out(`note: ${plain(note)}`);
 		out(`session: ${summary.sessionPath}`);
-		if (!summary.automationEnabled && (summary.jobs.length || summary.rules.length)) out("automation is disabled; enable it with /cron enable <id> or re-import with --activate-triggers=on");
+		// `ask` is the default: the same question the slash command asks, once, after the import.
+		// `askYesNo` already answers no with no terminal to ask at.
+		const enabled = await offerToEnable(summary, jobStore, triggerStore, mode === "ask" ? (question, detail) => {
+			if (process.stdin.isTTY) out(detail); // what the dialog shows above the question
+			return askYesNo(question);
+		} : undefined);
+		if (enabled.jobs || enabled.rules) out(`enabled ${enabled.jobs} cron job(s) and ${enabled.rules} trigger rule(s)`);
+		else if (!summary.automationEnabled && (summary.jobs.length || summary.rules.length)) out("automation is disabled; enable it with /cron enable <id> or re-import with --activate-triggers=on");
 		return 0;
 	}
 
@@ -393,7 +410,77 @@ export async function runCli(argv: string[], out: (line: string) => void = conso
 	return asked ? 2 : 0;
 }
 
-const SUBCOMMANDS = new Set(["export", "import", "sessions", "inspect", "host", "recipe", "web", "upgrade", "install-launcher", "help"]);
+const SUBCOMMANDS = new Set(["export", "import", "sessions", "inspect", "host", "recipe", "inbox", "web", "upgrade", "install-launcher", "help"]);
+
+/**
+ * `pi-loops inbox`: `/inbox list|claim|dismiss` for a shell with no pi open, and — with `--json` —
+ * for a program. The JSON is the contract in docs/downstream.md: the fields, their names and their
+ * types are fixed there, and `test/downstream/inbox.sh` reads them back with jq. What is not fixed:
+ * the plain text, which is for a person at a prompt. A claim here marks the finding and stops,
+ * since there is no session to hand it to; the caller is the one who acts on it.
+ */
+async function inboxCommand(positional: string[], opts: { all: boolean; json: boolean; reason?: string | true }, cwd: string, loopsDir: string, out: (line: string) => void): Promise<number> {
+	const fail = (why: string): number => {
+		out(opts.json ? JSON.stringify({ error: why }) : why);
+		return 1;
+	};
+	try {
+		return await inboxCommandBody(positional, opts, cwd, loopsDir, out, fail);
+	} catch (err: any) {
+		// A program reads one object either way: an unreadable file or a lock that timed out is an
+		// `error` on stdout, not a usage dump on stderr.
+		return fail(err?.message ?? String(err));
+	}
+}
+
+async function inboxCommandBody(positional: string[], opts: { all: boolean; json: boolean; reason?: string | true }, cwd: string, loopsDir: string, out: (line: string) => void, fail: (why: string) => number): Promise<number> {
+	const sub = positional[0] ?? "list";
+	const inbox = new Inbox(loopsDir);
+	if (sub === "list") {
+		const entries = opts.all ? inbox.listNew() : inProject(inbox.listNew(), cwd, sameProject);
+		if (opts.json) {
+			out(JSON.stringify({ findings: entries.map(findingJson) }));
+			return 0;
+		}
+		if (!entries.length) out(opts.all ? "inbox: nothing new on this machine" : `inbox: nothing new in ${cwd} (--all lists every project)`);
+		for (const e of entries) out(findingLine(e));
+		return 0;
+	}
+	if (sub === "claim" || sub === "dismiss") {
+		const ref = positional[1];
+		if (!ref) return fail(`inbox ${sub} needs a finding id`);
+		if (opts.reason === true) return fail("--reason needs a text (--reason=<text> when it starts with --)");
+		// An id or a prefix resolves machine-wide, as it does in /inbox, and only among what is new:
+		// a finding already claimed or dismissed is not decided twice. A number resolves to nothing
+		// here — `/inbox claim 3` is the number on a screen, and this command printed none — and the
+		// digits only pick the wording, since "no entry matching '1'" reads like a missing finding.
+		const entry = resolveInboxRef(inbox.listNew(), ref);
+		if (!entry) return fail(/^\d+$/.test(ref.trim()) ? `inbox ${sub} takes a finding id (inb-…) or a prefix of one, not a number` : `no new inbox entry matching '${ref}'`);
+		const updated = await inbox.setStatus(entry.id, sub === "claim" ? "claimed" : "dismissed", sub === "claim" ? "cli" : undefined, opts.reason);
+		if (!updated) return fail(`inbox entry ${entry.id} is gone`);
+		out(opts.json ? JSON.stringify({ finding: findingJson(updated) }) : `${updated.status} ${updated.id}`);
+		return 0;
+	}
+	return fail(`unknown inbox command ${JSON.stringify(sub)} (list | claim <id> | dismiss <id> [--reason <text>])`);
+}
+
+/**
+ * One finding as docs/downstream.md fixes it: the contract's fields of the entry and nothing else,
+ * in their order, with what a person may read redacted. Fields are added at the end, never renamed.
+ */
+function findingJson(e: InboxEntry): Record<string, unknown> {
+	const out: Record<string, unknown> = {};
+	for (const field of FINDING_FIELDS) out[field] = e[field];
+	out.text = redact(e.text);
+	out.dismiss_reason = e.dismiss_reason === null ? null : redact(e.dismiss_reason);
+	return out;
+}
+
+/** A person's line: the full id (it is what `claim` takes), the finding, where and when it came from. */
+function findingLine(e: InboxEntry): string {
+	const mark = `${e.kind === "checkpoint" ? "⚑ " : ""}${e.verified ? "✓ " : ""}`;
+	return `${e.id}  ${mark}${plain(redact(e.text))}  (${path.basename(e.cwd) || e.cwd || "—"}, ${e.source}, ${e.created_at})`;
+}
 
 /**
  * `pi-loops recipe`: the deterministic part of `/recipe`, for a shell with no pi open. `add` copies
@@ -492,12 +579,21 @@ function packageRoot(): string {
 	return path.join(path.dirname(fileURLToPath(import.meta.url)), "..");
 }
 
-/** Where this copy came from and what it is called, so an upgrade goes back to the same place. */
-function manifest(): { name?: string; repositoryUrl?: string } {
+/**
+ * Where this copy came from and what it is called, so an upgrade goes back to the same place —
+ * plus the `host/owner/repo` inside that URL, which is how pi spells the same repository in a
+ * `git:` spec and on disk. The URL is read here and nowhere else, so the two cannot drift apart.
+ */
+function manifest(): { name?: string; repositoryUrl?: string; repoPath?: string } {
 	try {
 		const pkg = JSON.parse(fs.readFileSync(path.join(packageRoot(), "package.json"), "utf8"));
 		const url = String(pkg?.repository?.url ?? "").replace(/^git\+/, "").replace(/\.git$/, "");
-		return { name: typeof pkg?.name === "string" ? pkg.name : undefined, repositoryUrl: url || undefined };
+		const at = /(?:^|@|\/\/)([^/@\s]+\.[a-z]{2,})[/:]([^/\s]+)\/([^/\s]+)$/.exec(url);
+		return {
+			name: typeof pkg?.name === "string" ? pkg.name : undefined,
+			repositoryUrl: url || undefined,
+			repoPath: at ? `${at[1]}/${at[2]}/${at[3]}` : undefined,
+		};
 	} catch {
 		return {}; // installed without its package.json: nothing to ask
 	}
@@ -687,17 +783,41 @@ export async function installLauncherWithConfirm(args: string[], confirm: (title
 	const target = launcherTarget(dir);
 	if (!target) return installLauncher(undefined, out);
 	const reach = isOnPath(target) ? ["Afterwards `pi-loops` starts a session from any directory."] : [`${target} is not on your PATH, so \`pi-loops\` will not be found until it is.`];
-	const ok = await confirm("Put `pi-loops` on your PATH?", [`This writes a launcher into ${target}.`, "", "It is a two-line shell script that runs this package with this node.", ...reach].join("\n"));
+	const ok = await confirm("Put `pi-loops` on your PATH?", [`This writes a launcher into ${target}.`, "", "It is a small shell script that runs this package with this node.", ...reach].join("\n"));
 	if (!ok) return undefined;
 	// The absolute directory the question named, not the flag again: resolving a relative --dir a
 	// second time, after the dialog, would follow a working directory that may have moved meanwhile.
 	return installLauncher(target, out);
 }
 
+/**
+ * What a launcher says when no copy of this package is at any of the paths it knows. One line and
+ * an exit code, because the alternative a person actually saw was Node's `Cannot find module` stack
+ * trace, which names a file that is gone and nothing they can do about it. It is written into the
+ * script inside single quotes, so it must contain none.
+ */
+const LAUNCHER_LOST =
+	"pi-loops: the package this launcher was written for is not where it was — write the launcher again with `/pi-loops install-launcher` in pi, or `node <the directory pi installed it into>/src/cli-entry.mjs install-launcher`";
+
+/**
+ * The other places this package can be, for a launcher whose recorded entry has gone: the two
+ * directories `pi install` puts it in, under the agent directory the launcher is written with. They
+ * are baked into the script as literal paths — the launcher looks, it does not work anything out.
+ */
+function piInstallEntries(agentDir: string): string[] {
+	const { name, repoPath } = manifest();
+	const entries: string[] = [];
+	// `<agent dir>/npm/node_modules/<name>` and `<agent dir>/git/<host>/<owner>/<repo>`: the same two
+	// layouts `upgradeSpec` reads backwards to work out which route this copy came down.
+	if (name) entries.push(path.join(agentDir, "npm", "node_modules", ...name.split("/"), "src", "cli-entry.mjs"));
+	if (repoPath) entries.push(path.join(agentDir, "git", ...repoPath.split("/"), "src", "cli-entry.mjs"));
+	return entries;
+}
+
 /**
  * `pi install` puts this package under pi's managed directory rather than on your PATH, so the
  * command that is supposed to start your sessions is reachable only by absolute path. This writes
- * a two-line launcher into a directory that is already on your PATH, which is the smallest thing
+ * a small launcher into a directory that is already on your PATH, which is the smallest thing
  * that fixes it without asking you to publish or install anything else.
  */
 export async function installLauncher(dir: string | undefined, out: (line: string) => void): Promise<number> {
@@ -710,9 +830,25 @@ export async function installLauncher(dir: string | undefined, out: (line: strin
 	if (dir && !isOnPath(target)) out(`note: ${target} is not on your PATH, so the command will not be found there yet`);
 	const entry = path.join(path.dirname(fileURLToPath(import.meta.url)), "cli-entry.mjs");
 	const file = path.join(target, "pi-loops");
-	// A launcher rather than a symlink: it survives the package moving, and it names the node that
-	// is running now, which is the one known to be new enough for this code.
-	const script = `#!/bin/sh\n# pi-loops launcher, written by \`pi-loops install-launcher\`.\nexec ${JSON.stringify(process.execPath)} ${JSON.stringify(entry)} "$@"\n`;
+	// A launcher rather than a symlink: it names the node that is running now, which is the one known
+	// to be new enough for this code. What it survives is this package being installed again by the
+	// other route — `pi install npm:` over a `git:` copy moves it, and a launcher that knew only where
+	// it used to be died in Node's `Cannot find module`. So the entry it recorded is the first place
+	// it looks and not the only one, and the recorded node is a path it checks rather than trusts.
+	const candidates = [entry, ...piInstallEntries(getAgentDir())].map((e) => JSON.stringify(e)).join(" ");
+	const script = [
+		"#!/bin/sh",
+		"# pi-loops launcher, written by `pi-loops install-launcher`.",
+		`node=${JSON.stringify(process.execPath)}`,
+		'[ -x "$node" ] || node=$(command -v node) || node=node',
+		`for entry in ${candidates}; do`,
+		'\t[ -f "$entry" ] || continue',
+		'\texec "$node" "$entry" "$@"',
+		"done",
+		`echo '${LAUNCHER_LOST}' >&2`,
+		"exit 1",
+		"",
+	].join("\n");
 	try {
 		fs.mkdirSync(target, { recursive: true });
 		fs.writeFileSync(file, script, { mode: 0o755 });

package/src/goal.ts

@@ -171,6 +171,17 @@ export function pauseFor(state: GoalState, reason: string, now = new Date()): {
 	return { state: { ...state, status: "paused", lastReason: reason, updatedAt: stamp(now.getTime()) }, action: { kind: "pause", reason } };
 }
 
+/**
+ * Esc on a turn is a person saying stop. The goal it was pursuing pauses — appended to the session,
+ * so a `--resume` finds it paused — until `/goal resume`. Without this the turn was merely not
+ * judged, and the next message the person sent brought the evaluator back to send them to work.
+ * Only a pursued goal changes; a paused, achieved or budget-limited one has nothing to stop.
+ */
+export function abortedTurn(state: GoalState, now = new Date()): { state: GoalState; action: GoalAction } | undefined {
+	if (state.status !== "pursuing") return undefined;
+	return pauseFor(state, "you stopped the turn (Esc); /goal resume to continue", now);
+}
+
 /** One line for `/goal` and the panel. */
 export function goalLine(state: GoalState): string {
 	const iter = `${state.iterations}/${MAX_CONTINUATIONS}`;

package/src/hooks.ts

@@ -12,7 +12,8 @@ import * as fs from "node:fs";
 import * as os from "node:os";
 import * as path from "node:path";
 import { envFlag } from "./config.ts";
-import { previewRedacted } from "./redact.ts";
+import { previewRedacted, redact } from "./redact.ts";
+import type { LoopJob, RunRecord } from "./store.ts";
 import { parseToml } from "./toml.ts";
 import { PI_LOOPS_VERSION } from "./version.ts";
 
@@ -82,6 +83,29 @@ export interface HookPayload {
 /** Event-specific fields; the runner fills in the session-level ones. */
 export type HookEventData = Pick<HookPayload, "event" | "message_kind" | "message_summary" | "assistant_event" | "tool_call_id" | "tool_name" | "tool_is_error" | "tool_args" | "tool_result_summary" | "compaction_trigger" | "compaction_tokens_before" | "compaction_summary" | "compaction_failed" | "run_job" | "run_id" | "run_ok" | "run_findings" | "run_error" | "run_cost_usd">;
 
+/**
+ * The same two events the interactive extension and the headless host fire. Whether a run happens
+ * here or there is an accident of who held the clock, and a hook rule should not be able to tell —
+ * so both processes fire the object these two return.
+ */
+export function runStartEvent(job: LoopJob, runId: string): HookEventData {
+	return { event: "run_start", run_job: job.name ?? job.id, run_id: runId, message_summary: truncateSummary(`${job.name ?? job.id}: ${job.prompt}`) };
+}
+
+export function runEndEvent(job: LoopJob, record: RunRecord): HookEventData {
+	const label = job.name ?? job.id;
+	return {
+		event: "run_end",
+		run_job: label,
+		run_id: record.runId,
+		run_ok: record.ok,
+		run_findings: record.findings,
+		run_error: record.error ? redact(record.error) : null,
+		run_cost_usd: record.usage?.cost ?? null,
+		message_summary: truncateSummary(record.ok ? `${label}: ok · ${record.findings} finding(s)` : `${label}: failed: ${record.error ?? "unknown error"}`),
+	};
+}
+
 export interface ParsedHooksFile {
 	allowProjectHooks: boolean;
 	hooks: HookConfig[];

package/src/host-runtime.ts

@@ -7,7 +7,7 @@
 import type { ToolDefinition } from "@earendil-works/pi-coding-agent";
 import * as path from "node:path";
 import type { LoopsConfig } from "./config.ts";
-import { HookRunner, truncateSummary } from "./hooks.ts";
+import { HookRunner, runEndEvent, runStartEvent } from "./hooks.ts";
 import { PI_BUILTIN_TOOL_NAMES } from "./mcp.ts";
 import { redact } from "./redact.ts";
 import type { SubagentRequest, SubagentRunner } from "./runner.ts";
@@ -119,7 +119,7 @@ export function createHostRuntime(deps: HostRuntimeDeps): HostRuntime {
 				// scheduler calls this synchronously). `.catch` because a rejection nobody owns takes
 				// the host down — hooks warn per rule, so there is nothing else to do with one.
 				const hooks = hookRunnerFor(job, runId);
-				if (hooks) void hooks.fire({ event: "run_start", run_job: job.name ?? job.id, run_id: runId, message_summary: truncateSummary(`${job.name ?? job.id}: ${job.prompt}`) }).catch((err: any) => log(`hooks: ${redact(err?.message ?? String(err))}`));
+				if (hooks) void hooks.fire(runStartEvent(job, runId)).catch((err: any) => log(`hooks: ${redact(err?.message ?? String(err))}`));
 			},
 			onCatchUp: (job) => log(`loop ${job.name ?? job.id}: catching up a missed tick`),
 			onRunFinished: ({ job, record, result }) => {
@@ -129,14 +129,10 @@ export function createHostRuntime(deps: HostRuntimeDeps): HostRuntime {
 				if (!hooks) return;
 				// `$PI_RUN_OK` alone answers "did last night's loop fail" — the thing the host exists to
 				// be able to tell someone.
-				const label = job.name ?? job.id;
-				const summary = record.ok ? `${label}: ok · ${record.findings} finding(s)` : `${label}: failed: ${record.error ?? "unknown error"}`;
 				// Its own hooks are the last thing a run does; the runner is dropped once they have run
 				// (until then `stop()` still has to drain it).
 				const forget = () => void runHooks.delete(record.runId);
-				void hooks
-					.fire({ event: "run_end", run_job: label, run_id: record.runId, run_ok: record.ok, run_findings: record.findings, run_error: record.error ? redact(record.error) : null, run_cost_usd: record.usage?.cost ?? null, message_summary: truncateSummary(summary) })
-					.then(forget, forget);
+				void hooks.fire(runEndEvent(job, record)).then(forget, forget);
 			},
 			onTick: async (now, leader) => {
 				if (!leader) {
@@ -153,7 +149,7 @@ export function createHostRuntime(deps: HostRuntimeDeps): HostRuntime {
 	});
 
 	const toInbox = async (content: string, trigger: { sourceLabel: string; traceId: string; cwd?: string }) => {
-		await scheduler.inbox.append({ source: `trigger:${trigger.sourceLabel}`, text: content.replace(/^\[Trigger [^\]]+\]\s*/, ""), runId: trigger.traceId, jobId: trigger.sourceLabel, cwd: trigger.cwd ?? "" });
+		await scheduler.inbox.append({ source: `trigger:${trigger.sourceLabel}`, text: content.replace(/^\[Trigger [^\]]+\]\s*/, ""), run_id: trigger.traceId, job_id: trigger.sourceLabel, cwd: trigger.cwd ?? "" });
 		return "inbox" as const;
 	};
 	triggers = new TriggerRuntime({