@astrosheep/keiyaku 2.9.4 → 2.9.6

package/build/core/status/board.js

@@ -3,42 +3,62 @@ import { observeGitRepository } from "../../git/branches.js";
 import { readProjectionStatusBoard } from "../projection/index.js";
 import { deriveQueueReadModel, queueMembership, } from "../settlement/index.js";
 import { findOpenArc, getMaxArc, receiptsAfterFence } from "../seal.js";
-import { openTaskStore, readTaskBoard, taskRepositoryFromStore, } from "../task/index.js";
+import { openTaskStore, readTaskBoard, taskRepositoryFromStore, taskUpdatedAt, } from "../task/index.js";
 import { deriveBootstrapDiagnostics, deriveContractState, hasCurrentPetitionVerdict, isTerminalState, } from "./lifecycle.js";
 import { commissionTarget, evaluateBaseDrift, latestBase, resolveDefaultBranchFromSettings, } from "./drift.js";
 import { computeClaimReconciliation, } from "./reconciliation.js";
 import { readStatusLedgers } from "./ledger-batch.js";
 function compareTaskStatusRows(left, right) {
-    if (left.pri !== right.pri)
-        return left.pri - right.pri;
-    if (left.createdAt !== right.createdAt)
-        return left.createdAt < right.createdAt ? -1 : 1;
+    const leftUpdated = taskUpdatedAt(left);
+    const rightUpdated = taskUpdatedAt(right);
+    if (leftUpdated !== rightUpdated)
+        return leftUpdated > rightUpdated ? -1 : 1;
     return left.id < right.id ? -1 : left.id > right.id ? 1 : 0;
 }
