@wrongstack/tools 0.308.6 → 0.308.7

package/dist/builtin.js

@@ -26246,6 +26246,7 @@ async function handleKanbanDetailAction(projectRoot, input) {
         ...input.metricStatus !== void 0 ? { status: input.metricStatus } : {},
         ...input.metricTarget !== void 0 ? { target: input.metricTarget } : {},
         ...input.metricCurrent !== void 0 ? { current: input.metricCurrent } : {},
+        ...input.metricDirection !== void 0 ? { direction: input.metricDirection } : {},
         ...input.metricUnit !== void 0 ? { unit: input.metricUnit } : {},
         ...input.metricNotes !== void 0 ? { notes: input.metricNotes } : {}
       });
@@ -26265,6 +26266,7 @@ async function handleKanbanDetailAction(projectRoot, input) {
           ...input.metricStatus !== void 0 ? { status: input.metricStatus } : {},
           ...input.metricTarget !== void 0 ? { target: input.metricTarget } : {},
           ...input.metricCurrent !== void 0 ? { current: input.metricCurrent } : {},
+          ...input.metricDirection !== void 0 ? { direction: input.metricDirection } : {},
           ...input.metricUnit !== void 0 ? { unit: input.metricUnit } : {},
           ...input.metricNotes !== void 0 ? { notes: input.metricNotes } : {}
         }
@@ -26427,6 +26429,7 @@ function taskInput(input) {
           status: input.metricStatus ?? "pending",
           ...input.metricTarget !== void 0 ? { target: input.metricTarget } : {},
           ...input.metricCurrent !== void 0 ? { current: input.metricCurrent } : {},
+          ...input.metricDirection !== void 0 ? { direction: input.metricDirection } : {},
           ...input.metricUnit !== void 0 ? { unit: input.metricUnit } : {},
           ...input.metricNotes !== void 0 ? { notes: input.metricNotes } : {}
         }
