@alphacoder-v0/pi-loops 0.20.0 → 0.22.0

package/src/recipe.ts

@@ -9,7 +9,7 @@
  * to `parseAddArgs` — the same parser, the same refusals — so a recipe can never create a job a
  * person could not have typed.
  */
-import { execFileSync } from "node:child_process";
+import { execFile, execFileSync } from "node:child_process";
 import * as fs from "node:fs";
 import * as os from "node:os";
 import * as path from "node:path";
@@ -42,6 +42,18 @@ export interface RecipeManifest {
 	summary: string;
 	needsTracker: boolean;
 	levels: AutonomyLevel[];
+	/**
+	 * Where the recipe sits in `/recipe list`: a `starter` reads and files findings and is the
+	 * one to install first; an `advanced` one writes somewhere — a worktree, a pull request, a
+	 * tracker — and wants the playbooks read before the level question is answered.
+	 */
+	tier: RecipeTier;
+	/** One sentence each, for `/recipe show`: the situations this recipe is for. */
+	usefulWhen: string[];
+	/** What the project must have for a run to work, checked before the install (`PREFLIGHT_CHECKS`). */
+	needs: PreflightCheck[];
+	/** The same, for `propose` and `act` — the levels whose runs push, open pull requests, or write. */
+	needsPropose: PreflightCheck[];
 	/** A script run once per project, with confirmation, before the jobs exist. */
 	setup?: string;
 	/** Files copied beside the playbooks (templates a playbook tells the run to create from). */
@@ -69,6 +81,18 @@ export interface InstallRecord {
 	source: string;
 }
 
+/**
+ * The checks a manifest may ask for before the install (`needs`, `needs_propose`). Each is one
+ * deterministic look at the project — a command on the PATH, a file, a remote — and none blocks:
+ * the point is that "the first sign of credentials that do not work should not be an empty inbox
+ * tomorrow morning" (README), so the confirmation says it tonight instead.
+ */
+export const PREFLIGHT_CHECKS = ["gh", "git-remote", "ci-workflows", "lockfile", "tracker-github"] as const;
+export type PreflightCheck = (typeof PREFLIGHT_CHECKS)[number];
+
+export const RECIPE_TIERS = ["starter", "advanced"] as const;
+export type RecipeTier = (typeof RECIPE_TIERS)[number];
+
 export const MANIFEST_FILE = "recipe.toml";
 export const RECORD_FILE = ".recipe.json";
 /** Where a recipe's files land in a project, relative to the project root. */
@@ -157,6 +181,19 @@ export function parseManifest(text: string, opts: { now?: number } = {}): Recipe
 	for (const f of files) if (!safeRelative(f)) throw new Error(`${where}: files entry "${f}" must be inside the recipe directory`);
 	const budget = doc.budget_hint_usd;
 	if (budget !== undefined && (typeof budget !== "number" || budget < 0)) throw new Error(`${where}: budget_hint_usd must be a non-negative number`);
+	const tierRaw = str(doc, "tier", where) ?? "advanced";
+	if (!(RECIPE_TIERS as readonly string[]).includes(tierRaw)) throw new Error(`${where}: tier must be ${RECIPE_TIERS.join(" or ")} (got "${tierRaw}")`);
+	const usefulWhen = strList(doc, "useful_when", where) ?? [];
+	const checks = (key: string): PreflightCheck[] => {
+		const out: PreflightCheck[] = [];
+		for (const c of strList(doc, key, where) ?? []) {
+			if (!(PREFLIGHT_CHECKS as readonly string[]).includes(c)) throw new Error(`${where}: ${key} entry "${c}" is not a check (checks are ${PREFLIGHT_CHECKS.join(", ")})`);
+			if (!out.includes(c as PreflightCheck)) out.push(c as PreflightCheck);
+		}
+		return out;
+	};
+	const needs = checks("needs");
+	const needsPropose = checks("needs_propose");
 	const jobsRaw = doc.job;
 	if (!Array.isArray(jobsRaw) || jobsRaw.length === 0) throw new Error(`${where}: at least one [[job]] is required`);
 	const jobs: RecipeJob[] = [];
@@ -190,7 +227,7 @@ export function parseManifest(text: string, opts: { now?: number } = {}): Recipe
 		}
 		jobs.push(job);
 	}
