@astrosheep/keiyaku 4.5.29 → 4.6.2

package/build/src/cli/commands/install.d.ts

@@ -17,7 +17,7 @@ export type InstallInvocationResult = Readonly<{
 }>;
 export type InstallRunner = (input: ProcessInput) => Promise<ProcessOutcome>;
 export declare const INSTALL_USAGE = "install <codex|claude|opencode|pi>\ninstall --all";
-export declare const INSTALL_ROOT_PURPOSE = "Install the Keiyaku plugin into a supported coding harness";
+export declare const INSTALL_ROOT_PURPOSE = "Install the Keiyaku plugin into a supported coding harness.";
 export declare function parseInstallCommand(argv: readonly string[]): ParsedInstallCommand;
 export declare function renderInstallHelp(): string;
 export declare function installAssetsRoot(): string;

package/build/src/cli/commands/install.js

@@ -3,7 +3,7 @@ import { fileURLToPath } from "node:url";
 import { CliUsageError, commandGuide, usageLine } from "../usage.js";
 export const HARNESS_NAMES = ["codex", "claude", "opencode", "pi"];
 export const INSTALL_USAGE = "install <codex|claude|opencode|pi>\ninstall --all";
-export const INSTALL_ROOT_PURPOSE = "Install the Keiyaku plugin into a supported coding harness";
+export const INSTALL_ROOT_PURPOSE = "Install the Keiyaku plugin into a supported coding harness.";
 function isHarness(value) {
     return value !== undefined && HARNESS_NAMES.includes(value);
 }
@@ -44,7 +44,7 @@ export function parseInstallCommand(argv) {
     };
 }
 export function renderInstallHelp() {
-    return `Install Keiyaku into your coding harnesses via each harness's native plugin/package installer. --all continues past failures; any failure exits 1.\n\n${usageLine(INSTALL_USAGE)}`;
+    return `${INSTALL_ROOT_PURPOSE}\n\n${usageLine(INSTALL_USAGE)}\n\n--all continues past failures; any failure exits 1.`;
 }
 const INSTALL_TIMEOUT_MS = 5 * 60 * 1000;
 const ASSET_ROOT = resolve(dirname(fileURLToPath(import.meta.url)), "../../../integrations/marketplace");

package/build/src/cli/commands/task-grammar.d.ts

@@ -0,0 +1,19 @@
+import { type CliUsageGuide } from "../usage.js";
+import { type TaskQueryExpression } from "./task-query.js";
+export type TaskAction = "add" | "show" | "ls" | "ready" | "blocked" | "tree" | "doctor" | "update" | "query" | "start" | "stop" | "hold" | "resume" | "done" | "drop" | "context" | "compose";
+type TaskFlagValue = string | true | readonly string[];
+type TaskStdin = "document" | "body" | "append" | "note" | "compose";
+export type ParsedTaskCommand = Readonly<{
+    command: "task";
+    action: TaskAction;
+    output: "text" | "json";
+    positionals: readonly string[];
+    flags: Readonly<Record<string, TaskFlagValue>>;
+    stdin?: TaskStdin;
+    where?: TaskQueryExpression;
+}>;
+export declare function isTaskAction(value: string | undefined): value is TaskAction;
+export declare function renderTaskHelp(action?: TaskAction): string;
+export declare function taskUsageGuide(action: TaskAction): CliUsageGuide;
+export declare function parseTaskCommand(argv: readonly string[]): ParsedTaskCommand;
+export {};

package/build/src/cli/commands/task-grammar.js

