project-mgr 0.3.2 → 0.5.0

package/dist/db.js

@@ -1,3 +1,4 @@
+import assert from "node:assert/strict";
 import { randomUUID } from "node:crypto";
 import { isDeepStrictEqual } from "node:util";
 import Database from "better-sqlite3";
@@ -75,6 +76,23 @@ export function openLedger(path = databasePath()) {
         BEGIN SELECT RAISE(ABORT, 'entry uid required; upgrade the writer'); END;`);
             db.prepare("INSERT INTO schema_migrations(version) VALUES (3)").run();
         }
+        if (!db.prepare("SELECT 1 FROM schema_migrations WHERE version = 4").get()) {
+            db.exec(`ALTER TABLE status_entries ADD COLUMN next_steps_source_uid TEXT REFERENCES status_entries(uid);
+        CREATE TABLE todos (
+        uid TEXT PRIMARY KEY, title TEXT NOT NULL,
+        project TEXT REFERENCES projects(slug),
+        entry_uid TEXT REFERENCES status_entries(uid),
+        step_index INTEGER, status TEXT NOT NULL CHECK(status IN ('open','completed','cancelled')),
+        created_at TEXT NOT NULL, completed_at TEXT,
+        UNIQUE(entry_uid, step_index)
+      );
+      CREATE INDEX idx_todos_project ON todos(project);
+      INSERT INTO schema_migrations(version) VALUES (4);`);
+        }
+        if (!db.prepare("SELECT 1 FROM schema_migrations WHERE version = 5").get()) {
+            db.exec(`ALTER TABLE status_entries ADD COLUMN next_todo_uids_json TEXT;
+        INSERT INTO schema_migrations(version) VALUES (5);`);
+        }
     }).immediate();
     return db;
 }
@@ -88,6 +106,15 @@ function entryFromRow(row) {
         ...(row.progress ? { progress: row.progress } : {}),
         blockers: JSON.parse(row.blockers_json),
         nextSteps: JSON.parse(row.next_steps_json),
+        // NULL means legacy (field absent). An explicit JSON array, including [], is new format.
+        ...(row.next_todo_uids_json == null
+            ? {}
+            : {
+                nextTodoUids: JSON.parse(row.next_todo_uids_json),
+            }),
+        ...(row.next_steps_source_uid
+            ? { nextStepsSourceUid: row.next_steps_source_uid }
+            : {}),
         decisions: JSON.parse(row.decisions_json),
         tags: JSON.parse(row.tags_json),
         occurredAt: row.occurred_at,
@@ -199,18 +226,11 @@ export function listProjects(db, options = {}) {
         return false;
     });
 }
-export function addStatus(db, value, defaultSource = "human", completes = []) {
-    const input = validateStatusEntry(value, defaultSource);
-    return db
-        .transaction(() => {
-        const result = addValidatedStatus(db, input);
-        for (const target of completes)
-            changeCompletion(db, target, result.entry.uid, "complete", undefined, input.source);
-        return result;
-    })
-        .immediate();
+function linkCompletions(db, targets, byUid, source) {
+    for (const target of targets)
+        changeCompletion(db, target, byUid, "complete", undefined, source);
 }
-function addValidatedStatus(db, input, recordedAt) {
+function existingIdentity(db, input, recordedAt, textRetry = false) {
     if (input.uid) {
         const existing = one(db, `${select} WHERE e.uid = ?`, input.uid);
         if (existing) {
@@ -219,7 +239,10 @@ function addValidatedStatus(db, input, recordedAt) {
                 id: existing.id,
                 recordedAt: existing.recordedAt,
             });
-            if (!isDeepStrictEqual(toPortableStatusEntry(existing), candidate) ||
+            // Text/ref equivalence is only for addStatus sugar retries, not imports.
+            const sameWrite = isDeepStrictEqual(toPortableStatusEntry(existing), candidate) ||
+                (textRetry && textRefEquivalent(db, existing, input));
+            if (!sameWrite ||
                 (recordedAt !== undefined && recordedAt !== existing.recordedAt))
                 throw new ValidationError("conflicting entry uid");
             return { entry: existing, inserted: false };
@@ -235,15 +258,94 @@ function addValidatedStatus(db, input, recordedAt) {
             return { entry: existing, inserted: false };
         }
     }
+    return undefined;
+}
+function textRefEquivalent(db, existing, input) {
+    // A text --next retry is the same write as the refs snapshot it produced.
+    if (existing.nextTodoUids === undefined || input.nextTodoUids !== undefined)
+        return false;
+    assert.ok(input.nextSteps);
+    const titles = input.nextSteps;
+    if (titles.length !== existing.nextTodoUids.length)
+        return false;
+    const candidate = toPortableStatusEntry({
+        ...input,
+        nextSteps: [],
+        nextTodoUids: existing.nextTodoUids,
+        id: existing.id,
+        recordedAt: existing.recordedAt,
+    });
+    if (!isDeepStrictEqual(toPortableStatusEntry(existing), candidate))
+        return false;
+    return existing.nextTodoUids.every((uid, index) => {
+        const todo = todoByUid(db, uid);
+        return todo !== undefined && todo.title === titles[index];
+    });
+}
+export function addStatus(db, value, defaultSource = "human", completes = []) {
+    const input = validateStatusEntry(value, defaultSource);
+    if (input.nextStepsSourceUid)
+        throw new ValidationError("new snapshots cannot set nextStepsSourceUid");
+    return db
+        .transaction(() => {
+        const replay = existingIdentity(db, input, undefined, true);
+        if (replay) {
+            linkCompletions(db, completes, replay.entry.uid, input.source);
+            return replay;
+        }
+        if (input.nextTodoUids !== undefined) {
+            assertSnapshotRefs(db, input.project, input.nextTodoUids);
+            const result = addValidatedStatus(db, { ...input, nextSteps: [] });
+            linkCompletions(db, completes, result.entry.uid, input.source);
+            return result;
+        }
+        // Text --next sugar: one new Todo per title, stored only as refs.
+        const uid = input.uid ?? randomUUID();
+        const nextTodoUids = input.nextSteps.map(() => randomUUID());
+        const recordedAt = new Date().toISOString();
+        const result = addValidatedStatus(db, { ...input, uid, nextSteps: [], nextTodoUids }, recordedAt);
+        assert.equal(result.inserted, true);
+        input.nextSteps.forEach((title, index) => {
+            insertTodo(db, {
+                uid: nextTodoUids[index],
+                title,
+                project: result.entry.project,
+                entryUid: result.entry.uid,
+                stepIndex: index,
+                status: "open",
+                createdAt: recordedAt,
+                completedAt: null,
+            });
+        });
+        linkCompletions(db, completes, result.entry.uid, input.source);
+        return result;
+    })
+        .immediate();
+}
+function addValidatedStatus(db, input, recordedAt) {
+    const existing = existingIdentity(db, input, recordedAt);
+    if (existing)
+        return existing;
+    if (input.nextStepsSourceUid) {
+        const origin = getEntry(db, input.nextStepsSourceUid);
+        if (!origin ||
+            origin.nextStepsSourceUid !== undefined ||
+            origin.project !== input.project ||
+            origin.occurredAt >= input.occurredAt ||
+            !isDeepStrictEqual(origin.nextSteps, input.nextSteps))
+            throw new ValidationError("invalid next step provenance");
+    }
     const now = recordedAt ?? new Date().toISOString();
     upsertProjectMetadata(db, { project: input.project });
     const project = db
         .prepare("SELECT id FROM projects WHERE slug = ?")
         .get(input.project);
     const result = db
-        .prepare(`INSERT INTO status_entries(project_id, status, summary, progress, blockers_json, next_steps_json, decisions_json, tags_json, occurred_at, recorded_at, source, external_ref, uid)
-      VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?)`)
-        .run(project.id, input.status, input.summary, input.progress ?? null, JSON.stringify(input.blockers), JSON.stringify(input.nextSteps), JSON.stringify(input.decisions), JSON.stringify(input.tags), input.occurredAt, now, input.source, input.externalRef ?? null, input.uid ?? randomUUID());
+        .prepare(`INSERT INTO status_entries(project_id, status, summary, progress, blockers_json, next_steps_json, decisions_json, tags_json, occurred_at, recorded_at, source, external_ref, uid, next_steps_source_uid, next_todo_uids_json)
+      VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?)`)
+        .run(project.id, input.status, input.summary, input.progress ?? null, JSON.stringify(input.blockers), JSON.stringify(input.nextSteps), JSON.stringify(input.decisions), JSON.stringify(input.tags), input.occurredAt, now, input.source, input.externalRef ?? null, input.uid ?? randomUUID(), input.nextStepsSourceUid ?? null, input.nextTodoUids === undefined
+        ? null
+        : JSON.stringify(input.nextTodoUids));
     return {
         entry: one(db, `${select} WHERE e.id = ?`, result.lastInsertRowid),
         inserted: true,
@@ -251,7 +353,14 @@ function addValidatedStatus(db, input, recordedAt) {
 }
 export function importStatuses(db, values) {
     const inputs = values.map((value) => validateStatusEntry(value, "import"));
-    return db.transaction(() => inputs.map((input) => addValidatedStatus(db, input)))();
+    return db.transaction(() => {
+        const results = inputs.map((input) => addValidatedStatus(db, input));
+        // Entry-only imports declare no Todos, so every ref is an omitted dependency.
+        const payloadTodos = new Set();
+        for (const result of results)
+            assertSnapshotRefs(db, result.entry.project, result.entry.nextTodoUids, payloadTodos);
+        return results;
+    })();
 }
 export function current(db, project) {
     const where = project ? " AND p.slug = ?" : "";
@@ -283,6 +392,7 @@ export function history(db, project, options = {}) {
     return rows.map((row) => annotateEntry(db, entryFromRow(row)));
 }
 export function at(db, project, occurredAt) {
+    // Stored snapshot only. Refs may be present; live Todo titles are not historical.
     return one(db, `${select} WHERE p.slug = ? AND e.occurred_at <= ? ORDER BY e.occurred_at DESC, e.id DESC LIMIT 1`, project, occurredAt);
 }
 export function countEntries(db, project) {
@@ -331,6 +441,9 @@ function annotateEntry(db, entry) {
         ...entry,
         effectiveStatus: followUp ? "completed" : entry.status,
         isCurrent: newest?.id === entry.id,
+        ...(entry.nextTodoUids !== undefined
+            ? { nextTodos: entry.nextTodoUids.map((uid) => resolveNextTodo(db, uid)) }
+            : {}),
         ...(followUp && latest
             ? {
                 completedBy: {
@@ -423,7 +536,14 @@ export function exportLedger(db, project) {
         const rows = db
             .prepare(`SELECT c.* FROM completion_events c JOIN status_entries e ON e.uid = c.target_uid JOIN projects p ON p.id = e.project_id ${project ? "WHERE p.slug = ?" : ""} ORDER BY c.id`)
             .all(...(project ? [project] : []));
-        return { version: 2, entries, completions: rows.map(completionFromRow) };
+        const todos = project ? todosVisibleToProject(db, project) : listTodos(db);
+        const version = ledgerVersion(entries, todos);
+        return {
+            version,
+            entries,
+            completions: rows.map(completionFromRow),
+            ...(version >= 3 ? { todos } : {}),
+        };
     })();
 }
 function record(value, keys) {
@@ -468,32 +588,378 @@ function validateCompletionEvent(value) {
         source: row.source,
     };
 }
+function declaredTodoUids(values) {
+    const uids = new Set();
+    for (const value of values) {
+        if (!value || typeof value !== "object" || !("todos" in value))
+            continue;
+        const todos = value.todos;
+        if (!Array.isArray(todos))
+            continue;
+        for (const todo of todos) {
+            if (todo &&
+                typeof todo === "object" &&
+                "uid" in todo &&
+                typeof todo.uid === "string")
+                uids.add(todo.uid);
+        }
+    }
+    return uids;
+}
 export function importLedger(db, values) {
     // Both legacy entries and versioned bundles are accepted atomically, including JSONL.
     return db
         .transaction(() => {
         const results = [];
+        // Refs must name Todos declared in this payload, not only rows already stored.
+        const payloadTodos = declaredTodoUids(values);
         for (const value of values) {
             if (value && typeof value === "object" && "version" in value) {
-                const bundle = record(value, ["version", "entries", "completions"]);
-                if (bundle.version !== 2 ||
+                const bundle = record(value, [
+                    "version",
+                    "entries",
+                    "completions",
+                    "todos",
+                ]);
+                const version = bundle.version;
+                if ((version !== 2 && version !== 3 && version !== 4) ||
+                    ((version === 3 || version === 4) &&
+                        !Array.isArray(bundle.todos)) ||
+                    (version === 2 && bundle.todos !== undefined) ||
                     !Array.isArray(bundle.entries) ||
                     !Array.isArray(bundle.completions))
                     throw new ValidationError("invalid ledger bundle");
+                const imported = [];
                 for (const item of bundle.entries) {
                     if (!item || typeof item !== "object" || Array.isArray(item))
                         throw new ValidationError("entry must be an object");
                     const { recordedAt, ...input } = item;
                     validateUid(input.uid);
-                    results.push(addValidatedStatus(db, validateStatusEntry(input, "import"), parseTime(recordedAt, "recordedAt")));
+                    const result = addValidatedStatus(db, validateStatusEntry(input, "import"), parseTime(recordedAt, "recordedAt"));
+                    imported.push(result.entry);
+                    results.push(result);
                 }
                 for (const event of bundle.completions)
                     insertCompletion(db, validateCompletionEvent(event));
+                if (version === 3 || version === 4)
+                    for (const todo of bundle.todos)
+                        importTodo(db, todo);
+                for (const entry of imported)
+                    assertSnapshotRefs(db, entry.project, entry.nextTodoUids, payloadTodos);
+            }
+            else {
+                const result = addValidatedStatus(db, validateStatusEntry(value, "import"));
+                results.push(result);
+                assertSnapshotRefs(db, result.entry.project, result.entry.nextTodoUids, payloadTodos);
             }
-            else
-                results.push(addValidatedStatus(db, validateStatusEntry(value, "import")));
         }
         return results;
     })
         .immediate();
 }
+const todoSelect = `SELECT uid, title, project, entry_uid AS entryUid,
+  step_index AS stepIndex, status, created_at AS createdAt, completed_at AS completedAt FROM todos`;
+function ledgerVersion(entries, todos) {
+    if (entries.some((entry) => entry.nextTodoUids !== undefined))
+        return 4;
+    if (todos.length > 0 ||
+        entries.some((entry) => entry.nextStepsSourceUid !== undefined))
+        return 3;
+    return 2;
+}
+function todosVisibleToProject(db, project) {
+    return db
+        .prepare(`${todoSelect} WHERE project = ?
+        OR uid IN (
+          SELECT j.value FROM status_entries e
+          JOIN projects p ON p.id = e.project_id
+          JOIN json_each(e.next_todo_uids_json) j
+          WHERE p.slug = ? AND e.next_todo_uids_json IS NOT NULL
+        )
+        ORDER BY created_at, uid`)
+        .all(project, project);
+}
+function todoByUid(db, uid) {
+    return db.prepare(todoSelect + " WHERE uid = ?").get(uid);
+}
+function resolveNextTodo(db, uid) {
+    const todo = todoByUid(db, uid);
+    if (!todo)
+        return { uid, title: uid, status: "open", project: null };
+    return {
+        uid: todo.uid,
+        title: todo.title,
+        status: todo.status,
+        project: todo.project,
+    };
+}
+function assertSnapshotRefs(db, project, uids, payloadTodos) {
+    if (uids === undefined)
+        return;
+    for (const uid of uids) {
+        const todo = todoByUid(db, uid);
+        if (!todo)
+            throw new ValidationError("dangling next todo uid");
+        if (todo.project !== null && todo.project !== project)
+            throw new ValidationError("cross-project next todo ref");
+        if (payloadTodos && !payloadTodos.has(uid))
+            throw new ValidationError("dangling next todo uid");
+    }
+}
+function todoIsReferenced(db, uid) {
+    return (db
+        .prepare(`SELECT 1 AS found FROM status_entries, json_each(next_todo_uids_json)
+         WHERE next_todo_uids_json IS NOT NULL AND json_each.value = ? LIMIT 1`)
+        .get(uid) !== undefined);
+}
+function stepTodo(db, entryUid, index) {
+    return db
+        .prepare(todoSelect + " WHERE entry_uid = ? AND step_index = ?")
+        .get(entryUid, index);
+}
+function legacySource(db, entry) {
+    if (!entry.nextStepsSourceUid)
+        return entry;
+    const origin = getEntry(db, entry.nextStepsSourceUid);
+    assert.ok(origin);
+    assert.equal(origin.nextStepsSourceUid, undefined);
+    return origin;
+}
+function preservedNextWork(db, latest) {
+    if (latest.nextTodoUids !== undefined)
+        return { nextSteps: [], nextTodoUids: [...latest.nextTodoUids] };
+    const source = legacySource(db, latest);
+    const pending = source.nextSteps.some((_, index) => stepTodo(db, source.uid, index) === undefined);
+    if (pending)
+        return {
+            nextSteps: [...source.nextSteps],
+            nextStepsSourceUid: source.uid,
+        };
+    return {
+        nextSteps: [],
+        nextTodoUids: source.nextSteps.map((_, index) => {
+            const todo = stepTodo(db, source.uid, index);
+            assert.ok(todo);
+            return todo.uid;
+        }),
+    };
+}
+export function listTodos(db, project, options = {}) {
+    const clauses = [];
+    const params = [];
+    if (project) {
+        clauses.push("project = ?");
+        params.push(project);
+    }
+    if (options.status !== undefined) {
+        if (!["open", "completed", "cancelled"].includes(options.status))
+            throw new ValidationError("invalid todo status");
+        clauses.push("status = ?");
+        params.push(options.status);
+    }
+    const rows = db
+        .prepare(todoSelect +
+        (clauses.length ? ` WHERE ${clauses.join(" AND ")}` : "") +
+        " ORDER BY created_at, uid")
+        .all(...params);
+    const pins = options.status === "open" && project
+        ? current(db, project)[0]?.nextTodoUids
+        : undefined;
+    if (pins?.length) {
+        const rank = new Map(pins.map((uid, index) => [uid, index]));
+        rows.sort((left, right) => {
+            const leftRank = rank.get(left.uid) ?? pins.length;
+            const rightRank = rank.get(right.uid) ?? pins.length;
+            return leftRank - rightRank;
+        });
+    }
+    return rows;
+}
+function insertTodo(db, todo) {
+    db.prepare(`INSERT INTO todos(uid,title,project,entry_uid,step_index,status,created_at,completed_at)
+    VALUES (?,?,?,?,?,?,?,?)`).run(todo.uid, todo.title, todo.project, todo.entryUid, todo.stepIndex, todo.status, todo.createdAt, todo.completedAt);
+    return todo;
+}
+export function createTodo(db, value) {
+    const input = record(value, ["title", "project", "entryUid"]);
+    if (typeof input.title !== "string" ||
+        !input.title.trim() ||
+        input.title.trim().length > 2000)
+        throw new ValidationError("title must contain 1 to 2000 characters");
+    let project = null;
+    let entryUid = null;
+    if (input.project != null) {
+        project = validateProjectMetadataInput({ project: input.project }).project;
+        if (!db.prepare("SELECT 1 FROM projects WHERE slug = ?").get(project))
+            throw new ValidationError("project not found");
+    }
+    if (input.entryUid != null) {
+        const entry = getEntry(db, validateUid(input.entryUid));
+        if (!entry)
+            throw new ValidationError("entry not found");
+        if (project && project !== entry.project)
+            throw new ValidationError("source project mismatch");
+        project = entry.project;
+        entryUid = entry.uid;
+    }
+    return insertTodo(db, {
+        uid: randomUUID(),
+        title: input.title.trim(),
+        project,
+        entryUid,
+        stepIndex: null,
+        status: "open",
+        createdAt: new Date().toISOString(),
+        completedAt: null,
+    });
+}
+export function convertNextStep(db, ref, index) {
+    return db
+        .transaction(() => {
+        const entry = getEntry(db, ref);
+        if (!entry ||
+            !Number.isInteger(index) ||
+            index < 0 ||
+            index >= entry.nextSteps.length)
+            throw new ValidationError("next step not found");
+        if (entry.nextStepsSourceUid)
+            return convertNextStep(db, entry.nextStepsSourceUid, index);
+        const existing = db
+            .prepare(todoSelect + " WHERE entry_uid = ? AND step_index = ?")
+            .get(entry.uid, index);
+        if (existing)
+            return existing;
+        return insertTodo(db, {
+            uid: randomUUID(),
+            title: entry.nextSteps[index],
+            project: entry.project,
+            entryUid: entry.uid,
+            stepIndex: index,
+            status: "open",
+            createdAt: new Date().toISOString(),
+            completedAt: null,
+        });
+    })
+        .immediate();
+}
+export function updateTodo(db, uid, value) {
+    validateUid(uid);
+    const input = record(value, ["status", "project"]);
+    return db
+        .transaction(() => {
+        const todo = db.prepare(todoSelect + " WHERE uid = ?").get(uid);
+        if (!todo)
+            throw new ValidationError("todo not found");
+        if (input.status !== undefined) {
+            if (!["open", "completed", "cancelled"].includes(input.status))
+                throw new ValidationError("invalid todo status");
+            if (todo.status !== input.status) {
+                todo.status = input.status;
+                todo.completedAt =
+                    todo.status === "completed" ? new Date().toISOString() : null;
+            }
+        }
+        if (input.project !== undefined) {
+            const nextProject = input.project === null
+                ? null
+                : validateProjectMetadataInput({ project: input.project }).project;
+            if (nextProject !== todo.project) {
+                if (todo.entryUid || todoIsReferenced(db, todo.uid))
+                    throw new ValidationError(todo.entryUid
+                        ? "source-linked todo project cannot change"
+                        : "referenced todo project cannot change");
+                if (nextProject &&
+                    !db
+                        .prepare("SELECT 1 FROM projects WHERE slug = ?")
+                        .get(nextProject))
+                    throw new ValidationError("project not found");
+                todo.project = nextProject;
+            }
+        }
+        db.prepare("UPDATE todos SET status=?, completed_at=?, project=? WHERE uid=?").run(todo.status, todo.completedAt, todo.project, uid);
+        return todo;
+    })
+        .immediate();
+}
+function importTodo(db, value) {
+    const input = record(value, [
+        "uid",
+        "title",
+        "project",
+        "entryUid",
+        "stepIndex",
+        "status",
+        "createdAt",
+        "completedAt",
+    ]);
+    validateUid(input.uid);
+    if (typeof input.title !== "string" ||
+        !input.title.trim() ||
+        input.title.length > 2000)
+        throw new ValidationError("invalid todo title");
+    if (!["open", "completed", "cancelled"].includes(input.status))
+        throw new ValidationError("invalid todo status");
+    parseTime(input.createdAt, "createdAt");
+    if (input.status === "completed")
+        parseTime(input.completedAt, "completedAt");
+    else if (input.completedAt !== null)
+        throw new ValidationError("invalid completion timestamp");
+    if (input.project !== null) {
+        validateProjectMetadataInput({ project: input.project });
+        upsertProjectMetadata(db, { project: input.project });
+    }
+    if (input.entryUid !== null) {
+        const entry = getEntry(db, validateUid(input.entryUid));
+        if (!entry || entry.project !== input.project)
+            throw new ValidationError("invalid todo source");
+        if (input.stepIndex !== null) {
+            if (!Number.isInteger(input.stepIndex) || Number(input.stepIndex) < 0)
+                throw new ValidationError("invalid next step index");
+            const index = Number(input.stepIndex);
+            if (entry.nextTodoUids !== undefined) {
+                if (entry.nextTodoUids[index] !== input.uid)
+                    throw new ValidationError("invalid next step index");
+            }
+            else if (entry.nextSteps[index] !== input.title)
+                throw new ValidationError("invalid next step index");
+        }
+    }
+    else if (input.stepIndex !== null)
+        throw new ValidationError("next step requires a source");
+    const todo = input;
+    const existing = db.prepare(todoSelect + " WHERE uid = ?").get(todo.uid);
+    if (existing) {
+        if (!isDeepStrictEqual(existing, todo))
+            throw new ValidationError("conflicting todo uid");
+    }
+    else
+        insertTodo(db, todo);
+}
+export function completeActivity(db, ref) {
+    return db
+        .transaction(() => {
+        const entry = getEntry(db, ref);
+        if (!entry)
+            throw new ValidationError("entry not found");
+        if (entry.effectiveStatus === "completed")
+            return entry;
+        const latest = current(db, entry.project)[0];
+        const occurredAt = new Date(Math.max(Date.now(), Date.parse(latest.occurredAt) + 1)).toISOString();
+        // Copy refs, or keep the full legacy string list until every index is converted.
+        const preserved = preservedNextWork(db, latest);
+        const followUp = addValidatedStatus(db, validateStatusEntry({
+            project: entry.project,
+            status: latest.status,
+            summary: `Completed activity #${entry.id}`,
+            progress: latest.progress,
+            blockers: latest.blockers,
+            decisions: latest.decisions,
+            tags: latest.tags,
+            occurredAt,
+            ...preserved,
+        }));
+        changeCompletion(db, entry.uid, followUp.entry.uid);
+        return getEntry(db, entry.uid);
+    })
+        .immediate();
+}

