@astrosheep/keiyaku 2.9.5 → 2.9.6

package/build/core/task/query.js

@@ -2,10 +2,16 @@ import { FlowError } from "../../flow-error.js";
 import { isCommissionId } from "../ids.js";
 import { taskUpdatedAt } from "./model.js";
 import { isTaskId } from "./validation.js";
-const FILTER_FIELDS = new Set([
-    "state", "priority", "parent", "needs", "blocks", "contract", "created", "updated",
-]);
+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])$/;
@@ -21,57 +27,87 @@ export function deriveTaskDisplay(task) {
         return "in_progress";
     return task.blocked ? "blocked" : "ready";
 }
-function invalidFilter(detail) {
-    throw new FlowError("INVALID_TARGET", `invalid task filter: ${detail}`);
+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],
+            })),
+        },
+    });
 }
-export function parseTaskFilter(expression) {
-    const match = /^([a-z][a-z0-9_-]*)(!=|<=|>=|=|<|>)(.*)$/.exec(expression);
+function parseTaskFilterTerm(term, expression, recoveredTerms) {
+    const match = /^([a-z][a-z0-9_-]*)(!=|<=|>=|~|=|<|>)(.*)$/.exec(term);
     if (!match)
-        invalidFilter(`'${expression}' must use FIELD OP VALUE`);
+        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}'`);
-    if (!ORDERED_FIELDS.has(field) && operator !== "=" && operator !== "!=") {
-        invalidFilter(`field '${field}' does not support operator '${operator}'`);
+        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`);
-    validateFilterValues(field, values);
+        invalidFilter(`field '${field}' has an empty value`, recoveredTerms);
+    validateFilterValues(field, values, recoveredTerms);
     return { field, operator, values };
 }
-function parseTimestamp(value, nowMs) {
+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`);
+            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>`);
+        invalidFilter(`timestamp '${value}' must be canonical ISO-8601 or now-<duration>`, recoveredTerms);
     }
     return timestamp;
 }
-function validateFilterValues(field, values) {
+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}'`);
+                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`);
+                invalidFilter(`priority '${value}' must be 0 through 3`, recoveredTerms);
         return;
     }
     if (field === "created" || field === "updated") {
         for (const value of values)
-            parseTimestamp(value, 0);
+            parseTimestamp(value, 0, recoveredTerms);
         return;
     }
     if (field === "parent" || field === "needs" || field === "blocks") {
@@ -79,14 +115,14 @@ function validateFilterValues(field, values) {
             if (field === "parent" && value === "none")
                 continue;
             if (!isTaskId(value))
-                invalidFilter(`value '${value}' must be a canonical full task id`);
+                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`);
+                invalidFilter(`value '${value}' must be a full commission id or none`, recoveredTerms);
         }
     }
 }
@@ -114,10 +150,16 @@ function compareValue(left, right, operator) {
         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")
@@ -167,6 +209,6 @@ export function selectTaskList(tasks, options = {}) {
     const nowMs = options.nowMs ?? Date.now();
     return tasks
         .filter((task) => selected(task, options.selection ?? "default"))
-        .filter((task) => filters.every((filter) => matchesFilter(task, filter, nowMs)))
+        .filter((task) => filters.every((filter) => filter.some((term) => matchesFilter(task, term, nowMs))))
         .sort(sort === undefined ? defaultCompare : (left, right) => explicitCompare(sort, left, right));
 }

package/build/generated/version.js

@@ -1,3 +1,3 @@
 // Generated into build output by scripts/build.mjs
-export const VERSION = "2.9.5";
-export const GIT_HASH = "ade1510";
+export const VERSION = "2.9.6";
+export const GIT_HASH = "cb7f9ef";

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@astrosheep/keiyaku",
-  "version": "2.9.5",
+  "version": "2.9.6",
   "description": "CLI for running iterative keiyaku workflows with Codex subagents.",
   "license": "MIT",
   "type": "module",

package/skills/keiyaku-workflow/SKILL.md

@@ -67,6 +67,12 @@ means it constructed the report, not that the candidate is acceptable. Use
 Commissioned workers never write Git metadata. The host alone reviews and
 commits accepted bytes before `arc`, `renew`, or `petition`.
 
+Dispatch rule: every time a dispatcher sends a worker, whether through
+`keiyaku call` or any other agent tool, the prompt must explicitly tell that
+worker to read the worktree-root `.keiyaku/KEIYAKU.md` first and follow its
+objective, scope, and checks. The file is the contract-body carrier; do not
+copy its rendered body into a dispatch prompt.
+
 ## Mid-flight commands (use when needed, skip otherwise)
 
 ```bash