@alphacoder-v0/pi-loops 0.22.4 → 0.22.5

package/CHANGELOG.md

@@ -5,6 +5,49 @@ All notable changes to pi-loops are documented here. The format follows
 
 ## [Unreleased]
 
+## [0.22.5] - 2026-09-28
+
+### Changed
+- **Both READMEs say what `/cron remove` reaches.** The command tables put `remove` in one row
+  with `enable` and `disable`, which resolve a name across the machine; removal stopped doing
+  that in 0.22.4 and the row never said so. It now states the rule: a name of this project, or
+  the exact id of a job anywhere.
+- **The design principles say when a job disappears.** Principle 11 said a job goes when you
+  remove it "and not before", which a one-shot that has fired and a job `/cron gc` collects
+  both contradict. It now names all three, and says none of them is time passing.
+- **`/cron` says `skipped overlaps`.** The listing called the counter `overlap skips`, while the
+  terminal panel and docs/loops.md call it `skipped overlaps`. The listing now uses the same name.
+- **The `/cron` listing is in `src/job-lines.ts`.** It was composed inside the extension's default
+  export, where no test can reach it. The lines are unchanged; each marker and column now has a test.
+- **docs/design.md counts eight recipes** and names `deps-sweeper`, which ships but was not listed.
+
+### Fixed
+- **A long session with non-ASCII text is listed as truncated again.** The session-list window is
+  64 KB of *bytes*, but the check asked whether the decoded string was that many UTF-16 code units
+  long. With CJK text the decoded length is smaller, so a session well past the window read as
+  complete and the resume picker printed a floor (`314 message(s)`) as an exact count. Both copies —
+  `src/session-head.ts` and the one inside `src/web.mjs` — now compare the bytes actually read.
+- **`pi-loops sessions --limit` refuses a value it cannot use.** `--limit abc` and `--limit 0`
+  printed nothing and exited 0, the same output as a project with no sessions, and `--limit -1`
+  printed all but the oldest. The value must now be a whole number of at least 1.
+- **`/triggers audit` refuses a limit it cannot read.** `alll`, `0` and `25x` quietly became the
+  default of 10 or 25, and `-5` printed almost the whole audit file. Anything other than one whole
+  number of at least 1 and `--all` now prints the usage line.
+- **The `/goal` evaluator gets the 40 000 characters docs/goal.md promises.** The cap counted UTF-16
+  code units, so an emoji-heavy transcript was cut to about half and could begin on half a character.
+- **The browser shows pi's last words with the cut marked.** When pi exits, the server cut its
+  stderr to 4000 UTF-16 code units and said nothing, so the tail looked whole and could begin on half
+  a character. The cut now counts characters and starts with `… (N chars dropped)`.
+- **The browser panel shows an MCP server's last error whole.** The Runtime box cut it at 120
+  characters with no ellipsis, although the error it receives is already capped at 160 and marked.
+- **The browser job card shows a loop's skipped overlaps,** as `/cron` and the terminal panel do.
+- **The browser panel keeps a job whose checkout is gone in this project.** It resolved a missing
+  path only one directory up, so a removed worktree two levels down counted as another project's,
+  while `/cron` still listed it with `[orphan: cwd missing]`. It now resolves the deepest ancestor
+  that exists, as `src/paths.ts` does.
+- **docs/web-ui-parity.md names a test that exists.** One line of the front-end gate named a test
+  that had been renamed. A new test checks every test name that a document gives.
+
 ## [0.22.4] - 2026-09-20
 
 ### Fixed

package/README.md

@@ -38,7 +38,7 @@ the first sign of credentials that do not work should not be an empty inbox tomo
 
 ```bash
 pi install npm:@alphacoder-v0/pi-loops                      # from npm, following new releases
-pi install git:github.com/alphacoder-v0/pi-loops@v0.22.4    # or from GitHub, at a pinned tag
+pi install git:github.com/alphacoder-v0/pi-loops@v0.22.5    # or from GitHub, at a pinned tag
 pi install /path/to/pi-loops                                # or a local checkout — `pi install .` in this repo
 pi -e /path/to/pi-loops                                     # or none of them: try it for one run, installing nothing
 ```
@@ -276,7 +276,7 @@ State stays in `~/.pi/agent/loops` until you delete it.
 |---|---|
 | `/cron add [--stateful] [--verify] "<schedule>" <prompt>` | Schedule a job: a plain job belongs to this chat and injects its result here (it sleeps while this session is not open), `--stateful` makes a loop that runs wherever the clock is, with memory and inbox routing, `--verify` adds the checker |
 | `/cron`, `/cron all` | This project's jobs, or every project on this machine |
