@anchrd/intel-api 0.13.0 → 0.15.0

package/dist/nodes/board/board.js

@@ -1,528 +0,0 @@
-import { ArchivedBoardStatusId, BoardDefaultStatuses, BoardMaxTaskDepth, } from "@anchrd/intel-contract";
-import { generateKeyBetween } from "fractional-indexing";
-import { IntelError } from "../../shared/intel-error/intel-error.js";
-/**
- * Statuses that answer whether standing in them means finished (anchrd/intel#311).
- *
- * ⚠️ This is the ONE place the old positional rule survives, and it survives as a data migration
- * rather than as a reading. A board written before `terminal` existed has no answer to "which
- * columns mean finished", and the honest answer is the one that board already behaved as: the last
- * column before `archived`, plus the shelf. Filling `false` everywhere instead would quietly declare
- * that nothing on any existing board is done — every finished task would become an open blocker
- * overnight. Filling `true` everywhere would be the same lie the other way round.
- *
- * ⚠️ It touches only what is missing. A status that already carries the flag keeps it, whatever the
- * position rule would have said — otherwise the migration would undo somebody's configuration every
- * time their board was read.
- *
- * `undefined` means "nothing to do", which is what keeps an untouched document identical rather
- * than merely equal.
- */
-function upgradedStatuses(statuses) {
-    if (!Array.isArray(statuses))
-        return undefined;
-    const entries = statuses.filter((status) => typeof status === "object" && status !== null);
-    if (entries.every((status) => "terminal" in status))
-        return undefined;
-    // The end of the work as the board behaved before the flag: the last column that is not the shelf,
-    // read in the stored order rather than in array order, because `order` is what a surface draws by.
-    const working = entries
-        .filter((status) => status.id !== ArchivedBoardStatusId)
-        .sort((left, right) => Number(left.order ?? 0) - Number(right.order ?? 0));
-    const lastWorking = working.at(-1)?.id;
-    return statuses.map((status) => {
-        if (typeof status !== "object" || status === null || "terminal" in status)
-            return status;
-        const entry = status;
-        return {
-            ...entry,
-            terminal: entry.id === ArchivedBoardStatusId || entry.id === lastWorking,
-        };
-    });
-}
-/**
- * The three task lists that have to be distinct, and how a stored entry is recognised again.
- *
- * ⚠️ `labels` are compared TRIMMED and the two id lists are not, and that mirrors the schema
- * exactly: `BoardTaskLabel` carries `.trim()`, `BoardTaskId` and `IntelId` do not. Comparing raw
- * here would leave `["Bug ", "Bug"]` untouched — and zod, which trims each entry BEFORE the
- * distinctness check runs on the array, would then see one word twice and refuse the board. That is
- * precisely the `board_unreadable` this function exists to prevent, arrived at through the fold.
- */
-const distinctTaskLists = [
-    { field: "dependsOn", identity: (value) => value },
-    {
-        field: "labels",
-        identity: (value) => (typeof value === "string" ? value.trim() : value),
-    },
-    { field: "references", identity: (value) => value },
-];
-/**
- * Tasks whose lists name nothing twice (anchrd/intel#318).
- *
- * ⚠️ `dependsOn`, `labels` and `references` are refused at the write boundary now, and that refusal
- * reaches nothing already in R2 — boards have been writable since `c29fd12` and `board_task_update`
- * took a repeat without complaint. A stored board carrying one would meet the strict `BoardTask` and
- * answer `board_unreadable`: the whole board lost over a value that has no reading, which is the
- * trap #311 walked into from the other side.
- *
- * ⚠️ Folded here and refused there, and the difference is not inconsistency — it is who is being
- * answered. A caller handed back a shorter list than it sent learns nothing and repeats itself; a
- * stored document has no caller to tell, and dropping the board instead would punish a reader for
- * what some writer did months ago.
- *
- * ⚠️ The FIRST mention keeps its place. Every surface draws these lists in the order they stand in.
- */
-function dedupedTaskLists(tasks) {
-    if (!Array.isArray(tasks))
-        return undefined;
-    let folded = false;
-    const next = tasks.map((task) => {
-        if (typeof task !== "object" || task === null)
-            return task;
-        const entry = task;
-        const lists = distinctTaskLists.flatMap(({ field, identity }) => {
-            const list = entry[field];
-            if (!Array.isArray(list))
-                return [];
-            const seen = new Set();
-            const distinct = list.filter((value) => {
-                const key = identity(value);
-                if (seen.has(key))
-                    return false;
-                seen.add(key);
-                return true;
-            });
-            return distinct.length === list.length ? [] : [[field, distinct]];
-        });
-        if (lists.length === 0)
-            return task;
-        folded = true;
-        return { ...entry, ...Object.fromEntries(lists) };
-    });
-    return folded ? next : undefined;
-}
-/**
- * A stored board brought up to the current schema, before it is validated.
- *
- * ⚠️ It runs before `BoardDocument.parse`, on `unknown`, because after that parse a missing field or
- * a repeated id is already a refusal — and `parseStoredBoard` is deliberately loud
- * (`board_unreadable`), so an un-upgraded board would not read as "old", it would read as corrupt.
- *
- * The upgrade is persisted by the next write of any kind, because every write serialises the whole
- * document. Nothing has to be migrated ahead of time and nothing has to be re-migrated.
- */
-export function upgradeStoredBoard(parsed) {
-    if (typeof parsed !== "object" || parsed === null)
-        return parsed;
-    const document = parsed;
-    const statuses = upgradedStatuses(document.statuses);
-    const tasks = dedupedTaskLists(document.tasks);
-    if (statuses === undefined && tasks === undefined)
-        return parsed;
-    return {
-        ...document,
-        ...(statuses !== undefined && { statuses }),
-        ...(tasks !== undefined && { tasks }),
-    };
-}
-/**
- * The first id a board document uses for two different things (anchrd/intel#321).
- *
- * ⚠️ Deliberately NOT a rule on `BoardDocument`, and that is the whole decision. A schema rule would
- * reach every parse of a stored body — `parseStoredBoard`, `indexing.ts`, the link reader — and a
- * board imported before this existed would stop answering with `board_unreadable`: the whole board
- * gone over something that costs one view. It is the trap #311 walked into, and #318 walked into
- * from the other side.
- *
- * ⚠️ And NOT folded in `upgradeStoredBoard` either, which is where the sibling rules of #318 went. A
- * repeated `dependsOn`, label or reference carries no information, so dropping the second mention
- * loses nothing. Two tasks under one id are two whole tasks — titles, dates, descriptions — and a
- * fold on the READ is written back by the next save of any kind, because every write serialises the
- * whole document. That is one task gone for good, for every board, without anybody having asked.
- * The UI folds the same pair for a DRAWING (`orderedTasks`), which costs nothing: the document keeps
- * both, and repairing the pair brings the second card back.
- *
- * ⚠️ What this does NOT rescue, and it is worth knowing: `replaced` matches a task by id, so the
- * first `board_task_update` against such a pair writes the SAME task into both entries. The stored
- * board is then two identical tasks rather than two different ones. That is a consequence of
- * addressing a board by task id at all (#285) and predates this rule; the reason the rule is at the
- * import is to stop the pair from existing, not to make it survivable.
- *
- * So it is asked exactly where there is a caller to answer: the bundle import, the one door a board
- * document written elsewhere comes in through. Everything else mints task ids itself (`deps.id()`)
- * and takes its status list through `ConfigureBoardInput`, which has demanded distinct ids since
- * #285.
- */
-export function repeatedBoardId(document) {
-    for (const list of ["statuses", "tasks"]) {
-        const seen = new Set();
-        for (const entry of document[list]) {
-            if (seen.has(entry.id))
-                return { list, id: entry.id };
-            seen.add(entry.id);
-        }
-    }
-    return null;
-}
-/**
- * Every board operation, applied to the document rather than to the file (#285).
- *
- * ⚠️ This module is where a board's rules live, and it is deliberately pure: it takes a document
- * and gives back the next one. The version, R2 and the retry against a racing write are the
- * service's business (`nodes.ts`), and the surfaces have no rules of their own — HTTP, MCP and the
- * UI all arrive here. A second implementation of "may this task depend on that one" is the thing
- * this shape exists to prevent.
- *
- * ⚠️ What it does NOT check is anything that needs the tree: whether a `references` id names a node
- * the writer may see, and whether an `agent` assignee is really an agent. Those are reads against
- * D1 and the ACL, so they happen in the service before the document is touched at all.
- */
-export function createBoard(deps) {
-    function byOrder(left, right) {
-        // The id breaks a tie that cannot happen: two keys are distinct by construction. It is here so
-        // the sort is total, because an unstable order would make two readers of the same board
-        // disagree about which card comes first.
-        if (left.order === right.order)
-            return left.id < right.id ? -1 : 1;
-        return left.order < right.order ? -1 : 1;
-    }
-    function sorted(tasks) {
-        return [...tasks].sort(byOrder);
-    }
-    function taskOf(board, taskId) {
-        const task = board.tasks.find((candidate) => candidate.id === taskId);
-        if (!task)
-            throw new IntelError(404, "board_task_not_found", "Task was not found");
-        return task;
-    }
-    function requireStatus(board, statusId) {
-        if (!board.statuses.some((status) => status.id === statusId)) {
-            throw new IntelError(422, "board_status_unknown", `This board has no status “${statusId}”`);
-        }
-    }
-    // The column a task lands in when nobody says otherwise: the first one that is not the shelf.
-    function firstOpenStatus(board) {
-        const open = [...board.statuses]
-            .sort((left, right) => left.order - right.order)
-            .find((status) => status.id !== ArchivedBoardStatusId);
-        if (!open) {
-            throw new IntelError(409, "board_status_unknown", "This board has no status a task could be added to");
-        }
-        return open.id;
-    }
-    function childrenOf(tasks) {
-        const children = new Map();
-        for (const task of tasks) {
-            const siblings = children.get(task.parentId);
-            if (siblings)
-                siblings.push(task);
-            else
-                children.set(task.parentId, [task]);
-        }
-        return children;
-    }
-    /**
-     * The task and everything under it, breadth first.
-     *
-     * ⚠️ The walk is bounded by the number of tasks rather than by the depth, so a board whose
-     * `parentId` chain somehow closed on itself — one written before the cycle check, or restored
-     * from a bundle — is counted once and does not spin here.
-     */
-    function withDescendants(tasks, rootId) {
-        const children = childrenOf(tasks);
-        const removed = new Set([rootId]);
-        const queue = [rootId];
-        for (let index = 0; index < queue.length; index += 1) {
-            const current = queue[index];
-            if (current === undefined)
-                continue;
-            for (const child of children.get(current) ?? []) {
-                if (removed.has(child.id))
-                    continue;
-                removed.add(child.id);
-                queue.push(child.id);
-            }
-        }
-        return removed;
-    }
-    function depthOf(tasks, taskId) {
-        let depth = 0;
-        let current = taskId;
-        const seen = new Set();
-        while (current !== null) {
-            if (seen.has(current))
-                break;
-            seen.add(current);
-            depth += 1;
-            current = tasks.find((task) => task.id === current)?.parentId ?? null;
-        }
-        return depth;
-    }
-    function heightOf(tasks, rootId) {
-        const children = childrenOf(tasks);
-        let height = 1;
-        let level = [rootId];
-        const seen = new Set(level);
-        while (level.length > 0) {
-            const next = [];
-            for (const id of level) {
-                for (const child of children.get(id) ?? []) {
-                    if (seen.has(child.id))
-                        continue;
-                    seen.add(child.id);
-                    next.push(child.id);
-                }
-            }
-            if (next.length > 0)
-                height += 1;
-            level = next;
-        }
-        return height;
-    }
-    /**
-     * Whether this task may hang under that parent (#285).
-     *
-     * ⚠️ Two refusals, not one, because they are two different mistakes. Hanging a task under its own
-     * descendant is a cycle — a subtree that has left the board without being deleted, invisible in
-     * every view. Hanging a legal subtree too deep is a bound: `BoardMaxTaskDepth` counts the whole
-     * chain, so moving an epic under another epic is measured with its own children, not as if it
-     * were a single card.
-     */
-    function requireParent(tasks, taskId, parentId) {
-        if (parentId === null)
-            return;
-        if (parentId === taskId) {
-            throw new IntelError(409, "board_parent_cycle", "A task cannot be its own parent");
-        }
-        if (!tasks.some((task) => task.id === parentId)) {
-            throw new IntelError(422, "board_parent_unknown", "The parent task is not on this board");
-        }
-        if (withDescendants(tasks, taskId).has(parentId)) {
-            throw new IntelError(409, "board_parent_cycle", "A task cannot be moved under one of its own subtasks");
-        }
-        const depth = depthOf(tasks, parentId) + heightOf(tasks, taskId);
-        if (depth > BoardMaxTaskDepth) {
-            throw new IntelError(422, "board_depth_exceeded", `Tasks nest at most ${BoardMaxTaskDepth} deep, and this would be ${depth}`);
-        }
-    }
-    /**
-     * Whether these dependencies exist here and describe no circle (#285).
-     *
-     * ⚠️ A dependency on a task this board does not hold is refused BECAUSE it might be a task in
-     * another board. Accepting it would hang this node on a file that can be edited, moved or deleted
-     * without anything here noticing — across boards the link is `references`, which names the board
-     * NODE and is a link the graph can see. "Unknown" and "in another board" are deliberately the same
-     * refusal: telling them apart would mean confirming that a task id exists somewhere the caller may
-     * have no access to.
-     *
-     * ⚠️ Own check, run over the whole graph and separate from the `parentId` walk. The two describe
-     * different things — where a card sits and what it waits for — and a subtask that waits for its
-     * own epic is legal in one and would be a cycle in the other.
-     */
-    function requireDependencies(tasks, taskId) {
-        const byId = new Map(tasks.map((task) => [task.id, task]));
-        for (const task of tasks) {
-            for (const dependency of task.dependsOn) {
-                if (!byId.has(dependency)) {
-                    throw new IntelError(422, "board_dependency_unknown", `A task can only depend on a task of the same board, and “${dependency}” is not one`);
-                }
-            }
-        }
-        // Depth-first from the changed task alone: everything else was acyclic before this write, so a
-        // circle that exists now has to run through the one task that changed.
-        const stack = [taskId];
-        const path = new Set();
-        const done = new Set();
-        const visit = (id) => {
-            if (done.has(id))
-                return;
-            if (path.has(id)) {
-                throw new IntelError(409, "board_dependency_cycle", "These dependencies would wait for each other in a circle");
-            }
-            path.add(id);
-            for (const dependency of byId.get(id)?.dependsOn ?? [])
-                visit(dependency);
-            path.delete(id);
-            done.add(id);
-        };
-        for (const id of stack)
-            visit(id);
-    }
-    /**
-     * The order key for a task's new place.
-     *
-     * ⚠️ Neighbours are read from the board's ONE key space rather than from the target column. A key
-     * minted between two cards is between them globally, and a filtered view of a sorted list is still
-     * sorted, so a column shows exactly what the caller asked for while no second key space has to be
-     * kept in step with the first.
-     *
-     * With no neighbour named, the task goes last in the column it is landing in — which is what
-     * "add a task" means without further instruction, and what a drop onto an empty column means.
-     */
-    function placementKey(board, placement, movingTaskId) {
-        const others = sorted(board.tasks.filter((task) => task.id !== movingTaskId));
-        const indexOf = (taskId) => {
-            const index = others.findIndex((task) => task.id === taskId);
-            if (index < 0) {
-                throw new IntelError(422, "board_neighbour_unknown", "The neighbour task is not on this board");
-            }
-            return index;
-        };
-        let afterIndex = placement.afterTaskId === null ? null : indexOf(placement.afterTaskId);
-        const beforeIndex = placement.beforeTaskId === null ? null : indexOf(placement.beforeTaskId);
-        if (afterIndex !== null && beforeIndex !== null && afterIndex >= beforeIndex) {
-            throw new IntelError(400, "board_neighbour_order", "The task named as the predecessor does not come before the one named as the successor");
-        }
-        if (afterIndex === null && beforeIndex === null) {
-            const column = others.filter((task) => task.status === placement.status && task.parentId === placement.parentId);
-            const last = column.at(-1);
-            if (!last)
-                return generateKeyBetween(others.at(-1)?.order ?? null, null);
-            afterIndex = others.indexOf(last);
-        }
-        const lower = afterIndex === null ? null : (others[afterIndex]?.order ?? null);
-        const upper = beforeIndex !== null
-            ? (others[beforeIndex]?.order ?? null)
-            : afterIndex !== null
-                ? (others[afterIndex + 1]?.order ?? null)
-                : null;
-        return generateKeyBetween(lower, upper);
-    }
-    function replaced(board, task) {
-        return {
-            statuses: board.statuses,
-            tasks: board.tasks.map((candidate) => (candidate.id === task.id ? task : candidate)),
-        };
-    }
-    return {
-        defaultBoard() {
-            return { statuses: [...BoardDefaultStatuses], tasks: [] };
-        },
-        /**
-         * The status list, written whole.
-         *
-         * ⚠️ `archived` is asserted here as well as at the boundary, and that is not the usual
-         * duplication. It is the rule the whole "sweep it away instead of deleting it" promise rests
-         * on, and a board that lost its shelf cannot be repaired by the caller who lost it — every task
-         * sitting there would point at a status that no longer exists.
-         *
-         * ⚠️ A status that tasks still sit in cannot be dropped. The alternative — moving those tasks
-         * somewhere — is a decision about somebody's work, and this call is not the place to make it
-         * silently.
-         */
-        configure(board, statuses) {
-            if (!statuses.some((status) => status.id === ArchivedBoardStatusId)) {
-                throw new IntelError(422, "board_status_archived_required", `The “${ArchivedBoardStatusId}” status cannot be removed`);
-            }
-            const kept = new Set(statuses.map((status) => status.id));
-            const orphaned = board.tasks.find((task) => !kept.has(task.status));
-            if (orphaned) {
-                throw new IntelError(409, "board_status_in_use", `Tasks still sit in “${orphaned.status}”, so it cannot be removed`);
-            }
-            const next = statuses.map((status, index) => ({
-                id: status.id,
-                label: status.label,
-                order: index,
-                // ⚠️ The shelf is always terminal and the boundary refuses an explicit `false` for it, so
-                // this is not a silent correction of something a caller asked for — it is the same fact
-                // stated where the document is built. Everything else defaults to "not finished": a new
-                // column is work, and a column that ends work is a thing somebody says on purpose (#311).
-                terminal: status.id === ArchivedBoardStatusId ? true : (status.terminal ?? false),
-            }));
-            return { statuses: next, tasks: board.tasks };
-        },
-        addTask(board, input) {
-            if (board.tasks.length >= 5_000) {
-                throw new IntelError(409, "board_task_limit", "This board holds as many tasks as it can");
-            }
-            const status = input.status ?? firstOpenStatus(board);
-            requireStatus(board, status);
-            const task = {
-                id: deps.id(),
-                title: input.title,
-                status,
-                assignee: input.assignee,
-                labels: input.labels,
-                startDate: input.startDate,
-                dueDate: input.dueDate,
-                parentId: input.parentId,
-                dependsOn: input.dependsOn,
-                order: placementKey(board, {
-                    status,
-                    parentId: input.parentId,
-                    afterTaskId: input.afterTaskId,
-                    beforeTaskId: input.beforeTaskId,
-                }, null),
-                description: input.description,
-                references: input.references,
-            };
-            const tasks = [...board.tasks, task];
-            requireParent(tasks, task.id, task.parentId);
-            requireDependencies(tasks, task.id);
-            return { board: { statuses: board.statuses, tasks }, task };
-        },
-        updateTask(board, input) {
-            const current = taskOf(board, input.taskId);
-            const task = {
-                ...current,
-                ...(input.title !== undefined && { title: input.title }),
-                ...(input.assignee !== undefined && { assignee: input.assignee }),
-                ...(input.labels !== undefined && { labels: input.labels }),
-                ...(input.startDate !== undefined && { startDate: input.startDate }),
-                ...(input.dueDate !== undefined && { dueDate: input.dueDate }),
-                ...(input.dependsOn !== undefined && { dependsOn: input.dependsOn }),
-                ...(input.description !== undefined && { description: input.description }),
-                ...(input.references !== undefined && { references: input.references }),
-            };
-            const next = replaced(board, task);
-            requireDependencies(next.tasks, task.id);
-            return { board: next, task };
-        },
-        moveTask(board, input) {
-            const current = taskOf(board, input.taskId);
-            const status = input.status ?? current.status;
-            requireStatus(board, status);
-            const parentId = input.parentId === undefined ? current.parentId : input.parentId;
-            // The parent is checked against the board as it stands, before the order key is minted: a
-            // refused move must not have spent one, and `placementKey` is the only step that cannot be
-            // undone by simply not returning the document.
-            requireParent(board.tasks, current.id, parentId);
-            const task = {
-                ...current,
-                status,
-                parentId,
-                order: placementKey(board, {
-                    status,
-                    parentId,
-                    afterTaskId: input.afterTaskId,
-                    beforeTaskId: input.beforeTaskId,
-                }, current.id),
-            };
-            return { board: replaced(board, task), task };
-        },
-        /**
-         * The task and everything under it (#285).
-         *
-         * ⚠️ Deleting cascades rather than orphaning: a subtask whose epic is gone has no place on any
-         * board, and leaving it behind under a `parentId` that names nothing is a card no view can file.
-         * The count comes back so a surface can say what it is about to do.
-         *
-         * ⚠️ The dependencies of what survives are cleaned up in the same act. A `dependsOn` pointing at
-         * a deleted task is an edge to nothing — it would draw a line into empty space in the graph view
-         * and make a task wait forever for something that cannot happen.
-         */
-        deleteTask(board, taskId) {
-            taskOf(board, taskId);
-            const removed = withDescendants(board.tasks, taskId);
-            const tasks = board.tasks
-                .filter((task) => !removed.has(task.id))
-                .map((task) => {
-                const dependsOn = task.dependsOn.filter((dependency) => !removed.has(dependency));
-                return dependsOn.length === task.dependsOn.length ? task : { ...task, dependsOn };
-            });
-            return { board: { statuses: board.statuses, tasks }, deleted: removed.size };
-        },
-        sorted,
-    };
-}

