@wrongstack/tools 0.308.6 → 0.309.0

package/dist/builtin.js

@@ -25425,13 +25425,7 @@ function broadcastTodoUpdate(context, todos) {
     to: `@session:${sessionId}`,
     type: "status",
     subject: `Kanban todo list updated (${todos.length} item${todos.length === 1 ? "" : "s"})`,
-    body: JSON.stringify({
-      kind: "kanban.todos.updated",
-      sessionId,
-      revision: context.state.revision,
-      todoCount: todos.length,
-      statusCounts
-    }),
+    body: `Shared Kanban board synced this session's todo list: ${todos.length} item${todos.length === 1 ? "" : "s"} \u2014 ${statusCounts.completed} completed, ${statusCounts.inProgress} in progress, ${statusCounts.pending} pending.`,
     priority: "normal",
     senderSessionId: sessionId
   }).catch(() => {
@@ -26246,6 +26240,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 +26260,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 +26423,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 +27113,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 +27322,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

@@ -25594,13 +25594,7 @@ function broadcastTodoUpdate(context, todos) {
     to: `@session:${sessionId}`,
     type: "status",
     subject: `Kanban todo list updated (${todos.length} item${todos.length === 1 ? "" : "s"})`,
-    body: JSON.stringify({
-      kind: "kanban.todos.updated",
-      sessionId,
-      revision: context.state.revision,
-      todoCount: todos.length,
-      statusCounts
-    }),
+    body: `Shared Kanban board synced this session's todo list: ${todos.length} item${todos.length === 1 ? "" : "s"} \u2014 ${statusCounts.completed} completed, ${statusCounts.inProgress} in progress, ${statusCounts.pending} pending.`,
     priority: "normal",
     senderSessionId: sessionId
   }).catch(() => {
@@ -26849,6 +26843,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 +26863,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 +27026,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 +27716,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 +27925,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

@@ -25425,13 +25425,7 @@ function broadcastTodoUpdate(context, todos) {
     to: `@session:${sessionId}`,
     type: "status",
     subject: `Kanban todo list updated (${todos.length} item${todos.length === 1 ? "" : "s"})`,
-    body: JSON.stringify({
-      kind: "kanban.todos.updated",
-      sessionId,
-      revision: context.state.revision,
-      todoCount: todos.length,
-      statusCounts
-    }),
+    body: `Shared Kanban board synced this session's todo list: ${todos.length} item${todos.length === 1 ? "" : "s"} \u2014 ${statusCounts.completed} completed, ${statusCounts.inProgress} in progress, ${statusCounts.pending} pending.`,
     priority: "normal",
     senderSessionId: sessionId
   }).catch(() => {
@@ -26246,6 +26240,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 +26260,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 +26423,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 +27113,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 +27322,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

@@ -226,13 +226,7 @@ function broadcastTodoUpdate(context, todos) {
     to: `@session:${sessionId}`,
     type: "status",
     subject: `Kanban todo list updated (${todos.length} item${todos.length === 1 ? "" : "s"})`,
-    body: JSON.stringify({
-      kind: "kanban.todos.updated",
-      sessionId,
-      revision: context.state.revision,
-      todoCount: todos.length,
-      statusCounts
-    }),
+    body: `Shared Kanban board synced this session's todo list: ${todos.length} item${todos.length === 1 ? "" : "s"} \u2014 ${statusCounts.completed} completed, ${statusCounts.inProgress} in progress, ${statusCounts.pending} pending.`,
     priority: "normal",
     senderSessionId: sessionId
   }).catch(() => {
@@ -1193,6 +1187,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 +1207,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 +1370,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 +2060,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 +2269,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/session-kanban.js

@@ -213,13 +213,7 @@ function broadcastTodoUpdate(context, todos) {
     to: `@session:${sessionId}`,
     type: "status",
     subject: `Kanban todo list updated (${todos.length} item${todos.length === 1 ? "" : "s"})`,
-    body: JSON.stringify({
-      kind: "kanban.todos.updated",
-      sessionId,
-      revision: context.state.revision,
-      todoCount: todos.length,
-      statusCounts
-    }),
+    body: `Shared Kanban board synced this session's todo list: ${todos.length} item${todos.length === 1 ? "" : "s"} \u2014 ${statusCounts.completed} completed, ${statusCounts.inProgress} in progress, ${statusCounts.pending} pending.`,
     priority: "normal",
     senderSessionId: sessionId
   }).catch(() => {

package/dist/task.js

@@ -186,13 +186,7 @@ function broadcastTodoUpdate(context, todos) {
     to: `@session:${sessionId}`,
     type: "status",
     subject: `Kanban todo list updated (${todos.length} item${todos.length === 1 ? "" : "s"})`,
-    body: JSON.stringify({
-      kind: "kanban.todos.updated",
-      sessionId,
-      revision: context.state.revision,
-      todoCount: todos.length,
-      statusCounts
-    }),
+    body: `Shared Kanban board synced this session's todo list: ${todos.length} item${todos.length === 1 ? "" : "s"} \u2014 ${statusCounts.completed} completed, ${statusCounts.inProgress} in progress, ${statusCounts.pending} pending.`,
     priority: "normal",
     senderSessionId: sessionId
   }).catch(() => {
@@ -1153,6 +1147,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 +1167,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 +1330,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 +2020,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 +2229,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

@@ -335,13 +335,7 @@ function broadcastTodoUpdate(context, todos) {
     to: `@session:${sessionId}`,
     type: "status",
     subject: `Kanban todo list updated (${todos.length} item${todos.length === 1 ? "" : "s"})`,
-    body: JSON.stringify({
-      kind: "kanban.todos.updated",
-      sessionId,
-      revision: context.state.revision,
-      todoCount: todos.length,
-      statusCounts
-    }),
+    body: `Shared Kanban board synced this session's todo list: ${todos.length} item${todos.length === 1 ? "" : "s"} \u2014 ${statusCounts.completed} completed, ${statusCounts.inProgress} in progress, ${statusCounts.pending} pending.`,
     priority: "normal",
     senderSessionId: sessionId
   }).catch(() => {
@@ -1140,6 +1134,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 +1154,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 +1317,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 +2007,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 +2216,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

@@ -25425,13 +25425,7 @@ function broadcastTodoUpdate(context, todos) {
     to: `@session:${sessionId}`,
     type: "status",
     subject: `Kanban todo list updated (${todos.length} item${todos.length === 1 ? "" : "s"})`,
-    body: JSON.stringify({
-      kind: "kanban.todos.updated",
-      sessionId,
-      revision: context.state.revision,
-      todoCount: todos.length,
-      statusCounts
-    }),
+    body: `Shared Kanban board synced this session's todo list: ${todos.length} item${todos.length === 1 ? "" : "s"} \u2014 ${statusCounts.completed} completed, ${statusCounts.inProgress} in progress, ${statusCounts.pending} pending.`,
     priority: "normal",
     senderSessionId: sessionId
   }).catch(() => {
@@ -26246,6 +26240,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 +26260,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 +26423,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 +27113,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 +27322,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.309.0",
   "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.309.0",
+    "@wrongstack/persistence": "0.309.0",
+    "@wrongstack/kanban": "0.309.0"
   },
   "devDependencies": {
     "@types/node": "^26.2.0",