-| `/cron enable\|disable\|remove <ref>` | Pause, resume or delete one job — and write an audit entry into the session, as `add` does |
+| `/cron enable\|disable\|remove <ref>` | Pause, resume or delete one job — and write an audit entry into the session, as `add` does. `remove` takes a name of this project or the exact id of a job anywhere, so a name never reaches a checkout you are not in |
 | `/cron disable --all` | Pause every job in this project (`--all-projects` for the machine); `/cron enable --all` resumes |
 | `/cron run <ref>` | Fire one job now instead of waiting for its schedule |
 | `/cron state <ref>` | The loop's notes — the Markdown it carries from one run to the next |

package/README.zh-CN.md

@@ -45,7 +45,7 @@ pi-loops 自己没有任何运行时依赖。
 
 ```bash
 pi install npm:@alphacoder-v0/pi-loops                      # 从 npm 装，跟着新版本走
-pi install git:github.com/alphacoder-v0/pi-loops@v0.22.4    # 或者从 GitHub 装，钉住一个 tag
+pi install git:github.com/alphacoder-v0/pi-loops@v0.22.5    # 或者从 GitHub 装，钉住一个 tag
 pi install /path/to/pi-loops                                # 或者本地检出；本仓库里就是 pi install .
 ```
 
@@ -242,6 +242,7 @@ playbook 拷到 `.agents/skills/<name>/`，通过 `.git/info/exclude` 排除在
 /cron add in 10m 提醒我看一下测试结果                           # 会话级闹钟
 /cron  ·  /cron list|ls|status      本项目的任务，[stateful] 标记；/cron all 看整台机器
 /cron enable|resume|disable|pause|remove <n|id|name>
+                                    remove 只认本项目的名字和编号，别的项目的任务要给完整 id（删除撤不回来）
 /cron set <ref> …                   改已有任务而不换 id（笔记因此留着）：--prompt、--schedule，
                                     以及 --model、--thinking、--timeout、--name 这几个钉子（`-` 解掉）
 /cron run 1                         立刻跑一次（once 跑完即删，every 的间隔从现在重算，cron 的下次不变；停用的普通任务会被拒绝）

package/docs/cli.md

@@ -238,7 +238,9 @@ in the session's control-plane audit.
 characters of the id, when the session started, the automation it
 has (`[2 cron, 1 trigger]`, or `[automation off]` when all of it is disabled), and what was first
 said in it — the session's name if it was given one, otherwise the first message, cut at eighty
-characters. `--all` lists every project and puts the cwd after the id. The id is what
+characters. `--all` lists every project and puts the cwd after the id. `--limit <n>` shows at most
+`n` (default 20); a whole number of at least 1 is required, and anything else is refused rather than
+read as an offset. The id is what
 `export --session` accepts; a unique prefix will do. `inspect` prints an archive's schedules, prompts and rules without
 writing anything, which is what you want before restoring on a machine you care about.
 

package/docs/design.md

@@ -102,7 +102,9 @@ machine. Everything here follows from that, and each one has a price.
     not otherwise need.
 
 11. **Bounded everywhere, and no expiry.** Loop state ≤ 2000 characters, a finding ≤ 500, at most
-    16 per run, prompts ≤ 8 KB. A job disappears when you remove it and not before.
+    16 per run, prompts ≤ 8 KB. A job disappears when you remove it, when a one-shot has fired, or
+    when `/cron gc` collects one whose session is gone — never because time passed. Each of the
+    three is recorded in the control-plane audit, the self-removals included.
 
 12. **Cycle suppression by hop count.** Sub-agents run at hop 1 and keep the cron and trigger tools
     (`cron_create`, `cron_remove`, listing, disabling), so a loop can manage automation; the
@@ -122,10 +124,10 @@ machine. Everything here follows from that, and each one has a price.
 15. **Recipes are files, not code.** A recipe (`CONTEXT.md` has the vocabulary) is a directory:
     a `recipe.toml` manifest whose `[[job]]` fields are the arguments of `/cron add` and nothing
     else, one playbook per job, an optional setup script. Anything the wizard does with one is
-    something a person could have done by hand with `/cron add` and `cp`. The first catalogue is
-    seven: issue-loop, daily-digest, changelog-draft, pr-watch, ci-sweeper, autoresearch, and
-    ecosystem — the last capped at `propose`, because every outward word it drafts is a finding a
-    person claims before it is said.
+    something a person could have done by hand with `/cron add` and `cp`. The catalogue is eight:
+    issue-loop, daily-digest, changelog-draft, pr-watch, ci-sweeper, autoresearch, deps-sweeper,
+    and ecosystem — `ecosystem` capped at `propose`, because every outward word it drafts is a
+    finding a person claims before it is said.
 
     The cost: a project cannot add a recipe by writing TypeScript, only by writing a directory,
     and the wizard can only ask what a manifest can declare.

package/docs/web-ui-parity.md

