pi-cc-loop 0.2.0 → 0.4.0

package/loopfile.ts

@@ -72,17 +72,13 @@ export class LoopFileDelivery {
 
 	/** The text of one tick for the loop.md sentinel. */
 	resolve(cwd: string, mode: TickMode): string {
-		const cronNote =
-			mode === "cron"
-				? "\nThe recurring job fires the next tick on its own: do not call schedule_wakeup from this tick."
-				: "";
 		const file = readLoopFile(cwd);
 		if (file) {
 			if (this.lastDelivered === file.content) {
 				return (
 					"# /loop tick \u2014 loop.md tasks\n" +
 					"Work the tasks from the loop.md contents established earlier in this conversation. " +
-					`If you cannot find them, treat this as a no-op tick.${cronNote}`
+					"If you cannot find them, treat this as a no-op tick."
 				);
 			}
 			this.lastDelivered = file.content;
@@ -92,16 +88,16 @@ export class LoopFileDelivery {
 					"instructions for this tick and every subsequent tick (the reminder on later fires refers back to this message).",
 				"",
 				file.content,
-			].join("\n") + cronNote;
+			].join("\n");
 		}
 		if (this.lastDelivered === MAINTENANCE_MARKER) {
 			return (
 				"# /loop tick \u2014 maintenance pass\n" +
 				"Run the maintenance pass using the instructions established earlier in this conversation. " +
-				`If you cannot find them, treat this as a no-op tick.${cronNote}`
+				"If you cannot find them, treat this as a no-op tick."
 			);
 		}
 		this.lastDelivered = MAINTENANCE_MARKER;
-		return MAINTENANCE_PROMPT + cronNote;
+		return MAINTENANCE_PROMPT;
 	}
 }

package/package.json