-async function readTaskStatusSummary(cwd) {
-    try {
-        const board = await readTaskBoard(taskRepositoryFromStore(await openTaskStore(cwd)));
-        const eligible = board.tasks.filter((task) => !task.contractId && (task.state === "open" || task.state === "in_progress"));
-        const inProgress = eligible.filter((task) => task.state === "in_progress").length;
-        const topTasks = [
-            ...eligible.filter((task) => task.state === "in_progress").sort(compareTaskStatusRows),
-            ...eligible.filter((task) => task.state === "open" && !task.blocked).sort(compareTaskStatusRows),
-        ]
-            .slice(0, 5)
-            .map(({ id, title, pri, createdAt, state, blocked }) => ({ id, title, pri, createdAt, state, blocked }));
-        const ready = eligible.filter((task) => task.state === "open" && !task.blocked).length;
-        const blocked = eligible.filter((task) => task.state === "open" && task.blocked).length;
-        if (board.tasks.length === 0 && board.diseases.length === 0)
-            return undefined;
+function timestampAge(timestamp, now) {
+    const value = Date.parse(timestamp);
+    return Number.isFinite(value) ? Math.max(0, now - value) : 0;
+}
+export function deriveTaskStatusSummary(board, now) {
+    const eligible = board.tasks.filter((task) => !task.contractId && (task.state === "open" || task.state === "in_progress"));
+    const inProgress = eligible.filter((task) => task.state === "in_progress").length;
+    const topTasks = [
+        ...eligible.filter((task) => task.state === "in_progress").sort(compareTaskStatusRows),
+        ...eligible.filter((task) => task.state === "open" && !task.blocked).sort(compareTaskStatusRows),
+    ]
+        .slice(0, 5)
+        .map((task) => {
+        const updatedAt = taskUpdatedAt(task);
         return {
-            total: board.tasks.length,
-            inProgress,
-            ready,
-            blocked,
-            omitted: inProgress + ready - topTasks.length,
-            topTasks,
-            diseases: board.diseases,
+            id: task.id,
+            title: task.title,
+            pri: task.pri,
+            state: task.state,
+            blocked: task.blocked,
+            createdAt: task.createdAt,
+            updatedAt,
+            ageMs: timestampAge(task.createdAt, now),
+            activityAgeMs: timestampAge(updatedAt, now),
         };
+    });
+    const ready = eligible.filter((task) => task.state === "open" && !task.blocked).length;
+    const blocked = eligible.filter((task) => task.state === "open" && task.blocked).length;
+    if (board.tasks.length === 0 && board.diseases.length === 0)
+        return undefined;
+    return {
+        total: board.tasks.length,
+        inProgress,
+        ready,
+        blocked,
+        omitted: inProgress + ready - topTasks.length,
+        topTasks,
+        diseases: board.diseases,
+    };
+}
+async function readTaskStatusSummary(cwd, now) {
+    try {
+        const board = await readTaskBoard(taskRepositoryFromStore(await openTaskStore(cwd)));
+        return deriveTaskStatusSummary(board, now);
     }
     catch (error) {
         return {
@@ -148,7 +168,7 @@ function deriveLastActiveAge(entries, now) {
 export async function readKanshiBoard(cwd, now, opts) {
     const targetFilter = opts?.target ?? null;
     const loadedSettings = await loadKeiyakuSettings(cwd);
-    const tasks = await readTaskStatusSummary(cwd);
+    const tasks = await readTaskStatusSummary(cwd, now);
     const repository = await observeGitRepository(cwd);
     if (repository.capability === "unknown")
         throw repository.error;

package/build/core/stored-agent-event.js

@@ -1,9 +1,10 @@
 import { activityEventBodySchema, AGENT_EVENT_TEXT_MAX_CHARS, AGENT_UNKNOWN_PAYLOAD_MAX_CHARS, EXEC_EVENT_BUFFER_HARD_CAP, } from "../agents/harness/index.js";
 import { isSubagentProvider } from "../keiyaku.js";
-const FAIL_CODES = new Set(["SUBAGENT_TIMEOUT", "SUBAGENT_NON_ZERO_EXIT", "SUBAGENT_SPAWN_ERROR", "SUBAGENT_EXEC_ERROR", "SUBAGENT_PROVIDER_UNAVAILABLE", "PROJECTION_STATE_ERROR"]);
+const FAIL_CODES = new Set(["SUBAGENT_TIMEOUT", "SUBAGENT_TRANSPORT_ERROR", "SUBAGENT_POLICY_BUDGET", "SUBAGENT_NON_ZERO_EXIT", "SUBAGENT_SPAWN_ERROR", "SUBAGENT_EXEC_ERROR", "SUBAGENT_PROVIDER_UNAVAILABLE", "PROJECTION_STATE_ERROR"]);
 const KNOWN = new Set(["message", "unknown", "activity", "thought", "plan", "turn", "usage", "warning", "diagnostic", "truncation", "done", "fail"]);
 const record = (value) => value !== null && typeof value === "object" && !Array.isArray(value);
 const finite = (value) => typeof value === "number" && Number.isFinite(value);
+const nonNegativeFinite = (value) => finite(value) && value >= 0;
 const optionalString = (value, key) => value[key] === undefined || typeof value[key] === "string";
 const nonNegativeSafeInteger = (value) => typeof value === "number" && Number.isSafeInteger(value) && value >= 0;
 const safeIntegerOrNull = (value) => value === null || (typeof value === "number" && Number.isSafeInteger(value));
@@ -14,7 +15,7 @@ function isValidStoredWarning(warning) {
     if (warning.reason === "retry") {
         return nonNegativeSafeInteger(warning.attempt)
             && nonNegativeSafeInteger(warning.maxRetries)
-            && nonNegativeSafeInteger(warning.retryDelayMs)
+            && nonNegativeFinite(warning.retryDelayMs)
             && safeIntegerOrNull(warning.errorStatus);
     }
     if (warning.reason === "refusal" || warning.reason === "overload") {

package/build/core/task/board.js

@@ -163,6 +163,7 @@ export function buildTaskBoardFromDocuments(documents) {
             parent: task.parent,
             from: [...task.from],
             createdAt: task.createdAt,
+            ...(task.updatedAt === undefined ? {} : { updatedAt: task.updatedAt }),
             creator: task.creator,
             ...(task.startedAt === undefined ? {} : { startedAt: task.startedAt }),
             ...(task.contractId === undefined ? {} : { contractId: task.contractId }),

package/build/core/task/commands.js

@@ -2,6 +2,7 @@ import { FlowError } from "../../flow-error.js";
 import { IdentifierSlugError, normalizeIdentifierSlug, SUFFIXABLE_IDENTIFIER_SLUG_MAX_UTF8_BYTES, } from "../identifier-slug.js";
 import { requireCanonicalTaskId, requireHealthy, resolveTaskId, } from "./board.js";
 import { dateTimestamp, invalid, nonblank, } from "./validation.js";
+import { advancedTaskUpdatedAt } from "./model.js";
 export async function readTaskBoard(repository) {
     return repository.read();
 }
@@ -15,6 +16,7 @@ function documentFromView(view) {
         parent: view.parent,
         from: [...view.from],
         createdAt: view.createdAt,
+        ...(view.updatedAt === undefined ? {} : { updatedAt: view.updatedAt }),
         creator: view.creator,
         ...(view.startedAt === undefined ? {} : { startedAt: view.startedAt }),
         ...(view.contractId === undefined ? {} : { contractId: view.contractId }),
@@ -74,6 +76,7 @@ export async function createTask(repository, input, deps) {
             }
             id = `${baseId}-${ordinal}`;
         }
+        const now = deps.now();
         const document = {
             id,
             title: input.title,
@@ -82,14 +85,15 @@ export async function createTask(repository, input, deps) {
             needs,
             parent,
             from,
-            createdAt: dateTimestamp("createdAt", deps.now()),
+            createdAt: dateTimestamp("createdAt", now),
+            updatedAt: dateTimestamp("updatedAt", now),
             creator: input.creator,
             body: input.body ?? "",
         };
         return replaceDocument(document, `Add task ${id}`);
     });
 }
-export async function updateTask(repository, fullIdValue, patch) {
+export async function updateTask(repository, fullIdValue, patch, now = new Date()) {
     const hasChange = Object.values(patch).some((value) => value !== undefined);
     if (!hasChange)
         throw new FlowError("EMPTY_PARAM", "task update requires at least one change");
@@ -118,17 +122,20 @@ export async function updateTask(repository, fullIdValue, patch) {
         if (JSON.stringify(document) === JSON.stringify(documentFromView(current))) {
             throw new FlowError("EMPTY_PARAM", "task update requires at least one change");
         }
+        document.updatedAt = advancedTaskUpdatedAt(current, now);
         return replaceDocument(document, `Update task ${id}`);
     });
 }
-async function transition(repository, fullIdValue, apply, subject) {
+async function transition(repository, fullIdValue, apply, subject, now) {
     return repository.mutate((board) => {
         requireHealthy(board);
         const id = fullIdValue === undefined
             ? selectSoleInProgress(board).id
             : resolveTaskId(board, fullIdValue);
-        const document = documentFromView(requireExisting(board, id));
+        const current = requireExisting(board, id);
+        const document = documentFromView(current);
         apply(document);
+        document.updatedAt = advancedTaskUpdatedAt(current, now);
         return replaceDocument(document, subject(id));
     });
 }
@@ -147,18 +154,18 @@ export async function startTask(repository, fullId, now) {
             invalid(`task ${document.id} is ${document.state}, not open`);
         document.state = "in_progress";
         document.startedAt = dateTimestamp("startedAt", now);
-    }, (id) => `Start task ${id}`);
+    }, (id) => `Start task ${id}`, now);
 }
-export async function stopTask(repository, fullId) {
+export async function stopTask(repository, fullId, now = new Date()) {
     return transition(repository, fullId, (document) => {
         rejectBound(document);
         if (document.state !== "in_progress")
             invalid(`task ${document.id} is ${document.state}, not in_progress`);
         document.state = "open";
         delete document.startedAt;
-    }, (id) => `Stop task ${id}`);
+    }, (id) => `Stop task ${id}`, now);
 }
-export async function doneTask(repository, fullId) {
+export async function doneTask(repository, fullId, now = new Date()) {
     return transition(repository, fullId, (document) => {
         rejectBound(document);
         if (document.state !== "open" && document.state !== "in_progress") {
@@ -166,9 +173,9 @@ export async function doneTask(repository, fullId) {
         }
         document.state = "done";
         delete document.startedAt;
-    }, (id) => `Done task ${id}`);
+    }, (id) => `Done task ${id}`, now);
 }
-export async function dropTask(repository, fullId) {
+export async function dropTask(repository, fullId, now = new Date()) {
     return transition(repository, fullId, (document) => {
         rejectBound(document, "drop");
         if (document.state !== "open" && document.state !== "in_progress") {
@@ -176,7 +183,7 @@ export async function dropTask(repository, fullId) {
         }
         document.state = "drop";
         delete document.startedAt;
-    }, (id) => `Drop task ${id}`);
+    }, (id) => `Drop task ${id}`, now);
 }
 export function selectSoleInProgress(board) {
     const candidates = board.tasks.filter((task) => task.state === "in_progress");
@@ -190,7 +197,7 @@ export function selectSoleInProgress(board) {
 }
 /** Reopen task pointers whose contract authority has disappeared. The caller
  * supplies the ledger fact; this operation itself remains storage-neutral. */
-export async function rollbackOrphanTaskPointers(repository, contractIds) {
+export async function rollbackOrphanTaskPointers(repository, contractIds, now = new Date()) {
     const before = await repository.read();
     const orphans = before.tasks
         .filter((task) => task.contractId !== undefined && !contractIds.has(task.contractId))
@@ -205,6 +212,7 @@ export async function rollbackOrphanTaskPointers(repository, contractIds) {
                 return [];
             const document = documentFromView(current);
             document.state = "open";
+            document.updatedAt = advancedTaskUpdatedAt(current, now);
             delete document.startedAt;
             delete document.contractId;
             return [document];

package/build/core/task/document.js

@@ -9,6 +9,7 @@ const FIELD_ORDER = [
     "parent",
     "from",
     "createdAt",
+    "updatedAt",
     "creator",
     "startedAt",
     "contractId",
@@ -134,6 +135,8 @@ export function parseTaskDocument(source) {
     if (from.includes(id))
         invalid("task field 'from' must not reference itself");
     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");
@@ -154,6 +157,7 @@ export function parseTaskDocument(source) {
         parent,
         from,
         createdAt,
+        ...(updatedAt === undefined ? {} : { updatedAt }),
         creator,
         ...(startedAt === undefined ? {} : { startedAt }),
         ...(contractId === undefined ? {} : { contractId }),
@@ -174,6 +178,7 @@ function serializeUnchecked(document) {
         parent: document.parent,
         from: document.from,
         createdAt: document.createdAt,
+        ...(document.updatedAt === undefined ? {} : { updatedAt: document.updatedAt }),
         creator: document.creator,
     };
     if (document.startedAt !== undefined)

package/build/core/task/index.js

@@ -9,4 +9,4 @@ export { openTaskCommandRepository, readTaskDoctor, taskCommandContractId, } fro
 export { openTaskStore } from "./task-git-store.js";
 export { taskRepositoryFromStore } from "./task-store-repository.js";
 export { isTaskId } from "./validation.js";
-export { buildTaskTree, createTask, doneTask, dropTask, parseTaskDocument, readTaskBoard, resolveTaskReadId, serializeTaskDocument, startTask, stopTask, updateTask, } from "./task.js";
+export { buildTaskTree, createTask, doneTask, dropTask, parseTaskDocument, readTaskBoard, resolveTaskReadId, serializeTaskDocument, startTask, stopTask, updateTask, deriveTaskDisplay, selectTaskList, taskUpdatedAt, advancedTaskUpdatedAt, } from "./task.js";

package/build/core/task/model.js

@@ -1 +1,8 @@
-export {};
+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();
+}

package/build/core/task/query.js

@@ -0,0 +1,214 @@
+import { FlowError } from "../../flow-error.js";
+import { isCommissionId } from "../ids.js";
+import { taskUpdatedAt } from "./model.js";
+import { isTaskId } from "./validation.js";
+export const TASK_FILTER_FIELDS = [
+    "title", "state", "priority", "parent", "needs", "blocks", "contract", "created", "updated",
+];
+export const TASK_FILTER_OPERATORS = ["=", "!=", "~", "<", "<=", ">", ">="];
+export const TASK_FILTER_GRAMMAR = "FIELD OP VALUE[,VALUE...] [| FIELD OP VALUE[,VALUE...]]...";
+export const TASK_FILTER_COMPLETION = "FIELD OP VALUE[,VALUE...]|FIELD OP VALUE[,VALUE...]";
+const FILTER_FIELDS = new Set(TASK_FILTER_FIELDS);
+const ORDERED_FIELDS = new Set(["priority", "created", "updated"]);
+const TITLE_OPERATORS = new Set(["=", "!=", "~"]);
+const ORDERED_OPERATORS = new Set(["=", "!=", "<", "<=", ">", ">="]);
+const DISPLAY_VALUES = new Set(["ready", "blocked", "in_progress", "done", "dropped", "bound"]);
+const SORT_KEYS = new Set(["priority", "modified", "created"]);
+const RELATIVE_TIME = /^now-([1-9][0-9]*)([smhdw])$/;
+const UNIT_MS = { s: 1_000, m: 60_000, h: 3_600_000, d: 86_400_000, w: 604_800_000 };
+export function deriveTaskDisplay(task) {
+    if (task.state === "done")
+        return "done";
+    if (task.state === "drop")
+        return "dropped";
+    if (task.contractId !== undefined)
+        return "bound";
+    if (task.state === "in_progress")
+        return "in_progress";
+    return task.blocked ? "blocked" : "ready";
+}
+function invalidFilter(detail, recoveredTerms = []) {
+    throw new FlowError("INVALID_TARGET", `invalid task filter: ${detail}`, {
+        facts: {
+            kind: "invalid_task_filter",
+            detail,
+            grammar: TASK_FILTER_GRAMMAR,
+            fields: [...TASK_FILTER_FIELDS],
+            operators: [...TASK_FILTER_OPERATORS],
+            recoveredTerms: recoveredTerms.map((term) => ({
+                field: term.field,
+                operator: term.operator,
+                values: [...term.values],
+            })),
+        },
+    });
+}
+function parseTaskFilterTerm(term, expression, recoveredTerms) {
+    const match = /^([a-z][a-z0-9_-]*)(!=|<=|>=|~|=|<|>)(.*)$/.exec(term);
+    if (!match)
+        invalidFilter(`'${expression}' must use ${TASK_FILTER_GRAMMAR}`, recoveredTerms);
+    const field = match[1];
+    const operator = match[2];
+    if (!FILTER_FIELDS.has(field))
+        invalidFilter(`unknown field '${field}'`, recoveredTerms);
+    if (field === "title" && !TITLE_OPERATORS.has(operator)) {
+        invalidFilter(`field '${field}' does not support operator '${operator}'`, recoveredTerms);
+    }
+    if (field !== "title" && (ORDERED_FIELDS.has(field)
+        ? !ORDERED_OPERATORS.has(operator)
+        : operator !== "=" && operator !== "!=")) {
+        invalidFilter(`field '${field}' does not support operator '${operator}'`, recoveredTerms);
+    }
+    const values = match[3].split(",");
+    if (values.some((value) => value.length === 0))
+        invalidFilter(`field '${field}' has an empty value`, recoveredTerms);
+    validateFilterValues(field, values, recoveredTerms);
+    return { field, operator, values };
+}
+export function parseTaskFilter(expression) {
+    const terms = expression.split("|");
+    const parsed = [];
+    for (const term of terms) {
+        if (term.length === 0)
+            invalidFilter(`'${expression}' must use ${TASK_FILTER_GRAMMAR}`, parsed);
+        parsed.push(parseTaskFilterTerm(term, expression, parsed));
+    }
+    return parsed;
+}
+function parseTimestamp(value, nowMs, recoveredTerms = []) {
+    const relative = RELATIVE_TIME.exec(value);
+    if (relative) {
+        const amount = Number(relative[1]);
+        const offset = amount * UNIT_MS[relative[2]];
+        if (!Number.isSafeInteger(offset))
+            invalidFilter(`timestamp '${value}' is outside the supported range`, recoveredTerms);
+        return nowMs - offset;
+    }
+    const timestamp = Date.parse(value);
+    if (!Number.isFinite(timestamp) || new Date(timestamp).toISOString() !== value) {
+        invalidFilter(`timestamp '${value}' must be canonical ISO-8601 or now-<duration>`, recoveredTerms);
+    }
+    return timestamp;
+}
+function validateFilterValues(field, values, recoveredTerms) {
+    if (field === "title")
+        return;
+    if (field === "state") {
+        for (const value of values)
+            if (!DISPLAY_VALUES.has(value))
+                invalidFilter(`unknown state '${value}'`, recoveredTerms);
+        return;
+    }
+    if (field === "priority") {
+        for (const value of values)
+            if (!/^[0-3]$/.test(value))
+                invalidFilter(`priority '${value}' must be 0 through 3`, recoveredTerms);
+        return;
+    }
+    if (field === "created" || field === "updated") {
+        for (const value of values)
+            parseTimestamp(value, 0, recoveredTerms);
+        return;
+    }
+    if (field === "parent" || field === "needs" || field === "blocks") {
+        for (const value of values) {
+            if (field === "parent" && value === "none")
+                continue;
+            if (!isTaskId(value))
+                invalidFilter(`value '${value}' must be a canonical full task id`, recoveredTerms);
+        }
+        return;
+    }
+    if (field === "contract") {
+        for (const value of values) {
+            if (value !== "none" && !isCommissionId(value))
+                invalidFilter(`value '${value}' must be a full commission id or none`, recoveredTerms);
+        }
+    }
+}
+export function parseTaskSort(value) {
+    if (value === undefined)
+        return undefined;
+    const keys = value.split(",");
+    if (keys.some((key) => !SORT_KEYS.has(key))) {
+        const invalid = keys.find((key) => !SORT_KEYS.has(key));
+        throw new FlowError("INVALID_TARGET", `invalid task sort key '${String(invalid)}'; expected priority, modified, or created`);
+    }
+    if (new Set(keys).size !== keys.length) {
+        throw new FlowError("INVALID_TARGET", "task sort keys must not repeat");
+    }
+    return keys;
+}
+function compareText(left, right) {
+    return left < right ? -1 : left > right ? 1 : 0;
+}
+function compareValue(left, right, operator) {
+    switch (operator) {
+        case "=": return left === right;
+        case "!=": return left !== right;
+        case "<": return left < right;
+        case "<=": return left <= right;
+        case ">": return left > right;
+        case ">=": return left >= right;
+        case "~": return false;
+    }
+}
+function matchesFilter(task, filter, nowMs) {
+    return filter.values.some((raw) => {
+        if (filter.field === "title") {
+            if (filter.operator === "~")
+                return task.title.toLowerCase().includes(raw.toLowerCase());
+            return compareValue(task.title, raw, filter.operator);
+        }
+        if (filter.field === "state")
+            return compareValue(deriveTaskDisplay(task), raw, filter.operator);
+        if (filter.field === "priority")
+            return compareValue(task.pri, Number(raw), filter.operator);
+        if (filter.field === "created")
+            return compareValue(Date.parse(task.createdAt), parseTimestamp(raw, nowMs), filter.operator);
+        if (filter.field === "updated")
+            return compareValue(Date.parse(taskUpdatedAt(task)), parseTimestamp(raw, nowMs), filter.operator);
+        const expected = raw === "none" ? null : raw;
+        if (filter.field === "parent")
+            return compareValue(task.parent ?? "\0", expected ?? "\0", filter.operator);
+        if (filter.field === "contract")
+            return compareValue(task.contractId ?? "\0", expected ?? "\0", filter.operator);
+        const relations = filter.field === "needs" ? task.needs : task.blocks;
+        return filter.operator === "=" ? relations.includes(raw) : !relations.includes(raw);
+    });
+}
+function selected(task, selection) {
+    const terminal = task.state === "done" || task.state === "drop";
+    return selection === "all" || (selection === "done" ? terminal : !terminal);
+}
+function displayOrder(task) {
+    const display = deriveTaskDisplay(task);
+    return display === "in_progress" ? 0 : display === "ready" ? 1 : display === "blocked" ? 2 : display === "bound" ? 3 : display === "done" ? 4 : 5;
+}
+function defaultCompare(left, right) {
+    return displayOrder(left) - displayOrder(right)
+        || left.pri - right.pri
+        || compareText(left.createdAt, right.createdAt)
+        || compareText(left.id, right.id);
+}
+function explicitCompare(keys, left, right) {
+    for (const key of keys) {
+        const difference = key === "priority"
+            ? left.pri - right.pri
+            : key === "modified"
+                ? compareText(taskUpdatedAt(right), taskUpdatedAt(left))
+                : compareText(right.createdAt, left.createdAt);
+        if (difference !== 0)
+            return difference;
+    }
+    return compareText(left.id, right.id);
+}
+export function selectTaskList(tasks, options = {}) {
+    const filters = (options.filters ?? []).map(parseTaskFilter);
+    const sort = parseTaskSort(options.sort);
+    const nowMs = options.nowMs ?? Date.now();
+    return tasks
+        .filter((task) => selected(task, options.selection ?? "default"))
+        .filter((task) => filters.every((filter) => filter.some((term) => matchesFilter(task, term, nowMs))))
+        .sort(sort === undefined ? defaultCompare : (left, right) => explicitCompare(sort, left, right));
+}