@astrosheep/keiyaku 2.9.13 → 4.0.1

package/build/core/task/compose.js

@@ -1,328 +0,0 @@
-import { FlowError } from "../../flow-error.js";
-import { taskIdentifierSlug, IdentifierSlugError } from "../identifier-slug.js";
-import { buildTaskBoardFromDocuments, requireHealthy, resolveTaskId } from "./board.js";
-import { formatTaskCoordinate, parseTaskCoordinate } from "./coordinate.js";
-import { advancedTaskUpdatedAt } from "./model.js";
-function atLine(line, message) {
-    throw new FlowError("INVALID_TARGET", `task compose line ${line}: ${message}`);
-}
-function parseRelationValues(line, field, value) {
-    if (value === "")
-        return [];
-    const values = value.split(",");
-    const references = values.map((entry) => {
-        if (!entry.startsWith("@"))
-            atLine(line, `${field}= accepts comma-separated @COORDINATE references or an explicit empty assignment`);
-        try {
-            return parseTaskCoordinate(entry.slice(1), `${field} coordinate`).coordinate;
-        }
-        catch (error) {
-            if (error instanceof FlowError)
-                atLine(line, `${field}= accepts comma-separated @COORDINATE references or an explicit empty assignment`);
-            throw error;
-        }
-    });
-    if (new Set(references).size !== references.length)
-        atLine(line, `${field}= cannot repeat a coordinate`);
-    return references;
-}
-function parseAssignments(line, tokens) {
-    let clearParent = false;
-    const relations = {};
-    const declared = new Set();
-    for (const token of tokens) {
-        const match = /^(parent|needs|supersedes|relates)=(.*)$/.exec(token);
-        if (!match)
-            atLine(line, "inline declarations must use parent=, needs=, supersedes=, or relates=");
-        const field = match[1];
-        const value = match[2];
-        if (declared.has(field))
-            atLine(line, `${field}= may appear only once`);
-        declared.add(field);
-        if (field === "parent") {
-            if (value !== "")
-                atLine(line, "parent= only clears the parent; use nesting to assign one");
-            clearParent = true;
-        }
-        else {
-            relations[field] = parseRelationValues(line, field, value);
-        }
-    }
-    return { clearParent, relations };
-}
-function declarationTokens(line, content, kind) {
-    if (/\[(?:parent|needs|supersedes|relates)=/.test(content)) {
-        atLine(line, "inline declarations use whitespace-separated field=value tokens, not brackets");
-    }
-    if (kind === "@") {
-        const [reference, ...assignments] = content.slice(1).split(/\s+/);
-        if (!reference)
-            atLine(line, "task references must be exactly @COORDINATE followed only by inline declarations");
-        return { reference, ...parseAssignments(line, assignments) };
-    }
-    const source = content.slice(1).trim();
-    if (!source)
-        atLine(line, "+ must be followed by a task title");
-    const tokens = source.split(/\s+/);
-    const assignmentStart = tokens.findIndex((token) => token.includes("="));
-    const titleTokens = assignmentStart === -1 ? tokens : tokens.slice(0, assignmentStart);
-    if (titleTokens.length === 0)
-        atLine(line, "+ must be followed by a task title");
-    const assignments = assignmentStart === -1 ? [] : tokens.slice(assignmentStart);
-    return { title: titleTokens.join(" "), ...parseAssignments(line, assignments) };
-}
-export function parseTaskCompositionSketch(input) {
-    if (!input.trim())
-        throw new FlowError("EMPTY_PARAM", "task compose sketch cannot be blank");
-    const nodes = [];
-    const taskAtDepth = new Map();
-    let pendingBodyBlanks;
-    let activeBody;
-    for (const [offset, raw] of input.split(/\r?\n/).entries()) {
-        const line = offset + 1;
-        if (/\t/.test(raw))
-            atLine(line, "uses spaces only; indentation is two spaces per tree level");
-        const indent = /^( *)/.exec(raw)[1].length;
-        if (indent % 2 !== 0)
-            atLine(line, "indentation must use whole two-space levels");
-        const content = raw.slice(indent).trimEnd();
-        const depth = indent / 2;
-        if (!content) {
-            if (activeBody) {
-                if (pendingBodyBlanks?.parent === activeBody)
-                    pendingBodyBlanks.count += 1;
-                else
-                    pendingBodyBlanks = { parent: activeBody, count: 1 };
-            }
-            else {
-                pendingBodyBlanks = undefined;
-            }
-            continue;
-        }
-        if (!content.startsWith("+") && !content.startsWith("@")) {
-            const parentDepth = [...taskAtDepth.keys()].filter((candidate) => candidate < depth).sort((a, b) => b - a)[0];
-            const parent = parentDepth === undefined ? undefined : taskAtDepth.get(parentDepth);
-            if (!parent?.title)
-                atLine(line, "bare prose is allowed only inside a new + task body");
-            if (pendingBodyBlanks?.parent === parent)
-                parent.body.push(...Array(pendingBodyBlanks.count).fill(""));
-            pendingBodyBlanks = undefined;
-            parent.body.push(raw.slice((parent.depth + 1) * 2));
-            activeBody = parent;
-            continue;
-        }
-        pendingBodyBlanks = undefined;
-        activeBody = undefined;
-        const kind = content.startsWith("+") ? "+" : "@";
-        const parsed = declarationTokens(line, content, kind);
-        for (const existingDepth of [...taskAtDepth.keys()])
-            if (existingDepth >= depth)
-                taskAtDepth.delete(existingDepth);
-        if (depth > 0 && !taskAtDepth.has(depth - 1))
-            atLine(line, "cannot indent below a missing parent task line");
-        const node = { line, depth, body: [], ...parsed };
-        nodes.push(node);
-        taskAtDepth.set(depth, node);
-    }
-    if (nodes.length === 0)
-        throw new FlowError("EMPTY_PARAM", "task compose sketch cannot be blank");
-    return nodes;
-}
-function requireHealthyFinalCompositionBoard(board, lines) {
-    const disease = board.diseases[0];
-    if (!disease)
-        return;
-    const coordinate = [disease.id, ...(disease.relatedIds ?? [])].find((candidate) => candidate !== undefined && lines.has(candidate));
-    if (coordinate !== undefined)
-        atLine(lines.get(coordinate), disease.message);
-    requireHealthy(board);
-}
-function documentFromView(task) {
-    return {
-        id: task.id, namespace: task.namespace, coordinate: task.coordinate, title: task.title,
-        state: task.state, pri: task.pri, needs: [...task.needs], parent: task.parent,
-        from: [...task.from], supersedes: [...task.supersedes], relatesTo: [...task.relatesTo],
-        notes: task.notes.map((note) => ({ ...note })),
-        createdAt: task.createdAt, ...(task.updatedAt === undefined ? {} : { updatedAt: task.updatedAt }),
-        creator: task.creator, ...(task.startedAt === undefined ? {} : { startedAt: task.startedAt }),
-        ...(task.contractId === undefined ? {} : { contractId: task.contractId }), body: task.body,
-    };
-}
-function allocateCoordinate(title, namespace, occupied, line) {
-    for (let ordinal = 1; Number.isSafeInteger(ordinal); ordinal += 1) {
-        try {
-            const localId = taskIdentifierSlug(title, ordinal === 1 ? "" : `-${ordinal}`);
-            const coordinate = formatTaskCoordinate(namespace, localId);
-            if (!occupied.has(coordinate))
-                return coordinate;
-        }
-        catch (error) {
-            if (error instanceof IdentifierSlugError)
-                atLine(line, `task title ${error.message}`);
-            throw error;
-        }
-    }
-    throw new FlowError("INTERNAL_STATE", "task compose allocation exceeded the safe integer range");
-}
-function same(left, right) {
-    return left.length === right.length && left.every((value, index) => value === right[index]);
-}
-function resolvedRelations(board, node) {
-    const result = {};
-    for (const [name, values] of Object.entries(node.relations)) {
-        try {
-            const resolved = values.map((value) => resolveTaskId(board, value));
-            if (new Set(resolved).size !== resolved.length)
-                atLine(node.line, `${name}= resolves the same coordinate more than once`);
-            result[name] = resolved;
-        }
-        catch (error) {
-            if (error instanceof FlowError)
-                atLine(node.line, error.message);
-            throw error;
-        }
-    }
-    return result;
-}
-/** Build the composition entirely from one board observation. Persistence is caller-owned. */
-export function planTaskComposition(board, input) {
-    requireHealthy(board);
-    const now = input.now();
-    const parsed = parseTaskCompositionSketch(input.sketch);
-    const occupied = new Set(board.byId.keys());
-    const resolved = [];
-    const declared = new Set();
-    const allocations = [];
-    const parents = new Map();
-    for (const node of parsed) {
-        if (node.depth > 0 && !parents.has(node.depth - 1))
-            atLine(node.line, "cannot indent below a missing parent line");
-        for (const depth of [...parents.keys()])
-            if (depth >= node.depth)
-                parents.delete(depth);
-        let coordinate;
-        let existing;
-        if (node.reference) {
-            try {
-                coordinate = resolveTaskId(board, node.reference);
-            }
-            catch (error) {
-                if (error instanceof FlowError)
-                    atLine(node.line, error.message);
-                throw error;
-            }
-            existing = board.byId.get(coordinate);
-        }
-        else {
-            coordinate = allocateCoordinate(node.title, input.namespace, occupied, node.line);
-            occupied.add(coordinate);
-            allocations.push({ title: node.title, coordinate });
-        }
-        if (declared.has(coordinate))
-            atLine(node.line, `task ${coordinate} is declared more than once`);
-        declared.add(coordinate);
-        const parent = node.depth > 0 ? parents.get(node.depth - 1) : node.clearParent ? null : undefined;
-        if (node.depth > 0 && node.clearParent)
-            atLine(node.line, "cannot combine nesting with parent=");
-        if (parent === coordinate)
-            atLine(node.line, `task ${coordinate} cannot be its own parent`);
-        if (parent && (board.byId.get(parent)?.state === "done" || board.byId.get(parent)?.state === "drop")) {
-            atLine(node.line, `terminal task ${parent} cannot be a parent target`);
-        }
-        resolved.push({ ...node, coordinate, existing, parent });
-        parents.set(node.depth, coordinate);
-    }
-    const relationBoard = { ...board, byId: new Map(board.byId) };
-    for (const allocation of allocations) {
-        const [namespace, id] = allocation.coordinate.includes("/") ? allocation.coordinate.split("/") : [null, allocation.coordinate];
-        const node = resolved.find((entry) => entry.coordinate === allocation.coordinate);
-        const document = { id, namespace, coordinate: allocation.coordinate, title: allocation.title, state: "open", pri: 2, needs: [], parent: null, from: [], supersedes: [], relatesTo: [], notes: [], createdAt: now.toISOString(), updatedAt: now.toISOString(), creator: input.creator, body: node.body.join("\n") };
-        relationBoard.byId.set(allocation.coordinate, { ...document, namespace, coordinate: allocation.coordinate, blocks: [], blocked: false, releasedNeeds: [], supersededBy: [], relatedTasks: [] });
-    }
-    const replacements = [];
-    const deltas = [];
-    for (const node of resolved) {
-        const current = node.existing;
-        const document = current ? documentFromView(current) : (() => {
-            const allocation = allocations.find((entry) => entry.coordinate === node.coordinate);
-            const [namespace, id] = node.coordinate.includes("/") ? node.coordinate.split("/") : [null, node.coordinate];
-            const timestamp = now.toISOString();
-            return { id, namespace, coordinate: node.coordinate, title: allocation.title, state: "open", pri: 2, needs: [], parent: null, from: [], supersedes: [], relatesTo: [], notes: [], createdAt: timestamp, updatedAt: timestamp, creator: input.creator, body: node.body.join("\n") };
-        })();
-        if (node.parent !== undefined)
-            document.parent = node.parent;
-        const relations = resolvedRelations(relationBoard, node);
-        if (relations.needs !== undefined) {
-            for (const target of relations.needs) {
-                const targetTask = relationBoard.byId.get(target);
-                if (targetTask?.state === "done" || targetTask?.state === "drop")
-                    atLine(node.line, `terminal task ${target} cannot be a needs target`);
-            }
-            if (relations.needs.includes(document.coordinate))
-                atLine(node.line, `task ${document.coordinate} needs must not reference itself`);
-            document.needs = relations.needs;
-        }
-        if (relations.supersedes !== undefined) {
-            if (relations.supersedes.includes(document.coordinate))
-                atLine(node.line, `task ${document.coordinate} supersedes must not reference itself`);
-            document.supersedes = relations.supersedes;
-        }
-        if (relations.relates !== undefined) {
-            if (relations.relates.includes(document.coordinate))
-                atLine(node.line, `task ${document.coordinate} relations must not reference itself`);
-            document.relatesTo = relations.relates;
-        }
-        if (document.relatesTo.includes(document.coordinate))
-            atLine(node.line, `task ${document.coordinate} relations must not reference itself`);
-        const before = current;
-        const delta = { coordinate: node.coordinate, allocated: !current };
-        if (!before || before.parent !== document.parent)
-            delta.parent = { before: before?.parent ?? null, after: document.parent };
-        if (!before || !same(before.needs, document.needs))
-            delta.needs = { before: before?.needs ?? [], after: document.needs };
-        if (!before || !same(before.supersedes, document.supersedes))
-            delta.supersedes = { before: before?.supersedes ?? [], after: document.supersedes };
-        if (!before || !same(before.relatesTo, document.relatesTo))
-            delta.relatesTo = { before: before?.relatesTo ?? [], after: document.relatesTo };
-        if (Object.keys(delta).length > 2) {
-            if (input.namespace !== null && current && current.namespace !== input.namespace) {
-                atLine(node.line, `task ${node.coordinate} is outside compose namespace ${input.namespace}`);
-            }
-            if (current)
-                document.updatedAt = advancedTaskUpdatedAt(current, input.now());
-            replacements.push(document);
-            deltas.push(delta);
-        }
-    }
-    if (replacements.length === 0)
-        throw new FlowError("EMPTY_PARAM", "task compose sketch makes no changes");
-    const replacementByCoordinate = new Map(replacements.map((document) => [document.coordinate, document]));
-    const finalBoard = buildTaskBoardFromDocuments(board.tasks.map((task) => replacementByCoordinate.get(task.coordinate) ?? documentFromView(task)).concat(replacements.filter((document) => !board.byId.has(document.coordinate))));
-    const mentioned = new Set(resolved.map((node) => node.coordinate));
-    requireHealthyFinalCompositionBoard(finalBoard, new Map(resolved.map((node) => [node.coordinate, node.line])));
-    const warnings = [];
-    for (const task of board.tasks) {
-        if (mentioned.has(task.coordinate))
-            continue;
-        for (const target of [...task.needs, ...(task.parent ? [task.parent] : []), ...task.supersedes, ...task.relatesTo]) {
-            if (mentioned.has(target))
-                warnings.push({ kind: "external_inbound", coordinate: target, related: task.coordinate });
-        }
-    }
-    for (const node of resolved) {
-        const task = finalBoard.byId.get(node.coordinate);
-        for (const target of task.supersedes) {
-            if (finalBoard.byId.get(target)?.state === "open")
-                warnings.push({ kind: "open_superseded", coordinate: task.coordinate, related: target });
-        }
-        if (task.contractId)
-            warnings.push({ kind: "bound_task", coordinate: task.coordinate, related: task.contractId });
-    }
-    return { allocations, replacements, deltas, warnings };
-}
-export async function composeTasks(repository, input) {
-    return repository.mutate((board) => {
-        const plan = planTaskComposition(board, input);
-        return { replacements: plan.replacements, subject: "Compose tasks", requireCommit: true, select: () => plan };
-    });
-}

package/build/core/task/coordinate.js

@@ -1,56 +0,0 @@
-import { FlowError } from "../../flow-error.js";
-import { isNormalizedIdentifierSlug } from "../identifier-slug.js";
-import { taskIdentifierSlug } from "../identifier-slug.js";
-export function formatTaskCoordinate(namespace, localId) {
-    return namespace === null ? localId : `${namespace}/${localId}`;
-}
-export function parseTaskCoordinate(value, field = "task coordinate") {
-    const parts = value.split("/");
-    if (parts.length < 1 || parts.length > 2) {
-        throw new FlowError("INVALID_TARGET", `${field} must be <local-id> or <namespace>/<local-id>`);
-    }
-    const namespace = parts.length === 1 ? null : parts[0];
-    const localId = parts.at(-1);
-    if (!isNormalizedIdentifierSlug(localId) || (namespace !== null && !isNormalizedIdentifierSlug(namespace))) {
-        throw new FlowError("INVALID_TARGET", `${field} must be <local-id> or <namespace>/<local-id>`);
-    }
-    return { namespace, localId, coordinate: formatTaskCoordinate(namespace, localId) };
-}
-export function isTaskCoordinate(value) {
-    try {
-        parseTaskCoordinate(value);
-        return true;
-    }
-    catch {
-        return false;
-    }
-}
-export function taskCoordinateFromSourcePath(sourcePath) {
-    const normalized = sourcePath.replaceAll("\\", "/");
-    const marker = "/.keiyaku/tasks/";
-    const markerIndex = normalized.lastIndexOf(marker);
-    const relative = markerIndex < 0 ? normalized : normalized.slice(markerIndex + marker.length);
-    if (!relative.endsWith(".md")) {
-        throw new FlowError("INVALID_TARGET", `task source must be a Markdown file below .keiyaku/tasks: ${sourcePath}`);
-    }
-    return parseTaskCoordinate(relative.slice(0, -3), "task source coordinate");
-}
-export const TASK_NAMESPACE_SCOPE_PREFIX = ".keiyaku/tasks/";
-export function taskNamespaceScope(namespace) {
-    parseTaskCoordinate(`${namespace}/task`, "task namespace");
-    return `${TASK_NAMESPACE_SCOPE_PREFIX}${namespace}/**`;
-}
-export function taskNamespaceFromScope(term) {
-    const match = /^\.keiyaku\/tasks\/([^/]+)\/\*\*$/.exec(term);
-    if (!match || !isNormalizedIdentifierSlug(match[1]))
-        return undefined;
-    return match[1];
-}
-export function allocateTaskNamespace(title, occupied) {
-    for (let ordinal = 1; Number.isSafeInteger(ordinal); ordinal += 1) {
-        const candidate = taskIdentifierSlug(title, ordinal === 1 ? "" : `-${ordinal}`);
-        if (!occupied.has(candidate))
-            return candidate;
-    }
-    throw new FlowError("INTERNAL_STATE", "task namespace collision ordinal exceeded the safe integer range");
-}

package/build/core/task/document.js

@@ -1,273 +0,0 @@
-import { isAlias, isMap, isScalar, isSeq, parseDocument, stringify, } from "yaml";
-import { canonicalTimestamp, fullId, isTaskId, invalid, nonblank, TASK_STATES, } from "./validation.js";
-const FIELD_ORDER = [
-    "id",
-    "title",
-    "state",
-    "pri",
-    "needs",
-    "parent",
-    "from",
-    "supersedes",
-    "relatesTo",
-    "notes",
-    "createdAt",
-    "updatedAt",
-    "creator",
-    "startedAt",
-    "contractId",
-];
-const FIELD_SET = new Set(FIELD_ORDER);
-const CREATION_INPUT_FIELDS = new Set([
-    "title", "pri", "needs", "parent", "from", "supersedes", "relatesTo",
-]);
-function validateNode(node) {
-    if (node == null)
-        return;
-    if (isAlias(node))
-        invalid("task front matter must not contain aliases");
-    if ("anchor" in node && node.anchor)
-        invalid("task front matter must not contain anchors");
-    if ("tag" in node && node.tag)
-        invalid("task front matter must not contain explicit tags");
-    if (isMap(node)) {
-        for (const item of node.items) {
-            const pair = item;
-            validateNode(pair.key);
-            validateNode(pair.value);
-        }
-    }
-    else if (isSeq(node)) {
-        for (const item of node.items)
-            validateNode(item);
-    }
-    else if (!isScalar(node)) {
-        invalid("task front matter contains an unsupported YAML node");
-    }
-}
-function frontMatter(source) {
-    if (!source.text.startsWith("---\n") && !source.text.startsWith("---\r\n")) {
-        invalid("task document must begin with exactly one '---' front matter block");
-    }
-    const lines = source.text.split(/\r?\n/);
-    let closing = -1;
-    for (let index = 1; index < lines.length; index += 1) {
-        if (lines[index] === "---") {
-            closing = index;
-            break;
-        }
-    }
-    if (closing < 0)
-        invalid("task document front matter is not closed");
-    return {
-        yaml: lines.slice(1, closing).join("\n"),
-        body: lines.slice(closing + 1).join("\n"),
-    };
-}
-function parseTaskSource(source) {
-    const split = frontMatter(source);
-    const parsed = parseDocument(split.yaml, {
-        merge: false,
-        prettyErrors: false,
-        strict: true,
-        uniqueKeys: true,
-    });
-    if (parsed.errors.length > 0) {
-        invalid(`invalid task YAML: ${parsed.errors[0].message}`);
-    }
-    validateNode(parsed.contents);
-    if (!isMap(parsed.contents))
-        invalid("task front matter must be a YAML mapping");
-    const values = new Map();
-    for (const item of parsed.contents.items) {
-        if (!isScalar(item.key) || typeof item.key.value !== "string") {
-            invalid("task front matter keys must be strings");
-        }
-        const key = item.key.value;
-        if (!FIELD_SET.has(key))
-            invalid(`unknown task front matter key '${key}'`);
-        const value = item.value;
-        if (key === "notes") {
-            values.set(key, noteArray(value));
-            continue;
-        }
-        if (isSeq(value)) {
-            const items = value.items.map((entry) => {
-                if (!isScalar(entry) || typeof entry.value !== "string") {
-                    return invalid(`task field '${key}' must contain only strings`);
-                }
-                return entry.value;
-            });
-            values.set(key, items);
-        }
-        else if (isScalar(value)) {
-            values.set(key, value.value);
-        }
-        else if (value === null) {
-            values.set(key, null);
-        }
-        else {
-            invalid(`task field '${key}' must be a scalar or string array`);
-        }
-    }
-    return { values, body: split.body };
-}
-function noteArray(value) {
-    if (!isSeq(value))
-        invalid("task field 'notes' must be an array of note objects");
-    return value.items.map((item) => {
-        if (!isMap(item))
-            invalid("task field 'notes' must contain only note objects");
-        const values = new Map();
-        for (const pair of item.items) {
-            if (!isScalar(pair.key) || typeof pair.key.value !== "string") {
-                invalid("task note fields must be strings");
-            }
-            const key = pair.key.value;
-            if (key !== "actor" && key !== "timestamp" && key !== "text") {
-                invalid(`unknown task note field '${key}'`);
-            }
-            if (!isScalar(pair.value))
-                invalid(`task note field '${key}' must be a string`);
-            values.set(key, pair.value.value);
-        }
-        return {
-            actor: nonblank("task note actor", values.get("actor")),
-            timestamp: canonicalTimestamp("task note timestamp", values.get("timestamp")),
-            text: nonblank("task note text", values.get("text")),
-        };
-    });
-}
-function taskNotes(values) {
-    const value = values.get("notes");
-    return value === undefined ? [] : value;
-}
-function stringArray(values, field, required) {
-    const value = values.get(field);
-    if (value === undefined && !required)
-        return [];
-    if (!Array.isArray(value))
-        invalid(`task field '${field}' must be a string array`);
-    const related = value.map((item) => fullId(field, item));
-    if (new Set(related).size !== related.length)
-        invalid(`task field '${field}' must be unique`);
-    return related;
-}
-function priority(values, required) {
-    const value = values.get("pri");
-    if (value === undefined && !required)
-        return undefined;
-    if (typeof value !== "number" || !Number.isInteger(value) || value < 0 || value > 3) {
-        invalid("task field 'pri' must be an integer from 0 through 3");
-    }
-    return value;
-}
-function parent(values, required) {
-    const value = values.get("parent");
-    if (value === undefined && !required)
-        return null;
-    if (value === null)
-        return null;
-    return fullId("parent", value);
-}
-export function parseTaskDocument(source) {
-    const { values, body } = parseTaskSource(source);
-    const id = nonblank("id", values.get("id"));
-    if (!isTaskId(id))
-        invalid("task field 'id' must be a canonical local task id");
-    const title = nonblank("title", values.get("title"));
-    const state = values.get("state");
-    if (typeof state !== "string" || !TASK_STATES.has(state)) {
-        invalid("task field 'state' must be open, in_progress, on_hold, done, or drop");
-    }
-    const pri = priority(values, true);
-    const needs = stringArray(values, "needs", true);
-    const taskParent = parent(values, true);
-    const from = stringArray(values, "from", true);
-    const supersedes = stringArray(values, "supersedes", false);
-    const relatesTo = stringArray(values, "relatesTo", false);
-    const notes = taskNotes(values);
-    const createdAt = canonicalTimestamp("createdAt", values.get("createdAt"));
-    const updatedValue = values.get("updatedAt");
-    const updatedAt = updatedValue === undefined ? undefined : canonicalTimestamp("updatedAt", updatedValue);
-    const creator = nonblank("creator", values.get("creator"));
-    const startedValue = values.get("startedAt");
-    const contractValue = values.get("contractId");
-    const startedAt = startedValue === undefined ? undefined : canonicalTimestamp("startedAt", startedValue);
-    const contractId = contractValue === undefined ? undefined : nonblank("contractId", contractValue);
-    if (state === "in_progress" && startedAt === undefined) {
-        invalid("task field 'startedAt' is required when state is in_progress");
-    }
-    if (state !== "in_progress" && startedAt !== undefined) {
-        invalid("task field 'startedAt' is forbidden unless state is in_progress");
-    }
-    return {
-        id,
-        title,
-        state: state,
-        pri,
-        needs,
-        parent: taskParent,
-        from,
-        supersedes,
-        relatesTo,
-        notes,
-        createdAt,
-        ...(updatedAt === undefined ? {} : { updatedAt }),
-        creator,
-        ...(startedAt === undefined ? {} : { startedAt }),
-        ...(contractId === undefined ? {} : { contractId }),
-        body,
-        source,
-    };
-}
-/** Parse the caller-owned subset of the canonical task document grammar. */
-export function parseTaskCreationDocument(source) {
-    const { values, body } = parseTaskSource(source);
-    for (const field of values.keys()) {
-        if (!CREATION_INPUT_FIELDS.has(field)) {
-            invalid(`task creation document field '${field}' is creation-owned and cannot be supplied`);
-        }
-    }
-    const pri = priority(values, false);
-    return {
-        title: nonblank("title", values.get("title")),
-        body,
-        ...(pri === undefined ? {} : { pri }),
-        needs: stringArray(values, "needs", false),
-        parent: parent(values, false),
-        from: stringArray(values, "from", false),
-        supersedes: stringArray(values, "supersedes", false),
-        relatesTo: stringArray(values, "relatesTo", false),
-    };
-}
-function validateDocument(document) {
-    return parseTaskDocument({ path: `${document.id}.md`, text: serializeUnchecked(document) });
-}
-function serializeUnchecked(document) {
-    const data = {
-        id: document.id,
-        title: document.title,
-        state: document.state,
-        pri: document.pri,
-        needs: [...document.needs],
-        parent: document.parent,
-        from: document.from,
-        ...(document.supersedes.length === 0 ? {} : { supersedes: document.supersedes }),
-        ...(document.relatesTo.length === 0 ? {} : { relatesTo: document.relatesTo }),
-        ...(document.notes.length === 0 ? {} : { notes: document.notes.map((note) => ({ ...note })) }),
-        createdAt: document.createdAt,
-        ...(document.updatedAt === undefined ? {} : { updatedAt: document.updatedAt }),
-        creator: document.creator,
-    };
-    if (document.startedAt !== undefined)
-        data.startedAt = document.startedAt;
-    if (document.contractId !== undefined)
-        data.contractId = document.contractId;
-    const yaml = stringify(data, { lineWidth: 0 }).trimEnd();
-    return `---\n${yaml}\n---\n${document.body}`;
-}
-export function serializeTaskDocument(document) {
-    validateDocument(document);
-    return serializeUnchecked(document);
-}

package/build/core/task/index.js

@@ -1,16 +0,0 @@
-/**
- * Public surface for the task package.
- * Only symbols required by current external consumers are re-exported.
- * Package-internal modules must import each other directly, not through this file.
- */
-export { previewTaskBoardForBind, reconcileTaskForfeit, replayClaimTasks, } from "./task-contract.js";
-export { replayPreparedTaskBind, replayPreparedTaskBindLocked, replayCommittedTaskBind, replayCommittedTaskBindForfeit, replayPreparedTaskBindForfeit, withPreparedTaskBind, withPreparedTaskBindSnapshot, } from "./task-bind-preparation.js";
-export { readTaskBoardGeneration } from "./task-git-store.js";
-export { resolveTaskCreator } from "./task-git-actor.js";
-export { openTaskCommandRepository, openTaskMutationContext, readTaskDoctor, taskCommandContractId, taskCommandNamespace, } from "./task-git-runtime.js";
-export { openTaskStore, readTaskHistory, readTaskNamespaces } from "./task-git-store.js";
-export { taskRepositoryFromStore } from "./task-store-repository.js";
-export { composeTasks, planTaskComposition, parseTaskCompositionSketch, } from "./compose.js";
-export { isTaskId } from "./validation.js";
-export { isTaskCoordinate, parseTaskCoordinate, taskCoordinateFromSourcePath, taskNamespaceFromScope } from "./coordinate.js";
-export { buildTaskTree, createTask, doneTask, dropTask, dropTaskWithNote, appendTaskNote, parseTaskCreationDocument, parseTaskDocument, readTaskBoard, resolveTaskReadId, serializeTaskDocument, startTask, stopTask, holdTask, resumeTask, updateTask, updateTaskWithReceipt, deriveTaskDisplay, selectTaskList, taskUpdatedAt, advancedTaskUpdatedAt, } from "./task.js";

package/build/core/task/model.js

@@ -1,8 +0,0 @@
-export function taskUpdatedAt(task) {
-    return task.updatedAt ?? task.createdAt;
-}
-export function advancedTaskUpdatedAt(task, observed) {
-    const observedMs = observed instanceof Date ? observed.getTime() : Date.parse(observed);
-    const priorMs = Date.parse(taskUpdatedAt(task));
-    return new Date(Math.max(observedMs, priorMs + 1)).toISOString();
-}