@@ -98,7 +98,8 @@ weaker, and worth converting whenever one of them breaks.
       different ways and one of them not at all, so a result that stopped at 8000 characters looked
       like a result that ended there. The count and the cut are characters, not UTF-16 code units, so
       an astral character is counted once and a cut cannot end on half of one. `test/web-page.test.ts`:
-      *a capped result counts characters, not the units a string is counted in*.
+      *a capped result counts characters, not the units a string is counted in*; `test/web.test.ts`:
+      *pi's dying words are cut by characters, and the cut says how much it dropped*.
 - [x] **You can see what the session made, not only read about it.** A picture in a reply is a
       picture — including one named in ordinary prose rather than as a link; a path is something to
       open; a page written into the reply has a preview; an image a tool returned is shown rather
@@ -136,7 +137,7 @@ weaker, and worth converting whenever one of them breaks.
       What counts as "this project" is what the extension says it is — symlinks resolved, `$HOME`
       too broad to be one — because a panel that disagrees with the command is worse than either.
       `test/web.test.ts`: *the panel and /cron agree about what this project is*.
-      `test/web-page.test.ts`: *a job this machine no longer owns is listed, not hidden*.
+      `test/web-page.test.ts`: *what the machine has that this project does not is counted, apart*.
 - [x] **When each job runs next, whatever its schedule.** The page used to work this out itself and
       understood only `every <interval>`, so a job on `0 9 * * *` — the first example in the
       README — showed nothing. A second cron parser in a page with no dependencies was the wrong
@@ -194,7 +195,8 @@ weaker, and worth converting whenever one of them breaks.
       browser. A session whose only question is on a terminal you closed is a stuck session. One
       asked while no browser was attached is held for a browser that turns up, and the list of those
       is bounded the way the event backlog is: an abandoned dialog was otherwise re-offered every
-      eight seconds for as long as the process lived.
+      eight seconds for as long as the process lived. `test/web.test.ts`: *dialogs held for a browser
+      that turns up are bounded, oldest first*.
 - [x] A confirmation shows what is about to happen apart from the reasoning about it, so it cannot
       be read as prose and waved through. `test/web-page.test.ts`: *a confirmation shows what is
       about to run*.
@@ -343,6 +345,7 @@ weaker, and worth converting whenever one of them breaks.
 - [x] Pairing survives an upgrade: the token is a file outside the package, so a device stays signed
       in across restarts and new versions. `test/web.test.ts`: *the token outlives the process*.
 - [x] Events are incremental. The backlog a late-joining browser replays is bounded.
+      `test/web.test.ts`: *the event backlog a late-joining browser replays is bounded*.
 - [x] Events carry no credential and no oversized tool payload; the image bytes a message already
       contains travel with it, and the page renders them rather than fetching them. The page itself
       is handed the token — in the cookie, and in the URL on a first visit — and nothing else is. The

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@alphacoder-v0/pi-loops",
-  "version": "0.22.4",
+  "version": "0.22.5",
   "description": "An automation layer for pi: cron + stateful loops with a triage inbox, maker/checker verification, dynamic triggers, MCP notifications and tools, lifecycle hooks, session archives. A non-invasive pi extension.",
   "type": "module",
   "license": "MIT",

package/src/cli.ts