package/dist/nodes/board/board.types.d.ts

@@ -1,31 +0,0 @@
-import type { AddBoardTaskInput, BoardDocument, BoardStatusInput, BoardTask, MoveBoardTaskInput, UpdateBoardTaskInput } from "@anchrd/intel-contract";
-export interface BoardDeps {
-    id(): string;
-}
-export interface BoardPlacement {
-    status: string;
-    parentId: string | null;
-    afterTaskId: string | null;
-    beforeTaskId: string | null;
-}
-export interface BoardOperations {
-    defaultBoard(): BoardDocument;
-    configure(board: BoardDocument, statuses: BoardStatusInput[]): BoardDocument;
-    addTask(board: BoardDocument, input: AddBoardTaskInput): {
-        board: BoardDocument;
-        task: BoardTask;
-    };
-    updateTask(board: BoardDocument, input: UpdateBoardTaskInput): {
-        board: BoardDocument;
-        task: BoardTask;
-    };
-    moveTask(board: BoardDocument, input: MoveBoardTaskInput): {
-        board: BoardDocument;
-        task: BoardTask;
-    };
-    deleteTask(board: BoardDocument, taskId: string): {
-        board: BoardDocument;
-        deleted: number;
-    };
-    sorted(tasks: readonly BoardTask[]): BoardTask[];
-}

