@ouro.bot/cli 0.1.0-alpha.289 → 0.1.0-alpha.290

package/dist/repertoire/tools-attachments.js

@@ -0,0 +1,316 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || (function () {
+    var ownKeys = function(o) {
+        ownKeys = Object.getOwnPropertyNames || function (o) {
+            var ar = [];
+            for (var k in o) if (Object.prototype.hasOwnProperty.call(o, k)) ar[ar.length] = k;
+            return ar;
+        };
+        return ownKeys(o);
+    };
+    return function (mod) {
+        if (mod && mod.__esModule) return mod;
+        var result = {};
+        if (mod != null) for (var k = ownKeys(mod), i = 0; i < k.length; i++) if (k[i] !== "default") __createBinding(result, mod, k[i]);
+        __setModuleDefault(result, mod);
+        return result;
+    };
+})();
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.attachmentToolDefinitions = void 0;
+const fs = __importStar(require("node:fs/promises"));
+const config_1 = require("../heart/config");
+const identity_1 = require("../heart/identity");
+const minimax_1 = require("../heart/providers/minimax");
+const minimax_vlm_1 = require("../heart/providers/minimax-vlm");
+const store_1 = require("../heart/attachments/store");
+const materialize_1 = require("../heart/attachments/materialize");
+const runtime_1 = require("../nerves/runtime");
+const tool_results_1 = require("./tool-results");
+const LIST_ATTACHMENTS_DESCRIPTION = "List the most recent attachments the harness preserved across senses. Use this when you need a stable attachment_id, " +
+    "when a repair flow says an attachment could not be found, or when you want to inspect what artifacts are currently on hand " +
+    "before asking the user to resend anything.";
+const MATERIALIZE_ATTACHMENT_DESCRIPTION = "Materialize an attachment into a concrete file path the harness can inspect or hand to other tools. " +
+    "Use variant=original when you want the raw file. Use variant=vision_safe for images when you want the harness to normalize " +
+    "size and format into a VLM-safe image before retrying.";
+const DESCRIBE_IMAGE_DESCRIPTION = "Use this to inspect an image attachment with a targeted question, or to re-interrogate an image after a wrong first answer. " +
+    "The harness materializes the original attachment, normalizes it into a VLM-safe image when needed, and sends it through the vision-language model. " +
+    "Prefer specific prompts like 'what is the confirmation number?' over 'describe this image'. " +
+    "Pass attachment_id when you have it; attachment_guid is accepted as a compatibility alias.";
+function trimArg(value) {
+    return value?.trim() ?? "";
+}
+function resolveAttachmentId(args) {
+    return trimArg(args.attachment_id) || trimArg(args.attachment_guid);
+}
+function parseLimit(raw) {
+    if (!raw)
+        return undefined;
+    const parsed = Number.parseInt(raw, 10);
+    if (!Number.isFinite(parsed) || parsed <= 0)
+        return undefined;
+    return parsed;
+}
+function normalizeThrownReason(error) {
+    const rendered = String(error);
+    return rendered.startsWith("Error: ") ? rendered.slice(7) : rendered;
+}
+function attachmentNotFound(tool, attachmentId) {
+    const friction = {
+        kind: "local_repair",
+        recoverability: "transformable",
+        summary: `Attachment ${attachmentId} is not in the recent attachment store anymore.`,
+        signature: `${tool}:attachment-not-found`,
+        suggested_next_actions: [
+            {
+                kind: "tool",
+                tool: "list_recent_attachments",
+                reason: "Find the current attachment_id for the artifact you want to inspect before retrying.",
+            },
+        ],
+    };
+    return (0, tool_results_1.frictionToolResult)(tool, friction);
+}
+function missingAttachmentId(tool) {
+    return (0, tool_results_1.frictionToolResult)(tool, {
+        kind: "input_error",
+        recoverability: "transformable",
+        summary: "An attachment id is required for this tool call.",
+        signature: `${tool}:missing-attachment-id`,
+        suggested_next_actions: [
+            {
+                kind: "tool",
+                tool: "list_recent_attachments",
+                reason: "Inspect the current recent attachments and retry with attachment_id.",
+            },
+        ],
+    });
+}
+function missingPrompt() {
+    return (0, tool_results_1.frictionToolResult)("describe_image", {
+        kind: "input_error",
+        recoverability: "transformable",
+        summary: "describe_image needs a targeted prompt before retrying.",
+        signature: "describe_image:missing-prompt",
+        suggested_next_actions: [
+            {
+                kind: "message",
+                message: "Retry with a specific question like 'what is the confirmation number?' or 'what date is shown?'",
+            },
+        ],
+    });
+}
+function normalizeMaterializeError(tool, attachmentId, reason) {
+    if (reason.startsWith("Attachment not found:")) {
+        return attachmentNotFound(tool, attachmentId);
+    }
+    if (reason.includes("is not an image")) {
+        return (0, tool_results_1.frictionToolResult)(tool, {
+            kind: "input_error",
+            recoverability: "transformable",
+            summary: `Attachment ${attachmentId} is not an image, so it cannot produce a vision_safe variant.`,
+            signature: `${tool}:not-image`,
+            suggested_next_actions: [
+                {
+                    kind: "tool",
+                    tool: "materialize_attachment",
+                    reason: "Retry with variant=original if you need the raw file instead.",
+                    args: { attachment_id: attachmentId, variant: "original" },
+                },
+            ],
+        });
+    }
+    return (0, tool_results_1.frictionToolResult)(tool, {
+        kind: "local_repair",
+        recoverability: "retryable",
+        summary: reason,
+        signature: `${tool}:materialize-failed`,
+        suggested_next_actions: [
+            {
+                kind: "tool",
+                tool: "materialize_attachment",
+                reason: "Retry materialization once more in case the file path or normalization target changed.",
+                args: { attachment_id: attachmentId, variant: "vision_safe" },
+            },
+        ],
+    });
+}
+async function buildImageDataUrl(filePath, mimeType) {
+    const buffer = await fs.readFile(filePath);
+    const encoded = buffer.toString("base64");
+    const normalizedMime = mimeType?.trim().toLowerCase() || "image/jpeg";
+    return `data:${normalizedMime};base64,${encoded}`;
+}
+exports.attachmentToolDefinitions = [
+    {
+        tool: {
+            type: "function",
+            function: {
+                name: "list_recent_attachments",
+                description: LIST_ATTACHMENTS_DESCRIPTION,
+                parameters: {
+                    type: "object",
+                    properties: {
+                        kind: {
+                            type: "string",
+                            enum: ["image", "audio", "document", "binary", "unknown"],
+                            description: "Optional attachment kind filter.",
+                        },
+                        limit: {
+                            type: "string",
+                            description: "Optional numeric limit for how many attachments to return.",
+                        },
+                    },
+                },
+            },
+        },
+        handler: async (args) => {
+            const agentName = (0, identity_1.getAgentName)();
+            const kind = trimArg(args.kind);
+            const attachments = (0, store_1.listRecentAttachments)(agentName, {
+                kind: kind ? kind : undefined,
+                limit: parseLimit(args.limit),
+            });
+            return (0, tool_results_1.okToolResult)("list_recent_attachments", attachments);
+        },
+        summaryKeys: ["kind", "limit"],
+    },
+    {
+        tool: {
+            type: "function",
+            function: {
+                name: "materialize_attachment",
+                description: MATERIALIZE_ATTACHMENT_DESCRIPTION,
+                parameters: {
+                    type: "object",
+                    properties: {
+                        attachment_id: {
+                            type: "string",
+                            description: "Stable attachment id such as attachment:cli-local-file:... or attachment:bluebubbles:...",
+                        },
+                        attachment_guid: {
+                            type: "string",
+                            description: "Compatibility alias for older callers. Prefer attachment_id.",
+                        },
+                        variant: {
+                            type: "string",
+                            enum: ["original", "vision_safe"],
+                            description: "Which attachment variant to materialize.",
+                        },
+                    },
+                    required: ["variant"],
+                },
+            },
+        },
+        handler: async (args) => {
+            const attachmentId = resolveAttachmentId(args);
+            if (!attachmentId) {
+                return missingAttachmentId("materialize_attachment");
+            }
+            const agentName = (0, identity_1.getAgentName)();
+            const variant = trimArg(args.variant) === "vision_safe" ? "vision_safe" : "original";
+            try {
+                const materialized = await (0, materialize_1.materializeAttachment)(agentName, attachmentId, { variant });
+                return (0, tool_results_1.okToolResult)("materialize_attachment", materialized);
+            }
+            catch (error) {
+                const reason = normalizeThrownReason(error);
+                return normalizeMaterializeError("materialize_attachment", attachmentId, reason);
+            }
+        },
+        summaryKeys: ["attachment_id", "attachment_guid", "variant"],
+    },
+    {
+        tool: {
+            type: "function",
+            function: {
+                name: "describe_image",
+                description: DESCRIBE_IMAGE_DESCRIPTION,
+                parameters: {
+                    type: "object",
+                    properties: {
+                        attachment_id: {
+                            type: "string",
+                            description: "Stable attachment id for the image you want to inspect.",
+                        },
+                        attachment_guid: {
+                            type: "string",
+                            description: "Compatibility alias for older callers. Prefer attachment_id.",
+                        },
+                        prompt: {
+                            type: "string",
+                            description: "A targeted question about the image.",
+                        },
+                    },
+                    required: ["prompt"],
+                },
+            },
+        },
+        handler: async (args) => {
+            const attachmentId = resolveAttachmentId(args);
+            if (!attachmentId) {
+                return missingAttachmentId("describe_image");
+            }
+            const prompt = trimArg(args.prompt);
+            if (!prompt) {
+                return missingPrompt();
+            }
+            const agentName = (0, identity_1.getAgentName)();
+            try {
+                const materialized = await (0, materialize_1.materializeAttachment)(agentName, attachmentId, { variant: "vision_safe" });
+                const imageDataUrl = await buildImageDataUrl(materialized.path, materialized.mimeType);
+                const { apiKey } = (0, config_1.getMinimaxConfig)();
+                if (!apiKey) {
+                    return (0, tool_results_1.frictionToolResult)("describe_image", {
+                        kind: "external_blocker",
+                        recoverability: "blocked",
+                        summary: "MiniMax credentials are missing, so image understanding is unavailable until credentials are fixed.",
+                        signature: "describe_image:minimax-missing-key",
+                        suggested_next_actions: [
+                            {
+                                kind: "message",
+                                message: "Repair the minimax credentials for this agent, then retry describe_image.",
+                            },
+                        ],
+                    });
+                }
+                const description = await (0, minimax_vlm_1.minimaxVlmDescribe)({
+                    apiKey,
+                    prompt,
+                    imageDataUrl,
+                    baseURL: minimax_1.MINIMAX_PROVIDER_BASE_URL,
+                    attachmentGuid: attachmentId,
+                    mimeType: materialized.mimeType,
+                });
+                (0, runtime_1.emitNervesEvent)({
+                    component: "tools",
+                    event: "tool.describe_image_success",
+                    message: "describe_image returned a description",
+                    meta: { attachmentId },
+                });
+                return description;
+            }
+            catch (error) {
+                const reason = normalizeThrownReason(error);
+                return normalizeMaterializeError("describe_image", attachmentId, reason);
+            }
+        },
+        summaryKeys: ["attachment_id", "attachment_guid", "prompt"],
+    },
+];

