@alphacoder-v0/pi-loops 0.22.3 → 0.22.5

package/CHANGELOG.md

@@ -5,6 +5,97 @@ 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
+- **Removing a running job aborts the run, and the run leaves nothing behind.** `/cron remove`,
+  `cron_remove` and `/recipe remove` deleted the job and left its sub-agent going; the run then
+  wrote its state, filed a finding for a job that no longer existed and recreated `sessions/<id>/`.
+  Removal now aborts an in-flight run and gives it up to two seconds to write its record — enough for
+  a normal abort, not a wait that outlasts a wedged sub-agent — and a run that finds its job gone
+  writes the record only, discarding the state and the findings.
+- **`/cron gc --purge` also collects the transcripts of jobs that are gone.** A removed job that
+  never wrote state but left `sessions/<id>/` behind was invisible to `orphanStates()`, so its
+  transcripts stayed for ever. The orphan scan now unions the state files with the transcript
+  directories and counts both in the size it reports.
+- **`/recipe remove --purge` keeps a playbook you edited.** `purgeInstall` deleted every file in the
+  record without comparing it with its untouched copy under `.orig/`, so an edit that `/recipe
+  update` would have preserved was destroyed without a word. It now removes a file only while it
+  still matches its untouched copy, keeps and names the edited ones, and leaves the directory in
+  place when one remains.
+- **A run whose `jobs.json` is torn mid-flight no longer disappears.** A run re-read the store to ask
+  whether its job was still there, and an empty or too-new file made that read throw: the record, the
+  findings and the run-finished callback were all skipped, so a run that had completed left no trace.
+  A store that cannot be read now counts as "the job is still there" — the record and the findings are
+  written, and only the job's own bookkeeping is skipped.
+- **`/recipe remove --purge` keeps a setup script you edited.** The install copied the setup script
+  but kept no untouched copy of it, and purge deleted it unconditionally, so an edited script was
+  destroyed without a word. The install now writes the `.orig` copy and purge compares it like any
+  other file, keeping and naming the edited one.
+- **The collection of a removed job's leftovers says what it does, and counts all of it.**
+  `removeWhere` deleted state and transcripts with no flag, so the next caller would have thrown away
+  a loop's notes unasked; it now keeps them unless the caller passes `purge`, which is what gc does.
+  The orphan scan also walks the whole transcript tree, so a nested file that `purgeState` deletes is
+  counted in the size `/cron gc` reports.
+- **The command line finds a project's sessions and recipe jobs from a subdirectory.** Three listings
+  compared the recorded directory with `===`, so run from a subdirectory of the project they answered
+  "nothing here" or "0 job(s)". They now use the same realpath-and-containment match the rest of
+  pi-loops uses.
+- **The docs say the command line does not delete.** There is no `cron remove`, `recipe remove` or
+  `inbox clear` on it: removal asks a person to confirm and records what it did in the session's
+  control-plane audit, so it stays in the slash commands.
+- **`/cron remove <name>` no longer reaches into another project.** A name resolved machine-wide, so
+  a name this project does not have deleted another checkout's job and said so in the same words as
+  any other removal. It now follows the rule `cron_remove` already had — a name resolves here, and
+  another project's job needs its exact id — and a removal that did reach outside names the project
+  it reached into.
+- **A one-shot that retires itself leaves a control-plane audit entry.** A one-shot was removed after
+  it fired or failed for the second time with nothing in the trail; the self-removal now goes through
+  the same audit as a removal a person asked for.
+
 ## [0.22.3] - 2026-09-16
 
 ### Changed

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.3    # 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.3    # 或者从 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

