project-mgr 0.4.0 → 0.5.1

package/CHANGELOG.md

@@ -1,5 +1,41 @@
 # Changelog
 
+## 0.5.1 - 2026-11-02
+
+### Added
+
+- Export `openWork(db, project?)` and expose it through `pmgr next` / `pmgr status next`, combining open pins, unpinned Todos, and unconverted legacy steps.
+- Add live `openWork` to CLI `current --json` and show open work with pin markers in text mode. Historical reads retain their previous shape.
+- Add repeatable `add --done-todo` / `--cancel-todo` for atomic closures and `todo-convert` by entry/index, project, or all current legacy sources.
+
+### Changed
+
+- **CLI behavior change:** plain `add` now keeps open pins; `--next` and `--next-todo` append (first-occurrence uid order). Use `--replace-next` to replace or clear pins without changing Todo status. Domain `addStatus` still defaults to replace; imports/exports stay unchanged. Fixed-uid re-pin of an already-carried pin remains a documented L2 limitation for direct API callers.
+- Reuse prior open Todos for exact trimmed `--next` titles, including unassigned Todos already pinned on the project, preferring pinned work, then the oldest Todo, while preserving provenance. Duplicate new titles in one write still create separate Todos.
+- Make `pmgr next --json` the daily checklist and guide agents to keep, finish, or explicitly retire work before adding new actions. Legacy carry preserves unconverted strings until explicit conversion. No automatic cancellation.
+- CLI `current` builds open work in one scan and groups it per project instead of re-querying each project.
+- Translate the new Todo/open-work section of `README_CN.md` into Chinese and document the L2 fixed-UID retry limitation in the architecture notes.
+
+## 0.5.0 - 2026-10-29
+
+### Added
+
+- Store new snapshot next work as `nextTodoUids` references. `add --next` creates Todos and those refs in one transaction; `add --next-todo` pins existing UIDs.
+- Reject mixed prose and refs, duplicate UIDs, combining `--next` with `--next-todo`, cross-project refs, and project changes that conflict with any historical reference.
+- Export version 4 carries refs and every Todo they need, including unassigned Todos referenced by a project export.
+- `todos --status open` lists open work. With `--project`, current snapshot pins are ordered first.
+- Dashboard activity history and project cards show referenced Todos with live status.
+
+### Changed
+
+- New snapshots no longer persist next-step prose. Legacy string `nextSteps` stay readable. Per-index conversion does not rewrite history; completion copies the full string list until every source index has a Todo, then materializes refs without creating Todos or changing their status.
+
+### Fixed
+
+- Detach the dashboard browser launch so a long-lived browser does not keep the process alive.
+- Reject dangling and cross-project `nextTodoUids` from `importStatuses`, and require imported refs to name Todos in the same payload. Entry-only imports declare no Todos, so they cannot reference existing rows.
+- Treat a fixed-UID retry of `--next` text as the same write after it has been stored as refs. Portable imports still require an exact snapshot match.
+
 ## 0.4.0 - 2026-10-28
 
 ### Added

package/README.md

@@ -225,7 +225,7 @@ pnpm start projects --query "mvp" --json
 
 ## Bulk import
 
-`import` accepts a JSON object, a JSON array, or a JSONL file containing one object per line. Every record is validated before the whole batch is written in one SQLite transaction; any failure rolls back the entire batch.
+`import` accepts a JSON object, a JSON array, or a JSONL file containing one object per line. Every record is validated before the whole batch is written in one SQLite transaction; any failure rolls back the entire batch. The example below is a legacy entry: string `nextSteps` are kept and do not create Todos. New snapshots created with `add` store `nextTodoUids` instead.
 
 ```json
 {
@@ -336,22 +336,72 @@ Independently migrated copies of legacy data receive different UUIDs. Cross-impo
 
 ### Todos and dashboard actions
 
-New `add --next` values create independent Todos linked to the new activity.
-Historical next steps stay as text until explicitly converted in the dashboard.
-The Todos tab supports standalone creation, optional project assignment, source
-links, completion, cancellation, and reopening. Project cards filter this list.
-Activity cards provide **Mark completed**, recording a follow-up with the current
-project status; this neither completes the project nor its Todos.
+Todos own actionable work. A new status snapshot stores ordered `nextTodoUids`
+and does not persist next-step prose. CLI `add` now carries open pins by default;
+plain `add` no longer clears them, and `--next` appends new work. An exact,
+case-sensitive title (after trimming) reuses a prior open Todo in that project
+or an unassigned Todo already pinned on it, preferring a current pin, then the oldest Todo. Provenance stays unchanged.
+Duplicate new titles within one write still create separate Todos.
+Use `--next-todo` to pin an existing UID explicitly.
+Do not combine `--next` with `--next-todo`. Duplicate UIDs in one list are rejected.
 
 ```sh