package/dist/nodes/board/board.types.js

@@ -1 +0,0 @@
-export {};

package/migrations/0013_agents_in_the_tree.sql

@@ -1,76 +0,0 @@
--- #139: a fifth kind in the shared tree — `agent`. It is a node like the other four: same
--- `parent_id`, same folder grants, same immutable `node_versions` rows, same R2 body (ADR-0005 §1).
--- Its body happens to be a JSON definition rather than prose, which the schema neither knows nor
--- needs to: nothing here creates a second content model, only the CHECK has to learn the word.
---
--- SQLite cannot alter a CHECK constraint, so the table is rebuilt — the same rebuild 0005 performed
--- for `table`, written the same long way round for the same two reasons. Both detours below are
--- copied from a file that earned them against a real database, not from caution.
---
--- ⚠️ First detour: the new table is created under the final name rather than built beside the old
--- one and renamed over it. `DROP TABLE` on a parent runs an implicit `DELETE FROM` first, so the
--- moment the old `nodes` goes, every row of `node_versions`, `tree_grants` and `flows` pointing at a
--- node is a foreign-key violation. `defer_foreign_keys` postpones the complaint to COMMIT but does
--- not withdraw it, and `ALTER TABLE ... RENAME` does not settle it either: a rename puts the name
--- back, not the rows. Only inserting the nodes again, under the name the children have referenced
--- all along, does. This is also why the self-reference below reads `REFERENCES nodes(id)` — the
--- final name — which is lesson 2 of the three recorded in `0009_no_context_policy.sql`.
---
--- ⚠️ Second detour: `node_links` is the only child of `nodes` declared ON DELETE CASCADE, so that
--- same implicit delete does not merely flag its rows, it removes them — the migration would commit
--- with every relationship between two documents quietly gone. The rows are carried out of the way
--- first and put back afterwards. That is a rescue, not a decision about the data: nothing is
--- dropped, rewritten or reinterpreted here.
---
--- ⚠️ On an empty database neither detour is visible, because nothing points at anything. That is
--- exactly how 0005's first version passed a green suite and then failed against the first database
--- with content in it, and why the proof for this file is a row count of every referencing table
--- before and after rather than a migration that merely ran.
---
--- `context_policy` is carried over unchanged and still NOT NULL. It is dead for every consumer
--- (#76) and only D1's refusal to drop a column a CHECK names keeps it here; removing it is #86 and
--- deliberately not smuggled into this rebuild.
-PRAGMA defer_foreign_keys = TRUE;
-
--- Plain holding tables on purpose: no keys, no CHECKs, no foreign keys, and the column set taken
--- from whatever the live table has. Anything enforced here would only be enforced a second time on
--- the way back in, and a holding table that can reject a row is a holding table that can lose one.
-CREATE TABLE nodes_carry AS SELECT * FROM nodes;
-CREATE TABLE node_links_carry AS SELECT * FROM node_links;
-
-DROP TABLE nodes;
-
-CREATE TABLE nodes (
-  id TEXT PRIMARY KEY NOT NULL,
-  parent_id TEXT REFERENCES nodes(id),
-  kind TEXT NOT NULL CHECK (kind IN ('folder', 'document', 'attachment', 'table', 'agent')),
-  title TEXT NOT NULL CHECK (length(title) BETWEEN 1 AND 240),
-  description TEXT CHECK (description IS NULL OR length(description) <= 2000),
-  context_policy TEXT NOT NULL CHECK (context_policy IN ('pinned', 'relevant', 'explicit')),
-  owner_id TEXT NOT NULL,
-  current_version_id TEXT,
-  created_at TEXT NOT NULL,
-  updated_at TEXT NOT NULL,
-  archived_at TEXT
-);
-
-INSERT INTO nodes (
-  id, parent_id, kind, title, description, context_policy, owner_id,
-  current_version_id, created_at, updated_at, archived_at
-)
-SELECT
-  id, parent_id, kind, title, description, context_policy, owner_id,
-  current_version_id, created_at, updated_at, archived_at
-FROM nodes_carry;
-
--- `OR IGNORE` because whether the cascade above actually fired is SQLite's business, not this
--- migration's: if it did, this puts the rows back; if it did not, each one is already present under
--- the same primary key and this is a no-op. Either way `node_links` ends up holding exactly what it
--- held before, which is the only outcome this statement is permitted to have.
-INSERT OR IGNORE INTO node_links SELECT * FROM node_links_carry;
-
-DROP TABLE nodes_carry;
-DROP TABLE node_links_carry;
-
-CREATE INDEX nodes_parent_idx ON nodes(parent_id, archived_at, title);
-CREATE INDEX nodes_owner_idx ON nodes(owner_id, archived_at);

package/migrations/0014_agent_applications.sql

@@ -1,25 +0,0 @@
--- #182: which Gate Application an agent node runs as. One row per agent that has a principal, and
--- nothing else — the row is a NAME, never a credential.
---
--- ⚠️ The Application KEY has no column here and must never get one (D27). Gate hands a key out once
--- in plain text and keeps only its hash, so there is nothing to store even in principle; the key
--- lives in the runtime's `AGENT_APPLICATION_KEYS` secret and reaches it through the one response
--- that created the agent. A column for it would turn every backup of this database into a set of
--- machine credentials.
---
--- ⚠️ A table rather than a column on `nodes`, for two reasons. The column would be NULL for every
--- folder, document, attachment and table there will ever be, which is a shape that says nothing
--- about four of the five kinds; and adding it would mean rebuilding `nodes` — SQLite cannot alter
--- a table a CHECK constrains — with the two detours `0013_agents_in_the_tree.sql` records. This
--- file writes one new table and touches nothing that exists.
---
--- ⚠️ Deliberately NOT `ON DELETE CASCADE`, unlike `node_links`. Migration 0013 explains what that
--- one cascade cost the rebuild it had to survive: an implicit `DELETE FROM` on the parent removed
--- its rows outright rather than merely flagging them, and they had to be carried out of the way and
--- put back. A second cascading child would hand the next rebuild the same trap twice. Nodes are
--- archived, never deleted, so nothing is being kept alive by leaving the cascade off.
-CREATE TABLE agent_applications (
-  node_id TEXT PRIMARY KEY NOT NULL REFERENCES nodes(id),
-  application_id TEXT NOT NULL,
-  created_at TEXT NOT NULL
-);