@@ -227,13 +227,20 @@ pi-loops recipe list | show <name|path> | add <name|path> [--cwd <dir>] [--level
 pi-loops inbox list [--all] [--cwd <dir>] | claim <id> | dismiss <id> [--reason <text>]   [--json]
 ```
 
+The command line reads, triages one finding at a time and moves sessions. It never creates or
+removes: there is no `cron remove`, no `recipe remove` and no `inbox clear`. Creating and removing
+jobs, rules and recipes are slash commands, because each asks a person first and records what it did
+in the session's control-plane audit.
+
 ## sessions, inspect
 
 `sessions` lists this project's sessions newest first, one line each: the first sixteen
 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/configuration.md

@@ -16,6 +16,7 @@ Everything lives under `~/.pi/agent/loops/` (override: `PI_LOOPS_DIR`).
 | `spend.json` | per-day totals of what rotation dropped from the run log, so a daily budget still counts it |
 | `sessions/<job-id>/`, `sessions/triggers-<project>-<hash>/` | sub-agent transcripts (20 per job, 40 per project's checks; the hash of the project's path keeps two projects named alike apart) |
 | `scheduler.json` | timer owner on this machine: pid, heartbeat |
+| `next-runs.json` | job id → when it runs next, as the timer owner computed it (`{ at, next }`). Written only when an answer changes, so it can be older than the last tick; the browser panel reads it rather than parsing schedules a second time |
 | `presence/` | one file per live pi process: pid, session, cwd (who acts for which project) |
 | `host.json`, `host.log` | the headless host that keeps the clock while no pi is open: pid, and its log |
 | `polls.json` | last dynamic check per project (shared, so a hand-over never double-checks) |

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/loops.md

@@ -240,7 +240,8 @@ cron job's clock restarts at the edit, so slots that only exist retroactively un
 expression are not owed. An `every <dur>` job is still measured from its last run — if it last ran
 longer ago than the new interval, it is genuinely overdue and the confirmation says `due now`
 instead of promising a later time. One-shots (`in 10m`, `at <ISO>`) are refused here: the scheduler
-deletes a `once` job after it fires, notes included.
+deletes a `once` job after it fires, notes included, and records the removal in the control-plane
+audit like any other.
 
 `/cron run <ref>` fires a job now instead of at its next due time, and that run counts as a run: a
 `once` job is fired and then removed (an enabled job with nothing left to fire is worse than none),
@@ -300,9 +301,14 @@ anything, so this is how you actually go quiet.
 If a loop is stuck showing `running` after a process was killed and its pid reused, `/cron clear
 <ref>` releases the marker (it asks first).
 
+`/cron remove` takes a name of this project, a number from its listing, or the exact id of a job
+anywhere — the rule `cron_remove` follows, because a removal cannot be undone and a name this
+project does not have should not reach another checkout. A job removed by its exact id from outside
+this project is named with the project it was in.
+
 `/cron remove` keeps the loop's notes (to change a prompt or a schedule, edit the job in place with
 `/cron set` instead); `--purge` deletes them. `/cron gc` collects this project's jobs whose session
-is gone — `--all` every project's, `--purge` also the loop state left behind by jobs that are gone.
+is gone — `--all` every project's, `--purge` also the loop state and transcripts left behind by jobs that are gone.
 
 A job that fails three times in a row is retried on a widening gap (5 minutes, doubling, up to six
 hours) instead of at every due tick, and says so; one success clears the streak.

package/docs/recipes.md

@@ -141,7 +141,8 @@ A playbook installed by hand, with no untouched copy, is left alone and named.
 
 `/recipe remove <name>` removes the recipe's jobs and keeps the files and the loops' notes;
 `--purge` deletes both — of the files, only what the install wrote, since `.agents/skills/` may
-hold the project's own. `/cron` shows recipe jobs like any other, and `/cron set` edits them like
+hold the project's own, and only a file that still matches its untouched copy: a playbook you
+edited is kept and named. `/cron` shows recipe jobs like any other, and `/cron set` edits them like
 any other — a recipe is how they were made, not what they are.
 
 ## Writing a recipe

package/docs/web-ui-parity.md

@@ -25,13 +25,15 @@ weaker, and worth converting whenever one of them breaks.
 - [x] Busy, queued count, and "pi exited" are all visible without opening a terminal.
       `test/web-page.test.ts`: *a tool call and a dead pi both reach the page*.
 - [x] Prompt history: ArrowUp and ArrowDown, but only while the caret is on the first or last line,
-      so they still navigate a multi-line draft.
+      so they still navigate a multi-line draft. `test/web-page.test.ts`: *prompt history recalls what
+      was sent, and steps aside on a middle line*.
 
 ## Composing
 
 - [x] `/` completes slash commands; `@` completes paths, and the mention is expanded before the
       prompt is sent — the expansion is anchored to the session's directory, not to anything the
-      browser supplies.
+      browser supplies. `test/web.test.ts`: *an @ mention is expanded from the session's directory,
+      and one outside it is skipped*.
 - [x] A command with an argument can be typed straight through. The completion list closes on the
       space, and an answer still in flight does not put it back — which it did, so Enter accepted
       the completion instead of sending the line and anything taking an argument was mouse-only.
@@ -85,6 +87,8 @@ weaker, and worth converting whenever one of them breaks.
       `test/web-page.test.ts`: *a gap in the event stream reloads the conversation*.
 - [x] While you are reading back through the conversation, an update never yanks the page — and
       never arrives silently either: there is a way back to the newest.
+      `test/web-page.test.ts`: *an update while you are reading back does not yank the page, and the
+      pill is the way back*.
 - [x] Every block says when it happened.
 - [x] Every message, tool call and result can be copied, including over plain http where the
       clipboard API is unavailable. The button waits for a hover on a mouse and is simply always
@@ -92,7 +96,10 @@ weaker, and worth converting whenever one of them breaks.
 - [x] Tool results, an extension's messages and pi's dying words are capped, and every cap says how
       much was dropped — one helper for the three of them, because they used to report it three
       different ways and one of them not at all, so a result that stopped at 8000 characters looked
-      like a result that ended there.
+      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*; `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
@@ -130,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
@@ -188,11 +195,14 @@ 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*.
-- [x] Enter does not approve: the focus starts on cancel.
+- [x] Enter does not approve: the focus starts on cancel, which is written before approve so the
+      first menu button is the one Enter hits. `test/web-page.test.ts`: *Enter in a confirmation
+      dialog hits cancel, not approve*.
 - [x] **A tab in the background does not hold one of the browser's six connections.** Every tab
       used to keep an event stream open for as long as it existed, so the sixth tab — or a few
       forgotten behind the first — left nothing for the request that sends what you typed, and the
@@ -335,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.3",
+  "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

@@ -184,7 +184,7 @@ export function pickSession(sessions: SessionFile[], opts: { id?: string; cwd: s
 		if (byPrefix.length > 1) throw new Error(`session id ${opts.id} is ambiguous (${byPrefix.length} matches)`);
 		throw new Error(`no session with id ${opts.id}`);
 	}
-	const here = sessions.filter((s) => s.cwd === opts.cwd);
+	const here = sessions.filter((s) => sameProject(s.cwd, opts.cwd));
 	if (!here.length) throw new Error(`no sessions recorded for ${opts.cwd}; pass --session <id>`);
 	return here[0];
 }
@@ -266,9 +266,15 @@ 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) => s.cwd === cwd);
+		const here = flags.has("all") ? sessions : sessions.filter((s) => sameProject(s.cwd, cwd));
 		if (!here.length) {
 			out(flags.has("all") ? "no sessions recorded" : `no sessions recorded for ${cwd} (use --all)`);
 			return 1;
@@ -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());
 		}
@@ -493,7 +499,7 @@ async function recipeCommand(positional: string[], opts: { level?: string; overw
 	if (sub === "list") {
 		const packaged = listRecipes();
 		const installed = new Map(installedRecipes(cwd).map((r) => [r.recipe, r]));
-		const jobs = new JobStore(loopsDir).load().filter((j) => j.recipe && j.cwd === cwd);
+		const jobs = new JobStore(loopsDir).load().filter((j) => j.recipe && sameProject(j.cwd, cwd));
 		for (const r of packaged) {
 			const rec = installed.get(r.manifest.name);
 			const n = jobs.filter((j) => j.recipe === r.manifest.name).length;

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();
+}