@@ -1,6 +1,6 @@
 {
 	"name": "pi-cc-loop",
-	"version": "0.2.0",
+	"version": "0.4.0",
 	"description": "Claude Code compatible /loop for the Pi coding agent: cron-scheduled fixed intervals, self-paced chains, and the same dispatch semantics as Claude Code.",
 	"author": "tarnish233",
 	"type": "module",

package/prompts.ts

@@ -23,6 +23,20 @@ export const MAINTENANCE_PROMPT = [
 ].join("\n");
 
 export const PROVENANCE = "[loop tick #{n} \u00b7 scheduled by /loop, not typed by the user]";
+/**
+ * A fixed-interval fire is framed as what it is - a scheduled task, not a
+ * loop iteration. Claude Code does the same: "This turn was started
+ * automatically by a schedule, not typed live by the user. The content below is
+ * the stored prompt of a scheduled task ... Treat it as this session's assigned
+ * task and carry it out." It never calls a cron fire a "loop tick"; that word
+ * belongs to dynamic pacing, where the model has to keep the loop alive. Naming
+ * it "loop" here is what made the model try to reschedule.
+ */
+export const SCHEDULED_TASK_PROVENANCE =
+	"[scheduled task {id} \u00b7 {schedule} \u00b7 started by the schedule, not typed by the user; it fires the next tick on its own, so do not call schedule_wakeup; to cancel it, call cron_delete with id {id}]";
+
+/** The first line of the hidden rules message a /loop request or a self-paced tick carries. */
+export const RULES_PROVENANCE = "[/loop instructions for this run \u00b7 added by pi-cc-loop, not typed by the user]";
 
 const DELAY_ADVICE = [
 	"- Pick the delay from what you are waiting for. For idle ticks with nothing specific to watch, use 1200-1800s.",
@@ -36,32 +50,49 @@ const DELAY_ADVICE = [
  * parse. Claude Code's /loop is a skill: the model reads the input and works
  * the schedule out itself, so an interval written in any language works.
  */
-const LOOP_SCHEDULE_RULES = [
-	"This is a `/loop` request. Its prompt is: {prompt}",
+/**
+ * The instructions for one `/loop` request. Claude Code's `/loop` is a skill:
+ * the command turns into a user message carrying these rules, and the model
+ * drives CronCreate / CronList / CronDelete / ScheduleWakeup itself. Nothing is
+ * created by code, so the conversation shows what was asked and what was done.
+ */
+const LOOP_FILE_SENTINEL_PLACEHOLDER = "__loop_md_sentinel__";
+
+const LOOP_COMMAND_GUIDELINES = [
+	"This is a `/loop` request from the user: {raw}",
 	"",
-	"Decide how it should repeat, then set it up.",
+	"## Read the input",
+	"- `[interval] <task>`: an interval was given (\"5m\", \"2h\", \"every 20m\", \"每2分钟\", \"每隔2小时\"). Use the fixed-interval mode below.",
+	"- `<task>` alone: no interval. Use the self-paced mode below and choose each delay yourself.",
+	"- An interval alone, or a bare `/loop`: the tasks come from loop.md (see the last section).",
+	"- `stop [id]` or `status`: see those sections.",
 	"",
-	"**If the prompt asks for a fixed interval** (\"every 30 seconds\", \"each 5 minutes\", \"every hour\",",
-	"\"\u6bcf30\u79d2\"): create a recurring job with the `cron_create` tool.",
-	"- `prompt`: the task without the interval wording, so every run does the task instead of scheduling it again.",
-	"- Convert the interval to a 5-field cron expression in local time (\"M H DoM Mon DoW\").",
-	"  `s` rounds up to the nearest minute (the scheduler's minimum granularity is 1 minute),",
-	"  `m` are minutes, `h` are hours, `d` are days. Examples: `5m` -> `*/5 * * * *`,",
-	"  `1h` -> `0 * * * *`, `1d` -> `0 0 * * *`. If the interval does not cleanly divide its",
-	"  unit, round to the nearest clean interval and tell the user what you rounded to.",
-	"- Then confirm to the user: what is scheduled, the cron expression, the human-readable",
-	"  cadence, the next run time from the tool result, that recurring jobs auto-expire after",
-	"  7 days (they run one final time, then are deleted), and the job id they can cancel with",
-	"  `cron_delete`.",
+	"## Fixed interval (an interval was given)",
+	"1. Call `cron_create` **once**, `recurring: true`, with a 5-field cron expression in local time and the task **without** the interval wording, so every run does the task instead of scheduling it again.",
+	"   - under a minute rounds up to `* * * * *`; 5 minutes is `*/5 * * * *`; every hour is `0 * * * *`; every day is `0 0 * * *`.",
+	"   - if the interval does not divide its unit cleanly, round to the nearest clean interval and say so.",
+	"2. **Then do the task now** \u2014 do not wait for the first fire.",
+	"3. Confirm briefly: what is scheduled, the cron expression, the cadence, the next run from the tool result, that a recurring job expires after 7 days (it fires once more, then is deleted), the job id, and that `/loop stop <id>` cancels it.",
+	"4. Never call `schedule_wakeup` for this loop: the cron fires its own ticks. Scheduling one would run the task twice.",
 	"",
-	"**Otherwise the interval is open-ended**: you pace the loop yourself.",
-	"- Do the task now, then write your update for the user.",
-	"- Then call the `schedule_wakeup` tool with `delaySeconds` (60-3600), a one-sentence `reason`,",
-	"  and `prompt` set to the same /loop prompt verbatim: {quoted}",
-	"  The turn ends as soon as `schedule_wakeup` returns, so call it last.",
-	DELAY_ADVICE,
-	"- If the task is complete or can no longer make progress, call `schedule_wakeup` with",
-	"  `stop: true` instead of scheduling another iteration.",
+	"## Self-paced (no interval)",
+	"1. Do the task now, then write your update for the user.",
+	"2. Then call `schedule_wakeup` with `delaySeconds` (60-3600), a one-sentence `reason`, and `prompt` set to the same `/loop` input verbatim ({quoted}). The turn ends as soon as it returns, so call it last.",
+	"{delayAdvice}",
+	"3. If the next iteration waits on an external event and no monitor is running for it, arm `Monitor` once with `loopPrompt` set to {quoted}; keep `delaySeconds` at 1200-1800 as the fallback heartbeat.",
+	"4. If the task is complete or cannot progress without the user, call `schedule_wakeup` with `stop: true` and say why.",
+	"",
+	"## status and stop",
+	"- `status`: call `cron_list` and report each job's id, cadence, next run and prompt, plus whether it is session-only or durable.",
+	"- `stop`: if the id is unknown, call `cron_list` first; then `cron_delete` for a scheduled job. A self-paced loop is ended with `schedule_wakeup` and `stop: true`.",
+	"",
+	"## Flags",
+	"- `--durable`: pass `durable: true` to `cron_create` so the job survives restarts.",
+	"- `--max N`: pass `maxFires: N`.",
+	"",
+	"## loop.md",
+	"When the request has no task of its own (bare `/loop`, or an interval alone), pass the literal sentinel " + LOOP_FILE_SENTINEL_PLACEHOLDER + " as the prompt: it expands at fire time to `.pi/loop.md`, or to the built-in maintenance pass when there is no loop.md.",
+	"For the run you do right now, read `.pi/loop.md` (or `~/.pi/loop.md`) yourself and do those tasks; the sentinel only expands on later fires.",
 ].join("\n");
 
 const LOOP_GUIDELINES = [
@@ -118,8 +149,18 @@ export function provenance(tick: number): string {
 	return fill(PROVENANCE, { n: String(tick) });
 }
 
-export function scheduleRules(prompt: string): string {
-	return fill(LOOP_SCHEDULE_RULES, { prompt: describePrompt(prompt), quoted: quote(prompt) });
+/** The header of a fixed-interval fire: a scheduled task, not a loop tick. */
+export function scheduledTaskProvenance(id: string, schedule: string): string {
+	return fill(SCHEDULED_TASK_PROVENANCE, { id, schedule });
+}
+
+export function loopCommandGuidelines(raw: string): string {
+	const quoted = quote(raw || LOOP_FILE_SENTINEL);
+	return fill(LOOP_COMMAND_GUIDELINES, {
+		raw: raw ? `${quote(raw)}` : "(empty: the loop.md tasks)",
+		quoted,
+		delayAdvice: DELAY_ADVICE,
+	}).replace(LOOP_FILE_SENTINEL_PLACEHOLDER, quote(LOOP_FILE_SENTINEL));
 }
 
 export function loopGuidelines(prompt: string): string {
@@ -172,10 +213,23 @@ By default (durable: false) the job belongs to this Pi session: it is restored i
 cron_create re-runs a prompt at fixed wall-clock intervals. To watch a log file, process, or command output and be told the moment something changes, use the Monitor tool instead when it is available \u2014 it streams events as they happen; cron polls on a schedule.
 
 ## Runtime behavior
-Jobs only fire while the agent is idle (not mid-turn). The scheduler shifts each job by a fixed per-job offset on top of whatever you pick: a recurring job runs up to half its period late (max 30 min), a "*/5 * * * *" job runs every 4m45s so the 5-minute prompt cache stays warm, and a one-shot job landing on :00 or :30 runs up to 90 s early. The result of this tool and of cron_list gives each job's actual next run time: when you tell the user when a job will run, give that time, not the minute in the cron expression.
+Jobs only fire while the agent is idle (not mid-turn). The scheduler shifts each job by a fixed per-job offset on top of whatever you pick: a recurring job runs up to half its period late (max 30 min), a "*/5 * * * *" job keeps its 5 minute cadence, late by that offset rather than early, and a one-shot job landing on :00 or :30 runs up to 90 s early. The result of this tool and of cron_list gives each job's actual next run time: when you tell the user when a job will run, give that time, not the minute in the cron expression.
 Recurring jobs auto-expire after 7 days \u2014 they fire one final time, then are deleted. Tell the user about the 7-day limit when scheduling recurring jobs.
 Returns a job ID you can pass to cron_delete.`;
 
+/**
+ * Appended to the result of a recurring `cron_create` in a plain turn (not a
+ * /loop request, not a scheduled tick). Claude Code's /loop skill says "Then
+ * immediately run it now ... Don't wait for the first cron fire", and its model
+ * reaches that skill for "every 5 minutes ..." typed without /loop: the skill is
+ * listed every turn and CronCreate is a deferred tool. Pi has no deferred tools,
+ * so the model calls cron_create directly and the result says it instead. A
+ * tool result is appended at the end of the transcript; the cache is untouched.
+ */
+export const RUN_NOW_HINT =
+	'If the user asked for this to repeat on an interval ("every 5 minutes"), do the task once now as well \u2014 ' +
+	'don\'t wait for the first fire, as /loop does. A job at set times ("every day at 9am") only runs at those times.';
+
 export const CRON_DELETE_DESCRIPTION =
 	"Cancel a job scheduled with cron_create, or end a self-paced /loop, by its id. Removes it from .pi/scheduled_tasks.json (durable jobs) or from this session (session-only jobs).";
 
@@ -189,7 +243,10 @@ Pass the same /loop prompt back via \`prompt\` each turn so the next firing repe
 Do not schedule a short wakeup to poll for work Pi will tell you about anyway (a monitor event, a command you are running): schedule a long fallback (1200s+) so the loop survives if that never arrives. For external work nothing notifies you about (a CI run, a deploy, a remote queue), pick a delay matched to how fast that state actually changes.
 
 ## Picking delaySeconds
-Most model providers cache the conversation prefix for about 5 minutes. Under 300s (60-270s) the next wakeup reads the context cached; past that it is read uncached \u2014 slower and more expensive. When actively polling, prefer 270s over 300s (300s pays the cache miss without amortizing it), and commit to 1200s+ rather than repeated ~300s waits. For idle ticks with no specific signal to watch, default to 1200-1800s (20-30 min). The runtime clamps to [60, 3600].
+Pick the delay from what you are waiting for. When actively polling state nothing notifies you about, match how fast it changes and commit to it instead of stacking short waits. For idle ticks with no specific signal to watch, default to 1200-1800s (20-30 min). The runtime clamps to [60, 3600].
+
+## Only for self-paced loops
+A /loop started with an interval (for example /loop 5m ...) is a cron job: it fires its own ticks, and calling this from one of those ticks would run the prompt twice. Cancel that kind of loop with \`cron_delete\` instead.
 
 ## The reason field
 One short sentence on what you chose and why. It is shown to the user: "watching CI run" beats "waiting".`;

package/render.ts

@@ -41,6 +41,22 @@ export function stripProvenance(text: string, pattern: RegExp): string {
 	return text.replace(pattern, "");
 }
 
+/** Cap a string for a display line, with an ellipsis. */
+export function truncate(text: string, max: number): string {
+	const flat = text.replace(/\s+/g, " ").trim();
+	return flat.length <= max ? flat : `${flat.slice(0, Math.max(0, max - 1))}\u2026`;
+}
+
+/** "900ms", "5s", "1m 30s": a duration for a status line. */
+export function formatDuration(ms: number): string {
+	if (ms < 1000) return `${Math.round(ms)}ms`;
+	const seconds = Math.round(ms / 1000);
+	if (seconds < 60) return `${seconds}s`;
+	const minutes = Math.floor(seconds / 60);
+	const rest = seconds % 60;
+	return rest ? `${minutes}m ${rest}s` : `${minutes}m`;
+}
+
 /** The first non-empty line of a text block. */
 export function firstLine(text: string): string {
 	for (const line of text.split("\n")) {
@@ -66,7 +82,11 @@ export function formatStamp(epochMs: number | undefined): string {
 	const date = new Date(epochMs ?? Date.now());
 	if (Number.isNaN(date.getTime())) return "";
 	const now = new Date();
-	const time = date.toLocaleTimeString(undefined, { hour: "numeric", minute: "2-digit" });
+	// Claude Code's clock style: "6:16pm", lowercase, no space.
+	const hour = date.getHours();
+	const time = `${hour % 12 === 0 ? 12 : hour % 12}:${String(date.getMinutes()).padStart(2, "0")}${
+		hour < 12 ? "am" : "pm"
+	}`;
 	if (date.toDateString() === now.toDateString()) return time;
 	const day = date.toLocaleDateString(undefined, { month: "short", day: "numeric" });
 	return `${day} ${time}`;

package/renderers.ts

@@ -1,137 +1,90 @@
 /**
- * Rendering for pi-cc-loop: the compact tool rows and the loop tick message.
+ * The display helpers pi-cc-loop still needs: clock times, the coarse countdown
+ * for the footer, and the block a scheduled fire draws in the transcript. The
+ * /loop request itself is an ordinary user message, rendered by Pi.
  */
 
-import type { Theme, ToolRenderers } from "@earendil-works/pi-coding-agent";
+import type { Theme } from "@earendil-works/pi-coding-agent";
+import { bodyLines, contentText, formatStamp, renderBlock, renderCard, stripProvenance } from "./render.ts";
 import { loadConfig } from "./config.ts";
 import { humanSchedule } from "./cron.ts";
 import { displayPrompt } from "./loopfile.ts";
-import {
-	bodyLines,
-	contentText,
-	firstLine,
-	formatStamp,
-	renderBlock,
-	renderCard,
-	stripProvenance,
-} from "./render.ts";
-import type { LoopJob } from "./schedule.ts";
-import { compactRenderers, truncate } from "./tool-rows.ts";
 
+
+/**
+ * A clock time the way Claude Code writes it: "6:16pm". Formatted here rather
+ * than through the locale, so the transcript reads the same everywhere.
+ */
 export function formatClock(epochMs: number | undefined): string {
 	if (!epochMs) return "unknown";
-	return new Date(epochMs).toLocaleTimeString(undefined, { hour: "2-digit", minute: "2-digit" });
-}
-
-export function formatDelay(seconds: number | undefined): string {
-	if (seconds === undefined) return "unknown";
-	if (seconds < 60) return `${seconds}s`;
-	const minutes = Math.floor(seconds / 60);
-	const rest = Math.round(seconds % 60);
-	return rest ? `${minutes}m ${rest}s` : `${minutes}m`;
+	const date = new Date(epochMs);
+	const hour = date.getHours();
+	const suffix = hour < 12 ? "am" : "pm";
+	const twelve = hour % 12 === 0 ? 12 : hour % 12;
+	return `${twelve}:${String(date.getMinutes()).padStart(2, "0")}${suffix}`;
 }
 
-export function jobSummary(job: LoopJob): string {
-	if (job.kind === "cron" && job.cron) {
-		return `${job.id} ${humanSchedule(job.cron)} \u00b7 next ${formatClock(job.nextFireAt)}`;
-	}
-	return `${job.id} self-paced \u00b7 ${job.scheduledFor ? `next ${formatClock(job.scheduledFor)}` : "unscheduled"}`;
+/**
+ * A countdown for the footer: "3m", "<1m", "2h 15m". Rounded up and coarse on
+ * purpose, so the shared footer line is repainted at most once a minute.
+ */
+export function formatEta(ms: number): string {
+	const seconds = ms / 1000;
+	if (seconds < 60) return "<1m";
+	const minutes = Math.ceil(seconds / 60);
+	if (minutes < 60) return `${minutes}m`;
+	const hours = Math.floor(minutes / 60);
+	const rest = minutes % 60;
+	return rest ? `${hours}h ${rest}m` : `${hours}h`;
 }
 
-/** One-line rows for the four loop tools. */
-export function loopToolRenderers(): Record<string, ToolRenderers> {
-	return {
-		cron_create: compactRenderers({
-			call: (args) => ({
-				label: "Schedule",
-				detail: `${args.cron ?? ""} \u00b7 ${truncate(displayPrompt(args.prompt ?? ""), 40)}`,
-			}),
-			summary: (d) =>
-				`Scheduled ${d.id ?? "?"} \u00b7 ${humanSchedule(d.cron ?? "")} \u00b7 next ${formatClock(d.nextFireAt)}` +
-				(d.recurring === false ? " \u00b7 one-shot" : "") +
-				(d.durable ? " \u00b7 durable" : "") +
-				(d.runsHere === false ? " \u00b7 runs in another session" : ""),
-			detail: (d) => (d.prompt ? displayPrompt(d.prompt) : undefined),
-		}),
-		cron_delete: compactRenderers({
-			call: (args) => ({ label: "Cancel", detail: args.id ?? "" }),
-			summary: (d) => (d.cancelled ? `Cancelled ${d.id ?? "?"}` : `No job ${d.id ?? "?"}`),
-		}),
-		cron_list: compactRenderers({
-			call: () => ({ label: "List scheduled jobs" }),
-			summary: (d) => {
-				const jobs: LoopJob[] = d.jobs ?? [];
-				if (!jobs.length) return "No scheduled jobs";
-				if (jobs.length === 1) return `1 job \u00b7 ${jobSummary(jobs[0])}`;
-				const shown = jobs.slice(0, 2).map(jobSummary).join(" \u00b7 ");
-				return `${jobs.length} jobs \u00b7 ${shown}${jobs.length > 2 ? " \u2026" : ""}`;
-			},
-			detail: (d) =>
-				((d.jobs ?? []) as LoopJob[])
-					.map((job) => `${jobSummary(job)} \u00b7 ${truncate(displayPrompt(job.prompt), 60)}`)
-					.join("\n") || undefined,
-		}),
-		schedule_wakeup: compactRenderers({
-			call: (args) =>
-				args.stop === true
-					? { label: "Stop loop" }
-					: {
-							label: "Wakeup",
-							detail: `${formatDelay(args.delaySeconds)}${args.reason ? ` \u00b7 ${truncate(args.reason, 40)}` : ""}`,
-						},
-			summary: (d) => {
-				if (d.agedOut) return "Loop ended \u00b7 7-day limit reached";
-				if (d.stopped) {
-					return `Stopped \u00b7 ${d.cancelledWakeups ?? 0} wakeup${d.cancelledWakeups === 1 ? "" : "s"} cancelled`;
-				}
-				const adjusted = d.wasClamped ? " (clamped)" : "";
-				return `Wakeup in ${formatDelay(d.clampedDelaySeconds)} \u00b7 loop ${d.id ?? "?"}${adjusted}`;
-			},
-			detail: (d, args) =>
-				[args.reason, d.scheduledFor ? `at ${formatClock(d.scheduledFor)}` : undefined]
-					.filter(Boolean)
-					.join(" \u00b7 ") || undefined,
-		}),
-	};
+/** What a tick carries for the renderer; the model reads `content`. */
+export interface ScheduledDetails {
+	kind?: "cron" | "wakeup";
+	tickCount?: number;
+	jobId?: string;
+	cron?: string;
+	prompt?: string;
+	reason?: string;
+	missed?: boolean;
 }
 
 /**
- * Draw a tick as a quiet block instead of Pi's default `[pi-cc-loop-tick]`
- * title. The provenance line is for the model, not the reader.
+ * Draw a scheduled fire the way Claude Code does: `✻ Running scheduled task ·
+ * 6:16pm`, then the task. The provenance line in `content` is addressed to the
+ * model ("started by the schedule...") and must not reach the reader.
  */
-export function renderTickMessage(message: any, options: any, theme: Theme): any {
-	const details = (message.details ?? {}) as {
-		tickCount?: number;
-		jobId?: string;
-		cron?: string;
-		immediate?: boolean;
-		missed?: boolean;
-	};
-	const text = contentText(message.content);
-	const prompt = stripProvenance(text, /^\[[^\]]*\]\n?/);
+export function renderScheduledMessage(message: any, options: any, theme: Theme): any {
+	const details = (message.details ?? {}) as ScheduledDetails;
+	const prompt = details.prompt ?? stripProvenance(contentText(message.content), /^\[[^\]]*\]\n?/);
+	// A fixed interval fires a scheduled task; only a self-paced tick is a loop.
 	const label = details.missed
-		? "loop \u00b7 missed jobs"
-		: details.tickCount !== undefined
-			? `loop #${details.tickCount}`
-			: "loop";
+		? "\u273b loop \u00b7 missed jobs"
+		: details.kind === "cron"
+			? "\u273b Running scheduled task"
+			: details.tickCount !== undefined
+				? `\u273b loop #${details.tickCount}`
+				: "\u273b loop";
 
 	if (!loadConfig().compactMessages) {
-		const summary = firstLine(prompt);
-		const header = details.missed
-			? label
-			: `loop tick #${details.tickCount ?? "?"}${summary ? ` \u00b7 ${summary}` : ""}`;
+		// Same naming as the block: a cron fire is a scheduled task, only a
+		// self-paced tick is a loop.
+		const header = details.missed ? label : `${label.replace("\u273b ", "")} \u00b7 ${displayPrompt(prompt)}`;
 		return renderCard({ header, body: prompt, expanded: options.expanded, outputPad: options.outputPad, theme });
 	}
 
 	const stamp = formatStamp(message.timestamp);
-	const header = stamp
-		? `${theme.fg("accent", theme.bold(label))}${theme.fg("dim", " \u00b7 ")}${theme.fg("muted", stamp)}`
-		: theme.fg("accent", theme.bold(label));
+	// The reason the model gave for this delay, in the header so the reader
+	// knows why the loop woke up without expanding anything.
+	const why = details.kind === "wakeup" && details.reason ? ` \u00b7 ${details.reason}` : "";
+	const header =
+		(stamp
+			? `${theme.fg("accent", theme.bold(label))}${theme.fg("dim", " \u00b7 ")}${theme.fg("muted", stamp)}`
+			: theme.fg("accent", theme.bold(label))) + (why ? theme.fg("dim", why) : "");
 
 	const meta: string[] = [];
 	if (details.jobId) meta.push(`job ${details.jobId}`);
-	if (details.cron) meta.push(`cron ${details.cron}`);
-	else if (details.immediate) meta.push("immediate run");
+	if (details.kind === "cron" && details.cron) meta.push(humanSchedule(details.cron));
 	else if (!details.missed) meta.push("self-paced");
 	meta.push("scheduled by /loop");
 

package/schedule.ts

@@ -159,6 +159,8 @@ export interface SchedulerHooks {
 	onExpire?: (job: LoopJob) => void;
 	/** Runs at the start of every scan (housekeeping such as durable jobs). */
 	onScan?: (now: number) => void;
+	/** A delivery threw (Pi's API is stale once the session is replaced); the tick is dropped. */
+	onDispatchError?: (job: LoopJob, error: Error) => void;
 }
 
 /** Claude Code checks for due tasks once a second. */
@@ -277,7 +279,12 @@ export class LoopScheduler {
 
 	/** Run one scan: housekeeping, mark due jobs pending, dispatch the oldest when idle. */
 	tick(now = Date.now()): void {
-		this.hooks.onScan?.(now);
+		try {
+			this.hooks.onScan?.(now);
+		} catch {
+			// Housekeeping (the durable file, the footer) is best effort. This runs
+			// from a timer, where an exception would take Pi down with it.
+		}
 		this.markDue(now);
 		this.tryDispatch(now);
 	}
@@ -336,7 +343,14 @@ export class LoopScheduler {
 			finished = next === null;
 		}
 
-		this.hooks.dispatch(job);
+		try {
+			this.hooks.dispatch(job);
+		} catch (error) {
+			// Dropped, like any tick that fails to start; the job keeps its next
+			// run. Not rethrown: this runs from a timer, where an exception would
+			// take Pi down with it.
+			this.hooks.onDispatchError?.(job, error instanceof Error ? error : new Error(String(error)));
+		}
 		if (finished) this.jobs.delete(job.id);
 		this.hooks.afterDispatch?.(job, finished);
 		if (expired) this.hooks.onExpire?.(job);

package/tool-rows.ts

@@ -1,79 +0,0 @@
-/**
- * Compact one-line tool rows and small formatting helpers shared by the pi-cc
- * extensions.
- *
- * This file is identical in pi-cc-loop and pi-cc-monitor; tests/shared.test.mjs
- * fails when the two copies drift apart.
- */
-
-import type { Theme, ToolRenderers } from "@earendil-works/pi-coding-agent";
-import { Container, Text } from "@earendil-works/pi-tui";
-
-/** Collapse whitespace and cut the text to `max` characters. */
-export function truncate(text: string, max: number): string {
-	const clean = text.replace(/\s+/g, " ").trim();
-	return clean.length > max ? `${clean.slice(0, max - 1)}\u2026` : clean;
-}
-
-/** "20s", "5m", "1m 30s", "1h", "1h 5m", "2d 3h". */
-export function formatDuration(ms: number): string {
-	if (!Number.isFinite(ms)) return "unknown";
-	const seconds = Math.max(0, Math.round(ms / 1000));
-	if (seconds < 60) return `${seconds}s`;
-	const minutes = Math.floor(seconds / 60);
-	const restSeconds = seconds % 60;
-	if (minutes < 60) return restSeconds ? `${minutes}m ${restSeconds}s` : `${minutes}m`;
-	const hours = Math.floor(minutes / 60);
-	const restMinutes = minutes % 60;
-	if (hours < 24) return restMinutes ? `${hours}h ${restMinutes}m` : `${hours}h`;
-	const days = Math.floor(hours / 24);
-	const restHours = hours % 24;
-	return restHours ? `${days}d ${restHours}h` : `${days}d`;
-}
-
-/** The first text line of a tool result. */
-export function resultText(result: { content?: Array<{ type?: string; text?: string }> }): string {
-	for (const block of result.content ?? []) {
-		if (block?.type === "text" && typeof block.text === "string") {
-			return block.text.split("\n")[0] ?? "";
-		}
-	}
-	return "";
-}
-
-export interface CompactRow {
-	/** The call row, shown while the call runs. It disappears once the result arrives. */
-	call: (args: any) => { label: string; detail?: string };
-	/** The one-line summary of a successful result. */
-	summary: (details: any, args: any) => string;
-	/** Extra lines shown when the row is expanded. */
-	detail?: (details: any, args: any) => string | undefined;
-}
-
-/**
- * Renderers that draw a tool call as a single result line, for example
- * `✓ Scheduled hu2389lz · Every minute · next 04:55 PM`. Errors show the first
- * line of the error text.
- */
-export function compactRenderers(row: CompactRow): ToolRenderers {
-	return {
-		renderCall(args: any, theme: Theme, context: any) {
-			if (!context?.isPartial && context?.executionStarted) return new Container();
-			const { label, detail } = row.call(args ?? {});
-			const title = theme.fg("toolTitle", theme.bold(label));
-			return new Text(detail ? `${title} ${theme.fg("muted", detail)}` : title, 0, 0);
-		},
-		renderResult(result: any, options: any, theme: Theme, context: any) {
-			if (options?.isPartial) return new Text(theme.fg("warning", "Working\u2026"), 0, 0);
-			if (context?.isError) {
-				return new Text(`${theme.fg("error", "\u2717 ")}${theme.fg("error", resultText(result) || "Failed")}`, 0, 0);
-			}
-			const details = result?.details ?? {};
-			const args = context?.args ?? {};
-			const summary = row.summary(details, args) || resultText(result);
-			const line = `${theme.fg("success", "\u2713 ")}${theme.fg("toolOutput", summary)}`;
-			const detail = options?.expanded ? row.detail?.(details, args) : undefined;
-			return new Text(detail ? `${line}\n${theme.fg("dim", detail)}` : line, 0, 0);
-		},
-	};
-}