agent-lyceum 0.13.0 → 0.14.0

package/README.md

@@ -28,10 +28,10 @@ Requires Node 20+, plus `claude` and/or `codex` on your `PATH` (already logged i
 | Project | `project add <name> --dir <repo>` | Register a project. [details](docs/commands.md#project-add) |
 | Project | `project` / `project remove <name> [--purge]` | List or unregister projects. [details](docs/commands.md#project-and-project-remove) |
 | Diagnose | `doctor [-p name] [--task-file f] [--resolved] [--json]` | Check config (with enforcement levels), git, the lock and runtime CLIs without running agents; `--resolved` prints every effective setting and its source. [details](docs/commands.md#doctor) |
-| Diagnose | `status [-p name] [--monitor]` | Show agents, mail, the current wake-up and past runs (`--json`, `--monitor`). [details](docs/commands.md#status) |
-| Run | `run ["task"] [--task-file f] [--agent a] [-p name]` | Give the task to the lead and run until done; with `--agent`, to one member alone. [details](docs/commands.md#run) |
-| Run | `resume [run-id] [--answer] [-p name]` | Continue an interrupted or failed run; `--answer` first answers the questions it is waiting on. [details](docs/commands.md#resume) |
-| Run | `clear <run-id> [-p name] [--dry-run] [--keep-worktrees]` / `clear --lock [run-id] --force` | Delete a run with its task memory and worktrees; or remove the lock a crashed run left behind. [details](docs/commands.md#clear) |
+| Diagnose | `status [-p name] [--monitor]` | Show agents, mail, the current wake-up and past runs (`--json`, `--monitor`); `--task-id` takes an id, a name or a unique prefix. [details](docs/commands.md#status) |
+| Run | `run ["task"] [--task-file f] [--name n] [--agent a] [-p name]` | Give the task to the lead and run until done; `--name` names the run; with `--agent`, to one member alone. [details](docs/commands.md#run) |
+| Run | `resume [run] ["follow-up"] [--task-file f] [--answer] [-p name]` | Continue an interrupted or failed run, or reopen a finished one with a follow-up; `--answer` first answers the questions it is waiting on. [details](docs/commands.md#resume) |
+| Run | `clear <run> [-p name] [--dry-run] [--keep-worktrees]` / `clear --lock [run-id] --force` | Delete a run (id, name or unique prefix) with its task memory and worktrees; or remove the lock a crashed run left behind. [details](docs/commands.md#clear) |
 | Run | `call <agent> ["task"] [--task-file f] [--dir d]` | Call one global agent on its own, outside any project; prints its answer. [details](docs/commands.md#call) |
 | Run | `tidy [-p name] [--agent a] [--layer project\|global] [--dry-run]` | Have agents tidy their own memory (manual only; archives, never deletes). [details](docs/commands.md#tidy) |
 | Run | `tidy --undo <timestamp> -p name --agent a` | Undo a tidy: move its archived files back. [details](docs/commands.md#tidy) |
@@ -138,6 +138,17 @@ Known limits:
 - `COMMON.md` and the `AGENT.md` files are shared by all runs of the project. Each run's guard only judges what changes while its own agents are working, so an edit by one run is kept; but if two runs' wake-ups overlap in time, a change one makes while the other's agents are working can be reverted by the other.
 - Two runs that edit the same file are for you to reconcile when merging; agent-lyceum never merges.
 
+### Continuing a finished run
+
+Every run has a **name**: made from the first line of the task (lowercase letters, digits and `-`, at most 30 characters; `task` if nothing usable is left; `-2`, `-3` on repeats), or chosen with `run --name <name>` (same characters and length; refused if the name is already used). `resume`, `clear` and `status --task-id` accept the full run id, the name, or a unique prefix of either; an ambiguous prefix lists the candidates and exits `1`, and an empty one is refused. `status` shows the name next to the id.
+
+A finished (`done`) run can be reopened with a follow-up request: `agent-lyceum resume [run] "<follow-up>"` (or `--task-file f`). The lead gets the text as a new `task`, and the run goes on with the same run dir, task memory, sessions and lead worktree.
+
+- **Which runs:** only a finished run can be reopened. A run that is still running is refused; a run that is not finished is refused when given text (resume it without text first). Without text nothing changes: a finished run just prints its result. Without a run, the candidates are the finished runs, newest first: exactly one is used, none is an error, and several are listed (in a terminal you pick one by number or name; without a terminal the command fails and lists them). A lone argument counts as follow-up text only when it cannot be a run reference (it contains whitespace or a character a run name cannot contain); a one-word follow-up needs `resume <run> "<text>"` or `--task-file`.
+- **What is kept:** the follow-up is saved as `runs/<run-id>/followups/<n>.md`. Each `done` report is kept as `done-<n>.md`, and `result.md` is always the latest. `state.json` gains `name`, `reopened` and `round_floor` (all optional, so older runs still load). Unresolved blocked integrations stay; the done-contract reminders start afresh for each reopened segment.
+- **Round limit:** `max_rounds` counts from the reopen: `rounds` keeps accumulating, and the limit is the rounds at reopen plus `max_rounds`.
+- **The lead's branch** (runs with a lead worktree): if the branch was already merged into your `HEAD` and the lead worktree is clean and untouched since the run ended, the worktree and the branch (same name, `agent-lyceum/<run-id>/<lead>`) are re-cut from your current `HEAD`, and a line says so. Otherwise the same worktree and branch continue. If a pull request was already recorded (`pr_url`) and the branch was not re-cut, a new `open_pr: true` only pushes ("pull request updated") while that pull request is still open; if it was merged (a squash merge included) or closed, a new pull request is opened instead. If the branch was re-cut, the recorded `pr_url` is cleared (the old URL stays in the run's notes) and a new pull request is opened when asked. agent-lyceum still never merges.
+
 ### Opening a pull request
 
 When your task asks for a pull request, the lead puts `open_pr: true` in the frontmatter of its `done` report. If the run then ends `completed` and the lead's branch has changes, agent-lyceum — not an agent — pushes `agent-lyceum/<run-id>/<lead>` to `origin` and runs `gh pr create` against the repo's default branch, using the lead's report as the description (ending with `🤖 Opened by agent-lyceum`). The run result prints the PR URL, and `state.json` records it as `pr_url`. Only the lead can ask: nobody else can send `done`, and no agent's sandbox is loosened — `git push` and `gh` run outside it, with your own credentials.
@@ -200,4 +211,6 @@ Enforcement is layered because no single mechanism is complete:
 
 `doctor` and `run` print every agent's level per category (`os`, `tool-rules`, `post-hoc`, `prompt-only`) and the paths it can write outside the repo. With `dispatcher.strict: true`, a run is refused unless memory, `AGENT.md` and other agents' context are OS-enforced.
 
+Git in agent worktrees: an agent can write its worktree's `.git` pointer file and its private git dir, which could make git read a config or hooks the agent planted. So every git call the dispatcher makes into an agent's worktree pins the git dir, common dir and work tree recorded when the worktree was made, turns off hooks, fsmonitor, external diff and textconv, and refuses a worktree whose git files were redirected or linked elsewhere, whose HEAD is not its own branch, or that contains a nested repository. Claude additionally may not write those pointer files (`denyWrite`); Codex cannot forbid single files and relies on the pinning alone. Residual risks are listed in [spec 15](docs/specs/15-worktree-git-isolation.md#156-殘留風險). This does not claim the dispatcher can never run code an agent planted. A repository using the `reftable` ref backend is refused in worktree modes.
+
 Known gaps: Claude Code's built-in Edit/Write tools are not sandboxed (covered by the `Edit` rules); Codex MCP tools and hooks run outside its sandbox; `--dangerously-bypass-approvals-and-sandbox` / `danger-full-access` disable everything. With `can_edit_agent_md`, a Codex lead's writable roots widen to whole agent directories.

package/README.zh-TW.md

@@ -28,10 +28,10 @@ npx agent-lyceum status
 | 專案 | `project add <name> --dir <repo>` | 註冊專案。 [詳細](docs/commands.zh-TW.md#project-add) |
 | 專案 | `project` / `project remove <name> [--purge]` | 列出或取消註冊專案。 [詳細](docs/commands.zh-TW.md#project-and-project-remove) |
 | 診斷 | `doctor [-p name] [--task-file f] [--resolved] [--json]` | 不執行 agent，檢查設定（含防護等級）、git、鎖與 runtime CLI；`--resolved` 印出每項生效設定與其來源。 [詳細](docs/commands.zh-TW.md#doctor) |
-| 診斷 | `status [-p name] [--monitor]` | 顯示 agent、信件、目前執行與歷次 run（支援 `--json`、`--monitor`）。 [詳細](docs/commands.zh-TW.md#status) |
-| 執行 | `run ["task"] [--task-file f] [--agent a] [-p name]` | 把任務交給 lead 並執行到結束；加 `--agent` 則只交給某個成員單獨做。 [詳細](docs/commands.zh-TW.md#run) |
-| 執行 | `resume [run-id] [--answer] [-p name]` | 接續被中斷或失敗的 run；`--answer` 會先回答它等待中的問題。 [詳細](docs/commands.zh-TW.md#resume) |
-| 執行 | `clear <run-id> [-p name] [--dry-run] [--keep-worktrees]` / `clear --lock [run-id] --force` | 刪除 run 與其任務記憶、worktree；或移除當機 run 留下的專案鎖。 [詳細](docs/commands.zh-TW.md#clear) |
+| 診斷 | `status [-p name] [--monitor]` | 顯示 agent、信件、目前執行與歷次 run（支援 `--json`、`--monitor`）；`--task-id` 接受 id、名稱或唯一前綴。 [詳細](docs/commands.zh-TW.md#status) |
+| 執行 | `run ["task"] [--task-file f] [--name n] [--agent a] [-p name]` | 把任務交給 lead 並執行到結束；`--name` 為 run 命名；加 `--agent` 則只交給某個成員單獨做。 [詳細](docs/commands.zh-TW.md#run) |
+| 執行 | `resume [run] ["追加要求"] [--task-file f] [--answer] [-p name]` | 接續被中斷或失敗的 run，或用追加要求重開已完成的 run；`--answer` 會先回答它等待中的問題。 [詳細](docs/commands.zh-TW.md#resume) |
+| 執行 | `clear <run> [-p name] [--dry-run] [--keep-worktrees]` / `clear --lock [run-id] --force` | 刪除 run（id、名稱或唯一前綴）與其任務記憶、worktree；或移除當機 run 留下的專案鎖。 [詳細](docs/commands.zh-TW.md#clear) |
 | 執行 | `call <agent> ["task"] [--task-file f] [--dir d]` | 單獨呼叫一個 global agent（不需專案），印出它的回答。 [詳細](docs/commands.zh-TW.md#call) |
 | 執行 | `tidy [-p name] [--agent a] [--layer project\|global] [--dry-run]` | 讓 agent 整理自己的記憶（只能手動觸發；封存而非刪除）。 [詳細](docs/commands.zh-TW.md#tidy) |
 | 執行 | `tidy --undo <時間戳> -p name --agent a` | 還原一次整理：把封存的檔案搬回。 [詳細](docs/commands.zh-TW.md#tidy) |
@@ -139,6 +139,17 @@ Agent 欄位：`runtime`（`claude-code`|`codex`；若 `model` 可辨識則可
 - `COMMON.md` 與各 `AGENT.md` 由專案的所有 run 共用。每個 run 的防護只判斷它自己的 agent 工作期間發生的修改，所以某個 run 的修改會被保留；但若兩個 run 的喚醒時間重疊，一個 run 在另一個 run 的 agent 工作期間所做的修改，可能被另一個 run 還原。
 - 兩個 run 修改同一個檔案時，要由你在合併時自行整合；agent-lyceum 從不自動合併。
 
+### 接續已完成的 run
+
+每個 run 都有**名稱**：由 task 第一行產生（小寫字母、數字與 `-`，最多 30 字元；沒有可用字元時用 `task`；重複時加 `-2`、`-3`），或用 `run --name <name>` 指定（字元與長度限制相同；名稱已被使用會拒絕）。`resume`、`clear` 與 `status --task-id` 接受完整 run id、名稱，或兩者之一的唯一前綴；前綴有歧義時會列出候選並以 `1` 結束，空字串會被拒絕。`status` 會在 id 旁顯示名稱。
+
+已完成（`done`）的 run 可以用追加要求重開：`agent-lyceum resume [run] "<追加要求>"`（或 `--task-file f`）。lead 會把這段文字當成新的 `task` 收到，run 沿用同一個 run 目錄、任務記憶、session 與 lead 的 worktree 繼續。
+
+- **哪些 run：** 只有已完成的 run 能重開。仍在執行的 run 會拒絕；尚未完成的 run 若帶文字也會拒絕（先不帶文字 resume 它）。不帶文字時行為不變：已完成的 run 只印出結果。沒指定 run 時，候選是已完成的 run，由新到舊：剛好一個就用它，沒有就報錯，有多個就列出（在終端機可用編號或名稱選；非互動環境則報錯並列出候選）。只有一個參數時，只有在它不可能是 run 參照（含空白，或含 run 名稱不能用的字元）才會被當成追加要求；單一個詞的追加要求要寫成 `resume <run> "<text>"` 或用 `--task-file`。
+- **保留什麼：** 追加要求存成 `runs/<run-id>/followups/<n>.md`。每份 `done` 報告保留為 `done-<n>.md`，`result.md` 永遠是最新一份。`state.json` 新增 `name`、`reopened`、`round_floor`（都是選填，舊的 run 照樣能讀）。未解決的 blocked integration 會保留；每段重開的 done 規範提醒重新計算。
+- **輪數上限：** `max_rounds` 從重開時起算：`rounds` 持續累加，上限是重開當下的輪數加 `max_rounds`。
+- **lead 的 branch**（lead 有 worktree 的 run）：若該 branch 已合併進你的 `HEAD`，且 lead 的 worktree 乾淨、自 run 結束後沒被動過，worktree 與 branch（同名，`agent-lyceum/<run-id>/<lead>`）會從你目前的 `HEAD` 重新切出，並印一行說明。否則沿用原本的 worktree 與 branch。若已記錄 PR（`pr_url`）且 branch 沒有重切，新的 `open_pr: true` 只會 push（「pull request updated」），而且只在該 PR 仍開啟時；若它已被合併（含 squash merge）或關閉，就改開一個新的 PR；若 branch 重切了，已記錄的 `pr_url` 會被清掉（舊網址留在 run 的 notes），要求時再開一個新的 PR。agent-lyceum 仍然從不合併。
+
 ### 開 PR
 
 當你的 task 要求開 PR 時，lead 會在它的 `done` 報告的 frontmatter 加上 `open_pr: true`。如果 run 之後以 `completed` 結束，且 lead 的 branch 有變更，就由 agent-lyceum（不是 agent）把 `agent-lyceum/<run-id>/<lead>` 推到 `origin`，並對 repo 的預設分支執行 `gh pr create`，以 lead 的報告作為描述（結尾為 `🤖 Opened by agent-lyceum`）。run 的結果會印出 PR 網址，`state.json` 也會把它記為 `pr_url`。只有 lead 能提出要求：其他人都不能送出 `done`，也沒有任何 agent 的沙箱被放寬——`git push` 與 `gh` 在沙箱外以你自己的憑證執行。
@@ -201,4 +212,6 @@ agents:
 
 `doctor` 與 `run` 會依類別（`os`、`tool-rules`、`post-hoc`、`prompt-only`）印出每個 agent 的防護等級，以及它能寫入 repo 之外的哪些路徑。設定 `dispatcher.strict: true` 時，除非記憶、`AGENT.md` 與其他 agent 的 context 都由 OS 強制保護，否則拒絕執行。
 
+agent worktree 內的 git:agent 能寫它 worktree 的 `.git` 指標檔與私有 git 目錄,可能讓 git 去讀 agent 埋的設定或 hook。因此 dispatcher 對 agent worktree 的每一次 git 呼叫,都釘住 worktree 建立當下記錄的 git dir、common dir 與 work tree,關閉 hook、fsmonitor、external diff 與 textconv,並拒絕使用 git 檔案被改向或連到別處、HEAD 不是它自己的分支、或內含巢狀 repository 的 worktree。Claude 另外不得寫那幾個指標檔(`denyWrite`);Codex 無法禁止單一檔案,只靠釘住。殘留風險列在 [spec 15](docs/specs/15-worktree-git-isolation.md#156-殘留風險)。這**不**表示 dispatcher 絕不會執行 agent 埋下的程式碼。使用 `reftable` ref 後端的 repository 在 worktree 模式下會被拒絕。
+
 已知缺口：Claude Code 內建的 Edit/Write 工具不在沙箱內（由 `Edit` 規則涵蓋）；Codex 的 MCP 工具與 hooks 在其沙箱之外執行；`--dangerously-bypass-approvals-and-sandbox` / `danger-full-access` 會停用所有防護。啟用 `can_edit_agent_md` 時，Codex lead 的可寫根目錄會擴大到整個 agent 目錄。

package/dist/ask-reply.d.ts

@@ -55,7 +55,7 @@ export interface AnswerCheck {
     }[];
 }
 export declare const isComplete: (c: AnswerCheck) => boolean;
-/** An answer that is just a letter ("b", "B:", "b)") becomes the one option that starts with that letter and a ":", "." or ")". No match, or more than one, leaves it as typed. */
+/** An answer that is just a letter ("b", "B:", "b)") becomes the one option that starts with that letter and a ":", "." or ")"; failing that, the letter (a = first) or number (1 = first) picks an option by position. No match, or more than one, leaves it as typed. */
 export declare function resolveOptionLetters(r: AskReply): AskReply;
 /** Only questions whose answer was not sent yet count. */
 export declare function checkAnswers(r: AskReply): AnswerCheck;

package/dist/ask-reply.js

@@ -116,23 +116,23 @@ export function addBatch(existing, asker, round, qs) {
 }
 export const isComplete = (c) => c.missing.length === 0 && c.invalid.length === 0;
 function problem(q) {
-    const v = q.answer?.value.trim();
-    if (!v)
-        return undefined;
-    if (q.options?.length && !q.options.includes(v) && !/^other:\s*\S/.test(v))
-        return `must be one of: ${q.options.join(", ")} — or start with "other:" and write your own`;
+    // Any non-empty text is a valid answer: the options are shortcuts, not a limit. A bare "other:" says nothing.
+    if (/^other:\s*$/.test(q.answer?.value.trim() ?? ""))
+        return `write your own answer after "other:", or pick one of: ${(q.options ?? []).join(", ")}`;
     return undefined;
 }
-/** An answer that is just a letter ("b", "B:", "b)") becomes the one option that starts with that letter and a ":", "." or ")". No match, or more than one, leaves it as typed. */
+/** An answer that is just a letter ("b", "B:", "b)") becomes the one option that starts with that letter and a ":", "." or ")"; failing that, the letter (a = first) or number (1 = first) picks an option by position. No match, or more than one, leaves it as typed. */
 export function resolveOptionLetters(r) {
     return {
         ...r,
         questions: r.questions.map((q) => {
-            const v = q.answer?.value.trim().match(/^([A-Za-z])[:.)]?$/)?.[1]?.toLowerCase();
-            if (q.delivered || !v || !q.options?.length)
+            const raw = q.answer?.value.trim().match(/^([A-Za-z]|\d{1,2})[:.)]?$/)?.[1]?.toLowerCase();
+            if (q.delivered || !raw || !q.options?.length || !q.answer)
                 return q;
-            const hits = q.options.filter((o) => o.toLowerCase().match(/^([a-z])[:.)]/)?.[1] === v);
-            return hits.length === 1 && q.answer ? { ...q, answer: { ...q.answer, value: hits[0] } } : q;
+            const hits = q.options.filter((o) => o.toLowerCase().match(/^([a-z])[:.)]/)?.[1] === raw);
+            const byPosition = /^\d+$/.test(raw) ? Number(raw) - 1 : raw.charCodeAt(0) - 97;
+            const pick = hits.length ? (hits.length === 1 ? hits[0] : undefined) : q.options[byPosition];
+            return pick ? { ...q, answer: { ...q.answer, value: pick } } : q;
         }),
     };
 }

package/dist/cli.js

@@ -10,12 +10,12 @@ import { RESULT_FILE, runTeam } from "./dispatcher.js";
 import { executeRunCleanup, planRunCleanup } from "./run-cleanup.js";
 import { diagnoseProject, formatDoctor, preflightRuntimes } from "./doctor.js";
 import { acquireProjectLock, forceUnlock, inspectRunLock, listRunLocks, listUnreadableRunLocks, LOCK_FILE, lockHolderAlive } from "./project-lock.js";
-import { loadRunState, newRunId, outcomeOf } from "./run-store.js";
+import { loadRunState, newRunId, outcomeOf, resolveRun, roundLimit, runLabel, slugify, uniqueName } from "./run-store.js";
 import { exitCodeForOutcome } from "./schema.js";
-import { absPath, assertName, projectPaths, resolveHome } from "./paths.js";
+import { absPath, assertName, NAME_RE, projectPaths, resolveHome } from "./paths.js";
 import { addProject, initHome, removeProject } from "./scaffold.js";
-import { buildStatusReport, buildTaskListReport, formatMonitor, formatRunDetail, formatStatusWithLog, formatTaskList, latestUnfinishedRun, runIsAlive } from "./status.js";
-import { prepareTask, readTaskFile } from "./task.js";
+import { buildStatusReport, buildTaskListReport, formatMonitor, formatRunDetail, formatStatusWithLog, formatTaskList, latestUnfinishedRun, listRuns, reopenCandidates, runIsAlive } from "./status.js";
+import { prepareTask, readTaskFile, taskMessageBody } from "./task.js";
 import { callAgent, callProject, callsDir, resolveCallAgent } from "./call.js";
 import { formatEnforcement, validateProject } from "./validate.js";
 import { must } from "./assert.js";
@@ -116,6 +116,19 @@ async function preflight(pr) {
     if (r.errors.length)
         fail(`${r.errors.map((e) => `ERROR  ${e}`).join("\n")}\nFix the above (see \`agent-lyceum doctor\`).`);
 }
+/** The run a user typed: full id, name or unique prefix. Exits with the candidates when it is unknown or ambiguous. */
+function findRun(pr, query) {
+    if (!query.trim())
+        return fail("Give a run id or name (see `agent-lyceum status --task-list`).");
+    assertName("run", query);
+    const r = resolveRun(listRuns(pr, Infinity), query);
+    if (r.ok)
+        return r.run;
+    if (r.reason === "none")
+        return fail(`Run "${query}" not found in ${pr.paths.runs}. List runs with: agent-lyceum status --task-list`);
+    const list = r.candidates.map((c) => `  ${c.state.name ?? "(no name)"}  ${c.state.run_id}  ${c.state.task_summary}`).join("\n");
+    return fail(`"${query}" matches several runs:\n${list}\nGive more of the name or id.`);
+}
 /** Take the lock of one run, or exit with the reason. `ignoreLimit`: the caller does not start a run (e.g. `clear`). `exclusive`: it needs the whole project (memory tidy). */
 function takeLock(pr, runId, opts = {}) {
     try {
@@ -151,7 +164,7 @@ function cancelOnSignals() {
     };
 }
 function printRun(summary, runDir) {
-    console.log(`\nRun ${summary.runId} ended: ${summary.endReason}, outcome: ${summary.outcome}, after ${summary.rounds} round(s). Logs: ${path.join(runDir, "log.jsonl")}`);
+    console.log(`\nRun ${runLabel({ name: summary.name, run_id: summary.runId })} ended: ${summary.endReason}, outcome: ${summary.outcome}, after ${summary.rounds} round(s). Logs: ${path.join(runDir, "log.jsonl")}`);
     if (summary.outcomeNote)
         console.log(`Note: ${summary.outcomeNote}`);
     if (summary.verification)
@@ -161,7 +174,7 @@ function printRun(summary, runDir) {
     }
     if (summary.pr) {
         if (summary.pr.status === "opened")
-            console.log(`\nPull request opened: ${summary.pr.url}`);
+            console.log(`\nPull request ${summary.pr.updated ? "updated" : "opened"}: ${summary.pr.url}`);
         else if (summary.pr.status === "skipped")
             console.log(`\nA pull request was asked for but not opened: ${summary.pr.reason}`);
         else
@@ -176,16 +189,20 @@ function reportRun(summary, runDir) {
     printRun(summary, runDir);
     process.exit(exitCodeForOutcome(summary.outcome));
 }
+const firstLine = (t) => t.trim().split("\n")[0].trim();
 /** Take the lock and continue a run; the lock is released when it stops (also when it stops because it waits for answers). */
-async function continueRun(pr, dir, runId) {
+async function continueRun(pr, dir, runId, followup) {
     const lease = takeLock(pr, runId);
     const cancel = cancelOnSignals();
     try {
         console.log(`Project ${pr.name} — repo ${pr.dir}`);
         const state = loadRunState(dir);
-        console.log(`Resuming run ${state.run_id} (${state.end_reason ?? "interrupted"}) at round ${state.rounds}/${pr.dispatcher.max_rounds}: ${state.task_summary}`);
+        if (followup)
+            console.log(`Reopening run ${runLabel(state)} (follow-up ${(state.reopened?.length ?? 0) + 1}): ${firstLine(followup.text)}`);
+        else
+            console.log(`Resuming run ${runLabel(state)} (${state.end_reason ?? "interrupted"}) at round ${state.rounds}/${roundLimit(state, pr.dispatcher.max_rounds)}: ${state.task_summary}`);
         // Read the state again under the lock: another process may have changed it while we were checking.
-        return await runTeam({ project: pr, resume: state, runDir: dir, signal: cancel.signal });
+        return await runTeam({ project: pr, resume: state, runDir: dir, signal: cancel.signal, followup });
     }
     finally {
         cancel.dispose();
@@ -238,6 +255,7 @@ program
     .option("-p, --project <name>")
     .option("--task-file <path>", "read the task from a file")
     .option("--agent <name>", "run only this member of the project, alone: it cannot mail teammates or ask you, and its own `done` ends the run")
+    .option("--name <name>", "name for this run (default: made from the task)")
     .option("--assume-defaults", "when the run stops to ask, use the suggested answer for every question that has one")
     .action(async (task, opts) => {
     try {
@@ -257,6 +275,13 @@ program
             checked = onlyAgent(sp, opts.agent);
         }
         await preflight(checked);
+        const taken = listRuns(pr, Infinity).flatMap((r) => (r.state.name ? [r.state.name] : []));
+        if (opts.name !== undefined) {
+            if (!/^[a-z0-9]+(-[a-z0-9]+)*$/.test(opts.name) || opts.name.length > 30)
+                fail(`Invalid run name "${opts.name}": use lowercase letters, digits and "-", at most 30 characters.`);
+            if (taken.includes(opts.name))
+                fail(`A run named "${opts.name}" already exists in project ${pr.name}.`);
+        }
         const runId = newRunId();
         const runDir = path.join(pr.paths.runs, runId);
         const lease = takeLock(pr, runId);
@@ -266,7 +291,8 @@ program
             const prepared = prepareTask({ text: task, file: opts.taskFile, cwd: process.cwd(), runDir });
             console.log(`Project ${pr.name} — repo ${pr.dir}${opts.agent ? ` — solo: ${opts.agent}` : ""}`);
             console.log(`Task: ${prepared.source === "file" ? `file ${prepared.sourcePath}` : "text"} (${prepared.bytes} bytes${prepared.inline ? "" : ", passed by reference"})`);
-            summary = await runTeam({ project: pr, task: prepared, runDir, soloAgent: opts.agent, signal: cancel.signal });
+            const name = opts.name ?? uniqueName(slugify(taskMessageBody(prepared).subject), taken);
+            summary = await runTeam({ project: pr, name, task: prepared, runDir, soloAgent: opts.agent, signal: cancel.signal });
         }
         finally {
             cancel.dispose();
@@ -278,15 +304,41 @@ program
         fail(e instanceof ConfigError ? e.message : e.message);
     }
 });
+/** With a follow-up text and no run named: the one finished run to reopen. Several: ask in a terminal, otherwise list them. Never guesses. */
+async function pickReopenRun(pr) {
+    const cands = reopenCandidates(pr);
+    if (cands.length === 0)
+        return fail('No run to continue. Start one with: agent-lyceum run "<task>"');
+    if (cands.length === 1)
+        return cands[0];
+    const label = (c) => `${runLabel(c.state)}  [${c.state.end_reason ?? "interrupted"}]  ${firstLine(c.state.task_summary)}`;
+    if (!interactive()) {
+        return fail(`Several runs could take this follow-up:\n${cands.map((c) => `  ${c.state.name ? `${c.state.name}  ` : ""}${c.state.run_id}  [${c.state.end_reason ?? "interrupted"}]  ${firstLine(c.state.task_summary)}`).join("\n")}\nName one: agent-lyceum resume <name> "..."`);
+    }
+    console.log("Which run should get the follow-up?");
+    for (const [i, c] of cands.entries())
+        console.log(`  ${i + 1}) ${label(c)}`);
+    const rl = readline.createInterface({ input: process.stdin, output: process.stdout });
+    const answer = (await rl.question("Number or name: ")).trim();
+    rl.close();
+    const n = Number(answer);
+    if (Number.isInteger(n) && n >= 1 && n <= cands.length)
+        return cands[n - 1];
+    const r = resolveRun(cands, answer);
+    if (r.ok)
+        return r.run;
+    return fail(`"${answer}" is not one of the listed runs.`);
+}
 program
-    .command("resume [run-id]")
-    .summary("Continue an interrupted (or failed) run")
-    .description("Continue an interrupted (or failed) run: same run dir, sessions and round count; the task is not re-sent.\n\nWhich run:\n  - without an id: the newest run that is not done or running\n  - with an id: that run")
+    .command("resume [run] [text]")
+    .summary("Continue an interrupted run, or reopen a finished one with a follow-up")
+    .description('Continue an interrupted (or failed) run: same run dir, sessions and round count; the task is not re-sent.\nOr reopen a finished run with a follow-up request: the lead gets the text as a new task and the run goes on with its memory and worktree.\n\nUsage:\n  - resume                    the newest run that is not done or running\n  - resume <run>              that run (full id, name or unique prefix); a finished run only prints its result\n  - resume <run> "<text>"     reopen that finished run with the follow-up\n  - resume "<text>"           if the one argument is not a run, it is the follow-up; the run is chosen among the runs that are not running\n                              (the only one, or you pick one in a terminal; without a terminal the candidates are listed and it fails)\n                              a one-word follow-up looks like a run name: use resume <run> "<text>" or --task-file\n  - --task-file <path>        read the follow-up from a file instead of an argument')
     .option("-p, --project <name>")
+    .option("--task-file <path>", "read the follow-up text from a file (reopens a finished run)")
     .option("--answer", "the run is waiting for answers: open ask-reply.md in $EDITOR, check the answers, then continue")
     .option("--no-edit", "with --answer: do not open the editor; check the file as it is")
     .option("--assume-defaults", "if the run waits for answers, use the suggested answer for every unanswered question that has one")
-    .action(async (runId, opts) => {
+    .action(async (runArg, textArg, opts) => {
     try {
         const pr = loadProject(opts.project);
         const res = validateProject(pr);
@@ -294,13 +346,30 @@ program
             console.error(`${i.level === "error" ? "ERROR" : "warn "}  ${i.message}`);
         if (!res.ok)
             fail("Configuration is invalid; fix the errors above (see `agent-lyceum doctor`).");
+        let text = textArg;
+        let query = runArg;
+        if (opts.taskFile) {
+            if (textArg !== undefined)
+                fail("Give the follow-up either as text or with --task-file, not both.");
+            text = readTaskFile(path.resolve(process.cwd(), opts.taskFile));
+        }
+        else if (query !== undefined && textArg === undefined) {
+            // One argument: a run if it names one. It is follow-up text only if it cannot be a run reference (it has whitespace or a character a run name cannot contain);
+            // a mistyped run name must not silently become the task. An ambiguous match is still an error.
+            const r = query.trim() ? resolveRun(listRuns(pr, Infinity), query) : undefined;
+            if (r && !r.ok && r.reason === "none" && !NAME_RE.test(query)) {
+                text = query;
+                query = undefined;
+            }
+        }
+        if (text !== undefined && !text.trim())
+            fail("The follow-up text is empty.");
         let found;
-        if (runId) {
-            assertName("run", runId);
-            const dir = path.join(pr.paths.runs, runId);
-            if (!fs.existsSync(path.join(dir, "state.json")))
-                fail(`Run "${runId}" not found in ${pr.paths.runs}.`);
-            found = { dir, state: loadRunState(dir) };
+        if (query !== undefined) {
+            found = findRun(pr, query);
+        }
+        else if (text !== undefined) {
+            found = await pickReopenRun(pr);
         }
         else {
             found = latestUnfinishedRun(pr);
@@ -311,19 +380,23 @@ program
         // A solo run needs only its own agent's runtime, as when it started.
         await preflight(state.solo_agent ? onlyAgent(soloProject(pr, state.solo_agent), state.solo_agent) : pr);
         if (!state.end_reason && runIsAlive(state, pr))
-            fail(`Run ${state.run_id} is still running (pid ${state.pid}).`);
-        if (state.end_reason === "done") {
+            fail(`Run ${runLabel(state)} is still running (pid ${state.pid}).`);
+        const reopen = text !== undefined;
+        if (reopen && state.end_reason !== "done")
+            fail(`Run ${runLabel(state)} is not finished (${state.end_reason ?? "interrupted"}); resume it without text first, then follow up.`);
+        if (!reopen && state.end_reason === "done") {
             const result = path.join(dir, RESULT_FILE);
             if (!fs.existsSync(result))
-                fail(`Run ${state.run_id} already finished (done); nothing to resume.`);
+                fail(`Run ${runLabel(state)} already finished (done); nothing to resume.`);
             const o = outcomeOf(state);
-            console.log(`Run ${state.run_id} already finished (done); nothing to resume. Outcome: ${o.outcome}${o.verified ? "" : " (not verified: this run ended before outcomes were recorded)"}. Result: ${result}\n\n${fs.readFileSync(result, "utf8")}`);
+            console.log(`Run ${runLabel(state)} already finished (done); nothing to resume. Outcome: ${o.outcome}${o.verified ? "" : " (not verified: this run ended before outcomes were recorded)"}. Result: ${result}\n\n${fs.readFileSync(result, "utf8")}`);
             process.exit(exitCodeForOutcome(o.outcome));
         }
-        if (state.rounds >= pr.dispatcher.max_rounds)
-            fail(`Run ${state.run_id} used ${state.rounds}/${pr.dispatcher.max_rounds} rounds; raise dispatcher.max_rounds in project.yaml first.`);
+        // A reopen recalculates the round limit from where the run stands.
+        if (!reopen && state.rounds >= roundLimit(state, pr.dispatcher.max_rounds))
+            fail(`Run ${runLabel(state)} used ${state.rounds}/${roundLimit(state, pr.dispatcher.max_rounds)} rounds; raise dispatcher.max_rounds in project.yaml first.`);
         if (opts.answer && state.end_reason !== "waiting")
-            fail(`Run ${state.run_id} is not waiting for answers (${state.end_reason ?? "not finished"}).`);
+            fail(`Run ${runLabel(state)} is not waiting for answers (${state.end_reason ?? "not finished"}).`);
         if (state.end_reason === "waiting") {
             if (opts.answer && opts.edit)
                 openInEditor(prepareAnswers(dir, {}).path);
@@ -333,7 +406,7 @@ program
                 process.exit(3);
             }
         }
-        const summary = await continueRun(pr, dir, state.run_id);
+        const summary = await continueRun(pr, dir, state.run_id, reopen ? { text: text } : undefined);
         await driveRun(pr, dir, summary, !!opts.assumeDefaults);
     }
     catch (e) {
@@ -412,10 +485,12 @@ program
             fail("--force only goes with --lock.");
         if (!runId)
             fail("Give the run id to clear (see `agent-lyceum status --task-list`), or use --lock.");
-        assertName("run", runId);
         const pr = loadProject(opts.project);
+        const target = findRun(pr, runId).state;
+        const full = target.run_id;
+        const label = runLabel(target);
         const showPlan = (plan) => {
-            console.log(`Run ${plan.summary}`);
+            console.log(`Run ${label}${plan.summary.slice(full.length)}`);
             for (const i of plan.items)
                 console.log(`  ${opts.dryRun ? "would delete" : "delete      "}  ${i.label}`);
             for (const k of plan.keep)
@@ -427,16 +502,16 @@ program
             return fail("Nothing was deleted.");
         };
         if (opts.dryRun) {
-            const plan = planRunCleanup(pr, runId, { keepWorktrees: opts.keepWorktrees });
+            const plan = planRunCleanup(pr, full, { keepWorktrees: opts.keepWorktrees });
             console.log("Dry run: nothing is deleted.");
             showPlan(plan);
             if (plan.refusals.length)
                 refuse(plan);
             return;
         }
-        const lease = takeLock(pr, runId, { ignoreLimit: true });
+        const lease = takeLock(pr, full, { ignoreLimit: true });
         try {
-            const plan = planRunCleanup(pr, runId, { keepWorktrees: opts.keepWorktrees });
+            const plan = planRunCleanup(pr, full, { keepWorktrees: opts.keepWorktrees });
             if (plan.refusals.length)
                 refuse(plan);
             showPlan(plan);
@@ -446,7 +521,7 @@ program
                     console.error(`FAILED  ${f.item.label}: ${f.error}`);
                 fail("Cleanup stopped at the first failure; fix it and repeat the same command to finish.");
             }
-            console.log(`Deleted run ${runId}: ${plan.summary.slice(runId.length + 2)}`);
+            console.log(`Deleted run ${label}: ${plan.summary.slice(full.length + 2)}`);
         }
         finally {
             lease.release();
@@ -656,9 +731,7 @@ program
         if (opts.json) {
             if (opts.monitor)
                 fail("--json cannot be combined with --monitor.");
-            if (opts.taskId)
-                assertName("run", opts.taskId);
-            const report = opts.taskList ? buildTaskListReport(pr) : buildStatusReport(pr, opts.taskId);
+            const report = opts.taskList ? buildTaskListReport(pr) : buildStatusReport(pr, opts.taskId !== undefined ? findRun(pr, opts.taskId).state.run_id : undefined);
             console.log(JSON.stringify(report, null, 2));
             return;
         }
@@ -666,12 +739,8 @@ program
             console.log(formatTaskList(pr, useColor()));
             return;
         }
-        if (opts.taskId) {
-            assertName("run", opts.taskId);
-            const dir = path.join(pr.paths.runs, opts.taskId);
-            if (!fs.existsSync(path.join(dir, "state.json")))
-                fail(`Run "${opts.taskId}" not found in ${pr.paths.runs}. List ids with: agent-lyceum status --task-list`);
-            console.log(formatRunDetail({ dir, state: loadRunState(dir) }, Date.now(), useColor(), pr));
+        if (opts.taskId !== undefined) {
+            console.log(formatRunDetail(findRun(pr, opts.taskId), Date.now(), useColor(), pr));
             return;
         }
         if (!opts.monitor) {

package/dist/open-pr.d.ts

@@ -16,9 +16,12 @@ export declare function prTitle(taskSummary: string): string;
 export declare function prBody(doneBody: string): string;
 /** The repo's default branch: `origin/HEAD`, else what `gh` says, else `main`. */
 export declare function defaultBase(cwd: string, run: CommandRunner): string;
-export type OpenPrResult = {
+export type OpenPrResult = 
+/** `updated`: the run's earlier, still open pull request got the new commits; nothing was created. */
+{
     status: "opened";
     url: string;
+    updated?: true;
 } | {
     status: "failed";
     step: "push" | "create" | "write";
@@ -42,6 +45,8 @@ export interface OpenPrInput {
     /** Where the description is written for `gh --body-file` (and for finishing by hand). */
     bodyFile: string;
     run: CommandRunner;
+    /** The run already has a pull request for this branch: while it is still open only the branch is pushed; otherwise (merged, closed) a new one is opened. */
+    existingUrl?: string;
 }
 /** Push the branch and open a pull request against the default branch. Never throws; says how to finish by hand when a step fails. */
 export declare function openPullRequest(i: OpenPrInput): OpenPrResult;

package/dist/open-pr.js

@@ -48,6 +48,16 @@ const firstLine = (s) => s.split(/\r?\n/).find((l) => l.trim())?.trim() ?? "no o
 const sh = (s) => `'${s.replace(/'/g, `'\\''`)}'`;
 /** Push the branch and open a pull request against the default branch. Never throws; says how to finish by hand when a step fails. */
 export function openPullRequest(i) {
+    if (i.existingUrl) {
+        // A squash merge leaves the branch looking unmerged, so ask GitHub. When the lookup itself fails, assume the PR is still open.
+        const view = i.run("gh", ["pr", "view", i.existingUrl, "--json", "state", "-q", ".state"], i.cwd);
+        if (!view.ok || view.out.trim() === "OPEN") {
+            const push = i.run("git", ["push", "-u", "origin", i.branch], i.cwd);
+            if (push.ok)
+                return { status: "opened", url: i.existingUrl, updated: true };
+            return { status: "failed", step: "push", reason: firstLine(push.out), manual: [`git -C ${sh(i.cwd)} push -u origin ${sh(i.branch)}`] };
+        }
+    }
     const base = defaultBase(i.cwd, i.run);
     try {
         atomicWrite(i.bodyFile, i.body);

package/dist/policy.js

@@ -89,6 +89,10 @@ export function writePolicy(project, agent) {
     if (ws)
         for (const f of ["CLAUDE.md", "AGENTS.md"])
             addDeny(path.join(ws.dir, f));
+    // Defence in depth: the dispatcher pins git's dir, common dir and work tree and never reads these, but a runtime that can
+    // forbid single files should not let the agent rewrite them either. Codex cannot; it relies on the pinning alone.
+    if (ws)
+        deny.push(path.join(ws.root, ".git"), ...["commondir", "config.worktree", "gitdir"].map((f) => path.join(ws.gitDir, f)));
     return {
         allowDirs,
         allowFiles,

package/dist/prompt.js

@@ -100,7 +100,7 @@ export function buildSystemPrompt(project, agent) {
             "</ask>",
             "```",
             "",
-            "The answers come back to you as a `reply` mail containing an `<answers>` block. A user answer that starts with `other:` is free text. Do not ask what you could decide yourself, and do not ask again for something already answered.",
+            "The answers come back to you as a `reply` mail containing an `<answers>` block. A user answer may be one of your options or any free text of their own (it may start with `other:`). Do not ask what you could decide yourself, and do not ask again for something already answered.",
         ]
         : []), ...(isLead
         ? [

package/dist/run-session.d.ts

@@ -14,6 +14,8 @@ export declare const MAX_DONE_REJECTIONS = 2;
 export declare const MAX_ASK_REJECTIONS = 2;
 export interface RunSummary {
     runId: string;
+    /** The run's name; absent on runs from older versions. */
+    name?: string;
     runDir: string;
     rounds: number;
     endReason: EndReason;
@@ -34,12 +36,18 @@ export interface RunSummary {
 }
 export interface RunOptions {
     project: ResolvedProject;
+    /** Name for a new run: already decided and not used by another run of the project. */
+    name?: string;
     /** Run only this member of the project, alone (`run --agent`). A resumed run uses the one recorded in its state. */
     soloAgent?: string;
     /** The task for a new run; omit when resuming. */
     task?: PreparedTask;
     /** Continue this earlier run (same run dir, sessions and counters) instead of starting a new one. */
     resume?: RunState;
+    /** Reopen a done run: this text becomes a new task for the lead. Only with `resume` of a run that ended `done`. */
+    followup?: {
+        text: string;
+    };
     runDir: string;
     invoker?: Invoker;
     /** Runs git and gh for the pull request. Tests pass a fake; the default is the real thing. */

package/dist/run-session.js

@@ -12,8 +12,8 @@ import { endOutcome, resolveDoneOutcome } from "./run-outcome.js";
 import { outboxDir, ownsDirs } from "./policy.js";
 import { buildSystemPrompt, buildUserPrompt, pickMessages } from "./prompt.js";
 import { atomicWrite } from "./fs-util.js";
-import { assertWorktreeRunnable, collectAgentChanges, dirtyPaths, existingAgentWorkspace, finishLeadBranch, integrateAgentChanges, prepareAgentWorkspace, refusedIntegration, resolveWorkspaceMode, snapshotBase, snapshotHead, toplevel } from "./worktree.js";
-import { bindRunProject, newRunId, newRunState, saveRunState } from "./run-store.js";
+import { assertWorktreeRunnable, collectAgentChanges, dirtyPaths, existingAgentWorkspace, finishLeadBranch, integrateAgentChanges, prepareAgentWorkspace, recutLeadWorkspace, refusedIntegration, resolveWorkspaceMode, snapshotBase, snapshotHead, toplevel } from "./worktree.js";
+import { bindRunProject, newRunId, newRunState, roundLimit, saveRunState } from "./run-store.js";
 import { soloProject } from "./solo.js";
 import { taskMessageBody } from "./task.js";
 import { must } from "./assert.js";
@@ -67,6 +67,8 @@ export class RunSession {
         const { task, resume, runDir } = opts;
         if (resume?.end_reason === "waiting")
             RunSession.assertAnswered(runDir, resume.run_id);
+        if (opts.followup && resume?.end_reason !== "done")
+            throw new Error("followup needs a finished (done) run");
         if (!task && !resume)
             throw new Error("runTeam needs a task or a run to resume");
         const invoke = opts.invoker ?? realInvoker;
@@ -86,10 +88,19 @@ export class RunSession {
             assertWorktreeRunnable(project, { fresh: !resume, concurrent });
         // Concurrent runs: the lead works in its own worktree cut from HEAD, so no other run (and not you) shares its files.
         let leadSpace;
+        let recut = false;
         if (concurrent && resume) {
             leadSpace = existingAgentWorkspace(project, runId, project.lead);
             if (!leadSpace)
                 throw new Error(`Run ${runId} has no worktree for ${project.lead} (was it cleared?), so it cannot be resumed.`);
+            if (opts.followup) {
+                // A reopened run whose branch you already merged starts on a fresh branch from HEAD (never when work would be lost).
+                const r = recutLeadWorkspace(project, runId, project.lead, leadSpace, resume.result_branch?.head);
+                leadSpace = r.ws;
+                recut = r.recut;
+                if (r.recut)
+                    say(`  ${project.lead}'s branch was already merged: a fresh branch ${leadSpace.branch} was cut from HEAD ${leadSpace.base.slice(0, 8)}`);
+            }
         }
         ensureProjectDirs(project);
         fs.mkdirSync(runDir, { recursive: true });
@@ -103,7 +114,7 @@ export class RunSession {
         }
         let state;
         if (resume) {
-            state = { ...resume, max_rounds: cfg.max_rounds, pid: process.pid, ended_at: undefined, end_reason: undefined, workspace_mode: wsMode, outcome: undefined, outcome_note: undefined, verification: undefined, active: {}, wakes: [...resume.wakes] };
+            state = { ...resume, max_rounds: roundLimit(resume, cfg.max_rounds), pid: process.pid, ended_at: undefined, end_reason: undefined, workspace_mode: wsMode, outcome: undefined, outcome_note: undefined, verification: undefined, active: {}, wakes: [...resume.wakes] };
             // A wake that was running when the process died never finished; keep it in the history as interrupted.
             for (const [agent, a] of Object.entries(resume.active ?? {})) {
                 state.wakes.push({
@@ -116,11 +127,24 @@ export class RunSession {
                     error: "interrupted",
                 });
             }
+            if (opts.followup) {
+                state.reopened = [...(resume.reopened ?? []), { at: new Date().toISOString() }];
+                state.round_floor = resume.rounds;
+                state.max_rounds = roundLimit(state, cfg.max_rounds);
+                state.result_branch = undefined;
+                state.done_rejections = 0;
+                if (recut && resume.pr_url) {
+                    // The recorded pull request is the merged branch's: it must not be mistaken for the new segment's.
+                    state.notes = [...(resume.notes ?? []), `The earlier pull request ${resume.pr_url} belongs to the merged branch; a new one is opened for the follow-up work.`];
+                    state.pr_url = undefined;
+                }
+            }
         }
         else {
             const t = taskMessageBody(task);
             state = newRunState({
                 run_id: runId,
+                name: opts.name,
                 project: project.name,
                 task_source: task.source,
                 task_path: task.sourcePath,
@@ -143,6 +167,24 @@ export class RunSession {
         const guard = new ProtectedGuard(leadSpace ? { ...project, workspaces: { ...project.workspaces, [project.lead]: leadSpace } } : project);
         if (resume) {
             log("resume", { rounds: state.rounds, interrupted: Object.keys(resume.active ?? {}) });
+            if (opts.followup) {
+                const n = state.reopened?.length ?? 1;
+                fs.mkdirSync(path.join(runDir, "followups"), { recursive: true });
+                fs.writeFileSync(path.join(runDir, "followups", `${n}.md`), `${opts.followup.text.trimEnd()}\n`);
+                // A run finished before done-<n>.md existed has only result.md: keep that report before the next done overwrites it.
+                const prev = path.join(runDir, `done-${n}.md`);
+                const legacy = path.join(runDir, RESULT_FILE);
+                if (!fs.existsSync(prev) && fs.existsSync(legacy))
+                    fs.copyFileSync(legacy, prev);
+                deliver(project, {
+                    from: "user",
+                    to: project.lead,
+                    type: "task",
+                    subject: opts.followup.text.split("\n").find((l) => l.trim())?.slice(0, 80) ?? "Follow-up",
+                    body: `## Goal\n${opts.followup.text.trimEnd()}\n\n## Acceptance criteria\nAs stated in the goal; the earlier result still holds unless the goal changes it.\n\n## Scope\nThis run's earlier work and files.\n\n## Upstream\nThe previous final report is in \`${path.join(runDir, `done-${n}.md`)}\`; the original task is in \`${path.join(runDir, "task.md")}\`.\n`,
+                });
+                log("reopen", { n });
+            }
         }
         else {
             const t = taskMessageBody(task);
@@ -246,14 +288,14 @@ export class RunSession {
         };
         let result;
         for (let attempt = 0; attempt <= cfg.retry; attempt++) {
-            if (state.rounds >= cfg.max_rounds) {
+            if (state.rounds >= state.max_rounds) {
                 result = { ok: false, text: "", exitCode: null, timedOut: false, error: "round limit reached" };
                 break;
             }
             const round = ++state.rounds;
             const started = Date.now();
             const att = beginAttempt(runDir, claim.id);
-            say(`[round ${state.rounds}/${cfg.max_rounds}] waking ${agent.name} (${agent.runtime})${attempt ? ` — retry ${attempt}` : ""}`);
+            say(`[round ${state.rounds}/${state.max_rounds}] waking ${agent.name} (${agent.runtime})${attempt ? ` — retry ${attempt}` : ""}`);
             const sessionId = agent.resume ? state.sessions[agent.name] : undefined;
             const handling = unread.map((m) => ({ from: m.meta.from, type: m.meta.type, subject: m.meta.subject, brief: briefOf(m.body), digest: digestOf(m.meta.type, m.body) }));
             state.active[agent.name] = { round, since: new Date(started).toISOString(), handling };
@@ -472,7 +514,9 @@ export class RunSession {
             this.doneOutcome = resolved.outcome;
             this.doneNote = resolved.note;
             this.doneVerification = resolved.verification;
-            atomicWrite(path.join(runDir, RESULT_FILE), `# ${route.done.subject}\n\n**Outcome:** ${this.doneOutcome}${this.doneNote ? ` (${this.doneNote})` : ""}\n\n${route.done.body.trimEnd()}\n`);
+            const report = `# ${route.done.subject}\n\n**Outcome:** ${this.doneOutcome}${this.doneNote ? ` (${this.doneNote})` : ""}\n\n${route.done.body.trimEnd()}\n`;
+            atomicWrite(path.join(runDir, RESULT_FILE), report);
+            atomicWrite(path.join(runDir, `done-${(state.reopened?.length ?? 0) + 1}.md`), report);
             this.pendingDoneFile = route.done.file;
             log("done", { subject: route.done.subject });
             this.endReason = "done";
@@ -604,6 +648,7 @@ export class RunSession {
             return skip(`the work could not be committed on ${this.leadSpace.branch}.`);
         if (!rb.files)
             return skip(`${rb.branch} has no file changes.`);
+        const existingUrl = state.pr_url;
         const result = openPullRequest({
             // Never the lead's worktree: the agent can write it (and its git pointers), and git would run what it planted there.
             cwd: toplevel(project.dir),
@@ -612,11 +657,14 @@ export class RunSession {
             body: prBody(this.doneMessage?.body ?? ""),
             bodyFile: path.join(runDir, "pr-body.md"),
             run: this.prRunner,
+            existingUrl,
         });
         log("pull-request", { ...result });
         if (result.status === "opened") {
+            say(`  pull request ${result.updated ? "updated" : "opened"}: ${result.url}`);
+            if (existingUrl && !result.updated && !state.notes?.some((n) => n.includes(existingUrl)))
+                this.note(`The earlier pull request ${existingUrl} was no longer open; a new one was opened for the follow-up work.`);
             state.pr_url = result.url;
-            say(`  pull request opened: ${result.url}`);
         }
         else {
             this.note(`The pull request could not be opened (${result.step}: ${result.reason}). The branch ${rb.branch} is kept.${result.manual.length ? ` To finish by hand:\n${result.manual.map((m) => `  ${m}`).join("\n")}` : ""}`);
@@ -655,7 +703,7 @@ export class RunSession {
     async run() {
         if (this.resume)
             this.recover();
-        const { say, cfg, runId, runDir, project, wsMode, log, state, opts } = this;
+        const { say, runId, runDir, project, wsMode, log, state, opts } = this;
         // When the lead was the last one woken and left every mailbox empty without a `done`, remind it once instead of ending silently.
         let leadWasLast = false;
         let nudged = false;
@@ -682,7 +730,7 @@ export class RunSession {
                 this.endReason = "idle";
                 break;
             }
-            if (state.rounds >= cfg.max_rounds) {
+            if (state.rounds >= state.max_rounds) {
                 this.endReason = "max_rounds";
                 break;
             }
@@ -744,6 +792,6 @@ export class RunSession {
         this.saveState();
         if (this.pendingDoneFile)
             finishDone(this.pendingDoneFile);
-        return { runId, runDir, rounds: state.rounds, endReason, outcome, outcomeNote, verification: this.doneVerification, doneMessage: this.doneMessage, askReplyPath: endReason === "waiting" ? askReplyPath(runDir) : undefined, resultBranch, pr };
+        return { runId, name: state.name, runDir, rounds: state.rounds, endReason, outcome, outcomeNote, verification: this.doneVerification, doneMessage: this.doneMessage, askReplyPath: endReason === "waiting" ? askReplyPath(runDir) : undefined, resultBranch, pr };
     }
 }

package/dist/run-store.d.ts

@@ -99,6 +99,14 @@ export interface RunState {
     wakes: WakeRecord[];
     /** Checklist progress: seeded from the task, then replaced by the lead's latest `## Steps`. */
     steps?: Step[];
+    /** Readable name; lets `resume`, `clear` and `status` find the run without its id. Absent on runs from older versions. */
+    name?: string;
+    /** One entry per time a finished run was reopened with a follow-up. */
+    reopened?: {
+        at: string;
+    }[];
+    /** `rounds` at the last reopen; the round limit counts from here. */
+    round_floor?: number;
 }
 /** `20261006T010203456Z-<128 random bits>`: sorts by start time and cannot collide, even for two starts in one millisecond. */
 export declare function newRunId(d?: Date): string;
@@ -122,3 +130,26 @@ export declare function outcomeOf(s: Pick<RunState, "outcome" | "end_reason">):
     outcome: RunOutcome;
     verified: boolean;
 } | undefined;
+export declare function slugify(text: string): string;
+/** `base`, or `base-2`, `base-3` … the first that is not in `taken`. */
+export declare function uniqueName(base: string, taken: string[]): string;
+/** How a run is named in output: `name (run_id)`, or just the id for a run without a name. */
+export declare const runLabel: (r: {
+    name?: string;
+    run_id: string;
+}) => string;
+export type RunRef = {
+    dir: string;
+    state: RunState;
+};
+export type Resolved = {
+    ok: true;
+    run: RunRef;
+} | {
+    ok: false;
+    reason: "none" | "ambiguous";
+    candidates: RunRef[];
+};
+/** Find a run by full id, exact name, or a prefix of either that matches exactly one run. An exact id or name always wins. */
+export declare function resolveRun(runs: RunRef[], query: string): Resolved;
+export declare const roundLimit: (state: Pick<RunState, "round_floor">, maxRounds: number) => number;

package/dist/run-store.js

@@ -39,6 +39,9 @@ const WireState = z
     wakes: z.array(z.any()).optional(),
     solo_agent: z.string().optional(),
     steps: z.array(z.object({ text: z.string(), done: z.boolean() })).optional(),
+    name: z.string().optional(),
+    reopened: z.array(z.object({ at: z.string() })).optional(),
+    round_floor: nonNeg.optional(),
 })
     .passthrough();
 /** A fresh v2 state; every collection present. */
@@ -119,3 +122,38 @@ export function outcomeOf(s) {
         return undefined;
     return { outcome: s.end_reason === "lead_failed" ? "failed" : s.end_reason === "cancelled" ? "cancelled" : s.end_reason === "waiting" ? "waiting" : "partial", verified: false };
 }
+const NAME_MAX = 30;
+export function slugify(text) {
+    const s = text
+        .toLowerCase()
+        .replace(/[^a-z0-9]+/g, "-")
+        .replace(/^-+|-+$/g, "")
+        .slice(0, NAME_MAX)
+        .replace(/-+$/g, "");
+    return s || "task";
+}
+/** `base`, or `base-2`, `base-3` … the first that is not in `taken`. */
+export function uniqueName(base, taken) {
+    if (!taken.includes(base))
+        return base;
+    for (let n = 2;; n++) {
+        const suffix = `-${n}`;
+        // The result stays within the 30 characters of a slug: trim the base, then any "-" the trim leaves at its end.
+        const candidate = `${base.slice(0, Math.max(1, NAME_MAX - suffix.length)).replace(/-+$/g, "")}${suffix}`;
+        if (!taken.includes(candidate))
+            return candidate;
+    }
+}
+/** How a run is named in output: `name (run_id)`, or just the id for a run without a name. */
+export const runLabel = (r) => (r.name ? `${r.name} (${r.run_id})` : r.run_id);
+/** Find a run by full id, exact name, or a prefix of either that matches exactly one run. An exact id or name always wins. */
+export function resolveRun(runs, query) {
+    const exact = runs.filter((r) => r.state.run_id === query || r.state.name === query);
+    if (exact.length === 1)
+        return { ok: true, run: exact[0] };
+    const pool = exact.length ? exact : runs.filter((r) => r.state.run_id.startsWith(query) || (r.state.name ?? "").startsWith(query));
+    if (pool.length === 1)
+        return { ok: true, run: pool[0] };
+    return { ok: false, reason: pool.length ? "ambiguous" : "none", candidates: pool };
+}
+export const roundLimit = (state, maxRounds) => (state.round_floor ?? 0) + maxRounds;

package/dist/status.d.ts

@@ -11,6 +11,11 @@ export declare function latestUnfinishedRun(project: ResolvedProject): {
     dir: string;
     state: RunState;
 } | undefined;
+/** Runs a follow-up text can reopen: the finished ones (end_reason "done"). Newest first. */
+export declare function reopenCandidates(project: ResolvedProject): {
+    dir: string;
+    state: RunState;
+}[];
 export declare function listRuns(project: ResolvedProject, limit: number): {
     dir: string;
     state: RunState;
@@ -44,6 +49,8 @@ export interface QueueItem {
 }
 export interface RunReport {
     run_id: string;
+    /** Absent on runs from older versions. */
+    name?: string;
     dir: string;
     /** running: its dispatcher is alive; interrupted: it died mid-run; ended: it stopped (see end_reason). */
     state: "running" | "interrupted" | "ended" | "waiting";

package/dist/status.js

@@ -2,7 +2,7 @@ import fs from "node:fs";
 import path from "node:path";
 import { askReplyPath, readAskReply } from "./ask-reply.js";
 import { RESULT_FILE } from "./dispatcher.js";
-import { bindRunProject, loadRunState, outcomeOf } from "./run-store.js";
+import { bindRunProject, loadRunState, outcomeOf, runLabel } from "./run-store.js";
 import { briefOf, digestOf } from "./format.js";
 import { listUnread } from "./mailbox.js";
 import { tidyAdvice } from "./memory-tidy.js";
@@ -33,6 +33,10 @@ export function latestRun(project) {
 export function latestUnfinishedRun(project) {
     return listRuns(project, Infinity).find((r) => r.state.end_reason !== "done" && (r.state.end_reason || !runIsAlive(r.state, project)));
 }
+/** Runs a follow-up text can reopen: the finished ones (end_reason "done"). Newest first. */
+export function reopenCandidates(project) {
+    return listRuns(project, Infinity).filter((r) => r.state.end_reason === "done");
+}
 export function listRuns(project, limit) {
     const root = project.paths.runs;
     if (!fs.existsSync(root))
@@ -182,6 +186,7 @@ export function buildRunReport(run, project, opts = {}) {
     }
     return {
         run_id: s.run_id,
+        name: s.name,
         dir: run.dir,
         state: s.end_reason === "waiting" ? "waiting" : s.end_reason ? "ended" : live ? "running" : "interrupted",
         live,
@@ -279,7 +284,7 @@ function summaryBlock(run, now, c) {
     const s = run;
     const live = s.live;
     const lines = [
-        `${c.bold("執行 " + s.run_id)}  [${stateColor(c, reportLabel(s))}]  第 ${s.rounds}/${s.max_rounds} 輪`,
+        `${c.bold("執行 " + runLabel(s))}  [${stateColor(c, reportLabel(s))}]  第 ${s.rounds}/${s.max_rounds} 輪`,
         `${L("任務：")}${taskText(s)}`,
     ];
     const steps = stepsLine(s.steps, c, s.end_reason === "done");
@@ -317,7 +322,7 @@ function summaryBlock(run, now, c) {
 /** What a run is doing / did, one line per wake. */
 function describeRun(s, now, c, limit = Infinity) {
     const lines = [
-        `${c.bold("執行 " + s.run_id)}  [${stateColor(c, reportLabel(s))}]  輪次 ${s.rounds}/${s.max_rounds}  輸出 tokens ${tokens(s.output_tokens)}`,
+        `${c.bold("執行 " + runLabel(s))}  [${stateColor(c, reportLabel(s))}]  輪次 ${s.rounds}/${s.max_rounds}  輸出 tokens ${tokens(s.output_tokens)}`,
         `  任務：${taskText(s)}`,
     ];
     const steps = stepsLine(s.steps, c);
@@ -383,10 +388,12 @@ export function formatTaskListReport(report, color = false) {
     const head = `${c.bold("專案：")}${report.project.name}  ${c.dim(`（共 ${runs.length} 個任務）`)}`;
     if (!runs.length)
         return `${head}\n\n無執行紀錄。`;
-    const header = ["ID", "狀態", "輪次", "目前步驟", "任務"];
+    const named = runs.some((s) => s.name);
+    const header = [...(named ? ["名稱"] : []), "ID", "狀態", "輪次", "目前步驟", "任務"];
     const rows = [header];
     for (const s of runs) {
         rows.push([
+            ...(named ? [s.name ?? ""] : []),
             s.run_id,
             reportLabel(s),
             `${s.rounds}/${s.max_rounds}`,
@@ -398,7 +405,7 @@ export function formatTaskListReport(report, color = false) {
     const line = (r, ri) => r
         .map((t, i) => {
         const p = i === r.length - 1 ? t : padCols(t, w[i] ?? 0);
-        return ri === 0 ? c.bold(p) : i === 1 ? stateColor(c, t) + " ".repeat(Math.max(0, (w[i] ?? 0) - cols(t))) : p;
+        return ri === 0 ? c.bold(p) : i === (named ? 2 : 1) ? stateColor(c, t) + " ".repeat(Math.max(0, (w[i] ?? 0) - cols(t))) : p;
     })
         .join("  ")
         .trimEnd();

package/dist/worktree.d.ts

@@ -162,6 +162,16 @@ export interface ResultBranch {
 }
 /** Commit the lead's checkout on its branch (once, at the end of a run) and write what changed as a patch. Never touches your repo's working tree. */
 export declare function finishLeadBranch(ws: AgentWorkspace, message: string, patchFile: string): ResultBranch;
+/**
+ * A reopened run whose lead branch was already merged into your HEAD starts its next segment on a fresh branch cut from HEAD,
+ * so the merged work is not offered again. Only when nothing would be lost: the branch's last committed head (`resultHead`) is
+ * in HEAD, the worktree is still at that head, and it holds no uncommitted work and nothing whose state is unknown.
+ * Otherwise the worktree and branch are returned unchanged. Your working tree, index and HEAD are never touched.
+ */
+export declare function recutLeadWorkspace(project: ResolvedProject, runId: string, agent: string, ws: AgentWorkspace, resultHead: string | undefined): {
+    ws: AgentWorkspace;
+    recut: boolean;
+};
 /** Names of the agents that have a worktree for this run. */
 export declare function listWorkspaceAgents(project: ResolvedProject, runId: string): string[];
 /** The snapshot refs (`refs/agent-lyceum/<run>/...`) of a run. */

package/dist/worktree.js

@@ -686,6 +686,31 @@ export function finishLeadBranch(ws, message, patchFile) {
         fs.writeFileSync(patchFile, agentGit(ws, ["diff", "--binary", "--full-index", ws.base, head]) + "\n");
     return { branch: ws.branch, head, base: ws.base, files: files.length, patch: files.length ? patchFile : undefined };
 }
+/**
+ * A reopened run whose lead branch was already merged into your HEAD starts its next segment on a fresh branch cut from HEAD,
+ * so the merged work is not offered again. Only when nothing would be lost: the branch's last committed head (`resultHead`) is
+ * in HEAD, the worktree is still at that head, and it holds no uncommitted work and nothing whose state is unknown.
+ * Otherwise the worktree and branch are returned unchanged. Your working tree, index and HEAD are never touched.
+ */
+export function recutLeadWorkspace(project, runId, agent, ws, resultHead) {
+    const keep = { ws, recut: false };
+    if (!resultHead)
+        return keep;
+    if (tryGit(toplevel(project.dir), ["merge-base", "--is-ancestor", resultHead, "HEAD"]) === undefined)
+        return keep;
+    const work = inspectWorkspace(project, runId, agent, ws);
+    if (!work || work.unknown || work.dirty.length)
+        return keep;
+    try {
+        if (agentGit(ws, ["rev-parse", "HEAD"]) !== resultHead)
+            return keep;
+    }
+    catch {
+        return keep;
+    }
+    removeAgentWorkspace(project, runId, agent);
+    return { ws: prepareAgentWorkspace(project, runId, agent, snapshotHead(project, runId)), recut: true };
+}
 /** Names of the agents that have a worktree for this run. */
 export function listWorkspaceAgents(project, runId) {
     const dir = path.join(project.paths.root, "worktrees", runId);

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "agent-lyceum",
-  "version": "0.13.0",
+  "version": "0.14.0",
   "description": "Config + dispatcher for teams of Claude Code / Codex agents with scoped context and file-based mailboxes",
   "keywords": [
     "ai",