-	return { name, summary, needsTracker: bool(doc, "needs_tracker", where) ?? false, levels, setup, files, budgetHintUsd: budget as number | undefined, jobs };
+	return { name, summary, needsTracker: bool(doc, "needs_tracker", where) ?? false, levels, tier: tierRaw as RecipeTier, usefulWhen, needs, needsPropose, setup, files, budgetHintUsd: budget as number | undefined, jobs };
 }
 
 /** Relative, inside the directory, and a single file: no `..`, no absolute path, no trailing slash. */
@@ -306,6 +343,125 @@ export function readLevelLine(text: string): AutonomyLevel | undefined {
 	return l && (AUTONOMY_LEVELS as readonly string[]).includes(l) ? (l as AutonomyLevel) : undefined;
 }
 
+/**
+ * What a playbook forbids, for `/recipe show` and the install confirmation: the non-empty lines
+ * under every `## Never…` heading (`## Never`, `## Never bump`), up to the next `## ` heading.
+ * The section is the packaged recipes' convention for the safety envelope of a run, and the one
+ * place a person can read it before the playbook is installed and followed unattended.
+ */
+export function neverSection(text: string): string[] {
+	const out: string[] = [];
+	let inside = false;
+	for (const line of text.split("\n")) {
+		if (/^## /.test(line)) {
+			inside = /^## Never\b/.test(line);
+			continue;
+		}
+		if (inside && line.trim()) out.push(line.trimEnd());
+	}
+	return out;
+}
+
+/* ------------------------------------------------------------------------------- preflight */
+
+/**
+ * Which checks apply to an install of `manifest` at `level`: the declared ones, `needs_propose`
+ * above `report`, and — for a recipe that reads the tracker — `gh` when the tracker description
+ * uses it. That last rule is what keeps a local Markdown tracker out of it: its description has
+ * no `gh` in it, so nothing is asked for that the project was never going to use. Returned in
+ * `PREFLIGHT_CHECKS` order, each once.
+ */
+export function preflightChecks(manifest: RecipeManifest, level: AutonomyLevel, trackerText: string | undefined): PreflightCheck[] {
+	const wanted = new Set<PreflightCheck>(manifest.needs);
+	if (level !== "report") for (const c of manifest.needsPropose) wanted.add(c);
+	if (manifest.needsTracker && trackerText && /\bgh\b/.test(trackerText)) wanted.add("gh");
+	return PREFLIGHT_CHECKS.filter((c) => wanted.has(c));
+}
+
+export interface PreflightLine {
+	check: PreflightCheck;
+	/** true = there; false = not there; undefined = could not tell (a timeout, an unreadable file). */
+	ok: boolean | undefined;
+	/** What was found, and for a miss what it means for the runs. */
+	detail: string;
+}
+
+const LOCKFILES = ["package-lock.json", "pnpm-lock.yaml", "yarn.lock", "bun.lock", "bun.lockb", "Cargo.lock", "poetry.lock", "uv.lock", "Pipfile.lock", "go.sum", "Gemfile.lock", "composer.lock"];
+
+/**
+ * Runs the checks against `project`. Never throws: a check that cannot run says so in its line.
+ * The commands run off the turn (`gh auth status` reaches the network), so a slow one holds the
+ * confirmation, not the whole window.
+ */
+export async function runPreflight(checks: PreflightCheck[], project: string, opts: { env?: NodeJS.ProcessEnv } = {}): Promise<PreflightLine[]> {
+	const env = opts.env ?? process.env;
+	const run = (file: string, args: string[]): Promise<{ code: number | "missing" | "timeout"; out: string }> =>
+		new Promise((resolve) => {
+			execFile(file, args, { cwd: project, env, encoding: "utf8", timeout: 10_000 }, (err: any, stdout, stderr) => {
+				if (!err) return resolve({ code: 0, out: String(stdout) });
+				if (err.code === "ENOENT") return resolve({ code: "missing", out: "" });
+				if (err.killed || err.code === "ETIMEDOUT") return resolve({ code: "timeout", out: "" });
+				resolve({ code: typeof err.code === "number" ? err.code : 1, out: `${stdout ?? ""}${stderr ?? ""}` });
+			});
+		});
+	const lines: PreflightLine[] = [];
+	for (const check of checks) {
+		switch (check) {
+			case "gh": {
+				const r = await run("gh", ["auth", "status"]);
+				if (r.code === 0) lines.push({ check, ok: true, detail: "gh: logged in" });
+				else if (r.code === "missing") lines.push({ check, ok: false, detail: "gh: not on the PATH — install the GitHub CLI and run `gh auth login`; runs that use it fail until then" });
+				else if (r.code === "timeout") lines.push({ check, ok: undefined, detail: "gh: could not check (`gh auth status` took more than 10s)" });
+				else lines.push({ check, ok: false, detail: "gh: not logged in — run `gh auth login`; runs that use it fail until then" });
+				break;
+			}
+			case "git-remote": {
+				const r = await run("git", ["remote", "get-url", "origin"]);
+				if (r.code === 0) lines.push({ check, ok: true, detail: `git remote: origin is ${r.out.trim().replace(/(:\/\/)[^/@\s]+@/, "$1")}` });
+				else if (r.code === "missing") lines.push({ check, ok: undefined, detail: "git remote: could not check (git is not on the PATH)" });
+				else if (r.code === "timeout") lines.push({ check, ok: undefined, detail: "git remote: could not check (git took more than 10s)" });
+				else lines.push({ check, ok: false, detail: "git remote: no origin — runs that fetch from it, push to it or open pull requests fail" });
+				break;
+			}
+			case "ci-workflows": {
+				let names: string[];
+				try {
+					names = fs.readdirSync(path.join(project, ".github", "workflows")).filter((n) => /\.ya?ml$/.test(n));
+				} catch {
+					names = [];
+				}
+				lines.push(names.length ? { check, ok: true, detail: `CI workflows: ${names.length} under .github/workflows` } : { check, ok: false, detail: "CI workflows: none under .github/workflows — runs that read the default branch's checks find no runs" });
+				break;
+			}
+			case "lockfile": {
+				const found = LOCKFILES.find((f) => fs.existsSync(path.join(project, f)));
+				lines.push(found ? { check, ok: true, detail: `lockfile: ${found}` } : { check, ok: false, detail: "lockfile: none found — the audit and outdated commands need one to name the package manager" });
+				break;
+			}
+			case "tracker-github": {
+				let text: string | undefined;
+				try {
+					text = fs.readFileSync(path.join(project, TRACKER_FILE), "utf8");
+				} catch {
+					text = undefined;
+				}
+				if (text === undefined) lines.push({ check, ok: false, detail: `tracker: ${TRACKER_FILE} is missing` });
+				else if (/\bgh\b/.test(text)) lines.push({ check, ok: true, detail: "tracker: GitHub" });
+				else lines.push({ check, ok: false, detail: "tracker: local Markdown, which has no pull requests — this recipe has nothing to watch" });
+				break;
+			}
+		}
+	}
+	return lines;
+}
+
+/** The lines the confirmation and `show` print: one per check, or one line when every check passed. */
+export function renderPreflight(lines: PreflightLine[]): string[] {
+	if (!lines.length) return [];
+	if (lines.every((l) => l.ok)) return ["  all checks pass"];
+	return lines.map((l) => `  ${l.ok ? "✓" : l.ok === false ? "✗" : "?"} ${l.detail}`);
+}
+
 /* ------------------------------------------------------------------------------ installing */
 
 export interface InstallPlan {

package/src/scheduler.ts

@@ -15,7 +15,7 @@ import { PresenceRegistry, type PresenceEntry, type PresenceKind, type PresenceS
 import * as path from "node:path";
 import { Inbox } from "./inbox.ts";
 import { pidAlive, withFileLock, writeFileAtomic } from "./lock.ts";
-import { composeCheckerPrompt, composeLoopPrompt, parseCheckerOutput, parseRunOutput, stripProtocolTags } from "./protocol.ts";
+import { composeCheckerPrompt, composeLoopPrompt, findingKind, parseCheckerOutput, parseRunOutput, stripProtocolTags } from "./protocol.ts";
 import { type RunnerResult, type SubagentRunner, failedRun } from "./runner.ts";
 import { previewRedacted, redact } from "./redact.ts";
 import { type SubagentSlot, SubagentSlots } from "./slots.ts";
@@ -767,8 +767,12 @@ export class LoopScheduler {
 	/** The body of one run: everything between claiming the job and writing its record. */
 	private async runOnce(job: LoopJob, claimed: LoopJob, runId: string, startedAt: string, ctrl: AbortController, session: SessionSnapshot, now: number, catchingUp: boolean, prior: { dueAt?: string; firedAt?: string }): Promise<void> {
 		const previousState = this.store.readState(job.id);
+		// `job` is the pre-claim snapshot, so its `lastFiredAt` is when the previous run started —
+		// a reason given before that was already in front of that run.
+		const dismissed = this.inbox.feedbackFor(job.id, job.lastFiredAt).map((e) => ({ text: String(e.text), reason: String(e.dismiss_reason ?? "") }));
 		const prompt = composeLoopPrompt(job.prompt, previousState, {
 			name: job.name,
+			dismissed,
 			// Zoned, unlike everything shown on a screen: this one goes into a sub-agent's prompt,
 			// where a model is asked to reason about how long ago the last run was and has no
 			// surrounding context to tell it which clock this came off. It used to be a bare local
@@ -834,7 +838,7 @@ export class LoopScheduler {
 			const source = `cron:${job.name ?? job.id.slice(0, "cron-".length + 8)}`;
 			for (const f of reviewed) {
 				try {
-					await this.inbox.append({ source, text: f.text, runId, jobId: job.id, cwd: job.cwd, verified: f.verified, verifiedReason: f.reason });
+					await this.inbox.append({ source, text: f.text, run_id: runId, job_id: job.id, cwd: job.cwd, kind: findingKind(f.text), verified: f.verified, verified_reason: f.reason });
 					findings.push(f.text);
 				} catch (err: any) {
 					this.log(`loop ${job.id}: inbox append failed: ${err?.message ?? err}`);

package/src/store.ts

@@ -579,11 +579,16 @@ export class JobStore {
 	}
 }
 
-/** Resolve "<n>" (1-based position in `jobs`) or an id / unique id prefix / exact name. */
-export function resolveJobRef(jobs: LoopJob[], ref: string): LoopJob | undefined {
+/**
+ * Resolve an id / unique id prefix / exact name — and, with `ordinals: true`, "<n>", the 1-based
+ * position in `jobs`. A number is a position in a list the caller printed, so only a caller that
+ * printed one may ask for it (`/cron`, which numbers what it shows); everywhere else, the
+ * model-facing tools included, an all-digit ref resolves to nothing.
+ */
+export function resolveJobRef(jobs: LoopJob[], ref: string, opts?: { ordinals?: boolean }): LoopJob | undefined {
 	const trimmed = ref.trim();
 	if (!trimmed) return undefined;
-	if (/^\d+$/.test(trimmed)) return jobs[Number(trimmed) - 1];
+	if (/^\d+$/.test(trimmed)) return opts?.ordinals ? jobs[Number(trimmed) - 1] : undefined;
 	const exact = jobs.find((j) => j.id === trimmed || j.name === trimmed);
 	if (exact) return exact;
 	const byPrefix = jobs.filter((j) => j.id.startsWith(trimmed));

package/src/tools.ts

@@ -4,6 +4,7 @@
  * definitions. One factory serves the interactive session (hop 0, registered with pi), every
  * in-process sub-session (hop 1, passed as customTools) and the headless host (hop 1, no UI).
  */
+import { QUIET_MARK_AFTER, SIGNAL_WINDOW_MS, loopSignal } from "./job-signal.ts";
 import type { ExtensionContext, ToolDefinition } from "@earendil-works/pi-coding-agent";
 import * as os from "node:os";
 import * as path from "node:path";
@@ -14,7 +15,7 @@ import type { LoopScheduler, SessionSnapshot } from "./scheduler.ts";
 import { MAX_PROMPT_BYTES, type LoopJob, newId, owningSessionId, resolveJobRef } from "./store.ts";
 import { asleepNote, ownerSession, runsIn } from "./job-owner.ts";
 import type { TriggerRuntime } from "./trigger-runtime.ts";
-import { withinProject } from "./presence.ts";
+import { sameProject, withinProject } from "./presence.ts";
 import { type TriggerStore, looksLikeFixedScheduleRequest, parseTriggerRule, resolveRuleRef, type DynamicTriggerRule } from "./triggers.ts";
 
 export interface ControlPlaneRequest {
@@ -77,16 +78,11 @@ function resolveJobCwd(sessionCwd: string, cwd: string | undefined): string {
 	return cwd ? path.resolve(sessionCwd || process.cwd(), cwd) : path.resolve(sessionCwd);
 }
 
-/** A worktree, a symlinked path or a subdirectory is the same project, as the runtime treats it. */
-function sameProject(a: string, b: string): boolean {
-	return withinProject(b, a) || withinProject(a, b);
-}
-
 /** A rule by ref, preferring this project's; another project's needs its exact id. */
 export function resolveRuleRefScoped(rules: DynamicTriggerRule[], ref: string, cwd: string): DynamicTriggerRule | undefined {
 	// Ordinals are what the user sees in `/triggers rules`; a model's list may be a different one,
-	// so the tools take an id, a unique prefix or a name — never a position.
-	if (/^\d+$/.test(ref.trim())) return undefined;
+	// so the tools take an id, a unique prefix or a name — never a position. That is the resolver's
+	// default: no caller here printed a numbered list, so none of them asks for one.
 	const mine = resolveRuleRef(
 		rules.filter((r) => withinProject(cwd, r.cwd) || withinProject(r.cwd, cwd)),
 		ref,
@@ -98,7 +94,6 @@ export function resolveRuleRefScoped(rules: DynamicTriggerRule[], ref: string, c
 
 /** A job by ref, preferring this project's; another project's needs its exact id. */
 export function resolveJobRefScoped(jobs: LoopJob[], ref: string, cwd: string): LoopJob | undefined {
-	if (/^\d+$/.test(ref.trim())) return undefined;
 	const mine = resolveJobRef(
 		jobs.filter((j) => sameProject(j.cwd, cwd)),
 		ref,
@@ -182,10 +177,13 @@ function nextRunForTool(job: LoopJob, now: number, sessionId: string | undefined
 }
 
 /** Cron jobs, rendered for a tool result. */
-function renderCronJobsForTool(jobs: LoopJob[], host: Pick<ToolHost, "session">): string {
+function renderCronJobsForTool(jobs: LoopJob[], host: Pick<ToolHost, "session" | "scheduler">): string {
 	if (!jobs.length) return "cron jobs: none";
 	const now = Date.now();
 	const lines = [`cron jobs: ${jobs.length}`];
+	// Read once for the listing, as `/cron` does; only loops have a signal to report.
+	const runs = jobs.some((j) => j.stateful) ? host.scheduler.store.allRuns() : [];
+	const inbox = jobs.some((j) => j.stateful) ? host.scheduler.inbox.list() : [];
 	for (const job of jobs) {
 		lines.push(`- ${job.id}${job.name ? ` "${job.name}"` : ""} [${job.enabled ? "enabled" : "disabled"}${job.stateful ? ", stateful" : ""}${job.verify ? ", verify" : ""}] schedule: ${formatSchedule(job.schedule)} action: ${previewRedacted(job.prompt, 120)}${job.cwd !== host.session().cwd ? ` cwd: ${job.cwd}` : ""}`);
 		const asleep = asleepNote(job, host.session().sessionId);
@@ -194,7 +192,15 @@ function renderCronJobsForTool(jobs: LoopJob[], host: Pick<ToolHost, "session">)
 		if (next) lines.push(`  next_run: ${stamp(next)}`);
 		if (job.running) lines.push(`  running_run_id: ${job.running.runId}`);
 		if (job.lastError) lines.push(`  last_error: ${previewRedacted(job.lastError, 120)}`);
+		if (job.consecutiveFailures) lines.push(`  consecutive_failures: ${job.consecutiveFailures}`);
 		if (job.skippedOverlap) lines.push(`  skipped_overlap_count: ${job.skippedOverlap}`);
+		if (job.stateful) {
+			// The same two facts `/cron` shows, so the model can say "this loop's findings are all
+			// dismissed" or "it has found nothing in 12 runs" when the user asks about their automation.
+			const s = loopSignal(job.id, runs, inbox, now - SIGNAL_WINDOW_MS);
+			if (s.findings) lines.push(`  signal_30d: findings=${s.findings} claimed=${s.claimed} dismissed=${s.dismissed}`);
+			if (s.quiet >= QUIET_MARK_AFTER) lines.push(`  quiet_streak: ${s.quiet} (consecutive runs with no finding)`);
+		}
 	}
 	return lines.join("\n");
 }
@@ -379,7 +385,7 @@ export function automationTools(scope: ToolScope, host: ToolHost): ToolDefinitio
 			const text = `${renderCronJobsForTool(jobs, host)}\ninbox: ${host.scheduler.inbox.newCount()} new finding(s)`;
 			const nowMs = Date.now();
 			const nextRun = (j: LoopJob) => nextRunForTool(j, nowMs, host.session().sessionId);
-			return { content: [{ type: "text", text }], details: { count: jobs.length, scope: everywhere ? "machine" : listCwd, storage_path: host.scheduler.store.jobsFile, jobs: jobs.map((j) => ({ id: j.id, name: j.name, schedule: formatSchedule(j.schedule), action_preview: previewRedacted(j.prompt, 120), enabled: j.enabled, stateful: j.stateful, verify: j.verify ?? false, cwd: j.cwd, running_run_id: j.running?.runId, last_due_at: j.lastDueAt, last_fired_at: j.lastFiredAt, last_completed_at: j.lastCompletedAt, last_error: j.lastError ? previewRedacted(j.lastError, 120) : undefined, skipped_overlap_count: j.skippedOverlap, next_run: (() => { const n = nextRun(j); return n ? stamp(n) : undefined; })(), owner_session: ownerSession(j), asleep: !runsIn(j, host.session().sessionId) || undefined, created_at: j.createdAt })) } };
+			return { content: [{ type: "text", text }], details: { count: jobs.length, scope: everywhere ? "machine" : listCwd, storage_path: host.scheduler.store.jobsFile, jobs: jobs.map((j) => ({ id: j.id, name: j.name, schedule: formatSchedule(j.schedule), action_preview: previewRedacted(j.prompt, 120), enabled: j.enabled, stateful: j.stateful, verify: j.verify ?? false, cwd: j.cwd, running_run_id: j.running?.runId, last_due_at: j.lastDueAt, last_fired_at: j.lastFiredAt, last_completed_at: j.lastCompletedAt, last_error: j.lastError ? previewRedacted(j.lastError, 120) : undefined, consecutive_failures: j.consecutiveFailures, skipped_overlap_count: j.skippedOverlap, next_run: (() => { const n = nextRun(j); return n ? stamp(n) : undefined; })(), owner_session: ownerSession(j), asleep: !runsIn(j, host.session().sessionId) || undefined, created_at: j.createdAt })) } };
 		},
 	});
 

package/src/triggers.ts

@@ -443,11 +443,16 @@ export function auditCronFinish(store: TriggerStore, job: { id: string; cwd: str
 	});
 }
 
-/** Resolve an id, a unique id prefix, or "<n>" in `rules`. */
-export function resolveRuleRef(rules: DynamicTriggerRule[], ref: string): DynamicTriggerRule | undefined {
+/**
+ * Resolve an id or a unique id prefix — and, with `ordinals: true`, "<n>", the 1-based position in
+ * `rules`. A number is a position in a list the caller printed, so only a caller that printed one
+ * may ask for it (`/triggers`, which numbers what it shows); everywhere else, the model-facing
+ * tools included, an all-digit ref resolves to nothing.
+ */
+export function resolveRuleRef(rules: DynamicTriggerRule[], ref: string, opts?: { ordinals?: boolean }): DynamicTriggerRule | undefined {
 	const t = ref.trim();
 	if (!t) return undefined;
-	if (/^\d+$/.test(t)) return rules[Number(t) - 1];
+	if (/^\d+$/.test(t)) return opts?.ordinals ? rules[Number(t) - 1] : undefined;
 	const exact = rules.find((r) => r.id === t);
 	if (exact) return exact;
 	const hits = rules.filter((r) => r.id.startsWith(t));

package/src/web.mjs

@@ -512,11 +512,15 @@ function automation(cwd) {
 	const elsewhere = { jobs: allJobs.length - jobs.length, rules: allRules.length - rules.length };
 
 	let inboxNew = 0;
+	let inboxDecisions = 0;
 	try {
 		for (const line of fs.readFileSync(path.join(LOOPS_DIR, "inbox.jsonl"), "utf8").split("\n")) {
 			if (!line.trim()) continue;
 			try {
-				if ((JSON.parse(line).status ?? "new") === "new") inboxNew++;
+				const e = JSON.parse(line);
+				if ((e.status ?? "new") !== "new") continue;
+				inboxNew++;
+				if (e.kind === "checkpoint") inboxDecisions++;
 			} catch {
 				/* skip a torn line */
 			}
@@ -527,7 +531,7 @@ function automation(cwd) {
 
 	// MCP servers and hooks are deliberately not counted from the config files here: what matters
 	// is which ones actually connected and what they exposed, and that is in the runtime snapshot.
-	return { installed: true, dir: LOOPS_DIR, jobs, rules, inboxNew, elsewhere };
+	return { installed: true, dir: LOOPS_DIR, jobs, rules, inboxNew, inboxDecisions, elsewhere };
 }
 
 /* ------------------------------------------------------------------ what a prompt needs first */
@@ -1359,14 +1363,21 @@ const server = http.createServer(async (req, res) => {
 			if (!text && !(images ?? []).length) return void json(res, { success: false, error: "empty prompt" }, 400);
 			const guard = commandRefusal(text ?? "");
 			if (guard) return void json(res, guard, 400);
-			// Submitting while a turn runs queues instead of racing it, as the TUI does.
-			const type = mode === "steer" ? "steer" : mode === "follow_up" ? "follow_up" : "prompt";
+			// Submitting while a turn runs queues instead of racing it, as the TUI does. `prompt` is the
+			// one rpc command that carries both halves of that: pi queues it while streaming, and an
+			// extension command — /inbox, /cron, /triggers, /goal — runs immediately, which is what the
+			// terminal does. The `follow_up` and `steer` commands refuse anything naming one of them with
+			// pi's "cannot be queued", which told the person to call prompt(). It is asked for
+			// unconditionally because the page's busy flag is its own guess: a send that lands while pi
+			// is streaming but before the page has noticed is queued rather than refused, and while pi
+			// is idle the option is not read at all.
+			const streamingBehavior = mode === "steer" ? "steer" : "followUp";
 			const message = expandMentions(text ?? "", sessionCwd);
 			// pi answers a prompt command when the command has *finished*, and a slash command may
 			// sit in a dialog for as long as a person takes to read what it shows (a setup script,
 			// say). Sixty seconds reported that as "timed out" while the command went on to succeed.
 			const patience = message.trimStart().startsWith("/") ? 15 * 60_000 : undefined;
-			return void json(res, await rpc({ type, message, ...(images?.length ? { images } : {}) }, patience));
+			return void json(res, await rpc({ type: "prompt", message, streamingBehavior, ...(images?.length ? { images } : {}) }, patience));
 		}
 		if (url.pathname === "/model" && req.method === "POST") {
 			// Recorded below, once pi has accepted it.
@@ -3425,7 +3436,7 @@ function renderSidebar(s) {
   if (!a.installed) { box.innerHTML = '<div class="notice">pi-loops not found in ' + safeText(a.dir || "") + "</div>"; }
   else {
     let html = "";
-    html += '<div class="notice">inbox <b>' + num(a.inboxNew) + "</b> new · " + num(a.jobs.length) + " job(s) · " + num(a.rules.length) + " rule(s)</div>";
+    html += '<div class="notice">inbox <b>' + num(a.inboxNew) + "</b> new" + (a.inboxDecisions ? " (" + num(a.inboxDecisions) + " decision" + (a.inboxDecisions === 1 ? "" : "s") + ")" : "") + " · " + num(a.jobs.length) + " job(s) · " + num(a.rules.length) + " rule(s)</div>";
     for (const j of a.jobs) {
       html += '<div class="card' + (j.enabled ? "" : " off") + '"><div class="t"><b>' + safeText(j.name || str(j.id).slice(0, 14)) + "</b>" +
         '<span class="m">' + safeText(j.schedule) + (j.stateful ? " · loop" : "") + "</span>" +
@@ -3793,7 +3804,7 @@ $("composer").onsubmit = async (e) => {
   const input = $("input");
   let text = input.value.trim();
   if (!text && !images.length) return;
-  input.value = ""; hidePop();
+  input.value = ""; hidePop(); saveDraft(); autoGrow();
   if (text) { sentPrompts.push(text); if (sentPrompts.length > 200) sentPrompts.shift(); }
   promptIdx = -1;
   // Typed rather than clicked, which is how these get used once they are a habit. They run here
@@ -3853,6 +3864,8 @@ $("undo").onclick = async () => {
   if (r.data?.cancelled) return row("notice", "", "undo was cancelled by an extension");
   // pi hands back the forked message; put it where it came from.
   $("input").value = r.data?.text ?? "";
+  saveDraft();
+  autoGrow();
   // The branch moved, so the conversation is taken again — through resync, which is the one path
   // that also resets what the page is counting against and drains what arrived meanwhile. This used
   // to be a second copy of it, and the copy was missing all three of those.
@@ -4152,6 +4165,51 @@ function remember(key, value) {
   }
 }
 
+/**
+ * What you have typed and not sent is the only copy of it, and this page reloads for its own
+ * reasons: the header button, the banner that says the page is stale, a phone that discards a
+ * backgrounded tab. None of them should cost a prompt. sessionStorage rather than localStorage,
+ * because two tabs of this address are open at once by design and one tab's typing must not land in
+ * the other's box. As with the theme, the store may refuse — that costs the draft, never the page.
+ */
+const DRAFT_KEY = "pi-web-draft";
+function savedDraft() {
+  try {
+    return sessionStorage.getItem(DRAFT_KEY) ?? "";
+  } catch (_) {
+    return "";
+  }
+}
+/**
+ * The text in the box, kept as it changes. Only the text: an attached image is one gesture to redo.
+ * Recalling a sent prompt with the up-arrow deliberately does not come through here — it is a look at
+ * something that already exists elsewhere, and storing it would drop the one copy of what does not.
+ */
+function saveDraft() {
+  try {
+    const text = $("input").value;
+    if (text) sessionStorage.setItem(DRAFT_KEY, text);
+    else sessionStorage.removeItem(DRAFT_KEY);
+  } catch (_) {
+    // Nothing to do and nothing worth saying: the draft simply does not outlive a reload.
+  }
+}
+
+/**
+ * The box grows with what is in it, up to the ceiling the stylesheet already puts on it. The order
+ * matters: scrollHeight is measured against the height the box has now, so it is set back to auto
+ * first — assigned straight back, the box can only ever get taller, and a shorter prompt would sit in
+ * a slot as tall as the last one. The cap stays in CSS (max-height:40vh) rather than being said
+ * twice, so past it the box scrolls exactly as it did before.
+ */
+function autoGrow() {
+  const el = $("input");
+  el.style.height = "auto";
+  // scrollHeight leaves out the border, and these boxes are border-box: without it added back, the
+  // content overflows by exactly the border and a box that fits its text shows a scrollbar anyway.
+  el.style.height = el.scrollHeight + (el.offsetHeight - el.clientHeight) + "px";
+}
+
 const THEMES = ["system", "light", "dark"];
 function applyTheme(theme) {
   const root = document.documentElement;
@@ -4269,6 +4327,8 @@ function accept(i) {
   el.value = el.value.slice(0, from) + it.value + (it.value.endsWith("/") ? "" : " ") + el.value.slice(el.selectionStart);
   el.focus();
   hidePop();
+  saveDraft();
+  autoGrow();
 }
 /** What has been sent from this composer, for the up-arrow. Not window.history, which it shadowed. */
 const sentPrompts = [];
@@ -4303,12 +4363,14 @@ $("input").onkeydown = (e) => {
       if (promptIdx === -1) promptDraft = el.value;
       promptIdx = Math.min(promptIdx + 1, sentPrompts.length - 1);
       el.value = sentPrompts[sentPrompts.length - 1 - promptIdx];
+      autoGrow();
       e.preventDefault();
       return;
     }
     if (e.key === "ArrowDown" && atEnd && promptIdx >= 0) {
       promptIdx -= 1;
       el.value = promptIdx === -1 ? promptDraft : sentPrompts[sentPrompts.length - 1 - promptIdx];
+      autoGrow();
       e.preventDefault();
       return;
     }
@@ -4334,6 +4396,8 @@ $("input").onkeydown = (e) => {
 };
 $("input").oninput = () => {
   const el = $("input");
+  saveDraft();
+  autoGrow();
   const line = el.value.slice(0, el.selectionStart).split("\n").pop();
   if (/(^\/[\w-]*$)|(@[^\s]*$)/.test(line)) updatePop(); else hidePop();
 };
@@ -4472,6 +4536,8 @@ function applyEvent(ev) {
 
 /* ---------------- start ---------------- */
 (async () => {
+  $("input").value = savedDraft();
+  autoGrow();
   setAllWork(allOpen);
   await refresh();
   const hist = await api("/history");