@@ -27116,7 +27119,7 @@ function serializeKanbanOutput(output, input) {
 
 // src/kanban-tool-schema.ts
 var KANBAN_TOOL_DESCRIPTION = "Durable project task boards: create and move cards, record checks, notes, links and assignments. The board is a record of the work, not a permit for it \u2014 nothing here gates other tools. Managed boards additionally enforce ordered Backlog \u2192 Todo \u2192 Running \u2192 Review \u2192 Done transitions; release_managed_lifecycle turns that off.";
-var KANBAN_TOOL_USAGE_HINT = 'Track substantial or multi-step work so it survives the session; a trivial edit or a question needs no card. Work stays on ONE board: call list_boards first and add_task to the board this project already uses. create_board is for a genuinely separate line of work, not for each new piece of it \u2014 a second board splits the same effort in two, and a board holding a single card is the usual sign. Common flow: list_boards or search_tasks to orient, add_task to record work, start_task when you begin, update_check with checkStatus "passed" to tick acceptance criteria (read their ids from get_task), then transition_task. On a managed board a refused transition names the field it wants \u2014 supply it and retry. When the acceptance criterion is something a machine can run, say so: set checkType ("command", "test", "file_exists", "file_matches", "git_diff", "metric") and put the command, pattern or path in checkNotes, then verify_completion executes it and the result is real evidence. Leave checkType off (or "manual") only for criteria that genuinely need a human eye \u2014 a manual check records your assertion, it does not test anything.';
+var KANBAN_TOOL_USAGE_HINT = 'Track substantial or multi-step work so it survives the session; a trivial edit or a question needs no card. Work stays on ONE board: call list_boards first and add_task to the board this project already uses. create_board is for a genuinely separate line of work, not for each new piece of it \u2014 a second board splits the same effort in two, and a board holding a single card is the usual sign. Common flow: list_boards or search_tasks to orient, add_task to record work, start_task when you begin, update_check with checkStatus "passed" to tick acceptance criteria (read their ids from get_task), then transition_task. On a managed board a refused transition names the field it wants \u2014 supply it and retry. When the acceptance criterion is something a machine can run, say so: set checkType ("command", "test", "file_exists", "file_matches", "git_diff", "metric") and put the command, pattern or path in checkNotes, then verify_completion executes it and the result is real evidence. Leave checkType off (or "manual") only for criteria that genuinely need a human eye \u2014 a manual check records your assertion, it does not test anything. Goal metrics pass when current >= target by default; when lower is better (error rate, cost ceiling, latency, open-bug count), pass metricDirection "at_most" with add_goal_metric / update_goal_metric so verification compares current <= target instead.';
 var KANBAN_INPUT_SCHEMA = {
   type: "object",
   properties: {
@@ -27325,6 +27328,7 @@ var KANBAN_INPUT_SCHEMA = {
     metricName: { type: "string" },
     metricTarget: { oneOf: [{ type: "string" }, { type: "number" }] },
     metricCurrent: { oneOf: [{ type: "string" }, { type: "number" }] },
+    metricDirection: { type: "string", enum: ["at_least", "at_most"] },
     metricUnit: { type: "string" },
     metricStatus: { type: "string", enum: ["pending", "met", "missed", "waived"] },
     metricNotes: { type: "string" },

package/dist/index.js

@@ -26849,6 +26849,7 @@ async function handleKanbanDetailAction(projectRoot, input) {
         ...input.metricStatus !== void 0 ? { status: input.metricStatus } : {},
         ...input.metricTarget !== void 0 ? { target: input.metricTarget } : {},
         ...input.metricCurrent !== void 0 ? { current: input.metricCurrent } : {},
+        ...input.metricDirection !== void 0 ? { direction: input.metricDirection } : {},
         ...input.metricUnit !== void 0 ? { unit: input.metricUnit } : {},
         ...input.metricNotes !== void 0 ? { notes: input.metricNotes } : {}
       });
@@ -26868,6 +26869,7 @@ async function handleKanbanDetailAction(projectRoot, input) {
           ...input.metricStatus !== void 0 ? { status: input.metricStatus } : {},
           ...input.metricTarget !== void 0 ? { target: input.metricTarget } : {},
           ...input.metricCurrent !== void 0 ? { current: input.metricCurrent } : {},
+          ...input.metricDirection !== void 0 ? { direction: input.metricDirection } : {},
           ...input.metricUnit !== void 0 ? { unit: input.metricUnit } : {},
           ...input.metricNotes !== void 0 ? { notes: input.metricNotes } : {}
         }
@@ -27030,6 +27032,7 @@ function taskInput(input) {
           status: input.metricStatus ?? "pending",
           ...input.metricTarget !== void 0 ? { target: input.metricTarget } : {},
           ...input.metricCurrent !== void 0 ? { current: input.metricCurrent } : {},
+          ...input.metricDirection !== void 0 ? { direction: input.metricDirection } : {},
           ...input.metricUnit !== void 0 ? { unit: input.metricUnit } : {},
           ...input.metricNotes !== void 0 ? { notes: input.metricNotes } : {}
         }
@@ -27719,7 +27722,7 @@ function serializeKanbanOutput(output, input) {
 
 // src/kanban-tool-schema.ts
 var KANBAN_TOOL_DESCRIPTION = "Durable project task boards: create and move cards, record checks, notes, links and assignments. The board is a record of the work, not a permit for it \u2014 nothing here gates other tools. Managed boards additionally enforce ordered Backlog \u2192 Todo \u2192 Running \u2192 Review \u2192 Done transitions; release_managed_lifecycle turns that off.";
-var KANBAN_TOOL_USAGE_HINT = 'Track substantial or multi-step work so it survives the session; a trivial edit or a question needs no card. Work stays on ONE board: call list_boards first and add_task to the board this project already uses. create_board is for a genuinely separate line of work, not for each new piece of it \u2014 a second board splits the same effort in two, and a board holding a single card is the usual sign. Common flow: list_boards or search_tasks to orient, add_task to record work, start_task when you begin, update_check with checkStatus "passed" to tick acceptance criteria (read their ids from get_task), then transition_task. On a managed board a refused transition names the field it wants \u2014 supply it and retry. When the acceptance criterion is something a machine can run, say so: set checkType ("command", "test", "file_exists", "file_matches", "git_diff", "metric") and put the command, pattern or path in checkNotes, then verify_completion executes it and the result is real evidence. Leave checkType off (or "manual") only for criteria that genuinely need a human eye \u2014 a manual check records your assertion, it does not test anything.';
+var KANBAN_TOOL_USAGE_HINT = 'Track substantial or multi-step work so it survives the session; a trivial edit or a question needs no card. Work stays on ONE board: call list_boards first and add_task to the board this project already uses. create_board is for a genuinely separate line of work, not for each new piece of it \u2014 a second board splits the same effort in two, and a board holding a single card is the usual sign. Common flow: list_boards or search_tasks to orient, add_task to record work, start_task when you begin, update_check with checkStatus "passed" to tick acceptance criteria (read their ids from get_task), then transition_task. On a managed board a refused transition names the field it wants \u2014 supply it and retry. When the acceptance criterion is something a machine can run, say so: set checkType ("command", "test", "file_exists", "file_matches", "git_diff", "metric") and put the command, pattern or path in checkNotes, then verify_completion executes it and the result is real evidence. Leave checkType off (or "manual") only for criteria that genuinely need a human eye \u2014 a manual check records your assertion, it does not test anything. Goal metrics pass when current >= target by default; when lower is better (error rate, cost ceiling, latency, open-bug count), pass metricDirection "at_most" with add_goal_metric / update_goal_metric so verification compares current <= target instead.';
 var KANBAN_INPUT_SCHEMA = {
   type: "object",
   properties: {
@@ -27928,6 +27931,7 @@ var KANBAN_INPUT_SCHEMA = {
     metricName: { type: "string" },
     metricTarget: { oneOf: [{ type: "string" }, { type: "number" }] },
     metricCurrent: { oneOf: [{ type: "string" }, { type: "number" }] },
+    metricDirection: { type: "string", enum: ["at_least", "at_most"] },
     metricUnit: { type: "string" },
     metricStatus: { type: "string", enum: ["pending", "met", "missed", "waived"] },
     metricNotes: { type: "string" },

package/dist/kanban-task-inputs.d.ts

@@ -33,6 +33,7 @@ export declare function taskInput(input: KanbanToolInput): {
         status: "met" | "missed" | "pending" | "waived";
         target?: string | number;
         current?: string | number;
+        direction?: "at_least" | "at_most";
         unit?: string;
         notes?: string;
     }[];

package/dist/kanban-tool-schema.d.ts

@@ -1,5 +1,5 @@
 import type { JSONSchema } from '@wrongstack/core/types';
 export declare const KANBAN_TOOL_DESCRIPTION = "Durable project task boards: create and move cards, record checks, notes, links and assignments. The board is a record of the work, not a permit for it \u2014 nothing here gates other tools. Managed boards additionally enforce ordered Backlog \u2192 Todo \u2192 Running \u2192 Review \u2192 Done transitions; release_managed_lifecycle turns that off.";
-export declare const KANBAN_TOOL_USAGE_HINT = "Track substantial or multi-step work so it survives the session; a trivial edit or a question needs no card. Work stays on ONE board: call list_boards first and add_task to the board this project already uses. create_board is for a genuinely separate line of work, not for each new piece of it \u2014 a second board splits the same effort in two, and a board holding a single card is the usual sign. Common flow: list_boards or search_tasks to orient, add_task to record work, start_task when you begin, update_check with checkStatus \"passed\" to tick acceptance criteria (read their ids from get_task), then transition_task. On a managed board a refused transition names the field it wants \u2014 supply it and retry. When the acceptance criterion is something a machine can run, say so: set checkType (\"command\", \"test\", \"file_exists\", \"file_matches\", \"git_diff\", \"metric\") and put the command, pattern or path in checkNotes, then verify_completion executes it and the result is real evidence. Leave checkType off (or \"manual\") only for criteria that genuinely need a human eye \u2014 a manual check records your assertion, it does not test anything.";
+export declare const KANBAN_TOOL_USAGE_HINT = "Track substantial or multi-step work so it survives the session; a trivial edit or a question needs no card. Work stays on ONE board: call list_boards first and add_task to the board this project already uses. create_board is for a genuinely separate line of work, not for each new piece of it \u2014 a second board splits the same effort in two, and a board holding a single card is the usual sign. Common flow: list_boards or search_tasks to orient, add_task to record work, start_task when you begin, update_check with checkStatus \"passed\" to tick acceptance criteria (read their ids from get_task), then transition_task. On a managed board a refused transition names the field it wants \u2014 supply it and retry. When the acceptance criterion is something a machine can run, say so: set checkType (\"command\", \"test\", \"file_exists\", \"file_matches\", \"git_diff\", \"metric\") and put the command, pattern or path in checkNotes, then verify_completion executes it and the result is real evidence. Leave checkType off (or \"manual\") only for criteria that genuinely need a human eye \u2014 a manual check records your assertion, it does not test anything. Goal metrics pass when current >= target by default; when lower is better (error rate, cost ceiling, latency, open-bug count), pass metricDirection \"at_most\" with add_goal_metric / update_goal_metric so verification compares current <= target instead.";
 export declare const KANBAN_INPUT_SCHEMA: JSONSchema;
 //# sourceMappingURL=kanban-tool-schema.d.ts.map

package/dist/kanban-tool-types.d.ts

@@ -41,6 +41,8 @@ export interface KanbanToolInput extends Omit<AssignKanbanTaskInput, 'status'> {
     metricName?: string | undefined;
     metricTarget?: string | number | undefined;
     metricCurrent?: string | number | undefined;
+    /** Comparison direction for the goal metric: `at_least` (default) or `at_most`. */
+    metricDirection?: 'at_least' | 'at_most' | undefined;
     metricUnit?: string | undefined;
     metricStatus?: 'pending' | 'met' | 'missed' | 'waived' | undefined;
     metricNotes?: string | undefined;

package/dist/kanban.js

@@ -721,6 +721,7 @@ async function handleKanbanDetailAction(projectRoot, input) {
         ...input.metricStatus !== void 0 ? { status: input.metricStatus } : {},
         ...input.metricTarget !== void 0 ? { target: input.metricTarget } : {},
         ...input.metricCurrent !== void 0 ? { current: input.metricCurrent } : {},
+        ...input.metricDirection !== void 0 ? { direction: input.metricDirection } : {},
         ...input.metricUnit !== void 0 ? { unit: input.metricUnit } : {},
         ...input.metricNotes !== void 0 ? { notes: input.metricNotes } : {}
       });
@@ -740,6 +741,7 @@ async function handleKanbanDetailAction(projectRoot, input) {
           ...input.metricStatus !== void 0 ? { status: input.metricStatus } : {},
           ...input.metricTarget !== void 0 ? { target: input.metricTarget } : {},
           ...input.metricCurrent !== void 0 ? { current: input.metricCurrent } : {},
+          ...input.metricDirection !== void 0 ? { direction: input.metricDirection } : {},
           ...input.metricUnit !== void 0 ? { unit: input.metricUnit } : {},
           ...input.metricNotes !== void 0 ? { notes: input.metricNotes } : {}
         }
@@ -902,6 +904,7 @@ function taskInput(input) {
           status: input.metricStatus ?? "pending",
           ...input.metricTarget !== void 0 ? { target: input.metricTarget } : {},
           ...input.metricCurrent !== void 0 ? { current: input.metricCurrent } : {},
+          ...input.metricDirection !== void 0 ? { direction: input.metricDirection } : {},
           ...input.metricUnit !== void 0 ? { unit: input.metricUnit } : {},
           ...input.metricNotes !== void 0 ? { notes: input.metricNotes } : {}
         }
@@ -1591,7 +1594,7 @@ function serializeKanbanOutput(output, input) {
 
 // src/kanban-tool-schema.ts
 var KANBAN_TOOL_DESCRIPTION = "Durable project task boards: create and move cards, record checks, notes, links and assignments. The board is a record of the work, not a permit for it \u2014 nothing here gates other tools. Managed boards additionally enforce ordered Backlog \u2192 Todo \u2192 Running \u2192 Review \u2192 Done transitions; release_managed_lifecycle turns that off.";
-var KANBAN_TOOL_USAGE_HINT = 'Track substantial or multi-step work so it survives the session; a trivial edit or a question needs no card. Work stays on ONE board: call list_boards first and add_task to the board this project already uses. create_board is for a genuinely separate line of work, not for each new piece of it \u2014 a second board splits the same effort in two, and a board holding a single card is the usual sign. Common flow: list_boards or search_tasks to orient, add_task to record work, start_task when you begin, update_check with checkStatus "passed" to tick acceptance criteria (read their ids from get_task), then transition_task. On a managed board a refused transition names the field it wants \u2014 supply it and retry. When the acceptance criterion is something a machine can run, say so: set checkType ("command", "test", "file_exists", "file_matches", "git_diff", "metric") and put the command, pattern or path in checkNotes, then verify_completion executes it and the result is real evidence. Leave checkType off (or "manual") only for criteria that genuinely need a human eye \u2014 a manual check records your assertion, it does not test anything.';
+var KANBAN_TOOL_USAGE_HINT = 'Track substantial or multi-step work so it survives the session; a trivial edit or a question needs no card. Work stays on ONE board: call list_boards first and add_task to the board this project already uses. create_board is for a genuinely separate line of work, not for each new piece of it \u2014 a second board splits the same effort in two, and a board holding a single card is the usual sign. Common flow: list_boards or search_tasks to orient, add_task to record work, start_task when you begin, update_check with checkStatus "passed" to tick acceptance criteria (read their ids from get_task), then transition_task. On a managed board a refused transition names the field it wants \u2014 supply it and retry. When the acceptance criterion is something a machine can run, say so: set checkType ("command", "test", "file_exists", "file_matches", "git_diff", "metric") and put the command, pattern or path in checkNotes, then verify_completion executes it and the result is real evidence. Leave checkType off (or "manual") only for criteria that genuinely need a human eye \u2014 a manual check records your assertion, it does not test anything. Goal metrics pass when current >= target by default; when lower is better (error rate, cost ceiling, latency, open-bug count), pass metricDirection "at_most" with add_goal_metric / update_goal_metric so verification compares current <= target instead.';
 var KANBAN_INPUT_SCHEMA = {
   type: "object",
   properties: {
@@ -1800,6 +1803,7 @@ var KANBAN_INPUT_SCHEMA = {
     metricName: { type: "string" },
     metricTarget: { oneOf: [{ type: "string" }, { type: "number" }] },
     metricCurrent: { oneOf: [{ type: "string" }, { type: "number" }] },
+    metricDirection: { type: "string", enum: ["at_least", "at_most"] },
     metricUnit: { type: "string" },
     metricStatus: { type: "string", enum: ["pending", "met", "missed", "waived"] },
     metricNotes: { type: "string" },

package/dist/pack.js

@@ -26246,6 +26246,7 @@ async function handleKanbanDetailAction(projectRoot, input) {
         ...input.metricStatus !== void 0 ? { status: input.metricStatus } : {},
         ...input.metricTarget !== void 0 ? { target: input.metricTarget } : {},
         ...input.metricCurrent !== void 0 ? { current: input.metricCurrent } : {},
+        ...input.metricDirection !== void 0 ? { direction: input.metricDirection } : {},
         ...input.metricUnit !== void 0 ? { unit: input.metricUnit } : {},
         ...input.metricNotes !== void 0 ? { notes: input.metricNotes } : {}
       });
@@ -26265,6 +26266,7 @@ async function handleKanbanDetailAction(projectRoot, input) {
           ...input.metricStatus !== void 0 ? { status: input.metricStatus } : {},
           ...input.metricTarget !== void 0 ? { target: input.metricTarget } : {},
           ...input.metricCurrent !== void 0 ? { current: input.metricCurrent } : {},
+          ...input.metricDirection !== void 0 ? { direction: input.metricDirection } : {},
           ...input.metricUnit !== void 0 ? { unit: input.metricUnit } : {},
           ...input.metricNotes !== void 0 ? { notes: input.metricNotes } : {}
         }
@@ -26427,6 +26429,7 @@ function taskInput(input) {
           status: input.metricStatus ?? "pending",
           ...input.metricTarget !== void 0 ? { target: input.metricTarget } : {},
           ...input.metricCurrent !== void 0 ? { current: input.metricCurrent } : {},
+          ...input.metricDirection !== void 0 ? { direction: input.metricDirection } : {},
           ...input.metricUnit !== void 0 ? { unit: input.metricUnit } : {},
           ...input.metricNotes !== void 0 ? { notes: input.metricNotes } : {}
         }
@@ -27116,7 +27119,7 @@ function serializeKanbanOutput(output, input) {
 
 // src/kanban-tool-schema.ts
 var KANBAN_TOOL_DESCRIPTION = "Durable project task boards: create and move cards, record checks, notes, links and assignments. The board is a record of the work, not a permit for it \u2014 nothing here gates other tools. Managed boards additionally enforce ordered Backlog \u2192 Todo \u2192 Running \u2192 Review \u2192 Done transitions; release_managed_lifecycle turns that off.";
-var KANBAN_TOOL_USAGE_HINT = 'Track substantial or multi-step work so it survives the session; a trivial edit or a question needs no card. Work stays on ONE board: call list_boards first and add_task to the board this project already uses. create_board is for a genuinely separate line of work, not for each new piece of it \u2014 a second board splits the same effort in two, and a board holding a single card is the usual sign. Common flow: list_boards or search_tasks to orient, add_task to record work, start_task when you begin, update_check with checkStatus "passed" to tick acceptance criteria (read their ids from get_task), then transition_task. On a managed board a refused transition names the field it wants \u2014 supply it and retry. When the acceptance criterion is something a machine can run, say so: set checkType ("command", "test", "file_exists", "file_matches", "git_diff", "metric") and put the command, pattern or path in checkNotes, then verify_completion executes it and the result is real evidence. Leave checkType off (or "manual") only for criteria that genuinely need a human eye \u2014 a manual check records your assertion, it does not test anything.';
+var KANBAN_TOOL_USAGE_HINT = 'Track substantial or multi-step work so it survives the session; a trivial edit or a question needs no card. Work stays on ONE board: call list_boards first and add_task to the board this project already uses. create_board is for a genuinely separate line of work, not for each new piece of it \u2014 a second board splits the same effort in two, and a board holding a single card is the usual sign. Common flow: list_boards or search_tasks to orient, add_task to record work, start_task when you begin, update_check with checkStatus "passed" to tick acceptance criteria (read their ids from get_task), then transition_task. On a managed board a refused transition names the field it wants \u2014 supply it and retry. When the acceptance criterion is something a machine can run, say so: set checkType ("command", "test", "file_exists", "file_matches", "git_diff", "metric") and put the command, pattern or path in checkNotes, then verify_completion executes it and the result is real evidence. Leave checkType off (or "manual") only for criteria that genuinely need a human eye \u2014 a manual check records your assertion, it does not test anything. Goal metrics pass when current >= target by default; when lower is better (error rate, cost ceiling, latency, open-bug count), pass metricDirection "at_most" with add_goal_metric / update_goal_metric so verification compares current <= target instead.';
 var KANBAN_INPUT_SCHEMA = {
   type: "object",
   properties: {
@@ -27325,6 +27328,7 @@ var KANBAN_INPUT_SCHEMA = {
     metricName: { type: "string" },
     metricTarget: { oneOf: [{ type: "string" }, { type: "number" }] },
     metricCurrent: { oneOf: [{ type: "string" }, { type: "number" }] },
+    metricDirection: { type: "string", enum: ["at_least", "at_most"] },
     metricUnit: { type: "string" },
     metricStatus: { type: "string", enum: ["pending", "met", "missed", "waived"] },
     metricNotes: { type: "string" },

package/dist/plan.js

@@ -1193,6 +1193,7 @@ async function handleKanbanDetailAction(projectRoot, input) {
         ...input.metricStatus !== void 0 ? { status: input.metricStatus } : {},
         ...input.metricTarget !== void 0 ? { target: input.metricTarget } : {},
         ...input.metricCurrent !== void 0 ? { current: input.metricCurrent } : {},
+        ...input.metricDirection !== void 0 ? { direction: input.metricDirection } : {},
         ...input.metricUnit !== void 0 ? { unit: input.metricUnit } : {},
         ...input.metricNotes !== void 0 ? { notes: input.metricNotes } : {}
       });
@@ -1212,6 +1213,7 @@ async function handleKanbanDetailAction(projectRoot, input) {
           ...input.metricStatus !== void 0 ? { status: input.metricStatus } : {},
           ...input.metricTarget !== void 0 ? { target: input.metricTarget } : {},
           ...input.metricCurrent !== void 0 ? { current: input.metricCurrent } : {},
+          ...input.metricDirection !== void 0 ? { direction: input.metricDirection } : {},
           ...input.metricUnit !== void 0 ? { unit: input.metricUnit } : {},
           ...input.metricNotes !== void 0 ? { notes: input.metricNotes } : {}
         }
@@ -1374,6 +1376,7 @@ function taskInput(input) {
           status: input.metricStatus ?? "pending",
           ...input.metricTarget !== void 0 ? { target: input.metricTarget } : {},
           ...input.metricCurrent !== void 0 ? { current: input.metricCurrent } : {},
+          ...input.metricDirection !== void 0 ? { direction: input.metricDirection } : {},
           ...input.metricUnit !== void 0 ? { unit: input.metricUnit } : {},
           ...input.metricNotes !== void 0 ? { notes: input.metricNotes } : {}
         }
@@ -2063,7 +2066,7 @@ function serializeKanbanOutput(output, input) {
 
 // src/kanban-tool-schema.ts
 var KANBAN_TOOL_DESCRIPTION = "Durable project task boards: create and move cards, record checks, notes, links and assignments. The board is a record of the work, not a permit for it \u2014 nothing here gates other tools. Managed boards additionally enforce ordered Backlog \u2192 Todo \u2192 Running \u2192 Review \u2192 Done transitions; release_managed_lifecycle turns that off.";
-var KANBAN_TOOL_USAGE_HINT = 'Track substantial or multi-step work so it survives the session; a trivial edit or a question needs no card. Work stays on ONE board: call list_boards first and add_task to the board this project already uses. create_board is for a genuinely separate line of work, not for each new piece of it \u2014 a second board splits the same effort in two, and a board holding a single card is the usual sign. Common flow: list_boards or search_tasks to orient, add_task to record work, start_task when you begin, update_check with checkStatus "passed" to tick acceptance criteria (read their ids from get_task), then transition_task. On a managed board a refused transition names the field it wants \u2014 supply it and retry. When the acceptance criterion is something a machine can run, say so: set checkType ("command", "test", "file_exists", "file_matches", "git_diff", "metric") and put the command, pattern or path in checkNotes, then verify_completion executes it and the result is real evidence. Leave checkType off (or "manual") only for criteria that genuinely need a human eye \u2014 a manual check records your assertion, it does not test anything.';
+var KANBAN_TOOL_USAGE_HINT = 'Track substantial or multi-step work so it survives the session; a trivial edit or a question needs no card. Work stays on ONE board: call list_boards first and add_task to the board this project already uses. create_board is for a genuinely separate line of work, not for each new piece of it \u2014 a second board splits the same effort in two, and a board holding a single card is the usual sign. Common flow: list_boards or search_tasks to orient, add_task to record work, start_task when you begin, update_check with checkStatus "passed" to tick acceptance criteria (read their ids from get_task), then transition_task. On a managed board a refused transition names the field it wants \u2014 supply it and retry. When the acceptance criterion is something a machine can run, say so: set checkType ("command", "test", "file_exists", "file_matches", "git_diff", "metric") and put the command, pattern or path in checkNotes, then verify_completion executes it and the result is real evidence. Leave checkType off (or "manual") only for criteria that genuinely need a human eye \u2014 a manual check records your assertion, it does not test anything. Goal metrics pass when current >= target by default; when lower is better (error rate, cost ceiling, latency, open-bug count), pass metricDirection "at_most" with add_goal_metric / update_goal_metric so verification compares current <= target instead.';
 var KANBAN_INPUT_SCHEMA = {
   type: "object",
   properties: {
@@ -2272,6 +2275,7 @@ var KANBAN_INPUT_SCHEMA = {
     metricName: { type: "string" },
     metricTarget: { oneOf: [{ type: "string" }, { type: "number" }] },
     metricCurrent: { oneOf: [{ type: "string" }, { type: "number" }] },
+    metricDirection: { type: "string", enum: ["at_least", "at_most"] },
     metricUnit: { type: "string" },
     metricStatus: { type: "string", enum: ["pending", "met", "missed", "waived"] },
     metricNotes: { type: "string" },

package/dist/task.js

@@ -1153,6 +1153,7 @@ async function handleKanbanDetailAction(projectRoot, input) {
         ...input.metricStatus !== void 0 ? { status: input.metricStatus } : {},
         ...input.metricTarget !== void 0 ? { target: input.metricTarget } : {},
         ...input.metricCurrent !== void 0 ? { current: input.metricCurrent } : {},
+        ...input.metricDirection !== void 0 ? { direction: input.metricDirection } : {},
         ...input.metricUnit !== void 0 ? { unit: input.metricUnit } : {},
         ...input.metricNotes !== void 0 ? { notes: input.metricNotes } : {}
       });
@@ -1172,6 +1173,7 @@ async function handleKanbanDetailAction(projectRoot, input) {
           ...input.metricStatus !== void 0 ? { status: input.metricStatus } : {},
           ...input.metricTarget !== void 0 ? { target: input.metricTarget } : {},
           ...input.metricCurrent !== void 0 ? { current: input.metricCurrent } : {},
+          ...input.metricDirection !== void 0 ? { direction: input.metricDirection } : {},
           ...input.metricUnit !== void 0 ? { unit: input.metricUnit } : {},
           ...input.metricNotes !== void 0 ? { notes: input.metricNotes } : {}
         }
@@ -1334,6 +1336,7 @@ function taskInput(input) {
           status: input.metricStatus ?? "pending",
           ...input.metricTarget !== void 0 ? { target: input.metricTarget } : {},
           ...input.metricCurrent !== void 0 ? { current: input.metricCurrent } : {},
+          ...input.metricDirection !== void 0 ? { direction: input.metricDirection } : {},
           ...input.metricUnit !== void 0 ? { unit: input.metricUnit } : {},
           ...input.metricNotes !== void 0 ? { notes: input.metricNotes } : {}
         }
@@ -2023,7 +2026,7 @@ function serializeKanbanOutput(output, input) {
 
 // src/kanban-tool-schema.ts
 var KANBAN_TOOL_DESCRIPTION = "Durable project task boards: create and move cards, record checks, notes, links and assignments. The board is a record of the work, not a permit for it \u2014 nothing here gates other tools. Managed boards additionally enforce ordered Backlog \u2192 Todo \u2192 Running \u2192 Review \u2192 Done transitions; release_managed_lifecycle turns that off.";
-var KANBAN_TOOL_USAGE_HINT = 'Track substantial or multi-step work so it survives the session; a trivial edit or a question needs no card. Work stays on ONE board: call list_boards first and add_task to the board this project already uses. create_board is for a genuinely separate line of work, not for each new piece of it \u2014 a second board splits the same effort in two, and a board holding a single card is the usual sign. Common flow: list_boards or search_tasks to orient, add_task to record work, start_task when you begin, update_check with checkStatus "passed" to tick acceptance criteria (read their ids from get_task), then transition_task. On a managed board a refused transition names the field it wants \u2014 supply it and retry. When the acceptance criterion is something a machine can run, say so: set checkType ("command", "test", "file_exists", "file_matches", "git_diff", "metric") and put the command, pattern or path in checkNotes, then verify_completion executes it and the result is real evidence. Leave checkType off (or "manual") only for criteria that genuinely need a human eye \u2014 a manual check records your assertion, it does not test anything.';
+var KANBAN_TOOL_USAGE_HINT = 'Track substantial or multi-step work so it survives the session; a trivial edit or a question needs no card. Work stays on ONE board: call list_boards first and add_task to the board this project already uses. create_board is for a genuinely separate line of work, not for each new piece of it \u2014 a second board splits the same effort in two, and a board holding a single card is the usual sign. Common flow: list_boards or search_tasks to orient, add_task to record work, start_task when you begin, update_check with checkStatus "passed" to tick acceptance criteria (read their ids from get_task), then transition_task. On a managed board a refused transition names the field it wants \u2014 supply it and retry. When the acceptance criterion is something a machine can run, say so: set checkType ("command", "test", "file_exists", "file_matches", "git_diff", "metric") and put the command, pattern or path in checkNotes, then verify_completion executes it and the result is real evidence. Leave checkType off (or "manual") only for criteria that genuinely need a human eye \u2014 a manual check records your assertion, it does not test anything. Goal metrics pass when current >= target by default; when lower is better (error rate, cost ceiling, latency, open-bug count), pass metricDirection "at_most" with add_goal_metric / update_goal_metric so verification compares current <= target instead.';
 var KANBAN_INPUT_SCHEMA = {
   type: "object",
   properties: {
@@ -2232,6 +2235,7 @@ var KANBAN_INPUT_SCHEMA = {
     metricName: { type: "string" },
     metricTarget: { oneOf: [{ type: "string" }, { type: "number" }] },
     metricCurrent: { oneOf: [{ type: "string" }, { type: "number" }] },
+    metricDirection: { type: "string", enum: ["at_least", "at_most"] },
     metricUnit: { type: "string" },
     metricStatus: { type: "string", enum: ["pending", "met", "missed", "waived"] },
     metricNotes: { type: "string" },

package/dist/todo.js

@@ -1140,6 +1140,7 @@ async function handleKanbanDetailAction(projectRoot, input) {
         ...input.metricStatus !== void 0 ? { status: input.metricStatus } : {},
         ...input.metricTarget !== void 0 ? { target: input.metricTarget } : {},
         ...input.metricCurrent !== void 0 ? { current: input.metricCurrent } : {},
+        ...input.metricDirection !== void 0 ? { direction: input.metricDirection } : {},
         ...input.metricUnit !== void 0 ? { unit: input.metricUnit } : {},
         ...input.metricNotes !== void 0 ? { notes: input.metricNotes } : {}
       });
@@ -1159,6 +1160,7 @@ async function handleKanbanDetailAction(projectRoot, input) {
           ...input.metricStatus !== void 0 ? { status: input.metricStatus } : {},
           ...input.metricTarget !== void 0 ? { target: input.metricTarget } : {},
           ...input.metricCurrent !== void 0 ? { current: input.metricCurrent } : {},
+          ...input.metricDirection !== void 0 ? { direction: input.metricDirection } : {},
           ...input.metricUnit !== void 0 ? { unit: input.metricUnit } : {},
           ...input.metricNotes !== void 0 ? { notes: input.metricNotes } : {}
         }
@@ -1321,6 +1323,7 @@ function taskInput(input) {
           status: input.metricStatus ?? "pending",
           ...input.metricTarget !== void 0 ? { target: input.metricTarget } : {},
           ...input.metricCurrent !== void 0 ? { current: input.metricCurrent } : {},
+          ...input.metricDirection !== void 0 ? { direction: input.metricDirection } : {},
           ...input.metricUnit !== void 0 ? { unit: input.metricUnit } : {},
           ...input.metricNotes !== void 0 ? { notes: input.metricNotes } : {}
         }
@@ -2010,7 +2013,7 @@ function serializeKanbanOutput(output, input) {
 
 // src/kanban-tool-schema.ts
 var KANBAN_TOOL_DESCRIPTION = "Durable project task boards: create and move cards, record checks, notes, links and assignments. The board is a record of the work, not a permit for it \u2014 nothing here gates other tools. Managed boards additionally enforce ordered Backlog \u2192 Todo \u2192 Running \u2192 Review \u2192 Done transitions; release_managed_lifecycle turns that off.";
-var KANBAN_TOOL_USAGE_HINT = 'Track substantial or multi-step work so it survives the session; a trivial edit or a question needs no card. Work stays on ONE board: call list_boards first and add_task to the board this project already uses. create_board is for a genuinely separate line of work, not for each new piece of it \u2014 a second board splits the same effort in two, and a board holding a single card is the usual sign. Common flow: list_boards or search_tasks to orient, add_task to record work, start_task when you begin, update_check with checkStatus "passed" to tick acceptance criteria (read their ids from get_task), then transition_task. On a managed board a refused transition names the field it wants \u2014 supply it and retry. When the acceptance criterion is something a machine can run, say so: set checkType ("command", "test", "file_exists", "file_matches", "git_diff", "metric") and put the command, pattern or path in checkNotes, then verify_completion executes it and the result is real evidence. Leave checkType off (or "manual") only for criteria that genuinely need a human eye \u2014 a manual check records your assertion, it does not test anything.';
+var KANBAN_TOOL_USAGE_HINT = 'Track substantial or multi-step work so it survives the session; a trivial edit or a question needs no card. Work stays on ONE board: call list_boards first and add_task to the board this project already uses. create_board is for a genuinely separate line of work, not for each new piece of it \u2014 a second board splits the same effort in two, and a board holding a single card is the usual sign. Common flow: list_boards or search_tasks to orient, add_task to record work, start_task when you begin, update_check with checkStatus "passed" to tick acceptance criteria (read their ids from get_task), then transition_task. On a managed board a refused transition names the field it wants \u2014 supply it and retry. When the acceptance criterion is something a machine can run, say so: set checkType ("command", "test", "file_exists", "file_matches", "git_diff", "metric") and put the command, pattern or path in checkNotes, then verify_completion executes it and the result is real evidence. Leave checkType off (or "manual") only for criteria that genuinely need a human eye \u2014 a manual check records your assertion, it does not test anything. Goal metrics pass when current >= target by default; when lower is better (error rate, cost ceiling, latency, open-bug count), pass metricDirection "at_most" with add_goal_metric / update_goal_metric so verification compares current <= target instead.';
 var KANBAN_INPUT_SCHEMA = {
   type: "object",
   properties: {
@@ -2219,6 +2222,7 @@ var KANBAN_INPUT_SCHEMA = {
     metricName: { type: "string" },
     metricTarget: { oneOf: [{ type: "string" }, { type: "number" }] },
     metricCurrent: { oneOf: [{ type: "string" }, { type: "number" }] },
+    metricDirection: { type: "string", enum: ["at_least", "at_most"] },
     metricUnit: { type: "string" },
     metricStatus: { type: "string", enum: ["pending", "met", "missed", "waived"] },
     metricNotes: { type: "string" },

package/dist/tool-tier.js

@@ -26246,6 +26246,7 @@ async function handleKanbanDetailAction(projectRoot, input) {
         ...input.metricStatus !== void 0 ? { status: input.metricStatus } : {},
         ...input.metricTarget !== void 0 ? { target: input.metricTarget } : {},
         ...input.metricCurrent !== void 0 ? { current: input.metricCurrent } : {},
+        ...input.metricDirection !== void 0 ? { direction: input.metricDirection } : {},
         ...input.metricUnit !== void 0 ? { unit: input.metricUnit } : {},
         ...input.metricNotes !== void 0 ? { notes: input.metricNotes } : {}
       });
@@ -26265,6 +26266,7 @@ async function handleKanbanDetailAction(projectRoot, input) {
           ...input.metricStatus !== void 0 ? { status: input.metricStatus } : {},
           ...input.metricTarget !== void 0 ? { target: input.metricTarget } : {},
           ...input.metricCurrent !== void 0 ? { current: input.metricCurrent } : {},
+          ...input.metricDirection !== void 0 ? { direction: input.metricDirection } : {},
           ...input.metricUnit !== void 0 ? { unit: input.metricUnit } : {},
           ...input.metricNotes !== void 0 ? { notes: input.metricNotes } : {}
         }
@@ -26427,6 +26429,7 @@ function taskInput(input) {
           status: input.metricStatus ?? "pending",
           ...input.metricTarget !== void 0 ? { target: input.metricTarget } : {},
           ...input.metricCurrent !== void 0 ? { current: input.metricCurrent } : {},
+          ...input.metricDirection !== void 0 ? { direction: input.metricDirection } : {},
           ...input.metricUnit !== void 0 ? { unit: input.metricUnit } : {},
           ...input.metricNotes !== void 0 ? { notes: input.metricNotes } : {}
         }
@@ -27116,7 +27119,7 @@ function serializeKanbanOutput(output, input) {
 
 // src/kanban-tool-schema.ts
 var KANBAN_TOOL_DESCRIPTION = "Durable project task boards: create and move cards, record checks, notes, links and assignments. The board is a record of the work, not a permit for it \u2014 nothing here gates other tools. Managed boards additionally enforce ordered Backlog \u2192 Todo \u2192 Running \u2192 Review \u2192 Done transitions; release_managed_lifecycle turns that off.";
-var KANBAN_TOOL_USAGE_HINT = 'Track substantial or multi-step work so it survives the session; a trivial edit or a question needs no card. Work stays on ONE board: call list_boards first and add_task to the board this project already uses. create_board is for a genuinely separate line of work, not for each new piece of it \u2014 a second board splits the same effort in two, and a board holding a single card is the usual sign. Common flow: list_boards or search_tasks to orient, add_task to record work, start_task when you begin, update_check with checkStatus "passed" to tick acceptance criteria (read their ids from get_task), then transition_task. On a managed board a refused transition names the field it wants \u2014 supply it and retry. When the acceptance criterion is something a machine can run, say so: set checkType ("command", "test", "file_exists", "file_matches", "git_diff", "metric") and put the command, pattern or path in checkNotes, then verify_completion executes it and the result is real evidence. Leave checkType off (or "manual") only for criteria that genuinely need a human eye \u2014 a manual check records your assertion, it does not test anything.';
+var KANBAN_TOOL_USAGE_HINT = 'Track substantial or multi-step work so it survives the session; a trivial edit or a question needs no card. Work stays on ONE board: call list_boards first and add_task to the board this project already uses. create_board is for a genuinely separate line of work, not for each new piece of it \u2014 a second board splits the same effort in two, and a board holding a single card is the usual sign. Common flow: list_boards or search_tasks to orient, add_task to record work, start_task when you begin, update_check with checkStatus "passed" to tick acceptance criteria (read their ids from get_task), then transition_task. On a managed board a refused transition names the field it wants \u2014 supply it and retry. When the acceptance criterion is something a machine can run, say so: set checkType ("command", "test", "file_exists", "file_matches", "git_diff", "metric") and put the command, pattern or path in checkNotes, then verify_completion executes it and the result is real evidence. Leave checkType off (or "manual") only for criteria that genuinely need a human eye \u2014 a manual check records your assertion, it does not test anything. Goal metrics pass when current >= target by default; when lower is better (error rate, cost ceiling, latency, open-bug count), pass metricDirection "at_most" with add_goal_metric / update_goal_metric so verification compares current <= target instead.';
 var KANBAN_INPUT_SCHEMA = {
   type: "object",
   properties: {
@@ -27325,6 +27328,7 @@ var KANBAN_INPUT_SCHEMA = {
     metricName: { type: "string" },
     metricTarget: { oneOf: [{ type: "string" }, { type: "number" }] },
     metricCurrent: { oneOf: [{ type: "string" }, { type: "number" }] },
+    metricDirection: { type: "string", enum: ["at_least", "at_most"] },
     metricUnit: { type: "string" },
     metricStatus: { type: "string", enum: ["pending", "met", "missed", "waived"] },
     metricNotes: { type: "string" },

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@wrongstack/tools",
-  "version": "0.308.6",
+  "version": "0.308.7",
   "license": "MIT",
   "description": "WrongStack built-in tools: read/write/edit, bash/exec, grep/glob, git, fetch, test, lint, and more.",
   "repository": {
@@ -253,9 +253,9 @@
     "turndown": "^7.2.4",
     "undici": "^8.10.0",
     "web-tree-sitter": "0.26.12",
-    "@wrongstack/kanban": "0.308.6",
-    "@wrongstack/core": "0.308.6",
-    "@wrongstack/persistence": "0.308.6"
+    "@wrongstack/core": "0.308.7",
+    "@wrongstack/persistence": "0.308.7",
+    "@wrongstack/kanban": "0.308.7"
   },
   "devDependencies": {
     "@types/node": "^26.2.0",