-pmgr todo-add --title "Review results" --project demo --json
+pmgr add --project demo --status active --summary "Review queued" \
+  --next "Collect logs" --next "Write the note" --source agent --json
 pmgr todo-add --title "Unassigned idea" --json
-pmgr todos --project demo --json
+pmgr add --project demo --status active --summary "Pin the idea" \
+  --next-todo <todo-uuid> --source agent --json
+pmgr next --project demo --json
 pmgr todo-update --uid <todo-uuid> --status completed --json
+pmgr todo-update --uid <todo-uuid> --status cancelled --json
 ```
 
-Exports with Todos use version 3 and preserve their identities and state;
-version-2 and legacy imports remain supported without creating new Todos from
-old next-step text. Conflicting Todo snapshots are rejected atomically on import.
-Dashboard writes are restricted to same-origin localhost requests with JSON bodies;
-remote-host dashboards remain read-only.
+The canonical daily checklist is `pmgr next --json` (also `pmgr status next`).
+Do not combine `nextSteps`, `nextTodos`, and `todos` by hand. Before every `add`,
+run `pmgr next --project P --json` and decide each item: keep it (do nothing;
+existing pins carry), finish it with `--done-todo <uid>`, or retire superseded
+work with `--cancel-todo <uid>`. Both close flags are repeatable and run in the
+same transaction as the snapshot. Unpinned work remains visible in the backlog.
+Use `--next` only for new actions, never status descriptions; put blockers in
+`--blocker`. No Todo is automatically cancelled by age or similarity.
+
+`--replace-next` restores replacement behavior: without next work it unpins
+everything; with next work it pins only those UIDs. It never closes Todos.
+The domain `addStatus` API still defaults to `nextMode: "replace"`; CLI `add`
+passes `"carry"` unless `--replace-next` is present. Imports stay strict.
+
+Legacy snapshots retain strings until explicitly converted. A plain carry-mode
+`add` preserves the full legacy list and `nextStepsSourceUid` while any index is
+unconverted; adding new next work then requires conversion or `--replace-next`.
+Conversion is idempotent and appends no snapshot:
+
+```sh
+pmgr todo-convert --entry <id-or-uid> --index 0 --json
+pmgr todo-convert --project demo --json
+# Back up before an explicit, user-run conversion of every current legacy source.
+pmgr export --format json > backup.json
+pmgr todo-convert --all --json
+```
+
+Once all source indices have Todos, the next carry-mode `add` materializes refs
+in index order, filtering out closed Todos. Historical snapshots stay unchanged.
+`next` combines converted Todos and unconverted strings without duplicates.
+
+`current --json` adds live `openWork` for each project's checklist, while its
+stored `nextSteps`, `nextTodoUids`, and live `nextTodos` retain their previous
+meaning, including closed pins. Text `current` prints open work with `[pinned]`
+markers. `history`, `at`, and `getEntry` do not gain `openWork`; `history` text
+and `completeActivity` follow-up copying stay unchanged. `at` returns stored
+snapshots without live Todo resolution.
+
+A snapshot may reference Todos that are unassigned or already in that project.
+If a Todo appears in any `nextTodoUids`, or is linked to a source entry, its
+project cannot be changed. Unpinning the current snapshot does not lift that lock.
+
+Exports that contain refs use version 4 and include every referenced Todo.
+Version 3 remains the Todo bundle without refs. Version 2 and legacy imports
+do not invent open work. Dangling, duplicate, mixed, or cross-project refs fail
+the whole import. Dashboard writes stay same-origin localhost JSON. Activity
+cards still offer **Mark completed**, which appends a follow-up and does not
+complete the project or its Todos. Adding a Todo from the dashboard does not
+pin it; pinning requires a new snapshot.

package/README_CN.md

@@ -223,7 +223,7 @@ pnpm start projects --query "mvp" --json
 
 ## 批量导入
 
-`import` 接受一个 JSON 对象、JSON 数组，或每行一个对象的 JSONL 文件。所有记录先校验，再在同一个 SQLite 事务中写入；任一记录失败时整批回滚。
+`import` 接受一个 JSON 对象、JSON 数组，或每行一个对象的 JSONL 文件。所有记录先校验，再在同一个 SQLite 事务中写入；任一记录失败时整批回滚。下面的示例是旧格式条目：字符串 `nextSteps` 会保留，且不会创建待办。用 `add` 写入的新快照会改为存储 `nextTodoUids`。
 
 ```json
 {
@@ -334,20 +334,60 @@ pmgr revoke-completion --entry 12 --by 18 --reason "验收仍未完成" --source
 
 ### 待办与仪表板操作
 
-新的 `add --next` 会创建独立待办，并关联到这条新动态。
-历史中的下一步仍只是文本，直到在仪表板里显式转为待办。
-待办页支持单独创建、可选关联项目、查看来源动态、标为已完成、取消和重新打开。项目卡片可以筛选这份列表。
-动态卡片提供 **标为已完成**，会用当前项目状态记一条后续动态；这既不会把项目标成完成，也不会完成它的待办。
+待办是具体工作的来源。新的状态快照按顺序存储 `nextTodoUids`，不再把下一步原文写入快照。
+CLI `add` 现在默认沿用仍处于 open 的钉住项：不带下一步的 `add` 不再清空它们，`--next` 会追加新工作。
+去掉首尾空白后，标题与该项目已有的 open 待办（或已钉在该项目上的未归属待办）完全一致（区分大小写）时，会复用那个待办：优先已钉住的，其次最早创建的。来源信息保持不变。
+同一次写入里重复的新标题仍会各自创建待办。要显式钉住已有 UID，请传 `--next-todo`。
+不要把 `--next` 和 `--next-todo` 写在同一次 `add` 里。同一列表里的重复 UID 会被拒绝。
 
 ```sh
-pmgr todo-add --title "复查结果" --project demo --json
+pmgr add --project demo --status active --summary "已排队复查" \
+  --next "收集日志" --next "写说明" --source agent --json
 pmgr todo-add --title "未归属的想法" --json
-pmgr todos --project demo --json
+pmgr add --project demo --status active --summary "钉住这个想法" \
+  --next-todo <todo-uuid> --source agent --json
+pmgr next --project demo --json
 pmgr todo-update --uid <todo-uuid> --status completed --json
+pmgr todo-update --uid <todo-uuid> --status cancelled --json
 ```
 
-带待办的导出使用 version 3，并保留待办的身份与状态；
-version 2 和旧版导入仍然可用，且不会把旧的下一步文本自动变成新待办。
-冲突的待办快照会在导入时整批拒绝。
-仪表板写入仅接受同源的 localhost JSON 请求；
-绑定到远程主机时，仪表板保持只读。
+每日清单统一使用 `pmgr next --json`（也可写作 `pmgr status next`），不要手动拼接 `nextSteps`、`nextTodos` 和 `todos`。
+每次 `add` 之前先运行 `pmgr next --project P --json`，逐条决定：保留（什么都不做，已钉住的会自动沿用）、用 `--done-todo <uid>` 完成，或用 `--cancel-todo <uid>` 退役被取代的工作。
+这两个关闭参数可重复，并与快照在同一事务中执行。未钉住的工作仍会作为积压项显示。
+`--next` 只写新的行动，不写状态描述；阻塞写进 `--blocker`。系统不会按时间或相似度自动取消任何待办。
+
+`--replace-next` 恢复替换语义：不带下一步时取消全部钉住，带下一步时只钉住这些 UID。它不会关闭待办。
+领域层 `addStatus` 默认仍是 `nextMode: "replace"`；CLI `add` 除非带 `--replace-next`，否则传 `"carry"`。导入仍保持严格校验。
+已知限制：领域 API 用固定 UID 重新钉住一个已沿用的待办时，原样重试会报 `conflicting entry uid`。CLI 不传固定 UID，`--external-ref` 重放不受影响。
+
+旧快照保留字符串 `nextSteps`，并省略 `nextTodoUids`，直到显式转换。
+只要还有来源下标未转换，沿用模式的 `add`（以及完成活动时的后续快照）会复制完整字符串列表和 `nextStepsSourceUid`；此时要写入新的下一步，需先转换或使用 `--replace-next`。
+转换是幂等的，不会追加快照：
+
+```sh
+pmgr todo-convert --entry <id-or-uid> --index 0 --json
+pmgr todo-convert --project demo --json
+# 对所有当前旧快照做显式转换前，先备份；仅在用户要求时执行。
+pmgr export --format json > backup.json
+pmgr todo-convert --all --json
+```
+
+每个下标都已有待办之后，下一次沿用模式的 `add` 会按原下标顺序写入引用，并过滤掉已关闭的待办。历史快照保持不变。
+`next` 会合并已转换的待办和未转换的字符串，不会重复。
+
+`current --json` 为每个项目增加实时的 `openWork` 清单；存储的 `nextSteps`、`nextTodoUids` 以及实时的 `nextTodos` 含义不变，仍包含已关闭的钉住项。
+文本模式的 `current` 会列出未完成工作，并用 `[pinned]` 标出钉住项。
+`history`、`at` 和 `getEntry` 不带 `openWork`；`history` 文本输出和完成活动的后续快照复制规则不变。
+`at` 返回当时存储的快照，不附加实时待办状态。
+
+快照只能引用未归属的待办，或已经属于该项目的待办。
+待办一旦出现在任意 `nextTodoUids` 中，或关联了来源动态，就不能再改项目。
+从当前快照拿掉引用，也不会解除这个限制。
+
+带引用的导出使用 version 4，并包含被引用的待办。
+没有引用、但有待办的导出仍是 version 3。
+version 2 和旧版导入不会凭空创建待办。
+悬空、重复、混用或跨项目引用会使整批导入失败。
+仪表板写入仍只接受同源的 localhost JSON 请求。
+动态卡片上的 **标为已完成** 会追加一条后续动态，既不完成项目，也不完成待办。
+在仪表板里新增待办不会把它钉进当前下一步；钉住需要再写一条快照。

package/dist/cli.js

@@ -2,7 +2,7 @@
 import { readFileSync, realpathSync } from "node:fs";
 import { basename } from "node:path";
 import { pathToFileURL } from "node:url";
-import { addStatus, createTodo, listTodos, updateTodo, at, current, history, importLedger, exportLedger, changeCompletion, listProjects, openLedger, parseTime, setProjectMetadata, startServer, ValidationError, } from "./index.js";
+import { addStatus, createTodo, convertNextStep, getEntry, openWork, openWorkByProject, listTodos, updateTodo, at, current, history, importLedger, exportLedger, changeCompletion, listProjects, openLedger, parseTime, setProjectMetadata, startServer, ValidationError, } from "./index.js";
 const booleanFlags = new Set([
     "json",
     "clear-description",
@@ -11,8 +11,19 @@ const booleanFlags = new Set([
     "no-open",
     "help",
     "version",
+    "replace-next",
+    "all",
+]);
+const repeats = new Set([
+    "next",
+    "next-todo",
+    "blocker",
+    "decision",
+    "tag",
+    "completes",
+    "done-todo",
+    "cancel-todo",
 ]);
-const repeats = new Set(["next", "blocker", "decision", "tag", "completes"]);
 function parse(argv) {
     const command = [];
     const flags = Object.create(null);
@@ -58,6 +69,10 @@ const allowedFlags = new Map([
             "progress",
             "blocker",
             "next",
+            "next-todo",
+            "replace-next",
+            "done-todo",
+            "cancel-todo",
             "decision",
             "tag",
             "at",
@@ -68,7 +83,9 @@ const allowedFlags = new Map([
         ]),
     ],
     ["todo-add", new Set(["title", "project", "entry", "json"])],
-    ["todos", new Set(["project", "json"])],
+    ["todos", new Set(["project", "status", "json"])],
+    ["next", new Set(["project", "json"])],
+    ["todo-convert", new Set(["entry", "index", "project", "all", "json"])],
     ["todo-update", new Set(["uid", "status", "project", "json"])],
     ["complete", new Set(["entry", "by", "reason", "source", "json"])],
     ["revoke-completion", new Set(["entry", "by", "reason", "source", "json"])],
@@ -97,18 +114,26 @@ const allowedFlags = new Map([
     ["serve", new Set(["port", "host", "open", "no-open", "json"])],
 ]);
 const commandHelp = {
+    next: ["List all open work, pinned first", "[--project <name>] [--json]"],
+    "todo-convert": [
+        "Convert legacy next steps without appending a snapshot",
+        "--entry <id-or-uid> --index <n> | --project <name> | --all [--json]",
+    ],
     "todo-add": [
         "Create an independent or linked Todo",
         "--title <text> [--project <name>] [--entry <uid>] [--json]",
     ],
-    todos: ["List Todos", "[--project <name>] [--json]"],
+    todos: [
+        "List Todos",
+        "[--project <name>] [--status open|completed|cancelled] [--json]",
+    ],
     "todo-update": [
         "Change Todo status or assign a project",
         "--uid <uuid> [--status open|completed|cancelled] [--project <name>] [--json]",
     ],
     add: [
         "Append a status snapshot",
-        "--project <name> --summary <text> [options]",
+        "--project <name> --summary <text> [--next <text> | --next-todo <uid>] [--replace-next] [--done-todo <uid>] [--cancel-todo <uid>] [options]",
     ],
     complete: [
         "Link a completed activity to its follow-up",
@@ -182,7 +207,7 @@ function validateInvocation(command, flags) {
     const action = command[statusCommand ? 1 : 0];
     const allowed = typeof action === "string" ? allowedFlags.get(action) : undefined;
     if (typeof action !== "string" || !allowed)
-        throw new ValidationError("usage: pmgr <add|complete|revoke-completion|import|current|projects|list|set-project|history|at|export|serve> (or: pmgr status <action>)");
+        throw new ValidationError("usage: pmgr <add|next|todo-add|todos|todo-update|todo-convert|complete|revoke-completion|import|current|projects|list|set-project|history|at|export|serve> (or: pmgr status <action>)");
     const positional = command.slice(statusCommand ? 2 : 1);
     if (action === "import") {
         if (positional.length > 1)
@@ -221,7 +246,7 @@ function output(value, json, write) {
         write(`${JSON.stringify(value)}\n`);
     else if (Array.isArray(value)) {
         const rows = value
-            .map((entry) => `${entry.project}\t${entry.effectiveStatus ?? entry.status}\t${entry.occurredAt}\t${entry.summary}${entry.completedBy ? ` (completed by #${entry.completedBy.id}; original: ${entry.status})` : ""}`)
+            .map((entry) => `${entry.project}\t${entry.effectiveStatus ?? entry.status}\t${entry.occurredAt}\t${entry.summary}${entry.completedBy ? ` (completed by #${entry.completedBy.id}; original: ${entry.status})` : ""}${entry.openWork ? entry.openWork.map((item) => `\n  - ${item.title}${item.pinned ? " [pinned]" : ""}`).join("") : ""}`)
             .join("\n");
         write(`${rows || "No entries found."}\n`);
     }
@@ -301,6 +326,50 @@ export function run(argv, write = process.stdout.write.bind(process.stdout)) {
     const json = flags.json === true;
     try {
         switch (action) {
+            case "next": {
+                const items = openWork(db, stringFlag(flags, "project"));
+                if (json)
+                    output(items, true, write);
+                else
+                    write(items.length
+                        ? items
+                            .map((item) => `${item.project ?? "-"}\t${item.kind === "todo" ? item.uid : `${item.entryUid}#${item.stepIndex}`}\t${item.pinned ? "pinned" : "-"}\t${item.title}`)
+                            .join("\n") + "\n"
+                        : "No open work.\n");
+                break;
+            }
+            case "todo-convert": {
+                const ref = stringFlag(flags, "entry");
+                const project = stringFlag(flags, "project");
+                if (Number(ref !== undefined) +
+                    Number(project !== undefined) +
+                    Number(flags.all === true) !==
+                    1)
+                    throw new ValidationError("use exactly one of --entry, --project, or --all");
+                if ((ref === undefined) !== (flags.index === undefined))
+                    throw new ValidationError("--entry requires --index; --index requires --entry");
+                const todos = db
+                    .transaction(() => {
+                    if (ref !== undefined)
+                        return [convertNextStep(db, ref, numberFlag(flags, "index", 0))];
+                    return current(db, project).flatMap((entry) => {
+                        if (entry.nextTodoUids !== undefined)
+                            return [];
+                        const source = entry.nextStepsSourceUid
+                            ? getEntry(db, entry.nextStepsSourceUid)
+                            : entry;
+                        return source.nextSteps.map((_, index) => convertNextStep(db, source.uid, index));
+                    });
+                })
+                    .immediate();
+                if (json)
+                    output(todos, true, write);
+                else
+                    write(todos
+                        .map((todo) => `${todo.uid}\t${todo.status}\t${todo.project}\t${todo.title}`)
+                        .join("\n") + "\n");
+                break;
+            }
             case "todo-add":
                 output(createTodo(db, {
                     title: stringFlag(flags, "title", true),
@@ -309,7 +378,15 @@ export function run(argv, write = process.stdout.write.bind(process.stdout)) {
                 }), json, write);
                 break;
             case "todos": {
-                const todos = listTodos(db, stringFlag(flags, "project"));
+                const status = stringFlag(flags, "status");
+                if (status !== undefined &&
+                    status !== "open" &&
+                    status !== "completed" &&
+                    status !== "cancelled")
+                    throw new ValidationError("--status must be open, completed, or cancelled");
+                const todos = listTodos(db, stringFlag(flags, "project"), status === undefined
+                    ? {}
+                    : { status: status });
                 if (json)
                     output(todos, true, write);
                 else
@@ -328,6 +405,10 @@ export function run(argv, write = process.stdout.write.bind(process.stdout)) {
                 const project = stringFlag(flags, "project", true);
                 const description = stringFlag(flags, "description");
                 const notes = stringFlag(flags, "notes");
+                const next = listFlag(flags, "next");
+                const nextTodo = listFlag(flags, "next-todo");
+                if (next.length > 0 && nextTodo.length > 0)
+                    throw new ValidationError("cannot combine --next and --next-todo");
                 const result = db
                     .transaction(() => {
                     if (description !== undefined || notes !== undefined) {
@@ -339,7 +420,19 @@ export function run(argv, write = process.stdout.write.bind(process.stdout)) {
                         summary: stringFlag(flags, "summary", true),
                         progress: stringFlag(flags, "progress"),
                         blockers: listFlag(flags, "blocker"),
-                        nextSteps: listFlag(flags, "next"),
+                        nextSteps: next,
+                        nextMode: flags["replace-next"] === true ? "replace" : "carry",
+                        closeTodos: [
+                            ...listFlag(flags, "done-todo").map((uid) => ({
+                                uid,
+                                status: "completed",
+                            })),
+                            ...listFlag(flags, "cancel-todo").map((uid) => ({
+                                uid,
+                                status: "cancelled",
+                            })),
+                        ],
+                        ...(nextTodo.length > 0 ? { nextTodoUids: nextTodo } : {}),
                         decisions: listFlag(flags, "decision"),
                         tags: listFlag(flags, "tag"),
                         occurredAt: stringFlag(flags, "at"),
@@ -360,9 +453,16 @@ export function run(argv, write = process.stdout.write.bind(process.stdout)) {
                     command[command[0] === "status" ? 2 : 1] ??
                     "")).map((result) => result.entry), json, write);
                 break;
-            case "current":
-                output(current(db, stringFlag(flags, "project")), json, write);
+            case "current": {
+                const project = stringFlag(flags, "project");
+                // One open-work scan for all projects, grouped per project.
+                const { groups } = openWorkByProject(db, project);
+                output(current(db, project).map((entry) => ({
+                    ...entry,
+                    openWork: groups.get(entry.project),
+                })), json, write);
                 break;
+            }
             case "projects":
             case "list":
                 outputProjects(listProjects(db, { query: stringFlag(flags, "query") }), json, write);

package/dist/db.d.ts

@@ -1,10 +1,35 @@
 import Database from "better-sqlite3";
-import { type ProjectMetadata, type ProjectOverview, type Source, type StatusEntry } from "./domain.js";
+import { type ProjectMetadata, type ProjectOverview, type Source, type StatusEntry, type StatusEntryInput } from "./domain.js";
 export type Ledger = Database.Database;
 export type InsertResult = {
     entry: StatusEntry;
     inserted: boolean;
 };
+export type AddStatusInput = StatusEntryInput & {
+    nextMode?: "carry" | "replace";
+    closeTodos?: {
+        uid: string;
+        status: "completed" | "cancelled";
+    }[];
+};
+export type OpenWorkItem = {
+    kind: "todo";
+    uid: string;
+    title: string;
+    project: string | null;
+    pinned: boolean;
+    pinIndex: number | null;
+    createdAt: string;
+    entryUid: string | null;
+} | {
+    kind: "legacy-step";
+    project: string;
+    entryUid: string;
+    stepIndex: number;
+    title: string;
+    pinned: true;
+    pinIndex: number;
+};
 export type HistoryOptions = {
     since?: string;
     until?: string;
@@ -20,6 +45,12 @@ export declare function listProjects(db: Ledger, options?: {
 export declare function addStatus(db: Ledger, value: unknown, defaultSource?: Source, completes?: string[]): InsertResult;
 export declare function importStatuses(db: Ledger, values: unknown[]): InsertResult[];
 export declare function current(db: Ledger, project?: string): StatusEntry[];
+/** Per-project open work from one current() and one Todo scan; no cross-project dedupe. */
+export declare function openWorkByProject(db: Ledger, project?: string): {
+    groups: Map<string, OpenWorkItem[]>;
+    unassigned: Todo[];
+};
+export declare function openWork(db: Ledger, project?: string): OpenWorkItem[];
 export declare function history(db: Ledger, project?: string, options?: HistoryOptions): StatusEntry[];
 export declare function at(db: Ledger, project: string, occurredAt: string): StatusEntry | undefined;
 export declare function countEntries(db: Ledger, project?: string): number;
@@ -37,12 +68,13 @@ export declare function getEntry(db: Ledger, ref: string): StatusEntry | undefin
 export declare function changeCompletion(db: Ledger, targetRef: string, byRef: string, action?: CompletionEvent["action"], reason?: string, source?: Source): CompletionEvent;
 export declare function exportLedger(db: Ledger, project?: string): {
     todos?: Todo[] | undefined;
-    version: number;
+    version: 3 | 2 | 4;
     entries: {
         recordedAt: string;
         progress?: string | undefined;
         externalRef?: string | undefined;
         nextStepsSourceUid?: string | undefined;
+        nextTodoUids?: string[] | undefined;
         uid: string;
         project: string;
         status: import("./domain.js").ProjectStatus;
@@ -67,7 +99,9 @@ export type Todo = {
     createdAt: string;
     completedAt: string | null;
 };
-export declare function listTodos(db: Ledger, project?: string): Todo[];
+export declare function listTodos(db: Ledger, project?: string, options?: {
+    status?: Todo["status"];
+}): Todo[];
 export declare function createTodo(db: Ledger, value: unknown): Todo;
 export declare function convertNextStep(db: Ledger, ref: string, index: number): Todo;
 export declare function updateTodo(db: Ledger, uid: string, value: unknown): Todo;