@@ -266,6 +266,12 @@ export async function runCli(argv: string[], out: (line: string) => void = conso
 	if (command === "inbox") return inboxCommand(positional, { all: flags.has("all"), json: flags.has("json"), reason: flags.get("reason") }, cwd, loopsDir, out);
 
 	if (command === "sessions") {
+		// A count, so anything that is not a whole number ≥ 1 would reach `slice` as NaN, a
+		// negative offset or a fraction, and change what is listed without ever saying so.
+		const limitFlag = flags.get("limit");
+		if (limitFlag !== undefined && (typeof limitFlag !== "string" || !/^\d+$/.test(limitFlag) || Number(limitFlag) < 1))
+			throw new Error(`--limit takes a whole number of sessions ≥ 1; got ${limitFlag === true ? "nothing" : JSON.stringify(limitFlag)}`);
+		const limit = limitFlag === undefined ? 20 : Number(limitFlag);
 		// `pickSession` refuses an unknown id, and there was no way to discover one.
 		const sessions = listSessions(path.join(agentDir, "sessions"));
 		const here = flags.has("all") ? sessions : sessions.filter((s) => sameProject(s.cwd, cwd));
@@ -277,7 +283,7 @@ export async function runCli(argv: string[], out: (line: string) => void = conso
 		// session has, what was first said in it. With --all the cwd sits after the id.
 		const jobs = new JobStore(loopsDir).load();
 		const rules = new TriggerStore(loopsDir).load();
-		for (const s of here.slice(0, Number(str("limit") ?? 20))) {
+		for (const s of here.slice(0, limit)) {
 			const badge = automationBadge(s.id, jobs, rules);
 			out(`${s.id.slice(0, 16)}  ${flags.has("all") ? `${s.cwd}  ` : ""}${(s.startedAt ?? stamp(s.mtimeMs)).slice(0, 16)}${badge ? `  [${badge}]` : ""}  ${s.preview ? previewText(s.preview) : ""}`.trimEnd());
 		}

package/src/goal.ts

@@ -69,7 +69,11 @@ export function transcriptFromMessages(messages: Array<{ role?: string; content?
 		if (text) lines.push(`${role}: ${text}`);
 	}
 	const joined = lines.join("\n");
-	return joined.length <= limit ? joined : `…\n${joined.slice(joined.length - limit)}`;
+	// Characters, not UTF-16 code units: one emoji is two units, so counting units cut an emoji-heavy
+	// transcript to about half of the 40 000 docs/goal.md promises and could land between the halves
+	// of one character. `tailChars` is the character-correct tail already used a few lines below.
+	const tail = tailChars(joined, limit);
+	return tail === joined ? joined : `…\n${tail}`;
 }
 
 function renderContent(content: unknown): string {

package/src/job-lines.ts

@@ -0,0 +1,68 @@
+/**
+ * The `/cron` listing, as lines.
+ *
+ * It lives here rather than in `src/pi-loops.ts` — the extension's default export, which nothing can
+ * import — because docs/loops.md states these markers and columns as the behaviour, and until this
+ * was importable no test could see one go. Everything it reads is a parameter, so a test can hand it
+ * a job, a run log and an inbox and read the lines a person reads.
+ */
+import type { InboxEntry } from "./inbox.ts";
+import { asleepNote, runsIn } from "./job-owner.ts";
+import { QUIET_MARK_AFTER, SIGNAL_WINDOW_MS, loopSignal, signalSummary } from "./job-signal.ts";
+import { previewRedacted } from "./redact.ts";
+import { computeNext, formatLocal, formatSchedule } from "./schedule.ts";
+import type { LoopJob, RunRecord } from "./store.ts";
+
+export interface JobLinesInput {
+	/** The whole run log, read once by the caller; only this listing's loops are filtered out of it. */
+	runs: RunRecord[];
+	/** The whole inbox, read once by the caller. */
+	inbox: InboxEntry[];
+	/** The session reading the list: a plain job of another session has no next run where it is. */
+	sessionId?: string;
+	now: number;
+	/** `$HOME`, for `~` shortening; passed rather than read so a test's paths are its own. */
+	home: string;
+	/** Injected because the answer decides `[orphan: cwd missing]`, and a test should not make directories. */
+	cwdExists: (cwd: string) => boolean;
+}
+
+/** The caller's `homeRel`, with `home` passed in: this module has no `process.env`. */
+const homeRel = (p: string, home: string) => (home && p.startsWith(home) ? `~${p.slice(home.length)}` : p);
+
+export function jobLines(jobs: LoopJob[], opts: JobLinesInput): string[] {
+	const { runs, inbox, sessionId, now, home, cwdExists } = opts;
+	return jobs
+		.map((job, i) => {
+			// A next run is shown where it will happen: a plain job of a session not open here has none.
+			const next =
+				job.enabled && runsIn(job, sessionId)
+					? computeNext(
+							{
+								schedule: job.schedule,
+								createdAt: Date.parse(job.createdAt),
+								lastFiredAt: job.lastFiredAt ? Date.parse(job.lastFiredAt) : undefined,
+							},
+							now,
+						)
+					: undefined;
+			const asleepMark = asleepNote(job, sessionId);
+			const dormant = asleepMark ? `[${asleepMark}]` : undefined;
+			const orphan = job.stateful && !cwdExists(job.cwd) ? "[orphan: cwd missing]" : undefined;
+			// What the loop's runs came to (src/job-signal.ts): `quiet ×N` in the marks once N empty
+			// runs are the newest, and the findings line — filed, claimed, dismissed — over 30 days.
+			// A loop was, until now, judged by whether it ran; this is whether it was worth running.
+			const signal = job.stateful ? loopSignal(job.id, runs, inbox, now - SIGNAL_WINDOW_MS) : undefined;
+			const quiet = signal && signal.quiet >= QUIET_MARK_AFTER ? `[quiet ×${signal.quiet}]` : undefined;
+			const marks = [job.stateful ? "[stateful]" : undefined, job.verify ? "[verify]" : undefined, dormant, orphan, quiet, job.running ? `running ${job.running.runId}` : undefined, job.catchUp ? undefined : "[no-catchup]"]
+				.filter(Boolean)
+				.join("  ");
+			const head = `${String(i + 1).padStart(2)}. ${job.id}${job.name ? ` "${job.name}"` : ""}  ${job.enabled ? "enabled" : "disabled"}  ${formatSchedule(job.schedule)}${marks ? `  ${marks}` : ""}`;
+			const action = `    action: ${previewRedacted(job.prompt, 120)}`;
+			const worth = signal ? signalSummary(signal) : undefined;
+			const meta = `    next ${next ? formatLocal(next) : "—"} · runs ${job.runCount}${job.skippedOverlap ? ` · skipped overlaps ${job.skippedOverlap}` : ""}${worth ? ` · 30d: ${worth}` : ""} · ${homeRel(job.cwd, home)}`;
+			const err = job.lastError ? `    last error: ${previewRedacted(job.lastError, 100)}` : job.lastFiredAt ? `    last fired: ${job.lastFiredAt}` : undefined;
+			return [head, action, meta, err].filter((l): l is string => !!l);
+		})
+		.flat();
+}

package/src/pi-loops.ts

@@ -25,7 +25,7 @@ import { sameProject } from "./presence.ts";
 import { isExactlyTrusted, sessionTrustCovers } from "./trust.ts";
 import { HookRunner, type HookEventData, messageKind, messageSummary, resultSummary, runEndEvent, runStartEvent, truncateSummary } from "./hooks.ts";
 import { failingSummary } from "./job-health.ts";
-import { QUIET_MARK_AFTER, SIGNAL_WINDOW_MS, loopSignal, signalSummary } from "./job-signal.ts";
+import { loopSignal, signalSummary } from "./job-signal.ts";
 import { LoopsLog, pruneLogs } from "./log.ts";
 import { type InboxEntry, belongsToProject, inProject, resolveInboxRef } from "./inbox.ts";
 import { McpPool } from "./mcp-pool.ts";
@@ -38,7 +38,8 @@ import { execFile } from "node:child_process";
 import { createHash } from "node:crypto";
 import { computeDue, computeNext, formatLocal, formatSchedule, localOffset, parseSchedule, stamp } from "./schedule.ts";
 import { applyJobEdit } from "./job-edit.ts";
-import { asleepNote, runsIn } from "./job-owner.ts";
+import { jobLines as cronJobLines } from "./job-lines.ts";
+import { runsIn } from "./job-owner.ts";
 import { AUTONOMY_LEVELS, type AutonomyLevel, INSTALL_ROOT, RECIPE_TIERS, type Recipe, type UpdateResult, addLineFor, ensureExcluded, installDirFor, installFiles, installedRecipes, isRecipeName, listRecipes, MAX_SETUP_SHOWN, TRACKER_FILE, loadRecipe, neverSection, packagedRecipesDir, parseAddWords, planInstall, playbookFiles, preflightChecks, purgeInstall, readRecord, renderPreflight, requireRecipeName, resolveRecipeRef, runPreflight, updateFiles } from "./recipe.ts";
 import { LoopScheduler, type SessionSnapshot } from "./scheduler.ts";
 import { MAX_PROMPT_BYTES, type LoopJob, type RunRecord, defaultLoopsDir, newId, resolveJobRef, sessionExists } from "./store.ts";
@@ -49,7 +50,7 @@ import { askHost, renderHostSnapshot } from "./host-control-channel.ts";
 import { waitForHost, HOST_LOG, crashedHost, hostPushWork, liveHost, piPackageDir, shouldHandOff, spawnHost, stopHost } from "./host-control.ts";
 import { summarizeSessionFile } from "./transcript.ts";
 import { TriggerRuntime, type TriggerOutcome } from "./trigger-runtime.ts";
-import { auditCronFinish, auditCronStart, TriggerStore, buildPeriodicCheckTrigger, controlPlanePreflight, resolveRuleRef } from "./triggers.ts";
+import { auditArgs, auditCronFinish, auditCronStart, TriggerStore, buildPeriodicCheckTrigger, controlPlanePreflight, resolveRuleRef } from "./triggers.ts";
 import { type ControlPlaneRequest, type CreateJobInput, type JobScope, type ToolHost, automationTools, checkJobName, createLoopJob, resolveJobRefScoped } from "./tools.ts";
 import { panelEnabled, readUiPrefs, writeUiPref } from "./ui-prefs.ts";
 import * as fs from "node:fs";
@@ -723,41 +724,12 @@ export default function piLoops(pi: ExtensionAPI) {
 	};
 
 	function jobLines(jobs: LoopJob[]): string[] {
-		const now = Date.now();
 		// Read once for the whole listing: the run log and the inbox are each one file, and a
-		// project with a dozen loops would otherwise parse them a dozen times per `/cron`.
-		const allRuns = jobs.some((j) => j.stateful) ? scheduler.store.allRuns() : [];
-		const allInbox = jobs.some((j) => j.stateful) ? scheduler.inbox.list() : [];
-		return jobs.map((job, i) => {
-			// A next run is shown where it will happen: a plain job of a session not open here has none.
-			const next = job.enabled && runsIn(job, session.sessionId)
-				? computeNext(
-						{
-							schedule: job.schedule,
-							createdAt: Date.parse(job.createdAt),
-							lastFiredAt: job.lastFiredAt ? Date.parse(job.lastFiredAt) : undefined,
-						},
-						now,
-					)
-				: undefined;
-			const asleepMark = asleepNote(job, session.sessionId);
-			const dormant = asleepMark ? `[${asleepMark}]` : undefined;
-			const orphan = job.stateful && !fs.existsSync(job.cwd) ? "[orphan: cwd missing]" : undefined;
-			// What the loop's runs came to (src/job-signal.ts): `quiet ×N` in the marks once N empty
-			// runs are the newest, and the findings line — filed, claimed, dismissed — over 30 days.
-			// A loop was, until now, judged by whether it ran; this is whether it was worth running.
-			const signal = job.stateful ? loopSignal(job.id, allRuns, allInbox, now - SIGNAL_WINDOW_MS) : undefined;
-			const quiet = signal && signal.quiet >= QUIET_MARK_AFTER ? `[quiet ×${signal.quiet}]` : undefined;
-			const marks = [job.stateful ? "[stateful]" : undefined, job.verify ? "[verify]" : undefined, dormant, orphan, quiet, job.running ? `running ${job.running.runId}` : undefined, job.catchUp ? undefined : "[no-catchup]"]
-				.filter(Boolean)
-				.join("  ");
-			const head = `${String(i + 1).padStart(2)}. ${job.id}${job.name ? ` "${job.name}"` : ""}  ${job.enabled ? "enabled" : "disabled"}  ${formatSchedule(job.schedule)}${marks ? `  ${marks}` : ""}`;
-			const action = `    action: ${previewRedacted(job.prompt, 120)}`;
-			const worth = signal ? signalSummary(signal) : undefined;
-			const meta = `    next ${next ? formatLocal(next) : "—"} · runs ${job.runCount}${job.skippedOverlap ? ` · overlap skips ${job.skippedOverlap}` : ""}${worth ? ` · 30d: ${worth}` : ""} · ${homeRel(job.cwd)}`;
-			const err = job.lastError ? `    last error: ${previewRedacted(job.lastError, 100)}` : job.lastFiredAt ? `    last fired: ${job.lastFiredAt}` : undefined;
-			return [head, action, meta, err].filter((l): l is string => !!l);
-		}).flat();
+		// project with a dozen loops would otherwise parse them a dozen times per `/cron`. The shape
+		// of the lines is src/job-lines.ts, where a test can see a marker go.
+		const runs = jobs.some((j) => j.stateful) ? scheduler.store.allRuns() : [];
+		const inbox = jobs.some((j) => j.stateful) ? scheduler.inbox.list() : [];
+		return cronJobLines(jobs, { runs, inbox, sessionId: session.sessionId, now: Date.now(), home: process.env.HOME ?? "", cwdExists: (cwd) => fs.existsSync(cwd) });
 	}
 
 	/* --------------------------------------------------------- creation */
@@ -1802,10 +1774,13 @@ export default function piLoops(pi: ExtensionAPI) {
 						return;
 					}
 					case "audit": {
-						const all = /\s--all\b|^--all\b/.test(rest);
-						const limit = Number.parseInt(rest.replace("--all", ""), 10) || 10;
+						const args = auditArgs(rest);
+						if ("usage" in args) {
+							ctx.ui.notify(args.usage, "warning");
+							return;
+						}
 						// This project's rows by default (rows without a cwd predate 0.1.3 and are shown too).
-						const rows = store.listAudit(limit, all ? undefined : (r) => !r.cwd || sameProject(r.cwd, session.cwd));
+						const rows = store.listAudit(args.limit, args.all ? undefined : (r) => !r.cwd || sameProject(r.cwd, session.cwd));
 						show(
 							ctx,
 							rows.length ? `Recent trigger audit (${rows.length}):` : "(no trigger audit entries)",

package/src/session-head.ts

@@ -27,11 +27,15 @@ const HEAD_BYTES = 64 * 1024;
 
 export function readSessionHead(file: string, bytes: number = HEAD_BYTES): SessionHead | undefined {
 	let text: string;
+	let readBytes = 0;
 	try {
 		const fd = fs.openSync(file, "r");
 		try {
 			const buf = Buffer.alloc(bytes);
-			text = buf.toString("utf8", 0, fs.readSync(fd, buf, 0, bytes, 0));
+			// `bytes` is a byte window, so the decision to cut is the byte count read, not the
+			// decoded string's length: a multi-byte character makes those differ.
+			readBytes = fs.readSync(fd, buf, 0, bytes, 0);
+			text = buf.toString("utf8", 0, readBytes);
 		} finally {
 			fs.closeSync(fd);
 		}
@@ -46,7 +50,7 @@ export function readSessionHead(file: string, bytes: number = HEAD_BYTES): Sessi
 		return undefined;
 	}
 	if (header?.type !== "session" || typeof header.id !== "string") return undefined;
-	const truncated = text.length >= bytes;
+	const truncated = readBytes >= bytes;
 	let name: string | undefined;
 	let first: string | undefined;
 	let messages = 0;

package/src/triggers.ts

@@ -406,6 +406,30 @@ export class TriggerStore {
 	}
 }
 
+export const AUDIT_USAGE = "usage: /triggers audit [N] [--all]   (N is the number of rows, default 10)";
+
+/**
+ * `/triggers audit [N] [--all]`, parsed where it can be tested: `src/pi-loops.ts` is the extension's
+ * default export, so nothing can import the handler. A limit the command cannot read is refused
+ * rather than silently replaced with the default, and a negative one is refused rather than handed
+ * to `listAudit`, where `slice(-limit)` stops meaning "limit" and prints the file from the top.
+ * `--all` lifts the project filter and may sit before or after the number.
+ */
+export function auditArgs(rest: string): { limit: number; all: boolean } | { usage: string } {
+	let limit = 10;
+	let all = false;
+	let numbered = false;
+	for (const part of rest.split(/\s+/).filter(Boolean)) {
+		if (part === "--all") all = true;
+		else if (!numbered && /^\d+$/.test(part)) {
+			limit = Number(part);
+			numbered = true;
+		} else return { usage: AUDIT_USAGE };
+	}
+	if (limit < 1) return { usage: AUDIT_USAGE };
+	return { limit, all };
+}
+
 /**
  * The control-plane prompt gate, pre-flight part. Prompt-class tool calls (create or remove
  * a trigger, re-enable a trigger or a cron job) need a human. Sub-agents have no prompt channel

package/src/web.mjs

@@ -210,6 +210,8 @@ const STDERR_KEEP = 8000;
 /** What actually leaves this process: the tail, which is the part that says why pi stopped. */
 const STDERR_SEND = 4000;
 let stderrTail = "";
+/** Characters the keep cut has already thrown away, so the send cut can count everything dropped. */
+let stderrDropped = 0;
 /**
  * The shapes a credential takes in a line of output.
  *
@@ -258,14 +260,25 @@ function maskSecrets(text) {
 }
 
 function recentStderr() {
-	// Redact the whole kept tail, then cut. The other order cut first, so a key that straddled the
-	// 4000-character boundary lost the `sk-` its pattern starts at — nothing matched, and the second
-	// half of it went out to every attached browser.
-	return maskSecrets(stderrTail.trim()).slice(-STDERR_SEND);
+	// Redact the whole kept tail, then cut by characters. `slice` counted UTF-16 code units, so the
+	// served tail could begin on the low half of an astral character — a replacement glyph where the
+	// error should start — and the page's own cap at 4000 could never fire: it was always handed 4000
+	// code units or fewer, and code points are never more numerous than code units, so nothing ever
+	// told the person anything was dropped. The count has to be put here rather than in the page,
+	// because `capped` keeps the first n characters and a tail keeps the last.
+	const kept = Array.from(maskSecrets(stderrTail.trim()));
+	if (!stderrDropped && kept.length <= STDERR_SEND) return kept.join("");
+	const room = STDERR_SEND - 40; // the marker line below is shorter than this
+	const shown = kept.slice(-room);
+	return `… (${stderrDropped + kept.length - shown.length} chars dropped)\n${shown.join("")}`;
 }
 pi.stderr.on("data", (d) => {
 	process.stderr.write(d);
-	stderrTail = (stderrTail + d.toString("utf8")).slice(-STDERR_KEEP);
+	// Characters, not code units: a cut on the code-unit half of an astral character leaves a lone
+	// surrogate in the tail, which `textContent` draws as a replacement glyph.
+	const all = Array.from(stderrTail + d.toString("utf8"));
+	stderrDropped += Math.max(0, all.length - STDERR_KEEP);
+	stderrTail = all.slice(-STDERR_KEEP).join("");
 });
 
 let nextId = 1;
@@ -502,10 +515,13 @@ function automation(cwd) {
 		runCount: j.runCount ?? 0,
 		lastError: maskSecrets(j.lastError),
 		running: !!j.running,
-		// The open body of a card shows these two, which the terminal's `/cron` line has and the
-		// panel did not; they leave the store as they were written, no reshaping.
+		// The open body of a card shows these, which the terminal's `/cron` line has and the panel
+		// did not; they leave the store as they were written, no reshaping.
 		cwd: j.cwd,
 		lastFiredAt: j.lastFiredAt,
+		// Due ticks a run was too slow to take. The `lastError` a skip writes is cleared by the next
+		// run; this count is not, so it is the last evidence a loop is losing cadence.
+		skippedOverlap: j.skippedOverlap ?? 0,
 		// Set only when it is not this machine's: the panel says so, and nothing else has to guess.
 		// What to type to fix it. The terminal's version of this line says `/cron set <n>`, where n
 		// is the position in a numbered list — which this panel does not have, so telling someone to
@@ -822,11 +838,15 @@ function listSessionsHere(limit = 40) {
 /** The header, a name if one was set early, and the first thing a person said. */
 function readHead(file) {
 	let text;
+	let readBytes = 0;
 	try {
 		const fd = fs.openSync(file, "r");
 		try {
 			const buf = Buffer.alloc(SESSION_HEAD);
-			text = buf.toString("utf8", 0, fs.readSync(fd, buf, 0, SESSION_HEAD, 0));
+			// `SESSION_HEAD` is a byte window, so the decision to cut is the byte count read, not the
+			// decoded string's length: a multi-byte character makes those differ.
+			readBytes = fs.readSync(fd, buf, 0, SESSION_HEAD, 0);
+			text = buf.toString("utf8", 0, readBytes);
 		} finally {
 			fs.closeSync(fd);
 		}
@@ -841,7 +861,7 @@ function readHead(file) {
 		return undefined;
 	}
 	if (header?.type !== "session" || typeof header.id !== "string") return undefined;
-	const cut = text.length >= SESSION_HEAD;
+	const cut = readBytes >= SESSION_HEAD;
 	let name;
 	let first;
 	let messages = 0;
@@ -2024,15 +2044,29 @@ function previewRoot(file) {
 	return undefined;
 }
 
-/** The path the filesystem actually means: symlinks followed as far as anything exists. */
+/**
+ * The path the filesystem actually means: every symlink above it resolved, whether or not the path
+ * itself exists. The deepest ancestor that does exist is resolved and the rest re-attached.
+ *
+ * One level up was not enough. A job whose cwd is a removed worktree or a checkout that moved is two
+ * or more levels below the deepest thing that exists, and a parent-only fallback returned the
+ * unresolved path — so `sameProject` said "another project" about a directory plainly inside this
+ * one, and the panel dropped a job `/cron` still lists with `[orphan: cwd missing]`. This is the
+ * walk `src/paths.ts` does as `realpathish`, copied because the front end is one file with no
+ * imports on purpose.
+ */
 function realOf(file) {
-	try {
-		return fs.realpathSync(file);
-	} catch {
+	if (!file) return "";
+	let at = path.resolve(file);
+	const tail = [];
+	for (;;) {
 		try {
-			return path.join(fs.realpathSync(path.dirname(file)), path.basename(file));
+			return path.join(fs.realpathSync(at), ...tail);
 		} catch {
-			return path.resolve(file);
+			const parent = path.dirname(at);
+			if (parent === at) return path.resolve(file); // reached the root and nothing resolved
+			tail.unshift(path.basename(at));
+			at = parent;
 		}
 	}
 }
@@ -3510,7 +3544,7 @@ function renderSidebar(s) {
         '<div class="body">' +
         '<pre class="full">' + prompt + "</pre>" +
         '<button class="copy" data-copy="' + safeText(j.id) + '">copy</button>' +
-        '<div class="m">id ' + safeText(j.id) + " · cwd " + safeText(j.cwd) + (j.lastFiredAt ? " · last fired " + safeText(j.lastFiredAt) : "") + "</div>" +
+        '<div class="m">id ' + safeText(j.id) + " · cwd " + safeText(j.cwd) + (j.lastFiredAt ? " · last fired " + safeText(j.lastFiredAt) : "") + (j.skippedOverlap ? " · skipped overlaps " + num(j.skippedOverlap) : "") + "</div>" +
         // A job belonging to a hostname this machine no longer has: it is listed, because it exists,
         // and it says why nothing is happening rather than leaving you to find out from the silence.
         (j.lastError ? '<div class="m" style="color:#c66">' + safeText(j.lastError) + "</div>" : "") +
@@ -3750,7 +3784,7 @@ function renderRuntime(rt) {
     // An MCP server's name, its state and its last error are all that server's own words.
     html += "<div>" + dot(m.state) + safeText(m.name) + " <span class=\"m\">" + safeText(m.state) + " · " + countOf((m.tools || []).length, "tools", m.tools) +
       (m.injects ? " · injects" : "") + (m.queued ? " · " + num(m.queued) + " queued" : "") + "</span></div>" +
-      (m.lastError ? '<div class="m" style="color:#c66">  ' + safeText(str(m.lastError).slice(0, 120)) + "</div>" : "");
+      (m.lastError ? '<div class="m" style="color:#c66">  ' + safeText(str(m.lastError)) + "</div>" : "");
   }
   if (rt.mcpConfigError) html += '<div class="m" style="color:#c66">mcp.toml: ' + safeText(rt.mcpConfigError) + "</div>";
   const h = rt.hooks || {};