@sentry/junior 0.5.0 → 0.7.0

package/dist/{chunk-3ENACZ27.js → chunk-JRKU55W5.js}

@@ -1,7 +1,12 @@
+import {
+  parseSkillFile,
+  stripFrontmatter
+} from "./chunk-KT5HARSN.js";
 import {
   CredentialUnavailableError,
   SANDBOX_SKILLS_ROOT,
   SANDBOX_WORKSPACE_ROOT,
+  aboutPathCandidates,
   botConfig,
   claimQueueIngressDedup,
   createPluginBroker,
@@ -26,7 +31,7 @@ import {
   skillRoots,
   soulPathCandidates,
   upsertAgentTurnSessionCheckpoint
-} from "./chunk-BKYYVLVN.js";
+} from "./chunk-RKOO42TW.js";
 import {
   logError,
   logException,
@@ -270,7 +275,7 @@ function escapeXml(value) {
 var replyDecisionSchema = z.object({
   should_reply: z.boolean().describe("Whether Junior should respond to this thread message."),
   confidence: z.number().min(0).max(1).describe("Classifier confidence from 0 to 1."),
-  reason: z.string().max(160).optional().describe("Short reason for the decision.")
+  reason: z.string().optional().describe("Short reason for the decision.")
 });
 var ROUTER_CONFIDENCE_THRESHOLD = 0.72;
 var ACK_REGEXES = [
@@ -281,6 +286,11 @@ var ACK_REGEXES = [
 ];
 var QUESTION_PREFIX_RE = /^(what|why|how|when|where|which|who|can|could|would|should|do|does|did|is|are|was|were|will)\b/i;
 var FOLLOW_UP_REF_RE = /\b(you|your|that|this|it|above|previous|earlier|last|just\s+said)\b/i;
+var LEADING_SLACK_MENTION_RE = /^\s*<@([A-Z0-9]+)(?:\|([^>]+))?>[\s,:-]*/i;
+var LEADING_NAMED_MENTION_RE = /^\s*@([a-z0-9._-]+)\b[\s,:-]*/i;
+function escapeRegExp(value) {
+  return value.replace(/[.*+?^${}()|[\]\\]/g, "\\$&");
+}
 function tokenizeForOverlap(value) {
   return value.toLowerCase().split(/[^a-z0-9]+/).filter((token) => token.length >= 4);
 }
@@ -329,6 +339,54 @@ function isLikelyAssistantDirectedFollowUp(text, conversationContext) {
   }
   return false;
 }
+function containsAssistantInvocation(text, botUserName) {
+  const escapedUserName = escapeRegExp(botUserName);
+  const plainNameMentionRe = new RegExp(`(^|\\s)@${escapedUserName}\\b`, "i");
+  const labeledEntityMentionRe = new RegExp(
+    `<@[^>|]+\\|${escapedUserName}>`,
+    "i"
+  );
+  return plainNameMentionRe.test(text) || labeledEntityMentionRe.test(text);
+}
+function detectLeadingOtherPartyAddress(rawText, text, botUserName) {
+  if (containsAssistantInvocation(rawText, botUserName) || containsAssistantInvocation(text, botUserName)) {
+    return void 0;
+  }
+  const leadingSlackMention = rawText.match(LEADING_SLACK_MENTION_RE);
+  if (leadingSlackMention) {
+    const label = leadingSlackMention[2]?.trim();
+    return label ? `slack_mention:${label}` : "slack_mention";
+  }
+  const leadingNamedMention = text.match(LEADING_NAMED_MENTION_RE);
+  if (!leadingNamedMention) {
+    return void 0;
+  }
+  const directedName = leadingNamedMention[1]?.trim();
+  if (!directedName || directedName.toLowerCase() === botUserName.toLowerCase()) {
+    return void 0;
+  }
+  return `named_mention:${directedName}`;
+}
+function getSubscribedReplyPreflightDecision(args) {
+  const text = args.text.trim();
+  const rawText = args.rawText.trim();
+  if (args.isExplicitMention) {
+    return { shouldReply: true, reason: "explicit_mention" /* ExplicitMention */ };
+  }
+  const leadingOtherPartyAddress = detectLeadingOtherPartyAddress(
+    rawText,
+    text,
+    args.botUserName
+  );
+  if (!leadingOtherPartyAddress) {
+    return void 0;
+  }
+  return {
+    shouldReply: false,
+    reason: "directed_to_other_party" /* DirectedToOtherParty */,
+    reasonDetail: leadingOtherPartyAddress
+  };
+}
 function buildRouterSystemPrompt(botUserName, conversationContext) {
   return [
     "You are a message router for a Slack assistant named Junior in a subscribed Slack thread.",
@@ -352,8 +410,14 @@ function buildRouterSystemPrompt(botUserName, conversationContext) {
 async function decideSubscribedThreadReply(args) {
   const text = args.input.text.trim();
   const rawText = args.input.rawText.trim();
-  if (args.input.isExplicitMention) {
-    return { shouldReply: true, reason: "explicit_mention" /* ExplicitMention */ };
+  const preflightDecision = getSubscribedReplyPreflightDecision({
+    botUserName: args.botUserName,
+    rawText,
+    text,
+    isExplicitMention: args.input.isExplicitMention
+  });
+  if (preflightDecision) {
+    return preflightDecision;
   }
   if (!text && !args.input.hasAttachments) {
     return { shouldReply: false, reason: "empty_message" /* EmptyMessage */ };
@@ -365,7 +429,10 @@ async function decideSubscribedThreadReply(args) {
     return { shouldReply: false, reason: "acknowledgment" /* Acknowledgment */ };
   }
   if (isLikelyAssistantDirectedFollowUp(text, args.input.conversationContext)) {
-    return { shouldReply: true, reason: "follow_up_question" /* FollowUpQuestion */ };
+    return {
+      shouldReply: true,
+      reason: "follow_up_question" /* FollowUpQuestion */
+    };
   }
   try {
     const result = await args.completeObject({
@@ -373,7 +440,10 @@ async function decideSubscribedThreadReply(args) {
       schema: replyDecisionSchema,
       maxTokens: 120,
       temperature: 0,
-      system: buildRouterSystemPrompt(args.botUserName, args.input.conversationContext),
+      system: buildRouterSystemPrompt(
+        args.botUserName,
+        args.input.conversationContext
+      ),
       prompt: rawText,
       metadata: {
         modelId: args.modelId,
@@ -694,20 +764,20 @@ var slackOutputPolicy = {
 
 // src/chat/prompt.ts
 var DEFAULT_SOUL = "You are Junior, a practical and concise assistant.";
-function loadSoul() {
+function loadOptionalMarkdownFile(candidates, fileName) {
   const attempted = [];
-  for (const resolved of soulPathCandidates()) {
+  for (const resolved of candidates) {
     attempted.push(resolved);
     try {
       const raw = fs.readFileSync(resolved, "utf8").trim();
       if (raw.length > 0) {
         logInfo(
-          "soul_loaded",
+          `${fileName.toLowerCase()}_loaded`,
           {},
           {
             "file.path": resolved
           },
-          "Loaded SOUL.md"
+          `Loaded ${fileName}`
         );
         return raw;
       }
@@ -715,16 +785,26 @@ function loadSoul() {
       continue;
     }
   }
+  return null;
+}
+function loadSoul() {
+  const soul = loadOptionalMarkdownFile(soulPathCandidates(), "SOUL.md");
+  if (soul) {
+    return soul;
+  }
   logWarn(
     "soul_load_fallback",
     {},
     {
-      "file.candidates": attempted
+      "file.candidates": soulPathCandidates()
     },
     "SOUL.md not found; using built-in default personality"
   );
   return DEFAULT_SOUL;
 }
+function loadAbout() {
+  return loadOptionalMarkdownFile(aboutPathCandidates(), "ABOUT.md");
+}
 var JUNIOR_PERSONALITY = (() => {
   try {
     return loadSoul();
@@ -740,6 +820,21 @@ var JUNIOR_PERSONALITY = (() => {
     return DEFAULT_SOUL;
   }
 })();
+var JUNIOR_ABOUT = (() => {
+  try {
+    return loadAbout();
+  } catch (error) {
+    logWarn(
+      "about_load_failed",
+      {},
+      {
+        "error.message": error instanceof Error ? error.message : String(error)
+      },
+      "Failed to load ABOUT.md; omitting about prompt context"
+    );
+    return null;
+  }
+})();
 function workspaceSkillDir(skillName) {
   return sandboxSkillDir(skillName);
 }
@@ -912,6 +1007,16 @@ function buildSystemPrompt(params) {
         JUNIOR_PERSONALITY.trim()
       ].join("\n")
     ),
+    ...JUNIOR_ABOUT ? [
+      renderTag(
+        "about",
+        [
+          "Use this as the assistant's product/domain description when relevant.",
+          "",
+          JUNIOR_ABOUT.trim()
+        ].join("\n")
+      )
+    ] : [],
     renderTag(
       "identity-context",
       [
@@ -965,11 +1070,12 @@ function buildSystemPrompt(params) {
         "- For factual or external questions, run tools/skills first, then answer from evidence.",
         "- Use tool descriptions as the source of truth for when each tool should or should not be called.",
         "- Use `bash` to inspect skill files from `skill_dir` and run shell commands inside the sandbox workspace.",
-        "- Use `attachFile` to attach files from the sandbox (for example screenshots, PDFs, logs) to the Slack reply.",
+        "- Use `attachFile` for files that actually exist in the sandbox (for example screenshots, PDFs, logs), or for `attachment_path` values returned by `imageGenerate`.",
         "- If the user asks to see/share/show a screenshot or file, attach the file with `attachFile` instead of only reporting its path.",
         "- Never claim a screenshot/file is attached unless `attachFile` succeeded in this turn.",
         "- If `attachFile` fails, explain the failure and do not say the file was shared.",
         "- Use `imageGenerate` when the user asks for image creation.",
+        "- `imageGenerate` returns generated image metadata, including `attachment_path` values you can pass to `attachFile` when the user should receive the image.",
         "- Use `slackCanvasCreate` for long-form docs/specs and `slackCanvasUpdate` for doc follow-ups.",
         "- `slackCanvasUpdate` targets the active artifact-context canvas automatically; do not ask the user for `canvas_id`.",
         "- When you create or update a Slack artifact in this turn (for example a canvas, list, posted message, or attached file), mention it explicitly in the final reply and include its link when the tool returned one.",
@@ -2358,127 +2464,6 @@ import path2 from "path";
 // src/chat/skills.ts
 import fs2 from "fs/promises";
 import path from "path";
-
-// src/chat/skill-frontmatter.ts
-import { parse as parseYaml } from "yaml";
-var FRONTMATTER_RE = /^---\r?\n([\s\S]*?)\r?\n---\r?\n?/;
-var SKILL_NAME_RE = /^[a-z0-9-]+$/;
-var CAPABILITY_TOKEN_RE = /^[a-z0-9]+(?:\.[a-z0-9-]+)+$/;
-var MAX_NAME_LENGTH = 64;
-var MAX_DESCRIPTION_LENGTH = 1024;
-var MAX_COMPATIBILITY_LENGTH = 500;
-function hasAngleBrackets(value) {
-  return value.includes("<") || value.includes(">");
-}
-function validateSkillName(name) {
-  if (!name) return "name must not be empty";
-  if (name.length > MAX_NAME_LENGTH) return `name must be <= ${MAX_NAME_LENGTH} characters`;
-  if (!SKILL_NAME_RE.test(name)) return "name must contain only lowercase letters, digits, and hyphens";
-  if (name.startsWith("-") || name.endsWith("-")) return "name must not start or end with a hyphen";
-  if (name.includes("--")) return "name must not contain consecutive hyphens";
-  return null;
-}
-function stripFrontmatter(raw) {
-  return raw.replace(FRONTMATTER_RE, "").trim();
-}
-function parseAndValidateSkillFrontmatter(raw, expectedName) {
-  const match = FRONTMATTER_RE.exec(raw);
-  if (!match) {
-    return { ok: false, error: "Missing YAML frontmatter at start of file" };
-  }
-  let parsed;
-  try {
-    parsed = parseYaml(match[1]);
-  } catch (error) {
-    return {
-      ok: false,
-      error: `Invalid YAML frontmatter: ${error instanceof Error ? error.message : String(error)}`
-    };
-  }
-  if (!parsed || typeof parsed !== "object" || Array.isArray(parsed)) {
-    return { ok: false, error: "Frontmatter must be a YAML object" };
-  }
-  const frontmatter = parsed;
-  const name = frontmatter.name;
-  const description = frontmatter.description;
-  if (typeof name !== "string") {
-    return { ok: false, error: 'Frontmatter field "name" must be a string' };
-  }
-  const nameError = validateSkillName(name);
-  if (nameError) {
-    return { ok: false, error: nameError };
-  }
-  if (expectedName && name !== expectedName) {
-    return { ok: false, error: `name "${name}" must match directory "${expectedName}"` };
-  }
-  if (typeof description !== "string") {
-    return { ok: false, error: 'Frontmatter field "description" must be a string' };
-  }
-  if (!description.trim()) {
-    return { ok: false, error: "description must not be empty" };
-  }
-  if (description.length > MAX_DESCRIPTION_LENGTH) {
-    return { ok: false, error: `description must be <= ${MAX_DESCRIPTION_LENGTH} characters` };
-  }
-  if (hasAngleBrackets(description)) {
-    return { ok: false, error: 'description must not contain "<" or ">"' };
-  }
-  if ("metadata" in frontmatter && (typeof frontmatter.metadata !== "object" || !frontmatter.metadata || Array.isArray(frontmatter.metadata))) {
-    return { ok: false, error: 'Frontmatter field "metadata" must be an object when present' };
-  }
-  if ("compatibility" in frontmatter) {
-    if (typeof frontmatter.compatibility !== "string") {
-      return { ok: false, error: 'Frontmatter field "compatibility" must be a string when present' };
-    }
-    if (frontmatter.compatibility.length > MAX_COMPATIBILITY_LENGTH) {
-      return { ok: false, error: `compatibility must be <= ${MAX_COMPATIBILITY_LENGTH} characters` };
-    }
-  }
-  if ("license" in frontmatter && typeof frontmatter.license !== "string") {
-    return { ok: false, error: 'Frontmatter field "license" must be a string when present' };
-  }
-  if ("allowed-tools" in frontmatter && typeof frontmatter["allowed-tools"] !== "string") {
-    return { ok: false, error: 'Frontmatter field "allowed-tools" must be a string when present' };
-  }
-  if ("requires-capabilities" in frontmatter) {
-    if (typeof frontmatter["requires-capabilities"] !== "string") {
-      return { ok: false, error: 'Frontmatter field "requires-capabilities" must be a string when present' };
-    }
-    const tokens = frontmatter["requires-capabilities"].split(/\s+/).map((token) => token.trim()).filter((token) => token.length > 0);
-    for (const token of tokens) {
-      if (!CAPABILITY_TOKEN_RE.test(token)) {
-        return {
-          ok: false,
-          error: `requires-capabilities token "${token}" is invalid; expected dotted lowercase tokens (for example "github.issues.write")`
-        };
-      }
-    }
-  }
-  if ("uses-config" in frontmatter) {
-    if (typeof frontmatter["uses-config"] !== "string") {
-      return { ok: false, error: 'Frontmatter field "uses-config" must be a string when present' };
-    }
-    const tokens = frontmatter["uses-config"].split(/\s+/).map((token) => token.trim()).filter((token) => token.length > 0);
-    for (const token of tokens) {
-      if (!CAPABILITY_TOKEN_RE.test(token)) {
-        return {
-          ok: false,
-          error: `uses-config token "${token}" is invalid; expected dotted lowercase tokens (for example "github.repo")`
-        };
-      }
-    }
-  }
-  return {
-    ok: true,
-    frontmatter: {
-      ...frontmatter,
-      name,
-      description
-    }
-  };
-}
-
-// src/chat/skills.ts
 var SKILL_CACHE_TTL_MS = 5e3;
 var skillCache = null;
 function resolveSkillRoots(options) {
@@ -2488,7 +2473,12 @@ function resolveSkillRoots(options) {
   const pluginRoots = getPluginSkillRoots();
   const seen = /* @__PURE__ */ new Set();
   const resolved = [];
-  for (const root of [...additionalRoots, ...envRoots, ...defaults, ...pluginRoots]) {
+  for (const root of [
+    ...additionalRoots,
+    ...envRoots,
+    ...defaults,
+    ...pluginRoots
+  ]) {
     const normalized = path.resolve(root);
     if (seen.has(normalized)) {
       continue;
@@ -2498,22 +2488,6 @@ function resolveSkillRoots(options) {
   }
   return resolved;
 }
-function parseAllowedTools(value) {
-  return parseTokenList(value);
-}
-function parseRequiresCapabilities(value) {
-  return parseTokenList(value);
-}
-function parseUsesConfig(value) {
-  return parseTokenList(value);
-}
-function parseTokenList(value) {
-  if (typeof value !== "string") {
-    return void 0;
-  }
-  const parsed = value.split(/\s+/).map((token) => token.trim()).filter((token) => token.length > 0);
-  return parsed.length > 0 ? parsed : void 0;
-}
 function validateSkillMetadata(input) {
   const unknownCapabilities = (input.requiresCapabilities ?? []).filter(
     (capability) => !isKnownCapability(capability)
@@ -2521,7 +2495,9 @@ function validateSkillMetadata(input) {
   if (unknownCapabilities.length > 0) {
     return `Unknown requires-capabilities values: ${unknownCapabilities.join(", ")}`;
   }
-  const unknownConfigKeys = (input.usesConfig ?? []).filter((configKey) => !isKnownConfigKey(configKey));
+  const unknownConfigKeys = (input.usesConfig ?? []).filter(
+    (configKey) => !isKnownConfigKey(configKey)
+  );
   if (unknownConfigKeys.length > 0) {
     return `Unknown uses-config values: ${unknownConfigKeys.join(", ")}`;
   }
@@ -2531,24 +2507,40 @@ async function readSkillDirectory(skillDir) {
   const skillFile = path.join(skillDir, "SKILL.md");
   try {
     const raw = await fs2.readFile(skillFile, "utf8");
-    const parsed = parseAndValidateSkillFrontmatter(raw, path.basename(skillDir));
+    const parsed = parseSkillFile(raw, path.basename(skillDir));
     if (!parsed.ok) {
-      logWarn("skill_frontmatter_invalid", {}, {
-        "file.path": skillDir,
-        "error.message": parsed.error
-      }, "Invalid skill frontmatter");
+      logWarn(
+        "skill_frontmatter_invalid",
+        {},
+        {
+          "file.path": skillDir,
+          "error.message": parsed.error
+        },
+        "Invalid skill frontmatter"
+      );
       return null;
     }
-    const { name, description } = parsed.frontmatter;
-    const allowedTools = parseAllowedTools(parsed.frontmatter["allowed-tools"]);
-    const requiresCapabilities = parseRequiresCapabilities(parsed.frontmatter["requires-capabilities"]);
-    const usesConfig = parseUsesConfig(parsed.frontmatter["uses-config"]);
-    const metadataError = validateSkillMetadata({ requiresCapabilities, usesConfig });
+    const {
+      name,
+      description,
+      allowedTools,
+      requiresCapabilities,
+      usesConfig
+    } = parsed.skill;
+    const metadataError = validateSkillMetadata({
+      requiresCapabilities,
+      usesConfig
+    });
     if (metadataError) {
-      logWarn("skill_frontmatter_invalid", {}, {
-        "file.path": skillDir,
-        "error.message": metadataError
-      }, "Invalid skill frontmatter");
+      logWarn(
+        "skill_frontmatter_invalid",
+        {},
+        {
+          "file.path": skillDir,
+          "error.message": metadataError
+        },
+        "Invalid skill frontmatter"
+      );
       return null;
     }
     return {
@@ -2560,10 +2552,15 @@ async function readSkillDirectory(skillDir) {
       usesConfig
     };
   } catch (error) {
-    logWarn("skill_directory_read_failed", {}, {
-      "file.path": skillDir,
-      "error.message": error instanceof Error ? error.message : String(error)
-    }, "Failed to read skill directory");
+    logWarn(
+      "skill_directory_read_failed",
+      {},
+      {
+        "file.path": skillDir,
+        "error.message": error instanceof Error ? error.message : String(error)
+      },
+      "Failed to read skill directory"
+    );
     return null;
   }
 }
@@ -2578,7 +2575,9 @@ async function discoverSkills(options) {
   for (const root of roots) {
     try {
       const entries = await fs2.readdir(root, { withFileTypes: true });
-      for (const entry of entries.sort((a, b) => a.name.localeCompare(b.name))) {
+      for (const entry of entries.sort(
+        (a, b) => a.name.localeCompare(b.name)
+      )) {
         if (!entry.isDirectory()) {
           continue;
         }
@@ -2589,10 +2588,15 @@ async function discoverSkills(options) {
         }
       }
     } catch (error) {
-      logWarn("skill_root_read_failed", {}, {
-        "file.directory": root,
-        "error.message": error instanceof Error ? error.message : String(error)
-      }, "Failed to read skill root");
+      logWarn(
+        "skill_root_read_failed",
+        {},
+        {
+          "file.directory": root,
+          "error.message": error instanceof Error ? error.message : String(error)
+        },
+        "Failed to read skill root"
+      );
     }
   }
   const sorted = discovered.sort((a, b) => a.name.localeCompare(b.name));
@@ -2605,7 +2609,9 @@ async function discoverSkills(options) {
 }
 function parseSkillInvocation(messageText, availableSkills) {
   const trimmed = messageText.trim();
-  const match = /(?:^|\s)\/([a-z0-9]+(?:-[a-z0-9]+)*)(?:\s+([\s\S]*))?/i.exec(trimmed);
+  const match = /(?:^|\s)\/([a-z0-9]+(?:-[a-z0-9]+)*)(?:\s+([\s\S]*))?/i.exec(
+    trimmed
+  );
   if (!match) {
     return null;
   }
@@ -2630,9 +2636,13 @@ async function loadSkillsByName(skillNames, available) {
     }
     const skillFile = path.join(meta.skillPath, "SKILL.md");
     const raw = await fs2.readFile(skillFile, "utf8");
+    const parsed = parseSkillFile(raw, meta.name);
+    if (!parsed.ok) {
+      throw new Error(`Invalid skill file in ${skillFile}: ${parsed.error}`);
+    }
     skills.push({
       ...meta,
-      body: stripFrontmatter(raw)
+      body: parsed.skill.body
     });
   }
   return skills;
@@ -2906,7 +2916,7 @@ async function detectMimeType(sandbox, targetPath) {
 }
 function createAttachFileTool(sandbox, hooks = {}) {
   return tool({
-    description: "Attach a file from the sandbox to the Slack reply. Use this immediately after creating screenshots/reports when the user asks to see/share the actual file, not just its path.",
+    description: "Attach a file to the Slack reply. Use this for files that exist in the sandbox, such as screenshots, PDFs, or logs, or for generated image `attachment_path` values returned earlier in the turn.",
     inputSchema: Type2.Object(
       {
         path: Type2.String({
@@ -2932,6 +2942,20 @@ function createAttachFileTool(sandbox, hooks = {}) {
       const targetPath = normalizeSandboxPath(requestedPath);
       const fileBuffer = await sandbox.readFileToBuffer({ path: targetPath });
       if (!fileBuffer) {
+        const generatedFile = hooks.getGeneratedFile?.(
+          path3.posix.basename(targetPath)
+        );
+        if (generatedFile) {
+          hooks.onGeneratedFiles?.([generatedFile]);
+          return {
+            ok: true,
+            attached: true,
+            path: targetPath,
+            filename: generatedFile.filename,
+            mime_type: generatedFile.mimeType ?? inferMimeType(generatedFile.filename),
+            bytes: Buffer.isBuffer(generatedFile.data) ? generatedFile.data.byteLength : generatedFile.data instanceof ArrayBuffer ? generatedFile.data.byteLength : generatedFile.data.size
+          };
+        }
         throw new Error(`failed to read file: ${targetPath}`);
       }
       if (fileBuffer.byteLength === 0) {
@@ -3215,12 +3239,22 @@ async function enrichImagePrompt(rawPrompt) {
       maxTokens: 1024
     });
     if (text && text.trim().length > 0) {
-      logInfo("image_prompt_enriched", {}, { "app.image.enriched_prompt_length": text.trim().length }, "Image prompt enriched with persona");
+      logInfo(
+        "image_prompt_enriched",
+        {},
+        { "app.image.enriched_prompt_length": text.trim().length },
+        "Image prompt enriched with persona"
+      );
       return text.trim();
     }
     return rawPrompt;
   } catch (error) {
-    logWarn("image_prompt_enrichment_failed", {}, { "error.message": String(error) }, "Image prompt enrichment failed, using raw prompt");
+    logWarn(
+      "image_prompt_enrichment_failed",
+      {},
+      { "error.message": String(error) },
+      "Image prompt enrichment failed, using raw prompt"
+    );
     return rawPrompt;
   }
 }
@@ -3245,7 +3279,7 @@ function parseImageGenerationError(status, body, model) {
     return `image generation failed: ${status} ${body}`;
   }
 }
-function createImageGenerateTool(hooks) {
+function createImageGenerateTool(hooks, deps = {}) {
   return tool({
     description: "Generate images from a prompt. Use when the user wants to visually show or represent something \u2014 feelings, concepts, art, humor, or any visual idea. Also use for explicit image creation requests.",
     inputSchema: Type3.Object({
@@ -3256,27 +3290,35 @@ function createImageGenerateTool(hooks) {
       })
     }),
     execute: async ({ prompt }) => {
+      const fetchImpl = deps.fetch ?? fetch;
       const apiKey = process.env.AI_GATEWAY_API_KEY ?? process.env.VERCEL_OIDC_TOKEN;
       if (!apiKey) {
-        throw new Error("Missing AI gateway credentials (AI_GATEWAY_API_KEY or VERCEL_OIDC_TOKEN)");
+        throw new Error(
+          "Missing AI gateway credentials (AI_GATEWAY_API_KEY or VERCEL_OIDC_TOKEN)"
+        );
       }
       const model = process.env.AI_IMAGE_MODEL ?? DEFAULT_IMAGE_MODEL;
       const enrichedPrompt = await enrichImagePrompt(prompt);
-      const response = await fetch("https://ai-gateway.vercel.sh/v1/chat/completions", {
-        method: "POST",
-        headers: {
-          "content-type": "application/json",
-          authorization: `Bearer ${apiKey}`
-        },
-        body: JSON.stringify({
-          model,
-          messages: [{ role: "user", content: enrichedPrompt }],
-          modalities: ["image"]
-        })
-      });
+      const response = await fetchImpl(
+        "https://ai-gateway.vercel.sh/v1/chat/completions",
+        {
+          method: "POST",
+          headers: {
+            "content-type": "application/json",
+            authorization: `Bearer ${apiKey}`
+          },
+          body: JSON.stringify({
+            model,
+            messages: [{ role: "user", content: enrichedPrompt }],
+            modalities: ["image"]
+          })
+        }
+      );
       if (!response.ok) {
         const text = await response.text();
-        throw new Error(parseImageGenerationError(response.status, text, model));
+        throw new Error(
+          parseImageGenerationError(response.status, text, model)
+        );
       }
       const payload = await response.json();
       const uploads = [];
@@ -3291,7 +3333,7 @@ function createImageGenerateTool(hooks) {
           mimeType = match[1] ?? mimeType;
           bytes = Buffer.from(match[2] ?? "", "base64");
         } else if (typeof url === "string" && url.length > 0) {
-          const fetched = await fetch(url);
+          const fetched = await fetchImpl(url);
           if (!fetched.ok) continue;
           mimeType = fetched.headers.get("content-type") ?? mimeType;
           bytes = Buffer.from(await fetched.arrayBuffer());
@@ -3305,7 +3347,7 @@ function createImageGenerateTool(hooks) {
         });
       }
       if (uploads.length > 0) {
-        hooks.onGeneratedFiles?.(uploads);
+        hooks.onGeneratedArtifactFiles?.(uploads);
       }
       return {
         ok: true,
@@ -3315,10 +3357,11 @@ function createImageGenerateTool(hooks) {
         image_count: uploads.length,
         images: uploads.map((upload) => ({
           filename: upload.filename,
+          attachment_path: upload.filename,
           media_type: upload.mimeType,
           bytes: upload.data.byteLength
         })),
-        delivery: "Images will be attached to the Slack response as files."
+        delivery: "Generated images are available to attach with attachFile using the returned attachment_path."
       };
     }
   });
@@ -3337,19 +3380,11 @@ function toLoadedSkill(result) {
     body: result.instructions
   };
 }
-function stripFrontmatter2(raw) {
-  if (!raw.startsWith("---")) {
-    return raw;
-  }
-  const match = /^---\n[\s\S]*?\n---\n?/.exec(raw);
-  if (!match) {
-    return raw;
-  }
-  return raw.slice(match[0].length);
-}
 async function loadSkillFromSandbox(sandbox, availableSkills, skillName) {
   const requested = skillName.trim().toLowerCase();
-  const skill = availableSkills.find((entry) => entry.name.toLowerCase() === requested);
+  const skill = availableSkills.find(
+    (entry) => entry.name.toLowerCase() === requested
+  );
   if (!skill) {
     return {
       ok: false,
@@ -3369,7 +3404,7 @@ async function loadSkillFromSandbox(sandbox, availableSkills, skillName) {
     description: skill.description,
     skill_dir: skillDir,
     location: skillFilePath,
-    instructions: stripFrontmatter2(file.toString("utf8"))
+    instructions: stripFrontmatter(file.toString("utf8"))
   };
 }
 function createLoadSkillTool(sandbox, availableSkills, options) {
@@ -3382,7 +3417,11 @@ function createLoadSkillTool(sandbox, availableSkills, options) {
       })
     }),
     execute: async ({ skill_name }) => {
-      const result = await loadSkillFromSandbox(sandbox, availableSkills, skill_name);
+      const result = await loadSkillFromSandbox(
+        sandbox,
+        availableSkills,
+        skill_name
+      );
       const loadedSkill = toLoadedSkill(result);
       if (loadedSkill) {
         await options?.onSkillLoaded?.(loadedSkill);
@@ -5034,7 +5073,7 @@ function createTools(availableSkills, hooks = {}, context) {
     webFetch: wrapToolExecution("webFetch", createWebFetchTool(hooks), hooks),
     imageGenerate: wrapToolExecution(
       "imageGenerate",
-      createImageGenerateTool(hooks),
+      createImageGenerateTool(hooks, hooks.toolOverrides?.imageGenerate),
       hooks
     ),
     slackCanvasUpdate: wrapToolExecution(
@@ -5540,14 +5579,14 @@ function createSandboxExecutor(options) {
                   } : {}
                 });
                 if (!snapshot.snapshotId) {
-                  await emitSandboxStatus("Starting sandbox...");
+                  await emitSandboxStatus("Booting up...");
                   return await Sandbox.create({
                     timeout: timeoutMs,
                     runtime
                   });
                 }
                 try {
-                  await emitSandboxStatus("Starting sandbox from snapshot...");
+                  await emitSandboxStatus("Booting up...");
                   return await Sandbox.create({
                     timeout: timeoutMs,
                     source: {
@@ -5573,7 +5612,7 @@ function createSandboxExecutor(options) {
                     throw error;
                   }
                   await emitSandboxStatus(
-                    "Retrying sandbox startup with a fresh snapshot..."
+                    "Booting up..."
                   );
                   return await Sandbox.create({
                     timeout: timeoutMs,
@@ -6185,9 +6224,9 @@ function formatToolStatus(toolName) {
   const known = {
     loadSkill: "Loading skill instructions",
     systemTime: "Reading current system time",
-    bash: "Running shell command in sandbox",
-    readFile: "Reading file in sandbox",
-    writeFile: "Writing file in sandbox",
+    bash: "Working in the shell",
+    readFile: "Reading a file",
+    writeFile: "Updating a file",
     webSearch: "Searching public sources",
     webFetch: "Reading source pages",
     slackChannelPostMessage: "Posting message to channel",
@@ -6208,16 +6247,23 @@ function formatToolStatus(toolName) {
 }
 function formatToolStatusWithInput(toolName, input) {
   const obj = input && typeof input === "object" ? input : void 0;
+  const command = obj ? compactStatusText(obj.command, 70) : void 0;
   const path6 = obj ? compactStatusPath(obj.path) : void 0;
   const filename = obj ? compactStatusFilename(obj.path) : void 0;
   const query = obj ? compactStatusText(obj.query, 70) : void 0;
   const domain = obj ? extractStatusUrlDomain(obj.url) : void 0;
   const skillName = obj ? compactStatusText(obj.skill_name ?? obj.skillName, 40) : void 0;
+  if (command && toolName === "bash") {
+    return `Running ${command}`;
+  }
   if (filename && toolName === "readFile") {
     return `Reading file ${filename}`;
   }
+  if (filename && toolName === "writeFile") {
+    return `Updating file ${filename}`;
+  }
   if (path6 && toolName === "writeFile") {
-    return `Writing file ${path6}`;
+    return `Updating file ${path6}`;
   }
   if (skillName && toolName === "loadSkill") {
     return `Loading skill ${skillName}`;
@@ -6234,7 +6280,7 @@ function formatToolResultStatus(toolName) {
   const known = {
     loadSkill: "Integrating loaded skill guidance",
     systemTime: "Applying current time context",
-    bash: "Analyzing command output",
+    bash: "Reviewing command results",
     readFile: "Analyzing file contents",
     writeFile: "Saving file update",
     webSearch: "Reviewing search results",
@@ -6257,16 +6303,23 @@ function formatToolResultStatus(toolName) {
 }
 function formatToolResultStatusWithInput(toolName, input) {
   const obj = input && typeof input === "object" ? input : void 0;
+  const command = obj ? compactStatusText(obj.command, 70) : void 0;
   const path6 = obj ? compactStatusPath(obj.path) : void 0;
   const filename = obj ? compactStatusFilename(obj.path) : void 0;
   const query = obj ? compactStatusText(obj.query, 70) : void 0;
   const domain = obj ? extractStatusUrlDomain(obj.url) : void 0;
   const skillName = obj ? compactStatusText(obj.skill_name ?? obj.skillName, 40) : void 0;
+  if (command && toolName === "bash") {
+    return `Reviewed results from ${command}`;
+  }
   if (filename && toolName === "readFile") {
     return `Reviewed file ${filename}`;
   }
+  if (filename && toolName === "writeFile") {
+    return `Updated file ${filename}`;
+  }
   if (path6 && toolName === "writeFile") {
-    return `Saved file ${path6}`;
+    return `Updated file ${path6}`;
   }
   if (skillName && toolName === "loadSkill") {
     return `Loaded skill ${skillName}`;
@@ -6766,6 +6819,7 @@ async function generateAssistantReply(messageText, context = {}) {
       };
     }
     const generatedFiles = [];
+    const replyFiles = [];
     const artifactStatePatch = {};
     const toolCalls = [];
     setTags({
@@ -6782,9 +6836,13 @@ async function generateAssistantReply(messageText, context = {}) {
     const tools = createTools(
       availableSkills,
       {
-        onGeneratedFiles: (files) => {
+        getGeneratedFile: (filename) => generatedFiles.find((file) => file.filename === filename),
+        onGeneratedArtifactFiles: (files) => {
           generatedFiles.push(...files);
         },
+        onGeneratedFiles: (files) => {
+          replyFiles.push(...files);
+        },
         onArtifactStatePatch: (patch) => {
           Object.assign(artifactStatePatch, patch);
         },
@@ -6798,6 +6856,7 @@ async function generateAssistantReply(messageText, context = {}) {
             `${formatToolResultStatusWithInput(toolName, input)}...`
           );
         },
+        toolOverrides: context.toolOverrides,
         onSkillLoaded: async (loadedSkill) => {
           const resolvedSkill = await skillSandbox.loadSkill(loadedSkill.name);
           const effective = resolvedSkill ?? loadedSkill;
@@ -6890,9 +6949,7 @@ async function generateAssistantReply(messageText, context = {}) {
           {
             onToolCall: (toolName) => {
               toolCalls.push(toolName);
-            },
-            onGeneratedFiles: (files) => generatedFiles.push(...files),
-            onArtifactStatePatch: (patch) => Object.assign(artifactStatePatch, patch)
+            }
           }
         )
       }
@@ -7044,7 +7101,7 @@ async function generateAssistantReply(messageText, context = {}) {
       explicitChannelPostIntent,
       channelPostPerformed,
       reactionPerformed,
-      hasFiles: generatedFiles.length > 0,
+      hasFiles: replyFiles.length > 0,
       streamingThreadReply: Boolean(context.onTextDelta)
     });
     const deliveryMode = deliveryPlan.mode;
@@ -7075,7 +7132,7 @@ async function generateAssistantReply(messageText, context = {}) {
     const outcome = primaryText ? stopReason === "error" ? "provider_error" : "success" : "execution_failure";
     const candidateText = primaryText || buildExecutionFailureMessage(toolErrorCount);
     const escapedOrRawPayload = isExecutionEscapeResponse(candidateText) || isRawToolPayloadResponse(candidateText);
-    const resolvedText = escapedOrRawPayload ? buildExecutionFailureMessage(toolErrorCount) : enforceAttachmentClaimTruth(candidateText, generatedFiles.length > 0);
+    const resolvedText = escapedOrRawPayload ? buildExecutionFailureMessage(toolErrorCount) : enforceAttachmentClaimTruth(candidateText, replyFiles.length > 0);
     const resolvedOutcome = escapedOrRawPayload ? "execution_failure" : outcome;
     if (shouldTrace) {
       logInfo(
@@ -7095,7 +7152,7 @@ async function generateAssistantReply(messageText, context = {}) {
     if (escapedOrRawPayload) {
       return {
         text: resolvedText,
-        files: generatedFiles.length > 0 ? generatedFiles : void 0,
+        files: replyFiles.length > 0 ? replyFiles : void 0,
         artifactStatePatch: Object.keys(artifactStatePatch).length > 0 ? artifactStatePatch : void 0,
         deliveryPlan,
         deliveryMode,
@@ -7118,7 +7175,7 @@ async function generateAssistantReply(messageText, context = {}) {
     }
     return {
       text: resolvedText,
-      files: generatedFiles.length > 0 ? generatedFiles : void 0,
+      files: replyFiles.length > 0 ? replyFiles : void 0,
       artifactStatePatch: Object.keys(artifactStatePatch).length > 0 ? artifactStatePatch : void 0,
       deliveryPlan,
       deliveryMode,
@@ -7408,7 +7465,7 @@ function resolveSlackChannelIdFromMessage(message) {
 }
 
 // src/chat/runtime/thread-context.ts
-function escapeRegExp(value) {
+function escapeRegExp2(value) {
   return value.replace(/[.*+?^${}()|[\]\\]/g, "\\$&");
 }
 function stripLeadingBotMention(text, options = {}) {
@@ -7417,10 +7474,10 @@ function stripLeadingBotMention(text, options = {}) {
   if (options.stripLeadingSlackMentionToken) {
     next = next.replace(/^\s*<@[^>]+>[\s,:-]*/, "").trim();
   }
-  const mentionByNameRe = new RegExp(`^\\s*@${escapeRegExp(botConfig.userName)}\\b[\\s,:-]*`, "i");
+  const mentionByNameRe = new RegExp(`^\\s*@${escapeRegExp2(botConfig.userName)}\\b[\\s,:-]*`, "i");
   next = next.replace(mentionByNameRe, "").trim();
   const mentionByLabeledEntityRe = new RegExp(
-    `^\\s*<@[^>|]+\\|${escapeRegExp(botConfig.userName)}>[\\s,:-]*`,
+    `^\\s*<@[^>|]+\\|${escapeRegExp2(botConfig.userName)}>[\\s,:-]*`,
     "i"
   );
   next = next.replace(mentionByLabeledEntityRe, "").trim();
@@ -7595,6 +7652,27 @@ function determineThreadMessageKind(args) {
   }
   return void 0;
 }
+function getMessageLogContext(args) {
+  return {
+    slackThreadId: args.normalizedThreadId,
+    slackChannelId: nonEmptyString(args.message.raw?.channel),
+    slackUserId: args.message.author?.userId
+  };
+}
+function logIgnoredIngressResult(args) {
+  args.deps.logInfo(
+    args.eventName,
+    args.logContext,
+    {
+      ...args.messageId ? { "messaging.message.id": args.messageId } : {},
+      ...args.kind ? { "app.queue.message_kind": args.kind } : {},
+      ...args.dedupKey ? { "app.queue.dedup_key": args.dedupKey } : {},
+      ...args.decisionReason ? { "app.decision.reason": args.decisionReason } : {},
+      "app.queue.route_result": args.routeResult
+    },
+    args.body
+  );
+}
 var defaultQueueRoutingDeps = {
   hasDedup: (key) => hasQueueIngressDedup(key),
   markDedup: (key, ttlMs) => claimQueueIngressDedup(key, ttlMs),
@@ -7604,7 +7682,11 @@ var defaultQueueRoutingDeps = {
   enqueueThreadMessage: async (payload, dedupKey) => await enqueueThreadMessage(payload, {
     idempotencyKey: dedupKey
   }),
-  shouldReplyInSubscribedThread: async ({ message, normalizedThreadId, thread }) => {
+  shouldReplyInSubscribedThread: async ({
+    message,
+    normalizedThreadId,
+    thread
+  }) => {
     const rawText = message.text;
     const text = stripLeadingBotMention(rawText, {
       stripLeadingSlackMentionToken: Boolean(message.isMention)
@@ -7649,25 +7731,56 @@ async function routeIncomingMessageToQueue(args) {
   if (!message || typeof message !== "object") {
     return "ignored_non_object";
   }
-  const normalizedThreadId = normalizeIncomingSlackThreadId(args.threadId, message);
+  const normalizedThreadId = normalizeIncomingSlackThreadId(
+    args.threadId,
+    message
+  );
+  const baseLogContext = getMessageLogContext({
+    message,
+    normalizedThreadId
+  });
   if ("threadId" in message) {
     message.threadId = normalizedThreadId;
   }
   const typedMessage = message;
   if (typedMessage.author?.isMe) {
+    logIgnoredIngressResult({
+      deps,
+      eventName: "queue_ingress_ignored_self_message",
+      logContext: baseLogContext,
+      messageId: nonEmptyString(typedMessage.id),
+      routeResult: "ignored_self_message",
+      body: "Ignoring self-authored message before queue routing"
+    });
     return "ignored_self_message";
   }
   const messageId = nonEmptyString(typedMessage.id);
   if (!messageId) {
+    logIgnoredIngressResult({
+      deps,
+      eventName: "queue_ingress_ignored_missing_message_id",
+      logContext: baseLogContext,
+      routeResult: "ignored_missing_message_id",
+      body: "Ignoring message without an id before queue routing"
+    });
     return "ignored_missing_message_id";
   }
   const isSubscribed = await deps.getIsSubscribed(normalizedThreadId);
-  const isMention = Boolean(typedMessage.isMention || runtime.detectMention?.(adapter, message));
+  const mentionSource = typedMessage.isMention ? "sdk_flag" : runtime.detectMention?.(adapter, message) ? "fallback_detector" : void 0;
+  const isMention = mentionSource !== void 0;
   const kind = determineThreadMessageKind({
     isSubscribed,
     isMention
   });
   if (!kind) {
+    logIgnoredIngressResult({
+      deps,
+      eventName: "queue_ingress_ignored_unsubscribed_non_mention",
+      logContext: baseLogContext,
+      messageId,
+      routeResult: "ignored_unsubscribed_non_mention",
+      body: "Ignoring unsubscribed non-mention message before queue routing"
+    });
     return "ignored_unsubscribed_non_mention";
   }
   const dedupKey = buildQueueIngressDedupKey(normalizedThreadId, messageId);
@@ -7675,21 +7788,25 @@ async function routeIncomingMessageToQueue(args) {
   if (alreadyDeduped) {
     deps.logInfo(
       "queue_ingress_dedup_hit",
-      {
-        slackThreadId: normalizedThreadId,
-        slackUserId: message.author.userId
-      },
+      baseLogContext,
       {
         "messaging.message.id": messageId,
         "app.queue.message_kind": kind,
         "app.queue.dedup_key": dedupKey,
-        "app.queue.dedup_outcome": "duplicate"
+        "app.queue.dedup_outcome": "duplicate",
+        ...mentionSource ? { "app.slack.mention_source": mentionSource } : {},
+        "app.queue.route_result": "ignored_duplicate"
       },
       "Skipping duplicate incoming message before queue enqueue"
     );
     return "ignored_duplicate";
   }
-  const thread = await runtime.createThread(adapter, normalizedThreadId, message, isSubscribed);
+  const thread = await runtime.createThread(
+    adapter,
+    normalizedThreadId,
+    message,
+    isSubscribed
+  );
   const serializedMessage = serializeMessageForQueue(message);
   const serializedThread = serializeThreadForQueue(thread);
   let payloadKind = kind;
@@ -7700,6 +7817,17 @@ async function routeIncomingMessageToQueue(args) {
       thread
     });
     if (!decision.shouldReply) {
+      logIgnoredIngressResult({
+        deps,
+        eventName: "queue_ingress_ignored_passive_no_reply",
+        logContext: baseLogContext,
+        messageId,
+        dedupKey,
+        kind,
+        routeResult: "ignored_passive_no_reply",
+        decisionReason: decision.reason,
+        body: "Skipping passive subscribed-thread reply before queue enqueue"
+      });
       return "ignored_passive_no_reply";
     }
     payloadKind = "subscribed_reply";
@@ -7734,6 +7862,7 @@ async function routeIncomingMessageToQueue(args) {
           {
             "messaging.message.id": messageId,
             "app.queue.message_kind": payloadKind,
+            ...mentionSource ? { "app.slack.mention_source": mentionSource } : {},
             "error.message": errorMessage
           },
           "Failed to add ingress processing reaction"
@@ -7790,8 +7919,10 @@ async function routeIncomingMessageToQueue(args) {
         {
           "messaging.message.id": messageId,
           "app.queue.message_kind": payloadKind,
+          ...mentionSource ? { "app.slack.mention_source": mentionSource } : {},
           "app.queue.dedup_key": dedupKey,
           "app.queue.dedup_outcome": "primary",
+          "app.queue.route_result": "routed",
           ...queueMessageId ? { "app.queue.message_id": queueMessageId } : {}
         },
         "Routing incoming message to queue"
@@ -7841,14 +7972,20 @@ function installChatBackgroundPatch() {
           }
         });
         if (result === "ignored_missing_message_id") {
-          const normalizedThreadId = normalizeIncomingSlackThreadId(threadId, message);
+          const normalizedThreadId = normalizeIncomingSlackThreadId(
+            threadId,
+            message
+          );
           this.logger?.error?.("Message processing error", {
             threadId: normalizedThreadId,
             reason: "missing_message_id"
           });
         }
       } catch (err) {
-        this.logger?.error?.("Message processing error", { error: err, threadId });
+        this.logger?.error?.("Message processing error", {
+          error: err,
+          threadId
+        });
       }
     };
     scheduleBackgroundWork(options, run);
@@ -7885,7 +8022,12 @@ function installChatBackgroundPatch() {
     const run = async () => {
       try {
         const { relatedThread, relatedMessage, relatedChannel } = await this.retrieveModalContext(event.adapter.name, contextId);
-        const fullEvent = { ...event, relatedThread, relatedMessage, relatedChannel };
+        const fullEvent = {
+          ...event,
+          relatedThread,
+          relatedMessage,
+          relatedChannel
+        };
         for (const { callbackIds, handler } of this.modalCloseHandlers) {
           if (callbackIds.length === 0 || callbackIds.includes(event.callbackId)) {
             await handler(fullEvent);
@@ -8019,18 +8161,13 @@ function createAppSlackRuntime(deps) {
           requesterUserName: message.author.userName,
           runId
         });
-        await deps.withSpan(
-          "chat.turn",
-          "chat.turn",
-          context,
-          async () => {
-            await thread.subscribe();
-            await deps.replyToThread(thread, message, {
-              explicitMention: true,
-              beforeFirstResponsePost: hooks?.beforeFirstResponsePost
-            });
-          }
-        );
+        await deps.withSpan("chat.turn", "chat.turn", context, async () => {
+          await thread.subscribe();
+          await deps.replyToThread(thread, message, {
+            explicitMention: true,
+            beforeFirstResponsePost: hooks?.beforeFirstResponsePost
+          });
+        });
       } catch (error) {
         const errorContext = logContext({
           threadId: deps.getThreadId(thread, message),
@@ -8083,6 +8220,45 @@ function createAppSlackRuntime(deps) {
           channelId,
           runId
         };
+        const preflightDecision = hooks?.preApprovedReply ? void 0 : getSubscribedReplyPreflightDecision({
+          botUserName: deps.assistantUserName,
+          rawText: rawUserText,
+          text: userText,
+          isExplicitMention: Boolean(message.isMention)
+        });
+        if (preflightDecision && !preflightDecision.shouldReply) {
+          const completedAtMs = deps.now();
+          const reason = preflightDecision.reasonDetail ? `${preflightDecision.reason}:${preflightDecision.reasonDetail}` : preflightDecision.reason;
+          deps.logWarn(
+            "subscribed_message_reply_skipped",
+            logContext({
+              threadId,
+              requesterId: message.author.userId,
+              requesterUserName: message.author.userName,
+              channelId,
+              runId
+            }),
+            {
+              "app.decision.reason": reason
+            },
+            "Skipping subscribed message reply"
+          );
+          await deps.onSubscribedMessageSkipped({
+            thread,
+            message,
+            decision: { shouldReply: false, reason },
+            completedAtMs,
+            preparedState: void 0
+          });
+          await deps.recordSkippedSubscribedMessage({
+            thread,
+            message,
+            decision: { shouldReply: false, reason },
+            completedAtMs,
+            userText
+          });
+          return;
+        }
         const preparedState = await deps.prepareTurnState({
           thread,
           message,
@@ -9647,7 +9823,7 @@ function resolveReplyDelivery(args) {
     postThreadText: (args.reply.deliveryMode ?? "thread") !== "channel_only",
     attachFiles: replyHasFiles ? args.hasStreamedThreadReply ? "followup" : "inline" : "none"
   };
-  let attachFiles = deliveryPlan.attachFiles;
+  let attachFiles = replyHasFiles ? deliveryPlan.attachFiles : "none";
   if (attachFiles === "followup" && !args.hasStreamedThreadReply) {
     attachFiles = "inline";
   }
@@ -10230,11 +10406,58 @@ var appSlackRuntime = createAppSlackRuntime({
   },
   getPreparedConversationContext: (preparedState) => preparedState.routingContext ?? preparedState.conversationContext,
   shouldReplyInSubscribedThread,
-  onSubscribedMessageSkipped: async ({ thread, preparedState, decision, completedAtMs }) => {
-    markConversationMessage(preparedState.conversation, preparedState.userMessageId, {
-      replied: false,
-      skippedReason: decision.reason
+  recordSkippedSubscribedMessage: async ({
+    thread,
+    message,
+    decision,
+    completedAtMs,
+    userText
+  }) => {
+    const conversation = coerceThreadConversationState(await thread.state);
+    const normalizedUserText = normalizeConversationText(userText) || "[non-text message]";
+    upsertConversationMessage(conversation, {
+      id: message.id,
+      role: "user",
+      text: normalizedUserText,
+      createdAtMs: message.metadata.dateSent.getTime(),
+      author: {
+        userId: message.author.userId,
+        userName: message.author.userName,
+        fullName: message.author.fullName,
+        isBot: typeof message.author.isBot === "boolean" ? message.author.isBot : void 0
+      },
+      meta: {
+        explicitMention: Boolean(message.isMention),
+        slackTs: message.id,
+        replied: false,
+        skippedReason: decision.reason,
+        imagesHydrated: true
+      }
+    });
+    conversation.processing.activeTurnId = void 0;
+    conversation.processing.lastCompletedAtMs = completedAtMs;
+    updateConversationStats(conversation);
+    await persistThreadState(thread, {
+      conversation
     });
+  },
+  onSubscribedMessageSkipped: async ({
+    thread,
+    preparedState,
+    decision,
+    completedAtMs
+  }) => {
+    if (!preparedState) {
+      return;
+    }
+    markConversationMessage(
+      preparedState.conversation,
+      preparedState.userMessageId,
+      {
+        replied: false,
+        skippedReason: decision.reason
+      }
+    );
     preparedState.conversation.processing.activeTurnId = void 0;
     preparedState.conversation.processing.lastCompletedAtMs = completedAtMs;
     updateConversationStats(preparedState.conversation);
@@ -10243,7 +10466,12 @@ var appSlackRuntime = createAppSlackRuntime({
     });
   },
   replyToThread,
-  initializeAssistantThread: async ({ threadId, channelId, threadTs, sourceChannelId }) => {
+  initializeAssistantThread: async ({
+    threadId,
+    channelId,
+    threadTs,
+    sourceChannelId
+  }) => {
     await initializeAssistantThread({
       threadId,
       channelId,