@@ -0,0 +1,438 @@
+import { CliUsageError, isBlankInput, TASK_FAMILY_USAGE_GUIDE, unknownCommandGuide, } from "../usage.js";
+import { parseTaskNamespaceSelector } from "../../task/catalog.js";
+import { parseTaskId } from "../../task/identity.js";
+import { parseTaskQueryExpression, validateTaskLimit, validateTaskParent, } from "./task-query.js";
+const COMMON = { json: "boolean" };
+const TASK_COMMAND_SPECS = {
+    add: {
+        arity: [0, 1],
+        stdin: "document",
+        flags: {
+            ...COMMON,
+            namespace: "value",
+            state: "value",
+            priority: "value",
+            needs: "repeat",
+            parent: "value",
+            supersedes: "repeat",
+            relates: "repeat",
+            body: "value",
+            note: "value",
+            actor: "value",
+        },
+        usage: `task add <TITLE> [--namespace <ns>] [--priority 0..3]
+  [--state open|in_progress|on_hold|done|drop]
+  [--note <text>] [--actor <actor>]
+  [--needs <TaskId>]... [--parent <TaskId>]
+  [--supersedes <TaskId>]... [--relates <TaskId>]...
+  [--body <text>]
+task add [--namespace <ns>] [--actor <actor>] -`,
+        purpose: "Create a Task from flags or a Task document on stdin.",
+        details: "The stdin document is YAML front matter (title, state, priority, needs, parent, supersedes, relates, note) followed by a Markdown body.",
+    },
+    show: {
+        arity: [1, Number.POSITIVE_INFINITY],
+        flags: COMMON,
+        usage: "task show <TaskId>...",
+        purpose: "Read one or more Tasks and their relationships.",
+    },
+    ls: {
+        arity: [0, 1],
+        flags: { ...COMMON, closed: "boolean", all: "boolean", world: "boolean", limit: "value" },
+        usage: "task ls [<namespace-selector>] [--closed | --all] [--world] [--limit <n>]",
+        purpose: "List Tasks in the selected namespace.",
+        details: [
+            "With no selector, lists the current directory Task context.",
+            "task/ selects the root namespace; --world lists every namespace in the current Task world.",
+        ].join("\n"),
+    },
+    ready: {
+        arity: [0, 0],
+        flags: { ...COMMON, world: "boolean", parent: "value", limit: "value" },
+        usage: "task ready [--world] [--parent <TaskId>] [--limit <n>]",
+        purpose: "List open Tasks whose every dependency is complete or dropped.",
+        details: "--world lists every namespace in the current Task world.",
+    },
+    blocked: {
+        arity: [0, 0],
+        flags: { ...COMMON, world: "boolean", parent: "value", limit: "value" },
+        usage: "task blocked [--world] [--parent <TaskId>] [--limit <n>]",
+        purpose: "List Tasks with unmet dependencies.",
+        details: "--world lists every namespace in the current Task world.",
+    },
+    query: {
+        arity: [0, 0],
+        flags: {
+            ...COMMON,
+            where: "value",
+            world: "boolean",
+            closed: "boolean",
+            all: "boolean",
+            sort: "value",
+            limit: "value",
+        },
+        usage: `task query [--where <expression>] [--closed | --all] [--world]
+  [--sort priority|created|updated|id] [--limit <n>]`,
+        purpose: "Filter and sort Tasks with a boolean expression.",
+        details: [
+            "fields: state priority title id parent under needs blocks ready blocked created updated",
+            "operators: = != < > <= >= ~ and or not ( )",
+            "sort: priority and created ascend; updated descends; id is lexical. Default: priority.",
+            "--world lists every namespace in the current Task world.",
+            "By default only active Tasks match; --closed selects terminal Tasks, --all includes both.",
+            "examples:",
+            "  keiyaku task query --where 'priority <= 1 and ready' --world",
+            "  keiyaku task query --where 'updated < 2026-08-06T00:00:00.000Z' --world",
+        ].join("\n"),
+    },
+    tree: {
+        arity: [1, 1],
+        flags: COMMON,
+        usage: "task tree <TaskId>",
+        purpose: "Show a Task and its parent/child breakdown.",
+    },
+    doctor: {
+        arity: [0, 0],
+        flags: COMMON,
+        usage: "task doctor",
+        purpose: "Check Tasks for inconsistencies without changing them.",
+    },
+    update: {
+        arity: [1, 1],
+        flags: {
+            ...COMMON,
+            title: "value",
+            body: "value",
+            append: "value",
+            note: "value",
+            priority: "value",
+            needs: "repeat",
+            "drop-needs": "repeat",
+            parent: "value",
+            "no-parent": "boolean",
+            supersedes: "repeat",
+            "drop-supersedes": "repeat",
+            relates: "repeat",
+            "drop-relates": "repeat",
+        },
+        usage: `task update <TaskId> [--title <text>] [--body <text>|- | --append <text>]
+  [--note <text>]
+  [--priority 0..3] [--needs <TaskId>]... [--drop-needs <TaskId>]...
+  [--parent <TaskId> | --no-parent]
+  [--supersedes <TaskId>]... [--drop-supersedes <TaskId>]...
+  [--relates <TaskId>]... [--drop-relates <TaskId>]...`,
+        purpose: "Change a Task's fields and relationships.",
+        details: [
+            "--body replaces the body; --append adds text after it, separated by a newline when needed.",
+            "--body - reads replacement body text from stdin.",
+        ].join("\n"),
+    },
+    start: {
+        arity: [1, Number.POSITIVE_INFINITY],
+        flags: COMMON,
+        usage: "task start <TaskId>...",
+        purpose: "Move one or more open Tasks into progress.",
+    },
+    stop: {
+        arity: [1, Number.POSITIVE_INFINITY],
+        flags: COMMON,
+        usage: "task stop <TaskId>...",
+        purpose: "Return one or more in-progress Tasks to open.",
+    },
+    hold: {
+        arity: [1, Number.POSITIVE_INFINITY],
+        flags: COMMON,
+        usage: "task hold <TaskId>...",
+        purpose: "Put one or more Tasks on hold.",
+    },
+    resume: {
+        arity: [1, Number.POSITIVE_INFINITY],
+        flags: COMMON,
+        usage: "task resume <TaskId>...",
+        purpose: "Return one or more held Tasks to open.",
+    },
+    done: {
+        arity: [1, Number.POSITIVE_INFINITY],
+        flags: { ...COMMON, note: "value" },
+        usage: "task done <TaskId>... [--note <text>]",
+        purpose: "Mark one or more Tasks done.",
+    },
+    drop: {
+        arity: [1, Number.POSITIVE_INFINITY],
+        flags: { ...COMMON, note: "value" },
+        usage: "task drop <TaskId>... [--note <text>]",
+        purpose: "Mark one or more Tasks as no longer needed.",
+    },
+    context: {
+        arity: [0, 1],
+        flags: COMMON,
+        usage: "task context [<namespace>]",
+        purpose: "Set or read the default Task namespace for this directory.",
+        details: "Omit <namespace> to read the current context; use / to reset it to the root namespace.",
+    },
+    compose: {
+        arity: [0, 0],
+        stdin: "compose",
+        flags: { ...COMMON, actor: "value", plan: "boolean" },
+        usage: "task compose [--actor <actor>] [--plan] -",
+        purpose: "Create or update several Tasks from one document, with an optional preview.",
+        details: [
+            "nodes: + <Title> creates; @task/<id> modifies a pre-existing Task",
+            "properties: as = <alias>; state = open|in_progress|on_hold|done|drop; pri = 0..3; parent = <ref>|empty",
+            "relations: needs|supersedes|relates with =, +=, or -=",
+            "references: @task/... is pre-existing; ^alias is new in this document",
+            "body: body = clears; body <<TOKEN reads exact content to TOKEN",
+            "TOKEN: [A-Z][A-Z0-9_]* with length 3..32",
+            "example:",
+            "  ns=feature",
+            "  + Parent",
+            "  as = parent",
+            "  pri = 1",
+            "  body <<BODY",
+            "  Exact body bytes.",
+            "  BODY",
+            "  + Child",
+            "  parent = ^parent",
+        ].join("\n"),
+    },
+};
+export function isTaskAction(value) {
+    return value !== undefined && Object.hasOwn(TASK_COMMAND_SPECS, value);
+}
+export function renderTaskHelp(action) {
+    if (action !== undefined) {
+        const spec = TASK_COMMAND_SPECS[action];
+        return `${spec.purpose}\n\n${renderTaskUsage(action)}${spec.details === undefined ? "" : `\n\n${spec.details}`}`;
+    }
+    return [
+        "usage  keiyaku task <command> ...",
+        "",
+        "commands:",
+        ...Object.values(TASK_COMMAND_SPECS).flatMap((spec) => spec.usage
+            .split("\n")
+            .map((line) => `  ${line}`)
+            .concat(`    ${spec.purpose}`)),
+    ].join("\n");
+}
+function renderTaskUsage(action) {
+    return TASK_COMMAND_SPECS[action].usage
+        .split("\n")
+        .map((line, index) => {
+        if (index === 0 || line.trimStart().startsWith("task ")) {
+            const command = line.trimStart().startsWith("task ") ? `keiyaku ${line.trim()}` : `keiyaku ${line}`;
+            return `${index === 0 ? "usage  " : "      "}${command}`;
+        }
+        return `      ${line.trim()}`;
+    })
+        .join("\n");
+}
+function taskUsage(action) {
+    const lines = TASK_COMMAND_SPECS[action].usage.split("\n");
+    return lines
+        .map((line, index) => {
+        if (index === 0 || line.trimStart().startsWith("task "))
+            return `keiyaku ${line.trim()}`;
+        return `           ${line.trim()}`;
+    })
+        .join("\n");
+}
+export function taskUsageGuide(action) {
+    return {
+        scope: `keiyaku task ${action}`,
+        accepts: taskUsage(action),
+        help: `keiyaku task ${action} --help`,
+    };
+}
+function setFlag(flags, name, kind, value, fail) {
+    if (flags[name] !== undefined && kind !== "repeat")
+        fail(`duplicate option: --${name}`);
+    if (kind === "boolean") {
+        flags[name] = true;
+        return;
+    }
+    if (value === undefined)
+        fail(`--${name} requires a value`);
+    if (isBlankInput(value))
+        fail(`--${name} requires a nonblank value`);
+    if (kind === "repeat") {
+        const current = flags[name];
+        flags[name] = [...(Array.isArray(current) ? current : []), value];
+    }
+    else
+        flags[name] = value;
+}
+function scanTaskOption(input, fail) {
+    const token = input.argv[input.index], name = token.slice(2), kind = input.spec.flags[name];
+    if (kind === undefined)
+        fail(`option ${token} is not valid for task ${input.action}`);
+    const next = kind === "boolean" ? undefined : input.argv[input.index + 1];
+    if (next === "-" && input.action === "update" && name === "body") {
+        if (input.stdin !== undefined)
+            fail("stdin marker '-' may appear only once");
+        input.flags[name] = "";
+        return { index: input.index + 1, stdin: name };
+    }
+    if (kind !== "boolean" && (next === undefined || next.startsWith("--") || next === "-"))
+        fail(`--${name} requires a value`);
+    setFlag(input.flags, name, kind, next, fail);
+    return {
+        index: input.index + (kind === "boolean" ? 0 : 1),
+        ...(input.stdin === undefined ? {} : { stdin: input.stdin }),
+    };
+}
+function scanTaskArgv(action, argv, fail) {
+    const spec = TASK_COMMAND_SPECS[action], positionals = [], flags = {};
+    let stdin;
+    let positionalOnly = false;
+    for (let index = 1; index < argv.length; index += 1) {
+        const token = argv[index];
+        if (!positionalOnly && token === "--") {
+            positionalOnly = true;
+            continue;
+        }
+        if (!positionalOnly && token === "-") {
+            if (spec.stdin === undefined)
+                fail("stdin marker '-' is not valid here");
+            if (stdin !== undefined)
+                fail("stdin marker '-' may appear only once");
+            stdin = spec.stdin;
+            continue;
+        }
+        if (positionalOnly || !token.startsWith("--")) {
+            if (isBlankInput(token))
+                fail(`task ${action} requires a nonblank value`);
+            positionals.push(token);
+            continue;
+        }
+        const scanned = scanTaskOption({ action, spec, argv, index, flags, ...(stdin === undefined ? {} : { stdin }) }, fail);
+        index = scanned.index;
+        stdin = scanned.stdin;
+    }
+    return { positionals, flags, ...(stdin === undefined ? {} : { stdin }) };
+}
+function validateUpdate(scanned, fail) {
+    const flags = scanned.flags;
+    if (flags.body !== undefined && flags.append !== undefined)
+        fail("--body and --append are mutually exclusive");
+    if (flags.parent !== undefined && flags["no-parent"] === true)
+        fail("--parent and --no-parent are mutually exclusive");
+    if (Object.keys(flags).every((name) => name === "json"))
+        fail("task update requires at least one patch option");
+}
+function validateTaskReadFlags(action, flags, fail) {
+    if ((action === "ls" || action === "query") && flags.closed === true && flags.all === true)
+        fail("--closed and --all are mutually exclusive");
+    if (action === "ls" && flags.world === true) {
+        // An explicit selector is checked below, after positional shape is known.
+    }
+    if (typeof flags.limit === "string") {
+        try {
+            validateTaskLimit(flags.limit);
+        }
+        catch (error) {
+            fail(error instanceof Error ? error.message : String(error));
+        }
+    }
+    if (typeof flags.sort === "string" &&
+        flags.sort !== "priority" &&
+        flags.sort !== "created" &&
+        flags.sort !== "updated" &&
+        flags.sort !== "id") {
+        fail("--sort must be priority, created, updated, or id");
+    }
+    if ((action === "ready" || action === "blocked") && typeof flags.parent === "string") {
+        try {
+            validateTaskParent(flags.parent);
+        }
+        catch (error) {
+            fail(error instanceof Error ? error.message : String(error));
+        }
+    }
+}
+/** Actions whose positionals are all addressed TaskIds validated by the native owner. */
+const TASK_ID_ACTIONS = new Set([
+    "show",
+    "tree",
+    "update",
+    "start",
+    "stop",
+    "hold",
+    "resume",
+    "done",
+    "drop",
+]);
+/** Validate every addressed TaskId positional through the native owner before any read or write. */
+function validateTaskIdPositionals(positionals, fail) {
+    for (const taskId of positionals) {
+        try {
+            parseTaskId(taskId);
+        }
+        catch (error) {
+            fail(error instanceof Error ? error.message : String(error));
+        }
+    }
+}
+/** Validate an explicit `task ls` namespace selector through the native owner. */
+function validateListSelector(selector, fail) {
+    if (selector !== "task/" && (!selector.startsWith("task/") || !selector.endsWith("/")))
+        fail(`invalid Task namespace selector: ${selector}`);
+    if (selector === "task/")
+        return;
+    try {
+        parseTaskNamespaceSelector(selector);
+    }
+    catch (error) {
+        fail(error instanceof Error ? error.message : String(error));
+    }
+}
+function validateTaskScan(action, scanned, fail) {
+    const spec = TASK_COMMAND_SPECS[action], { positionals, flags, stdin } = scanned;
+    if (positionals.length < spec.arity[0] || positionals.length > spec.arity[1])
+        fail(`task ${action} has invalid positional arguments`);
+    if (action === "add" && (stdin === "document") === (positionals.length === 1))
+        fail("task add requires either TITLE or '-' input");
+    if (action === "add" &&
+        stdin === "document" &&
+        Object.keys(flags).some((name) => name !== "json" && name !== "namespace" && name !== "actor"))
+        fail("task add document input owns its creation fields");
+    if (action === "compose" && stdin !== "compose")
+        fail("task compose requires '-' input");
+    if (TASK_ID_ACTIONS.has(action))
+        validateTaskIdPositionals(positionals, fail);
+    if (action === "ls" && positionals.length === 1) {
+        validateListSelector(positionals[0], fail);
+        if (flags.world === true)
+            fail("--world cannot be combined with an explicit Task namespace selector");
+    }
+    validateTaskReadFlags(action, flags, fail);
+    if (action === "update")
+        validateUpdate(scanned, fail);
+}
+export function parseTaskCommand(argv) {
+    const candidate = argv[0];
+    if (!isTaskAction(candidate)) {
+        throw new CliUsageError(`unknown task command: ${candidate ?? ""}`, unknownCommandGuide(TASK_FAMILY_USAGE_GUIDE, candidate ?? ""));
+    }
+    const action = candidate;
+    const fail = (message) => {
+        throw new CliUsageError(message, taskUsageGuide(action));
+    };
+    const scanned = scanTaskArgv(action, argv, fail);
+    validateTaskScan(action, scanned, fail);
+    let where;
+    if (action === "query" && typeof scanned.flags.where === "string") {
+        try {
+            where = parseTaskQueryExpression(scanned.flags.where);
+        }
+        catch (error) {
+            fail(error instanceof Error ? error.message : String(error));
+        }
+    }
+    return {
+        command: "task",
+        action,
+        output: scanned.flags.json === true ? "json" : "text",
+        ...scanned,
+        ...(where === undefined ? {} : { where }),
+    };
+}

