agent-lyceum 0.13.1 → 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.

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` 在沙箱外以你自己的憑證執行。

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/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.1",
+  "version": "0.14.0",
   "description": "Config + dispatcher for teams of Claude Code / Codex agents with scoped context and file-based mailboxes",
   "keywords": [
     "ai",