@pellux/goodvibes-agent 1.6.2 → 1.6.4

package/CHANGELOG.md

@@ -2,6 +2,14 @@
 
 Product-facing release notes for GoodVibes Agent.
 
+## 1.6.4 - 2026-07-07
+
+- The exec tool no longer denies destructive- or escalation-class commands (kill, docker, sudo) that the permission configuration allows — class-level risk is decided by permission settings alone. The only remaining unconditional block is a small frozen catastrophic list (root filesystem deletion, raw disk destruction, fork bombs).
+
+## 1.6.3 - 2026-07-07
+
+- SDK 1.4.0 pin: the shared daemon contracts gain server-side companion-chat turn control — a true stop verb (provider stream aborted, honest partial persisted), queue-when-busy sends, and steer (interrupt-and-send-now). No agent-side behavior changes; agent session turns already had lifecycle control on the operator wire.
+
 ## 1.6.2 - 2026-07-07
 
 - Updated to SDK 1.3.3: the macOS capability-limit classification now matches Apple SQLite's exact refusal message, so compiled binaries report the honest limit instead of an error.

package/README.md

@@ -1,7 +1,7 @@
 # GoodVibes Agent
 
 [![License: MIT](https://img.shields.io/badge/License-MIT-blue.svg)](https://opensource.org/licenses/MIT)
-[![Version: 1.5.3](https://img.shields.io/badge/version-1.6.2-blue.svg)](#install)
+[![Version: 1.5.3](https://img.shields.io/badge/version-1.6.4-blue.svg)](#install)
 
 GoodVibes Agent is the installable autonomous operator assistant for GoodVibes. It keeps the existing terminal renderer and workspace bones, but the product goal is different from a vibecoding harness: the user should experience one assistant that can chat, plan, remember, research, schedule, send, generate, run visible agents, and operate the GoodVibes daemon contract with clear confirmation gates.
 

package/dist/package/main.js

@@ -4463,7 +4463,7 @@ var init_mcp = __esm(() => {
 // node_modules/@pellux/goodvibes-sdk/dist/platform/version.js
 import { readFileSync as readFileSync3 } from "fs";
 import { join as join4 } from "path";
-var version = "1.3.3", VERSION2;
+var version = "1.4.1", VERSION2;
 var init_version = __esm(() => {
   try {
     const pkg = JSON.parse(readFileSync3(join4(import.meta.dir, "..", "..", "package.json"), "utf-8"));
@@ -63439,6 +63439,39 @@ function collectCommandNodes(node, acc = []) {
 }
 
 // node_modules/@pellux/goodvibes-sdk/dist/platform/runtime/permissions/normalization/classifier.js
+function catastrophicReason(seg) {
+  const { command, args: args2, flags: flags2, raw } = seg;
+  const operands = [
+    ...args2,
+    ...seg.tokens.filter((t) => t.type !== "command" && t.type !== "flag").map((t) => t.value)
+  ];
+  if (command === "rm") {
+    if (flags2.includes("--no-preserve-root")) {
+      return "rm --no-preserve-root: destructive root filesystem deletion";
+    }
+    const recursive = flags2.some((f) => f.includes("r") || f === "--recursive");
+    const force = flags2.some((f) => f.includes("f") || f === "--force");
+    if (recursive && force && operands.some((a) => a === "/" || a === "/*")) {
+      return "rm -rf /: destructive root filesystem deletion";
+    }
+  }
+  if (command === "dd" && operands.some((a) => a.startsWith("of=/dev/"))) {
+    return "dd writing to a raw device: destructive disk overwrite";
+  }
+  if (command.startsWith("mkfs") || command === "wipefs") {
+    return `${command}: destructive filesystem/device wipe`;
+  }
+  if (command === "shred" && operands.some((a) => a.startsWith("/dev/"))) {
+    return "shred on a raw device: destructive disk overwrite";
+  }
+  if (raw.includes(":(){") || raw.includes(":|:&")) {
+    return "fork bomb: destructive resource exhaustion";
+  }
+  if (/>\s*\/dev\/(sd|hd|nvme|vd|mmcblk)/.test(raw)) {
+    return "redirect to a raw disk device: destructive disk overwrite";
+  }
+  return null;
+}
 function higherPriority(a, b) {
   const ai = CLASSIFICATION_PRIORITY.indexOf(a);
   const bi = CLASSIFICATION_PRIORITY.indexOf(b);
@@ -63880,7 +63913,7 @@ No parseable command segments found. Denied as a precaution.`,
   }
   return compound;
 }
-var DEFAULT_ALLOWED_CLASSES, OBFUSCATION_CHECKS, CLASSIFICATION_PRIORITY2, DEFAULT_POLICIES;
+var DEFAULT_ALLOWED_CLASSES, ALL_COMMAND_CLASSES, OBFUSCATION_CHECKS, CLASSIFICATION_PRIORITY2, DEFAULT_POLICIES;
 var init_verdict = __esm(() => {
   init_classifier();
   DEFAULT_ALLOWED_CLASSES = new Set([
@@ -63888,6 +63921,13 @@ var init_verdict = __esm(() => {
     "write",
     "network"
   ]);
+  ALL_COMMAND_CLASSES = new Set([
+    "read",
+    "write",
+    "network",
+    "destructive",
+    "escalation"
+  ]);
   OBFUSCATION_CHECKS = [
     {
       description: "base64-encoded argument (possible command injection)",
@@ -63930,9 +63970,16 @@ var init_verdict = __esm(() => {
     "read"
   ];
   DEFAULT_POLICIES = [
-    (_, cls) => cls === "destructive" ? `segment classified as destructive \u2014 denied by policy` : null,
-    (_, cls) => cls === "escalation" ? `segment classified as escalation \u2014 denied by policy` : null,
-    (_node, _cls) => null
+    (node, _cls) => {
+      const reason = catastrophicReason({
+        raw: node.raw,
+        tokens: node.tokens,
+        command: node.command,
+        args: node.args,
+        flags: node.flags
+      });
+      return reason === null ? null : `unconditionally blocked destructive command \u2014 ${reason}`;
+    }
   ];
 });
 
@@ -64004,15 +64051,27 @@ var init_normalization = __esm(() => {
 function isASTNormalizationEnabled(flagManager) {
   return flagManager?.isEnabled("shell-ast-normalization") ?? false;
 }
-function baselineGuard(command) {
+function baselineGuard(command, allowedClasses) {
   const normalized = normalizeCommand(command);
+  for (const seg of normalized.segments) {
+    const reason = catastrophicReason(seg);
+    if (reason !== null) {
+      return {
+        allowed: false,
+        denialMessage: `Command denied (safety block): "${command}"
+` + `Unconditionally blocked destructive command \u2014 ${reason}.
+` + `This block is not affected by permission settings.`,
+        astModeActive: false
+      };
+    }
+  }
   const cls = normalized.highestClassification;
-  if (cls === "destructive" || cls === "escalation") {
+  if (!allowedClasses.has(cls)) {
     return {
       allowed: false,
-      denialMessage: `Command denied (baseline mode): "${command}"
+      denialMessage: `Command denied (command-class policy): "${command}"
 ` + `Classification: ${cls}
-` + `Highest-risk operation in compound command is classified as ${cls}.`,
+` + `Classification "${cls}" is not in the caller's allowed set [${[...allowedClasses].join(", ")}].`,
       astModeActive: false
     };
   }
@@ -64039,7 +64098,7 @@ async function guardExecCommand(command, allowedClasses = DEFAULT_ALLOWED_CLASSE
   if (isASTNormalizationEnabled(flagManager)) {
     return astGuard(command, allowedClasses);
   }
-  return baselineGuard(command);
+  return baselineGuard(command, allowedClasses);
 }
 function formatDenialResponse(result, cmd) {
   const segmentDetails = result.verdict?.segments.map((s) => ({
@@ -64062,6 +64121,7 @@ var init_ast_guard = __esm(() => {
   init_parser();
   init_verdict();
   init_normalization();
+  init_classifier();
 });
 
 // node_modules/@pellux/goodvibes-sdk/dist/platform/tools/exec/file-ops.js
@@ -64434,7 +64494,7 @@ function handleBgSpecialCommand(processManager, cmd) {
   return processManager.handleCommand(cmd);
 }
 async function runCommand(processManager, overflowHandler, featureFlags, cmdStr, cmdInput, workingDirectory, globalTimeout, signal) {
-  const guardResult = await guardExecCommand(cmdStr, DEFAULT_ALLOWED_CLASSES, featureFlags);
+  const guardResult = await guardExecCommand(cmdStr, ALL_COMMAND_CLASSES, featureFlags);
   if (!guardResult.allowed) {
     const denial = formatDenialResponse(guardResult, cmdStr);
     return {
@@ -264004,8 +264064,8 @@ var FOUNDATION_METADATA;
 var init_foundation_metadata = __esm(() => {
   FOUNDATION_METADATA = {
     productId: "goodvibes",
-    productVersion: "1.3.3",
-    operatorMethodCount: 327,
+    productVersion: "1.4.1",
+    operatorMethodCount: 329,
     operatorEventCount: 31,
     peerEndpointCount: 6
   };
@@ -264019,7 +264079,7 @@ var init_operator_contract = __esm(() => {
     product: {
       id: "goodvibes",
       surface: "operator",
-      version: "1.3.3"
+      version: "1.4.1"
     },
     auth: {
       modes: [
@@ -286083,6 +286143,16 @@ var init_operator_contract = __esm(() => {
                     },
                     createdAt: {
                       type: "number"
+                    },
+                    deliveryState: {
+                      type: "string",
+                      enum: [
+                        "cancelled",
+                        "queued"
+                      ]
+                    },
+                    inReplyTo: {
+                      type: "string"
                     }
                   },
                   required: [
@@ -286161,6 +286231,99 @@ var init_operator_contract = __esm(() => {
           },
           invokable: true
         },
+        {
+          id: "companion.chat.messages.steer",
+          title: "Steer Companion Chat (Interrupt And Send)",
+          description: 'Send a message that runs IMMEDIATELY, interrupting the in-flight turn if one is running. The message jumps to the front of the pending-turn queue; the active turn is cancelled through the same finalization path as companion.chat.turns.cancel (any non-empty partial reply is persisted with `deliveryState: "cancelled"` and the terminal `turn.cancelled` event reaches every subscriber), then the steered message\'s turn starts. Messages queued behind an active turn keep their places behind the steer. With no turn running this behaves as an ordinary send. Accepts the same payload as companion.chat.messages.create (`body`/`content`, `attachments`, `metadata`). Returns the new message id, `steered: true`, and `cancelledTurnId` when a turn was interrupted. Ordinary sends posted while a turn is running are QUEUED (transcript-visible immediately with `deliveryState: "queued"`, answered in order) \u2014 steer is the explicit jump-the-line verb.',
+          category: "companion",
+          source: "builtin",
+          access: "authenticated",
+          transport: [
+            "http",
+            "ws"
+          ],
+          scopes: [
+            "write:sessions"
+          ],
+          http: {
+            method: "POST",
+            path: "/api/companion/chat/sessions/{sessionId}/messages/steer"
+          },
+          inputSchema: {
+            type: "object",
+            properties: {
+              sessionId: {
+                type: "string"
+              },
+              body: {
+                type: "string"
+              },
+              content: {
+                type: "string"
+              },
+              attachments: {
+                type: "array",
+                items: {
+                  type: "object",
+                  properties: {
+                    artifactId: {
+                      type: "string"
+                    },
+                    label: {
+                      type: "string"
+                    },
+                    metadata: {
+                      type: "object",
+                      properties: {},
+                      additionalProperties: false
+                    }
+                  },
+                  required: [
+                    "artifactId"
+                  ],
+                  additionalProperties: false
+                }
+              },
+              metadata: {
+                type: "object",
+                properties: {},
+                additionalProperties: false
+              }
+            },
+            required: [
+              "sessionId"
+            ],
+            additionalProperties: true
+          },
+          outputSchema: {
+            type: "object",
+            properties: {
+              sessionId: {
+                type: "string"
+              },
+              messageId: {
+                type: "string"
+              },
+              steered: {
+                type: "boolean"
+              },
+              cancelledTurnId: {
+                type: "string"
+              },
+              turnStarted: {
+                type: "boolean"
+              }
+            },
+            required: [
+              "sessionId",
+              "messageId",
+              "steered",
+              "turnStarted"
+            ],
+            additionalProperties: false
+          },
+          invokable: true
+        },
         {
           id: "companion.chat.sessions.close",
           title: "Close Companion Chat Session",
@@ -286627,6 +286790,16 @@ var init_operator_contract = __esm(() => {
                     },
                     createdAt: {
                       type: "number"
+                    },
+                    deliveryState: {
+                      type: "string",
+                      enum: [
+                        "cancelled",
+                        "queued"
+                      ]
+                    },
+                    inReplyTo: {
+                      type: "string"
                     }
                   },
                   required: [
@@ -286935,6 +287108,68 @@ var init_operator_contract = __esm(() => {
           },
           invokable: true
         },
+        {
+          id: "companion.chat.turns.cancel",
+          title: "Cancel Companion Chat Turn",
+          description: 'Stop the in-flight turn for a companion chat session \u2014 a true server-side stop: the provider stream is aborted, any non-empty partial reply is persisted to the transcript with an explicit `deliveryState: "cancelled"` marker (an honest partial, never disguised as a complete reply) AND committed to the model-facing conversation history with an explicit interruption note \u2014 later turns can reason about what the user saw and stopped, which is usually what a follow-up or steer refers to, and the terminal `turn.cancelled` event is published to every subscriber of the session stream so a stop from one client converges on all others. Any announced tool call without a result is closed with a synthetic error `turn.tool_result` before the terminal event. Optional `turnId` guards against cancelling a newer turn a stale stop raced against (409 TURN_MISMATCH). No turn in flight is the benign 404 NO_ACTIVE_TURN (the turn finished before the stop landed). Repeat cancels are idempotent successes. The session stays open; the next message starts a fresh turn normally.',
+          category: "companion",
+          source: "builtin",
+          access: "authenticated",
+          transport: [
+            "http",
+            "ws"
+          ],
+          scopes: [
+            "write:sessions"
+          ],
+          http: {
+            method: "POST",
+            path: "/api/companion/chat/sessions/{sessionId}/turns/cancel"
+          },
+          inputSchema: {
+            type: "object",
+            properties: {
+              sessionId: {
+                type: "string"
+              },
+              turnId: {
+                type: "string"
+              }
+            },
+            required: [
+              "sessionId"
+            ],
+            additionalProperties: true
+          },
+          outputSchema: {
+            type: "object",
+            properties: {
+              sessionId: {
+                type: "string"
+              },
+              turnId: {
+                type: "string"
+              },
+              cancelled: {
+                type: "boolean"
+              },
+              alreadyCancelled: {
+                type: "boolean"
+              },
+              partialPersisted: {
+                type: "boolean"
+              }
+            },
+            required: [
+              "sessionId",
+              "turnId",
+              "cancelled",
+              "partialPersisted"
+            ],
+            additionalProperties: false
+          },
+          invokable: true
+        },
         {
           id: "config.get",
           title: "Get Config",
@@ -345393,10 +345628,10 @@ var init_operator_contract = __esm(() => {
         }
       ],
       schemaCoverage: {
-        methods: 327,
-        typedInputs: 327,
+        methods: 329,
+        typedInputs: 329,
         genericInputs: 0,
-        typedOutputs: 327,
+        typedOutputs: 329,
         genericOutputs: 0
       },
       eventCoverage: {
@@ -345405,8 +345640,8 @@ var init_operator_contract = __esm(() => {
         withWireEvents: 31
       },
       validationCoverage: {
-        methods: 327,
-        validated: 325,
+        methods: 329,
+        validated: 327,
         skippedGeneric: 0,
         skippedUntyped: 2
       }
@@ -345502,12 +345737,14 @@ var init_operator_method_ids = __esm(() => {
     "companion.chat.messages.edit",
     "companion.chat.messages.list",
     "companion.chat.messages.retry",
+    "companion.chat.messages.steer",
     "companion.chat.sessions.close",
     "companion.chat.sessions.create",
     "companion.chat.sessions.delete",
     "companion.chat.sessions.get",
     "companion.chat.sessions.list",
     "companion.chat.sessions.update",
+    "companion.chat.turns.cancel",
     "config.get",
     "config.set",
     "continuity.snapshot",
@@ -450511,7 +450748,9 @@ var init_operator_contract_schemas_runtime = __esm(() => {
     role: COMPANION_CHAT_MESSAGE_ROLE_SCHEMA,
     content: STRING_SCHEMA,
     attachments: arraySchema(COMPANION_CHAT_ATTACHMENT_SCHEMA),
-    createdAt: NUMBER_SCHEMA
+    createdAt: NUMBER_SCHEMA,
+    deliveryState: enumSchema(["cancelled", "queued"]),
+    inReplyTo: STRING_SCHEMA
   }, ["id", "sessionId", "role", "content", "attachments", "createdAt"]);
   COMPANION_CHAT_SESSION_WITH_MESSAGES_SCHEMA = objectSchema({
     session: COMPANION_CHAT_SESSION_SCHEMA,
@@ -453393,6 +453632,51 @@ var init_method_catalog_control_companion = __esm(() => {
         turnStarted: BOOLEAN_SCHEMA
       }, ["sessionId", "editedFrom", "messageId", "supersededMessageIds", "turnStarted"])
     }),
+    methodDescriptor({
+      id: "companion.chat.messages.steer",
+      title: "Steer Companion Chat (Interrupt And Send)",
+      description: 'Send a message that runs IMMEDIATELY, interrupting the in-flight turn if one is running. The message jumps to the front of the pending-turn queue; the active turn is cancelled through the same finalization path as companion.chat.turns.cancel (any non-empty partial reply is persisted with `deliveryState: "cancelled"` and the terminal `turn.cancelled` event reaches every subscriber), then the steered message\'s turn starts. Messages queued behind an active turn keep their places behind the steer. With no turn running this behaves as an ordinary send. Accepts the same payload as companion.chat.messages.create (`body`/`content`, `attachments`, `metadata`). Returns the new message id, `steered: true`, and `cancelledTurnId` when a turn was interrupted. Ordinary sends posted while a turn is running are QUEUED (transcript-visible immediately with `deliveryState: "queued"`, answered in order) \u2014 steer is the explicit jump-the-line verb.',
+      category: "companion",
+      scopes: ["write:sessions"],
+      http: { method: "POST", path: "/api/companion/chat/sessions/{sessionId}/messages/steer" },
+      inputSchema: bodyEnvelopeSchema({
+        sessionId: STRING_SCHEMA,
+        body: STRING_SCHEMA,
+        content: STRING_SCHEMA,
+        attachments: arraySchema(objectSchema({
+          artifactId: STRING_SCHEMA,
+          label: STRING_SCHEMA,
+          metadata: objectSchema({}, [])
+        }, ["artifactId"])),
+        metadata: objectSchema({}, [])
+      }, ["sessionId"]),
+      outputSchema: objectSchema({
+        sessionId: STRING_SCHEMA,
+        messageId: STRING_SCHEMA,
+        steered: BOOLEAN_SCHEMA,
+        cancelledTurnId: STRING_SCHEMA,
+        turnStarted: BOOLEAN_SCHEMA
+      }, ["sessionId", "messageId", "steered", "turnStarted"])
+    }),
+    methodDescriptor({
+      id: "companion.chat.turns.cancel",
+      title: "Cancel Companion Chat Turn",
+      description: 'Stop the in-flight turn for a companion chat session \u2014 a true server-side stop: the provider stream is aborted, any non-empty partial reply is persisted to the transcript with an explicit `deliveryState: "cancelled"` marker (an honest partial, never disguised as a complete reply) AND committed to the model-facing conversation history with an explicit interruption note \u2014 later turns can reason about what the user saw and stopped, which is usually what a follow-up or steer refers to, and the terminal `turn.cancelled` event is published to every subscriber of the session stream so a stop from one client converges on all others. Any announced tool call without a result is closed with a synthetic error `turn.tool_result` before the terminal event. Optional `turnId` guards against cancelling a newer turn a stale stop raced against (409 TURN_MISMATCH). No turn in flight is the benign 404 NO_ACTIVE_TURN (the turn finished before the stop landed). Repeat cancels are idempotent successes. The session stays open; the next message starts a fresh turn normally.',
+      category: "companion",
+      scopes: ["write:sessions"],
+      http: { method: "POST", path: "/api/companion/chat/sessions/{sessionId}/turns/cancel" },
+      inputSchema: bodyEnvelopeSchema({
+        sessionId: STRING_SCHEMA,
+        turnId: STRING_SCHEMA
+      }, ["sessionId"]),
+      outputSchema: objectSchema({
+        sessionId: STRING_SCHEMA,
+        turnId: STRING_SCHEMA,
+        cancelled: BOOLEAN_SCHEMA,
+        alreadyCancelled: BOOLEAN_SCHEMA,
+        partialPersisted: BOOLEAN_SCHEMA
+      }, ["sessionId", "turnId", "cancelled", "partialPersisted"])
+    }),
     methodDescriptor({
       id: "companion.chat.events.stream",
       title: "Stream Companion Chat Events",
@@ -813161,6 +813445,12 @@ async function dispatchCompanionChatRoutes(req, context) {
   if (sub === "messages/edit" && req.method === "POST") {
     return handleEditMessage(req, sessionId, context);
   }
+  if (sub === "turns/cancel" && req.method === "POST") {
+    return handleCancelTurn(req, sessionId, context);
+  }
+  if (sub === "messages/steer" && req.method === "POST") {
+    return handleSteerMessage(req, sessionId, context);
+  }
   if (sub === "events" && req.method === "GET") {
     return handleGetEvents(req, sessionId, context);
   }
@@ -813417,6 +813707,42 @@ async function handleGetMessages(sessionId, context) {
   const messages = context.chatManager.getMessages(sessionId);
   return Response.json({ sessionId, messages });
 }
+async function handleCancelTurn(req, sessionId, context) {
+  const bodyOrResponse = await context.parseOptionalJsonBody(req);
+  if (bodyOrResponse instanceof Response)
+    return bodyOrResponse;
+  const body2 = bodyOrResponse ?? {};
+  const input = {
+    turnId: typeof body2["turnId"] === "string" && body2["turnId"].trim() ? body2["turnId"].trim() : undefined
+  };
+  try {
+    return Response.json(await context.chatManager.cancelTurn(sessionId, input));
+  } catch (err2) {
+    return respondWithManagerError(err2);
+  }
+}
+async function handleSteerMessage(req, sessionId, context) {
+  const bodyOrResponse = await context.parseJsonBody(req);
+  if (bodyOrResponse instanceof Response)
+    return bodyOrResponse;
+  const body2 = bodyOrResponse;
+  const rawContent = readCompanionChatMessageBody(body2);
+  const attachments = readCompanionChatAttachments(body2);
+  if (attachments instanceof Response)
+    return attachments;
+  if (!rawContent.trim() && attachments.length === 0) {
+    return Response.json({ error: "content, body, or attachments are required", code: "INVALID_INPUT" }, { status: 400 });
+  }
+  try {
+    const result = await context.chatManager.steerMessage(sessionId, rawContent, "", {
+      attachments,
+      metadata: typeof body2["metadata"] === "object" && body2["metadata"] !== null ? body2["metadata"] : undefined
+    });
+    return Response.json(result, { status: 202 });
+  } catch (err2) {
+    return respondWithManagerError(err2);
+  }
+}
 async function handleGetEvents(req, sessionId, context) {
   const session2 = context.chatManager.getSession(sessionId);
   if (!session2) {
@@ -814619,7 +814945,7 @@ class HomeAssistantConversationRoutes {
       const body2 = await this.context.parseJsonBody(req);
       if (body2 instanceof Response)
         return body2;
-      return this.cancelConversation(body2);
+      return await this.cancelConversation(body2);
     }
     return null;
   }
@@ -814805,14 +815131,24 @@ data: ${JSON.stringify(data)}
       }
     });
   }
-  cancelConversation(body2) {
+  async cancelConversation(body2) {
     const indexed = readString27(body2.messageId ?? body2.message_id) ? this.messageIndex.get(readString27(body2.messageId ?? body2.message_id)) : undefined;
     const sessionId = readString27(body2.sessionId ?? body2.session_id) ?? indexed?.sessionId;
     if (!sessionId) {
       return Response.json({ ok: false, error: "sessionId or known messageId is required." }, { status: 400 });
     }
-    const session2 = this.context.chatManager.closeSession(sessionId);
-    return session2 ? Response.json({ ok: true, sessionId, status: "cancelled" }) : Response.json({ ok: false, sessionId, error: "Unknown Home Assistant chat session." }, { status: 404 });
+    if (!this.context.chatManager.getSession(sessionId)) {
+      return Response.json({ ok: false, sessionId, error: "Unknown Home Assistant chat session." }, { status: 404 });
+    }
+    try {
+      await this.context.chatManager.cancelTurn(sessionId);
+    } catch (error51) {
+      const code2 = error51.code;
+      if (code2 !== "NO_ACTIVE_TURN") {
+        return Response.json({ ok: false, sessionId, error: error51 instanceof Error ? error51.message : String(error51) }, { status: 500 });
+      }
+    }
+    return Response.json({ ok: true, sessionId, status: "cancelled" });
   }
   parseInput(body2) {
     const threadId = readString27(body2.threadId ?? body2.thread_id);
@@ -816957,6 +817293,135 @@ var init_companion_chat_rate_limiter = __esm(() => {
   init_dist();
 });
 
+// node_modules/@pellux/goodvibes-sdk/dist/platform/companion/companion-chat-turn-control.js
+function createTurnAbortScope(turnId, sessionSignal) {
+  const controller = new AbortController;
+  const onSessionAbort = () => {
+    controller.abort();
+  };
+  if (sessionSignal.aborted)
+    controller.abort();
+  else
+    sessionSignal.addEventListener("abort", onSessionAbort, { once: true });
+  let settle;
+  const settled = new Promise((resolve31) => {
+    settle = resolve31;
+  });
+  const activeTurn = { turnId, controller, cancelRequested: false, settled };
+  return {
+    activeTurn,
+    abortSignal: controller.signal,
+    settle,
+    detach: () => {
+      sessionSignal.removeEventListener("abort", onSessionAbort);
+    }
+  };
+}
+function finalizeCancelledTurn(ctx) {
+  const { sessionId, turnId } = ctx;
+  const stoppedBy = ctx.wasCancelRequested() ? "user" : ctx.isShutdown() ? "shutdown" : "session-closed";
+  for (const [toolCallId, toolName] of ctx.openToolCalls) {
+    ctx.publish({
+      type: "turn.tool_result",
+      sessionId,
+      turnId,
+      toolCallId,
+      toolName,
+      result: "Cancelled: the turn was stopped before this tool call completed.",
+      isError: true
+    });
+  }
+  ctx.openToolCalls.clear();
+  const assistantContent = ctx.getAssistantContent();
+  const uncommitted = ctx.getUncommittedContent();
+  if (uncommitted.trim()) {
+    ctx.commitPartialToHistory(uncommitted + TURN_INTERRUPTION_NOTE);
+  }
+  let persistedId;
+  let envelope;
+  if (assistantContent.trim()) {
+    const now4 = Date.now();
+    ctx.persistPartial({
+      id: ctx.assistantMessageId,
+      sessionId,
+      role: "assistant",
+      content: assistantContent,
+      attachments: [],
+      createdAt: now4,
+      deliveryState: "cancelled",
+      inReplyTo: ctx.userMessageId
+    });
+    persistedId = ctx.assistantMessageId;
+    envelope = {
+      sessionId,
+      messageId: ctx.assistantMessageId,
+      body: assistantContent,
+      source: "companion-chat-assistant",
+      timestamp: now4
+    };
+  }
+  ctx.publish({
+    type: "turn.cancelled",
+    sessionId,
+    turnId,
+    stoppedBy,
+    partialPersisted: persistedId !== undefined,
+    ...persistedId !== undefined ? { assistantMessageId: persistedId, envelope } : {}
+  });
+  ctx.resolveReply(persistedId !== undefined ? { assistantMessageId: persistedId, response: assistantContent } : {});
+  ctx.settle({
+    partialPersisted: persistedId !== undefined,
+    ...persistedId !== undefined ? { assistantMessageId: persistedId } : {}
+  });
+}
+async function cancelActiveTurn(sessionId, turn2, input) {
+  if (!turn2) {
+    throw Object.assign(new Error("No turn is in flight for this session \u2014 it may have finished before the stop landed."), { code: "NO_ACTIVE_TURN", status: 404 });
+  }
+  if (input.turnId !== undefined && input.turnId !== turn2.turnId) {
+    throw Object.assign(new Error("The requested turn is not the active turn \u2014 a newer turn is already running."), { code: "TURN_MISMATCH", status: 409 });
+  }
+  const alreadyCancelled = turn2.cancelRequested;
+  if (!alreadyCancelled) {
+    turn2.cancelRequested = true;
+    turn2.controller.abort();
+  }
+  const settled = await Promise.race([
+    turn2.settled,
+    new Promise((resolve31) => setTimeout(resolve31, CANCEL_SETTLE_TIMEOUT_MS))
+  ]);
+  return {
+    sessionId,
+    turnId: turn2.turnId,
+    cancelled: true,
+    ...alreadyCancelled ? { alreadyCancelled: true } : {},
+    partialPersisted: settled?.partialPersisted ?? false
+  };
+}
+function awaitCompanionReply(timeoutMs, post, onTimeout) {
+  let messageId = "";
+  return new Promise((resolve31) => {
+    const timeout = setTimeout(() => {
+      if (messageId)
+        onTimeout(messageId);
+      resolve31({ messageId, error: "Timed out waiting for companion chat reply" });
+    }, timeoutMs);
+    timeout.unref?.();
+    post({ resolve: resolve31, timeout }).then((id) => {
+      messageId = id;
+    }).catch((error51) => {
+      clearTimeout(timeout);
+      resolve31({
+        messageId,
+        error: error51 instanceof Error ? error51.message : String(error51)
+      });
+    });
+  });
+}
+var TURN_INTERRUPTION_NOTE = `
+
+[Interrupted: the user stopped this response here, before it was complete.]`, CANCEL_SETTLE_TIMEOUT_MS = 3000;
+
 // node_modules/@pellux/goodvibes-sdk/dist/platform/companion/companion-chat-manager.js
 import { randomUUID as randomUUID43 } from "crypto";
 function assertCompleteProviderModelRoute(input) {
@@ -816987,6 +817452,7 @@ class CompanionChatManager {
   gcTimer = null;
   initCompleted = false;
   pendingReplies = new Map;
+  disposed = false;
   _pendingSaves = new Map;
   constructor(config6) {
     this.provider = config6.provider;
@@ -817140,6 +817606,13 @@ class CompanionChatManager {
     this._brokerSync.track(sessionId, () => this._brokerSync.closeSession(sessionId));
     return updated;
   }
+  async cancelTurn(sessionId, input = {}) {
+    const session2 = this.sessions.get(sessionId);
+    if (!session2) {
+      throw Object.assign(new Error(`Session not found: ${sessionId}`), { code: "SESSION_NOT_FOUND", status: 404 });
+    }
+    return cancelActiveTurn(sessionId, session2.activeTurn ?? null, input);
+  }
   async deleteSession(sessionId) {
     const session2 = this.sessions.get(sessionId);
     if (!session2) {
@@ -817160,29 +817633,11 @@ class CompanionChatManager {
     });
   }
   async postMessageAndWaitForReply(sessionId, content, clientId = "", options = {}) {
-    let messageId = "";
-    const result = new Promise((resolve31) => {
-      const timeout = setTimeout(() => {
-        if (messageId)
-          this.pendingReplies.delete(messageId);
-        resolve31({ messageId, error: "Timed out waiting for companion chat reply" });
-      }, options.timeoutMs ?? 120000);
-      timeout.unref?.();
-      this._postMessageInternal(sessionId, content, clientId, {
-        pendingReply: { resolve: resolve31, timeout },
-        attachments: options.attachments,
-        ...options.onTurnEvent ? { onTurnEvent: options.onTurnEvent } : {}
-      }).then((id) => {
-        messageId = id;
-      }).catch((error51) => {
-        clearTimeout(timeout);
-        resolve31({
-          messageId,
-          error: error51 instanceof Error ? error51.message : String(error51)
-        });
-      });
-    });
-    return result;
+    return awaitCompanionReply(options.timeoutMs ?? 120000, (pendingReply) => this._postMessageInternal(sessionId, content, clientId, {
+      pendingReply,
+      attachments: options.attachments,
+      ...options.onTurnEvent ? { onTurnEvent: options.onTurnEvent } : {}
+    }), (messageId) => this.pendingReplies.delete(messageId));
   }
   async _postMessageInternal(sessionId, content, clientId, options = {}) {
     const session2 = this.sessions.get(sessionId);
@@ -817199,6 +817654,7 @@ class CompanionChatManager {
     }
     const messageId = randomUUID43();
     const now4 = Date.now();
+    const queuedBehindActiveTurn = session2.activeTurn != null && options.steer !== true;
     const userMsg = {
       id: messageId,
       sessionId,
@@ -817206,10 +817662,11 @@ class CompanionChatManager {
       content,
       attachments,
       ...options.metadata !== undefined ? { metadata: options.metadata } : {},
-      createdAt: now4
+      createdAt: now4,
+      ...queuedBehindActiveTurn ? { deliveryState: "queued" } : {}
     };
+    const providerContent = await buildProviderUserContent(content, attachments, this.artifactStore);
     session2.messages.push(userMsg);
-    session2.conversation.addUserMessage(await buildProviderUserContent(content, attachments, this.artifactStore));
     session2.lastActivityAt = now4;
     this._updateMeta(session2, {
       messageCount: session2.messages.length,
@@ -817219,16 +817676,21 @@ class CompanionChatManager {
     if (options.pendingReply) {
       this.pendingReplies.set(messageId, options.pendingReply);
     }
-    this._runTurn(session2, messageId, options.onTurnEvent).catch((error51) => {
-      logger.warn("[companion-chat] turn execution failed", {
-        sessionId,
-        messageId,
-        error: summarizeError(error51)
-      });
-    });
+    const entry = {
+      userMessageId: messageId,
+      providerContent,
+      ...options.onTurnEvent ? { onTurnEvent: options.onTurnEvent } : {}
+    };
+    const queue = session2.pendingTurns ??= [];
+    if (options.steer === true)
+      queue.unshift(entry);
+    else
+      queue.push(entry);
+    this._startNextTurn(session2);
     return messageId;
   }
   dispose() {
+    this.disposed = true;
     if (this.gcTimer) {
       clearInterval(this.gcTimer);
       this.gcTimer = null;
@@ -817238,11 +817700,70 @@ class CompanionChatManager {
     }
     this.sessions.clear();
   }
+  async steerMessage(sessionId, content, clientId = "", options = {}) {
+    const activeBefore = this.sessions.get(sessionId)?.activeTurn ?? null;
+    const messageId = await this._postMessageInternal(sessionId, content, clientId, {
+      attachments: options.attachments,
+      metadata: options.metadata,
+      steer: true
+    });
+    let cancelledTurnId;
+    if (activeBefore) {
+      try {
+        const result = await this.cancelTurn(sessionId, { turnId: activeBefore.turnId });
+        cancelledTurnId = result.turnId;
+      } catch (err2) {
+        const code2 = err2.code;
+        if (code2 !== "NO_ACTIVE_TURN" && code2 !== "TURN_MISMATCH")
+          throw err2;
+      }
+    }
+    const session2 = this.sessions.get(sessionId);
+    if (session2)
+      this._startNextTurn(session2);
+    return {
+      sessionId,
+      messageId,
+      steered: true,
+      ...cancelledTurnId !== undefined ? { cancelledTurnId } : {},
+      turnStarted: true
+    };
+  }
+  _startNextTurn(session2) {
+    if (session2.activeTurn || session2.meta.status === "closed")
+      return;
+    const next = session2.pendingTurns?.shift();
+    if (!next)
+      return;
+    const idx = session2.messages.findIndex((m3) => m3.id === next.userMessageId);
+    const queuedMsg = idx >= 0 ? session2.messages[idx] : undefined;
+    if (queuedMsg?.deliveryState === "queued") {
+      const { deliveryState: _cleared, ...delivered } = queuedMsg;
+      session2.messages[idx] = delivered;
+      this._persist(session2.meta.id);
+    }
+    session2.conversation.addUserMessage(next.providerContent);
+    this._runTurn(session2, next.userMessageId, next.onTurnEvent).catch((error51) => {
+      logger.warn("[companion-chat] turn execution failed", {
+        sessionId: session2.meta.id,
+        messageId: next.userMessageId,
+        error: summarizeError(error51)
+      });
+    });
+  }
   async _runTurn(session2, userMessageId, onTurnEvent) {
     const turnId = randomUUID43();
     const sessionId = session2.meta.id;
-    const abortSignal = session2.abortController.signal;
+    const scope = createTurnAbortScope(turnId, session2.abortController.signal);
+    const abortSignal = scope.abortSignal;
+    session2.activeTurn = scope.activeTurn;
+    const openToolCalls = new Map;
     const publish = (event) => {
+      if (event.type === "turn.tool_call" && event.toolCallId) {
+        openToolCalls.set(event.toolCallId, event.toolName);
+      } else if (event.type === "turn.tool_result" && event.toolCallId) {
+        openToolCalls.delete(event.toolCallId);
+      }
       this.eventPublisher.publishEvent(`companion-chat.${event.type}`, event, session2.subscriberClientId ? { clientId: session2.subscriberClientId } : undefined);
       try {
         onTurnEvent?.(event);
@@ -817259,7 +817780,31 @@ class CompanionChatManager {
     };
     publish({ type: "turn.started", sessionId, messageId: userMessageId, turnId, envelope: startEnvelope });
     let assistantContent = "";
+    let uncommittedContent = "";
     const assistantMessageId = randomUUID43();
+    const finalizeCancelled = () => finalizeCancelledTurn({
+      sessionId,
+      turnId,
+      assistantMessageId,
+      userMessageId,
+      getAssistantContent: () => assistantContent,
+      getUncommittedContent: () => uncommittedContent,
+      commitPartialToHistory: (content) => {
+        session2.conversation.addAssistantMessage(content);
+      },
+      openToolCalls,
+      wasCancelRequested: () => scope.activeTurn.cancelRequested,
+      isShutdown: () => this.disposed,
+      publish,
+      persistPartial: (message) => {
+        session2.messages.push(message);
+        session2.lastActivityAt = message.createdAt;
+        this._updateMeta(session2, { messageCount: session2.messages.length, updatedAt: message.createdAt });
+        this._persist(sessionId);
+      },
+      resolveReply: (extra) => this.resolvePendingReply(userMessageId, { messageId: userMessageId, ...extra, error: "Turn cancelled" }),
+      settle: scope.settle
+    });
     try {
       const toolDefinitions = this.toolRegistry?.getToolDefinitions() ?? [];
       let completed = false;
@@ -817271,7 +817816,7 @@ class CompanionChatManager {
           tools: toolDefinitions,
           abortSignal
         });
-        let roundAssistantContent = "";
+        uncommittedContent = "";
         const toolCalls = [];
         for await (const chunk of stream6) {
           if (abortSignal.aborted)
@@ -817279,7 +817824,7 @@ class CompanionChatManager {
           switch (chunk.type) {
             case "text_delta": {
               const delta = chunk.delta ?? "";
-              roundAssistantContent += delta;
+              uncommittedContent += delta;
               assistantContent += delta;
               publish({ type: "turn.delta", sessionId, turnId, delta });
               break;
@@ -817323,11 +817868,13 @@ class CompanionChatManager {
         if (abortSignal.aborted)
           break;
         if (toolCalls.length === 0) {
-          session2.conversation.addAssistantMessage(roundAssistantContent);
+          session2.conversation.addAssistantMessage(uncommittedContent);
+          uncommittedContent = "";
           completed = true;
           break;
         }
-        session2.conversation.addAssistantMessage(roundAssistantContent, { toolCalls });
+        session2.conversation.addAssistantMessage(uncommittedContent, { toolCalls });
+        uncommittedContent = "";
         if (!this.toolRegistry) {
           completed = true;
           break;
@@ -817349,7 +817896,7 @@ class CompanionChatManager {
         }
       }
       if (abortSignal.aborted) {
-        this.resolvePendingReply(userMessageId, { messageId: userMessageId, error: "Turn cancelled" });
+        finalizeCancelled();
         return;
       }
       const now4 = Date.now();
@@ -817359,7 +817906,8 @@ class CompanionChatManager {
         role: "assistant",
         content: assistantContent,
         attachments: [],
-        createdAt: now4
+        createdAt: now4,
+        inReplyTo: userMessageId
       };
       session2.messages.push(assistantMsg);
       session2.lastActivityAt = now4;
@@ -817380,8 +817928,14 @@ class CompanionChatManager {
         publish({ type: "turn.error", sessionId, turnId, error: errorMessage });
         this.resolvePendingReply(userMessageId, { messageId: userMessageId, error: errorMessage });
       } else {
-        this.resolvePendingReply(userMessageId, { messageId: userMessageId, error: "Turn cancelled" });
+        finalizeCancelled();
       }
+    } finally {
+      if (session2.activeTurn === scope.activeTurn)
+        session2.activeTurn = null;
+      scope.detach();
+      scope.settle({ partialPersisted: false });
+      this._startNextTurn(session2);
     }
   }
   regenerateMessage(sessionId, input = {}) {
@@ -837066,7 +837620,7 @@ var createStyledCell = (char, overrides = {}) => ({
 // src/version.ts
 import { readFileSync } from "fs";
 import { join } from "path";
-var _version = "1.6.2";
+var _version = "1.6.4";
 try {
   const pkg = JSON.parse(readFileSync(join(import.meta.dir, "..", "package.json"), "utf-8"));
   _version = typeof pkg.version === "string" ? pkg.version : _version;
@@ -869724,7 +870278,11 @@ function createBrowserKnowledgeSdkFromRoutes(knowledgeRoutes, options = {}) {
       },
       messages: {
         create: (id, input) => invoke("companion.chat.messages.create", { sessionId: id, ...input }),
-        list: (id) => invoke("companion.chat.messages.list", { sessionId: id })
+        list: (id) => invoke("companion.chat.messages.list", { sessionId: id }),
+        steer: (id, input) => invoke("companion.chat.messages.steer", { sessionId: id, ...input })
+      },
+      turns: {
+        cancel: (id, input) => invoke("companion.chat.turns.cancel", { sessionId: id, ...input ?? {} })
       },
       events: {
         stream: (id, handlers, options2) => sdk.streams.open("/api/companion/chat/sessions/" + id + "/events", handlers, options2)
@@ -894274,13 +894832,13 @@ init_state();
 
 // src/input/commands/recall-shared.ts
 var VALID_CLASSES = ["decision", "constraint", "incident", "pattern", "fact", "risk", "runbook", "architecture", "ownership"];
-var VALID_SCOPES2 = ["session", "project", "team"];
+var VALID_SCOPES = ["session", "project", "team"];
 var VALID_REVIEW_STATES = ["fresh", "reviewed", "stale", "contradicted"];
 function isValidClass(s4) {
   return VALID_CLASSES.includes(s4);
 }
 function isValidScope(s4) {
-  return VALID_SCOPES2.includes(s4);
+  return VALID_SCOPES.includes(s4);
 }
 function isValidReviewState(s4) {
   return VALID_REVIEW_STATES.includes(s4);
@@ -894323,7 +894881,7 @@ function handleRecallSearch(args2, context) {
     if (isValidScope(scope))
       filter.scope = scope;
     else {
-      context.print(`[memory] Unknown scope "${scope}". Valid values ${VALID_SCOPES2.join(", ")}.`);
+      context.print(`[memory] Unknown scope "${scope}". Valid values ${VALID_SCOPES.join(", ")}.`);
       return;
     }
   }
@@ -894498,7 +895056,7 @@ function handleRecallList(args2, context) {
   if (scopeIdx !== -1 && args2[scopeIdx + 1]) {
     const scope = args2[scopeIdx + 1];
     if (!isValidScope(scope)) {
-      context.print(`[memory] Unknown scope "${scope}". Valid values ${VALID_SCOPES2.join(", ")}.`);
+      context.print(`[memory] Unknown scope "${scope}". Valid values ${VALID_SCOPES.join(", ")}.`);
       return;
     }
     filter.scope = scope;
@@ -894548,7 +895106,7 @@ async function handleRecallAdd(args2, context) {
   const tags = tagsRaw ? tagsRaw.split(",").map((token) => token.trim()).filter(Boolean) : [];
   const scope = scopeRaw && isValidScope(scopeRaw) ? scopeRaw : "project";
   if (scopeRaw && !isValidScope(scopeRaw)) {
-    context.print(`[memory] Invalid scope "${scopeRaw}". Valid values ${VALID_SCOPES2.join(", ")}.`);
+    context.print(`[memory] Invalid scope "${scopeRaw}". Valid values ${VALID_SCOPES.join(", ")}.`);
     return;
   }
   const provenance = [];
@@ -894683,7 +895241,7 @@ function handleRecallExport(args2, context) {
   if (scopeIdx !== -1 && commandArgs[scopeIdx + 1]) {
     const scope = commandArgs[scopeIdx + 1];
     if (!isValidScope(scope)) {
-      context.print(`[memory] Unknown scope "${scope}". Valid values ${VALID_SCOPES2.join(", ")}.`);
+      context.print(`[memory] Unknown scope "${scope}". Valid values ${VALID_SCOPES.join(", ")}.`);
       return;
     }
     filter.scope = scope;
@@ -894762,7 +895320,7 @@ function handleRecallHandoffExport(args2, context) {
   const scopeIdx = commandArgs.indexOf("--scope");
   const scopeRaw = scopeIdx !== -1 ? commandArgs[scopeIdx + 1] : "team";
   if (!scopeRaw || !isValidScope(scopeRaw)) {
-    context.print(`[memory] Unknown scope "${scopeRaw ?? ""}". Valid values ${VALID_SCOPES2.join(", ")}.`);
+    context.print(`[memory] Unknown scope "${scopeRaw ?? ""}". Valid values ${VALID_SCOPES.join(", ")}.`);
     return;
   }
   const bundle = memory.exportBundle({ scope: scopeRaw });
@@ -894878,7 +895436,7 @@ function handleRecallPromote(args2, context) {
   const id = parsed.rest[0];
   const scope = parsed.rest[1];
   if (!id || !scope || !isValidScope(scope)) {
-    context.print(`[memory] Usage: /memory promote <id> <${VALID_SCOPES2.join("|")}> --yes`);
+    context.print(`[memory] Usage: /memory promote <id> <${VALID_SCOPES.join("|")}> --yes`);
     return;
   }
   if (!parsed.yes) {
@@ -908468,7 +909026,7 @@ async function tryWireMemoryCommand(runtime2, normalized, rest) {
 
 // src/cli/memory-command.ts
 var VALID_CLASSES2 = ["decision", "constraint", "incident", "pattern", "fact", "risk", "runbook", "architecture", "ownership"];
-var VALID_SCOPES4 = ["session", "project", "team"];
+var VALID_SCOPES3 = ["session", "project", "team"];
 var VALID_REVIEW_STATES3 = ["fresh", "reviewed", "stale", "contradicted"];
 var VALID_PROVENANCE_KINDS = ["session", "turn", "task", "event", "file"];
 var VALUE_OPTIONS = new Set([
@@ -908568,7 +909126,7 @@ function isMemoryClass2(value) {
   return VALID_CLASSES2.includes(value);
 }
 function isMemoryScope2(value) {
-  return VALID_SCOPES4.includes(value);
+  return VALID_SCOPES3.includes(value);
 }
 function isReviewState(value) {
   return VALID_REVIEW_STATES3.includes(value);
@@ -908583,7 +909141,7 @@ function requireClass(value) {
 }
 function requireScope(value) {
   if (!value || !isMemoryScope2(value))
-    throw new Error(`Invalid memory scope "${value ?? ""}". Valid values ${VALID_SCOPES4.join(", ")}`);
+    throw new Error(`Invalid memory scope "${value ?? ""}". Valid values ${VALID_SCOPES3.join(", ")}`);
   return value;
 }
 function optionalScope(value) {
@@ -923868,8 +924426,6 @@ function operatorContractMethods3() {
 function operatorMethodSearchText(method) {
   return [
     method.id,
-    method.title,
-    method.description,
     method.category,
     method.http?.method,
     method.http?.path,

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@pellux/goodvibes-agent",
-  "version": "1.6.2",
+  "version": "1.6.4",
   "private": false,
   "description": "GoodVibes personal operator assistant TUI with a proactive Agent product brain, isolated Agent Knowledge, local profiles, routines, skills, personas, and explicit build delegation.",
   "type": "module",
@@ -92,7 +92,7 @@
   },
   "dependencies": {},
   "devDependencies": {
-    "@pellux/goodvibes-sdk": "1.3.3",
+    "@pellux/goodvibes-sdk": "1.4.1",
     "sql.js": "^1.14.1",
     "sqlite-vec": "^0.1.9",
     "zustand": "^5.0.12",

package/src/tools/agent-harness-background-processes.ts

@@ -88,10 +88,11 @@ function operatorContractMethods(): readonly OperatorContractMethod[] {
 }
 
 function operatorMethodSearchText(method: OperatorContractMethod): string {
+  // EXCLUDES title/description prose: discovery keys off what a method IS
+  // (id/route/category/scopes), not how its docs read — SDK 1.4.0's "terminal
+  // turn.cancelled event" wording false-matched as a terminal/TTY capability.
   return [
     method.id,
-    method.title,
-    method.description,
     method.category,
     method.http?.method,
     method.http?.path,

package/src/version.ts

@@ -6,7 +6,7 @@ import { join } from 'node:path';
 // The prebuild script updates the fallback value before compilation.
 // Uses import.meta.dir (Bun) to locate package.json relative to this file,
 // which is correct regardless of the process working directory.
-let _version = '1.6.2';
+let _version = '1.6.4';
 try {
   const pkg = JSON.parse(readFileSync(join(import.meta.dir, '..', 'package.json'), 'utf-8')) as {
     readonly version?: unknown;