package/build/src/cli/commands/task-query.js

@@ -1,4 +1,4 @@
-import { TASK_RELATION_PREDICATE_FIELDS, normalizeTaskQuery, } from "../../task/query.js";
+import { normalizeTaskQueryPredicate, TaskQueryPredicateError, } from "../../task/query.js";
 function syntax(message, offset) {
     throw new Error(`${message} at column ${offset + 1}`);
 }
@@ -80,80 +80,27 @@ function lex(source) {
     tokens.push({ kind: "end", value: "", offset: source.length });
     return tokens;
 }
-function canonicalTaskId(token, field) {
-    if (!token.value.startsWith("task/"))
-        return syntax(`${field} requires a canonical TaskId`, token.offset);
-    return token.value;
-}
-function state(token) {
-    if (token.value !== "open" &&
-        token.value !== "in_progress" &&
-        token.value !== "on_hold" &&
-        token.value !== "done" &&
-        token.value !== "drop") {
-        return syntax(`invalid state ${JSON.stringify(token.value)}`, token.offset);
+function parsedPredicate(field, operator, value) {
+    if (field.value === "title" && value.kind !== "string") {
+        syntax("title values must use double quotes", value.offset);
     }
-    return token.value;
-}
-function priority(token) {
-    const value = Number(token.value);
-    if (!Number.isInteger(value) || value < 0 || value > 3)
-        return syntax("priority requires 0..3", token.offset);
-    return value;
-}
-function boolean(token) {
-    if (token.value === "true")
-        return true;
-    if (token.value === "false")
-        return false;
-    return syntax("boolean predicate requires true or false", token.offset);
-}
-function timestamp(token, field) {
-    const milliseconds = Date.parse(token.value);
-    if (!Number.isFinite(milliseconds) || new Date(milliseconds).toISOString() !== token.value)
-        return syntax(`${field} requires a canonical UTC ISO timestamp`, token.offset);
-    return token.value;
-}
-function equalityOperator(token, field) {
-    if (token.value !== "=" && token.value !== "!=")
-        syntax(`${field} supports only = and !=`, token.offset);
-    return token.value;
-}
-function orderedOperator(token, field) {
-    if (token.value === "~")
-        syntax(`${field} operator is invalid`, token.offset);
-    return token.value;
-}
-function textOperator(token, field) {
-    if (token.value !== "=" && token.value !== "!=" && token.value !== "~") {
-        syntax(`${field} supports only =, !=, and ~`, token.offset);
+    // Acquire textual literals only; the Task owner judges fields, operators and values.
+    const literal = field.value === "priority"
+        ? Number(value.value)
+        : field.value === "parent" && value.value === "none"
+            ? null
+            : (field.value === "ready" || field.value === "blocked") && (value.value === "true" || value.value === "false")
+                ? value.value === "true"
+                : value.value;
+    try {
+        return normalizeTaskQueryPredicate({ field: field.value, operator: operator.value, value: literal });
     }
-    return token.value;
-}
-function parseTextPredicate(field, operator, value) {
-    const selected = textOperator(operator, field);
-    if (field === "title" && value.kind !== "string")
-        syntax("title values must use double quotes", value.offset);
-    if (field === "id" && selected !== "~")
-        canonicalTaskId(value, "id");
-    return { field, operator: selected, value: value.value };
-}
-function parseRelationPredicate(field, operator, value) {
-    const relationField = TASK_RELATION_PREDICATE_FIELDS.find((candidate) => candidate === field.value);
-    if (relationField === undefined) {
-        syntax(`unknown query field ${JSON.stringify(field.value)}`, field.offset);
+    catch (error) {
+        if (error instanceof TaskQueryPredicateError) {
+            return syntax(error.message, { field, operator, value }[error.part].offset);
+        }
+        throw error;
     }
-    return {
-        field: relationField,
-        operator: equalityOperator(operator, relationField),
-        value: canonicalTaskId(value, relationField),
-    };
-}
-function parseBooleanPredicate(field, operator, value) {
-    return { field, operator: equalityOperator(operator, field), value: boolean(value) };
-}
-function parseTimestampPredicate(field, operator, value) {
-    return { field, operator: orderedOperator(operator, field), value: timestamp(value, field) };
 }
 class Parser {
     tokens;
@@ -217,7 +164,7 @@ class Parser {
         if (field.kind !== "word")
             syntax("expected query field", field.offset);
         if ((field.value === "ready" || field.value === "blocked") && this.current().kind !== "operator") {
-            return { field: field.value, operator: "=", value: true };
+            return parsedPredicate(field, { kind: "operator", value: "=", offset: field.offset }, { kind: "word", value: "true", offset: field.offset });
         }
         const operator = this.take();
         if (operator.kind !== "operator")
@@ -225,41 +172,13 @@ class Parser {
         const value = this.take();
         if (value.kind !== "word" && value.kind !== "string")
             syntax(`expected value for ${field.value}`, value.offset);
-        return this.typedPredicate(field, operator, value);
-    }
-    typedPredicate(field, operator, value) {
-        switch (field.value) {
-            case "state":
-                return { field: "state", operator: equalityOperator(operator, "state"), value: state(value) };
-            case "priority":
-                return { field: "priority", operator: orderedOperator(operator, "priority"), value: priority(value) };
-            case "title":
-                return parseTextPredicate("title", operator, value);
-            case "id":
-                return parseTextPredicate("id", operator, value);
-            case "parent":
-                return {
-                    field: "parent",
-                    operator: equalityOperator(operator, "parent"),
-                    value: value.value === "none" ? null : canonicalTaskId(value, "parent"),
-                };
-            case "ready":
-                return parseBooleanPredicate("ready", operator, value);
-            case "blocked":
-                return parseBooleanPredicate("blocked", operator, value);
-            case "created":
-                return parseTimestampPredicate("created", operator, value);
-            case "updated":
-                return parseTimestampPredicate("updated", operator, value);
-            default:
-                return parseRelationPredicate(field, operator, value);
-        }
+        return parsedPredicate(field, operator, value);
     }
 }
 export function parseTaskQueryExpression(source) {
     if (source.trim().length === 0)
         return syntax("query expression must be nonblank", 0);
-    return normalizeTaskQuery(new Parser(lex(source)).parse());
+    return new Parser(lex(source)).parse();
 }
 export function validateTaskLimit(source) {
     if (!/^[1-9][0-9]*$/u.test(source) || !Number.isSafeInteger(Number(source)))
@@ -267,7 +186,7 @@ export function validateTaskLimit(source) {
 }
 export function validateTaskParent(source) {
     try {
-        normalizeTaskQuery({ kind: "predicate", predicate: { field: "under", operator: "=", value: source } });
+        normalizeTaskQueryPredicate({ field: "under", operator: "=", value: source });
     }
     catch {
         throw new Error("--parent requires a canonical TaskId");