package/dist/repertoire/tools-base.js

@@ -15,6 +15,7 @@ const tools_travel_1 = require("./tools-travel");
 const tools_user_profile_1 = require("./tools-user-profile");
 const tools_stripe_1 = require("./tools-stripe");
 const tools_flight_1 = require("./tools-flight");
+const tools_attachments_1 = require("./tools-attachments");
 // Re-export flow tools for consumers that import them from tools-base
 var tools_flow_1 = require("./tools-flow");
 Object.defineProperty(exports, "ponderTool", { enumerable: true, get: function () { return tools_flow_1.ponderTool; } });
@@ -44,6 +45,7 @@ exports.baseToolDefinitions = [
     ...tools_user_profile_1.userProfileToolDefinitions,
     ...tools_stripe_1.stripeToolDefinitions,
     ...tools_flight_1.flightToolDefinitions,
+    ...tools_attachments_1.attachmentToolDefinitions,
 ];
 // Convenience array of just the tool schemas (no handler/integration metadata).
 // Used by consumers that need the OpenAI function-tool format.

package/dist/repertoire/tools-bluebubbles.js

@@ -2,22 +2,6 @@
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.bluebubblesToolDefinitions = void 0;
 const runtime_1 = require("../nerves/runtime");
-const config_1 = require("../heart/config");
-const minimax_1 = require("../heart/providers/minimax");
-const minimax_vlm_1 = require("../heart/providers/minimax-vlm");
-const attachment_cache_1 = require("../senses/bluebubbles/attachment-cache");
-const media_1 = require("../senses/bluebubbles/media");
-// AX-1: the tool description is the only instruction manual a future agent
-// gets. It must teach WHEN to reach for the tool and HOW to write a good
-// prompt. A type-signature-style "Describes an image." is a violation.
-const DESCRIBE_IMAGE_DESCRIPTION = "Use this tool to look at an attachment the user sent, or to re-interrogate an image with a targeted question. " +
-    "The current chat model can't see images natively; this tool runs the image through a vision-language model (VLM) " +
-    "and returns a text description. " +
-    "Prefer targeted prompts (\"what's the flight number in the bottom-right?\") over generic ones (\"describe this image\") — " +
-    "you'll get better answers. " +
-    "Call this when the user sent a screenshot and you need to read text from it, verify a detail, or double-check something " +
-    "the ingestion-time auto-describe summary might have missed. " +
-    "The attachment_guid comes from the attachment marker in the user's most recent message.";
 exports.bluebubblesToolDefinitions = [
     {
         tool: {
@@ -107,95 +91,4 @@ exports.bluebubblesToolDefinitions = [
         },
         summaryKeys: ["target", "threadOriginatorGuid"],
     },
-    {
-        tool: {
-            type: "function",
-            function: {
-                name: "describe_image",
-                description: DESCRIBE_IMAGE_DESCRIPTION,
-                parameters: {
-                    type: "object",
-                    properties: {
-                        attachment_guid: {
-                            type: "string",
-                            description: "The guid of the attachment to describe. Usually pulled from the attachment marker in the user's most recent message.",
-                        },
-                        prompt: {
-                            type: "string",
-                            description: "A targeted question about the image. Prefer specific prompts over generic ones — e.g. 'what's the flight number in the bottom-right?' gives better answers than 'describe this image'.",
-                        },
-                    },
-                    required: ["attachment_guid", "prompt"],
-                },
-            },
-        },
-        handler: async (args) => {
-            const attachmentGuid = typeof args.attachment_guid === "string" ? args.attachment_guid.trim() : "";
-            const prompt = typeof args.prompt === "string" ? args.prompt.trim() : "";
-            if (!attachmentGuid) {
-                (0, runtime_1.emitNervesEvent)({
-                    level: "warn",
-                    component: "tools",
-                    event: "tool.error",
-                    message: "describe_image missing attachment_guid",
-                    meta: {},
-                });
-                return "describe_image: attachment_guid is required — pass the guid from the inbound attachment marker and retry";
-            }
-            if (!prompt) {
-                (0, runtime_1.emitNervesEvent)({
-                    level: "warn",
-                    component: "tools",
-                    event: "tool.error",
-                    message: "describe_image missing prompt",
-                    meta: {},
-                });
-                return "describe_image: prompt is required — supply a targeted question (e.g. 'what's the flight number in the bottom-right?') and retry";
-            }
-            const summary = (0, attachment_cache_1.lookupBlueBubblesAttachment)(attachmentGuid);
-            if (!summary) {
-                (0, runtime_1.emitNervesEvent)({
-                    level: "warn",
-                    component: "tools",
-                    event: "tool.error",
-                    message: "describe_image attachment not found in cache",
-                    meta: { attachmentGuid },
-                });
-                return `describe_image: no attachment with guid ${attachmentGuid} found in recent messages — ask the user to resend the image or verify the guid`;
-            }
-            try {
-                const config = (0, config_1.getBlueBubblesConfig)();
-                const channelConfig = (0, config_1.getBlueBubblesChannelConfig)();
-                const downloaded = await (0, media_1.downloadBlueBubblesAttachment)(summary, config, channelConfig);
-                const mimeType = downloaded.contentType ?? summary.mimeType ?? "image/png";
-                const base64 = downloaded.buffer.toString("base64");
-                const dataUrl = `data:${mimeType};base64,${base64}`;
-                const { apiKey } = (0, config_1.getMinimaxConfig)();
-                if (!apiKey) {
-                    throw new Error("minimax API key not found in secrets.json — re-run credential setup or add a minimax key");
-                }
-                const description = await (0, minimax_vlm_1.minimaxVlmDescribe)({
-                    apiKey,
-                    prompt,
-                    imageDataUrl: dataUrl,
-                    baseURL: minimax_1.MINIMAX_PROVIDER_BASE_URL,
-                    attachmentGuid,
-                    mimeType,
-                });
-                return description;
-            }
-            catch (error) {
-                const reason = error instanceof Error ? error.message : String(error);
-                (0, runtime_1.emitNervesEvent)({
-                    level: "warn",
-                    component: "tools",
-                    event: "tool.error",
-                    message: "describe_image failed",
-                    meta: { attachmentGuid, reason },
-                });
-                return `describe_image failed: ${reason}`;
-            }
-        },
-        summaryKeys: ["attachment_guid", "prompt"],
-    },
 ];

package/dist/repertoire/tools-flow.js

@@ -5,17 +5,51 @@ exports.ponderTool = {
     type: "function",
     function: {
         name: "ponder",
-        description: "i need to sit with this. from a conversation, takes the thread inward with a thought and a parting word. from inner dialog, keeps the wheel turning for another pass. must be the only tool call in the turn. Use when a question deserves more thought than this turn allows. Don't ponder trivial questions.",
+        description: "create or revise a typed ponder packet so i don't lose the plot while i keep working. use this for harness friction, research, or reflection that should survive the current turn. ponder does not end the turn, does not defer the response by itself, and may be followed by more tools before i settle or rest. Don't ponder trivial questions.",
         parameters: {
             type: "object",
             properties: {
+                action: {
+                    type: "string",
+                    enum: ["create", "revise"],
+                    description: "create a new packet or revise an existing drafting packet.",
+                },
+                kind: {
+                    type: "string",
+                    enum: ["harness_friction", "research", "reflection"],
+                    description: "the packet kind. determines the SOP the inner session should follow.",
+                },
+                packet_id: {
+                    type: "string",
+                    description: "required for action=revise. the packet to revise in place.",
+                },
+                follows_packet_id: {
+                    type: "string",
+                    description: "optional follow-up linkage when a new packet grows out of an earlier one.",
+                },
+                objective: {
+                    type: "string",
+                    description: "the durable objective for this packet.",
+                },
+                summary: {
+                    type: "string",
+                    description: "brief factual summary of the work object or friction being preserved.",
+                },
+                success_criteria: {
+                    type: "string",
+                    description: "newline-delimited success criteria bullets.",
+                },
+                payload_json: {
+                    type: "string",
+                    description: "JSON object string with packet-specific structured details. use {} when empty.",
+                },
                 thought: {
                     type: "string",
-                    description: "the question or thread that needs more thought — brief framing, not analysis. required from a conversation, ignored from inner dialog.",
+                    description: "deprecated compatibility field. legacy thought text is normalized into a reflection packet.",
                 },
                 say: {
                     type: "string",
-                    description: "what you say before going quiet — speak to what caught your attention, not just that something did. required from a conversation, ignored from inner dialog.",
+                    description: "deprecated compatibility field. retained for migration only; it no longer controls deferral or silence.",
                 },
             },
         },
@@ -53,10 +87,19 @@ exports.restTool = {
     type: "function",
     function: {
         name: "rest",
-        description: "put this down for now — the wheel stops until the next heartbeat. must be the only tool call in the turn.",
+        description: "end an inner-session turn when i'm done thinking. rest remains the explicit terminal move for the inner session and must be the only tool call in the turn. on idle heartbeat turns, use status=HEARTBEAT_OK.",
         parameters: {
             type: "object",
-            properties: {},
+            properties: {
+                status: {
+                    type: "string",
+                    description: "optional rest status. use HEARTBEAT_OK when the heartbeat fires and there is nothing to do.",
+                },
+                note: {
+                    type: "string",
+                    description: "optional brief note about why i'm resting.",
+                },
+            },
         },
     },
 };

package/dist/repertoire/tools.js

@@ -15,7 +15,6 @@ const tools_bundle_1 = require("./tools-bundle");
 const runtime_1 = require("../nerves/runtime");
 const guardrails_1 = require("./guardrails");
 const identity_1 = require("../heart/identity");
-const model_capabilities_1 = require("../heart/model-capabilities");
 const tools_surface_1 = require("./tools-surface");
 const mcp_tools_1 = require("./mcp-tools");
 function safeGetAgentRoot() {
@@ -75,17 +74,10 @@ function filterByCapability(toolList, providerCapabilities) {
 // Teams/integration tools are included only if their integration is in availableIntegrations.
 // When toolPreferences is provided, matching preferences are appended to tool descriptions.
 // When providerCapabilities is provided, tools with requiredCapability are filtered.
-// When chatModel is provided and has `vision: true` in ModelCapabilities, the
-// BlueBubbles-scoped `describe_image` tool is excluded (native image_url
-// pass-through makes the tool redundant). When chatModel is undefined the
-// tool IS included — the default errs toward more tools on an ambiguous caller.
-function getToolsForChannel(capabilities, toolPreferences, _context, providerCapabilities, mcpManager, chatModel) {
+function getToolsForChannel(capabilities, toolPreferences, _context, providerCapabilities, mcpManager, _chatModel) {
     const baseTools = baseToolsForCapabilities();
-    const visionCapable = chatModel ? (0, model_capabilities_1.getModelCapabilities)(chatModel).vision === true : false;
     const bluebubblesTools = capabilities?.channel === "bluebubbles"
-        ? tools_bluebubbles_1.bluebubblesToolDefinitions
-            .filter((d) => d.tool.function.name !== "describe_image" || !visionCapable)
-            .map((d) => d.tool)
+        ? tools_bluebubbles_1.bluebubblesToolDefinitions.map((d) => d.tool)
         : [];
     let result;
     if (!capabilities || capabilities.availableIntegrations.length === 0) {

package/dist/senses/attention-queue.js

@@ -13,9 +13,22 @@ function originKey(friendId, channel, key) {
     return `${friendId}/${channel}/${key}`;
 }
 function buildAttentionQueue(input) {
-    const { drainedPending, outstandingObligations, friendNameResolver } = input;
+    const { drainedPending, outstandingObligations, friendNameResolver, packetResolver } = input;
     const seen = new Set();
     const items = [];
+    const enrichPacket = (packetId) => {
+        if (!packetId || !packetResolver)
+            return {};
+        const packet = packetResolver(packetId);
+        if (!packet)
+            return { packetId };
+        return {
+            packetId,
+            packetKind: packet.kind,
+            packetObjective: packet.objective,
+            packetSummary: packet.summary,
+        };
+    };
     // Source 1: drained pending messages with delegatedFrom (current-turn delegations)
     for (const msg of drainedPending) {
         if (!msg.delegatedFrom)
@@ -33,6 +46,7 @@ function buildAttentionQueue(input) {
             ...(bridgeId ? { bridgeId } : {}),
             delegatedContent: msg.content,
             ...(msg.obligationId ? { obligationId: msg.obligationId } : {}),
+            ...enrichPacket(msg.packetId),
             source: "drained",
             timestamp: msg.timestamp,
         });
@@ -54,6 +68,7 @@ function buildAttentionQueue(input) {
             ...(bridgeId ? { bridgeId } : {}),
             delegatedContent: obligation.delegatedContent,
             obligationId: obligation.id,
+            ...enrichPacket(obligation.packetId),
             source: "obligation-recovery",
             timestamp: obligation.createdAt,
         });
@@ -88,6 +103,10 @@ function buildAttentionQueueSummary(queue) {
         return "";
     const lines = ["you're holding:"];
     for (const item of queue) {
+        if (item.packetKind && item.packetObjective) {
+            lines.push(`- [${item.id}] ${item.friendName} -> ${item.packetKind}: ${item.packetObjective}`);
+            continue;
+        }
         const preview = item.delegatedContent.length > CONTENT_PREVIEW_MAX
             ? `${item.delegatedContent.slice(0, CONTENT_PREVIEW_MAX - 3)}...`
             : item.delegatedContent;