package/dist/domain.d.ts

@@ -18,6 +18,12 @@ export type ProjectMetadataInput = {
     description?: string | null;
     notes?: string | null;
 };
+export type NextTodoRef = {
+    uid: string;
+    title: string;
+    status: "open" | "completed" | "cancelled";
+    project: string | null;
+};
 export type StatusEntryInput = {
     uid?: string;
     project: string;
@@ -26,13 +32,19 @@ export type StatusEntryInput = {
     progress?: string;
     blockers?: string[];
     nextSteps?: string[];
+    nextTodoUids?: string[];
+    nextStepsSourceUid?: string;
     decisions?: string[];
     tags?: string[];
     occurredAt?: string;
     source?: Source;
     externalRef?: string;
 };
-export type StatusEntry = Required<Omit<StatusEntryInput, "progress" | "externalRef">> & {
+export type StatusEntry = Required<Omit<StatusEntryInput, "progress" | "externalRef" | "nextStepsSourceUid" | "nextTodoUids">> & {
+    nextStepsSourceUid?: string;
+    nextTodoUids?: string[];
+    /** Live Todo rows for display. Not a historical as-of view. */
+    nextTodos?: NextTodoRef[];
     id: number;
     progress?: string;
     externalRef?: string;
@@ -47,12 +59,12 @@ export type StatusEntry = Required<Omit<StatusEntryInput, "progress" | "external
         recordedAt: string;
     };
 };
-export type PortableStatusEntry = Omit<StatusEntry, "id" | "recordedAt" | "effectiveStatus" | "isCurrent" | "completedBy">;
+export type PortableStatusEntry = Omit<StatusEntry, "id" | "recordedAt" | "effectiveStatus" | "isCurrent" | "completedBy" | "nextTodos">;
 export declare class ValidationError extends Error {
     constructor(message: string);
 }
 export declare function parseTime(value: unknown, field: string): string;
 export declare function validateProjectMetadataInput(value: unknown): ProjectMetadataInput;
-export declare function validateStatusEntry(value: unknown, defaultSource?: Source): StatusEntryInput & Required<Pick<StatusEntryInput, "occurredAt" | "source">>;
+export declare function validateStatusEntry(value: unknown, defaultSource?: Source): StatusEntryInput & Required<Pick<StatusEntryInput, "occurredAt" | "source" | "nextSteps" | "blockers" | "decisions" | "tags">>;
 export declare function toPortableStatusEntry(entry: StatusEntry): PortableStatusEntry;
 export declare function validateUid(value: unknown): string;